orchid-orm 1.31.1 → 1.31.3

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationQuery, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, QueryBase, TableDataFn, DbTableOptionScopes, SqlMethod, DefaultSchemaConfig, DefaultColumnTypes, RelationQueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
+import { Query, SelectableFromShape, CreateMethodsNames, CreateData, AddQueryDefaults, RelationConfigBase, UpdateData, WhereArg, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationJoinQuery, RelationQuery, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, QueryBase, TableDataFn, DbTableOptionScopes, SqlMethod, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
 export * from 'pqb';
-import { ColumnsShapeBase, EmptyObject, MaybeArray, CoreQueryScopes, ColumnShapeOutput, ColumnShapeInput, ColumnShapeInputPartial, ColumnSchemaConfig, RecordUnknown, QueryReturnType } from 'orchid-core';
+import { ColumnsShapeBase, EmptyObject, MaybeArray, RecordUnknown, Simplify, ColumnShapeOutput, ColumnShapeInput, ColumnShapeInputPartial, CoreQueryScopes, ColumnSchemaConfig, QueryColumns, QueryReturnType } from 'orchid-core';
 export * from 'orchid-core';
 
 interface RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> {
@@ -11,48 +11,41 @@ interface RelationRefsOptions<Column extends PropertyKey = string, Ref extends P
     columns: Column[];
     references: Ref[];
 }
-interface 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>;
 interface 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>;
 
 interface HasOne extends RelationThunkBase {
     type: 'hasOne';
     options: HasOneOptions;
 }
-type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape']> | RelationThroughOptions<Through, Source>);
+type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationRefsOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape']> | RelationThroughOptions<Through, Source>);
 type HasOneParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
     [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
-} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
-interface HasOneInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Populate = T['relations'][Name]['options'] extends RelationRefsOptions ? Record<T['relations'][Name]['options']['references'][number], true> : T['relations'][Name]['options'] extends RelationKeysOptions ? Record<T['relations'][Name]['options']['foreignKey'], true> : never, Q extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? {
+} : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
+type HasOnePopulate<T extends RelationConfigSelf, Name extends string> = T['relations'][Name]['options'] extends RelationRefsOptions ? Record<T['relations'][Name]['options']['references'][number], true> : never;
+type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationThroughOptions ? {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
-        defaults: Populate;
+        defaults: HasOnePopulate<T, Name>;
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
     } : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
 } : {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
-        defaults: Populate;
+        defaults: HasOnePopulate<T, Name>;
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
     } : K extends 'join' ? RelJoin : TableQuery[K];
-}, NestedCreateQuery extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> {
+};
+interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Q extends Query, CD = CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>> extends RelationConfigBase {
     query: Q;
-    methodQuery: T['relations'][Name]['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
-    joinQuery: RelationJoinQuery;
-    one: true;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
         [P in Name]?: RelationToOneDataForCreate<{
-            nestedCreateQuery: NestedCreateQuery;
+            nestedCreateQuery: CD;
             table: Q;
         }>;
     };
@@ -65,51 +58,39 @@ interface HasOneInfo<T extends RelationConfigSelf, Name extends keyof T['relatio
         update: UpdateData<Q>;
     };
     dataForUpdateOne: {
+        disconnect: boolean;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<Q>;
+    } | {
         set: WhereArg<Q>;
     } | {
         upsert: {
             update: UpdateData<Q>;
-            create: CreateData<NestedCreateQuery> | (() => CreateData<NestedCreateQuery>);
+            create: CD | (() => CD);
         };
     } | {
-        create: CreateData<NestedCreateQuery>;
+        create: CD;
     };
-    params: HasOneParams<T, T['relations'][Name]>;
 }
 
 interface HasMany extends RelationThunkBase {
     type: 'hasMany';
-    options: HasManyOptions;
+    options: HasOneOptions;
 }
