@mikro-orm/knex 7.0.0-dev.7 → 7.0.0-dev.70

package/schema/DatabaseTable.js

@@ -1,4 +1,4 @@
-import { Cascade, DecimalType, EntitySchema, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
+import { Cascade, DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
 /**
  * @internal
  */
@@ -91,47 +91,52 @@ export class DatabaseTable {
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.nativeEnumName || prop.items?.every(Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(i => typeof i === 'string') ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
             this.columns[field].unsigned ??= this.columns[field].autoincrement;
+            if (this.nativeEnums[type]) {
+                this.columns[field].enumItems ??= this.nativeEnums[type].items;
+            }
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
+            const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
             }
-            this.foreignKeys[constraintName] = {
-                constraintName,
-                columnNames: prop.fieldNames,
-                localTableName: this.getShortestName(false),
-                referencedColumnNames: prop.referencedColumnNames,
-                referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
-            };
-            const cascade = prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL);
-            if (prop.deleteRule || cascade || prop.nullable) {
-                this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
-            }
-            if (prop.updateRule) {
-                this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
-            }
-            if ((prop.cascade.includes(Cascade.PERSIST) || prop.cascade.includes(Cascade.ALL))) {
-                const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
-                    return fk.constraintName !== constraintName
-                        && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
-                        && fk.referencedTableName === this.foreignKeys[constraintName].referencedTableName;
-                });
-                if (!hasCascadePath || this.platform.supportsMultipleCascadePaths()) {
-                    this.foreignKeys[constraintName].updateRule ??= 'cascade';
+            if (prop.createForeignKeyConstraint) {
+                this.foreignKeys[constraintName] = {
+                    constraintName,
+                    columnNames: prop.fieldNames,
+                    localTableName: this.getShortestName(false),
+                    referencedColumnNames: prop.referencedColumnNames,
+                    referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
+                };
+                const cascade = prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL);
+                if (prop.deleteRule || cascade || prop.nullable) {
+                    this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
+                }
+                if (prop.updateRule) {
+                    this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
+                }
+                if ((prop.cascade.includes(Cascade.PERSIST) || prop.cascade.includes(Cascade.ALL))) {
+                    const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
+                        return fk.constraintName !== constraintName
+                            && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
+                            && fk.referencedTableName === this.foreignKeys[constraintName].referencedTableName;
+                    });
+                    if (!hasCascadePath || this.platform.supportsMultipleCascadePaths()) {
+                        this.foreignKeys[constraintName].updateRule ??= 'cascade';
+                    }
+                }
+                if (prop.deferMode) {
+                    this.foreignKeys[constraintName].deferMode = prop.deferMode;
                 }
