@entity-access/entity-access 1.0.1

package/src/query/ast/Expressions.ts

@@ -0,0 +1,294 @@
+import { IColumn } from "../../decorators/IColumn.js";
+import { IClassOf } from "../../decorators/IClassOf.js";
+import { ITextOrFunctionArray } from "./IStringTransformer.js";
+import type EntityType from "../../entity-query/EntityType.js";
+
+const flattenedSelf = Symbol("flattenedSelf");
+
+/**
+ * The reason we are using our own Expression type is to keep
+ * our expressions small and independent of JavaScript ESTree style.
+ *
+ * Reason is simple, our visitor pattern can be small and can stay
+ * independent of any other extra expression types.
+ *
+ * We will cache our expressions, to avoid parsing them multiple times.
+ * Our expressions do not need to store exact line numbers, comments,
+ * extra annotations. We can add some shortcut optimizations which might
+ * not be possible with outer libraries unless they support it.
+ *
+ * In future, we might make our own expression parser as we only need
+ * handful of features to keep it small and faster. Or we can swap some
+ * other JavaScript parser without affecting our code generation process.
+ */
+
+export abstract class Expression {
+
+    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);
+        return p as T;
+    }
+
+    static clone<T extends Expression>(expression: T): T {
+        const r = {} as any;
+        Object.setPrototypeOf(r, Object.getPrototypeOf(expression));
+        for (const key in expression) {
+            if (Object.prototype.hasOwnProperty.call(expression, key)) {
+                const element = expression[key];
+                if(Array.isArray(element)) {
+                    r[key] = element.map((x) => this.clone(x));
+                } else {
+                    r[key] = element;
+                }
+            }
+        }
+        return r as T;
+    }
+
+    private static shallowCopy(expression, constants: Expression[]) {
+        const copy = {} as any;
+        for (const key in expression) {
+            if (Object.prototype.hasOwnProperty.call(expression, key)) {
+                const element = expression[key];
+                if (key === "type" || key === "is") {
+                    continue;
+                }
+                if (element instanceof Constant) {
+                    constants.push(element);
+                }
+                copy[key] = element;
+            }
+        }
+        Object.setPrototypeOf(copy, Object.getPrototypeOf(expression));
+        return copy;
+    }
+
+    readonly type: never | string;
+
+}
+
+export class PlaceholderExpression extends Expression {
+    readonly type = "PlaceholderExpression";
+    expression: () => ITextOrFunctionArray;
+}
+
+export class BinaryExpression extends Expression {
+
+    readonly type = "BinaryExpression";
+
+    left: Expression;
+    right: Expression;
+    operator: string;
+}
+
+export class CoalesceExpression extends Expression {
+    readonly type = "CoalesceExpression";
+    left: Expression;
+    right: Expression;
+}
+
+export class ValuesStatement extends Expression {
+    readonly type = "ValuesStatement";
+    as: QuotedLiteral;
+    fields: QuotedLiteral[];
+    values: Expression[][];
+}
+
+export class OrderByExpression extends Expression {
+    readonly type = "OrderByExpression";
+    target: Expression;
+    descending: boolean;
+}
+
+export class ExistsExpression extends Expression {
+    readonly type = "ExistsExpression";
+    target: Expression;
+}
+
+export class CallExpression extends Expression {
+    readonly type = "CallExpression";
+    callee: Expression;
+    arguments: Expression[];
+}
+
+export class MemberExpression extends Expression {
+    readonly type = "MemberExpression";
+    target: Expression;
+    property: Expression;
+    computed: boolean;
+}
+
+export class ArrowFunctionExpression extends Expression {
+    readonly type = "ArrowFunctionExpression";
+    params: Expression[];
+    body: Expression;
+}
+
+export type TableSource = SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
+
+export class SelectStatement extends Expression {
+
+    readonly type = "SelectStatement";
+
+    source: TableSource;
+
+    as: QuotedLiteral;
+
+    fields: (Expression | QuotedLiteral | ExpressionAs)[];
+
+    where: Expression;
+
+    orderBy: OrderByExpression[];
+
+    joins: JoinExpression[];
+
+    limit: number;
+
+    offset: number;
+
+}
+
+export class JoinExpression extends Expression {
+    readonly type = "JoinExpression";
+    joinType: "LEFT" | "INNER";
+    source: SelectStatement | QuotedLiteral | ExpressionAs;
+    as: QuotedLiteral;
+    where: Expression;
+    model: EntityType;
+}
+
+export class ReturnUpdated extends Expression {
+    readonly type = "ReturnUpdated";
+
+    fields: QuotedLiteral[];
+
+    changes: "INSERTED" | "DELETED" | "UPDATED";
+}
+
+export class Constant extends Expression {
+    readonly type = "Constant";
+    public value: any;
+}
+
+export class Identifier extends Expression {
+    readonly type = "Identifier";
+    public value: string;
+}
+
+export class NullExpression extends Expression {
+    readonly type = "NullExpression";
+}
+
+export class StringLiteral extends Expression {
+    readonly type = "StringLiteral";
+    public value: string;
+}
+
+export class BooleanLiteral extends Expression {
+    readonly type = "BooleanLiteral";
+    public value: boolean;
+}
+
+export class NumberLiteral extends Expression {
+    readonly type = "NumberLiteral";
+    public value: number;
+}
+
+export class BigIntLiteral extends Expression {
+    readonly type = "BigIntLiteral";
+    public value: bigint;
+}
+
+export class TemplateLiteral extends Expression {
+    readonly type = "TemplateLiteral";
+    public value: 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
+        });
+    }
+
+    readonly type = "QuotedLiteral";
+    public literal: string;
+}
+
+export class ExpressionAs extends Expression {
+    readonly type = "ExpressionAs";
+    expression: Expression;
+    alias: QuotedLiteral;
+}
+
+export class TableLiteral extends Expression {
+    readonly type = "TableLiteral";
+    schema: QuotedLiteral;
+    name: QuotedLiteral;
+
+}
+
+export class InsertStatement extends Expression {
+    readonly type = "InsertStatement";
+    table: TableLiteral;
+
+    values: ValuesStatement | SelectStatement;
+
+    returnValues: ReturnUpdated;
+
+}
+
+export class UpdateStatement extends Expression {
+
+    readonly type = "UpdateStatement";
+
+    table: TableLiteral | QuotedLiteral;
+
+    set: BinaryExpression[];
+
+    where: Expression;
+
+}
+
+export class DeleteStatement extends Expression {
+    readonly type = "DeleteStatement";
+    table: TableLiteral;
+    where: Expression;
+}
+
+export type ExpressionType =
+    BinaryExpression |
+    ValuesStatement |
+    SelectStatement |
+    Constant|
+    QuotedLiteral|
+    ExpressionAs|
+    TableLiteral|
+    InsertStatement|
+    UpdateStatement|
+    DeleteStatement|
+    ReturnUpdated|
+    OrderByExpression|
+    JoinExpression|
+    NullExpression|
+    StringLiteral|
+    NumberLiteral|
+    BigIntLiteral|
+    BooleanLiteral|
+    TemplateLiteral|
+    MemberExpression|
+    CallExpression|
+    CoalesceExpression|
+    ExistsExpression|
+    Identifier |
+    PlaceholderExpression|
+    ArrowFunctionExpression
+;

