@entity-access/entity-access 1.0.547 → 1.1.1

package/src/query/parser/ArrowToExpression.ts

@@ -18,7 +18,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
      * @param target parameter target
      * @returns Parsed expression
      */
-    public static transform(fx: (p: any) => (x: any) => any, target?: ParameterExpression, outerParameter?: ParameterExpression) {
+    public static transform(fx: (x: any, p: any) => any, target?: ParameterExpression, outerParameter?: ParameterExpression) {
         const key = fx.toString();
         const rs = new Restructure();
         const node = rs.visit(parseExpression(key));
@@ -26,7 +26,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     /**
-     * Since expression parsed as a different parameter in nested lambda (p) => (x) => x..,
+     * Since expression parsed as a different parameter in nested lambda (x, p) => x..,
      * we need to replace x with provided target to bind x with respective ParameterExpression.
      * As ParameterExpression contains the type and model associated with the table represented by `x`.
      * @param node parsed node
@@ -35,9 +35,6 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
      */
     private static transformUncached(node: bpe.Node, target?: ParameterExpression, outerParameter?: ParameterExpression): { params: ParameterExpression[], body: Expression, target: ParameterExpression } {
 
-        if (node.type !== "ArrowFunctionExpression") {
-            throw new Error("Expecting an arrow function");
-        }
 
         const paramSet = new Map<string, any>();
 
@@ -45,46 +42,67 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
 
         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);
+        if (node.type !== "ArrowFunctionExpression") {
+            throw new Error("Expecting an arrow function");
         }
 
-        if (outerParameter && firstOuterParam) {
-            paramSet.set(firstOuterParam, outerParameter);
-        }
+        let name = "____x";
 
         let body = node.body;
-        if (body.type !== "ArrowFunctionExpression") {
-            throw new Error("Expecting an arrow function");
-        }
-
-        const firstTarget = body.params[0];
+        let firstTarget: (bpe.Identifier | bpe.Pattern | bpe.RestElement);
+        if (body.type === "ArrowFunctionExpression") {
+            firstTarget = body.params[0];
+            if (firstTarget) {
 
-        let name = "____x";
+                if (firstTarget.type !== "Identifier") {
+                    throw new Error("Expecting an identifier");
+                }
+                name = firstTarget.name;
+            }
+            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);
+            }
 
-        if (firstTarget) {
+            if (outerParameter && firstOuterParam) {
+                paramSet.set(firstOuterParam, outerParameter);
+            }
+            body = body.body;
+        } else {
+            firstTarget = node.params[0];
+            if (firstTarget) {
 
-            if (firstTarget.type !== "Identifier") {
-                throw new Error("Expecting an identifier");
+                if (firstTarget.type !== "Identifier") {
+                    throw new Error("Expecting an identifier");
+                }
+                name = firstTarget.name;
+            }
+            const lastParam = node.params.at(-1) as any as bpe.Identifier;
+            if (lastParam) {
+                if (outerParameter) {
+                    paramSet.set(lastParam.name, outerParameter);
+                } else {
+                    const p1 = ParameterExpression.create({ name: lastParam.name });
+                    paramSet.set(lastParam.name, p1);
+                    params.push(p1);
+                }
             }
-            name = firstTarget.name;
+
         }
 
 
-        target ??= ParameterExpression.create({ name});
 
-        body = body.body;
+        target ??= ParameterExpression.create({ name});
 
         const visitor = new this(paramSet, target, name);
         return {

package/src/workflows/WorkflowStorage.ts

@@ -43,11 +43,11 @@ export default class WorkflowStorage {
 
     getPendingWorkflowCount({ taskGroup = void 0 } = { }) {
         const db = new WorkflowDbContext(this.driver);
-        let q = db.workflows.where(void 0, (p) => (x) => x.isWorkflow === true
+        let q = db.workflows.where(void 0, (x, p) => x.isWorkflow === true
             && x.state === "queued"
         );
         if (taskGroup) {
-            q = q.where({ taskGroup}, (p) => (x) => x.taskGroup === p.taskGroup);
+            q = q.where({ taskGroup}, (x, p) => x.taskGroup === p.taskGroup);
         }
         return q.count();
     }
@@ -56,13 +56,13 @@ export default class WorkflowStorage {
         const now = this.clock.utcNow;
         const db = new WorkflowDbContext(this.driver);
         const { group, deferSeconds } = throttle;
-        const w = await db.workflows.where({ group, now }, (p) => (x) => x.throttleGroup === p.group
+        const w = await db.workflows.where({ group, now }, (x, p) => x.throttleGroup === p.group
                 && x.state !== "failed"
                 && x.state !== "done"
                 && x.isWorkflow === true
                 && x.eta >= Sql.cast.asDateTime(p.now)
             )
-            .orderByDescending(void 0, (p) => (x) => x.queued)
+            .orderByDescending(void 0, (x, p) => x.queued)
             .first();
         if (w) {
             w.eta = DateTime.from(w.eta).addSeconds(deferSeconds);
@@ -76,9 +76,9 @@ export default class WorkflowStorage {
 
         const db = new WorkflowDbContext(this.driver);
 
-        const last = await db.workflows.where(throttle, (p) => (x) => x.throttleGroup === p.group
+        const last = await db.workflows.where(throttle, (x, p) => x.throttleGroup === p.group
             && x.isWorkflow === true)
-            .orderByDescending(void 0, (p) => (x) => x.queued)
+            .orderByDescending(void 0, (x, p) => x.queued)
             .first();
 
         if (last) {
@@ -143,12 +143,12 @@ export default class WorkflowStorage {
         if (text) {
             // save..
             await db.workflows.statements.update({ extra: text }, { id });
-            // await db.workflows.where({ id }, (p) => (x) => x.id === p.id)
-            //     .update({ text}, (p) => (x) => ({ extra: p.text }));
+            // await db.workflows.where({ id }, (x, p) => x.id === p.id)
+            //     .update({ text}, (x, p) => ({ extra: p.text }));
             return text;
         }
-        const item = await db.workflows.where({ id }, (p) => (x) => x.id === p.id)
-            .select(void 0, (p) => (x) => ({ extra: x.extra}) ).first();
+        const item = await db.workflows.where({ id }, (x, p) => x.id === p.id)
+            .select(void 0, (x, p) => ({ extra: x.extra}) ).first();
         return item?.extra;
 }
 
@@ -162,9 +162,9 @@ export default class WorkflowStorage {
 
         // if parent workflows exist
         // change eta to recent ones...
-        const hasPendingChildren = await db.workflows.where({ id }, (p) => (x) => x.parentID === p.id && x.isWorkflow === true)
+        const hasPendingChildren = await db.workflows.where({ id }, (x, p) => x.parentID === p.id && x.isWorkflow === true)
             .limit(1000)
-            .update(void 0, (p) => (x) => ({
+            .update(void 0, (x, p) => ({
                 eta: Sql.date.addMinutes(Sql.date.now(),-1)
             }));
 
@@ -172,16 +172,16 @@ export default class WorkflowStorage {
             return;
         }
 
-        await db.workflows.where({ id}, (p) => (x) => x.parentID === p.id)
+        await db.workflows.where({ id}, (x, p) => x.parentID === p.id)
             .limit(1000)
-            .delete({ id }, (p) => (x) => x.parentID === p.id);
+            .delete({ id }, (x, p) => x.parentID === p.id);
 
-        if (await db.workflows.where({ id}, (p) => (x) => x.parentID === p.id).some()) {
+        if (await db.workflows.where({ id}, (x, p) => x.parentID === p.id).some()) {
             return;
         }
 
         await db.workflows.asQuery()
-            .delete({ id}, (p) => (x) => x.id === p.id);
+            .delete({ id}, (x, p) => x.id === p.id);
 
         return true;
     }
@@ -255,17 +255,17 @@ export default class WorkflowStorage {
         const uuid = randomUUID();
 
         const items = await db.workflows
-            .where({now, taskGroup}, (p) => (x) => x.eta <= p.now
+            .where({now, taskGroup}, (x, p) => x.eta <= p.now
                 && ( x.lockedTTL === null
                     || x.lockedTTL <= p.now
                 )
                 && x.isWorkflow === true
                 && x.taskGroup === p.taskGroup)
-            .orderBy({}, (p) => (x) => x.eta)
-            .thenBy({}, (p) => (x) => x.priority)
+            .orderBy({}, (x, p) => x.eta)
+            .thenBy({}, (x, p) => x.priority)
             .limit(20)
             .withSignal(signal)
-            .updateSelect({ uuid}, (p) => (x) => ({
+            .updateSelect({ uuid}, (x, p) => ({
                 lockedTTL: Sql.date.addSeconds(Sql.date.now(), 15),
                 lockToken: p.uuid
             }));