@entity-access/entity-access 1.0.2 → 1.0.6

package/src/query/parser/ArrowToExpression.ts

@@ -1,27 +1,40 @@
 import { parseExpression } from "@babel/parser";
-import { ArrowFunctionExpression, BinaryExpression, CallExpression, CoalesceExpression, Constant, Expression, Identifier, MemberExpression, NullExpression, NumberLiteral, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
+import { ArrowFunctionExpression, BinaryExpression, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, ParameterExpression, QuotedLiteral, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
 import { BabelVisitor } from "./BabelVisitor.js";
 import * as bpe from "@babel/types";
-import EntityType from "../../entity-query/EntityType.js";
-import { EntitySource } from "../../model/EntitySource.js";
+import Restructure from "./Restructure.js";
+import { NotSupportedError } from "./NotSupportedError.js";
+import TimedCache from "../../common/cache/TimedCache.js";
 
 type IQueryFragment = string | { name?: string, value?: any };
-type IQueryFragments = IQueryFragment[];
+
+const parsedCache = new TimedCache<string, bpe.Node>();
 
 export default class ArrowToExpression extends BabelVisitor<Expression> {
 
-    public static transform(fx: (p: any) => (x: any) => any) {
-        const node = parseExpression(fx.toString());
+    public static transform(fx: (p: any) => (x: any) => any, target?: ParameterExpression) {
+        const key = fx.toString();
+        const node = parsedCache.getOrCreate(key, fx, (k, f) => {
+            const rs = new Restructure();
+            return rs.visit(parseExpression(f.toString()));
+        });
+        return this.transformUncached(node, target);
+    }
+
+    private static transformUncached(node: bpe.Node, target?: ParameterExpression) {
+
         if (node.type !== "ArrowFunctionExpression") {
             throw new Error("Expecting an arrow function");
         }
 
-        const firstParam = node.params[0];
-        if (firstParam.type !== "Identifier") {
-            throw new Error("Expecting an identifier");
-        }
+        const params = [] as ParameterExpression[];
 
-        const paramName = firstParam.name;
+        for (const iterator of node.params) {
+            if (iterator.type !== "Identifier") {
+                throw new Error("Expecting an identifier");
+            }
+            params.push(ParameterExpression.create({ name: iterator.name }));
+        }
 
         let body = node.body;
         if (body.type !== "ArrowFunctionExpression") {
@@ -33,13 +46,13 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
             throw new Error("Expecting an identifier");
         }
 
-        const target = firstTarget.name;
+        target ??= ParameterExpression.create({ name: firstTarget.name});
 
         body = body.body;
 
-        const visitor = new this(paramName, target);
+        const visitor = new this(params, target, firstTarget.name);
         return {
-            param: paramName,
+            params,
             target,
             body: visitor.visit(body)
         };
@@ -47,11 +60,24 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
 
     public readonly leftJoins: string[] = [];
 
+    private targetStack: Map<any,any> = new Map();
+
     protected constructor(
-        public param: string,
-        public target: string
+        public params: ParameterExpression[],
+        public target: ParameterExpression,
+        targetName: string
     ) {
         super();
+        this.targetStack.set("Sql", "Sql");
+        for (const iterator of params) {
+            this.targetStack.set(iterator.name, iterator);
+        }
+        if (targetName) {
+            this.targetStack.set(targetName, target);
+        }
+        if (target?.name) {
+            this.targetStack.set(target.name, target);
+        }
     }
 
     visitBigIntLiteral({ value }: bpe.BigIntLiteral) {
@@ -79,10 +105,24 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     visitTemplateLiteral(node: bpe.TemplateLiteral) {
-        const value = node.expressions.map((x) => this.visit(x));
+        // const value = node.expressions.map((x) => this.visit(x));
+        const value = [] as Expression[];
+        for (let index = 0; index < node.quasis.length; index++) {
+            const { value: { cooked }} = node.quasis[index];
+            if (cooked) {
+                value.push(StringLiteral.create({ value: cooked }));
+            }
+            if (index < node.expressions.length) {
+                value.push(this.visit(node.expressions[index]));
+            }
+        }
         return TemplateLiteral.create({ value });
     }
 
+    visitTemplateElement(node: bpe.TemplateElement): Expression {
+        throw new NotSupportedError();
+    }
+
     visitLogicalExpression(node: bpe.LogicalExpression): Expression {
         const left = this.visit(node.left);
         const right = this.visit(node.right);
@@ -100,6 +140,10 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
         return BinaryExpression.create({ left, operator, right });
     }
 
+    visitArrayExpression(node: bpe.ArrayExpression): Expression {
+        return Expression.array(node.elements.map((e) => this.visit(e)));
+    }
+
     visitBinaryExpression(node: bpe.BinaryExpression) {
         let operator = node.operator as string;
         switch(node.operator) {
@@ -122,7 +166,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
                 operator = "=";
                 break;
             default:
-                throw new Error(`Operator ${operator} not supported`);
+                throw new NotSupportedError(`Operator ${operator}`);
         }
         const left = this.visit(node.left);
         const right = this.visit(node.right);
@@ -130,6 +174,10 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     visitCallExpression({ callee, arguments: args }: bpe.CallExpression) {
+
+        // we need to sanitize callee
+        this.sanitize(callee);
+
         return CallExpression.create({
             callee: callee ? this.visit(callee) : void 0,
             arguments: args ? args.map((x) => this.visit(x)) : []
@@ -137,6 +185,10 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     visitIdentifier({ name: value }: bpe.Identifier): Expression {
+        const scopedName = this.targetStack.get(value);
+        if (typeof scopedName === "object") {
+            return scopedName;
+        }
         return Identifier.create({ value });
     }
 
@@ -150,11 +202,74 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): Expression {
-        const params = node.params.map((x) => this.visit(x));
+        const params = [] as ParameterExpression[];
+        const names = [];
+        for (const iterator of node.params) {
+            if (iterator.type !== "Identifier") {
+                throw new NotSupportedError();
+            }
+            names.push(iterator.name);
+            const p = ParameterExpression.create({ name: iterator.name });
+            this.targetStack.set(iterator.name, p);
+            params.push(p);
+        }
         const body = this.visit(node.body);
+        for (const name of names) {
+            this.targetStack.delete(name);
+        }
         return ArrowFunctionExpression.create({
             params,
             body
         });
     }
+
+    visitObjectExpression(node: bpe.ObjectExpression): Expression {
+        const properties = [] as ExpressionAs[];
+        for (const iterator of node.properties) {
+            switch(iterator.type) {
+                case "ObjectProperty":
+                    switch(iterator.key.type) {
+                        case "Identifier":
+                            properties.push( ExpressionAs.create({
+                                alias: QuotedLiteral.create({ literal: iterator.key.name}),
+                                expression: this.visit(iterator.value)
+                            }) );
+                            break;
+                        default:
+                            throw new NotSupportedError();
+                    }
+                    continue;
+                default:
+                    throw new NotSupportedError();
+            }
+        }
+        return NewObjectExpression.create({
+            properties
+        });
+    }
+
+    visitConditionalExpression(node: bpe.ConditionalExpression): Expression {
+        return ConditionalExpression.create({
+            test: this.visit(node.test),
+            consequent: this.visit(node.consequent),
+            alternate: this.visit(node.alternate)
+        });
+    }
+
+    private sanitize(node: bpe.Expression | bpe.V8IntrinsicIdentifier) {
+        switch(node.type) {
+            case "Identifier":
+                const name = node.name;
+                const scopedName = this.targetStack.get(name);
+                if (scopedName === null || scopedName === void 0) {
+                    throw new Error(`Unknown identifier ${name}`);
+                }
+                return;
+            case "MemberExpression":
+            case "OptionalMemberExpression":
+                return this.sanitize(node.object);
+        }
+        throw new Error(`Unexpected expression type ${node.type}`);
+    }
+
 }

package/src/query/parser/BabelVisitor.ts

@@ -1,9 +1,9 @@
 import * as bp from "@babel/parser";
 import * as bpe from "@babel/types";
 
-export class BabelVisitor<T> {
-    visit(nodeAny: bpe.Expression | bpe.Node): T {
-        const node = nodeAny as bpe.Expression;
+export abstract class BabelVisitor<T> {
+    visit(node: bpe.Expression | bpe.Node): T {
+        // const node = nodeAny as bpe.Expression;
         switch (node.type) {
             case "BinaryExpression":
                 return this.visitBinaryExpression(node);
@@ -33,54 +33,42 @@ export class BabelVisitor<T> {
                 return this.visitIdentifier(node);
             case "MemberExpression":
                 return this.visitMemberExpression(node);
+            case "ObjectExpression":
+                return this.visitObjectExpression(node);
+            case "ObjectProperty":
+                return this.visitObjectProperty(node);
+            case "TemplateElement":
+                return this.visitTemplateElement(node);
+            case "ArrayExpression":
+                return this.visitArrayExpression(node);
             case "RegExpLiteral":
             default:
                 throw new Error(`Translation from ${node.type} not supported`);
         }
     }
-    visitMemberExpression(node: bpe.MemberExpression): T {
-        return;
+    visitArrayExpression(node: bpe.ArrayExpression): T {
+        throw new Error("Method not implemented.");
     }
-    visitLogicalExpression(node: bpe.LogicalExpression): T {
-        return;
-    }
-    visitIdentifier(node: bpe.Identifier): T {
-        return;
-    }
-    visitTemplateLiteral(node: bpe.TemplateLiteral): T {
-        return;
-    }
-    visitNumericLiteral(node: bpe.NumericLiteral): T {
-        return;
-    }
-    visitDecimalLiteral(node: bpe.DecimalLiteral): T {
-        return;
-    }
-    visitBooleanLiteral(node: bpe.BooleanLiteral): T {
-        return;
-    }
-    visitBigIntLiteral(node: bpe.BigIntLiteral): T {
-        return;
-    }
-    visitStringLiteral(node: bpe.StringLiteral): T {
-        return;
-    }
-    visitNullLiteral(node: bpe.NullLiteral): T {
-        return;
-    }
-    visitConditionalExpression(node: bpe.ConditionalExpression): T {
-        return;
+    abstract visitTemplateElement(node: bpe.TemplateElement): T;
+    visitObjectProperty(node: bpe.ObjectProperty): T {
+        throw new Error("Method not implemented.");
     }
+    abstract visitObjectExpression(node: bpe.ObjectExpression): T;
+    abstract visitMemberExpression(node: bpe.MemberExpression): T;
+    abstract visitLogicalExpression(node: bpe.LogicalExpression): T;
+    abstract visitIdentifier(node: bpe.Identifier): T;
+    abstract visitTemplateLiteral(node: bpe.TemplateLiteral): T;
+    abstract visitNumericLiteral(node: bpe.NumericLiteral): T;
+    abstract visitDecimalLiteral(node: bpe.DecimalLiteral): T;
+    abstract visitBooleanLiteral(node: bpe.BooleanLiteral): T;
+    abstract visitBigIntLiteral(node: bpe.BigIntLiteral): T;
+    abstract visitStringLiteral(node: bpe.StringLiteral): T;
+    abstract visitNullLiteral(node: bpe.NullLiteral): T;
+    abstract visitConditionalExpression(node: bpe.ConditionalExpression): T;
 
-    visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): T {
-        return;
-    }
+    abstract visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): T;
 
-    visitCallExpression(node: bpe.CallExpression): T {
-        return;
-    }
+    abstract visitCallExpression(node: bpe.CallExpression): T;
 
-    visitBinaryExpression(node: bpe.BinaryExpression): T {
-        return;
-    }
+    abstract visitBinaryExpression(node: bpe.BinaryExpression): T;
 }

package/src/query/parser/NotSupportedError.ts

@@ -0,0 +1,5 @@
+export class NotSupportedError extends Error {
+    constructor(message?: string) {
+        super(message ? `${message} Not Supported`: "Not Supported");
+    }
+}

package/src/query/parser/Restructure.ts

@@ -0,0 +1,66 @@
+import * as bpe from "@babel/types";
+import { BabelVisitor } from "./BabelVisitor.js";
+import { NotSupportedError } from "./NotSupportedError.js";
+import TransformVisitor from "./TransformVisitor.js";
+
+export default class Restructure extends TransformVisitor {
+
+    private map: Map<string, bpe.Node> = new Map();
+
+    visitTemplateElement(node: bpe.TemplateElement): bpe.Node {
+        return node;
+    }
+
+    visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): bpe.Node {
+
+        // we need to restructure identifiers from destructure
+
+        node.params = node.params.map((x) => this.toIdentifier(x));
+
+        node.body = this.visit(node.body) as bpe.Expression;
+
+        return node;
+    }
+
+    visitIdentifier(node: bpe.Identifier): bpe.Node {
+        return this.map.get(node.name) ?? node;
+    }
+
+    toIdentifier(x: bpe.Identifier | bpe.Pattern | bpe.RestElement): bpe.Identifier {
+        switch(x.type) {
+            case "Identifier":
+                return x;
+            case "ObjectPattern":
+                const id = `x${this.map.size + 1}`;
+                const idExp = bpe.identifier(id);
+                this.convertPattern(idExp, x);
+                return idExp;
+            case "ArrayPattern":
+            case "AssignmentPattern":
+            case "RestElement":
+                throw new NotSupportedError();
+        }
+    }
+
+    convertPattern(parentExp: bpe.Expression, x: bpe.ObjectPattern) {
+        for (const iterator of x.properties) {
+            switch(iterator.type) {
+                case "RestElement":
+                    throw new NotSupportedError();
+                case "ObjectProperty":
+                    switch(iterator.key.type){
+                        case "Identifier":
+                            const childExp = bpe.memberExpression(parentExp, iterator.key);
+                            this.map.set(iterator.key.name, childExp);
+                            switch(iterator.value.type) {
+                                case "ObjectPattern":
+                                    this.convertPattern(childExp, iterator.value);
+                                    break;
+                            }
+                        break;
+                    }
+            }
+        }
+    }
+
+}

package/src/query/parser/TransformVisitor.ts

@@ -0,0 +1,83 @@
+import * as bpe from "@babel/types";
+import { BabelVisitor } from "./BabelVisitor.js";
+
+export default class TransformVisitor extends BabelVisitor<bpe.Node> {
+
+    transform<T>(n:T) {
+        if (!n) {
+            return n;
+        }
+        if (Array.isArray(n)) {
+            return n.map((x) => this.transform(x));
+        }
+        return this.visit(n as any);
+    }
+
+    visitTemplateElement(node: bpe.TemplateElement): bpe.Node {
+        return node;
+    }
+
+    visitObjectExpression(node: bpe.ObjectExpression): bpe.Node {
+        return bpe.objectExpression(
+            this.transform(node.properties)
+        );
+    }
+    visitMemberExpression(node: bpe.MemberExpression): bpe.Node {
+        return bpe.memberExpression(this.transform(node.object), this.transform(node.property), node.computed, node.optional);
+    }
+    visitLogicalExpression(node: bpe.LogicalExpression): bpe.Node {
+        return bpe.logicalExpression(node.operator, this.transform(node.left), this.transform(node.right));
+    }
+    visitIdentifier(node: bpe.Identifier): bpe.Node {
+        return node;
+    }
+    visitTemplateLiteral(node: bpe.TemplateLiteral): bpe.Node {
+        return bpe.templateLiteral(this.transform(node.quasis), this.transform(node.expressions));
+    }
+    visitNumericLiteral(node: bpe.NumericLiteral): bpe.Node {
+        return node;
+    }
+    visitDecimalLiteral(node: bpe.DecimalLiteral): bpe.Node {
+        return node;
+    }
+    visitBooleanLiteral(node: bpe.BooleanLiteral): bpe.Node {
+        return node;
+    }
+    visitBigIntLiteral(node: bpe.BigIntLiteral): bpe.Node {
+        return node;
+    }
+    visitStringLiteral(node: bpe.StringLiteral): bpe.Node {
+        return node;
+    }
+    visitNullLiteral(node: bpe.NullLiteral): bpe.Node {
+        return node;
+    }
+    visitConditionalExpression(node: bpe.ConditionalExpression): bpe.Node {
+        return bpe.conditionalExpression(
+            this.transform(node.test),
+            this.transform(node.consequent),
+            this.transform(node.alternate));
+    }
+    visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): bpe.Node {
+        return bpe.arrowFunctionExpression(this.transform(node.params), this.transform(node.body), node.async);
+    }
+    visitCallExpression(node: bpe.CallExpression): bpe.Node {
+        return bpe.callExpression(this.transform(node.callee), this.transform(node.arguments));
+    }
+    visitBinaryExpression(node: bpe.BinaryExpression): bpe.Node {
+        return bpe.binaryExpression(node.operator, this.transform(node.left), this.transform(node.right));
+    }
+
+    visitObjectProperty(node: bpe.ObjectProperty): bpe.Node {
+
+        let key = node.key;
+        if (node.key.type !== "Identifier") {
+            key = this.transform(key);
+        }
+
+        const value = this.transform(node.value);
+
+        return bpe.objectProperty(key, value, node.computed, node.shorthand, node.decorators);
+    }
+
+}

package/src/sql/ISql.ts

@@ -2,6 +2,16 @@ export interface ISql {
 
     in<T>(a: T, array: T[]): boolean;
 
+    cast: {
+        asNumber(a: any): number;
+        asInteger(a: any): number;
+        asBigInt(a: any): number;
+        asText(a: any): string;
+        asDate(a: any): Date;
+        asDateTime(a: any): Date;
+        asDecimal(a: any): number;
+    }
+
     text: {
         concat(... fragments: string[]): string;
         like(text: string, test: string): boolean;

package/src/tests/db-tests/tests/select-items.ts

@@ -34,4 +34,16 @@ export default async function(this: TestConfig) {
     allHeadphones = await context.products.where({ headPhoneCategory }, (p) => (x) => x.categories.some((pc) => pc.categoryID === p.headPhoneCategory)).count();
 
     assert.equal(6, allHeadphones);
+
+    const first = await context.productCategories.where({ headPhoneCategory }, (p) => (x) => x.category.categoryID === p.headPhoneCategory).first();
+
+    // delete first one...
+    context.products.delete(first);
+
+    await context.saveChanges();
+
+    allHeadphones = await context.products.where({ headPhoneCategory }, (p) => (x) => x.categories.some((pc) => pc.categoryID === p.headPhoneCategory)).count();
+
+    assert.equal(5, allHeadphones);
+
 }

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

@@ -5,48 +5,64 @@ import { assertSqlMatch, trimInternal } from "../trimInternal.js";
 import PostgreSqlDriver from "../../../drivers/postgres/PostgreSqlDriver.js";
 
 const sql1 = `SELECT
-    "P1"."productID",
-    "P1"."name",
-    "P1"."ownerID"
-FROM "Products" AS "P1"
-WHERE
-    EXISTS (SELECT
-                $1 AS "o1"
-        FROM "OrderItems" AS "O0"
-        WHERE 
-            ("P1"."productID" = "O0"."productID")
-            AND ("O0"."productID" = $2)
-            )
-        `;
+"p1"."productID",
+"p1"."name",
+"p1"."ownerID",
+"p1"."status"
+FROM "Products" AS "p1"
+WHERE EXISTS (SELECT
+1
+FROM "OrderItems" AS "o"
+WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $1))`;
 
 const sql2 = `SELECT
-"P1"."productID","P1"."name","P1"."ownerID"
-FROM "Products" AS "P1"
+"p1"."productID",
+"p1"."name",
+"p1"."ownerID",
+"p1"."status"
+FROM "Products" AS "p1"
 WHERE EXISTS (SELECT
-$1 AS "o1"
-FROM "OrderItems" AS "O0"
-WHERE ("P1"."productID" = "O0"."productID") AND ("O0"."productID" = $2)) AND EXISTS (SELECT
-$3 AS "o1"
-FROM "OrderItems" AS "O1"
-WHERE ("P1"."productID" = "O1"."productID") AND ("O1"."amount" > $4))`;
+1
+FROM "OrderItems" AS "o"
+WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $1)) AND EXISTS (SELECT
+1
+FROM "OrderItems" AS "o1"
+WHERE ("p1"."productID" = "o1"."productID") AND ("o1"."amount" > $2))`;
 
 const sql3 = `SELECT
-"P1"."productID","P1"."name","P1"."ownerID"
-FROM "Products" AS "P1"
+"p1"."productID",
+"p1"."name",
+"p1"."ownerID",
+"p1"."status"
+FROM "Products" AS "p1"
 WHERE EXISTS (SELECT
-$1 AS "o1"
-FROM "OrderItems" AS "O0"
-WHERE ("P1"."productID" = "O0"."productID") AND ("O0"."productID" = $2)) AND EXISTS (SELECT
-$3 AS "o1"
-FROM "OrderItems" AS "O1"
- INNER JOIN "Orders" AS "O2" ON "O1"."orderID" = "O2"."orderID"
-WHERE ("P1"."productID" = "O1"."productID") AND ("O2"."orderDate" > $4))`;
+1
+FROM "OrderItems" AS "o"
+WHERE ("p1"."productID" = "o"."productID") AND ("o"."productID" = $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))`;
 
 const productJoin = `SELECT
-"P1"."productID","P1"."name","P1"."ownerID"
-FROM "Products" AS "P1"
- LEFT JOIN "Users" AS "U0" ON "P1"."ownerID" = "U0"."userID"
-WHERE "U0"."dateCreated" > $1`;
+"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`;
+
+
+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)`;
 
 export default function() {
 
@@ -68,4 +84,8 @@ export default function() {
     query = context.products.where({ date: new Date()}, (p) => (x) => x.owner.dateCreated > p.date);
     r = query.toQuery();
     assertSqlMatch(productJoin, r.text);
+
+    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);
 }

package/src/tests/expressions/sanitize/sanitize-test.ts

@@ -0,0 +1,17 @@
+import assert from "assert";
+import QueryCompiler from "../../../compiler/QueryCompiler.js";
+
+declare let pg_kill: any;
+
+export default function () {
+
+    const compiler = QueryCompiler.instance;
+
+    const name = "Akash";
+
+    assert.throws(()=>
+        compiler.execute({ name }, (p) => (x) => pg_kill(9))
+    );
+
+
+}

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

@@ -0,0 +1,24 @@
+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 };
+
+export default function() {
+
+
+    const compiler = QueryCompiler.instance;
+
+    const name = "Akash";
+
+    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);
+
+    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);
+
+}