package/src/query/ast/IStringTransformer.ts

@@ -0,0 +1,74 @@
+export type ITextOrFunction = string | ((p: any) => any);
+export type ITextOrFunctionArray = ITextOrFunction[];
+
+export type IStringTransformer = (s: string) => string;
+
+export type ISqlMethodTransformer = (callee: string, args: string[]) => string;
+
+
+export const prepareAny = (a: TemplateStringsArray, ... p: any[]): any => {
+    const r = [];
+    for (let index = 0; index < a.length; index++) {
+        const element = a[index];
+        r.push(element);
+        if (index < p.length) {
+            const pi = p[index];
+            if (Array.isArray(pi)) {
+                r.push(... pi);
+                continue;
+            }
+            r.push(pi);
+        }
+    }
+    return r.flat(2);
+};
+
+const addNonEmptyFlat = (array: any[], item: any) => {
+    if (typeof item === "string") {
+        if(item) {
+            array.push(item);
+            return;
+        }
+    }
+    if (Array.isArray(item)) {
+        for (const iterator of item) {
+            if (typeof iterator === "string") {
+                if (iterator) {
+                    array.push(iterator);
+                    continue;
+                }
+                continue;
+            }
+            array.push(iterator);
+        }
+        return;
+    }
+    array.push(item);
+};
+
+export const prepare = (a: TemplateStringsArray, ... p: (ITextOrFunction | ITextOrFunctionArray)[]): ITextOrFunctionArray => {
+
+    const r = [];
+    for (let index = 0; index < a.length; index++) {
+        const element = a[index];
+        addNonEmptyFlat(r, element);
+        if (index < p.length) {
+            const pi = p[index];
+            addNonEmptyFlat(r, pi);
+        }
+    }
+    return r.flat(2);
+};
+
+export const prepareJoin = (a: (ITextOrFunction | ITextOrFunctionArray)[], sep: string = ","): ITextOrFunctionArray => {
+    const r = [];
+    let first = true;
+    for (const iterator of a) {
+        if (!first) {
+            r.push(",");
+        }
+        first = false;
+        addNonEmptyFlat(r, iterator);
+    }
+    return r.flat(2);
+};

