@mikro-orm/knex 6.0.0-dev.9 → 6.0.0-dev.90

package/schema/DatabaseTable.js

@@ -14,6 +14,7 @@ class DatabaseTable {
         this.indexes = [];
         this.checks = [];
         this.foreignKeys = {};
+        this.nativeEnums = {}; // for postgres
         Object.defineProperties(this, {
             platform: { enumerable: false, writable: true },
         });
@@ -41,7 +42,7 @@ class DatabaseTable {
             const type = v.name in enums ? 'enum' : v.type;
             v.mappedType = this.platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
-            v.enumItems = enums[v.name] || [];
+            v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
             return o;
         }, {});
@@ -51,7 +52,6 @@ class DatabaseTable {
     }
     addColumnFromProperty(prop, meta) {
         prop.fieldNames.forEach((field, idx) => {
-            var _a;
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.platform.getMappedType(type);
             if (mappedType instanceof core_1.DecimalType) {
@@ -64,9 +64,9 @@ class DatabaseTable {
                 }
             }
             if (mappedType instanceof core_1.DateTimeType) {
-                prop.length ?? (prop.length = this.platform.getDefaultDateTimeLength());
+                prop.length ??= this.platform.getDefaultDateTimeLength();
             }
-            const primary = !meta.compositePK && !!prop.primary && prop.reference === core_1.ReferenceType.SCALAR && this.platform.isNumericColumn(mappedType);
+            const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
@@ -74,21 +74,22 @@ class DatabaseTable {
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ?? primary,
                 primary,
+                nativeEnumName: prop.nativeEnumName,
                 nullable: !!prop.nullable,
                 length: prop.length,
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            (_a = this.columns[field]).unsigned || (_a.unsigned = this.columns[field].autoincrement);
+            this.columns[field].unsigned ||= this.columns[field].autoincrement;
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.ONE_TO_ONE].includes(prop.reference)) {
+        if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.schema === '*' ? this.schema : prop.targetMeta.schema ?? this.schema;
             if (prop.referencedTableName.includes('.')) {
@@ -102,11 +103,11 @@ class DatabaseTable {
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
             };
             const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) || prop.cascade.includes(core_1.Cascade.ALL);
-            if (prop.onDelete || cascade || prop.nullable) {
-                this.foreignKeys[constraintName].deleteRule = prop.onDelete || (cascade ? 'cascade' : 'set null');
+            if (prop.deleteRule || cascade || prop.nullable) {
+                this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.onUpdateIntegrity || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
-                this.foreignKeys[constraintName].updateRule = prop.onUpdateIntegrity || 'cascade';
+            if (prop.updateRule || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
+                this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
         }
         if (prop.index) {
@@ -164,8 +165,8 @@ class DatabaseTable {
         }
         const meta = schema.init().meta;
         meta.relations
-            .filter(prop => prop.primary && prop.reference === core_1.ReferenceType.MANY_TO_ONE && !meta.compositePK)
-            .forEach(prop => prop.reference = core_1.ReferenceType.ONE_TO_ONE);
+            .filter(prop => prop.primary && prop.kind === core_1.ReferenceKind.MANY_TO_ONE && !meta.compositePK)
+            .forEach(prop => prop.kind = core_1.ReferenceKind.ONE_TO_ONE);
         return meta;
     }
     /**
@@ -206,20 +207,20 @@ class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column);
         const index = compositeFkIndexes[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
         const unique = compositeFkUniques[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
-        const reference = this.getReferenceType(fk, unique);
+        const kind = this.getReferenceKind(fk, unique);
         const type = this.getPropertyType(namingStrategy, column, fk);
         const fkOptions = {};
         if (fk) {
             fkOptions.fieldNames = fk.columnNames;
             fkOptions.referencedTableName = fk.referencedTableName;
             fkOptions.referencedColumnNames = fk.referencedColumnNames;
-            fkOptions.onUpdateIntegrity = fk.updateRule?.toLowerCase();
-            fkOptions.onDelete = fk.deleteRule?.toLowerCase();
+            fkOptions.updateRule = fk.updateRule?.toLowerCase();
+            fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
         }
         return {
             name: prop,
             type,
-            reference,
+            kind,
             columnType: column.type,
             default: this.getPropertyDefaultValue(schemaHelper, column, type),
             defaultRaw: this.getPropertyDefaultValue(schemaHelper, column, type, true),
@@ -234,14 +235,14 @@ class DatabaseTable {
             ...fkOptions,
         };
     }
-    getReferenceType(fk, unique) {
+    getReferenceKind(fk, unique) {
         if (fk && unique) {
-            return core_1.ReferenceType.ONE_TO_ONE;
+            return core_1.ReferenceKind.ONE_TO_ONE;
         }
         if (fk) {
-            return core_1.ReferenceType.MANY_TO_ONE;
+            return core_1.ReferenceKind.MANY_TO_ONE;
         }
-        return core_1.ReferenceType.SCALAR;
+        return core_1.ReferenceKind.SCALAR;
     }
     getPropertyName(namingStrategy, column) {
         const fk = Object.values(this.foreignKeys).find(fk => fk.columnNames.includes(column.name));
@@ -288,7 +289,7 @@ class DatabaseTable {
         return '' + val;
     }
     addIndex(meta, index, type) {
-        const properties = core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+        const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames)));
         if (properties.length === 0 && !index.expression) {
             return;
         }
@@ -308,10 +309,10 @@ class DatabaseTable {
     }
     toJSON() {
         const { platform, columns, ...rest } = this;
-        const columnsMapped = Object.keys(columns).reduce((o, col) => {
+        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
             const { mappedType, ...restCol } = columns[col];
             o[col] = restCol;
-            o[col].mappedType = Object.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
+            o[col].mappedType = core_1.Utils.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };

package/schema/SchemaComparator.js

@@ -425,8 +425,10 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        const unquote = (str) => str?.replace(/['"`]/g, '');
-        return unquote(check1.expression) !== unquote(check2.expression);
+        // check constraint definition might be normalized by the driver,
+        // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
+        const simplify = (str) => str?.replace(/['"`()]/g, '').toLowerCase();
+        return simplify(check1.expression) !== simplify(check2.expression);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -437,6 +439,11 @@ class SchemaComparator {
             const defaultValueTo = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + to.default);
             return defaultValueFrom === defaultValueTo;
         }
+        if (to.mappedType instanceof core_1.JsonType) {
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
+        }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {
             // normalize now/current_timestamp defaults, also remove `()` from the end of default expression
             const defaultValueFrom = from.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');

package/schema/SchemaHelper.d.ts

@@ -18,7 +18,9 @@ export declare abstract class SchemaHelper {
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
@@ -29,8 +31,8 @@ export declare abstract class SchemaHelper {
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
-    getAlterColumnAutoincrement(tableName: string, column: Column): string;
-    getChangeColumnCommentSQL(tableName: string, to: Column): string;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
     getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;

package/schema/SchemaHelper.js

@@ -46,7 +46,13 @@ class SchemaHelper {
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
-    async loadInformationSchema(schema, connection, tables) {
+    getDropNativeEnumSQL(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    getAlterNativeEnumSQL(name, schema, value) {
+        throw new Error('Not supported by given driver');
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
         for (const t of tables) {
             const table = schema.addTable(t.table_name, t.schema_name);
             table.comment = t.table_comment;
@@ -122,17 +128,17 @@ class SchemaHelper {
             core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
         }
         else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), column.default !== undefined);
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
         }
         return col;
     }
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
-    getAlterColumnAutoincrement(tableName, column) {
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }
-    getChangeColumnCommentSQL(tableName, to) {
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
     async getNamespaces(connection) {

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-import type { MikroORM, ISchemaGenerator } from '@mikro-orm/core';
+import type { ISchemaGenerator, MikroORM } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
@@ -8,8 +8,6 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private readonly options;
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    generate(): Promise<string>;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -82,10 +80,10 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * creates new database and connects to it
      */
     createDatabase(name: string): Promise<void>;
-    dropDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
-    }): Promise<undefined>;
+    }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;
     private createTable;

package/schema/SqlSchemaGenerator.js

@@ -13,14 +13,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    async generate() {
-        const [dropSchema, createSchema] = await Promise.all([
-            this.getDropSchemaSQL({ wrap: false }),
-            this.getCreateSchemaSQL({ wrap: false }),
-        ]);
-        return this.wrapSchema(dropSchema + createSchema);
-    }
     async createSchema(options) {
         await this.ensureDatabase();
         const sql = await this.getCreateSchemaSQL(options);
@@ -101,7 +93,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.ensureDatabase();
         const wrap = options.wrap ?? this.options.disableForeignKeys;
         const metadata = this.getOrderedMetadata(options.schema).reverse();
-        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
+        const schemas = this.getTargetSchema(options.schema).getNamespaces();
+        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         let ret = '';
         // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
@@ -118,6 +111,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         for (const meta of metadata) {
             ret += await this.dump(this.dropTable(meta.collection, this.getSchemaName(meta, options)), '\n');
         }
+        if (this.platform.supportsNativeEnums()) {
+            for (const columnName of Object.keys(schema.getNativeEnums())) {
+                const sql = this.helper.getDropNativeEnumSQL(columnName, options.schema ?? this.config.get('schema'));
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+            }
+        }
         if (options.dropMigrationsTable) {
             ret += await this.dump(this.dropTable(this.config.get('migrations').tableName, this.config.get('schema')), '\n');
         }
@@ -140,7 +139,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
-        await this.ensureDatabase();
+        if (!options.fromSchema) {
+            await this.ensureDatabase();
+        }
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
@@ -151,14 +152,16 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         };
     }
     async prepareSchemaForComparison(options) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
-        options.safe ?? (options.safe = false);
-        options.dropTables ?? (options.dropTables = true);
+        options.wrap ??= this.options.disableForeignKeys;
+        options.safe ??= false;
+        options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
-        const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
+        const schemas = toSchema.getNamespaces();
+        const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
+        toSchema.setNativeEnums(fromSchema.getNativeEnums());
         return { fromSchema, toSchema };
     }
     async diffToSQL(schemaDiff, options) {
@@ -262,6 +265,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
+        const changedNativeEnums = [];
+        for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+            if (column.nativeEnumName && changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
+                changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
+            }
+        }
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const index of Object.values(diff.removedIndexes)) {
                 this.dropIndex(table, index);
@@ -298,17 +307,20 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 if (changedProperties.size === 1 && changedProperties.has('comment')) {
                     continue;
                 }
+                if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
+                    continue;
+                }
                 const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties).alter();
                 this.helper.configureColumn(column, col, this.knex, changedProperties);
             }
             for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column, schemaName));
             }
             for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
                 if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
                     continue; // will be handled via knex
                 }
