@entity-access/entity-access 1.0.198 → 1.0.200

package/src/query/ast/ExpressionToSql.ts

@@ -693,8 +693,10 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                                 return join.as;
                             }
                             const joinType = select.preferLeftJoins ? "LEFT" : (fkColumn.nullable ? "LEFT" : "INNER");
-                            const joinParameter = ParameterExpression.create({ name: relation.relatedEntity.name[0]});
-                            joinParameter.model = relation.relatedEntity;
+                            const joinParameter = ParameterExpression.create({
+                                name: relation.relatedEntity.name[0],
+                                model: relation.relatedEntity
+                            });
                             join = JoinExpression.create({
                                 as: joinParameter,
                                 joinType,
@@ -779,79 +781,79 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         // };
     }
 
-    private flatten(pc: IPropertyChain) : IPropertyChain {
-
-        if (!pc) {
-            return pc;
-        }
-
-        // check if we have parameter..
-        let { parameter } = pc;
-        if (!parameter) {
-            return pc;
-        }
-        if (pc.chain.length <= 1) {
-            return pc;
-        }
-
-        const chain = [ ... pc.chain];
-
-        const scope = this.scope.get(parameter);
-        const select = scope?.selectStatement ?? this.source?.selectStatement;
-        if (!select) {
-            return pc;
-        }
-        let type = select.model;
-
-        select.joins ??= [];
-
-        while(chain.length > 1) {
-            const property = chain.shift();
-            const propertyInfo = type.getProperty(property);
-            if (!propertyInfo.relation || propertyInfo.relation.isInverseRelation) {
-                return pc;
-            }
-
-            const relation = propertyInfo.relation;
-            // check if relation is optional...
-            if (!relation.fkColumn) {
-                return pc;
-            }
-
-            const { fkColumn } = relation;
-
-            const join = select.joins.find((x) => x.model === relation.relatedEntity);
-            if (!join) {
-                const joinType = fkColumn.nullable ? "LEFT" : "INNER";
-                const joinParameter = ParameterExpression.create({ name: relation.relatedEntity.name[0]});
-                joinParameter.model = relation.relatedEntity;
-                select.joins.push(JoinExpression.create({
-                    as: joinParameter,
-                    joinType,
-                    model: joinParameter.model,
-                    source: Expression.identifier(relation.relatedEntity.name),
-                    where: Expression.equal(
-                        Expression.member(parameter, fkColumn.columnName),
-                        Expression.member(joinParameter, relation.relatedEntity.keys[0].columnName)
-                    )
-                }));
-                parameter = joinParameter;
-                type = relation.relatedEntity;
-                this.scope.create({ parameter, model: type, selectStatement: select });
-                pc.parameter = parameter;
-                pc.chain = [ ... chain ];
-            } else {
-                // we will add parameter in scope in case if it is not there
-                // this is the case when query is composed over already existing
-                // there is still an error on this one...
-                pc.parameter = parameter = join.as as ParameterExpression;
-                type = join.model;
-                pc.chain = [... chain];
-                this.scope.create({ parameter, model: type, selectStatement: select });
-            }
-        }
-
-        return pc;
-    }
+    // private flatten(pc: IPropertyChain) : IPropertyChain {
+
+    //     if (!pc) {
+    //         return pc;
+    //     }
+
+    //     // check if we have parameter..
+    //     let { parameter } = pc;
+    //     if (!parameter) {
+    //         return pc;
+    //     }
+    //     if (pc.chain.length <= 1) {
+    //         return pc;
+    //     }
+
+    //     const chain = [ ... pc.chain];
+
+    //     const scope = this.scope.get(parameter);
+    //     const select = scope?.selectStatement ?? this.source?.selectStatement;
+    //     if (!select) {
+    //         return pc;
+    //     }
+    //     let type = select.model;
+
+    //     select.joins ??= [];
+
+    //     while(chain.length > 1) {
+    //         const property = chain.shift();
+    //         const propertyInfo = type.getProperty(property);
+    //         if (!propertyInfo.relation || propertyInfo.relation.isInverseRelation) {
+    //             return pc;
+    //         }
+
+    //         const relation = propertyInfo.relation;
+    //         // check if relation is optional...
+    //         if (!relation.fkColumn) {
+    //             return pc;
+    //         }
+
+    //         const { fkColumn } = relation;
+
+    //         const join = select.joins.find((x) => x.model === relation.relatedEntity);
+    //         if (!join) {
+    //             const joinType = fkColumn.nullable ? "LEFT" : "INNER";
+    //             const joinParameter = ParameterExpression.create({ name: relation.relatedEntity.name[0]});
+    //             joinParameter.model = relation.relatedEntity;
+    //             select.joins.push(JoinExpression.create({
+    //                 as: joinParameter,
+    //                 joinType,
+    //                 model: joinParameter.model,
+    //                 source: Expression.identifier(relation.relatedEntity.name),
+    //                 where: Expression.equal(
+    //                     Expression.member(parameter, fkColumn.columnName),
+    //                     Expression.member(joinParameter, relation.relatedEntity.keys[0].columnName)
+    //                 )
+    //             }));
+    //             parameter = joinParameter;
+    //             type = relation.relatedEntity;
+    //             this.scope.create({ parameter, model: type, selectStatement: select });
+    //             pc.parameter = parameter;
+    //             pc.chain = [ ... chain ];
+    //         } else {
+    //             // we will add parameter in scope in case if it is not there
+    //             // this is the case when query is composed over already existing
+    //             // there is still an error on this one...
+    //             pc.parameter = parameter = join.as as ParameterExpression;
+    //             type = join.model;
+    //             pc.chain = [... chain];
+    //             this.scope.create({ parameter, model: type, selectStatement: select });
+    //         }
+    //     }
+
+    //     return pc;
+    // }
 
 }