package/src/query/ast/SqlLiteral.ts

@@ -0,0 +1,25 @@
+export default class SqlLiteral {
+    static escapeLiteral(str: string) {
+        let hasBackslash = false;
+        let escaped = "'";
+
+        for (const c of str) {
+          if (c === "'") {
+            escaped += c + c;
+          } else if (c === '\\') {
+            escaped += c + c;
+            hasBackslash = true;
+          } else {
+            escaped += c;
+          }
+        }
+
+        escaped += "'";
+
+        if (hasBackslash === true) {
+          escaped = ' E' + escaped;
+        }
+
+        return escaped;
+    }
+}

package/src/query/ast/Visitor.ts

@@ -0,0 +1,159 @@
+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";
+
+
+export default abstract class Visitor<T = any> {
+
+    visit(e1: Expression): T {
+
+        const e = e1 as ExpressionType;
+
+        switch (e.type) {
+            case "InsertStatement":
+                return this.visitInsertStatement(e);
+            case "Constant":
+                return this.visitConstant(e);
+            case "ExpressionAs":
+                return this.visitExpressionAs(e);
+            case "QuotedLiteral":
+                return this.visitQuotedLiteral(e);
+            case "SelectStatement":
+                return this.visitSelectStatement(e);
+            case "TableLiteral":
+                return this.visitTableLiteral(e);
+            case "ValuesStatement":
+                return this.visitValuesStatement(e);
+            case "BinaryExpression":
+                return this.visitBinaryExpression(e);
+            case "UpdateStatement":
+                return this.visitUpdateStatement(e);
+            case "DeleteStatement":
+                return this.visitDeleteStatement(e);
+            case "ReturnUpdated":
+                return this.visitReturnUpdated(e);
+            case "OrderByExpression":
+                return this.visitOrderByExpression(e);
+            case "JoinExpression":
+                return this.visitJoinExpression(e);
+            case "NullExpression":
+                return this.visitNullExpression(e);
+            case "BigIntLiteral":
+                return this.visitBigIntLiteral(e);
+            case "BooleanLiteral":
+                return this.visitBooleanLiteral(e);
+            case "NumberLiteral":
+                return this.visitNumberLiteral(e);
+            case "StringLiteral":
+                return this.visitStringLiteral(e);
+            case "TemplateLiteral":
+                return this.visitTemplateLiteral(e);
+            case "MemberExpression":
+                return this.visitMemberExpression(e);
+            case "CallExpression":
+                return this.visitCallExpression(e);
+            case "Identifier":
+                return this.visitIdentifier(e);
+            case "CoalesceExpression":
+                return this.visitCoalesceExpression(e);
+            case "ExistsExpression":
+                return this.visitExistsExpression(e);
+            case "PlaceholderExpression":
+                return this.visitPlaceholderExpression(e);
+            case "ArrowFunctionExpression":
+                return this.visitArrowFunctionExpression(e);
+        }
+        const c: never = e;
+        throw new Error(`${e1.type} Not implemented`);
+    }
+    visitArrowFunctionExpression(e: ArrowFunctionExpression): T {
+        return;
+    }
+    visitPlaceholderExpression(e: PlaceholderExpression): T {
+        return;
+    }
+    visitExistsExpression(e: ExistsExpression): T {
+        return;
+    }
+    visitCoalesceExpression(e: CoalesceExpression): T {
+        return;
+    }
+    visitIdentifier(e: Identifier): T {
+        return;
+    }
+    visitCallExpression(e: CallExpression): T {
+        return;
+    }
+    visitMemberExpression(e: MemberExpression): T {
+        return;
+    }
+    visitTemplateLiteral(e: TemplateLiteral): T {
+        return;
+    }
+    visitStringLiteral(e: StringLiteral): T {
+        return;
+    }
+    visitNumberLiteral(e: NumberLiteral): T {
+        return;
+    }
+    visitBooleanLiteral(e: BooleanLiteral): T {
+        return;
+    }
+    visitBigIntLiteral(e: BigIntLiteral): T {
+        return;
+    }
+    visitNullExpression(e: NullExpression): T {
+        return;
+    }
+
+    visitJoinExpression(e: JoinExpression): T {
+        return;
+    }
+
+    visitOrderByExpression(e: OrderByExpression): T {
+        return;
+    }
+
+    visitReturnUpdated(e: ReturnUpdated): T {
+        return;
+    }
+
+    visitDeleteStatement(e: DeleteStatement): T {
+        return;
+    }
+
+    visitUpdateStatement(e: UpdateStatement): T {
+        return;
+    }
+
+    visitBinaryExpression(e: BinaryExpression): T {
+        return;
+    }
+
+    visitValuesStatement(e: ValuesStatement): T {
+        return;
+    }
+
+    visitTableLiteral(e: TableLiteral): T {
+        return;
+    }
+
+    visitSelectStatement(e: SelectStatement): T {
+        return;
+    }
+
+    visitQuotedLiteral(e: QuotedLiteral): T {
+        return;
+    }
+
+    visitExpressionAs(e: ExpressionAs): T {
+        return;
+    }
+
+    visitConstant(e: Constant): T {
+        return;
+    }
+
+    visitInsertStatement(e: InsertStatement): T {
+        return;
+    }
+
+}

