@entity-access/entity-access 1.0.25 → 1.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entity-access/entity-access",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/decorators/IColumn.ts

@@ -8,6 +8,11 @@ export interface IColumn {
     columnName?: string;
     order?: number;
     key?: boolean;
+    /**
+     * While creating table, descending order will be chosen for primary keys/foreign keys
+     * for non text keys.
+     */
+    indexOrder?: "descending" | "ascending";
     autoGenerate?: boolean;
     dataType?: ISqlType;
     nullable?: boolean;

package/src/decorators/IIndex.ts

@@ -0,0 +1,24 @@
+export interface IIndexedColumn {
+    name: string;
+    descending: boolean;
+}
+
+export type IndexedColumn<T> = ((x: T) => any) | { name:((x: T) => any), descending: boolean};
+
+export default interface IIndexDef<T = any> {
+    name: string;
+    columns: IndexedColumn<T>[];
+    unique?: boolean;
+    include?: string[];
+    indexType?: string;
+    filter?: (x: T) => boolean;
+}
+
+export interface IIndex{
+    name: string;
+    columns: IIndexedColumn[];
+    unique?: boolean;
+    include?: string[];
+    indexType?: string;
+    filter?: ((x: any) => boolean) | string;
+}

package/src/decorators/Index.ts

@@ -0,0 +1,42 @@
+import ExpressionToSql from "../query/ast/ExpressionToSql.js";
+import ArrowToExpression from "../query/parser/ArrowToExpression.js";
+import { IClassOf } from "./IClassOf.js";
+import IIndexDef, { IIndex, IIndexedColumn } from "./IIndex.js";
+import SchemaRegistry from "./SchemaRegistry.js";
+import NameParser from "./parser/NameParser.js";
+
+
+export default function Index<T>(
+    {
+        name,
+        columns: columnDefs,
+        unique,
+        include,
+        indexType,
+        filter
+    }
+    : IIndexDef<T>) {
+    return function(target: IClassOf<T>) {
+        const model = SchemaRegistry.model(target);
+        const columns = [] as IIndexedColumn[];
+
+        const i: IIndex = {
+            name,
+            unique,
+            include,
+            indexType,
+            filter,
+            columns
+        };
+        for (const iterator of columnDefs) {
+            const def = typeof iterator === "function"
+                ? { name: iterator, descending: false }
+                : iterator;
+            columns.push({
+                name: NameParser.parseMember(def.name),
+                descending: def.descending
+            });
+        }
+        model.indexes.push(i);
+    };
+}

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -93,7 +93,7 @@ export default class PostgreSqlDriver extends BaseDriver {
     }
 
     public automaticMigrations(): Migrations {
-        return new PostgresAutomaticMigrations();
+        return new PostgresAutomaticMigrations(this.compiler);
     }
 
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {

package/src/drivers/sql-server/SqlServerDriver.ts

@@ -114,7 +114,7 @@ export default class SqlServerDriver extends BaseDriver {
     }
 
     public automaticMigrations(): Migrations {
-        return new SqlServerAutomaticMigrations();
+        return new SqlServerAutomaticMigrations(this.sqlQueryCompiler);
     }
 
     protected async newRequest() {

package/src/entity-query/EntityType.ts

@@ -5,6 +5,7 @@ import NameParser from "../decorators/parser/NameParser.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
 import { Expression, ExpressionAs, QuotedLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
 import InstanceCache from "../common/cache/InstanceCache.js";
+import { IIndex } from "../decorators/IIndex.js";
 
 export const addOrCreateColumnSymbol = Symbol("addOrCreateColumn");
 export const addColumnSymbol = Symbol("addOrCreateColumn");
@@ -26,6 +27,8 @@ export default class EntityType {
 
     public readonly relations: IEntityRelation[] = [];
 
+    public readonly indexes: IIndex[] = [];
+
     public readonly keys: IColumn[] = [];
 
     public readonly nonKeys: IColumn[] = [];

package/src/migrations/Migrations.ts

@@ -1,16 +1,33 @@
+import type QueryCompiler from "../compiler/QueryCompiler.js";
+import { IIndex } from "../decorators/IIndex.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
-import EntityType from "../entity-query/EntityType.js";
+import type EntityType from "../entity-query/EntityType.js";
 import type EntityContext from "../model/EntityContext.js";
 
 export default abstract class Migrations {
 
+    constructor(protected compiler: QueryCompiler) {}
+
     public async migrate(context: EntityContext) {
         for (const iterator of context.model.entities.keys()) {
             const type = SchemaRegistry.model(iterator);
             await this.migrateTable(context, type);
+
+            for (const index of type.indexes) {
+                await this.migrateIndexInternal(context, index, type);
+            }
         }
+
     }
 
+    async migrateIndexInternal(context: EntityContext, index: IIndex, type: EntityType) {
+        // parse filter... pending...
+        this.migrateIndex(context, index, type);
+
+    }
+
+    abstract migrateIndex(context: EntityContext, index: IIndex, type: EntityType);
+
     abstract migrateTable(context: EntityContext, type: EntityType): Promise<any>;
 
 

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -1,4 +1,5 @@
 import { IColumn } from "../../decorators/IColumn.js";
+import { IIndex } from "../../decorators/IIndex.js";
 import { BaseDriver } from "../../drivers/base/BaseDriver.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityContext from "../../model/EntityContext.js";
@@ -20,24 +21,21 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
 
         await this.createColumns(driver, type, nonKeyColumns);
 
-        await this.createIndexes(driver, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
+        await this.createIndexes(context, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
 
     }
 
-    async createIndexes(driver: BaseDriver, type: EntityType, fkColumns: IColumn[]) {
-
-        const name = type.schema
-        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
-        : JSON.stringify(type.name);
-
+    async createIndexes(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
-            const indexName =  JSON.stringify(`IX_${type.name}_${iterator.columnName}`);
-            const columnName = JSON.stringify(iterator.columnName);
-            let query = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${name} ( ${columnName})`;
-            if (iterator.nullable !== true) {
-                query += ` WHERE (${columnName} is not null)`;
-            }
-            await driver.executeQuery(query);
+            const filter = iterator.nullable
+                ? `${ JSON.stringify(iterator.columnName)} IS NOT NULL`
+                : "";
+            const indexDef: IIndex = {
+                name: `IX_${type.name}_${iterator.columnName}`,
+                columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
+                filter
+            };
+            await this.migrateIndex(context, indexDef, type);
         }
     }
 
@@ -93,5 +91,23 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
 
     }
 
+    async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
+        const driver = context.driver;
+        const name = type.schema
+        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
+        : JSON.stringify(type.name);
+        const indexName =  JSON.stringify(index.name);
+        const columns = [];
+        for (const column of index.columns) {
+            const columnName = JSON.stringify(column.name);
+            columns.push(`${columnName} ${column.descending ? "DESC" : "ASC"}`);
+        }
+        let query = `CREATE ${index.unique ? "UNIQUE" : ""} INDEX IF NOT EXISTS ${indexName} ON ${name} ( ${columns.join(", ")})`;
+        if (index.filter) {
+            query += ` WHERE (${index.filter})`;
+        }
+        await driver.executeQuery(query);
+    }
+
 
 }

package/src/migrations/sql-server/SqlServerAutomaticMigrations.ts

@@ -1,4 +1,5 @@
 import { IColumn } from "../../decorators/IColumn.js";
+import { IIndex } from "../../decorators/IIndex.js";
 import { BaseDriver } from "../../drivers/base/BaseDriver.js";
 import { SqlServerLiteral } from "../../drivers/sql-server/SqlServerLiteral.js";
 import EntityType from "../../entity-query/EntityType.js";
@@ -21,27 +22,21 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
 
         await this.createColumns(driver, type, nonKeyColumns);
 
-        await this.createIndexes(driver, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
+        await this.createIndexes(context, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
 
     }
 
-    async createIndexes(driver: BaseDriver, type: EntityType, fkColumns: IColumn[]) {
-
-        const name = type.schema
-        ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
-        : SqlServerLiteral.quotedLiteral(type.name);
-
+    async createIndexes(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
-            const indexName =  SqlServerLiteral.quotedLiteral(`IX_${type.name}_${iterator.columnName}`);
-            const columnName = SqlServerLiteral.quotedLiteral(iterator.columnName);
-            let query = `IF NOT EXISTS(SELECT * FROM sys.indexes WHERE name = '${indexName}' AND object_id = OBJECT_ID('${name}'))
-                BEGIN   
-                    CREATE INDEX ${indexName} ON ${name} ( ${columnName})`;
-            if (iterator.nullable !== true) {
-                query += ` WHERE (${columnName} is not null)`;
-            }
-            query += `END`;
-            await driver.executeQuery(query);
+            const filter = iterator.nullable
+                ? `${ SqlServerLiteral.quotedLiteral(iterator.columnName)} IS NOT NULL`
+                : "";
+            const indexDef: IIndex = {
+                name: `IX_${type.name}_${iterator.columnName}`,
+                columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
+                filter
+            };
+            await this.migrateIndex(context, indexDef, type);
         }
     }
 
@@ -101,5 +96,26 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
 
     }
 
+    async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
+        const driver = context.driver;
+        const name = type.schema
+            ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
+            : SqlServerLiteral.quotedLiteral(type.name);
+        const indexName =  SqlServerLiteral.quotedLiteral(index.name);
+        const columns = [];
+        for (const column of index.columns) {
+            const columnName = SqlServerLiteral.quotedLiteral(column.name);
+            columns.push(`${columnName} ${column.descending ? "DESC" : "ASC"}`);
+        }
+        let query = `IF NOT EXISTS(SELECT * FROM sys.indexes WHERE name = '${indexName}' AND object_id = OBJECT_ID('${name}'))
+        BEGIN   
+            CREATE ${index.unique ? "UNIQUE" : ""} INDEX ${indexName} ON ${name} ( ${columns.join(", ")})`;
+        if (index.filter) {
+            query += ` WHERE (${index.filter})`;
+        }
+        query += `\nEND`;
+        await driver.executeQuery(query);
+    }
+
 
 }

package/src/model/changes/ChangeEntry.ts

@@ -49,12 +49,36 @@ export default class ChangeEntry implements IChanges {
             return;
         }
 
-        const { type: { columns }, entity, original } = this;
+        const { type: { columns, keys }, entity } = this;
+        let { original } = this;
 
         if (original === void 0) {
-            this.status = "inserted";
-            this.detectDependencies();
-            return;
+
+            // check if all keys are set or not...
+
+            let keysSet = true;
+            let autoGenerate = false;
+            for (const iterator of keys) {
+                autoGenerate ||= iterator.autoGenerate;
+                if(entity[iterator.name] === void 0) {
+                    keysSet = false;
+                }
+            }
+
+            if (keysSet) {
+                if (!autoGenerate) {
+                    this.status = "inserted";
+                    this.detectDependencies();
+                    return;
+                }
+            } else if (autoGenerate) {
+                this.status = "inserted";
+                this.detectDependencies();
+                return;
+            }
+
+            this.original = { ... entity };
+            original = this.original;
         }
 
         this.detectDependencies();
@@ -133,6 +157,11 @@ export default class ChangeEntry implements IChanges {
             // if related has key defined.. set it...
             const rKey = iterator.relatedEntity.keys[0];
 
+            // lets set the prototype...
+            const prototype = iterator.relatedTypeClass.prototype;
+            if (Object.getPrototypeOf(related) !== prototype) {
+                Object.setPrototypeOf(related, prototype);
+            }
             const relatedChanges = this.changeSet.getEntry(related);
 
             const keyValue = related[rKey.name];

package/src/model/changes/ChangeSet.ts

@@ -1,3 +1,4 @@
+import EntityAccessError from "../../common/EntityAccessError.js";
 import SchemaRegistry from "../../decorators/SchemaRegistry.js";
 import EntityContext from "../EntityContext.js";
 import IdentityService, { identityMapSymbol } from "../identity/IdentityService.js";
@@ -47,7 +48,11 @@ export default class ChangeSet {
         if (entry) {
             return entry;
         }
-        const type = SchemaRegistry.model(Object.getPrototypeOf(entity).constructor);
+        const c = Object.getPrototypeOf(entity).constructor;
+        if (c === Object) {
+            throw new EntityAccessError("Entity type not set");
+        }
+        const type = SchemaRegistry.model(c);
         const jsonKey = IdentityService.getIdentity(entity);
         if (jsonKey) {
             const existing = this.identityMap.get(jsonKey);

package/src/model/events/EntityEvents.ts

@@ -61,7 +61,7 @@ export default abstract class EntityEvents<T> {
         return this.modify(query);
     }
 
-    beforeInsert(entity: T, entry: ChangeEntry) {
+    beforeInsert(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 
@@ -69,23 +69,23 @@ export default abstract class EntityEvents<T> {
         return filter.modify();
     }
 
-    afterInsert(entity: T, entry: ChangeEntry) {
+    afterInsert(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 
-    beforeUpdate(entity: T, entry: ChangeEntry) {
+    beforeUpdate(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 
-    afterUpdate(entity: T, entry: ChangeEntry) {
+    afterUpdate(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 
-    beforeDelete(entity: T, entry: ChangeEntry) {
+    beforeDelete(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 
-    afterDelete(entity: T, entry: ChangeEntry) {
+    afterDelete(entity: T, entry: ChangeEntry): void | Promise<void> {
         return done;
     }
 

package/src/tests/model/ShoppingContext.ts

@@ -2,6 +2,7 @@ import EntityContext from "../../model/EntityContext.js";
 import Column from "../../decorators/Column.js";
 import { RelateTo } from "../../decorators/Relate.js";
 import Table from "../../decorators/Table.js";
+import Index from "../../decorators/Index.js";
 
 export const statusPublished = "published";
 
@@ -24,6 +25,11 @@ export class ShoppingContext extends EntityContext {
 }
 
 @Table("Users")
+@Index({
+    name: "IX_Unique_Users",
+    columns: [(x) => x.userName],
+    unique: true
+})
 export class User {
 
     @Column({ key: true , autoGenerate: true, dataType: "BigInt" })
@@ -32,6 +38,9 @@ export class User {
     @Column({})
     public dateCreated: Date;
 
+    @Column({ dataType: "Char", length: 200 })
+    public userName: string;
+
     public ownedProducts: Product[];
 
     public orders: Order[];

package/src/tests/model/createContext.ts

@@ -17,6 +17,7 @@ export async function createContext(driver: BaseDriver) {
 
     await seed(context);
 
+    driver.connectionString.database = context.driver.connectionString.database;
     return context;
 
 }
@@ -29,9 +30,15 @@ async function seed(context: ShoppingContext) {
     const now = new Date();
 
     // add admin user...
-    context.users.add({ dateCreated: new Date()});
+    context.users.add({
+        userName: "admin",
+        dateCreated: new Date()
+    });
     // add seller
-    const seller = context.users.add({ dateCreated: new Date()});
+    const seller = context.users.add({
+        userName: "self",
+        dateCreated: new Date()
+    });
 
     addHeadPhones(context, now, seller);
 
@@ -45,6 +52,7 @@ async function seed(context: ShoppingContext) {
     const productPrice = product.prices[0];
 
     const user = context.users.add({
+        userName: "customer1",
         dateCreated: new Date(),
         orders: [
             context.orders.add({

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

@@ -94,11 +94,11 @@ async function addNewOrder(this: TestConfig, customer: User, userID?) {
 
 async function createUser(config: TestConfig) {
     const context = await createContext(config.driver);
-    config.driver.connectionString.database = context.driver.connectionString.database;
     const user = context.users.add({
+        userName: "customer",
         dateCreated: new Date()
     });
     await context.saveChanges();
-    return user;
+    return { ... user };
 }