orchid-orm 1.14.4 → 1.15.0

package/dist/index.d.ts

@@ -1,18 +1,34 @@
 import * as pqb from 'pqb';
-import { QueryWithTable, SetQueryTableAlias, Query, WhereArg, UpdateData, CreateData, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationConfigBase, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, RelationQueryBase, DefaultColumnTypes, QueryData, QueryBase, ColumnsShape, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, QueryWithTable, SetQueryTableAlias, WhereArg, UpdateData, CreateData, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationConfigBase, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, RelationQueryBase, DefaultColumnTypes, QueryData, QueryBase, ColumnsShape, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, raw, testTransaction } from 'pqb';
 import * as orchid_core from 'orchid-core';
 import { EmptyObject, MaybeArray, ColumnTypesBase, ColumnsShapeBase, ColumnShapeOutput } from 'orchid-core';
 
-interface BelongsTo extends RelationThunkBase {
+type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
+    scope?: ScopeFn<Related, Scope>;
+    required?: boolean;
+};
+type RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> = {
+    columns: Column[];
+    references: Ref[];
+};
+type RelationKeysOptions<PK extends PropertyKey = string, FK extends PropertyKey = string> = {
+    primaryKey: PK;
+    foreignKey: FK;
+};
+type RelationRefsOrKeysOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string, PK extends PropertyKey = string, FK extends PropertyKey = string> = RelationRefsOptions<Column, Ref> | RelationKeysOptions<PK, FK>;
+type RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> = {
+    through: Through;
+    source: Source;
+};
+type RelationHasOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> = RelationRefsOrKeysOptions<Column, Ref, Column, Ref>;
+
+type BelongsTo = RelationThunkBase & {
     type: 'belongsTo';
-    returns: 'one';
-    options: RelationCommonOptions & {
-        primaryKey: string;
-        foreignKey: string;
-    };
-}
-type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options']['foreignKey'], Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>> = {
+    options: BelongsToOptions;
+};
+type BelongsToOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Self['columns']['shape'], keyof InstanceType<Related>['columns']['shape'], keyof InstanceType<Related>['columns']['shape'], keyof Self['columns']['shape']>;
+type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>> = {
     table: Q;
     query: Q;
     joinQuery(fromQuery: Query, toQuery: Query): Query;
@@ -40,26 +56,20 @@ type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string
             create: CreateData<Q> | (() => CreateData<Q>);
         };
     };
-    params: Record<FK, T['columns']['shape'][FK]['type']>;
+    params: {
+        [K in FK]: T['columns']['shape'][FK]['type'];
+    };
     populate: never;
     chainedCreate: false;
     chainedDelete: false;
 };
 