-type HasManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Columns, Related, Scope, Through, Source>;
-type HasManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
-    [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
-} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
-interface HasManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Populate extends PropertyKey = T['relations'][Name]['options'] extends RelationRefsOptions ? T['relations'][Name]['options']['references'][number] : T['relations'][Name]['options'] extends RelationKeysOptions ? T['relations'][Name]['options']['foreignKey'] : never, Q extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
-        as: Name;
-        defaults: Record<Populate, true>;
-        hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
-} : {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
-        as: Name;
-        defaults: Record<Populate, true>;
-        hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : K extends 'join' ? RelJoin : TableQuery[K];
-}> {
+interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Q extends Query> extends RelationConfigBase {
     query: Q;
-    methodQuery: Q;
-    joinQuery: RelationJoinQuery;
-    one: false;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: {
-        [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
-            nestedCreateQuery: T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Record<Populate, true>>;
-            table: Q;
-        }>;
+        [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
+            create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>[];
+            connect?: WhereArg<Q>[];
+            connectOrCreate?: {
+                where: WhereArg<Q>;
+                create: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>;
+            }[];
+        };
     };
     dataForCreate: never;
     dataForUpdate: {
@@ -121,35 +102,41 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends keyof T['relati
         };
     };
     dataForUpdateOne: {
+        disconnect?: MaybeArray<WhereArg<Q>>;
+        delete?: MaybeArray<WhereArg<Q>>;
+        update?: {
+            where: MaybeArray<WhereArg<Q>>;
+            data: UpdateData<Q>;
+        };
         set?: MaybeArray<WhereArg<Q>>;
-        create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Record<Populate, true>>>[];
+        create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>[];
     };
-    params: HasManyParams<T, T['relations'][Name]>;
 }
 
-type RelJoin = JoinQueryMethod & (<T extends Query>(this: T) => T);
+interface RelJoin extends JoinQueryMethod {
+    <T extends Query>(this: T): T;
+}
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     options: BelongsToOptions;
 }
-type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape'], keyof InstanceType<Related>['columns']['shape'], keyof Columns>;
-type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never;
-type BelongsToParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = {
+interface BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> extends RelationCommonOptions<Related, Scope>, RelationRefsOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape']> {
+}
+type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : never;
+type BelongsToParams<T extends RelationConfigSelf, Relation extends BelongsTo> = {
     [Name in BelongsToFKey<Relation>]: T['columns']['shape'][Name]['type'];
 };
-interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, FK extends string, Required, Q extends Query = {
-    [P in keyof TableQuery]: P extends 'meta' ? // Omit is optimal
-    Omit<TableQuery['meta'], 'selectable'> & {
+type BelongsToQuery<T extends Query, Name extends string> = {
+    [P in keyof T]: P extends 'meta' ? // Omit is optimal
+    Omit<T['meta'], 'selectable'> & {
         as: Name;
         hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : P extends 'join' ? RelJoin : P extends CreateMethodsNames | DeleteMethodsNames ? never : TableQuery[P];
-}> {
+        selectable: SelectableFromShape<T['shape'], Name>;
+    } : P extends 'join' ? RelJoin : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P];
+};
+interface BelongsToInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Required, Q extends Query> extends RelationConfigBase {
     query: Q;
-    methodQuery: Required extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
-    joinQuery: RelationJoinQuery;
-    one: true;
     omitForeignKeyInCreate: FK;
     dataForCreate: {
         columns: {
@@ -174,12 +161,21 @@ interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['rela
         create: CreateData<Q>;
     };
     dataForUpdateOne: {
+        disconnect: boolean;
+    } | {
+        set: WhereArg<Q>;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<Q>;
+    } | {
+        create: CreateData<Q>;
+    } | {
         upsert: {
             update: UpdateData<Q>;
             create: CreateData<Q> | (() => CreateData<Q>);
         };
     };
-    params: BelongsToParams<T, T['relations'][Name]>;
 }
 
 declare function transaction<T extends {
@@ -272,7 +268,9 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 }
-type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
+interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> {
+    scope?: ScopeFn<Related, Scope>;
+    required?: boolean;
     columns: (keyof Columns)[];
     references: string[];
     through: {
@@ -280,37 +278,30 @@ type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeB
         columns: string[];
         references: (keyof InstanceType<Related>['columns']['shape'])[];
     };
-} | {
-    primaryKey: keyof Columns;
-    foreignKey: string;
-    joinTable: string;
-    associationPrimaryKey: string;
-    associationForeignKey: keyof InstanceType<Related>['columns']['shape'];
-});
-type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends {
-    columns: string[];
-} ? {
+}
+type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends HasAndBelongsToMany> = {
     [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
-} : Relation['options'] extends {
-    primaryKey: string;
-} ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : never;
-interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Q extends Query = {
+};
+type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
     } : K extends 'join' ? RelJoin : TableQuery[K];
-}> {
+};
+interface HasAndBelongsToManyInfo<Name extends string, Q extends Query> extends RelationConfigBase {
     query: Q;
-    methodQuery: Q;
     joinQuery: RelationJoinQuery;
-    one: false;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: {
-        [P in Name]?: RelationToManyDataForCreate<{
-            nestedCreateQuery: Q;
-            table: Q;
-        }>;
+        [P in Name]?: {
+            create?: CreateData<Q>[];
+            connect?: WhereArg<Q>[];
+            connectOrCreate?: {
+                where: WhereArg<Q>;
+                create: CreateData<Q>;
+            }[];
+        };
     };
     dataForCreate: never;
     dataForUpdate: {
@@ -323,15 +314,23 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends key
         };
         create?: CreateData<Q>[];
     };
-    dataForUpdateOne: EmptyObject;
-    params: HasAndBelongsToManyParams<T, T['relations'][Name]>;
+    dataForUpdateOne: {
+        disconnect?: MaybeArray<WhereArg<Q>>;
+        set?: MaybeArray<WhereArg<Q>>;
+        delete?: MaybeArray<WhereArg<Q>>;
+        update?: {
+            where: MaybeArray<WhereArg<Q>>;
+            data: UpdateData<Q>;
+        };
+        create?: CreateData<Q>[];
+    };
 }
 
 type RelationToOneDataForCreate<Rel extends {
-    nestedCreateQuery: Query;
+    nestedCreateQuery: unknown;
     table: Query;
 }> = {
-    create: CreateData<Rel['nestedCreateQuery']>;
+    create: Rel['nestedCreateQuery'];
     connect?: never;
     connectOrCreate?: never;
 } | {
@@ -343,7 +342,7 @@ type RelationToOneDataForCreate<Rel extends {
     connect?: never;
     connectOrCreate: {
         where: WhereArg<Rel['table']>;
-        create: CreateData<Rel['nestedCreateQuery']>;
+        create: Rel['nestedCreateQuery'];
     };
 };
 type RelationToOneDataForCreateSameQuery<Q extends Query> = {
@@ -362,17 +361,6 @@ type RelationToOneDataForCreateSameQuery<Q extends Query> = {
         create: CreateData<Q>;
     };
 };
-type RelationToManyDataForCreate<Rel extends {
-    nestedCreateQuery: Query;
-    table: Query;
-}> = {
-    create?: CreateData<Rel['nestedCreateQuery']>[];
-    connect?: WhereArg<Rel['table']>[];
-    connectOrCreate?: {
-        where: WhereArg<Rel['table']>;
-        create: CreateData<Rel['nestedCreateQuery']>;
-    }[];
-};
 interface RelationThunkBase {
     type: string;
     fn(): TableClass;
@@ -389,10 +377,10 @@ interface RelationConfigSelf {
     };
     relations: RelationThunks;
 }
-type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation> : Relation extends HasOne ? HasOneParams<T, Relation> : Relation extends HasMany ? HasManyParams<T, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation> : never;
-type MapRelation<T extends RelationConfigSelf, K extends keyof T['relations'] & string> = RelationQuery<T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, RelationScopeOrTable<T['relations'][K]>, BelongsToFKey<T['relations'][K]>, T['relations'][K]['options']['required']> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : never>;
+type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation> : never;
+type MapRelation<T extends RelationConfigSelf, K extends keyof T['relations'] & string, R extends Query> = T['relations'][K] extends BelongsTo ? RelationQuery<BelongsToInfo<T, K, T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<R, K>>, BelongsToParams<T, T['relations'][K]>, T['relations'][K]['options']['required'], true> : T['relations'][K] extends HasOne ? RelationQuery<HasOneInfo<T, K, HasOneQuery<T, K, RelationScopeOrTable<T['relations'][K]>>>, HasOneParams<T, T['relations'][K]>, T['relations'][K]['options']['required'], true> : T['relations'][K] extends HasMany ? RelationQuery<HasManyInfo<T, K, HasOneQuery<T, K, RelationScopeOrTable<T['relations'][K]>>>, HasOneParams<T, T['relations'][K]>, true, false> : T['relations'][K] extends HasAndBelongsToMany ? RelationQuery<HasAndBelongsToManyInfo<K, HasAndBelongsToManyQuery<K, RelationScopeOrTable<T['relations'][K]>>>, HasAndBelongsToManyParams<T, T['relations'][K]>, true, false> : never;
 type MapRelations<T> = T extends RelationConfigSelf ? {
-    [K in keyof T['relations'] & string]: MapRelation<T, K>;
+    [K in keyof T['relations'] & string]: MapRelation<T, K, RelationScopeOrTable<T['relations'][K]>>;
 } : EmptyObject;
 
 interface TableClass<T extends Table = Table> {
@@ -402,16 +390,14 @@ interface TableClass<T extends Table = Table> {
 interface TableClasses {
     [K: string]: TableClass;
 }
-interface RelationQueriesBase {
-    [K: string]: RelationQueryBase;
-}
-interface TableToDb<T extends Table, RelationQueries extends RelationQueriesBase> extends Db<T['table'], T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, RelationQueries, T['types'], T['columns']['shape'] & ComputedColumnsFromOptions<T['computed']>, MapTableScopesOption<T['scopes'], T['softDelete']>> {
+interface TableToDb<T extends Table, Relations extends RelationsBase> extends Db<T['table'], T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, T['types'], T['columns']['shape'] & ComputedColumnsFromOptions<T['computed']>, MapTableScopesOption<T['scopes'], T['softDelete']>> {
+    relations: Relations;
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
     name: string;
 }
-type DbTable<T extends Table> = TableToDb<T, MapRelations<T>> & MapRelations<T>;
+type DbTable<T extends Table> = T extends RelationConfigSelf ? TableToDb<T, MapRelations<T>> & MapRelations<T> : TableToDb<T, RelationsBase>;
 type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<InstanceType<Related>>) => Scope;
 interface Table {
     table: string;
@@ -428,19 +414,23 @@ interface Table {
      * collect computed columns returned by {@link BaseTable.setColumns}
      */
     computed?: ComputedOptionsFactory<never, never>;
-    scopes?: CoreQueryScopes;
+    scopes?: RecordUnknown;
     readonly softDelete?: true | string;
     comment?: string;
 }
-type Queryable<T extends Table> = {
+type Queryable<T extends Table> = Simplify<{
     [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
-};
-type Selectable<T extends Table> = ColumnShapeOutput<T['columns']['shape']>;
-type Insertable<T extends Table> = ColumnShapeInput<T['columns']['shape']>;
-type Updatable<T extends Table> = ColumnShapeInputPartial<T['columns']['shape']>;
-type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
-type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
-type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns']['shape'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']['shape']>) => T;
+}>;
+type Selectable<T extends Table> = Simplify<ColumnShapeOutput<T['columns']['shape']>>;
+type Insertable<T extends Table> = Simplify<ColumnShapeInput<T['columns']['shape']>>;
+type Updatable<T extends Table> = Simplify<ColumnShapeInputPartial<T['columns']['shape']>>;
+type BeforeHookMethod = (cb: QueryBeforeHook) => void;
+type AfterHookMethod = (cb: QueryAfterHook) => void;
+type AfterSelectableHookMethod = <Shape extends QueryColumns, S extends (keyof Shape)[]>(this: {
+    columns: {
+        shape: Shape;
+    };
+}, select: S, cb: AfterHook<S, Shape>) => void;
 interface SetColumnsResult<Shape extends ColumnsShapeBase, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
     shape: Shape;
     data: Data extends unknown[] ? Data : [Data];
@@ -584,7 +574,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Columns, Related, Scope, Through, Source>>(this: {
+    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };

package/dist/index.js

@@ -299,8 +299,8 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
   }
 }
 const makeBelongsToMethod = (relation, relationName, query) => {
-  const primaryKeys = "columns" in relation.options ? relation.options.references : [relation.options.primaryKey];
-  const foreignKeys = "columns" in relation.options ? relation.options.columns : [relation.options.foreignKey];
+  const primaryKeys = relation.options.references;
+  const foreignKeys = relation.options.columns;
   const len = primaryKeys.length;
   const state = { query, primaryKeys, foreignKeys, len };
   const makeWhere = relationWhere(len, primaryKeys, foreignKeys);
@@ -617,8 +617,8 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
       reverseJoin: reverseJoin2
     };
   }
-  const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
-  const foreignKeys = "columns" in relation.options ? relation.options.references : [relation.options.foreignKey];
+  const primaryKeys = relation.options.columns;
+  const foreignKeys = relation.options.references;
   const state = { query, primaryKeys, foreignKeys };
   const len = primaryKeys.length;
   const reversedOn = {};
@@ -879,8 +879,8 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
       reverseJoin: reverseJoin2
     };
   }
