@entity-access/entity-access 1.0.9 → 1.0.11

package/src/sql/ISql.ts

@@ -14,13 +14,44 @@ export interface ISql {
 
     text: {
         concat(... fragments: string[]): string;
+        /**
+         * Concat with separator
+         * @param separator separator used to join
+         * @param fragments text fragments
+         */
+        concatWS(separator: string, ... fragments: string[]): string;
+        difference(left: string, right: string): number;
         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;
+        /**
+         * This will return index of given search, and it will
+         * return -1 if test value is not found. If underlying provider
+         * supports 1 as starting index, 1 will be subtracted from given result.
+         * @param text string to be searched in
+         * @param test string to search
+         */
         indexOf(text: string, test: string): number;
+        normalize(text: string, kind?: string): string;
+        collate(text: string, collation: string): string;
+        lower(text: string): string;
+        upper(text: string): string;
+        trim(text: string): string;
+
+        reverse(text: string): string;
+
+        /**
+         * Create substring from the given string. Please note that the index you specify should be
+         * zero based, and based on underlying provider, index will be incremented by one if provider
+         * supports 1 as starting index.
+         * @param text text
+         * @param start start index, zero based, one will be added to support underlying database positioning
+         * @param length length
+         */
+        substring(text: string, start: number, length?: number): string;
     },
 
     date: {

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

@@ -1,6 +1,6 @@
 import assert from "assert";
 import Logger from "../../../common/Logger.js";
-import { ServiceProvider } from "../../../di/di.js";
+import { ServiceCollection, ServiceProvider } from "../../../di/di.js";
 import { BaseDriver } from "../../../drivers/base/BaseDriver.js";
 import ContextEvents from "../../../model/events/ContextEvents.js";
 import { TestConfig } from "../../TestConfig.js";
@@ -31,10 +31,10 @@ async function getNewOrders(this: TestConfig) {
     try {
         const user = new UserInfo();
         user.userID = 2;
-        scope.add(Logger, Logger.instance);
+        ServiceCollection.register("Singleton", Logger, () => Logger.instance);
         scope.add(BaseDriver, this.driver);
         scope.add(UserInfo, user);
-        scope.add(ContextEvents, new ShoppingContextEvents());
+        ServiceCollection.register("Singleton", ContextEvents, () => new ShoppingContextEvents());
         const context = scope.create(ShoppingContext);
         context.verifyFilters = true;
 
@@ -53,10 +53,10 @@ async function addNewOrder(this: TestConfig, customer: User, userID?) {
     try {
         const user = new UserInfo();
         user.userID = userID ?? customer.userID;
-        scope.add(Logger, Logger.instance);
+        ServiceCollection.register("Singleton", Logger, () => Logger.instance);
         scope.add(BaseDriver, this.driver);
         scope.add(UserInfo, user);
-        scope.add(ContextEvents, new ShoppingContextEvents());
+        ServiceCollection.register("Singleton", ContextEvents, () => new ShoppingContextEvents());
         const context = scope.create(ShoppingContext);
         context.verifyFilters = true;