@entity-access/entity-access 1.0.490 → 1.0.492

package/src/common/CIMap.ts

@@ -0,0 +1,50 @@
+export default class CIMap<V> implements Map<string, V> {
+
+    [Symbol.toStringTag] = "CIMap";
+
+    get size() {
+        return this.map.size;
+    }
+
+    private map = new Map<string,V>();
+
+
+    clear() {
+        this.map.clear();
+    }
+    delete(key: string): boolean {
+        key = key?.toLowerCase();
+        return this.map.delete(key);
+    }
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void {
+        return this.map.forEach(callbackfn);
+    }
+    get(key: string): V {
+        key = key?.toLowerCase();
+        return this.map.get(key);
+    }
+    has(key: string): boolean {
+        key = key?.toLowerCase();
+        return this.map.has(key);
+    }
+    set(key: string, value: V): this {
+        key = key?.toLowerCase();
+        this.map.set(key, value);
+        return this;
+    }
+
+    entries() {
+        return this.map.entries();
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return this.map.values();
+    }
+    [Symbol.iterator]() {
+        return this.map[Symbol.iterator]();
+    }
+
+
+}

package/src/common/IColumnSchema.ts

@@ -8,4 +8,16 @@ export default interface IColumnSchema {
     computed?: any;
     ownerName?: string;
     ownerType?: string;
+}
+
+export interface IIndexSchema {
+    name: string;
+}
+
+export interface IConstraintSchema {
+    name: string;
+}
+
+export interface IForeignKeyConstraintSchema {
+    name: string;
 }

package/src/drivers/base/BaseDriver.ts