-  const primaryKeys = "columns" in relation.options ? relation.options.columns : [relation.options.primaryKey];
-  const foreignKeys = "columns" in relation.options ? relation.options.references : [relation.options.foreignKey];
+  const primaryKeys = relation.options.columns;
+  const foreignKeys = relation.options.references;
   const state = { query, primaryKeys, foreignKeys };
   const len = primaryKeys.length;
   const reversedOn = {};
@@ -977,7 +977,10 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
             obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
           }
           queries.push(
-            pqb._queryUpdate(t.where(item.where), obj)
+            pqb._queryUpdate(
+              t.where(item.where),
+              obj
+            )
           );
         }
       }
@@ -1147,25 +1150,12 @@ const removeColumnName = (column) => {
   return cloned;
 };
 const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
-  let primaryKeys;
-  let foreignKeys;
-  let joinTable;
-  let throughForeignKeys;
-  let throughPrimaryKeys;
   const { options } = relation;
-  if ("columns" in options) {
-    primaryKeys = options.columns;
-    foreignKeys = options.references;
-    joinTable = options.through.table;
-    throughForeignKeys = options.through.columns;
-    throughPrimaryKeys = options.through.references;
-  } else {
-    primaryKeys = [options.primaryKey];
-    foreignKeys = [options.foreignKey];
-    joinTable = options.joinTable;
-    throughForeignKeys = [options.associationForeignKey];
-    throughPrimaryKeys = [options.associationPrimaryKey];
-  }
+  const primaryKeys = options.columns;
+  const foreignKeys = options.references;
+  const joinTable = options.through.table;
+  const throughForeignKeys = options.through.columns;
+  const throughPrimaryKeys = options.through.references;
   const { snakeCase } = table.internal;
   const foreignKeysFull = foreignKeys.map((key, i) => {
     if (snakeCase)