@entity-access/entity-access 1.0.1

package/src/query/parser/BabelVisitor.ts

@@ -0,0 +1,86 @@
+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;
+        switch (node.type) {
+            case "BinaryExpression":
+                return this.visitBinaryExpression(node);
+            case "LogicalExpression":
+                return this.visitLogicalExpression(node);
+            case "CallExpression":
+                return this.visitCallExpression(node);
+            case "ArrowFunctionExpression":
+                return this.visitArrowFunctionExpression(node);
+            case "ConditionalExpression":
+                return this.visitConditionalExpression(node);
+            case "NullLiteral":
+                return this.visitNullLiteral(node);
+            case "StringLiteral":
+                return this.visitStringLiteral(node);
+            case "BigIntLiteral":
+                return this.visitBigIntLiteral(node);
+            case "BooleanLiteral":
+                return this.visitBooleanLiteral(node);
+            case "DecimalLiteral":
+                return this.visitDecimalLiteral(node);
+            case "NumericLiteral":
+                return this.visitNumericLiteral(node);
+            case "TemplateLiteral":
+                return this.visitTemplateLiteral(node);
+            case "Identifier":
+                return this.visitIdentifier(node);
+            case "MemberExpression":
+                return this.visitMemberExpression(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;
+    }
+
+    visitArrowFunctionExpression(node: bpe.ArrowFunctionExpression): T {
+        return;
+    }
+
+    visitCallExpression(node: bpe.CallExpression): T {
+        return;
+    }
+
+    visitBinaryExpression(node: bpe.BinaryExpression): T {
+        return;
+    }
+}

package/src/sql/ISql.ts

@@ -0,0 +1,31 @@
+export interface ISql {
+
+    in<T>(a: T, array: T[]): boolean;
+
+    text: {
+        concat(... fragments: string[]): string;
+        like(text: string, test: string): boolean;
+        iLike(text: string, test: string): boolean;
+        left(text: string, length: number): string;
+        right(text: string, length: number): string;
+        startsWith(text: string, test: string): boolean;
+        endsWith(text: string, test: string): boolean;
+        indexOf(text: string, test: string): number;
+    },
+
+    date: {
+        yearOf(d: Date): number;
+        monthOf(d: Date): number;
+        dayOf(d: Date): number;
+        minuteOf(d: Date): number;
+        hourOf(d: Date): number;
+        secondOf(d: Date): number;
+        addYears(d: Date, n: number): Date;
+        addMonths(d: Date, n: number): Date;
+        addDays(d: Date, n: number): Date;
+        addHours(d: Date, n: number): Date;
+        addMinutes(d: Date, n: number): Date;
+        addSeconds(d: Date, n: number): Date;
+    }
+
+}

package/src/sql/Sql.ts

@@ -0,0 +1,4 @@
+import { ISql } from "./ISql.js";
+
+const Sql: ISql = void 0;
+export default Sql;

package/src/tests/TestConfig.ts

@@ -0,0 +1,6 @@
+import { BaseDriver } from "../drivers/base/BaseDriver.js";
+
+export class TestConfig {
+    db:boolean;
+    driver: BaseDriver;
+}

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

@@ -0,0 +1,37 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext, headPhoneCategory } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const headphone = await context.products.where({ name: "Jabber Head Phones" }, (p) => (x) => x.name === p.name).first();
+
+    assert.notEqual(null, headphone);
+
+    const products = await context.products.where({}, (p) => (x) => x.productID > 0)
+        .offset(2)
+        .limit(5)
+        .orderBy({}, (p) => (x) => x.name)
+        .toArray();
+
+    assert.equal(5, products.length);
+
+    const sorted = [ ... products].sort((a, b) => a.name.localeCompare(b.name));
+
+    assert.equal(products.join(","), sorted.join(","));
+
+    // count all headphones...
+    let allHeadphones = await context.productCategories.where({ headPhoneCategory }, (p) => (x) => x.category.categoryID === p.headPhoneCategory).count();
+
+    assert.equal(6, allHeadphones);
+
+    allHeadphones = await context.products.where({ headPhoneCategory }, (p) => (x) => x.categories.some((pc) => pc.categoryID === p.headPhoneCategory)).count();
+
+    assert.equal(6, allHeadphones);
+}

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

@@ -0,0 +1,17 @@
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const first = await context.products.all().first();
+
+    first.name = "First product";
+
+    await context.saveChanges();
+}

