@entity-access/entity-access 1.0.2 → 1.0.5

package/src/query/ast/Expressions.ts

@@ -1,7 +1,7 @@
-import { IColumn } from "../../decorators/IColumn.js";
 import { IClassOf } from "../../decorators/IClassOf.js";
-import { ITextOrFunctionArray } from "./IStringTransformer.js";
+import { ITextQuery } from "./IStringTransformer.js";
 import type EntityType from "../../entity-query/EntityType.js";
+import DebugStringVisitor from "./DebugStringVisitor.js";
 
 const flattenedSelf = Symbol("flattenedSelf");
 
@@ -24,9 +24,64 @@ const flattenedSelf = Symbol("flattenedSelf");
 
 export abstract class Expression {
 
+    static as(expression: Expression, alias: QuotedLiteral | string) {
+        if (typeof alias === "string") {
+            alias = Expression.quotedLiteral(alias);
+        }
+        return ExpressionAs.create({
+            expression,
+            alias
+        });
+    }
+
+    static templateLiteral(value: Expression[]) {
+        return TemplateLiteral.create({ value });
+    }
+
+
+    static constant(value: string) {
+        return Constant.create({ value });
+    }
+
+    static quotedLiteral(name: string) {
+        return QuotedLiteral.create({ literal: name });
+    }
+
+    static parameter(name: string) {
+        return ParameterExpression.create({ name });
+    }
+
+    static identifier(name: string) {
+        return Identifier.create({ value: name });
+    }
+
+    static logicalAnd(left: Expression, right: Expression): BinaryExpression {
+        return BinaryExpression.create({ left, operator: "AND", right});
+    }
+
+    static member(target: Expression, identifier: string |Expression): MemberExpression {
+        return MemberExpression.create({
+            target,
+            property: typeof identifier === "string"
+                ? this.identifier(identifier)
+                : identifier
+        });
+    }
+
+    static equal(left: Expression, right: Expression) {
+        return BinaryExpression.create({ left, right, operator: "="});
+    }
+
     static create<T extends Expression>(this: IClassOf<T>, p: Partial<Omit<T, "type">>) {
         (p as any).type = (this as any).name;
         Object.setPrototypeOf(p, this.prototype);
+        Object.defineProperty(p, "debugView", {
+            get() {
+                return DebugStringVisitor.expressionToString(this);
+            },
+            enumerable: true,
+            configurable: true
+        });
         return p as T;
     }
 
@@ -68,9 +123,9 @@ export abstract class Expression {
 
 }
 
-export class PlaceholderExpression extends Expression {
-    readonly type = "PlaceholderExpression";
-    expression: () => ITextOrFunctionArray;
+export class PartialExpression extends Expression {
+    readonly type = "PartialExpression";
+    query: ITextQuery;
 }
 
 export class BinaryExpression extends Expression {
@@ -112,6 +167,21 @@ export class CallExpression extends Expression {
     arguments: Expression[];
 }
 
+export class ParameterExpression extends Expression {
+    readonly type = "ParameterExpression";
+    name: string;
+    /**
+     * Default value if any...
+     */
+    value: any;
+
+    quotedLiteral: (x: string) => string;
+
+    toString() {
+        return this.quotedLiteral?.(this.name) ?? this.name;
+    }
+}
+
 export class MemberExpression extends Expression {
     readonly type = "MemberExpression";
     target: Expression;
@@ -121,7 +191,7 @@ export class MemberExpression extends Expression {
 
 export class ArrowFunctionExpression extends Expression {
     readonly type = "ArrowFunctionExpression";
-    params: Expression[];
+    params: ParameterExpression[];
     body: Expression;
 }
 
@@ -131,9 +201,9 @@ export class SelectStatement extends Expression {
 
     readonly type = "SelectStatement";
 
-    source: TableSource;
+    source: TableSource | ValuesStatement;
 
-    as: QuotedLiteral;
+    as: ParameterExpression;
 
     fields: (Expression | QuotedLiteral | ExpressionAs)[];
 
@@ -147,13 +217,30 @@ export class SelectStatement extends Expression {
 
     offset: number;
 
+    // name holds string
+    names: string;
+
+    model: EntityType;
+
+}
+
+export class NewObjectExpression extends Expression {
+    readonly type = "NewObjectExpression";
+    properties: ExpressionAs[];
+}
+
+export class ConditionalExpression extends Expression {
+    readonly type = "ConditionalExpression";
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
 }
 
 export class JoinExpression extends Expression {
     readonly type = "JoinExpression";
     joinType: "LEFT" | "INNER";
     source: SelectStatement | QuotedLiteral | ExpressionAs;
-    as: QuotedLiteral;
+    as: QuotedLiteral | ParameterExpression;
     where: Expression;
     model: EntityType;
 }
@@ -200,8 +287,17 @@ export class BigIntLiteral extends Expression {
     public value: bigint;
 }
 
+export class TemplateElement extends Expression {
+    readonly type = "TemplateElement";
+    public value: {
+        raw: string;
+        cooked: string;
+    };
+}
+
 export class TemplateLiteral extends Expression {
     readonly type = "TemplateLiteral";
+    public quasis: TemplateElement[];
     public value: Expression[];
 }
 
@@ -260,7 +356,7 @@ export class UpdateStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral;
+    table: TableLiteral | QuotedLiteral;
     where: Expression;
 }
 
@@ -289,6 +385,9 @@ export type ExpressionType =
     CoalesceExpression|
     ExistsExpression|
     Identifier |
-    PlaceholderExpression|
-    ArrowFunctionExpression
+    ArrowFunctionExpression |
+    ConditionalExpression |
+    NewObjectExpression |
+    ParameterExpression |
+    TemplateElement
 ;

package/src/query/ast/IStringTransformer.ts

@@ -1,10 +1,22 @@
-export type ITextOrFunction = string | ((p: any) => any);
-export type ITextOrFunctionArray = ITextOrFunction[];
+export type ITextQueryFragment = string | ((p: any) => any) | { toString(): string };
+export type ITextQuery = ITextQueryFragment[];
 
 export type IStringTransformer = (s: string) => string;
 
 export type ISqlMethodTransformer = (callee: string, args: string[]) => string;
 
+export class QueryParameter {
+
+    static create(name: () => string, quotedLiteral: (n: string) => string ) {
+        return new QueryParameter(name, quotedLiteral);
+    }
+
+    constructor(public name: () => string, public quotedLiteral: (n: string) => string) {}
+
+    toString() {
+        return this.quotedLiteral(this.name());
+    }
+}
 
 export const prepareAny = (a: TemplateStringsArray, ... p: any[]): any => {
     const r = [];
@@ -46,7 +58,7 @@ const addNonEmptyFlat = (array: any[], item: any) => {
     array.push(item);
 };
 
-export const prepare = (a: TemplateStringsArray, ... p: (ITextOrFunction | ITextOrFunctionArray)[]): ITextOrFunctionArray => {
+export const prepare = (a: TemplateStringsArray, ... p: (ITextQueryFragment | ITextQuery)[]): ITextQuery => {
 
     const r = [];
     for (let index = 0; index < a.length; index++) {
@@ -60,7 +72,7 @@ export const prepare = (a: TemplateStringsArray, ... p: (ITextOrFunction | IText
     return r.flat(2);
 };
 
-export const prepareJoin = (a: (ITextOrFunction | ITextOrFunctionArray)[], sep: string = ","): ITextOrFunctionArray => {
+export const prepareJoin = (a: (ITextQueryFragment | ITextQuery)[], sep: string = ","): ITextQuery => {
     const r = [];
     let first = true;
     for (const iterator of a) {

package/src/query/ast/ReplaceParameter.ts

@@ -0,0 +1,40 @@
+import { Expression } from "@babel/types";
+
+export default class ReplaceParameter {
+
+    public static replace(tree: Expression | Expression[], from: Expression, to: Expression) {
+        if (!tree) {
+            return tree;
+        }
+        if (tree === from) {
+            return to;
+        }
+        if (Array.isArray(tree)) {
+            const copy = [];
+            let index = 0;
+            for (const iterator of tree) {
+                Object.defineProperty(copy, index++, {
+                    value: this.replace(iterator, from, to),
+                    writable: false,
+                    enumerable: true
+                });
+            }
+            return tree;
+        }
+        if (!(tree as any).type) {
+            return tree;
+        }
+        const treeCopy = {};
+        for (const key in tree) {
+            if (Object.prototype.hasOwnProperty.call(tree, key)) {
+                const element = tree[key];
+                Object.defineProperty(treeCopy, key, {
+                    value: this.replace(element, from, to)
+                });
+            }
+        }
+        Object.setPrototypeOf(treeCopy, Object.getPrototypeOf(tree));
+        return treeCopy;
+    }
+
+}

package/src/query/ast/Visitor.ts

@@ -1,4 +1,4 @@
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NullExpression, NumberLiteral, OrderByExpression, PlaceholderExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -56,18 +56,33 @@ export default abstract class Visitor<T = any> {
                 return this.visitCoalesceExpression(e);
             case "ExistsExpression":
                 return this.visitExistsExpression(e);
-            case "PlaceholderExpression":
-                return this.visitPlaceholderExpression(e);
             case "ArrowFunctionExpression":
                 return this.visitArrowFunctionExpression(e);
+            case "ConditionalExpression":
+                return this.visitConditionalExpression(e);
+            case "NewObjectExpression":
+                return this.visitNewObjectExpression(e);
+            case "TemplateElement":
+                return this.visitTemplateElement(e);
+            case "ParameterExpression":
+                return this.visitParameterExpression(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
-    visitArrowFunctionExpression(e: ArrowFunctionExpression): T {
+    visitParameterExpression(e: ParameterExpression): T {
+        return;
+    }
+    visitTemplateElement(e: TemplateElement): T {
+        return;
+    }
+    visitNewObjectExpression(e: NewObjectExpression): T {
+        return;
+    }
+    visitConditionalExpression(e: ConditionalExpression): T {
         return;
     }
-    visitPlaceholderExpression(e: PlaceholderExpression): T {
+    visitArrowFunctionExpression(e: ArrowFunctionExpression): T {
         return;
     }
     visitExistsExpression(e: ExistsExpression): T {

package/src/query/parser/ArrowToExpression.ts

@@ -1,27 +1,34 @@
 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";
 
 type IQueryFragment = string | { name?: string, value?: any };
 type IQueryFragments = IQueryFragment[];
 
 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 rs = new Restructure();
+
+        const node = rs.visit(parseExpression(fx.toString()));
         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 +40,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 +54,19 @@ 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);
+        }
+        this.targetStack.set(targetName ?? target.name, target);
     }
 
     visitBigIntLiteral({ value }: bpe.BigIntLiteral) {
@@ -79,10 +94,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);
@@ -122,7 +151,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 +159,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 +170,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 +187,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({ value: 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,37 @@ 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 "RegExpLiteral":
             default:
                 throw new Error(`Translation from ${node.type} not supported`);
         }
     }
-    visitMemberExpression(node: bpe.MemberExpression): T {
-        return;
-    }
-    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");
+    }
+}