@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.6

package/{dist/schema → schema}/SchemaHelper.js

@@ -24,25 +24,51 @@ class SchemaHelper {
     supportsSchemaConstraints() {
         return true;
     }
-    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-        const pk = indexes.find(i => i.primary);
-        return pk ? pk.columnNames : [];
+    async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
+        const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
+        return core_1.Utils.flatten(pks);
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
     }
+    getTableKey(t) {
+        const unquote = (str) => str.replace(/['"`]/g, '');
+        const parts = t.table_name.split('.');
+        if (parts.length > 1) {
+            return `${unquote(parts[0])}.${unquote(parts[1])}`;
+        }
+        if (t.schema_name) {
+            return `${unquote(t.schema_name)}.${unquote(t.table_name)}`;
+        }
+        return unquote(t.table_name);
+    }
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
+    async loadInformationSchema(schema, connection, tables) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name);
+            table.comment = t.table_comment;
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema, cols);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, checks, table.name, table.schema);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
     getListTablesSQL(schemaName) {
         throw new Error('Not supported by given driver');
     }
-    getRenameColumnSQL(tableName, oldColumnName, to) {
+    getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         tableName = this.platform.quoteIdentifier(tableName);
         oldColumnName = this.platform.quoteIdentifier(oldColumnName);
         const columnName = this.platform.quoteIdentifier(to.name);
-        return `alter table ${tableName} rename column ${oldColumnName} to ${columnName}`;
+        const schemaReference = (schemaName !== undefined && schemaName !== 'public') ? ('"' + schemaName + '".') : '';
+        const tableReference = schemaReference + tableName;
+        return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
     getCreateIndexSQL(tableName, index) {
         /* istanbul ignore if */
@@ -59,13 +85,22 @@ class SchemaHelper {
     getRenameIndexSQL(tableName, index, oldIndexName) {
         return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
     }
+    hasNonDefaultPrimaryKeyName(table) {
+        const pkIndex = table.getPrimaryKey();
+        if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
+            return false;
+        }
+        const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
+        return pkIndex?.keyName !== defaultName;
+    }
     createTableColumn(table, column, fromTable, changedProperties) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
         if (column.autoincrement && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
             if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey: !changedProperties });
+                return table.bigIncrements(column.name, { primaryKey });
             }
-            return table.increments(column.name, { primaryKey: !changedProperties });
+            return table.increments(column.name, { primaryKey });
         }
         if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
             return table.enum(column.name, column.enumItems);
@@ -100,13 +135,16 @@ class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to) {
         return '';
     }
+    async getNamespaces(connection) {
+        return [];
+    }
     async getColumns(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
     async getIndexes(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
-    async getChecks(connection, tableName, schemaName) {
+    async getChecks(connection, tableName, schemaName, columns) {
         throw new Error('Not supported by given driver');
     }
     async mapIndexes(indexes) {

package/{dist/schema → schema}/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/{dist/typings.d.ts → typings.d.ts}

@@ -7,10 +7,11 @@ export interface Table {
     schema_name?: string;
     table_comment?: string;
 }
-export declare type KnexStringRef = Knex.Ref<string, {
+export type KnexStringRef = Knex.Ref<string, {
     [alias: string]: string;
 }>;
-export declare type Field<T> = string | keyof T | KnexStringRef | Knex.QueryBuilder;
+type AnyString = string & {};
+export type Field<T> = AnyString | keyof T | KnexStringRef | Knex.QueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
@@ -42,6 +43,7 @@ export interface Column {
     unique?: boolean;
     /** mysql only */
     extra?: string;
+    ignoreSchemaChanges?: ('type' | 'extra')[];
 }
 export interface ForeignKey {
     columnNames: string[];
@@ -81,6 +83,7 @@ export interface TableDifference {
     name: string;
     changedComment?: string;
     fromTable: DatabaseTable;
+    toTable: DatabaseTable;
     addedColumns: Dictionary<Column>;
     changedColumns: Dictionary<ColumnDifference>;
     removedColumns: Dictionary<Column>;
@@ -107,7 +110,7 @@ export interface SchemaDifference {
 }
 export interface IQueryBuilder<T> {
     readonly alias: string;
-    readonly type: QueryType;
+    readonly type?: QueryType;
     _fields?: Field<T>[];
     select(fields: Field<T> | Field<T>[], distinct?: boolean): this;
     addSelect(fields: string | string[]): this;
@@ -148,3 +151,4 @@ export interface ICriteriaNode {
     getPath(addIndex?: boolean): string;
     getPivotPath(path: string): string;
 }
+export {};