@mikro-orm/knex 7.0.0-dev.38 → 7.0.0-dev.39

package/SqlEntityManager.d.ts

@@ -1,8 +1,13 @@
-import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions, type RawQueryFragment } from '@mikro-orm/core';
+import { type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
 import type { SqlEntityRepository } from './SqlEntityRepository.js';
+import type { Kysely } from 'kysely';
+import type { InferKyselyDB } from './typings.js';
+export interface GetKyselyOptions {
+    type?: ConnectionType;
+}
 /**
  * @inheritDoc
  */
@@ -18,8 +23,10 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * Returns configured Kysely instance.
      */
-    getKysely(type?: ConnectionType): import("kysely").Kysely<any>;
+    getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> : TDB>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
+type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? (Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta>) : never;
+export {};

package/SqlEntityManager.js

@@ -19,8 +19,8 @@ export class SqlEntityManager extends EntityManager {
     /**
      * Returns configured Kysely instance.
      */
-    getKysely(type) {
-        return this.getConnection(type).getClient();
+    getKysely(options = {}) {
+        return this.getConnection(options.type).getClient();
     }
     async execute(query, params = [], method = 'all', loggerContext) {
         return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.38",
+  "version": "7.0.0-dev.39",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -57,6 +57,6 @@
     "@mikro-orm/core": "^6.5.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.38"
+    "@mikro-orm/core": "7.0.0-dev.39"
   }
 }

package/typings.d.ts

@@ -1,9 +1,10 @@
-import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
+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';
 import type { QueryBuilder } from './query/QueryBuilder.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+import type { Generated, Kysely } from 'kysely';
 export interface Table {
     table_name: string;
     schema_name?: string;
@@ -189,4 +190,81 @@ export interface ICriteriaNode<T extends object> {
     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 {};