Merge pull request #65 from Entity-Access/main

Migration steps reduced

Author: ackava

package-lock.json

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

package.json

@@ -6,4 +6,6 @@ export default interface IColumnSchema {
     default: string;
     key: boolean;
     computed?: any;
+    ownerName?: string;
+    ownerType?: string;
 }

src/common/IColumnSchema.ts

@@ -22,12 +22,12 @@ export const SqlServerSqlHelper: ISqlHelpers = {
         spatial: {
         point(x, y, srid) {
             if (srid === void 0) {
-                return prepareAny `Point(${x}, ${y}, 4326)`;
+                return prepareAny `geography::Point(${x}, ${y}, 4326)`;
             }
-            return prepareAny `Point(${x}, ${y}, ${srid})`;
+            return prepareAny `geography::Point(${x}, ${y}, ${srid})`;
         },
         location(x: any) {
-                return prepareAny `Point(${[(p) => x[0](p).longitude]}, ${[(p) => x[0](p).latitude]}, 4326)`;
+                return prepareAny `geography::Point(${[(p) => x[0](p).longitude]}, ${[(p) => x[0](p).latitude]}, 4326)`;
         },
         distance(x, y) {
             return prepareAny `${x}.STDistance(${y})`;

src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -9,6 +9,7 @@ import { IColumn } from "../../decorators/IColumn.js";
 import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../../migrations/Migrations.js";
 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";
 
@@ -180,7 +181,7 @@ export abstract class BaseConnection {
      * This migrations only support creation of missing items.
      * However, you can provide events to change existing items.
      */
-    public abstract automaticMigrations(): Migrations;
+    public abstract automaticMigrations(context: EntityContext): Migrations;
 
     public async runInTransaction<T = any>(fx?: () => Promise<T>) {
         await using tx = await this.createTransaction();
@@ -209,7 +210,7 @@ export abstract class BaseConnection {
         return tx;
     }
 
-    abstract getSchema(schema: string, table: string): Promise<IColumnSchema[]>;
+    abstract getColumnSchema(schema: string): Promise<IColumnSchema[]>;
 
 
     protected abstract createDbTransaction(): Promise<EntityTransaction>;

src/drivers/base/BaseDriver.ts

@@ -6,6 +6,7 @@ import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../../migrations/Migrations.js";
 import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
+import EntityContext from "../../model/EntityContext.js";
 import DateTime from "../../types/DateTime.js";
 import { BaseConnection, BaseDriver, EntityTransaction, IDbConnectionString, IDbReader, IQuery, toQuery } from "../base/BaseDriver.js";
 import pg from "pg";
@@ -215,12 +216,40 @@ class PostgreSqlConnection extends BaseConnection {
     }
 
 
-    public automaticMigrations(): Migrations {
-        return new PostgresAutomaticMigrations(this.compiler);
+    public automaticMigrations(context: EntityContext): Migrations {
+        return new PostgresAutomaticMigrations(context);
     }
 
-    getSchema(schema: string, table: string): Promise<IColumnSchema[]> {
-        throw new EntityAccessError("Not implemented");
+    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> {

src/drivers/postgres/PostgreSqlDriver.ts

@@ -10,6 +10,7 @@ import TimedCache from "../../common/cache/TimedCache.js";
 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";
 
 export type ISqlServerConnectionString = IDbConnectionString & sql.config;
 
@@ -128,7 +129,7 @@ export class SqlServerConnection extends BaseConnection {
         super(driver);
     }
 
-    async getSchema(schema: string, table: string): Promise<IColumnSchema[]> {
+    async getColumnSchema(schema: string): Promise<IColumnSchema[]> {
         const text = `
                         SELECT
                 COLUMN_NAME as [name],
@@ -160,12 +161,13 @@ export class SqlServerConnection extends BaseConnection {
                     WHEN COLUMN_DEFAULT is NULL THEN ''
                     ELSE '() => ' + COLUMN_DEFAULT
                 END as [default],
-                ColumnProperty(OBJECT_ID(TABLE_SCHEMA+'.'+TABLE_NAME),COLUMN_NAME,'IsComputed') as [computed]
+                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
-            AND TABLE_NAME = $2
         `;
-        const r = await this.executeQuery({ text, values: [schema, table] });
+        const r = await this.executeQuery({ text, values: [schema] });
         return r.rows;
     }
 
@@ -237,8 +239,8 @@ export class SqlServerConnection extends BaseConnection {
         return value;
     }
 
-    public automaticMigrations(): Migrations {
-        return new SqlServerAutomaticMigrations(this.sqlQueryCompiler);
+    public automaticMigrations(context: EntityContext): Migrations {
+        return new SqlServerAutomaticMigrations(context);
     }
 
     protected async createDbTransaction(): Promise<EntityTransaction> {

src/drivers/sql-server/SqlServerDriver.ts

@@ -0,0 +1,39 @@
+import IColumnSchema from "../common/IColumnSchema.js";
+import type { BaseConnection } from "../drivers/base/BaseDriver.js";
+
+export default class ExistingSchema {
+
+
+    public static async getSchema(connection: BaseConnection, schema: string, table: string, caseInsensitive = false) {
+        let s = this.cache.get(schema);
+        if (!s) {
+            const columns = await connection.getColumnSchema(schema);
+            s = new ExistingSchema(columns, caseInsensitive);
+            this.cache.set(schema, s);
+        }
+        if (caseInsensitive) {
+            table = table.toLowerCase();
+        }
+        return s.tables.get(table) ?? [];
+    }
+
+    private static cache = new Map<string, ExistingSchema>();
+
+    public tables = new Map<string,IColumnSchema[]>();
+
+    constructor(columns: IColumnSchema[], caseInsensitive = false) {
+        for (const c of columns) {
+            let tableName = c.ownerName;
+            if (caseInsensitive) {
+                tableName = tableName.toLowerCase();
+            }
+            let table = this.tables.get(tableName);
+            if (!table) {
+                table = [];
+                this.tables.set(tableName, table);
+            }
+            table.push(c);
+        }
+    }
+
+}

src/migrations/ExistingSchema.ts

@@ -1,28 +1,52 @@
+import Logger, { ConsoleLogger } from "../common/Logger.js";
 import { modelSymbol } from "../common/symbols/symbols.js";
 import type QueryCompiler from "../compiler/QueryCompiler.js";
 import ICheckConstraint from "../decorators/ICheckConstraint.js";
+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 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 {
 
-    constructor(protected compiler: QueryCompiler) {}
+    logger: Logger;
 
-    public async migrate(context: EntityContext , {
+    constructor(
+        private context: EntityContext,
+        private connection: BaseConnection = context.connection,
+        protected compiler: QueryCompiler = context.driver.compiler
+    ) {
+
+    }
+
+    public async migrate({
         version,
         name = "default",
         historyTableName = "migrations",
+        log = new ConsoleLogger(false),
         seed,
-    }: { version?: string, name?: string, historyTableName?: string, seed?: (c: EntityContext) => Promise<any>} = {} ) {
+        createIndexForForeignKeys = true
+    }: {
+        version?: string,
+        name?: string,
+        historyTableName?: string,
+        log?: Logger,
+        seed?: (c: EntityContext) => Promise<any>,
+        createIndexForForeignKeys?: boolean
+    } = {} ) {
+        const { context } = this;
         const { model } = context;
+        this.logger = log ?? context.logger;
         const postMigration = [] as (() => Promise<void>)[];
 
         if (version) {
             // check if we have already stored this version...
             if(await this.hasVersion(context, name, version, historyTableName)) {
+                // eslint-disable-next-line no-console
                 console.warn(`Skipping migration, migration already exists for ${version}`);
                 return false;
             }
@@ -68,6 +92,16 @@ export default abstract class Migrations {
             }
 
             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 (isInverseRelation) {
                     continue;
                 }
@@ -120,6 +154,8 @@ export default abstract class Migrations {
 
     abstract ensureVersionTable(context: EntityContext, table: string): Promise<any>;
 
+    abstract createIndexForForeignKeys(context: EntityContext, type: EntityType, fkColumns: IColumn[]): Promise<void>;
+
     async commitVersion(context: EntityContext, name, version, table) {
         const { quote, escapeLiteral } = this.compiler;
 
@@ -164,4 +200,10 @@ export default abstract class Migrations {
 
     abstract migrateCheckConstraint(context: EntityContext, checkConstraint: ICheckConstraint, type: EntityType);
 
+    protected executeQuery(command: IQuery, signal?: AbortSignal): Promise<IQueryResult> {
+        const text = typeof command === "string" ? command : command.text;
+        this.logger?.log(text);
+        return this.connection.executeQuery(command, signal);
+    }
+
 }