remult 0.25.7 → 0.25.8-exp.1

package/README.md

@@ -5,23 +5,17 @@
   <h1>Remult</h1>
   <p>Full-stack CRUD, simplified, with SSOT TypeScript entities</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
-		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
-	</a>
+		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield"></a>
 	<a href="https://codecov.io/gh/remult/remult" rel="nofollow">
-        	<img src="https://codecov.io/gh/remult/remult/branch/master/graph/badge.svg?token=LYWQRUN3D1"/>
-      	</a>
+        	<img src="https://codecov.io/gh/remult/remult/branch/master/graph/badge.svg?token=LYWQRUN3D1"/></a>
     	<a href="https://raw.githubusercontent.com/remult/remult/master/LICENSE" rel="nofollow">
-		<img alt="GitHub license" src="https://img.shields.io/badge/license-MIT-blue.svg">
-	</a>
+		<img alt="GitHub license" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
 	<a href="https://www.npmjs.com/package/remult" rel="nofollow">
-		<img alt="npm version" src="https://badge.fury.io/js/remult.svg">
-	</a>
+		<img alt="npm version" src="https://badge.fury.io/js/remult.svg"></a>
 	<a href="https://www.npmjs.com/package/remult" rel="nofollow">
-		<img alt="npm downloads" src="https://img.shields.io/npm/dm/remult">
-	</a>
+		<img alt="npm downloads" src="https://img.shields.io/npm/dm/remult"></a>
 	<a href="https://discord.gg/GXHk7ZfuG5" rel="nofollow">
-		<img alt="Join Discord" src="https://badgen.net/discord/online-members/GXHk7ZfuG5?icon=discord&label=Discord"/>
-	</a>
+		<img alt="Join Discord" src="https://badgen.net/discord/members/GXHk7ZfuG5?icon=discord&label=Discord"/></a>
 </div>
 
 <br/>

package/esm/migrations/compare-migration-snapshots.js

@@ -0,0 +1,39 @@
+import { repo } from '../index.js';
+import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+export async function compareMigrationSnapshot({ entities, snapshot, migrationBuilder: migrationBuilder, }) {
+    snapshot = JSON.parse(JSON.stringify(snapshot));
+    for (const entity of entities) {
+        const meta = repo(entity).metadata;
+        const e = await dbNamesOf(meta, (x) => x);
+        if (shouldCreateEntity(meta, e)) {
+            let entitySnapshot = snapshot.entities[e.$entityName];
+            let createColumns = true;
+            if (!entitySnapshot) {
+                createColumns = false;
+                await migrationBuilder.createTable(meta);
+                entitySnapshot = snapshot.entities[e.$entityName] = {
+                    key: meta.key,
+                    className: meta.entityType.name,
+                    columns: {},
+                };
+            }
+            for (const field of meta.fields) {
+                if (!shouldNotCreateField(field, e)) {
+                    const column = entitySnapshot.columns[e.$dbNameOf(field)];
+                    if (!column) {
+                        if (createColumns)
+                            await migrationBuilder.addColumn(meta, field);
+                        entitySnapshot.columns[e.$dbNameOf(field)] = { key: field.key };
+                    }
+                }
+            }
+        }
+        return snapshot;
+    }
+}
+export function emptySnapshot() {
+    return {
+        version: 1,
+        entities: {},
+    };
+}

package/esm/migrations/generate-migrations.js

