fix(withCache) bind this context

Author: men232

packages/core/src/cache/createWithCache/createWithCache.ts

@@ -45,7 +45,7 @@ export function createWithCache<T extends AnyFunction>({
     argToKeyOptions,
   };
 
-  const wrapFn = ((...args: Parameters<T>) => {
+  const wrapFn = function (this: any, ...args: Parameters<T>) {
     const storage = getBucket(getPointer());
     const cacheKey = args.map(v => argToKey(v, argToKeyOptions)).join('_');
 
@@ -54,7 +54,7 @@ export function createWithCache<T extends AnyFunction>({
       return isAsync ? Promise.resolve(value) : value;
     }
 
-    const newValue = fn(...args);
+    const newValue = fn.apply(this, args);
 
     if (isPromise(newValue)) {
       // cache only success result
@@ -67,7 +67,7 @@ export function createWithCache<T extends AnyFunction>({
     storage.set(cacheKey, newValue);
 
     return newValue;
-  }) as T;
+  } as T;
 
   (wrapFn as any).$cache = $cache;
 

packages/core/src/cache/withCache/withCache.test.ts

@@ -8,6 +8,16 @@ describe('withCache', () => {
     expect(rnd()).toBe(rnd());
   });
 
+  test('should keep this context', () => {
+    const fn = withCache(function (this: any) {
+      return this;
+    });
+
+    const context = Symbol();
+
+    expect(fn.call(context)).toBe(context);
+  });
+
   test('object arguments must be handled (strategy: ref)', () => {
     const user = { id: 1, name: 'Andrew L.' };
 

packages/core/src/cache/withCacheBucket/withCacheBucket.test.ts

@@ -10,6 +10,19 @@ describe('withCacheBucket', () => {
     expect(rnd()).toBe(rnd());
   });
 
+  test('should keep this context', () => {
+    const fn = withCacheBucket(
+      { sizeMs: 100, capacity: 1 },
+      function (this: any) {
+        return this;
+      },
+    );
+
+    const context = Symbol();
+
+    expect(fn.call(context)).toBe(context);
+  });
+
   test('check size ms', async () => {
     let called = 0;
 

packages/core/src/cache/withCacheBucketBatch/withCacheBucketBatch.test.ts

@@ -2,6 +2,27 @@ import { describe, expect, it } from 'vitest';
 import { withCacheBucketBatch } from './withCacheBucketBatch';
 
 describe('withCacheBucketBatch', () => {
+  it('should keep this context', async () => {
+    let tracked: any;
+    const fn = withCacheBucketBatch(
+      {
+        key: 'id',
+        sizeMs: 1000,
+        capacity: 10,
+        batchSize: 2,
+      },
+      async function (this: any, values: string[]) {
+        tracked = this;
+        return [];
+      },
+    );
+
+    const context = Symbol();
+    // @ts-expect-error
+    await fn.call(context, [{ _id: 'test' }]);
+    expect(tracked).toBe(context);
+  });
+
   it('should cache objects', async () => {
     const records: Record<string, { id: string; name: string; gen: number }> = {
       '1': { id: '1', name: 'John', gen: 0 },

packages/core/src/cache/withCacheBucketBatch/withCacheBucketBatch.ts

@@ -93,7 +93,7 @@ export function withCacheBucketBatch<T extends object, K extends keyof T>(
     return fnCache;
   };
 
-  const wrapFn = async (values: any) => {
+  const wrapFn = async function (this: any, values: any) {
     const result = new Map();
 
     let fnCache = getBucket();
@@ -103,7 +103,7 @@ export function withCacheBucketBatch<T extends object, K extends keyof T>(
     const drainMaybe = async () => {
       if (!batchSet.size) return;
 
-      const items = await resolver(Array.from(batchSet));
+      const items = await resolver.call(this, Array.from(batchSet));
 
       for (let idx = 0; idx < items.length; idx++) {
         const item = items[idx];

packages/core/src/cache/withCacheFixed/withCacheFixed.test.ts

@@ -8,6 +8,16 @@ describe('withCacheFixed', () => {
     expect(rnd()).toBe(rnd());
   });
 
+  test('should keep this context', () => {
+    const fn = withCacheFixed({ capacity: 1 }, function (this: any) {
+      return this;
+    });
+
+    const context = Symbol();
+
+    expect(fn.call(context)).toBe(context);
+  });
+
   test('check capacity', () => {
     let called = 0;
 

packages/core/src/cache/withCacheLRU/withCacheLRU.test.ts

@@ -8,6 +8,16 @@ describe('withCacheLRU', () => {
     expect(rnd()).toBe(rnd());
   });
 
+  test('should keep this context', () => {
+    const fn = withCacheLRU({ capacity: 1 }, function (this: any) {
+      return this;
+    });
+
+    const context = Symbol();
+
+    expect(fn.call(context)).toBe(context);
+  });
+
   test('check capacity', () => {
     let called = 0;
 

packages/core/src/cache/withDeepClone/withDeepClone.test.ts

@@ -12,4 +12,15 @@ describe('withDeepClone', () => {
 
     expect(user.id).lt(user2.id);
   });
+
+  test('should keep this context', () => {
+    let tracked: any;
+    const fn = withDeepClone(function (this: any) {
+      tracked = this;
+    });
+
+    const context = Symbol();
+    fn.call(context);
+    expect(tracked).toBe(context);
+  });
 });