@entity-access/entity-access 1.0.55 → 1.0.56

package/src/query/ast/Expressions.ts

@@ -29,9 +29,9 @@ export abstract class Expression {
         return ArrayExpression.create({ elements });
     }
 
-    static as(expression: Expression, alias: QuotedLiteral | string) {
+    static as(expression: Expression, alias: Identifier | string) {
         if (typeof alias === "string") {
-            alias = Expression.quotedLiteral(alias);
+            alias = Expression.identifier(alias);
         }
         return ExpressionAs.create({
             expression,
@@ -48,10 +48,6 @@ export abstract class Expression {
         return Constant.create({ value });
     }
 
-    static quotedLiteral(name: string) {
-        return QuotedLiteral.create({ literal: name });
-    }
-
     static parameter(name: string) {
         return ParameterExpression.create({ name });
     }
@@ -155,8 +151,8 @@ export class CoalesceExpression extends Expression {
 
 export class ValuesStatement extends Expression {
     readonly type = "ValuesStatement";
-    as: QuotedLiteral;
-    fields: QuotedLiteral[];
+    as: Identifier;
+    fields: Identifier[];
     values: Expression[][];
 }
 
@@ -215,7 +211,7 @@ export class ArrowFunctionExpression extends Expression {
     body: Expression;
 }
 
-export type TableSource = SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
+export type TableSource = SelectStatement | Identifier | ExpressionAs | TableLiteral;
 
 export type Expand = { [key: string]: string | Expand };
 
@@ -227,7 +223,7 @@ export class SelectStatement extends Expression {
 
     sourceParameter: ParameterExpression;
 
-    fields: (Expression | QuotedLiteral | ExpressionAs)[];
+    fields: (Expression | Identifier | ExpressionAs)[];
 
     where: Expression;
 
@@ -261,8 +257,8 @@ export class ConditionalExpression extends Expression {
 export class JoinExpression extends Expression {
     readonly type = "JoinExpression";
     joinType: "LEFT" | "INNER";
-    source: SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
-    as: QuotedLiteral | ParameterExpression;
+    source: SelectStatement | Identifier | ExpressionAs | TableLiteral;
+    as: Identifier | ParameterExpression;
     where: Expression;
     model: EntityType;
 }
@@ -270,7 +266,7 @@ export class JoinExpression extends Expression {
 export class ReturnUpdated extends Expression {
     readonly type = "ReturnUpdated";
 
-    fields: QuotedLiteral[];
+    fields: Identifier[];
 
     changes: "INSERTED" | "DELETED" | "UPDATED";
 }
@@ -300,6 +296,9 @@ export class BooleanLiteral extends Expression {
 }
 
 export class NumberLiteral extends Expression {
+
+    static one = NumberLiteral.create({ value: 1 });
+
     readonly type = "NumberLiteral";
     public value: number;
 }
@@ -323,34 +322,34 @@ export class TemplateLiteral extends Expression {
     public value: Expression[];
 }
 
-export class QuotedLiteral extends Expression {
+// export class QuotedLiteral extends Expression {
 
-    static propertyChain(... properties: string[]): Expression {
-        const literal = properties.pop();
-        const property = QuotedLiteral.create({ literal });
-        if (properties.length === 0) {
-            return property;
-        }
-        return MemberExpression.create({
-            target: QuotedLiteral.propertyChain(... properties),
-            property
-        });
-    }
+//     static propertyChain(... properties: string[]): Expression {
+//         const literal = properties.pop();
+//         const property = QuotedLiteral.create({ literal });
+//         if (properties.length === 0) {
+//             return property;
+//         }
+//         return MemberExpression.create({
+//             target: QuotedLiteral.propertyChain(... properties),
+//             property
+//         });
+//     }
 
-    readonly type = "QuotedLiteral";
-    public literal: string;
-}
+//     readonly type = "QuotedLiteral";
+//     public literal: string;
+// }
 
 export class ExpressionAs extends Expression {
     readonly type = "ExpressionAs";
     expression: Expression;
-    alias: QuotedLiteral;
+    alias: Identifier;
 }
 
 export class TableLiteral extends Expression {
     readonly type = "TableLiteral";
-    schema: QuotedLiteral;
-    name: QuotedLiteral;
+    schema: Identifier;
+    name: Identifier;
 
 }
 
@@ -368,7 +367,7 @@ export class UpdateStatement extends Expression {
 
     readonly type = "UpdateStatement";
 
-    table: TableLiteral | QuotedLiteral;
+    table: TableLiteral | Identifier;
 
     set: BinaryExpression[];
 
@@ -383,7 +382,7 @@ export class UnionAllStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral | QuotedLiteral;
+    table: TableLiteral | Identifier
     where: Expression;
 }
 
@@ -392,7 +391,7 @@ export type ExpressionType =
     ValuesStatement |
     SelectStatement |
     Constant|
-    QuotedLiteral|
+    // QuotedLiteral|
     ExpressionAs|
     TableLiteral|
     InsertStatement|

package/src/query/ast/IStringTransformer.ts

@@ -9,14 +9,14 @@ export type ISqlMethodTransformer = (compiler: QueryCompiler, callee: string[],
 
 export class QueryParameter {
 
-    static create(name: () => string, quotedLiteral: (n: string) => string ) {
-        return new QueryParameter(name, quotedLiteral);
+    static create(name: () => string) {
+        return new QueryParameter(name);
     }
 
-    constructor(public name: () => string, public quotedLiteral: (n: string) => string) {}
+    constructor(public name: () => string) {}
 
     toString() {
-        return this.quotedLiteral(this.name());
+        return this.name();
     }
 }
 

package/src/query/ast/Visitor.ts

@@ -1,5 +1,5 @@
 import { NotSupportedError } from "../parser/NotSupportedError.js";
-import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -15,8 +15,6 @@ export default abstract class Visitor<T = any> {
                 return this.visitConstant(e);
             case "ExpressionAs":
                 return this.visitExpressionAs(e);
-            case "QuotedLiteral":
-                return this.visitQuotedLiteral(e);
             case "SelectStatement":
                 return this.visitSelectStatement(e);
             case "TableLiteral":
@@ -171,10 +169,6 @@ export default abstract class Visitor<T = any> {
         return;
     }
 
-    visitQuotedLiteral(e: QuotedLiteral): T {
-        return;
-    }
-
     visitExpressionAs(e: ExpressionAs): T {
         return;
     }

package/src/query/expander/QueryExpander.ts

@@ -95,11 +95,11 @@ export class QueryExpander {
             joinWhere = Expression.equal(
                 Expression.member(
                     parent.sourceParameter,
-                    Expression.quotedLiteral(fk.columnName)
+                    Expression.identifier(fk.columnName)
                 ),
                 Expression.member(
                     select.sourceParameter,
-                    Expression.quotedLiteral(model.keys[0].columnName)
+                    Expression.identifier(model.keys[0].columnName)
                 )
             );
             // load parent..
@@ -121,11 +121,11 @@ export class QueryExpander {
         joinWhere = Expression.equal(
             Expression.member(
                 parent.sourceParameter,
-                Expression.quotedLiteral(fk.columnName)
+                Expression.identifier(fk.columnName)
             ),
             Expression.member(
                 select.sourceParameter,
-                Expression.quotedLiteral(relation.relatedEntity.keys[0].columnName)
+                Expression.identifier(relation.relatedEntity.keys[0].columnName)
             )
         );
 

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, QuotedLiteral, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
+import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, 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";
@@ -231,7 +231,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
                     switch(iterator.key.type) {
                         case "Identifier":
                             properties.push( ExpressionAs.create({
-                                alias: QuotedLiteral.create({ literal: iterator.key.name}),
+                                alias: Expression.identifier(iterator.key.name),
                                 expression: this.visit(iterator.value)
                             }) );
                             break;

package/src/tests/eternity/eternity-tests.ts

@@ -65,7 +65,6 @@ export default async function (this: TestConfig) {
     scope.add(WorkflowClock, mockClock);
     scope.add(BaseDriver, this.driver);
     const storage = new EternityStorage(this.driver, mockClock);
-    await storage.seed();
     scope.add(Mailer, mailer);
     scope.add(EternityStorage, storage);
 
@@ -75,6 +74,8 @@ export default async function (this: TestConfig) {
     // this is an important step
     c.register(SendWorkflow);
 
+    await storage.seed();
+
     const id = await c.queue(SendWorkflow, "a");
 
     mockClock.add(TimeSpan.fromSeconds(15));

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

@@ -5,64 +5,64 @@ import { assertSqlMatch, trimInternal } from "../trimInternal.js";
 import PostgreSqlDriver from "../../../drivers/postgres/PostgreSqlDriver.js";
 
 const sql1 = `SELECT
-"p1"."productID",
-"p1"."name",
-"p1"."ownerID",
-"p1"."status"
-FROM "Products" AS "p1"
+p1.product_id,
+p1.name,
+p1.owner_id,
+p1.status
+FROM Products AS p1
 WHERE EXISTS (SELECT
 1
-FROM "OrderItems" AS "o"
-WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $1))`;
+FROM OrderItems AS o
+WHERE (p1.product_id = o.product_id) AND (o.product_id = $1))`;
 
 const sql2 = `SELECT
-"p1"."productID",
-"p1"."name",
-"p1"."ownerID",
-"p1"."status"
-FROM "Products" AS "p1"
+p1.product_id,
+p1.name,
+p1.owner_id,
+p1.status
+FROM Products AS p1
 WHERE EXISTS (SELECT
 1
-FROM "OrderItems" AS "o"
-WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $1)) AND EXISTS (SELECT
+FROM OrderItems AS o
+WHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND EXISTS (SELECT
 1
-FROM "OrderItems" AS "o1"
-WHERE ("p1"."productID" = "o1"."productID") AND ("o1"."amount" > $2))`;
+FROM OrderItems AS o1
+WHERE (p1.product_id = o1.product_id) AND (o1.amount > $2))`;
 
 const sql3 = `SELECT
-"p1"."productID",
-"p1"."name",
-"p1"."ownerID",
-"p1"."status"
-FROM "Products" AS "p1"
+p1.product_id,
+p1.name,
+p1.owner_id,
+p1.status
+FROM Products AS p1
 WHERE EXISTS (SELECT
 1
-FROM "OrderItems" AS "o"
-WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $1)) AND EXISTS (SELECT
+FROM OrderItems AS o
+WHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND EXISTS (SELECT
 1
-FROM "OrderItems" AS "o1"
- INNER JOIN "Orders" AS "o2" ON "o1"."orderID" = "o2"."orderID"
-WHERE ("p1"."productID" = "o1"."productID") AND ("o2"."orderDate" > $2))`;
+FROM OrderItems AS o1
+ INNER JOIN Orders AS o2 ON o1.order_id = o2.order_id
+WHERE (p1.product_id = o1.product_id) AND (o2.order_date > $2))`;
 
 const productJoin = `SELECT
-"p1"."productID",
-"p1"."name",
-"p1"."ownerID",
-"p1"."status"
-FROM "Products" AS "p1"
- LEFT JOIN "Users" AS "u" ON "p1"."ownerID" = "u"."userID"
-WHERE "u"."dateCreated" > $1`;
+p1.product_id,
+p1.name,
+p1.owner_id,
+p1.status
+FROM Products AS p1
+ LEFT JOIN Users AS u ON p1.owner_id = u.user_id
+WHERE u.date_created > $1`;
 
 
 const join2 = `SELECT
-"o1"."orderItemID",
-"o1"."orderID",
-"o1"."productID",
-"o1"."priceID",
-"o1"."amount"
-FROM "OrderItems" AS "o1"
- INNER JOIN "Products" AS "p" ON "o1"."productID" = "p"."productID"
-WHERE ("o1"."productID" = $1) OR ("p"."ownerID" = $2)`;
+o1.order_item_id,
+o1.order_id,
+o1.product_id,
+o1.price_id,
+o1.amount
+FROM OrderItems AS o1
+ INNER JOIN Products AS p ON o1.product_id = p.product_id
+WHERE (o1.product_id = $1) OR (p.owner_id = $2)`;
 
 export default function() {
 

package/src/tests/expressions/select/select.ts

@@ -1,8 +1,5 @@
 import assert from "assert";
 import QueryCompiler from "../../../compiler/QueryCompiler.js";
-import ArrowToExpression from "../../../query/parser/ArrowToExpression.js";
-import { ExpressionAs, Identifier, MemberExpression, NewObjectExpression, QuotedLiteral } from "../../../query/ast/Expressions.js";
-import ExpressionToSql from "../../../query/ast/ExpressionToSql.js";
 
 type ICustomer = { firstName: string; lastName: string; emailAddress: string; birthDate: Date };
 
@@ -15,10 +12,10 @@ export default function() {
 
     let r = compiler.execute({ name }, (p) => ({ firstName, lastName, emailAddress }: ICustomer) => ({ emailAddress, name: `${firstName} ${lastName}` }));
 
-    assert.strictEqual(`FROM ("x1"."emailAddress" AS "emailAddress",CONCAT("x1"."firstName",$1,"x1"."lastName") AS "name")`, r.text);
+    assert.strictEqual(`FROM (x1.emailAddress AS emailAddress,CONCAT(x1.firstName,' ',x1.lastName) AS name)`, r.text);
 
     r = compiler.execute({ name }, (p) => ({ id }) => ({ error: `${id > 0 ? "Error" : ""}` }));
 
-    assert.strictEqual(`FROM (CONCAT((CASE WHEN "x1"."id" > $1 THEN $2 ELSE $3 END)) AS "error")`, r.text);
+    assert.strictEqual(`FROM (CONCAT((CASE WHEN x1.id > 0 THEN 'Error' ELSE '' END)) AS error)`, r.text);
 
 }

package/src/tests/expressions/simple/parse-arrow.ts

@@ -10,37 +10,37 @@ export default function () {
 
     let r = compiler.execute({ name }, (p) => (x) => x.firstName === p.name);
 
-    assert.equal(`"x"."firstName" = $1`, r.text);
+    assert.equal(`x.firstName = $1`, r.text);
 
     r = compiler.execute({ name }, (p) => (x) => x.firstName === p.name && x.lastName !== p.name);
 
-    assert.equal(`("x"."firstName" = $1) AND ("x"."lastName" <> $2)`, r.text);
+    assert.equal(`(x.firstName = $1) AND (x.lastName <> $2)`, r.text);
 
     r = compiler.execute({ name }, (p) => (x) => (x.firstName === p.name || x.middleName === p.name) && x.lastName !== p.name);
 
-    assert.equal(`(("x"."firstName" = $1) OR ("x"."middleName" = $2)) AND ("x"."lastName" <> $3)`, r.text);
+    assert.equal(`((x.firstName = $1) OR (x.middleName = $2)) AND (x.lastName <> $3)`, r.text);
 
 
-    const sqlServerCompiler = new QueryCompiler({ quotedLiteral: (x) => `[${x}]`});
+    const sqlServerCompiler = new QueryCompiler({});
     r = sqlServerCompiler.execute({ name }, (p) => (x) => x.firstName === p.name && x.lastName !== p.name);
 
-    assert.equal(`([x].[firstName] = $1) AND ([x].[lastName] <> $2)`, r.text);
+    assert.equal(`(x.firstName = $1) AND (x.lastName <> $2)`, r.text);
 
     r = compiler.execute({ name }, (p) => (x) => ( x.firstName ?? x.lastName ) === p.name);
 
-    assert.equal(`COALESCE("x"."firstName", "x"."lastName") = $1`, r.text);
+    assert.equal(`COALESCE(x.firstName, x.lastName) = $1`, r.text);
 
     r = compiler.execute({ name }, (p) => (x) => Sql.text.like(x.firstName, p.name));
 
-    assert.equal(`("x"."firstName" LIKE $1)`, r.text);
+    assert.equal(`(x.firstName LIKE $1)`, r.text);
 
     r = compiler.execute({ days: 1 }, (p) => (x) => Sql.date.addDays(x.birthDate, p.days));
 
-    assert.equal(`("x"."birthDate" + ($1 * interval '1 day'))`, r.text);
+    assert.equal(`(x.birthDate + ($1 * interval '1 day'))`, r.text);
 
     r = compiler.execute({name}, (p) => (x) => Sql.text.startsWith(x.firstName, p.name));
 
-    assert.equal(`starts_with("x"."firstName", $1)`, r.text);
+    assert.equal(`starts_with(x.firstName, $1)`, r.text);
     assert.equal("Akash", r.values[0]);
 
     const code = "1235";
@@ -49,7 +49,7 @@ export default function () {
         (p) => (x: KeyCode) =>
             x.code === Sql.cast.asNumber(p.code) && x.key === Sql.cast.asText(p.key) );
 
-    assert.equal(`("x"."code" = ($1 ::double)) AND ("x"."key" = ($2 ::text))`, r.text);
+    assert.equal(`(x.code = ($1 ::double)) AND (x.key = ($2 ::text))`, r.text);
 
 }