Merge branch 'main' into dev

Author: ackava

package-lock.json

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

package.json

@@ -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]();
+    }
+
+
+}

src/common/CIMap.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;
 }

src/common/IColumnSchema.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>;
 
 }

src/drivers/base/BaseDriver.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);
+        }
+    }
+
+}

src/drivers/base/ExistingSchema.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);
     }

src/drivers/postgres/PostgreSqlDriver.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);