@mikro-orm/knex 7.0.0-dev.4 → 7.0.0-dev.41

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;
@@ -163,17 +165,21 @@ export interface IQueryBuilder<T> {
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
     hasFlag(flag: QueryFlag): boolean;
+    scheduleFilterCheck(path: string): void;
 }
 export interface ICriteriaNodeProcessOptions {
     alias?: string;
     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;
@@ -181,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 {};