package/src/query/parser/ArrowToExpression.ts

@@ -0,0 +1,160 @@
+import { parseExpression } from "@babel/parser";
+import { ArrowFunctionExpression, BinaryExpression, CallExpression, CoalesceExpression, Constant, Expression, Identifier, MemberExpression, NullExpression, NumberLiteral, 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";
+
+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());
+        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 paramName = firstParam.name;
+
+        let body = node.body;
+        if (body.type !== "ArrowFunctionExpression") {
+            throw new Error("Expecting an arrow function");
+        }
+
+        const firstTarget = body.params[0];
+        if (firstTarget.type !== "Identifier") {
+            throw new Error("Expecting an identifier");
+        }
+
+        const target = firstTarget.name;
+
+        body = body.body;
+
+        const visitor = new this(paramName, target);
+        return {
+            param: paramName,
+            target,
+            body: visitor.visit(body)
+        };
+    }
+
+    public readonly leftJoins: string[] = [];
+
+    protected constructor(
+        public param: string,
+        public target: string
+    ) {
+        super();
+    }
+
+    visitBigIntLiteral({ value }: bpe.BigIntLiteral) {
+        return Constant.create({ value });
+    }
+
+    visitBooleanLiteral({ value }: bpe.BooleanLiteral) {
+        return Constant.create({ value });
+    }
+
+    visitDecimalLiteral( { value }: bpe.DecimalLiteral) {
+        return Constant.create({ value });
+    }
+
+    visitNullLiteral(node: bpe.NullLiteral) {
+        return NullExpression.create({});
+    }
+
+    visitStringLiteral({ value }: bpe.StringLiteral) {
+        return StringLiteral.create({ value });
+    }
+
+    visitNumericLiteral({ value }: bpe.NumericLiteral) {
+        return NumberLiteral.create({ value });
+    }
+
+    visitTemplateLiteral(node: bpe.TemplateLiteral) {
+        const value = node.expressions.map((x) => this.visit(x));
+        return TemplateLiteral.create({ value });
+    }
+
+    visitLogicalExpression(node: bpe.LogicalExpression): Expression {
+        const left = this.visit(node.left);
+        const right = this.visit(node.right);
+        let operator = node.operator as string;
+        switch(node.operator) {
+            case "&&":
+                operator = "AND";
+                break;
+            case "||":
+                operator = "OR";
+                break;
+            case "??":
+                return CoalesceExpression.create({ left, right });
+        }
+        return BinaryExpression.create({ left, operator, right });
+    }
+
+    visitBinaryExpression(node: bpe.BinaryExpression) {
+        let operator = node.operator as string;
+        switch(node.operator) {
+            case "!=":
+            case "!==":
+                operator = "<>";
+                break;
+            case "<":
+            case ">":
+            case "*":
+            case "%":
+            case "/":
+            case "+":
+            case "-":
+            case ">=":
+            case "<=":
+                break;
+            case "==":
+            case "===":
+                operator = "=";
+                break;
+            default:
+                throw new Error(`Operator ${operator} not supported`);
+        }
+        const left = this.visit(node.left);
+        const right = this.visit(node.right);
+        return BinaryExpression.create({ left , operator , right });
+    }
+
+    visitCallExpression({ callee, arguments: args }: bpe.CallExpression) {
+        return CallExpression.create({
+            callee: callee ? this.visit(callee) : void 0,
+            arguments: args ? args.map((x) => this.visit(x)) : []
+        });
+    }
+
+    visitIdentifier({ name: value }: bpe.Identifier): Expression {
+        return Identifier.create({ value });
+    }
+
+    visitMemberExpression({ object , property: key, computed }: bpe.MemberExpression) {
+        const property = this.visit(key);
+        return MemberExpression.create({
+            target: this.visit(object),
+            property,
+            computed
+        });
+    }
+
+    visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): Expression {
+        const params = node.params.map((x) => this.visit(x));
+        const body = this.visit(node.body);
+        return ArrowFunctionExpression.create({
+            params,
+            body
+        });
+    }
+}