@entity-access/entity-access 1.0.10 → 1.0.12

package/src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -1,8 +1,11 @@
 
-import { prepare, prepareAny } from "../../query/ast/IStringTransformer.js";
-import { ISqlHelpers, flattenHelpers } from "../ISqlHelpers.js";
+import { prepareAny } from "../../query/ast/IStringTransformer.js";
+import Sql from "../../sql/Sql.js";
+import { ISqlHelpers } from "../ISqlHelpers.js";
+import type QueryCompiler from "../QueryCompiler.js";
 
 export const SqlServerSqlHelper: ISqlHelpers = {
+    ... Sql,
     in(a, array) {
         return prepareAny `${a} IN ${array}`;
     },
@@ -151,12 +154,18 @@ export const SqlServerSqlHelper: ISqlHelpers = {
     }
 };
 
-const names = flattenHelpers(SqlServerSqlHelper, "Sql");
+export default function SqlServerSqlMethodTransformer(compiler: QueryCompiler, callee: string[], args: any[]): string {
 
-export default function SqlServerSqlMethodTransformer(callee: string, args: any[]): string {
-    const name = names[callee];
-    if (!name) {
+    let start = SqlServerSqlHelper;
+    for (const iterator of callee) {
+        start = start[iterator];
+        if (!start) {
+            return;
+        }
+    }
+    if (!start) {
         return;
     }
-    return names[callee]?.(... args);
-}
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return (start as unknown as Function).apply(compiler, args);
+}

package/src/decorators/Relate.ts

@@ -0,0 +1,37 @@
+import type { IClassOf } from "./IClassOf.js";
+import SchemaRegistry from "./SchemaRegistry.js";
+import NameParser from "./parser/NameParser.js";
+
+
+
+export default function Relate<T, TRelated>(c: IClassOf<TRelated>,
+    {
+        foreignKey: name, inverseProperty: inv, inverseKey: invKey, dotNotCreateIndex
+    }: {
+
+        foreignKey: (item: T) => any;
+
+        inverseProperty: (item: TRelated) => any;
+
+        inverseKey?: (item: TRelated) => any;
+        dotNotCreateIndex?: boolean;
+    }
+
+) {
+    return (target: T, key: string): any => {
+
+        const cn = target.constructor ?? target;
+        const type = SchemaRegistry.model(cn);
+
+        type.addRelation({
+            type,
+            name: key,
+            foreignKey: NameParser.parseMember(name),
+            relatedTypeClass: c,
+            relatedName: NameParser.parseMember(inv),
+            relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
+            dotNotCreateIndex
+        });
+
+    };
+}

package/src/di/di.ts

@@ -41,12 +41,12 @@ export class ServiceProvider implements IDisposable {
         this[parentServiceProvider] = parent;
     }
 
-    // add<T1, T extends T1>(type: IAbstractClassOf<T1> | IClassOf<T1>, instance: T) {
-    //     this.getRegistration(type, true);
-    //     this.map.set(type, instance);
-    //     instance[serviceProvider] = this;
-    //     return instance;
-    // }
+    add<T1, T extends T1>(type: IAbstractClassOf<T1> | IClassOf<T1>, instance: T) {
+        this.getRegistration(type, true);
+        this.map.set(type, instance);
+        instance[serviceProvider] = this;
+        return instance;
+    }
 
 
     createScope() {

package/src/query/ast/ExpressionToSql.ts

@@ -228,9 +228,8 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             }
 
             if (identifier?.value === "Sql") {
-                const names = `${identifier.value}.${chain.join(".")}`;
                 const argList = e.arguments.map((x) => this.visit(x));
-                const transformedCallee = this.compiler.sqlMethodTransformer(names, argList as any[]);
+                const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, chain, argList as any[]);
                 if (transformedCallee) {
                     return prepare `${transformedCallee}`;
                 }

package/src/query/ast/IStringTransformer.ts

@@ -1,9 +1,11 @@
+import type QueryCompiler from "../../compiler/QueryCompiler.js";
+
 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 type ISqlMethodTransformer = (compiler: QueryCompiler, callee: string[], args: string[]) => string;
 
 export class QueryParameter {
 
@@ -18,7 +20,7 @@ export class QueryParameter {
     }
 }
 
-export const prepareAny = (a: TemplateStringsArray, ... p: any[]): any => {
+export const prepareAny = (a: TemplateStringsArray, ... p: any[]): string[] => {
     const r = [];
     for (let index = 0; index < a.length; index++) {
         const element = a[index];

package/src/sql/Sql.ts

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

package/src/tests/model/ShoppingContext.ts

@@ -1,6 +1,6 @@
 import EntityContext from "../../model/EntityContext.js";
 import Column from "../../decorators/Column.js";
-import ForeignKey from "../../decorators/ForeignKey.js";
+import Relate from "../../decorators/Relate.js";
 import Table from "../../decorators/Table.js";
 
 export const statusPublished = "published";
@@ -73,10 +73,9 @@ export class Product {
 
     public categories: ProductCategory[];
 
-    @ForeignKey({
-        key: (product) => product.ownerID,
-        related: User,
-        relatedProperty: (user) => user.ownedProducts
+    @Relate(User, {
+        foreignKey: (product) => product.ownerID,
+        inverseProperty: (user) => user.ownedProducts
     })
     public owner: User;
 
@@ -95,17 +94,15 @@ export class ProductCategory {
     @Column({ dataType: "Char", length: 200})
     public categoryID: string;
 
-    @ForeignKey({
-        key: (pc) => pc.productID,
-        related: Product,
-        relatedProperty: (c) => c.categories
+    @Relate(Product, {
+        foreignKey: (pc) => pc.productID,
+        inverseProperty: (c) => c.categories
     })
     public product: Product;
 
-    @ForeignKey({
-        key: (pc) => pc.categoryID,
-        related: Category,
-        relatedProperty: (c) => c.productCategories
+    @Relate(Category, {
+        foreignKey: (pc) => pc.categoryID,
+        inverseProperty: (c) => c.productCategories
     })
     public category: Category;
 }
@@ -131,10 +128,9 @@ export class ProductPrice {
     @Column({})
     public productID: number;
 
-    @ForeignKey({
-        key: (productPrice) => productPrice.productID,
-        related: Product,
-        relatedProperty: (product) => product.prices
+    @Relate(Product, {
+        foreignKey: (productPrice) => productPrice.productID,
+        inverseProperty: (product) => product.prices
     })
     public product: Product;
 
@@ -155,10 +151,9 @@ export class Order {
 
     public orderItems: OrderItem[];
 
-    @ForeignKey({
-        key: (order) => order.customerID,
-        related: User,
-        relatedProperty: (user) => user.orders
+    @Relate(User, {
+        foreignKey: (order) => order.customerID,
+        inverseProperty: (user) => user.orders
     })
     public customer: User;
 
@@ -182,25 +177,22 @@ export class OrderItem {
     @Column()
     public amount: number;
 
-    @ForeignKey({
-        key: (orderItem) => orderItem.orderID,
-        related: Order,
-        relatedProperty: (order) => order.orderItems
+    @Relate(Order, {
+        foreignKey: (orderItem) => orderItem.orderID,
+        inverseProperty: (order) => order.orderItems
     })
     public order: Order;
 
-    @ForeignKey({
-        key: (orderItem) => orderItem.productID,
-        related: Product,
-        relatedProperty:(product) => product.orderItems
+    @Relate(Product, {
+        foreignKey: (orderItem) => orderItem.productID,
+        inverseProperty:(product) => product.orderItems
     })
     public product: Product;
 
 
-    @ForeignKey({
-        key: (orderItem) => orderItem.priceID,
-        related: ProductPrice,
-        relatedProperty: (productPrice) => productPrice.orderItems
+    @Relate(ProductPrice, {
+        foreignKey: (orderItem) => orderItem.priceID,
+        inverseProperty: (productPrice) => productPrice.orderItems
     })
     public productPrice: ProductPrice;
 

package/src/tests/security/tests/place-order.ts

@@ -32,8 +32,8 @@ async function getNewOrders(this: TestConfig) {
         const user = new UserInfo();
         user.userID = 2;
         ServiceCollection.register("Singleton", Logger, () => Logger.instance);
-        ServiceCollection.register("Singleton", BaseDriver, () => this.driver);
-        ServiceCollection.register("Scoped", UserInfo, () => user);
+        scope.add(BaseDriver, this.driver);
+        scope.add(UserInfo, user);
         ServiceCollection.register("Singleton", ContextEvents, () => new ShoppingContextEvents());
         const context = scope.create(ShoppingContext);
         context.verifyFilters = true;
@@ -54,8 +54,8 @@ async function addNewOrder(this: TestConfig, customer: User, userID?) {
         const user = new UserInfo();
         user.userID = userID ?? customer.userID;
         ServiceCollection.register("Singleton", Logger, () => Logger.instance);
-        ServiceCollection.register("Singleton", BaseDriver, () => this.driver);
-        ServiceCollection.register("Scoped", UserInfo, () => user);
+        scope.add(BaseDriver, this.driver);
+        scope.add(UserInfo, user);
         ServiceCollection.register("Singleton", ContextEvents, () => new ShoppingContextEvents());
         const context = scope.create(ShoppingContext);
         context.verifyFilters = true;