package/src/tests/drivers/postgres/connection-test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import PostgreSqlDriver from "../../../drivers/postgres/PostgreSqlDriver.js";
+import { Query } from "../../../query/Query.js";
+import { TestConfig } from "../../TestConfig.js";
+
+export default async function (this: TestConfig) {
+
+    if(!this.db) {
+        return;
+    }
+
+    const connection = this.driver;
+
+    await connection.ensureDatabase();
+    // create table...
+    await connection.executeQuery(`SELECT 1;`);
+
+    // select items...
+    const items = await connection.executeReader(`SELECT * FROM (VALUES (1, 1), (1, 1)) as V(ID, Value)`);
+
+    try {
+        for await (const iterator of items.next(100)) {
+            console.log(iterator);
+        }
+    } finally {
+        await items.dispose();
+    }
+
+}

package/src/tests/drivers/sql-server/sql-server-test.ts

@@ -0,0 +1,9 @@
+import assert from "assert";
+import SqlServerDriver from "../../../drivers/sql-server/SqlServerDriver.js";
+import { SqlServerLiteral } from "../../../drivers/sql-server/SqlServerLiteral.js";
+
+export default function () {
+
+    assert.equal("N'A\\'B'", SqlServerLiteral.escapeLiteral("A'B") );
+
+}

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

@@ -0,0 +1,71 @@
+import assert from "assert";
+import QueryCompiler from "../../../compiler/QueryCompiler.js";
+import { ShoppingContext } from "../../model/ShoppingContext.js";
+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)
+            )
+        `;
+
+const sql2 = `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)) AND EXISTS (SELECT
+$3 AS "o1"
+FROM "OrderItems" AS "O1"
+WHERE ("P1"."productID" = "O1"."productID") AND ("O1"."amount" > $4))`;
+
+const sql3 = `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)) 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))`;
+
+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`;
+
+export default function() {
+
+    const context = new ShoppingContext(new PostgreSqlDriver({}));
+    let query = context.products.where({ productID: 1 }, (p) => (x) => x.orderItems.some((o) => o.productID === p.productID));
+
+    let r = query.toQuery();
+    assertSqlMatch(sql1, r.text);
+
+    const old = query;
+    query = query.where({ amount: 200}, (p) => (x) => x.orderItems.some((o) => o.amount > p.amount));
+    r = query.toQuery();
+    assertSqlMatch(sql2, r.text);
+
+    query = old.where({ date: new Date()}, (p) => (x) => x.orderItems.some((o) => o.order.orderDate > p.date));
+    r = query.toQuery();
+    assertSqlMatch(sql3, r.text);
+
+    query = context.products.where({ date: new Date()}, (p) => (x) => x.owner.dateCreated > p.date);
+    r = query.toQuery();
+    assertSqlMatch(productJoin, r.text);
+}

package/src/tests/expressions/simple/parse-arrow.ts

@@ -0,0 +1,46 @@
+import assert from "assert";
+import Sql from "../../../sql/Sql.js";
+import QueryCompiler from "../../../compiler/QueryCompiler.js";
+
+export default function () {
+
+    const compiler = QueryCompiler.instance;
+
+    const name = "Akash";
+
+    let r = compiler.execute({ name }, (p) => (x) => x.firstName === p.name);
+
+    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);
+
+    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);
+
+
+    const sqlServerCompiler = new QueryCompiler({ quotedLiteral: (x) => `[${x}]`});
+    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);
+
+    r = compiler.execute({ name }, (p) => (x) => ( x.firstName ?? x.lastName ) === p.name);
+
+    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);
+
+    r = compiler.execute({ days: 1 }, (p) => (x) => Sql.date.addDays(x.birthDate, p.days));
+
+    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("Akash", r.values[0]);
+
+}

package/src/tests/expressions/trimInternal.ts

@@ -0,0 +1,23 @@
+import { AssertionError } from "assert";
+
+export const trimInternal = (text: string) => {
+    let r = "";
+    for (const iterator of text) {
+        switch(iterator) {
+            case "\n":
+            case "\t":
+            case "\r":
+            case " ":
+                continue;
+        }
+        r += iterator;
+    }
+    return r;
+};
+
+export const assertSqlMatch = (expected: string, actual: string) => {
+    if (trimInternal(expected) === trimInternal(actual)) {
+        return;
+    }
+    throw new AssertionError({ expected, actual, operator: "===" });
+};

package/src/tests/model/ShoppingContext.ts

