@entity-access/entity-access 1.0.54 → 1.0.56

package/src/query/ast/ExpressionToSql.ts

@@ -2,7 +2,7 @@ import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
 import { filteredSymbol } from "../../model/events/EntityEvents.js";
-import { 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, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { 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, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import { ITextQuery, QueryParameter, prepare, prepareJoin } from "./IStringTransformer.js";
 import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
@@ -75,7 +75,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const source = e.source.type === "ValuesStatement"
             ? prepare `(${this.visit(e.source)})`
             : this.visit(e.source);
-        const as = e.sourceParameter ? prepare ` AS ${this.compiler.quotedLiteral( this.scope.nameOf(e.sourceParameter))}` : "";
+        const as = e.sourceParameter ? prepare ` AS ${this.scope.nameOf(e.sourceParameter)}` : "";
         const fields = this.visitArray(e.fields, ",\n\t\t");
         return prepare `SELECT
         ${fields}
@@ -100,10 +100,6 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         }
     }
 
-    visitQuotedLiteral(e: QuotedLiteral): ITextQuery {
-        return [this.compiler.quotedLiteral(e.literal)];
-    }
-
     visitExpressionAs(e: ExpressionAs): ITextQuery {
         return prepare `${this.visit(e.expression)} AS ${this.visit(e.alias)}`;
     }
@@ -113,16 +109,16 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     }
 
     visitBigIntLiteral({ value }: BigIntLiteral): ITextQuery {
-        return [() => value];
+        return [value.toString()];
     }
 
     visitNumberLiteral( { value }: NumberLiteral): ITextQuery {
-        return [() => value];
+        return [value.toString()];
     }
 
     visitStringLiteral({ value }: StringLiteral): ITextQuery {
         const escapeLiteral = this.compiler.escapeLiteral;
-        return [() => escapeLiteral(value)];
+        return [escapeLiteral(value)];
     }
 
     visitBooleanLiteral( { value }: BooleanLiteral): ITextQuery {
@@ -163,15 +159,15 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                             let select: SelectStatement;
 
                             if (this.source?.context) {
-                                let query = this.source.context.query(relatedType);
-                                // check if we have filter...
-                                const entityEvents = this.source.context.eventsFor(relatedType, false);
-                                if (entityEvents) {
-                                    query = entityEvents.includeFilter(query);
-                                }
+                                const query = this.source.context.filteredQuery(relatedType, "include", false);
+                                // // check if we have filter...
+                                // const entityEvents = this.source.context.eventsFor(relatedType, false);
+                                // if (entityEvents) {
+                                //     query = entityEvents.includeFilter(query);
+                                // }
                                 select = { ... (query as EntityQuery).selectStatement };
                                 select.fields = [
-                                    Identifier.create({ value: "1"})
+                                    NumberLiteral.create({ value: 1})
                                 ];
                             } else {
                                 select = relatedModel.selectOneNumber();
@@ -273,7 +269,14 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 return [(p) => p[chain[0]]];
             }
             const name = this.scope.nameOf(parameter);
-            return [ QueryParameter.create(() => name, this.compiler.quotedLiteral) , "." , chain.map((x) => this.compiler.quotedLiteral(x)).join(".")];
+
+            // need to change name as per naming convention here...
+            const namingConvention = this.compiler.namingConvention;
+            if (scope.model && namingConvention) {
+                chain[0] = namingConvention(chain[0]);
+            }
+
+            return [ QueryParameter.create(() => name) , "." , chain.join(".")];
         }
 
         const { target, computed, property } = me;
@@ -395,9 +398,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         }
         const table = this.visit(e.source);
         const where = this.visit(e.where);
-        const as = e.as ? prepare ` AS ${ e.as.type === "QuotedLiteral"
-            ? this.compiler.quotedLiteral(e.as.literal)
-            : this.compiler.quotedLiteral( this.scope.nameOf(e.as) )}` : "";
+        const as = e.as ? prepare ` AS ${ e.as.type === "Identifier"
+            ? e.as.value
+            : this.scope.nameOf(e.as )}` : "";
         return prepare ` ${e.joinType || "LEFT"} JOIN ${table}${as} ON ${where}`;
     }
 
@@ -519,7 +522,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                     as: joinParameter,
                     joinType,
                     model: joinParameter.model,
-                    source: Expression.quotedLiteral(relation.relatedEntity.name),
+                    source: Expression.identifier(relation.relatedEntity.name),
                     where: Expression.equal(
                         Expression.member(parameter, fkColumn.columnName),
                         Expression.member(joinParameter, relation.relatedEntity.keys[0].columnName)

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

@@ -75,12 +75,12 @@ export class QueryExpander {
         const { relation } = mp;
         const { relatedTypeClass: propertyType } = relation;
 
-        let query = this.context.query(propertyType);
+        const query = this.context.filteredQuery(propertyType, "include", false, model, p.value);
         // if (this.filter) {
-            const events = this.context.eventsFor(propertyType, false);
-            if (events) {
-                query = events.includeFilter(query, model, p.value) ?? query;
-            }
+            // const events = this.context.eventsFor(propertyType, false);
+            // if (events) {
+            //     query = events.includeFilter(query, model, p.value) ?? query;
+            // }
         // }
         const select = { ... (query as EntityQuery).selectStatement };
 
@@ -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);
 
 }