-                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column, schemaName));
             }
             for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
                 this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
@@ -345,6 +357,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 table.comment(comment);
             }
         }));
+        if (this.platform.supportsNativeEnums()) {
+            changedNativeEnums.forEach(([enumName, itemsNew, itemsOld]) => {
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
+                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
+            });
+        }
         return ret;
     }
     /**
@@ -356,24 +375,26 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.driver.reconnect();
     }
     async dropDatabase(name) {
+        name ??= this.config.get('dbName');
         this.config.set('dbName', this.helper.getManagementDbName());
         await this.driver.reconnect();
         await this.driver.execute(this.helper.getDropDatabaseSQL('' + this.knex.ref(name)));
     }
     async execute(sql, options = {}) {
-        options.wrap ?? (options.wrap = false);
+        options.wrap ??= false;
         const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
         if (lines.length === 0) {
             return;
         }
         if (this.platform.supportsMultipleStatements()) {
             const query = lines.join('\n');
-            return void await this.driver.execute(query);
+            await this.driver.execute(query);
+            return;
         }
         await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
-    wrapSchema(sql, options = {}) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
+    wrapSchema(sql, options) {
+        options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;
         }

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
+import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
 import type { QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
@@ -11,7 +11,7 @@ export type KnexStringRef = Knex.Ref<string, {
     [alias: string]: string;
 }>;
 type AnyString = string & {};
-export type Field<T> = AnyString | keyof T | KnexStringRef | Knex.QueryBuilder;
+export type Field<T> = AnyString | keyof T | RawQueryFragment | KnexStringRef | Knex.QueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
@@ -25,6 +25,7 @@ export interface JoinOptions {
     path?: string;
     prop: EntityProperty;
     cond: Dictionary;
+    cond_?: Dictionary;
 }
 export interface Column {
     name: string;
@@ -38,6 +39,7 @@ export interface Column {
     scale?: number;
     default?: string | null;
     comment?: string;
+    nativeEnumName?: string;
     enumItems?: string[];
     primary?: boolean;
     unique?: boolean;
@@ -122,7 +124,8 @@ export interface IQueryBuilder<T> {
     join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
+    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
+    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -136,16 +139,16 @@ export interface IQueryBuilder<T> {
     getAliasForJoinPath(path: string): string | undefined;
     getNextAlias(entityName?: string): string;
 }
-export interface ICriteriaNode {
+export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
-    readonly parent?: ICriteriaNode | undefined;
+    readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: string | undefined;
     payload: any;
     prop?: EntityProperty;
     index?: number;
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+    process(qb: IQueryBuilder<T>, alias?: string): any;
     shouldInline(payload: any): boolean;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
     getPath(addIndex?: boolean): string;