@@ -0,0 +1,51 @@
+import path from 'path';
+import fs from 'fs';
+import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-snapshots.js';
+import { updateMigrationsFile } from './update-migrations-ts-file.js';
+import { DefaultMigrationBuilder, } from './migration-types.js';
+import { isOfType } from '../src/isOfType.js';
+import { initDataProvider } from '../server/initDataProvider.js';
+export async function generateMigrations(options) {
+    const migrationDir = options.migrationsFolder ||
+        path.join(process.cwd(), 'src/server/migrations');
+    const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
+    const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
+    const dataProvider = await initDataProvider(options.dataProvider);
+    for (const p of [snapshotFileName, migrationsTSFilename]) {
+        if (!fs.existsSync(path.dirname(p))) {
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+        }
+    }
+    let snapshot = emptySnapshot();
+    if (fs.existsSync(snapshotFileName)) {
+        snapshot = JSON.parse(fs.readFileSync(snapshotFileName).toString());
+    }
+    let hasSql = false;
+    let steps = [];
+    const code = {
+        //https://marketplace.visualstudio.com/items?itemName=qufiwefefwoyn.inline-sql-syntax
+        addSql: (sql) => {
+            steps.push('await sql(`--sql\n' + sql + '`)');
+            hasSql = true;
+        },
+        addTypescriptCode: (code) => steps.push(code),
+        addComment: (comment) => steps.push(comment.indexOf('\n') >= 0 ? `/*${comment}*/` : `// ${comment}`),
+    };
+    let migrationBuilder = new DefaultMigrationBuilder(code);
+    if (isOfType(dataProvider, 'provideMigrationBuilder')) {
+        migrationBuilder = dataProvider.provideMigrationBuilder(code);
+    }
+    snapshot = await compareMigrationSnapshot({
+        entities: options.entities,
+        snapshot,
+        migrationBuilder,
+    });
+    if (steps.length)
+        await updateMigrationsFile(migrationsTSFilename, [
+            `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
+        ]);
+    fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+}

package/esm/migrations/index.js

@@ -0,0 +1,2 @@
+export { generateMigrations } from './generate-migrations.js';
+export { migrate } from './migrate.js';

package/esm/migrations/migrate.js

@@ -0,0 +1,66 @@
+import { __decorate, __metadata } from "tslib";
+import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
+import { initDataProvider } from '../server/initDataProvider.js';
+import { doTransaction } from '../src/context.js';
+import { cast, isOfType } from '../src/isOfType.js';
+export async function migrate(options) {
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProvider(options.dataProvider);
+    const prev = remult.dataProvider;
+    remult.dataProvider = dataProvider;
+    try {
+        let VersionInfo = class VersionInfo extends IdEntity {
+            version = -1;
+        };
+        __decorate([
+            Fields.number(),
+            __metadata("design:type", Object)
+        ], VersionInfo.prototype, "version", void 0);
+        VersionInfo = __decorate([
+            Entity(migrationTableName)
+        ], VersionInfo);
+        const repo = new Remult(dataProvider).repo(VersionInfo);
+        if (dataProvider.ensureSchema) {
+            await dataProvider.ensureSchema([repo.metadata]);
+        }
+        let v = await repo.findFirst();
+        if (!v) {
+            v = repo.create();
+            v.version = -1;
+        }
+        const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
+        for (const [stepText, action] of steps) {
+            const step = parseInt(stepText);
+            if (step < 0)
+                throw new Error('Migration step number must be a non-negative integer');
+            if (v.version >= step)
+                continue;
+            console.info('Executing migration step ' + step);
+            console.time('Completed migration step ' + step);
+            try {
+                await doTransaction(remult, async (dp) => {
+                    const utils = {
+                        sql: async (sql) => {
+                            await cast(dp, 'execute').execute(sql);
+                        },
+                    };
+                    await action(utils);
+                });
+                console.timeEnd('Completed migration step ' + step);
+            }
+            catch (err) {
+                console.error('Failed to execute migration step ' + step);
+                console.error(err);
+                throw err;
+            }
+            v.version = step;
+            await v.save();
+        }
+    }
+    finally {
+        remult.dataProvider = prev;
+    }
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+}

package/esm/migrations/migration-types.js

@@ -0,0 +1,12 @@
+export class DefaultMigrationBuilder {
+    code;
+    constructor(code) {
+        this.code = code;
+    }
+    async createTable(meta) {
+        this.code.addComment('create table ' + meta.entityType.name);
+    }
+    async addColumn(meta, field) {
+        this.code.addComment('add column ' + meta.entityType.name + '.' + field.key);
+    }
+}

package/esm/migrations/update-migrations-ts-file.js

@@ -0,0 +1,112 @@
+// consider replacing with https://www.npmjs.com/package/ts-morph
+import * as ts from 'typescript';
+import * as fs from 'fs';
+export async function updateMigrationsFile(filePath, steps) {
+    let maxStep = -1;
+    function buildSteps() {
+        return steps.map((step) => ts.factory.createPropertyAssignment(ts.factory.createIdentifier((++maxStep).toString()), ts.factory.createIdentifier(step)));
+    }
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '');
+    }
+    const importPath = 'remult/migrations';
+    const importName = 'Migrations';
+    // Load the file
+    const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
+    let migrationsExportFound = false;
+    // Find the "migrations" named export and add the new member
+    let updatedSourceFile = ts.transform(sourceFile, [
+        (context) => {
+            return (node) => {
+                const visitor = (node) => {
+                    if (ts.isVariableStatement(node) &&
+                        node.declarationList.declarations.length > 0) {
+                        const declaration = node.declarationList.declarations[0];
+                        if (ts.isIdentifier(declaration.name) &&
+                            declaration.name.text === 'migrations' &&
+                            declaration.initializer &&
+                            ts.isObjectLiteralExpression(declaration.initializer)) {
+                            migrationsExportFound = true;
+                            declaration.initializer.properties.forEach((property) => {
+                                if (ts.isPropertyAssignment(property)) {
+                                    if (ts.isNumericLiteral(property.name)) {
+                                        const step = parseInt(property.name.text);
+                                        if (step > maxStep) {
+                                            maxStep = step;
+                                        }
+                                    }
+                                }
+                            });
+                            let steps = buildSteps();
+                            // Found the "migrations" array
+                            // Update the initializer with the new steps
+                            const updatedInitializer = ts.factory.updateObjectLiteralExpression(declaration.initializer, [...declaration.initializer.properties, ...steps]);
+                            // Update the declaration with the new initializer
+                            const updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, undefined, declaration.type, // Preserve the original type annotation if present
+                            updatedInitializer);
+                            return ts.factory.updateVariableStatement(node, node.modifiers, ts.factory.updateVariableDeclarationList(node.declarationList, [
+                                updatedDeclaration,
+                            ]));
+                        }
+                    }
+                    return ts.visitEachChild(node, visitor, context);
+                };
+                return ts.visitNode(node, visitor);
+            };
+        },
+    ]).transformed[0];
+    if (!migrationsExportFound) {
+        let importFound = false;
+        // Check if the import statement already exists
+        sourceFile.statements.forEach((statement) => {
+            if (ts.isImportDeclaration(statement) &&
+                ts.isStringLiteral(statement.moduleSpecifier) &&
+                statement.moduleSpecifier.text === `${importPath}`) {
+                statement.importClause?.namedBindings?.forEachChild((namedBinding) => {
+                    if (ts.isImportSpecifier(namedBinding) &&
+                        namedBinding.name.text === importName) {
+                        importFound = true;
+                    }
+                });
+            }
+        });
+        // If the import statement doesn't exist, create it
+        if (!importFound) {
+            updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+                ts.factory.createExpressionStatement(ts.factory.createIdentifier(`import type { ${importName} } from '${importPath}'`)),
+                ...updatedSourceFile.statements,
+            ]);
+        }
+        // Create a new export for migrations if it doesn't exist
+        const newMigrationsExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration('migrations', undefined, // You can add a type annotation here if needed
+            ts.factory.createTypeReferenceNode(importName, undefined), ts.factory.createObjectLiteralExpression(buildSteps(), false)),
+        ], ts.NodeFlags.Const));
+        // Add the new export to the end of the file
+        updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+            ...updatedSourceFile.statements,
+            newMigrationsExport,
+        ]);
+    }
+    let code = ts.createPrinter().printFile(updatedSourceFile);
+    try {
+        let prettier;
+        try {
+            prettier = await import('prettier' + '');
+        }
+        catch (err) {
+            console.warn('error importing prettier,for better formatting run `npm i -D prettier`. Writing raw code to file.');
+        }
+        if (prettier) {
+            let options = await prettier.resolveConfig();
+            code = await prettier.format(code, {
+                ...options,
+                parser: 'typescript',
+            });
+        }
+    }
+    catch (err) {
+        console.log('error formatting code, writing raw code to file.');
+    }
+    fs.writeFileSync(filePath, code);
+}

package/esm/postgres/postgres-data-provider.js

@@ -1,3 +1,4 @@
+import { remult as defaultRemult } from '../src/remult-proxy.js';
 import pg from 'pg';
 const { Pool } = pg;
 import { Remult } from '../src/context.js';
@@ -8,8 +9,10 @@ export class PostgresDataProvider {
     options;
     supportsJsonColumnType = true;
     static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
+        const r = (remult || defaultRemult).dataProvider;
+        if (!r._getSourceSql)
+            throw 'the data provider is not an SqlDatabase';
+        const me = r._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -35,6 +38,21 @@ export class PostgresDataProvider {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
+    end() {
+        return this.pool.end();
+    }
+    provideMigrationBuilder(builder) {
+        var db = new SqlDatabase(this);
+        var sb = new PostgresSchemaBuilder(db, this.options?.schema);
+        return {
+            addColumn: async (meta, field) => {
+                builder.addSql(await sb.getAddColumnScript(meta, field));
+            },
+            createTable: async (meta) => {
+                builder.addSql(await sb.createTableScript(meta));
+            },
+        };
+    }
     wrapIdentifier = (name) => name
         .split('.')
         .map((name) => name.startsWith('"') ? name : '"' + name.replace(/"/g, '""') + '"')
@@ -172,4 +190,7 @@ export class PostgresSchemaWrapper {
             c.release();
         }
     }
+    end() {
+        return this.pool.end();
+    }
 }

package/esm/postgres/schema-builder.js

@@ -1,4 +1,4 @@
-import { dbNamesOf, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { remult as defaultRemult } from '../src/remult-proxy.js';
 import { remultStatic } from '../src/remult-static.js';
 import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
@@ -19,7 +19,7 @@ export function postgresColumnSyntax(x, dbName) {
             if (x.valueConverter == ValueConverters.DateOnly)
                 result += ' date';
             else
-                result += ' timestamp';
+                result += ' timestamptz';
         else
             result += ' ' + x.valueConverter.fieldTypeInDb;
     }
@@ -109,11 +109,9 @@ export class PostgresSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             try {
-                if (!entity.options.sqlExpression) {
-                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
+                if (shouldCreateEntity(entity, e)) {
+                    await this.createIfNotExist(entity);
+                    await this.verifyAllColumns(entity);
                 }
             }
             catch (err) {
@@ -130,29 +128,41 @@ export class PostgresSchemaBuilder {
             `${this.whereTableAndSchema(c, e)}`)
             .then(async (r) => {
             if (r.rows.length == 0) {
-                let result = '';
-                for (const x of entity.fields) {
-                    if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
-                        if (result.length != 0)
-                            result += ',';
-                        result += '\r\n  ';
-                        if (isAutoIncrement(x))
-                            result += e.$dbNameOf(x) + ' serial';
-                        else {
-                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
-                        }
-                        if (x == entity.idMetadata.field)
-                            result += ' primary key';
-                    }
-                }
-                let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
-CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
+                const sql = await this.createTableScript(entity);
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);
             }
         });
     }
+    /* @internal*/
+    async getAddColumnScript(entity, field) {
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+        return (`ALTER table ${this.schemaAndName(e)} ` +
+            `ADD column ${postgresColumnSyntax(field, e.$dbNameOf(field))}`);
+    }
+    /* @internal*/
+    async createTableScript(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x))
+                    result += e.$dbNameOf(x) + ' serial';
+                else {
+                    result += postgresColumnSyntax(x, e.$dbNameOf(x));
+                }
+                if (x == entity.idMetadata.field)
+                    result += ' primary key';
+            }
+        }
+        let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
+CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
+        return sql;
+    }
     async addColumnIfNotExist(entity, c) {
         let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
         if (shouldNotCreateField(c(entity), e))
@@ -163,8 +173,7 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
             if ((await cmd.execute(`SELECT 1 FROM information_schema.columns WHERE ` +
                 `${this.whereTableAndSchema(cmd, e)} ` +
                 `AND column_name=${cmd.param(colName.toLocaleLowerCase())}`)).rows.length == 0) {
-                let sql = `ALTER table ${this.schemaAndName(e)} ` +
-                    `ADD column ${postgresColumnSyntax(c(entity), colName)}`;
+                let sql = await this.getAddColumnScript(entity, c(entity));
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);

package/esm/remult-knex/index.js

@@ -1,4 +1,4 @@
-import { dbNamesOf, isDbReadonly, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf, isDbReadonly, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces.js';
 import { CompoundIdField } from '../src/CompoundIdField.js';
 import { remult as remultContext } from '../src/remult-proxy.js';
@@ -13,6 +13,34 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
+    end() {
+        return this.knex.destroy();
+    }
+    /* @internal */
+    provideMigrationBuilder(builder) {
+        var sb = new KnexSchemaBuilder(this.knex);
+        return {
+            async createTable(entity) {
+                let e = await dbNamesOf(entity, (x) => x);
+                sb.createTableKnexCommand(entity, e)
+                    .toSQL()
+                    .forEach((sql) => builder.addSql(sql.sql));
+            },
+            async addColumn(entity, field) {
+                let e = await dbNamesOf(entity, (x) => x);
+                await sb
+                    .createColumnKnexCommand(e, field, e.$dbNameOf(field))
+                    .toSQL()
+                    .forEach((sql) => builder.addSql(sql.sql));
+            },
+        };
+    }
+    createCommand() {
+        return new KnexBridgeToSQLCommand(this.knex);
+    }
+    execute(sql) {
+        return this.createCommand().execute(sql);
+    }
     static getDb(remult) {
         const r = (remult || remultContext).dataProvider;
         if (!r.knex)
@@ -350,11 +378,9 @@ export class KnexSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, (x) => x);
             try {
-                if (!entity.options.sqlExpression) {
-                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
+                if (shouldCreateEntity(entity, e)) {
+                    await this.createIfNotExist(entity);
+                    await this.verifyAllColumns(entity);
                 }
             }
             catch (err) {
@@ -366,27 +392,30 @@ export class KnexSchemaBuilder {
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity, (x) => x);
         if (!(await this.knex.schema.hasTable(e.$entityName))) {
-            let cols = new Map();
-            for (const f of entity.fields) {
-                cols.set(f, {
-                    name: e.$dbNameOf(f),
-                    readonly: shouldNotCreateField(f, e),
-                });
-            }
-            await logSql(this.knex.schema.createTable(e.$entityName, (b) => {
-                for (const x of entity.fields) {
-                    if (!cols.get(x).readonly || isAutoIncrement(x)) {
-                        if (isAutoIncrement(x))
-                            b.increments(cols.get(x).name);
-                        else {
-                            buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
-                            if (x == entity.idMetadata.field)
-                                b.primary([cols.get(x).name]);
-                        }
+            await logSql(this.createTableKnexCommand(entity, e));
+        }
+    }
+    createTableKnexCommand(entity, e) {
+        let cols = new Map();
+        for (const f of entity.fields) {
+            cols.set(f, {
+                name: e.$dbNameOf(f),
+                readonly: shouldNotCreateField(f, e),
+            });
+        }
+        return this.knex.schema.createTable(e.$entityName, (b) => {
+            for (const x of entity.fields) {
+                if (!cols.get(x).readonly || isAutoIncrement(x)) {
+                    if (isAutoIncrement(x))
+                        b.increments(cols.get(x).name);
+                    else {
+                        buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
+                        if (x == entity.idMetadata.field)
+                            b.primary([cols.get(x).name]);
                     }
                 }
-            }));
-        }
+            }
+        });
     }
     async addColumnIfNotExist(entity, c) {
         let e = await dbNamesOf(entity, (x) => x);
@@ -395,11 +424,14 @@ export class KnexSchemaBuilder {
         let col = c(entity);
         let colName = e.$dbNameOf(col);
         if (!(await this.knex.schema.hasColumn(e.$entityName, colName))) {
-            await logSql(this.knex.schema.alterTable(e.$entityName, (b) => {
-                buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
-            }));
+            await logSql(this.createColumnKnexCommand(e, col, colName));
         }
     }
+    createColumnKnexCommand(e, col, colName) {
+        return this.knex.schema.alterTable(e.$entityName, (b) => {
+            buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
+        });
+    }
     async verifyAllColumns(entity) {
         let e = await dbNamesOf(entity, (x) => x);
         try {
@@ -502,3 +534,59 @@ function translateValueAndHandleArrayAndHandleArray(field, val) {
         return JSON.stringify(result);
     return result;
 }
+class KnexBridgeToSQLCommand {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    values = [];
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (Array.isArray(val))
+            val = JSON.stringify(val);
+        this.values.push(val);
+        return '?';
+    }
+    async execute(sql) {
+        return await this.source.raw(sql, this.values).then((r) => {
+            switch (this.source.client.config.client) {
+                case 'mysql':
+                case 'mysql2':
+                    return new KnexPostgresBridgeToSQLQueryResult({
+                        fields: r[1],
+                        rows: r[0],
+                    });
+                case 'pg':
+                    return new KnexPostgresBridgeToSQLQueryResult(r);
+                default:
+                case 'better-sqlite3':
+                case 'mssql':
+                    return new KnexPostgresBridgeToSQLQueryResult({
+                        rows: r,
+                    });
+            }
+        });
+    }
+}
+class KnexPostgresBridgeToSQLQueryResult {
+    r;
+    getColumnKeyInResultForIndexInSelect(index) {
+        if (this.r.fields)
+            return this.r.fields[index].name;
+        if (this.rows.length == 0)
+            throw Error('No rows');
+        let i = 0;
+        for (let m in this.rows[0]) {
+            if (i++ == index)
+                return m;
+        }
+        throw Error('index not found');
+    }
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    rows;
+}