@@ -12,6 +12,7 @@ import ChangeEntry, { IChange } from "../../model/changes/ChangeEntry.js";
 import type EntityContext from "../../model/EntityContext.js";
 import { BinaryExpression, Constant, DeleteStatement, Expression, Identifier, InsertStatement, ReturnUpdated, SelectStatement, TableLiteral, UpdateStatement, UpsertStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 import { Query } from "../../query/Query.js";
+import type ExistingSchema from "./ExistingSchema.js";
 
 export interface IRecord {
     [key: string]: string | boolean | number | Date | Uint8Array | Blob;
@@ -210,9 +211,6 @@ export abstract class BaseConnection {
         return tx;
     }
 
-    abstract getColumnSchema(schema: string): Promise<IColumnSchema[]>;
-
-
     protected abstract createDbTransaction(): Promise<EntityTransaction>;
 
 }

package/src/drivers/base/ExistingSchema.ts

@@ -0,0 +1,60 @@
+import CIMap from "../../common/CIMap.js";
+import IColumnSchema, { IConstraintSchema, IForeignKeyConstraintSchema, IIndexSchema } from "../../common/IColumnSchema.js";
+import { BaseConnection } from "./BaseDriver.js";
+
+export default class ExistingSchema {
+
+    public readonly tables: Map<string, Map<string, IColumnSchema>>;
+    public readonly indexes: Map<string, IIndexSchema>;
+    public readonly constraints: Map<string, IConstraintSchema>;
+    public readonly foreignKeys: Map<string, IForeignKeyConstraintSchema>;
+
+    constructor(
+        caseInsensitive = false,
+        {
+            columns,
+            indexes,
+            constraints,
+            foreignKeys
+         }: {
+            columns: IColumnSchema[],
+            indexes?: IIndexSchema[],
+            constraints?: IConstraintSchema[],
+            foreignKeys?: IForeignKeyConstraintSchema[]
+        }
+    ) {
+
+        this.tables = caseInsensitive
+            ? new CIMap<CIMap<IColumnSchema>>()
+            : new Map<string,Map<string, IColumnSchema>>();
+
+        for (const c of columns) {
+            const table = c.ownerName;
+            let list = this.tables.get(table);
+            if (!list) {
+                list = caseInsensitive ? new CIMap<IColumnSchema>() : new Map<string, IColumnSchema>();
+                this.tables.set(table, list);
+            }
+            list.set(c.name, c);
+        }
+
+        this.indexes = new CIMap<IIndexSchema>();
+
+        for (const index of indexes) {
+            this.indexes.set(index.name, index);
+        }
+
+        this.constraints = new CIMap<IConstraintSchema>();
+
+        for (const constraint of constraints) {
+            this.constraints.set(constraint.name, constraint);
+        }
+
+        this.foreignKeys = new CIMap<IForeignKeyConstraintSchema>();
+
+        for (const fk of foreignKeys) {
+            this.foreignKeys.set(fk.name, fk);
+        }
+    }
+
+}

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -11,6 +11,7 @@ import DateTime from "../../types/DateTime.js";
 import { BaseConnection, BaseDriver, EntityTransaction, IDbConnectionString, IDbReader, IQuery, toQuery } from "../base/BaseDriver.js";
 import pg from "pg";
 import Cursor from "pg-cursor";
+import ExistingSchema from "../base/ExistingSchema.js";
 export interface IPgSqlConnectionString extends IDbConnectionString {
 
     user?: string, // default process.env.PGUSER || process.env.USER
@@ -220,38 +221,6 @@ class PostgreSqlConnection extends BaseConnection {
         return new PostgresAutomaticMigrations(context);
     }
 
-    async getColumnSchema(schema: string): Promise<IColumnSchema[]> {
-        const text = `
-        select 
-            column_name as "columnName",
-            case data_type
-                when 'bigint' then 'BigInt'
-                when 'boolean' then 'Boolean'
-                when 'timestamp' then 'DateTime'
-                when 'timestamp with time zone' then 'DateTime'
-                when 'timestamp without time zone' then 'DateTime'
-                when 'integer' then 'Int'
-                when 'real' then 'Double'
-                when 'numeric' then 'Decimal'
-                else 'Char' end as "dataType",
-            case
-                when is_nullable = 'YES' then true
-                else false end as "nullable",
-            character_maximum_length as "length",
-            case
-                when is_identity = 'YES' then 'identity'
-                else null end as "identity",
-            case
-                when is_generated = 'YES' then '() => 1'
-                else null end as "computed",
-            table_name as "ownerName",
-            'table' as "ownerType"
-            from information_schema.columns
-            where table_schema = $1`;
-        const r = await this.executeQuery({ text, values: [ schema ]});
-        return r.rows;
-    }
-
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
         return new DbReader(command, this, signal);
     }

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

@@ -11,6 +11,7 @@ import EntityType from "../../entity-query/EntityType.js";
 import DateTime from "../../types/DateTime.js";
 import IColumnSchema from "../../common/IColumnSchema.js";
 import type EntityContext from "../../model/EntityContext.js";
+import ExistingSchema from "../base/ExistingSchema.js";
 
 export type ISqlServerConnectionString = IDbConnectionString & sql.config;
 
@@ -129,48 +130,6 @@ export class SqlServerConnection extends BaseConnection {
         super(driver);
     }
 
-    async getColumnSchema(schema: string): Promise<IColumnSchema[]> {
-        const text = `
-                        SELECT
-                COLUMN_NAME as [name],
-                CASE DATA_TYPE
-                    WHEN 'bit' THEN 'Boolean'
-                    WHEN 'int' Then 'Int'
-                    WHEN 'bigint' THEN 'BigInt'
-                    WHEN 'date' then 'DateTime'
-                    WHEN 'datetime' then 'DateTime'
-                    WHEN 'datetime2' then 'DateTime'
-                    WHEN 'real' then 'Float'
-                    WHEN 'double' then 'Double'
-                    WHEN 'decimal' then 'Decimal'
-                    WHEN 'identity' then 'UUID'
-                    WHEN 'varbinary' then 'ByteArray'
-                    WHEN 'geometry' then 'Geometry'
-                    ELSE 'Char'
-                END as [dataType],
-                CASE WHEN IS_NULLABLE = 'YES' THEN 1 ELSE 0 END as [nullable],
-                CHARACTER_MAXIMUM_LENGTH as [length],
-                CASE 
-                    WHEN COLUMN_DEFAULT = 'getutcdate()' then '() => Sql.date.now()'
-                    WHEN COLUMN_DEFAULT = '(getutcdate())' then '() => Sql.date.now()'
-                    WHEN COLUMN_DEFAULT = '(newid())' then '() => Sql.crypto.randomUUID()'
-                    WHEN (COLUMN_DEFAULT = '(0)' OR COLUMN_DEFAULT = '((0))')
-                        AND DATA_TYPE = 'bit' THEN '() => false'
-                    WHEN (COLUMN_DEFAULT = '(1)' OR COLUMN_DEFAULT = '((1))')
-                        AND DATA_TYPE = 'bit' THEN '() => true'
-                    WHEN COLUMN_DEFAULT is NULL THEN ''
-                    ELSE '() => ' + COLUMN_DEFAULT
-                END as [default],
-                ColumnProperty(OBJECT_ID(TABLE_SCHEMA+'.'+TABLE_NAME),COLUMN_NAME,'IsComputed') as [computed],
-                TABLE_NAME as [ownerName],
-                'table' as [ownerType]
-                FROM INFORMATION_SCHEMA.COLUMNS
-            WHERE TABLE_SCHEMA = $1
-        `;
-        const r = await this.executeQuery({ text, values: [schema] });
-        return r.rows;
-    }
-
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
         command = toQuery(command);
         let rq = await this.newRequest(signal);

package/src/migrations/Migrations.ts

@@ -1,3 +1,4 @@
+import CIMap from "../common/CIMap.js";
 import Logger, { ConsoleLogger } from "../common/Logger.js";
 import { modelSymbol } from "../common/symbols/symbols.js";
 import type QueryCompiler from "../compiler/QueryCompiler.js";
@@ -6,18 +7,20 @@ import { IColumn } from "../decorators/IColumn.js";
 import type { IForeignKeyConstraint } from "../decorators/IForeignKeyConstraint.js";
 import type { IIndex } from "../decorators/IIndex.js";
 import type { BaseConnection, IQuery, IQueryResult } from "../drivers/base/BaseDriver.js";
+import ExistingSchema from "../drivers/base/ExistingSchema.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type EntityContext from "../model/EntityContext.js";
 import type EntityQuery from "../model/EntityQuery.js";
-import ExistingSchema from "./ExistingSchema.js";
 
 export default abstract class Migrations {
 
     logger: Logger;
 
+    protected schemaCache = new Map<string, ExistingSchema>();
+
     constructor(
         private context: EntityContext,
-        private connection: BaseConnection = context.connection,
+        protected connection: BaseConnection = context.connection,
         protected compiler: QueryCompiler = context.driver.compiler
     ) {
 
@@ -76,12 +79,17 @@ export default abstract class Migrations {
                 }
             }
 
+            const schema = await this.getSchema(type);
+
             await this.migrateTable(context, type);
 
             // create constraints
             for (const iterator of type.checkConstraints) {
+                if (schema.constraints.has(iterator.name)) {
+                    continue;
+                }
                 const source = context.query(type.typeClass) as EntityQuery<any>;
-                const { target , textQuery } = this.compiler.compileToSql(source, `(p) => ${iterator.filter}` as any);
+                const { textQuery } = this.compiler.compileToSql(source, `(p) => ${iterator.filter}` as any);
                 const r = new RegExp(source.selectStatement.sourceParameter.name + "\\.", "ig");
                 iterator.filter = textQuery.join("").replace(r, "") as any;
                 await this.migrateCheckConstraint(context, iterator, type);
@@ -91,20 +99,21 @@ export default abstract class Migrations {
                 await this.migrateIndexInternal(context, index, type);
             }
 
-            for (const { isInverseRelation , foreignKeyConstraint, relatedTypeClass } of type.relations) {
+            if (createIndexForForeignKeys) {
+                postMigration.push(() =>
+                    this.createIndexForForeignKeys(context, type, type.nonKeys.filter((x) =>
+                        x.fkRelation
+                        && (!x.key || type.keys.indexOf(x) !== 0)
+                        && !x.fkRelation?.doNotCreateIndex))
+                );
+            }
 
-                if (createIndexForForeignKeys) {
-                    postMigration.push(() =>
-                        this.createIndexForForeignKeys(context, type, type.nonKeys.filter((x) =>
-                            x.fkRelation
-                            && (!x.key || type.keys.indexOf(x) !== 0)
-                            && !x.fkRelation?.doNotCreateIndex))
-                    );
-                }
+            for (const { isInverseRelation , foreignKeyConstraint, relatedTypeClass } of type.relations) {
 
                 if (isInverseRelation) {
                     continue;
                 }
+
                 if (!foreignKeyConstraint) {
                     continue;
                 }
@@ -120,6 +129,9 @@ export default abstract class Migrations {
                 //     foreignKeyConstraint.refColumns.push(relatedEntity.getProperty(iterator.name).field);
                 // }
 
+                if(schema.foreignKeys.has(foreignKeyConstraint.name)) {
+                    continue;
+                }
                 postMigration.push(() => this.migrateForeignKey(context, foreignKeyConstraint));
             }
         }
@@ -173,6 +185,13 @@ export default abstract class Migrations {
 
         index = { ... index };
 
+        const schema = await this.getSchema(type);
+
+        if (schema.indexes.has(index.name)) {
+            return;
+        }
+
+
         for (const column of index.columns) {
             const c = type.getProperty(column.name);
             if (c.field) {
@@ -192,14 +211,67 @@ export default abstract class Migrations {
 
     }
 
-    abstract migrateIndex(context: EntityContext, index: IIndex, type: EntityType);
+    async migrateTable(context: EntityContext, type: EntityType) {
 
-    abstract migrateTable(context: EntityContext, type: EntityType): Promise<any>;
+        const schema = await this.getSchema(type);
+
+        // create table if not exists...
+        const nonKeyColumns = type.nonKeys;
+        const keys = type.keys;
+
+        if (!schema.tables.has(type.name)) {
+            await this.createTable(type, keys);
+        }
+
+        await this.createColumns(type, nonKeyColumns);
+
+    }
+
+    async createColumns(type: EntityType, nonKeyColumns: IColumn[]) {
+        const name = type.schema
+            ? type.schema + "." + type.name
+            : type.name;
+
+        if (nonKeyColumns.length > 1) {
+            nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        const schema = await this.getSchema(type);
+
+        const table = schema.tables.get(type.name);
+
+        for (const iterator of nonKeyColumns) {
+            if (table?.has(iterator.columnName)) {
+                continue;
+            }
+            await this.createColumn(type, iterator);
+        }
+
+    }
+
+    abstract createTable(type: EntityType, keys: IColumn[]);
+
+    abstract createColumn(type: EntityType, column: IColumn);
+
+    abstract migrateIndex(context: EntityContext, index: IIndex, type: EntityType);
 
     abstract migrateForeignKey(context: EntityContext, constraint: IForeignKeyConstraint);
 
     abstract migrateCheckConstraint(context: EntityContext, checkConstraint: ICheckConstraint, type: EntityType);
 
+    public async getSchema(type: EntityType): Promise<ExistingSchema> {
+        const schema = type.schema || "__ default + __ schema ";
+        let s = this.schemaCache.get(schema);
+        if (s) {
+            return s;
+        }
+        s = await this.getExistingSchema(type);
+        this.schemaCache.set(schema, s);
+        return s;
+    }
+
+    protected abstract getExistingSchema(type: EntityType): Promise<ExistingSchema>;
+
     protected executeQuery(command: IQuery, signal?: AbortSignal): Promise<IQueryResult> {
         const text = typeof command === "string" ? command : command.text;
         this.logger?.log(text);

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -4,9 +4,9 @@ import { IColumn } from "../../decorators/IColumn.js";
 import { IForeignKeyConstraint } from "../../decorators/IForeignKeyConstraint.js";
 import { IIndex } from "../../decorators/IIndex.js";
 import { BaseConnection, BaseDriver } from "../../drivers/base/BaseDriver.js";
+import ExistingSchema from "../../drivers/base/ExistingSchema.js";
 import EntityType from "../../entity-query/EntityType.js";
 import type EntityContext from "../../model/EntityContext.js";
-import ExistingSchema from "../ExistingSchema.js";
 import PostgresMigrations from "./PostgresMigrations.js";
 
 export default class PostgresAutomaticMigrations extends PostgresMigrations {
@@ -20,21 +20,6 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         )`);
     }
 
-    async migrateTable(context: EntityContext, type: EntityType) {
-
-
-        // create table if not exists...
-        const nonKeyColumns = type.nonKeys;
-        const keys = type.keys;
-
-        const driver = context.connection;
-
-        await this.createTable(driver, type, keys);
-
-        await this.createColumns(driver, type, nonKeyColumns);
-
-    }
-
     async createIndexForForeignKeys(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
             const filter = iterator.nullable
@@ -45,56 +30,39 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
                 columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
                 filter
             };
-            await this.migrateIndex(context, indexDef, type);
+            await this.migrateIndexInternal(context, indexDef, type);
         }
     }
 
-    async createColumns(driver: BaseConnection, type: EntityType, nonKeyColumns: IColumn[]) {
+    async createColumn(type: EntityType, iterator: IColumn) {
 
         const name = type.schema
-        ? type.schema + "." + type.name
-        : type.name;
-
-        if (nonKeyColumns.length > 1) {
-            nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-        }
+            ? type.schema + "." + type.name
+            : type.name;
 
-        const columns = await ExistingSchema.getSchema(driver, type.schema || "public", type.name, true);
+        const { quotedColumnName } = iterator;
 
-        const columnSet = new Set(columns.map((x) => x.name));
 
-        for (const iterator of nonKeyColumns) {
-            const { columnName } = iterator;
-            if (columnSet.has(columnName)) {
-                continue;
-            }
-            let def = `ALTER TABLE ${name} ADD COLUMN IF NOT EXISTS ${columnName} `;
-            def += this.getColumnDefinition(iterator);
+        let def = `ALTER TABLE ${name} ADD COLUMN IF NOT EXISTS ${quotedColumnName} `;
+        def += this.getColumnDefinition(iterator);
 
-            if (iterator.nullable !== true) {
-                def += " NOT NULL ";
-            }
-
-            if (iterator.generated === "computed") {
-                def += ` GENERATED ALWAYS AS (${iterator.computed}) ${iterator.stored ? "STORED" : ""} \r\n\t`;
-            }
-
-            if (typeof iterator.default === "string") {
-                def += " DEFAULT " + iterator.default;
-            }
+        if (iterator.nullable !== true) {
+            def += " NOT NULL ";
+        }
 
-            await this.executeQuery(def + ";");
+        if (iterator.generated === "computed") {
+            def += ` GENERATED ALWAYS AS (${iterator.computed}) ${iterator.stored ? "STORED" : ""} \r\n\t`;
         }
 
-    }
+        if (typeof iterator.default === "string") {
+            def += " DEFAULT " + iterator.default;
+        }
 
-    async createTable(driver: BaseConnection, type: EntityType, keys: IColumn[]) {
+        await this.executeQuery(def + ";");
 
-        const columns = await ExistingSchema.getSchema(driver, type.schema || "public", type.name, true);
+    }
 
-        if (columns.length) {
-            return;
-        }
+    async createTable(type: EntityType, keys: IColumn[]) {
 
         const name = type.schema
             ? type.schema + "." + type.name
@@ -132,10 +100,10 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
     }
 
     async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
-        const driver = context.connection;
+
         const name = type.schema
-        ? type.schema + "." + type.name
-        : type.name;
+            ? type.schema + "." + type.name
+            : type.name;
         const indexName =  index.name;
         const columns = [];
         for (const column of index.columns) {

package/src/migrations/postgres/PostgresMigrations.ts

@@ -1,8 +1,86 @@
 import { IColumn } from "../../decorators/IColumn.js";
+import ExistingSchema from "../../drivers/base/ExistingSchema.js";
+import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../Migrations.js";
 
 export default abstract class PostgresMigrations extends Migrations {
 
+    async getExistingSchema(type: EntityType) {
+
+        const schema = type.schema || "public";
+        const values = [schema];
+
+        let text = `
+        select 
+            column_name as "name",
+            case data_type
+                when 'bigint' then 'BigInt'
+                when 'boolean' then 'Boolean'
+                when 'timestamp' then 'DateTime'
+                when 'timestamp with time zone' then 'DateTime'
+                when 'timestamp without time zone' then 'DateTime'
+                when 'integer' then 'Int'
+                when 'real' then 'Double'
+                when 'numeric' then 'Decimal'
+                else 'Char' end as "dataType",
+            case
+                when is_nullable = 'YES' then true
+                else false end as "nullable",
+            character_maximum_length as "length",
+            case
+                when is_identity = 'YES' then 'identity'
+                else null end as "identity",
+            case
+                when is_generated = 'YES' then '() => 1'
+                else null end as "computed",
+            table_name as "ownerName",
+            'table' as "ownerType"
+            from information_schema.columns
+            where table_schema = $1`;
+
+        let r = await this.executeQuery({ text, values});
+        const columns =  r.rows;
+
+        text = `
+        SELECT
+            tc.constraint_name as "name"
+        FROM information_schema.table_constraints AS tc 
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+			WHERE
+                tc.constraint_type = 'FOREIGN KEY'
+                AND tc.table_schema = $1
+        `;
+        r = await this.executeQuery({ text, values});
+        const foreignKeys = r.rows;
+
+        text = `
+        SELECT indexname as "name" FROM pg_indexes where schemaName=$1`;
+        r = await this.executeQuery({ text, values });
+        const indexes = r.rows;
+
+        text = `
+           SELECT
+            tc.constraint_name as "name"
+        FROM information_schema.table_constraints AS tc 
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+			WHERE
+                tc.constraint_type <> 'FOREIGN KEY'
+                AND tc.table_schema = $1`;
+
+        r = await this.executeQuery({ text, values });
+        const constraints = r.rows;
+
+        return new ExistingSchema(false, { columns, foreignKeys, indexes, constraints });
+    }
+
     protected getColumnDefinition(iterator: IColumn) {
         if (iterator.dataType === "Decimal") {
             if (iterator.precision && iterator.scale) {