refactor: change names of functions

Author: danpoletaev

packages/math-utils/src/memory_calculator.ts

@@ -145,7 +145,7 @@ const roundToClosestPowerOf2 = (num: number): number | undefined => {
  * @param defaultMemoryMbytes The raw string expression, e.g., "{{runOptions.memoryMbytes}} * 2".
  * @returns A safe, processed expression for evaluation, e.g., "runOptions.memoryMbytes * 2".
  */
-const preprocessDefaultMemoryExpression = (defaultMemoryMbytes: string): string => {
+const preprocessRunMemoryExpression = (defaultMemoryMbytes: string): string => {
     const variableRegex = /{{\s*([a-zA-Z0-9_.]+)\s*}}/g;
 
     const processedExpression = defaultMemoryMbytes.replace(
@@ -193,7 +193,7 @@ const preprocessDefaultMemoryExpression = (defaultMemoryMbytes: string): string
  * @param context The `MemoryEvaluationContext` (containing `input` and `runOptions`) available to the expression.
  * @returns The calculated memory value rounded to the closest power of 2 clamped within allowed limits.
 */
-export const calculateDefaultMemoryFromExpression = (
+export const calculateRunDynamicMemory = (
     defaultMemoryMbytes: string,
     context: MemoryEvaluationContext,
     options: { cache: LruCache<EvalFunction> } | undefined = undefined,
@@ -204,7 +204,7 @@ export const calculateDefaultMemoryFromExpression = (
 
     // Replaces all occurrences of {{variable}} with variable
     // e.g., "{{runOptions.memoryMbytes}} + 1024" becomes "runOptions.memoryMbytes + 1024"
-    const preProcessedExpression = preprocessDefaultMemoryExpression(defaultMemoryMbytes);
+    const preprocessedExpression = preprocessRunMemoryExpression(defaultMemoryMbytes);
 
     const preparedContext = {
         ...context,
@@ -214,16 +214,16 @@ export const calculateDefaultMemoryFromExpression = (
     let finalResult: number | { entries: number[] };
 
     if (options?.cache) {
-        let compiledExpr = options.cache.get(preProcessedExpression);
+        let compiledExpr = options.cache.get(preprocessedExpression);
 
         if (!compiledExpr) {
-            compiledExpr = limitedCompile(preProcessedExpression);
-            options.cache.add(preProcessedExpression, compiledExpr!);
+            compiledExpr = limitedCompile(preprocessedExpression);
+            options.cache.add(preprocessedExpression, compiledExpr!);
         }
 
         finalResult = compiledExpr.evaluate(preparedContext);
     } else {
-        finalResult = limitedEvaluate(preProcessedExpression, preparedContext);
+        finalResult = limitedEvaluate(preprocessedExpression, preparedContext);
     }
 
     // Mathjs wraps multi-line expressions in an object, so we need to extract the last entry.

test/memory_calculator.test.ts

@@ -1,7 +1,7 @@
 import type { EvalFunction } from 'mathjs';
 
 import { LruCache } from '@apify/datastructures';
-import { calculateDefaultMemoryFromExpression, DEFAULT_MEMORY_MBYTES_MAX_CHARS } from '@apify/math-utils';
+import { calculateRunDynamicMemory, DEFAULT_MEMORY_MBYTES_MAX_CHARS } from '@apify/math-utils';
 
 describe('calculateDefaultMemoryFromExpression', () => {
     const emptyContext = { input: {}, runOptions: {} };
@@ -10,7 +10,7 @@ describe('calculateDefaultMemoryFromExpression', () => {
         it('correctly calculates and rounds memory from one-line expression', () => {
             const context = { input: { size: 10 }, runOptions: {} };
             // 10 * 1024 = 10240. log2(10240) ~ 13.32. round(13.32) -> 2^13 = 8192
-            const result = calculateDefaultMemoryFromExpression('input.size * 1024', context);
+            const result = calculateRunDynamicMemory('input.size * 1024', context);
             expect(result).toBe(8192);
         });
 
@@ -22,34 +22,34 @@ describe('calculateDefaultMemoryFromExpression', () => {
                 baseVal * multVal
             `;
             // 10 * 1024 = 10240. Rounds to 8192.
-            const result = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(8192);
         });
 
         it('correctly accesses runOptions from the context', () => {
             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 = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(8192);
         });
 
         it('correctly handles a single number expression', () => {
-            const result = calculateDefaultMemoryFromExpression('2048', emptyContext);
+            const result = calculateRunDynamicMemory('2048', emptyContext);
             expect(result).toBe(2048);
         });
 
         it('correctly handles expressions with custom get() function', () => {
             const context = { input: { nested: { value: 20 } }, runOptions: {} };
             const expr = "get(input, 'nested.value', 10) * 50"; // 20 * 50 = 1000
-            const result = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(1024);
         });
 
         it('should use get() default value when path is invalid', () => {
             const context = { input: { user: {} }, runOptions: {} };
             const expr = "get(input, 'user.settings.memory', 512)";
-            const result = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(512);
         });
 
@@ -78,7 +78,7 @@ describe('calculateDefaultMemoryFromExpression', () => {
                 '$desc',
                 ({ expression }) => {
                     // in case operation is not supported, mathjs will throw
-                    expect(calculateDefaultMemoryFromExpression(expression, context)).toBeDefined();
+                    expect(calculateRunDynamicMemory(expression, context)).toBeDefined();
                 },
             );
         });
@@ -88,87 +88,87 @@ describe('calculateDefaultMemoryFromExpression', () => {
         it('should throw error if variable doesn\'t start with .runOptions or .input', () => {
             const context = { input: {}, runOptions: { memoryMbytes: 16 } };
             const expr = '{{unexistingVariable}} * 1024';
-            expect(() => calculateDefaultMemoryFromExpression(expr, context))
+            expect(() => calculateRunDynamicMemory(expr, context))
                 .toThrow(`Invalid variable '{{unexistingVariable}}' in expression. Variables must start with 'input.' or 'runOptions.'.`);
         });
 
         it('correctly replaces {{runOptions.variable}} with valid runOptions.variable', () => {
             const context = { input: {}, runOptions: { memoryMbytes: 16 } };
             const expr = '{{runOptions.memoryMbytes}} * 1024';
-            const result = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(16384);
         });
 
         it('correctly replaces {{input.variable}} with valid input.variable', () => {
             const context = { input: { value: 16 }, runOptions: { } };
             const expr = '{{input.value}} * 1024';
-            const result = calculateDefaultMemoryFromExpression(expr, context);
+            const result = calculateRunDynamicMemory(expr, context);
             expect(result).toBe(16384);
         });
 
         it('should throw error if runOptions variable is invalid', () => {
             const context = { input: { value: 16 }, runOptions: { } };
             const expr = '{{runOptions.customVariable}} * 1024';
-            expect(() => calculateDefaultMemoryFromExpression(expr, context))
+            expect(() => calculateRunDynamicMemory(expr, context))
                 .toThrow(`Invalid variable '{{runOptions.customVariable}}' in expression. Only the following runOptions are allowed:`);
         });
     });
 
     describe('Rounding Logic', () => {
         it('should round down (e.g., 10240 -> 8192)', () => {
             // 2^13 = 8192, 2^14 = 16384.
-            const result = calculateDefaultMemoryFromExpression('10240', emptyContext);
+            const result = calculateRunDynamicMemory('10240', emptyContext);
             expect(result).toBe(8192);
         });
 
         it('should round up (e.g., 13000 -> 16384)', () => {
             // 13000 is closer to 16384 than 8192.
-            const result = calculateDefaultMemoryFromExpression('13000', emptyContext);
+            const result = calculateRunDynamicMemory('13000', emptyContext);
             expect(result).toBe(16384);
         });
 
         it('should clamp to the minimum memory limit if the result is too low', () => {
-            const result = calculateDefaultMemoryFromExpression('64', emptyContext);
+            const result = calculateRunDynamicMemory('64', emptyContext);
             expect(result).toBe(128);
         });
 
         it('should clamp to the maximum memory limit if the result is too high', () => {
-            const result = calculateDefaultMemoryFromExpression('100000', emptyContext);
+            const result = 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', () => {
             const expr = '1'.repeat(DEFAULT_MEMORY_MBYTES_MAX_CHARS + 1); // Assuming max length is 1000
-            expect(() => calculateDefaultMemoryFromExpression(expr, emptyContext))
+            expect(() => calculateRunDynamicMemory(expr, emptyContext))
                 .toThrow(`The defaultMemoryMbytes expression is too long. Max length is ${DEFAULT_MEMORY_MBYTES_MAX_CHARS} characters.`);
         });
 
         it('should throw an error for invalid syntax', () => {
             const expr = '1 +* 2';
-            expect(() => calculateDefaultMemoryFromExpression(expr, emptyContext))
+            expect(() => calculateRunDynamicMemory(expr, emptyContext))
                 .toThrow();
         });
 
         it('should throw error if result is 0', () => {
-            expect(() => calculateDefaultMemoryFromExpression('10 - 10', emptyContext)).toThrow(`Calculated memory value must be a positive number, greater than 0, got: 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 negative', () => {
-            expect(() => calculateDefaultMemoryFromExpression('5 - 10', emptyContext)).toThrow(`Calculated memory value must be a positive number, greater than 0, got: -5`);
+            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 NaN', () => {
-            expect(() => calculateDefaultMemoryFromExpression('0 / 0', emptyContext)).toThrow('Failed to round number to a power of 2.');
+            expect(() => calculateRunDynamicMemory('0 / 0', emptyContext)).toThrow('Failed to round number to a power of 2.');
         });
 
         it('should throw error if result is a non-numeric (string)', () => {
-            expect(() => calculateDefaultMemoryFromExpression("'hello'", emptyContext)).toThrow('Failed to round number to a power of 2.');
+            expect(() => calculateRunDynamicMemory("'hello'", emptyContext)).toThrow('Failed to round number to a power of 2.');
         });
 
         it('should throw error when disabled functionality of MathJS is used', () => {
-            expect(() => calculateDefaultMemoryFromExpression('evaluate(512)', emptyContext)).toThrow('Function evaluate is disabled');
+            expect(() => calculateRunDynamicMemory('evaluate(512)', emptyContext)).toThrow('Function evaluate is disabled');
         });
     });
 
@@ -185,20 +185,20 @@ describe('calculateDefaultMemoryFromExpression', () => {
             expect(cache.length()).toBe(0);
 
             // First call - cache miss
-            const result1 = calculateDefaultMemoryFromExpression(expr, context, { cache });
+            const result1 = calculateRunDynamicMemory(expr, context, { cache });
             expect(result1).toBe(8192);
             expect(cache.length()).toBe(1); // Expression is now cached
 
             // Second call - cache hit
-            const result2 = calculateDefaultMemoryFromExpression(expr, context, { cache });
+            const result2 = calculateRunDynamicMemory(expr, context, { cache });
             expect(result2).toBe(8192);
             expect(cache.length()).toBe(1); // Cache length is unchanged
         });
 
         it('should cache different expressions separately', () => {
             const expr2 = 'input.size * 2048'; // 10 * 2048 = 20480 -> 16384
-            calculateDefaultMemoryFromExpression(expr, context, { cache });
-            calculateDefaultMemoryFromExpression(expr2, context, { cache });
+            calculateRunDynamicMemory(expr, context, { cache });
+            calculateRunDynamicMemory(expr2, context, { cache });
             expect(cache.length()).toBe(2);
         });
     });