@entity-access/entity-access 1.0.2 → 1.0.6

package/src/query/ast/Expressions.ts

@@ -1,7 +1,8 @@
-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";
+import { IEntityRelation } from "../../decorators/IColumn.js";
 
 const flattenedSelf = Symbol("flattenedSelf");
 
@@ -24,9 +25,68 @@ const flattenedSelf = Symbol("flattenedSelf");
 
 export abstract class Expression {
 
+    static array(elements: Expression[]) {
+        return ArrayExpression.create({ elements });
+    }
+
+    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 +128,14 @@ export abstract class Expression {
 
 }
 
-export class PlaceholderExpression extends Expression {
-    readonly type = "PlaceholderExpression";
-    expression: () => ITextOrFunctionArray;
+export class ArrayExpression extends Expression {
+    readonly type = "ArrayExpression";
+    elements: Expression[];
+}
+
+export class PartialExpression extends Expression {
+    readonly type = "PartialExpression";
+    query: ITextQuery;
 }
 
 export class BinaryExpression extends Expression {
@@ -112,6 +177,26 @@ export class CallExpression extends Expression {
     arguments: Expression[];
 }
 
+export class ParameterExpression extends Expression {
+    readonly type = "ParameterExpression";
+    name: string;
+    /**
+     * Default value if any...
+     */
+    value: any;
+
+    /**
+     * Entity Model representing the variable
+     */
+    model: EntityType;
+
+    quotedLiteral: (x: string) => string;
+
+    toString() {
+        return this.quotedLiteral?.(this.name) ?? this.name;
+    }
+}
+
 export class MemberExpression extends Expression {
     readonly type = "MemberExpression";
     target: Expression;
@@ -121,19 +206,21 @@ export class MemberExpression extends Expression {
 
 export class ArrowFunctionExpression extends Expression {
     readonly type = "ArrowFunctionExpression";
-    params: Expression[];
+    params: ParameterExpression[];
     body: Expression;
 }
 
 export type TableSource = SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
 
+export type Expand = { [key: string]: string | Expand };
+
 export class SelectStatement extends Expression {
 
     readonly type = "SelectStatement";
 
-    source: TableSource;
+    source: TableSource | ValuesStatement;
 
-    as: QuotedLiteral;
+    as: ParameterExpression;
 
     fields: (Expression | QuotedLiteral | ExpressionAs)[];
 
@@ -147,13 +234,30 @@ export class SelectStatement extends Expression {
 
     offset: number;
 
+    model: EntityType;
+
+    // include  relations...
+    include: SelectStatement[];
+
+}
+
+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;
+    source: SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
+    as: QuotedLiteral | ParameterExpression;
     where: Expression;
     model: EntityType;
 }
@@ -200,8 +304,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 +373,7 @@ export class UpdateStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral;
+    table: TableLiteral | QuotedLiteral;
     where: Expression;
 }
 
@@ -289,6 +402,10 @@ export type ExpressionType =
     CoalesceExpression|
     ExistsExpression|
     Identifier |
-    PlaceholderExpression|
-    ArrowFunctionExpression
+    ArrowFunctionExpression |
+    ConditionalExpression |
+    NewObjectExpression |
+    ParameterExpression |
+    ArrayExpression |
+    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,12 +72,14 @@ 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) {
         if (!first) {
-            r.push(",");
+            if (sep) {
+                r.push(sep);
+            }
         }
         first = false;
         addNonEmptyFlat(r, iterator);

package/src/query/ast/ParameterScope.ts

@@ -0,0 +1,97 @@
+import type EntityType from "../../entity-query/EntityType.js";
+import type { ParameterExpression, SelectStatement } from "./Expressions.js";
+
+
+export interface IMappingModel {
+    parameter: ParameterExpression;
+    selectStatement?: SelectStatement;
+    name?: string;
+    model?: EntityType;
+    replace?: ParameterExpression;
+    isRuntimeParam?: boolean;
+}
+
+/**
+ * This class will provide scope for ever parameter along with type mapping, unique name and
+ * and replace parameter
+ */
+export default class ParameterScope {
+
+    private map:Map<ParameterExpression, IMappingModel> = new Map();
+
+    private names: Set<string> = new Set();
+
+    public get(p: ParameterExpression) {
+        const model = this.map.get(p);
+        return model;
+    }
+
+    public nameOf(p: ParameterExpression) {
+        const model = this.map.get(p);
+        return model.name;
+    }
+
+    public alias(
+        originalParameter: ParameterExpression,
+        alias: ParameterExpression,
+        selectStatement: SelectStatement
+    ) {
+        const model = this.map.get(originalParameter);
+        if (!model.selectStatement) {
+            model.selectStatement = selectStatement;
+        } else {
+            selectStatement = model.selectStatement;
+        }
+        return this.create({ parameter: alias, selectStatement, name: model.name, replace: originalParameter });
+    }
+
+    create(model: IMappingModel) {
+
+        const existing = this.map.get(model.parameter);
+        if (existing) {
+            existing.replace = model.replace;
+            existing.selectStatement = model.selectStatement;
+            existing.model ??= existing.selectStatement.model;
+            return;
+        }
+
+        if (!model.replace) {
+            // create name...
+            model.name = this.createName(model.parameter.model?.name?.[0] ?? model.parameter.name, model.parameter.name );
+        }
+
+        if (!model.model) {
+            if (model.parameter.model) {
+                model.model = model.parameter.model;
+            } else if (model.selectStatement){
+                model.model = model.selectStatement.model;
+            }
+        }
+
+        this.map.set(model.parameter, model);
+    }
+    createName(prefix: string, name?: string): string {
+        if (name) {
+            name = name.toLocaleLowerCase();
+            if (!this.names.has(name)) {
+                this.names.add(name);
+                return name;
+            }
+        }
+        let index = 1;
+        prefix = prefix.toLocaleLowerCase();
+        while(true) {
+            name = `${prefix}${index++}`;
+            if (this.names.has(name)) {
+                continue;
+            }
+            this.names.add(name);
+            return name;
+        }
+    }
+
+    delete(param1: ParameterExpression) {
+        // this.map.delete(param1);
+    }
+
+}

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,5 @@
-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 { 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, 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 +57,38 @@ 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);
+            case "ArrayExpression":
+                return this.visitArrayExpression(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
-    visitArrowFunctionExpression(e: ArrowFunctionExpression): T {
+    visitArrayExpression(e: ArrayExpression): T {
+        throw new NotSupportedError("Array Expression");
+    }
+    visitParameterExpression(e: ParameterExpression): T {
         return;
     }
-    visitPlaceholderExpression(e: PlaceholderExpression): T {
+    visitTemplateElement(e: TemplateElement): T {
+        return;
+    }
+    visitNewObjectExpression(e: NewObjectExpression): T {
+        return;
+    }
+    visitConditionalExpression(e: ConditionalExpression): T {
+        return;
+    }
+    visitArrowFunctionExpression(e: ArrowFunctionExpression): T {
         return;
     }
     visitExistsExpression(e: ExistsExpression): T {

package/src/query/expander/QueryExpander.ts

@@ -0,0 +1,147 @@
+import EntityType from "../../entity-query/EntityType.js";
+import EntityContext from "../../model/EntityContext.js";
+import EntityQuery from "../../model/EntityQuery.js";
+import { ArrowFunctionExpression, ExistsExpression, Expression, ExpressionType, JoinExpression, ParameterExpression, SelectStatement, TableSource } from "../ast/Expressions.js";
+import ArrowToExpression from "../parser/ArrowToExpression.js";
+import { NotSupportedError } from "../parser/NotSupportedError.js";
+
+export class QueryExpander {
+    static expand(context: EntityContext, select: SelectStatement, p) {
+        const qe = new QueryExpander(context, select);
+        const expression = ArrowToExpression.transform(`(_____________________x) => ${p}` as any);
+        qe.expandNode(select, select.model, expression.body as ExpressionType);
+        return select;
+    }
+
+    constructor(
+        private context: EntityContext,
+        private select: SelectStatement
+    ) {
+
+    }
+
+    expandNode(parent: SelectStatement, model: EntityType, node: ExpressionType): [SelectStatement, EntityType] {
+
+        if (node.type === "ArrayExpression") {
+            for (const iterator of node.elements) {
+                this.expandNode(parent, model,  iterator as ExpressionType);
+            }
+            return;
+        }
+
+        if(node.type === "CallExpression") {
+            const callee = node.callee as ExpressionType;
+            if (callee.type !== "MemberExpression") {
+                throw new NotSupportedError(callee.type);
+            }
+            const property = callee.property as ExpressionType;
+            if (property.type !== "Identifier") {
+                throw new NotSupportedError(property.type);
+            }
+            if (property.value !== "forEach") {
+                throw new NotSupportedError(property.value);
+            }
+            const [expandedSelect, expandedType] = this.expandNode(parent, model, callee.target as ExpressionType);
+
+            const arrow = node.arguments[0];
+            if (!arrow || arrow.type !== "ArrowFunctionExpression") {
+                throw new NotSupportedError(arrow?.type ?? "Empty Expression");
+            }
+            this.expandNode(expandedSelect, expandedType, (arrow as ArrowFunctionExpression).body as ExpressionType);
+            return [expandedSelect, expandedType];
+        }
+
+        if (node.type !== "MemberExpression") {
+            throw new NotSupportedError(node.type);
+        }
+
+        const p = node.property as ExpressionType;
+        if (p.type !== "Identifier") {
+            throw new NotSupportedError(p.type);
+        }
+
+        const target = node.target as ExpressionType;
+        if (target.type === "MemberExpression") {
+            const [mepSelect, mepType] = this.expandNode(parent, model, target);
+            parent = mepSelect;
+            model = mepType;
+        }
+
+        const mp = model.getProperty(p.value);
+        if (!mp.relation) {
+            throw new NotSupportedError(`No relation found ${p.value} in ${model.name}`);
+        }
+        const { relation } = mp;
+        const { relatedTypeClass: propertyType } = relation;
+
+        let query = this.context.query(propertyType);
+        const events = this.context.eventsFor(propertyType, false);
+        if (events) {
+            query = events.includeFilter(query, model, p.value) ?? query;
+        }
+        const select = { ... (query as EntityQuery).selectStatement };
+
+        let where: Expression;
+        let joinWhere: Expression;
+
+        const fk = relation.fkColumn ?? relation.relatedRelation.fkColumn;
+
+
+        if(relation.isInverseRelation) {
+
+            joinWhere = Expression.equal(
+                Expression.member(
+                    parent.as,
+                    Expression.quotedLiteral(fk.columnName)
+                ),
+                Expression.member(
+                    select.as,
+                    Expression.quotedLiteral(model.keys[0].columnName)
+                )
+            );
+            // load parent..
+            where = parent.where
+                ? Expression.logicalAnd(joinWhere, parent.where)
+                : joinWhere;
+
+            const joins = (select.joins ??= []);
+            joins.push(JoinExpression.create({
+                source: parent.source as TableSource,
+                as: parent.as,
+                model,
+                where
+            }));
+            (this.select.include ??= []).push(select);
+            return [select, relation.relatedEntity];
+        }
+
+        joinWhere = Expression.equal(
+            Expression.member(
+                parent.as,
+                Expression.quotedLiteral(fk.columnName)
+            ),
+            Expression.member(
+                select.as,
+                Expression.quotedLiteral(relation.relatedEntity.keys[0].columnName)
+            )
+        );
+
+        parent = { ... parent };
+
+        parent.where = parent.where
+            ? Expression.logicalAnd(parent.where, joinWhere)
+            : joinWhere;
+
+        const existsWhere = ExistsExpression.create({
+            target: parent
+        });
+
+        select.where = select.where
+            ? Expression.logicalAnd(select.where, existsWhere)
+            : existsWhere;
+
+        (this.select.include ??= []).push(select);
+
+        return [select, relation.relatedEntity];
+    }
+}