refactor: made generic cache async

Author: danpoletaev

packages/actor-memory-expression/src/memory_calculator.ts

@@ -178,16 +178,16 @@ const processTemplateVariables = (defaultMemoryMbytes: string): string => {
 * @param cache An optional cache to store/retrieve compiled expressions.
 * @returns The compiled EvalFunction.
 */
-const getCompiledExpression = (expression: string, cache: CompilationCache | undefined): EvalFunction => {
+const getCompiledExpression = async (expression: string, cache: CompilationCache | undefined): Promise<EvalFunction> => {
     if (!cache) {
         return compile(expression);
     }
 
-    let compiledExpression = cache.get(expression);
+    let compiledExpression = await cache.get(expression);
 
     if (!compiledExpression) {
         compiledExpression = compile(expression);
-        cache.set(expression, compiledExpression!);
+        await cache.set(expression, compiledExpression!);
     }
 
     return compiledExpression;
@@ -202,7 +202,7 @@ const getCompiledExpression = (expression: string, cache: CompilationCache | und
  * @param options.cache Optional synchronous cache. Since compiled functions cannot be saved to a database/Redis, they are kept in local memory.
  * @returns The calculated memory value rounded to the closest power of 2 and clamped within allowed limits.
 */
-export const calculateRunDynamicMemory = (
+export const calculateRunDynamicMemory = async (
     defaultMemoryMbytes: string,
     context: MemoryEvaluationContext,
     options: { cache: CompilationCache } | undefined = undefined,
@@ -220,7 +220,7 @@ export const calculateRunDynamicMemory = (
         get: customGetFunc,
     };
 
-    const compiledExpression = getCompiledExpression(preprocessedExpression, options?.cache);
+    const compiledExpression = await getCompiledExpression(preprocessedExpression, options?.cache);
 
     let finalResult: number | { entries: number[] } = compiledExpression.evaluate(preparedContext);
 

packages/actor-memory-expression/src/types.ts

@@ -16,7 +16,7 @@ export type MemoryEvaluationContext = {
 }
 
 export type CompilationCache = {
-    get: (expression: string) => EvalFunction | null;
-    set: (expression: string, compilationResult: EvalFunction) => void;
-    length: () => number;
+    get: (expression: string) => Promise<EvalFunction | null>;
+    set: (expression: string, compilationResult: EvalFunction) => Promise<void>;
+    length: () => Promise<number>;
 }

test/memory_calculator.test.ts

@@ -8,49 +8,49 @@ describe('calculateDefaultMemoryFromExpression', () => {
     const emptyContext = { input: {}, runOptions: {} };
 
     describe('Basic evaluation', () => {
-        it('correctly calculates and rounds memory from one-line expression', () => {
+        it('correctly calculates and rounds memory from one-line expression', async () => {
             const context = { input: { size: 10 }, runOptions: {} };
             // 10 * 1024 = 10240. log2(10240) ~ 13.32. round(13.32) -> 2^13 = 8192
-            const result = calculateRunDynamicMemory('input.size * 1024', context);
+            const result = await calculateRunDynamicMemory('input.size * 1024', context);
             expect(result).toBe(8192);
         });
 
-        it('correctly calculates and rounds memory from multi-line expression', () => {
+        it('correctly calculates and rounds memory from multi-line expression', async () => {
             const context = { input: { base: 10, multiplier: 1024 }, runOptions: {} };
             const expr = `
                 baseVal = input.base;
                 multVal = input.multiplier;
                 baseVal * multVal
             `;
             // 10 * 1024 = 10240. Rounds to 8192.
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(8192);
         });
 
-        it('correctly accesses runOptions from the context', () => {
+        it('correctly accesses runOptions from the context', async () => {
             const context = { input: {}, runOptions: { timeoutSecs: 60 } };
             const expr = 'runOptions.timeoutSecs * 100'; // 60 * 100 = 6000
             // log2(6000) ~ 12.55. round(13) -> 2^13 = 8192
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(8192);
         });
 
-        it('correctly handles a single number expression', () => {
-            const result = calculateRunDynamicMemory('2048', emptyContext);
+        it('correctly handles a single number expression', async () => {
+            const result = await calculateRunDynamicMemory('2048', emptyContext);
             expect(result).toBe(2048);
         });
 
-        it('correctly handles expressions with custom get() function', () => {
+        it('correctly handles expressions with custom get() function', async () => {
             const context = { input: { nested: { value: 20 } }, runOptions: {} };
             const expr = "get(input, 'nested.value', 10) * 50"; // 20 * 50 = 1000
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(1024);
         });
 
-        it('should use get() default value when path is invalid', () => {
+        it('should use get() default value when path is invalid', async () => {
             const context = { input: { user: {} }, runOptions: {} };
             const expr = "get(input, 'user.settings.memory', 512)";
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(512);
         });
 
@@ -78,10 +78,10 @@ describe('calculateDefaultMemoryFromExpression', () => {
 
             it.each(cases)(
                 `supports operation '$name'`,
-                ({ expression, result }) => {
+                async ({ expression, result }) => {
                     // in case operation is not supported, mathjs will throw
                     // we round the result to the closest power of 2 and clamp within limits.
-                    expect(calculateRunDynamicMemory(expression, context)).toBe(result);
+                    expect(await calculateRunDynamicMemory(expression, context)).toBe(result);
                 },
             );
         });
@@ -108,100 +108,100 @@ describe('calculateDefaultMemoryFromExpression', () => {
 
             it.each(cases)(
                 `supports operation '$name'`,
-                ({ expression, error }) => {
+                async ({ expression, error }) => {
                     // in case operation is not supported, mathjs will throw
                     // we round the result to the closest power of 2 and clamp within limits.
-                    expect(() => calculateRunDynamicMemory(expression, context)).toThrow(error);
+                    await expect(calculateRunDynamicMemory(expression, context)).rejects.toThrow(error);
                 },
             );
         });
     });
 
     describe('Template {{variables}} support', () => {
-        it('should throw error if variable doesn\'t start with runOptions. or input.', () => {
+        it('should throw error if variable doesn\'t start with runOptions. or input.', async () => {
             const context = { input: {}, runOptions: { memoryMbytes: 16 } };
             const expr = '{{nonexistentVariable}} * 1024';
-            expect(() => calculateRunDynamicMemory(expr, context))
-                .toThrow(`Invalid variable '{{nonexistentVariable}}' in expression.`);
+            await expect(calculateRunDynamicMemory(expr, context))
+                .rejects.toThrow(`Invalid variable '{{nonexistentVariable}}' in expression.`);
         });
 
-        it('correctly evaluates valid runOptions property', () => {
+        it('correctly evaluates valid runOptions property', async () => {
             const context = { input: {}, runOptions: { memoryMbytes: 16 } };
             const expr = '{{runOptions.memoryMbytes}} * 1024';
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(16384);
         });
 
-        it('correctly evaluates input property', () => {
+        it('correctly evaluates input property', async () => {
             const context = { input: { value: 16 }, runOptions: { } };
             const expr = '{{input.value}} * 1024';
-            const result = calculateRunDynamicMemory(expr, context);
+            const result = await calculateRunDynamicMemory(expr, context);
             expect(result).toBe(16384);
         });
 
-        it('should throw error if runOptions property is not supported', () => {
+        it('should throw error if runOptions property is not supported', async () => {
             const context = { input: { value: 16 }, runOptions: { } };
             const expr = '{{runOptions.customVariable}} * 1024';
-            expect(() => calculateRunDynamicMemory(expr, context))
-                .toThrow(`Invalid variable '{{runOptions.customVariable}}' in expression. Only the following runOptions are allowed:`);
+            await expect(calculateRunDynamicMemory(expr, context))
+                .rejects.toThrow(`Invalid variable '{{runOptions.customVariable}}' in expression. Only the following runOptions are allowed:`);
         });
     });
 
     describe('Rounding logic', () => {
-        it('should round down (e.g., 10240 -> 8192)', () => {
+        it('should round down (e.g., 10240 -> 8192)', async () => {
             // 2^13 = 8192, 2^14 = 16384.
-            const result = calculateRunDynamicMemory('10240', emptyContext);
+            const result = await calculateRunDynamicMemory('10240', emptyContext);
             expect(result).toBe(8192);
         });
 
-        it('should round up (e.g., 13000 -> 16384)', () => {
+        it('should round up (e.g., 13000 -> 16384)', async () => {
             // 13000 is closer to 16384 than 8192.
-            const result = calculateRunDynamicMemory('13000', emptyContext);
+            const result = await calculateRunDynamicMemory('13000', emptyContext);
             expect(result).toBe(16384);
         });
 
-        it('should clamp to the minimum memory limit if the result is too low', () => {
-            const result = calculateRunDynamicMemory('64', emptyContext);
+        it('should clamp to the minimum memory limit if the result is too low', async () => {
+            const result = await calculateRunDynamicMemory('64', emptyContext);
             expect(result).toBe(128);
         });
 
-        it('should clamp to the maximum memory limit if the result is too high', () => {
-            const result = calculateRunDynamicMemory('100000', emptyContext);
+        it('should clamp to the maximum memory limit if the result is too high', async () => {
+            const result = await calculateRunDynamicMemory('100000', emptyContext);
             expect(result).toBe(32768);
         });
     });
 
     describe('Invalid/error handling', () => {
-        it('should throw an error if expression length is greater than DEFAULT_MEMORY_MBYTES_MAX_CHARS', () => {
+        it('should throw an error if expression length is greater than DEFAULT_MEMORY_MBYTES_MAX_CHARS', async () => {
             const expr = '1'.repeat(DEFAULT_MEMORY_MBYTES_EXPRESSION_MAX_LENGTH + 1);
-            expect(() => calculateRunDynamicMemory(expr, emptyContext))
-                .toThrow(`The defaultMemoryMbytes expression is too long. Max length is ${DEFAULT_MEMORY_MBYTES_EXPRESSION_MAX_LENGTH} characters.`);
+            await expect(calculateRunDynamicMemory(expr, emptyContext))
+                .rejects.toThrow(`The defaultMemoryMbytes expression is too long. Max length is ${DEFAULT_MEMORY_MBYTES_EXPRESSION_MAX_LENGTH} characters.`);
         });
 
-        it('should throw an error for invalid syntax', () => {
+        it('should throw an error for invalid syntax', async () => {
             const expr = '1 +* 2';
-            expect(() => calculateRunDynamicMemory(expr, emptyContext))
-                .toThrow();
+            await expect(calculateRunDynamicMemory(expr, emptyContext))
+                .rejects.toThrow();
         });
 
-        it('should throw error if result is 0', () => {
-            expect(() => calculateRunDynamicMemory('10 - 10', emptyContext)).toThrow(`Calculated memory value must be a positive number, greater than 0, got: 0.`);
+        it('should throw error if result is 0', async () => {
+            await expect(calculateRunDynamicMemory('10 - 10', emptyContext)).rejects.toThrow(`Calculated memory value must be a positive number, greater than 0, got: 0.`);
         });
 
-        it('should throw error if result is negative', () => {
-            expect(() => calculateRunDynamicMemory('5 - 10', emptyContext)).toThrow(`Calculated memory value must be a positive number, greater than 0, got: -5.`);
+        it('should throw error if result is negative', async () => {
+            await expect(calculateRunDynamicMemory('5 - 10', emptyContext)).rejects.toThrow(`Calculated memory value must be a positive number, greater than 0, got: -5.`);
         });
 
-        it('should throw error if result is NaN', () => {
-            expect(() => calculateRunDynamicMemory('0 / 0', emptyContext)).toThrow('Calculated memory value is not a valid number: NaN.');
+        it('should throw error if result is NaN', async () => {
+            await expect(calculateRunDynamicMemory('0 / 0', emptyContext)).rejects.toThrow('Calculated memory value is not a valid number: NaN.');
         });
 
-        it('should throw error if result is a non-numeric (string)', () => {
-            expect(() => calculateRunDynamicMemory("'hello'", emptyContext)).toThrow('Calculated memory value is not a valid number: hello.');
+        it('should throw error if result is a non-numeric (string)', async () => {
+            await expect(calculateRunDynamicMemory("'hello'", emptyContext)).rejects.toThrow('Calculated memory value is not a valid number: hello.');
         });
 
-        it('should throw error when disabled functionality of MathJS is used', () => {
-            expect(() => calculateRunDynamicMemory('evaluate(512)', emptyContext)).toThrow('Function evaluate is disabled.');
+        it('should throw error when disabled functionality of MathJS is used', async () => {
+            await expect(calculateRunDynamicMemory('evaluate(512)', emptyContext)).rejects.toThrow('Function evaluate is disabled.');
         });
     });
 
@@ -213,31 +213,31 @@ describe('calculateDefaultMemoryFromExpression', () => {
         beforeEach(() => {
             const lruCache = new LruCache<EvalFunction>({ maxLength: 10 });
             cache = {
-                get: (expression: string) => lruCache.get(expression),
-                set: (expression: string, compilationResult: EvalFunction) => lruCache.add(expression, compilationResult),
-                length: () => lruCache.length(),
+                get: async (expression: string) => lruCache.get(expression),
+                set: async (expression: string, compilationResult: EvalFunction) => { lruCache.add(expression, compilationResult); },
+                length: async () => lruCache.length(),
             };
         });
 
-        it('correctly works with cache passed in options', () => {
-            expect(cache.length()).toBe(0);
+        it('correctly works with cache passed in options', async () => {
+            expect(await cache.length()).toBe(0);
 
             // First call - cache miss
-            const result1 = calculateRunDynamicMemory(expr, context, { cache });
+            const result1 = await calculateRunDynamicMemory(expr, context, { cache });
             expect(result1).toBe(8192);
-            expect(cache.length()).toBe(1); // Expression is now cached
+            expect(await cache.length()).toBe(1); // Expression is now cached
 
             // Second call - cache hit
-            const result2 = calculateRunDynamicMemory(expr, context, { cache });
+            const result2 = await calculateRunDynamicMemory(expr, context, { cache });
             expect(result2).toBe(8192);
-            expect(cache.length()).toBe(1); // Cache length is unchanged
+            expect(await cache.length()).toBe(1); // Cache length is unchanged
         });
 
-        it('should cache different expressions separately', () => {
+        it('should cache different expressions separately', async () => {
             const expr2 = 'input.size * 2048'; // 10 * 2048 = 20480 -> 16384
-            calculateRunDynamicMemory(expr, context, { cache });
-            calculateRunDynamicMemory(expr2, context, { cache });
-            expect(cache.length()).toBe(2);
+            await calculateRunDynamicMemory(expr, context, { cache });
+            await calculateRunDynamicMemory(expr2, context, { cache });
+            expect(await cache.length()).toBe(2);
         });
     });
 });