-interface HasMany extends RelationThunkBase {
+type HasMany = RelationThunkBase & {
     type: 'hasMany';
-    returns: 'many';
-    options: RelationCommonOptions & ({
-        primaryKey: string;
-        foreignKey: string;
-    } | {
-        through: string;
-        source: string;
-    });
-}
-type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, Populate extends string = Relation['options'] extends {
-    foreignKey: string;
-} ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = [Populate] extends [never] ? Q : Q & {
+    options: HasManyOptions;
+};
+type HasManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Self, Related, Scope, Through, Source>;
+type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, Populate extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['references'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : Q & {
     meta: {
         defaults: Record<Populate, true>;
     };
@@ -70,9 +80,7 @@ type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation ext
     one: false;
     required: Relation['options']['required'] extends true ? true : false;
     omitForeignKeyInCreate: never;
-    dataForCreate: Relation['options'] extends {
-        through: string;
-    } ? EmptyObject : RelationToManyDataForCreate<{
+    dataForCreate: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
         nestedCreateQuery: NestedCreateQuery;
         table: Q;
     }>;
@@ -88,32 +96,20 @@ type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation ext
         set?: MaybeArray<WhereArg<Q>>;
         create?: CreateData<NestedCreateQuery>[];
     };
-    params: Relation['options'] extends {
-        primaryKey: string;
-    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
-        through: string;
-    } ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
+    params: Relation['options'] extends RelationRefsOptions ? {
+        [K in Relation['options']['columns'][number]]: T['columns']['shape'][K]['type'];
+    } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
     populate: Populate;
-    chainedCreate: Relation['options'] extends {
-        primaryKey: string;
-    } ? true : false;
+    chainedCreate: Relation['options'] extends RelationThroughOptions ? false : true;
     chainedDelete: true;
 };
 
-interface HasOne extends RelationThunkBase {
+type HasOne = RelationThunkBase & {
     type: 'hasOne';
-    returns: 'one';
-    options: RelationCommonOptions & ({
-        primaryKey: string;
-        foreignKey: string;
-    } | {
-        through: string;
-        source: string;
-    });
-}
-type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, Populate extends string = Relation['options'] extends {
-    foreignKey: string;
-} ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = [Populate] extends [never] ? Q : Q & {
+    options: HasOneOptions;
+};
+type HasOneOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Self['columns']['shape'], keyof InstanceType<Related>['columns']['shape']> | RelationThroughOptions<Through, Source>);
+type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, Populate extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['references'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : Q & {
     meta: {
         defaults: Record<Populate, true>;
     };
@@ -124,9 +120,7 @@ type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation exte
     one: true;
     required: Relation['options']['required'] extends true ? true : false;
     omitForeignKeyInCreate: never;
-    dataForCreate: Relation['options'] extends {
-        through: string;
-    } ? EmptyObject : RelationToOneDataForCreate<{
+    dataForCreate: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToOneDataForCreate<{
         nestedCreateQuery: NestedCreateQuery;
         table: Q;
     }>;
@@ -147,15 +141,11 @@ type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation exte
     } | {
         create: CreateData<NestedCreateQuery>;
     };
-    params: Relation['options'] extends {
-        primaryKey: string;
-    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
-        through: string;
-    } ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
+    params: Relation['options'] extends RelationRefsOptions ? {
+        [K in Relation['options']['columns'][number]]: T['columns']['shape'][K]['type'];
+    } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
     populate: Populate;
-    chainedCreate: Relation['options'] extends {
-        primaryKey: string;
-    } ? true : false;
+    chainedCreate: Relation['options'] extends RelationThroughOptions ? false : true;
     chainedDelete: true;
 };
 
@@ -241,17 +231,25 @@ declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedSta
     noPrimaryKey?: NoPrimaryKeyOption | undefined;
 }, tables: T) => OrchidORM<T>;
 
-interface HasAndBelongsToMany extends RelationThunkBase {
+type HasAndBelongsToMany = RelationThunkBase & {
     type: 'hasAndBelongsToMany';
-    returns: 'many';
-    options: RelationCommonOptions & {
-        primaryKey: string;
-        foreignKey: string;
-        associationPrimaryKey: string;
-        associationForeignKey: string;
-        joinTable: string;
+    options: HasAndBelongsToManyOptions;
+};
+type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
+    columns: (keyof Self['columns']['shape'])[];
+    references: string[];
+    through: {
+        table: string;
+        columns: string[];
+        references: (keyof InstanceType<Related>['columns']['shape'])[];
     };
-}
+} | {
+    primaryKey: keyof Self['columns']['shape'];
+    foreignKey: string;
+    joinTable: string;
+    associationPrimaryKey: string;
+    associationForeignKey: keyof InstanceType<Related>['columns']['shape'];
+});
 type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, K extends string, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>> = {
     table: Q;
     query: Q;
@@ -274,16 +272,18 @@ type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMa
         create?: CreateData<Q>[];
     };
     dataForUpdateOne: EmptyObject;
-    params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
+    params: Relation['options'] extends {
+        columns: string[];
+    } ? {
+        [K in Relation['options']['columns'][number]]: T['columns']['shape'][K]['type'];
+    } : Relation['options'] extends {
+        primaryKey: string;
+    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : never;
     populate: never;
     chainedCreate: true;
     chainedDelete: true;
 };
 