@@ -0,0 +1,203 @@
+import EntityContext from "../../model/EntityContext.js";
+import Column from "../../decorators/Column.js";
+import ForeignKey from "../../decorators/ForeignKey.js";
+import Table from "../../decorators/Table.js";
+import PostgreSqlDriver from "../../drivers/postgres/PostgreSqlDriver.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import { Console } from "console";
+
+export class ShoppingContext extends EntityContext {
+
+    public categories = this.model.register(Category);
+
+    public productCategories = this.model.register(ProductCategory);
+
+    public products = this.model.register(Product);
+
+    public productPrices = this.model.register(ProductPrice);
+
+    public orders = this.model.register(Order);
+
+    public orderItems = this.model.register(OrderItem);
+
+    public users = this.model.register(User);
+
+}
+
+@Table("Users")
+export class User {
+
+    @Column({ key: true , autoGenerate: true, dataType: "BigInt" })
+    public userID: number;
+
+    @Column({})
+    public dateCreated: Date;
+
+    public ownedProducts: Product[];
+
+    public orders: Order[];
+
+}
+
+@Table("Categories")
+export class Category {
+
+    @Column({ key: true, dataType: "Char", length: 200 })
+    public categoryID: string;
+
+    @Column({ length: 200 })
+    public name: string;
+
+    public productCategories: ProductCategory[];
+
+}
+
+
+@Table("Products")
+export class Product {
+
+    @Column({ key: true, autoGenerate: true, dataType: "BigInt" })
+    public productID: number;
+
+    @Column()
+    public name: string;
+
+    @Column({ nullable: true })
+    public ownerID: number;
+
+    public orderItems: OrderItem[];
+
+    public prices: ProductPrice[];
+
+    public categories: ProductCategory[];
+
+    @ForeignKey({
+        key: (product) => product.ownerID,
+        related: User,
+        relatedProperty: (user) => user.ownedProducts
+    })
+    public owner: User;
+
+}
+
+
+@Table("ProductCategories")
+export class ProductCategory {
+
+    @Column({ key: true, dataType: "BigInt", autoGenerate: true })
+    public productCategoryID: number;
+
+    @Column({ dataType: "BigInt" })
+    public productID: number;
+
+    @Column({ dataType: "Char", length: 200})
+    public categoryID: string;
+
+    @ForeignKey({
+        key: (pc) => pc.productID,
+        related: Product,
+        relatedProperty: (c) => c.categories
+    })
+    public product: Product;
+
+    @ForeignKey({
+        key: (pc) => pc.categoryID,
+        related: Category,
+        relatedProperty: (c) => c.productCategories
+    })
+    public category: Category;
+}
+
+@Table("ProductPrices")
+export class ProductPrice {
+
+    @Column({ key: true, autoGenerate: true, dataType: "BigInt"})
+    public priceID: number;
+
+    @Column()
+    public active: boolean;
+
+    @Column()
+    public startDate: Date;
+
+    @Column({ nullable: true})
+    public endDate?: Date;
+
+    public amount: number;
+
+    public productID: number;
+
+    @ForeignKey({
+        key: (productPrice) => productPrice.productID,
+        related: Product,
+        relatedProperty: (product) => product.prices
+    })
+    public product: Product;
+
+    public orderItems: OrderItem[];
+}
+
+@Table("Orders")
+export class Order {
+
+    @Column({ key: true, autoGenerate: true, dataType: "BigInt"})
+    public orderID: number;
+
+    @Column()
+    public orderDate: Date;
+
+    @Column()
+    public customerID: number;
+
+    public orderItems: OrderItem[];
+
+    @ForeignKey({
+        key: (order) => order.customerID,
+        related: User,
+        relatedProperty: (user) => user.orders
+    })
+    public customer: User;
+
+}
+
+@Table("OrderItems")
+export class OrderItem {
+
+    @Column({ key: true, autoGenerate: true, dataType: "BigInt"})
+    public orderItemID: number;
+
+    @Column()
+    public orderID: number;
+
+    @Column()
+    public productID: number;
+
+    @Column()
+    public priceID: number;
+
+    @Column()
+    public amount: number;
+
+    @ForeignKey({
+        key: (orderItem) => orderItem.orderID,
+        related: Order,
+        relatedProperty: (order) => order.orderItems
+    })
+    public order: Order;
+
+    @ForeignKey({
+        key: (orderItem) => orderItem.productID,
+        related: Product,
+        relatedProperty:(product) => product.orderItems
+    })
+    public product: Product;
+
+
+    @ForeignKey({
+        key: (orderItem) => orderItem.priceID,
+        related: ProductPrice,
+        relatedProperty: (productPrice) => productPrice.orderItems
+    })
+    public productPrice: ProductPrice;
+
+}