-            }
-            if (prop.deferMode) {
-                this.foreignKeys[constraintName].deferMode = prop.deferMode;
             }
         }
         if (prop.index) {
@@ -157,7 +162,7 @@ export class DatabaseTable {
         }
     }
     getIndexName(value, columnNames, type) {
-        if (Utils.isString(value)) {
+        if (typeof value === 'string') {
             return value;
         }
         return this.platform.getIndexName(this.name, columnNames, type);
@@ -610,7 +615,7 @@ export class DatabaseTable {
             fkOptions.deferMode = fk.deferMode;
             fkOptions.columnTypes = fk.columnNames.map(col => this.getColumn(col).type);
         }
-        return {
+        const ret = {
             name: prop,
             type,
             runtimeType,
@@ -638,6 +643,11 @@ export class DatabaseTable {
             persist,
             ...fkOptions,
         };
+        const nativeEnumName = Object.keys(this.nativeEnums).find(name => name === column.type);
+        if (nativeEnumName) {
+            ret.nativeEnumName = nativeEnumName;
+        }
+        return ret;
     }
     getReferenceKind(fk, unique) {
         if (fk && unique) {
@@ -671,10 +681,17 @@ export class DatabaseTable {
         if (fk) {
             return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
+        const enumMode = this.platform.getConfig().get('entityGenerator').enumMode;
         // If this column is using an enum.
         if (column.enumItems?.length) {
-            // We will create a new enum name for this type and set it as the property type as well.
-            return namingStrategy.getEnumClassName(column.name, this.name, this.schema);
+            const name = column.nativeEnumName ?? column.name;
+            const tableName = column.nativeEnumName ? undefined : this.name;
+            if (enumMode === 'ts-enum') {
+                // We will create a new enum name for this type and set it as the property type as well.
+                return namingStrategy.getEnumClassName(name, tableName, this.schema);
+            }
+            // With other enum strategies, we need to use the type name.
+            return namingStrategy.getEnumTypeName(name, tableName, this.schema);
         }
         return column.mappedType?.runtimeType ?? 'unknown';
     }
@@ -697,6 +714,23 @@ export class DatabaseTable {
         }
         return '' + val;
     }
+    processIndexExpression(indexName, expression, meta) {
+        if (expression instanceof Function) {
+            const table = {
+                name: this.name,
+                schema: this.schema,
+                toString() {
+                    if (this.schema) {
+                        return `${this.schema}.${this.name}`;
+                    }
+                    return this.name;
+                },
+            };
+            const exp = expression(table, meta.createColumnMappingObject(), indexName);
+            return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+        }
+        return expression;
+    }
     addIndex(meta, index, type) {
         const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
             const parts = prop.split('.');
@@ -738,7 +772,7 @@ export class DatabaseTable {
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: index.expression,
+            expression: this.processIndexExpression(name, index.expression, meta),
             options: index.options,
             deferMode: index.deferMode,
         });

package/schema/SchemaComparator.js

@@ -269,7 +269,7 @@ export class SchemaComparator {
         }
         for (const toConstraint of Object.values(toForeignKeys)) {
             tableDifferences.addedForeignKeys[toConstraint.constraintName] = toConstraint;
-            this.log(`FK constraint ${toConstraint.constraintName} added from table ${tableDifferences.name}`, { constraint: toConstraint });
+            this.log(`FK constraint ${toConstraint.constraintName} added to table ${tableDifferences.name}`, { constraint: toConstraint });
             changes++;
         }
         return changes ? tableDifferences : false;
@@ -511,7 +511,7 @@ export class SchemaComparator {
             return str
                 ?.replace(/_\w+'(.*?)'/g, '$1')
                 .replace(/in\s*\((.*?)\)/ig, '= any (array[$1])')
-                .replace(/['"`()]|::\w+| +/g, '')
+                .replace(/['"`()\n[\]]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/ig, '$1')
                 .toLowerCase();
         };

package/schema/SchemaHelper.d.ts

@@ -63,6 +63,8 @@ export declare abstract class SchemaHelper {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected processComment(comment: string): string;

package/schema/SchemaHelper.js

@@ -119,9 +119,8 @@ export class SchemaHelper {
                 }
             }
             Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items, the values are case insensitive
-                itemsOld = itemsOld.map(v => v.toLowerCase());
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
                 if (enumName.includes('.')) {
                     const [enumSchemaName, rawEnumName] = enumName.split('.');
                     ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld)));
@@ -264,7 +263,12 @@ export class SchemaHelper {
         if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        if (useDefault) {
+            // https://dev.mysql.com/doc/refman/9.0/en/data-type-defaults.html
+            const needsExpression = ['blob', 'text', 'json', 'point', 'linestring', 'polygon', 'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection'].some(type => column.type.toLowerCase().startsWith(type));
+            const defaultSql = needsExpression && !column.default.startsWith('(') ? `(${column.default})` : column.default;
+            col.push(`default ${defaultSql}`);
+        }
         Utils.runIfNotEmpty(() => col.push(column.extra), column.extra);
         Utils.runIfNotEmpty(() => col.push(`comment ${this.platform.quoteValue(column.comment)}`), column.comment);
         return col.join(' ');

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type Dictionary, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -8,24 +8,27 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    create(options?: CreateSchemaOptions): Promise<void>;
     /**
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
     getTargetSchema(schema?: string): DatabaseSchema;
+    protected getOrderedMetadata(schema?: string): EntityMetadata[];
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    drop(options?: DropSchemaOptions): Promise<void>;
     createNamespace(name: string): Promise<void>;
     dropNamespace(name: string): Promise<void>;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
     private getSchemaName;
-    updateSchema(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
+    update(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
     getUpdateSchemaSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<string>;
     getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<{
         up: string;
@@ -45,7 +48,9 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     /**
      * creates new database and connects to it
      */
-    createDatabase(name?: string): Promise<void>;
+    createDatabase(name?: string, options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
     dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
@@ -54,5 +59,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
     private append;
+    private matchName;
+    private isTableSkipped;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -8,7 +8,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
-    async createSchema(options) {
+    async create(options) {
         await this.ensureDatabase();
         const sql = await this.getCreateSchemaSQL(options);
         await this.execute(sql);
@@ -17,6 +17,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
      * Returns true if the database was created.
      */
     async ensureDatabase(options) {
+        await this.connection.ensureConnection();
         const dbName = this.config.get('dbName');
         if (this.lastEnsuredDatabase === dbName && !options?.forceCheck) {
             return true;
@@ -27,18 +28,17 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             const managementDbName = this.helper.getManagementDbName();
             if (managementDbName) {
                 this.config.set('dbName', managementDbName);
-                await this.driver.reconnect();
-                await this.createDatabase(dbName);
-                this.config.set('dbName', dbName);
-                await this.driver.reconnect();
+                await this.driver.reconnect({ skipOnConnect: true });
+                await this.createDatabase(dbName, { skipOnConnect: true });
             }
             if (options?.create) {
-                await this.createSchema(options);
+                await this.create(options);
             }
             return true;
         }
+        /* v8 ignore next 3 */
         if (options?.clear) {
-            await this.clearDatabase(options);
+            await this.clear({ ...options, clearIdentityMap: false });
         }
         return false;
     }
@@ -47,6 +47,15 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
         return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
     }
+    getOrderedMetadata(schema) {
+        const metadata = super.getOrderedMetadata(schema);
+        // Filter out skipped tables
+        return metadata.filter(meta => {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema ?? schema ?? this.config.get('schema');
+            return !this.isTableSkipped(tableName, tableSchema);
+        });
+    }
     async getCreateSchemaSQL(options = {}) {
         const toSchema = this.getTargetSchema(options.schema);
         const ret = [];
@@ -80,7 +89,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return this.wrapSchema(ret, options);
     }
-    async dropSchema(options = {}) {
+    async drop(options = {}) {
         if (options.dropDb) {
             const name = this.config.get('dbName');
             return this.dropDatabase(name);
@@ -96,11 +105,11 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const sql = this.helper.getDropNamespaceSQL(name);
         await this.execute(sql);
     }
-    async clearDatabase(options) {
+    async clear(options) {
         // truncate by default, so no value is considered as true
         /* v8 ignore next 3 */
         if (options?.truncate === false) {
-            return super.clearDatabase(options);
+            return super.clear(options);
         }
         await this.execute(this.helper.disableForeignKeysSQL());
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
@@ -111,7 +120,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 .execute();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
-        this.clearIdentityMap();
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
     }
     async getDropSchemaSQL(options = {}) {
         await this.ensureDatabase();
@@ -156,7 +167,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return resolvedName;
     }
-    async updateSchema(options = {}) {
+    async update(options = {}) {
         const sql = await this.getUpdateSchemaSQL(options);
         await this.execute(sql);
     }
@@ -280,15 +291,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     /**
      * creates new database and connects to it
      */
-    async createDatabase(name) {
+    async createDatabase(name, options) {
         name ??= this.config.get('dbName');
         const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
         if (sql) {
-            // console.log(sql);
             await this.execute(sql);
         }
         this.config.set('dbName', name);
-        await this.driver.reconnect();
+        await this.driver.reconnect(options);
     }
     async dropDatabase(name) {
         name ??= this.config.get('dbName');
@@ -318,12 +328,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         if (this.platform.supportsMultipleStatements()) {
             for (const group of groups) {
                 const query = group.join('\n');
-                // console.log(query);
                 await this.driver.execute(query);
             }
             return;
         }
-        // console.log(groups);
         await Utils.runSerial(groups.flat(), line => this.driver.execute(line));
     }
     async dropTableIfExists(name, schema) {
@@ -349,6 +357,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     append(array, sql, pad) {
         return this.helper.append(array, sql, pad);
     }
+    matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    isTableSkipped(tableName, schemaName) {
+        const skipTables = this.options.skipTables;
+        if (!skipTables || skipTables.length === 0) {
+            return false;
+        }
+        const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+        return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
+    }
 }
 // for back compatibility
 export { SqlSchemaGenerator as SchemaGenerator };

package/typings.d.ts

@@ -1,4 +1,5 @@
-import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
+import type { Generated, Kysely } from 'kysely';
+import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName, EntitySchemaWithMeta, Primary, PrimaryProperty, Opt } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -27,6 +28,7 @@ export interface JoinOptions {
     cond_?: Dictionary;
     subquery?: string;
     nested?: Set<JoinOptions>;
+    parent?: JoinOptions;
 }
 export interface Column {
     name: string;
@@ -74,7 +76,7 @@ export interface IndexDef {
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: string;
     }>;
-    deferMode?: DeferMode;
+    deferMode?: DeferMode | `${DeferMode}`;
 }
 export interface CheckDef<T = unknown> {
     name: string;
@@ -170,11 +172,14 @@ export interface ICriteriaNodeProcessOptions {
     matchPopulateJoins?: boolean;
     ignoreBranching?: boolean;
     preferNoBranch?: boolean;
+    type?: 'orderBy';
+    filter?: boolean;
 }
 export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: string | undefined;
+    readonly strict?: boolean;
     payload: any;
     prop?: EntityProperty;
     index?: number;
@@ -182,8 +187,85 @@ export interface ICriteriaNode<T extends object> {
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
     getPath(addIndex?: boolean): string;
     getPivotPath(path: string): string;
 }
+export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
+export type InferEntityProperties<Schema> = Schema extends EntitySchemaWithMeta<any, any, any, any, infer Properties> ? Properties : never;
+export type InferKyselyDB<TEntities extends {
+    name: string;
+}, TOptions = {}> = MapValueAsTable<MapByName<TEntities>, TOptions>;
+export type InferDBFromKysely<TKysely extends Kysely<any>> = TKysely extends Kysely<infer TDB> ? TDB : never;
+type PreferStringLiteral<TCandidate, TFallback> = [
+    TCandidate
+] extends [never] ? TFallback : string extends TCandidate ? TFallback : TCandidate extends string ? TCandidate : TFallback;
+export type MapByName<T extends {
+    name: string;
+    tableName?: string;
+}> = {
+    [P in T as PreferStringLiteral<NonNullable<P['tableName']>, P['name']>]: P;
+};
+export type MapValueAsTable<TMap extends Record<string, any>, TOptions = {}> = {
+    [K in keyof TMap as TransformName<K, 'underscore'>]: InferKyselyTable<TMap[K], 'underscore'>;
+};
+export type InferKyselyTable<TSchema extends EntitySchemaWithMeta, TNamingStrategy extends 'underscore' | 'entity' = 'underscore', TProcessOnCreate extends boolean = false> = ExcludeNever<{
+    -readonly [K in keyof InferEntityProperties<TSchema> as TransformColumnName<K, TNamingStrategy, MaybeReturnType<InferEntityProperties<TSchema>[K]>>]: InferColumnValue<MaybeReturnType<InferEntityProperties<TSchema>[K]>, TProcessOnCreate>;
+}>;
+type TransformName<TName, TNamingStrategy extends 'underscore' | 'entity'> = TNamingStrategy extends 'underscore' ? TName extends string ? SnakeCase<TName> : TName : TName;
+type TransformColumnName<TName, TNamingStrategy extends 'underscore' | 'entity', TBuilder> = TNamingStrategy extends 'entity' ? TName : TBuilder extends {
+    '~options': {
+        fieldName: string;
+    };
+} ? TBuilder['~options']['fieldName'] : TName extends string ? MaybeJoinColumnName<SnakeCase<TName>, TBuilder> : never;
+type MaybeJoinColumnName<TName extends string, TBuilder> = TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': {
+        kind: 'm:1';
+    };
+} ? PrimaryProperty<Value> extends string ? `${TName}_${SnakeCase<PrimaryProperty<Value>>}` : never : TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': {
+        kind: '1:1';
+        owner: true;
+    };
+} ? PrimaryProperty<Value> extends string ? `${TName}_${SnakeCase<PrimaryProperty<Value>>}` : never : TName;
+export type SnakeCase<TName extends string> = TName extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uncapitalize<P1>}${SnakeCase<P2>}` : `${Uncapitalize<P1>}_${SnakeCase<Uncapitalize<P2>>}` : TName;
+type InferColumnValue<TBuilder, TProcessOnCreate extends boolean> = TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': infer TOptions;
+} ? MaybeNever<MaybeGenerated<MaybeJoinKey<Value, TOptions>, TOptions, TProcessOnCreate>, TOptions> : never;
+type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptions extends {
+    nullable: true;
+} ? (TValue | null) : TOptions extends {
+    autoincrement: true;
+} ? Generated<TValue> : TOptions extends {
+    default: true;
+} ? Generated<TValue> : TOptions extends {
+    defaultRaw: true;
+} ? Generated<TValue> : TProcessOnCreate extends false ? TValue : TOptions extends {
+    onCreate: Function;
+} ? Generated<TValue> : TValue;
+type MaybeJoinKey<TValue, TOptions> = TOptions extends {
+    kind: 'm:1';
+} ? UnwrapOpt<Primary<TValue>> : TOptions extends {
+    kind: '1:1';
+} ? TOptions extends {
+    owner: true;
+} ? UnwrapOpt<Primary<TValue>> : never : TValue;
+type UnwrapOpt<TValue> = TValue extends Opt<infer OriginalValue> ? OriginalValue : TValue;
+type MaybeNever<TValue, TOptions> = TOptions extends {
+    persist: true;
+} ? never : TOptions extends {
+    kind: 'm:n';
+} ? never : TValue;
+type ExcludeNever<TMap extends Record<string, any>> = {
+    [K in keyof TMap as TMap[K] extends never ? never : K]: TMap[K];
+};
 export {};