package/src/query/ast/Expressions.ts

@@ -58,8 +58,8 @@ export abstract class Expression {
         return Constant.create({ value });
     }
 
-    static parameter(name: string) {
-        return ParameterExpression.create({ name });
+    static parameter(name: string, model?: EntityType) {
+        return ParameterExpression.create({ name, model });
     }
 
     static identifier(name: string) {
@@ -70,6 +70,10 @@ export abstract class Expression {
         return BinaryExpression.create({ left, operator: "AND", right});
     }
 
+    static logicalOr(left: Expression, right: Expression): BinaryExpression {
+        return BinaryExpression.create({ left, operator: "OR", right});
+    }
+
     static member(target: Expression, identifier: string |Expression): MemberExpression {
         return MemberExpression.create({
             target,
@@ -83,6 +87,14 @@ export abstract class Expression {
         return BinaryExpression.create({ left, right, operator: "="});
     }
 
+    static less(left: Expression, right: Expression) {
+        return BinaryExpression.create({ left, right, operator: "<"});
+    }
+
+    static lessOrEqual(left: Expression, right: Expression) {
+        return BinaryExpression.create({ left, right, operator: "<="});
+    }
+
     static assign(left: Expression, right: Expression) {
         return BinaryExpression.create({ left, right, operator: "="});
     }

package/src/query/expander/QueryExpander.ts

@@ -109,7 +109,7 @@ export class QueryExpander {
 
 
             const joins = (select.joins ??= []);
-            const joinParameter = Expression.parameter(parent.sourceParameter.name);
+            const joinParameter = Expression.parameter(parent.sourceParameter.name, parent.model);
 
             // This join has to be INNER JOIN as we are only interested
             // in the results that matches parent query exactly
@@ -175,7 +175,7 @@ export class QueryExpander {
         //     : existsWhere;
 
         const selectJoins = (select.joins ??= []);
-        const selectJoinParameter = Expression.parameter(parent.sourceParameter.name);
+        const selectJoinParameter = Expression.parameter(parent.sourceParameter.name, parent.model);
 
         // This join has to be INNER JOIN as we are only interested
         // in the results that matches parent query exactly

package/src/workflows/WorkflowStorage.ts

@@ -251,9 +251,17 @@ export default class WorkflowStorage {
                 where: Expression.logicalAnd(Expression.equal(
                     Expression.identifier("id"),
                     Expression.member(px, "id")
-                ), Expression.equal(
-                    Expression.identifier(lockTokenField),
-                    NullExpression.create({})
+                ), Expression.logicalOr(
+                    Expression.equal(
+                        Expression.identifier(lockTTLField),
+                        NullExpression.create({})
+                    ),
+                    Expression.lessOrEqual(
+                        Expression.identifier(lockTTLField),
+                        CallExpression.create({
+                            callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "now")
+                        })
+                    )
                 ))
             });
 
@@ -279,9 +287,13 @@ export default class WorkflowStorage {
         for (const iterator of items) {
             // try to acquire lock...
             iterator.lockToken = uuid;
-            const r = await q.invoke(db.connection, iterator);
-            if (r.updated > 0) {
-                list.push(iterator);
+            try {
+                const r = await q.invoke(db.connection, iterator);
+                if (r.updated > 0) {
+                    list.push(iterator);
+                }
+            } catch (error) {
+                console.error(error);            
             }
         }
         return list;