-type RelationCommonOptions = {
-    scope?(q: QueryWithTable): QueryWithTable;
-    required?: boolean;
-};
 type RelationToOneDataForCreate<Rel extends {
     nestedCreateQuery: Query;
     table: Query;
@@ -316,7 +316,6 @@ type RelationToManyDataForCreate<Rel extends {
 };
 interface RelationThunkBase {
     type: string;
-    returns: 'one' | 'many';
     fn(): TableClass;
     options: RelationCommonOptions;
 }
@@ -647,58 +646,23 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
             shape: T_13;
             type: ColumnShapeOutput<T_13>;
         };
-        belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
-            primaryKey: keyof InstanceType<Related>["columns"]["shape"];
-            foreignKey: keyof Self["columns"]["shape"];
-            scope?: ScopeFn<Related, Scope> | undefined;
-            required?: boolean | undefined;
-        }>(this: Self, fn: () => Related, options: Options): {
+        belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends BelongsToOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
             type: "belongsTo";
-            returns: "one";
             fn: () => Related;
             options: Options;
         };
-        hasOne<Self_1 extends any, Related_1 extends TableClass<Table>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
-            primaryKey: keyof Self_1["columns"]["shape"];
-            foreignKey: keyof InstanceType<Related_1>["columns"]["shape"];
-        } | {
-            through: Through;
-            source: Source;
-        }) & {
-            scope?: ScopeFn<Related_1, Scope_1> | undefined;
-            required?: boolean | undefined;
-        }>(this: Self_1, fn: () => Related_1, options: Options_1): {
+        hasOne<Self_1 extends any, Related_1 extends TableClass<Table>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends HasOneOptions<Self_1, Related_1, Scope_1, Through, Source>>(this: Self_1, fn: () => Related_1, options: Options_1): {
             type: "hasOne";
-            returns: "one";
             fn: () => Related_1;
             options: Options_1;
         };
-        hasMany<Self_2 extends any, Related_2 extends TableClass<Table>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
-            primaryKey: keyof Self_2["columns"]["shape"];
-            foreignKey: keyof InstanceType<Related_2>["columns"]["shape"];
-        } | {
-            through: Through_1;
-            source: Source_1;
-        }) & {
-            scope?: ScopeFn<Related_2, Scope_2> | undefined;
-            required?: boolean | undefined;
-        }>(this: Self_2, fn: () => Related_2, options: Options_2): {
+        hasMany<Self_2 extends any, Related_2 extends TableClass<Table>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends HasManyOptions<Self_2, Related_2, Scope_2, Through_1, Source_1>>(this: Self_2, fn: () => Related_2, options: Options_2): {
             type: "hasMany";
-            returns: "many";
             fn: () => Related_2;
             options: Options_2;
         };
-        hasAndBelongsToMany<Self_3 extends any, Related_3 extends TableClass<Table>, Scope_3 extends Query, Options_3 extends {
-            primaryKey: keyof Self_3["columns"]["shape"];
-            associationPrimaryKey: keyof InstanceType<Related_3>["columns"]["shape"];
-            foreignKey: string;
-            associationForeignKey: string;
-            joinTable: string;
-            scope?: ScopeFn<Related_3, Scope_3> | undefined;
-            required?: boolean | undefined;
-        }>(this: Self_3, fn: () => Related_3, options: Options_3): {
+        hasAndBelongsToMany<Self_3 extends any, Related_3 extends TableClass<Table>, Scope_3 extends Query, Options_3 extends HasAndBelongsToManyOptions<Self_3, Related_3, Scope_3>>(this: Self_3, fn: () => Related_3, options: Options_3): {
             type: "hasAndBelongsToMany";
-            returns: "many";
             fn: () => Related_3;
             options: Options_3;
         };
@@ -744,4 +708,4 @@ type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T
 }>(q: Q) => Q & Mapped) & T & Mapped;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
 
-export { DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableToDb, TableType, createBaseTable, createRepo, orchidORM };
+export { DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, ScopeFn, Table, TableClass, TableClasses, TableToDb, TableType, createBaseTable, createRepo, orchidORM };