@entity-access/entity-access 1.0.219 → 1.0.221

package/src/query/expander/QueryExpander.ts

@@ -19,7 +19,7 @@ export class QueryExpander {
 
     private include: SelectStatement[] = [];
 
-    private included = new Map<string, [SelectStatement, EntityType]>();
+    private included = new Map<string, [string, SelectStatement, EntityType]>();
 
     constructor(
         private context: EntityContext,
@@ -29,7 +29,7 @@ export class QueryExpander {
 
     }
 
-    expandNode(key: string, parent: SelectStatement, model: EntityType, node: ExpressionType): [SelectStatement, EntityType] {
+    expandNode(key: string, parent: SelectStatement, model: EntityType, node: ExpressionType): [string, SelectStatement, EntityType] {
 
         parent = cloner.clone(parent);
 
@@ -52,14 +52,14 @@ export class QueryExpander {
             if (property.value !== "forEach") {
                 throw new NotSupportedError(property.value);
             }
-            const [expandedSelect, expandedType] = this.expandNode(key, parent, model, callee.target as ExpressionType);
-
+            const [k, expandedSelect, expandedType] = this.expandNode(key, parent, model, callee.target as ExpressionType);
+            key = k;
             const arrow = node.arguments[0];
             if (!arrow || arrow.type !== "ArrowFunctionExpression") {
                 throw new NotSupportedError(arrow?.type ?? "Empty Expression");
             }
             this.expandNode(key, expandedSelect, expandedType, (arrow as ArrowFunctionExpression).body as ExpressionType);
-            return [expandedSelect, expandedType];
+            return [key, expandedSelect, expandedType];
         }
 
         if (node.type !== "MemberExpression") {
@@ -73,7 +73,8 @@ export class QueryExpander {
 
         const target = node.target as ExpressionType;
         if (target.type === "MemberExpression") {
-            const [mepSelect, mepType] = this.expandNode( key, parent, model, target);
+            const [k, mepSelect, mepType] = this.expandNode( key, parent, model, target);
+            key = k;
             parent = mepSelect;
             model = mepType;
         }
@@ -153,7 +154,7 @@ export class QueryExpander {
             // const text = DebugStringVisitor.expressionToString(select);
             // console.log(text);
             this.include.push(select);
-            relationSet = [select, relation.relatedEntity];
+            relationSet = [key, select, relation.relatedEntity];
             this.included.set(key, relationSet);
             return relationSet;
         }
@@ -211,7 +212,7 @@ export class QueryExpander {
 
         this.include.push(select);
 
-        relationSet = [select, relation.relatedEntity];
+        relationSet = [key, select, relation.relatedEntity];
         this.included.set(key, relationSet);
         return relationSet;
     }

package/src/query/parser/ArrowToExpression.ts

@@ -1,5 +1,5 @@
 import { parseExpression } from "@babel/parser";
-import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, ParameterExpression, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
+import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NotExpression, NullExpression, NumberLiteral, ParameterExpression, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
 import { BabelVisitor } from "./BabelVisitor.js";
 import * as bpe from "@babel/types";
 import Restructure from "./Restructure.js";
@@ -104,6 +104,10 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
         return NumberLiteral.create({ value });
     }
 
+    visitUnaryExpression(node: bpe.UnaryExpression): Expression {
+        return NotExpression.create({ expression: this.visit(node.argument)});
+    }
+
     visitTemplateLiteral(node: bpe.TemplateLiteral) {
         // const value = node.expressions.map((x) => this.visit(x));
 

package/src/query/parser/BabelVisitor.ts

@@ -41,6 +41,8 @@ export abstract class BabelVisitor<T> {
                 return this.visitTemplateElement(node);
             case "ArrayExpression":
                 return this.visitArrayExpression(node);
+            case "UnaryExpression":
+                return this.visitUnaryExpression(node);
             case "RegExpLiteral":
             default:
                 throw new Error(`Translation from ${node.type} not supported`);
@@ -53,6 +55,7 @@ export abstract class BabelVisitor<T> {
     visitObjectProperty(node: bpe.ObjectProperty): T {
         throw new Error("Method not implemented.");
     }
+    abstract visitUnaryExpression(node: bpe.UnaryExpression): T;
     abstract visitObjectExpression(node: bpe.ObjectExpression): T;
     abstract visitMemberExpression(node: bpe.MemberExpression): T;
     abstract visitLogicalExpression(node: bpe.LogicalExpression): T;

package/src/query/parser/Restructure.ts

@@ -7,6 +7,10 @@ export default class Restructure extends TransformVisitor {
 
     private map: Map<string, bpe.Node> = new Map();
 
+    visitUnaryExpression(node: bpe.UnaryExpression): bpe.Node {
+        return node;
+    }
+
     visitTemplateElement(node: bpe.TemplateElement): bpe.Node {
         return node;
     }

package/src/query/parser/TransformVisitor.ts

@@ -68,6 +68,10 @@ export default class TransformVisitor extends BabelVisitor<bpe.Node> {
         return bpe.binaryExpression(node.operator, this.transform(node.left), this.transform(node.right));
     }
 
+    visitUnaryExpression(node: bpe.UnaryExpression): bpe.Node {
+        return bpe.unaryExpression(node.operator, node.argument, node.prefix);
+    }
+
     visitObjectProperty(node: bpe.ObjectProperty): bpe.Node {
 
         let key = node.key;

package/src/tests/expressions/left-joins/child-joins.ts

@@ -64,6 +64,8 @@ FROM order_items AS o1
  LEFT JOIN products AS p ON o1.product_id = p.product_id
 WHERE (o1.product_id = $1) OR (p.owner_id = $2)`;
 
+const notExp = 'SELECT\n        p1.product_id,\n\t\tp1.name,\n\t\tp1.owner_id,\n\t\tp1.status\n        FROM products AS p1\n\tWHERE EXISTS (SELECT\n        1\n        FROM order_items AS o\n\tWHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND  NOT (EXISTS (SELECT\n        1\n        FROM order_items AS o1\n\t\t INNER JOIN orders AS o2 ON o1.order_id = o2.order_id\n\tWHERE (p1.product_id = o1.product_id) AND (o2.order_date > $2)))';
+
 export default function() {
 
     const context = new ShoppingContext(new PostgreSqlDriver({}));
@@ -88,4 +90,9 @@ export default function() {
     const q = context.orderItems.where({ o: 1,  owner: 1}, (p) => (x) => x.productID === p.o || x.product.ownerID === p.owner);
     r = q.toQuery();
     assertSqlMatch(join2, r.text);
+
+    query = old.where({ date: new Date()}, (p) => (x) => !x.orderItems.some((o) => o.order.orderDate > p.date));
+    r = query.toQuery();
+    assertSqlMatch(notExp, r.text);
+
 }