@entity-access/entity-access 1.0.495 → 1.0.497

package/src/query/parser/ArrowToExpression.ts

@@ -4,14 +4,9 @@ import { BabelVisitor } from "./BabelVisitor.js";
 import * as bpe from "@babel/types";
 import Restructure from "./Restructure.js";
 import { NotSupportedError } from "./NotSupportedError.js";
-import TimedCache from "../../common/cache/TimedCache.js";
 
 type IQueryFragment = string | { name?: string, value?: any };
 
-const parsedCache = new TimedCache<string, bpe.Node>();
-
-const parameterCacheSymbol = Symbol("parameterCacheSymbol");
-
 const defaultObject = {};
 
 export default class ArrowToExpression extends BabelVisitor<Expression> {
@@ -25,10 +20,8 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
      */
     public static transform(fx: (p: any) => (x: any) => any, target?: ParameterExpression, outerParameter?: ParameterExpression) {
         const key = fx.toString();
-        const node = parsedCache.getOrCreate(key, fx, (k, f) => {
-            const rs = new Restructure();
-            return rs.visit(parseExpression(f.toString()));
-        });
+        const rs = new Restructure();
+        const node = rs.visit(parseExpression(key));
         return this.transformUncached(node, target, outerParameter);
     }
 
@@ -40,70 +33,65 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
      * @param target parameter to replace
      * @returns transformed node
      */
-    private static transformUncached(node: bpe.Node, tx?: ParameterExpression, outerParameter?: ParameterExpression): { params: Map<string, any>, body: Expression, target: ParameterExpression } {
+    private static transformUncached(node: bpe.Node, target?: ParameterExpression, outerParameter?: ParameterExpression): { params: ParameterExpression[], body: Expression, target: ParameterExpression } {
 
-        const cache = node[parameterCacheSymbol] ??= new TimedCache<ParameterExpression,bpe.Node>();
-
-        return cache.getOrCreate(tx ?? defaultObject, tx, (_, target) => {
-
-            if (node.type !== "ArrowFunctionExpression") {
-                throw new Error("Expecting an arrow function");
-            }
+        if (node.type !== "ArrowFunctionExpression") {
+            throw new Error("Expecting an arrow function");
+        }
 
-            const paramSet = new Map<string, any>();
+        const paramSet = new Map<string, any>();
 
-            let firstOuterParam = null;
+        let firstOuterParam = null;
 
-            const params = [];
+        const params = [];
 
-            for (const iterator of node.params) {
-                if (iterator.type !== "Identifier") {
-                    throw new Error("Expecting an identifier");
-                }
-                if (!firstOuterParam && outerParameter) {
-                    firstOuterParam = iterator.name;
-                    paramSet.set(iterator.name, outerParameter);
-                    params.push(outerParameter);
-                    continue;
-                }
-                const p1 = ParameterExpression.create({ name: iterator.name });
-                paramSet.set(iterator.name, p1);
-                params.push(p1);
+        for (const iterator of node.params) {
+            if (iterator.type !== "Identifier") {
+                throw new Error("Expecting an identifier");
             }
-
-            if (outerParameter && firstOuterParam) {
-                paramSet.set(firstOuterParam, outerParameter);
+            if (!firstOuterParam && outerParameter) {
+                firstOuterParam = iterator.name;
+                paramSet.set(iterator.name, outerParameter);
+                params.push(outerParameter);
+                continue;
             }
+            const p1 = ParameterExpression.create({ name: iterator.name });
+            paramSet.set(iterator.name, p1);
+            params.push(p1);
+        }
 
-            let body = node.body;
-            if (body.type !== "ArrowFunctionExpression") {
-                throw new Error("Expecting an arrow function");
-            }
+        if (outerParameter && firstOuterParam) {
+            paramSet.set(firstOuterParam, outerParameter);
+        }
 
-            const firstTarget = body.params[0];
+        let body = node.body;
+        if (body.type !== "ArrowFunctionExpression") {
+            throw new Error("Expecting an arrow function");
+        }
 
-            let name = "____x";
+        const firstTarget = body.params[0];
 
-            if (firstTarget) {
+        let name = "____x";
 
-                if (firstTarget.type !== "Identifier") {
-                    throw new Error("Expecting an identifier");
-                }
-                name = firstTarget.name;
+        if (firstTarget) {
+
+            if (firstTarget.type !== "Identifier") {
+                throw new Error("Expecting an identifier");
             }
+            name = firstTarget.name;
+        }
 
 
-            target ??= ParameterExpression.create({ name});
+        target ??= ParameterExpression.create({ name});
 
-            body = body.body;
+        body = body.body;
 
-            const visitor = new this(paramSet, target, name);
-            return {
-                params,
-                target,
-                body: visitor.visit(body)
-            };
-        });
+        const visitor = new this(paramSet, target, name);
+        return {
+            params,
+            target,
+            body: visitor.visit(body)
+        };
     }
 
     public readonly leftJoins: string[] = [];