orchid-orm 1.59.3 → 1.59.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Column, TableData, ColumnsShape, Query, SelectableFromShape, CreateManyMethodsNames, CreateData, AddQueryDefaults, RelationConfigBase, QueryTake, QueryTakeOptional, EmptyObject, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ComputedOptionsConfig, QueryOrExpression, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, QueryScopes, ColumnSchemaConfig, StaticSQLArgs, RawSql, DynamicSQLArg, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHookInternal, QueryAfterHook, AfterHook, WhereResult, MergeQuery, QueryReturnType } from 'pqb';
+import { Column, TableData, ColumnsShape, Query, SelectableFromShape, CreateManyMethodsNames, QueryHasWhere, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, EmptyObject, CreateData, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ComputedOptionsConfig, QueryOrExpression, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, QueryScopes, ColumnSchemaConfig, StaticSQLArgs, RawSql, DynamicSQLArg, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHookInternal, QueryAfterHook, AfterHook, MergeQuery, QueryReturnType } from 'pqb';
 export * from 'pqb';
 
 interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
@@ -20,36 +20,27 @@ interface HasOne extends RelationThunkBase {
 interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
     required?: boolean;
 }
-type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, InstanceType<Related>['columns']['shape']> | RelationHasOneThroughOptions<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 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 HasOneQueryThrough<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
-        as: Name;
-        defaults: HasOnePopulate<T, Name>;
-        hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
-};
-type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationThroughOptions ? HasOneQueryThrough<T, Name, TableQuery> : {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
-        as: Name;
-        defaults: HasOnePopulate<T, Name>;
-        hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : K extends 'join' ? RelJoin : K extends CreateManyMethodsNames ? never : TableQuery[K];
-};
-interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query, CD = T['relations'][Name]['options'] extends RelationThroughOptions ? CreateData<Q> : CreateData<AddQueryDefaults<Q, HasOnePopulate<T, Name>>>> extends RelationConfigBase {
+type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
+type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? {
+    [Name in Options['columns'][number]]: T['columns']['shape'][Name]['type'];
+} : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
+type HasOneQueryThrough<Name extends string, TableQuery extends Query> = {
+    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K];
+} & QueryHasWhere & HasRelJoin;
+type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
+    [K in keyof TableQuery]: K extends '__defaults' ? {
+        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
+    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K];
+} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
+interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
     returnsOne: true;
     query: Q;
-    params: HasOneParams<T, Rel>;
-    maybeSingle: T['relations'][Name]['options']['required'] extends true ? QueryTake<Q> : QueryTakeOptional<Q>;
+    params: HasOneParams<T, Rel['options']>;
+    maybeSingle: T['relations'][Name]['options']['required'] extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
         [P in Name]?: RelationToOneDataForCreate<{
-            nestedCreateQuery: CD;
+            nestedCreateQuery: CreateData<Q>;
             table: Q;
         }>;
     };
@@ -72,10 +63,10 @@ interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel exte
     } | {
         upsert: {
             update: UpdateData<Q>;
-            create: CD | (() => CD);
+            create: CreateData<Q> | (() => CreateData<Q>);
         };
     } | {
-        create: CD;
+        create: CreateData<Q>;
     };
 }
 
@@ -83,27 +74,24 @@ interface HasMany extends RelationThunkBase {
     type: 'hasMany';
     options: HasOneOptions;
 }
-type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationThroughOptions ? HasOneQueryThrough<T, Name, TableQuery> : {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
-        as: Name;
-        defaults: HasOnePopulate<T, Name>;
-        hasWhere: true;
-        selectable: SelectableFromShape<TableQuery['shape'], Name>;
-    } : K extends 'join' ? RelJoin : TableQuery[K];
-};
+type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
+    [K in keyof TableQuery]: K extends '__defaults' ? {
+        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
+    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
+} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
 interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany, Q extends Query> extends RelationConfigBase {
     returnsOne: false;
     query: Q;
-    params: HasOneParams<T, Rel>;
+    params: HasOneParams<T, Rel['options']>;
     maybeSingle: Q;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: {
         [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
-            create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>[];
+            create?: CreateData<Q>[];
             connect?: WhereArg<Q>[];
             connectOrCreate?: {
                 where: WhereArg<Q>;
-                create: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>;
+                create: CreateData<Q>;
             }[];
         };
     };
@@ -125,42 +113,39 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
         };
         set?: MaybeArray<WhereArg<Q>>;
         add?: MaybeArray<WhereArg<Q>>;
-        create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>[];
+        create?: CreateData<Q>[];
     };
 }
 
 interface RelJoin extends JoinQueryMethod {
     <T extends Query>(this: T): T;
 }
+interface HasRelJoin {
+    join: RelJoin;
+}
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     options: BelongsToOptions;
 }
-interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass> {
+interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
     required?: boolean;
     columns: (keyof Columns)[];
-    references: (keyof InstanceType<Related>['columns']['shape'])[];
+    references: (keyof Related['columns']['shape'])[];
     foreignKey?: boolean | TableData.References.Options;
-    on?: ColumnsShape.InputPartial<InstanceType<Related>['columns']['shape']>;
+    on?: ColumnsShape.InputPartial<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'];
+type BelongsToParams<T extends RelationConfigSelf, FK extends string> = {
+    [Name in FK]: T['columns']['shape'][Name]['type'];
 };
 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<T['shape'], Name>;
-    } : P extends 'join' ? RelJoin : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P];
-};
-interface BelongsToInfo<T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo, FK extends string, Required, Q extends Query> extends RelationConfigBase {
+    [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P];
+} & QueryHasWhere & HasRelJoin;
+interface BelongsToInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Required, Q extends Query> extends RelationConfigBase {
     returnsOne: true;
     query: Q;
-    params: BelongsToParams<T, Rel>;
-    maybeSingle: Required extends true ? QueryTake<Q> : QueryTakeOptional<Q>;
+    params: BelongsToParams<T, FK>;
+    maybeSingle: Required extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
     omitForeignKeyInCreate: FK;
     dataForCreate: {
         columns: FK;
@@ -220,8 +205,11 @@ interface FromQuery extends Query {
     returnType: 'all';
 }
 type OrchidORM<T extends TableClasses = TableClasses> = {
-    [K in keyof T]: ORMTableInputToQueryBuilder<InstanceType<T[K]>>;
-} & {
+    [K in keyof T]: T[K] extends {
+        new (): infer R extends ORMTableInput;
+    } ? TableToDb<R> : never;
+} & OrchidORMMethods;
+interface OrchidORMMethods {
     /**
      * @see import('pqb').Transaction.prototype.transaction
      */
@@ -302,7 +290,7 @@ type OrchidORM<T extends TableClasses = TableClasses> = {
      */
     $from<Arg extends MaybeArray<FromArg<Query>>>(arg: Arg): FromResult<FromQuery, Arg>;
     $close(): Promise<void>;
-};
+}
 type OrchidOrmParam<Options> = true | null extends true ? 'Set strict: true to tsconfig' : Options;
 declare const orchidORMWithAdapter: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: OrchidOrmParam<({
     db: Query;
@@ -314,7 +302,7 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 }
-interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass> {
+interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
     required?: boolean;
     columns: (keyof Columns)[];
     references: string[];
@@ -322,25 +310,21 @@ interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Co
     through: {
         table: string;
         columns: string[];
-        references: (keyof InstanceType<Related>['columns']['shape'])[];
+        references: (keyof Related['columns']['shape'])[];
         foreignKey?: boolean | TableData.References.Options;
     };
-    on?: ColumnsShape.InputPartial<InstanceType<Related>['columns']['shape']>;
+    on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends HasAndBelongsToMany> = {
-    [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
+type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = {
+    [Name in FK]: T['columns']['shape'][Name]['type'];
 };
 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<T extends RelationConfigSelf, Name extends string, Rel extends HasAndBelongsToMany, Q extends Query> extends RelationConfigBase {
+    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
+} & QueryHasWhere & HasRelJoin;
+interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Q extends Query> extends RelationConfigBase {
     returnsOne: false;
     query: Q;
-    params: HasAndBelongsToManyParams<T, Rel>;
+    params: HasAndBelongsToManyParams<T, FK>;
     maybeSingle: Q;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: {
@@ -415,25 +399,26 @@ type RelationToOneDataForCreateSameQuery<Q extends Query> = {
 };
 interface RelationThunkBase {
     type: string;
-    fn(): TableClass;
+    related: ORMTableInput;
     options: unknown;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 interface RelationThunks {
     [K: string]: RelationThunk;
 }
-type RelationTableToQuery<Relation extends RelationThunkBase> = ORMTableInputToQueryBuilder<InstanceType<ReturnType<Relation['fn']>>>;
+type RelationTableToQuery<Relation> = Relation extends {
+    related: infer R extends ORMTableInput;
+} ? TableToDb<R> : never;
 interface RelationConfigSelf {
     columns: {
         shape: Column.Shape.QueryInit;
     };
     relations: RelationThunks;
 }
-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 RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation['options']['columns'][number] & string> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation['options']> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation['options']['columns'][number] & string> : never;
 
 interface TableClass<T extends ORMTableInput = ORMTableInput> {
     new (): T;
-    instance(): T;
 }
 interface TableClasses {
     [K: string]: TableClass;
@@ -446,12 +431,11 @@ interface TableInfo {
 }
 interface Table extends Query, TableInfo {
 }
-interface TableToDb<T extends ORMTableInput, Relations extends RelationsBase> extends TableInfo, 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>> {
-    relations: Relations;
+interface TableToDb<T extends ORMTableInput> extends TableInfo, 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>, ColumnsShape.DefaultSelectKeys<T['columns']['shape']>> {
+    relations: T extends RelationConfigSelf ? {
+        [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationTableToQuery<T['relations'][K]>, K>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never;
+    } : EmptyObject;
 }
-type ORMTableInputToQueryBuilder<T extends ORMTableInput> = T extends RelationConfigSelf ? TableToDb<T, T extends RelationConfigSelf ? {
-    [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, T['relations'][K], T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationTableToQuery<T['relations'][K]>, K>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K], HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never;
-} : EmptyObject> : TableToDb<T, EmptyObject>;
 interface ORMTableInput {
     table: string;
     columns: {
@@ -617,40 +601,48 @@ interface BaseTableInstance<ColumnTypes> {
             shape: Shape;
         };
     }, scopes: DbTableOptionScopes<Table, Shape, Keys>): QueryScopes<Keys>;
-    belongsTo<Columns extends Column.Shape.QueryInit, Related extends TableClass, Options extends BelongsToOptions<Columns, Related>>(this: {
+    belongsTo<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends BelongsToOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
-    }, fn: () => Related, options: Options): {
+    }, fn: () => {
+        new (): Related;
+    }, options: Options): {
         type: 'belongsTo';
-        fn: () => Related;
+        related: Related;
         options: Options;
     };
-    hasOne<Columns extends Column.Shape.QueryInit, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
-    }, fn: () => Related, options: Options): {
+    }, fn: () => {
+        new (): Related;
+    }, options: Options): {
         type: 'hasOne';
-        fn: () => Related;
+        related: Related;
         options: Options;
     };
-    hasMany<Columns extends Column.Shape.QueryInit, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
-    }, fn: () => Related, options: Options): {
+    }, fn: () => {
+        new (): Related;
+    }, options: Options): {
         type: 'hasMany';
-        fn: () => Related;
+        related: Related;
         options: Options;
     };
-    hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends TableClass, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
+    hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
-    }, fn: () => Related, options: Options): {
+    }, fn: () => {
+        new (): Related;
+    }, options: Options): {
         type: 'hasAndBelongsToMany';
-        fn: () => Related;
+        related: Related;
         options: Options;
     };
     beforeQuery: BeforeHookMethod;
@@ -722,13 +714,13 @@ type QueryOne<T extends Query> = {
 interface MethodsBase<T extends Query> {
     queryMethods?: QueryMethods<T>;
     queryOneMethods?: QueryMethods<QueryOne<T>>;
-    queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
-    queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
+    queryWithWhereMethods?: QueryMethods<T & QueryHasWhere>;
+    queryOneWithWhereMethods?: QueryMethods<QueryOne<T & QueryHasWhere>>;
     methods?: RecordUnknown;
 }
 type MapQueryMethods<BaseQuery extends Query, Method> = Method extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
 type MapMethods<T extends Query, Methods extends MethodsBase<T>> = {
-    [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<WhereResult<Query>>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<WhereResult<Query>, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never;
+    [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never;
 };
 type Repo<T extends Query, Methods extends MethodsBase<T>> = T & MapMethods<T, Methods>;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<(<Q extends {
@@ -736,4 +728,4 @@ declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(tabl
     shape: T['shape'];
 }>(q: Q) => Query & Q & MapMethods<T, Methods>) & T, Methods>;
 
-export { type BaseTableClass, type BaseTableInstance, type DefaultSelect, type Insertable, type MapMethods, type MapQueryMethods, type MethodsBase, type ORMTableInput, type ORMTableInputToQueryBuilder, type OrchidORM, type OrchidOrmParam, type Queryable, type Repo, type Selectable, type SetColumnsResult, type Table, type TableClass, type TableClasses, type TableInfo, type TableToDb, type Updatable, createBaseTable, createRepo, orchidORMWithAdapter };
+export { type BaseTableClass, type BaseTableInstance, type DefaultSelect, type Insertable, type MapMethods, type MapQueryMethods, type MethodsBase, type ORMTableInput, type OrchidORM, type OrchidOrmParam, type Queryable, type Repo, type Selectable, type SetColumnsResult, type Table, type TableClass, type TableClasses, type TableInfo, type TableToDb, type Updatable, createBaseTable, createRepo, orchidORMWithAdapter };

package/dist/index.js

@@ -422,7 +422,10 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
         q,
         (as) => {
           foreignKeys.forEach((foreignKey, i) => {
-            item[foreignKey]._sql = `(SELECT "${as}"."${primaryKeys[i]}" FROM "${as}")`;
+            item[foreignKey]._sql = selectCteColumnSql(
+              as,
+              primaryKeys[i]
+            );
           });
         },
         "create" in value ? pqb._queryCreate(selectPKeys, value.create) : pqb._orCreate(
@@ -437,9 +440,8 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
       const as = pqb.getFreeAlias(q.q.withShapes, "q");
       pqb._with(q, as, query.select(...primaryKeys).findBy(value.connect));
       foreignKeys.map((foreignKey, i) => {
-        const selectColumn = `(SELECT "${as}"."${primaryKeys[i]}" FROM "${as}")`;
         item[foreignKey] = new pqb.RawSql(
-          i === 0 ? `CASE WHEN (SELECT count(*) FROM "${as}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn
+          selectCteColumnMustExistSql(i, as, primaryKeys[i])
         );
       });
       return;
@@ -543,13 +545,18 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
           }
         }
         if (loadPrimaryKeys) {
-          const record = await pqb._queryFindBy(
-            query.select(...loadPrimaryKeys),
-            params.set
-          );
           for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
-            update[loadForeignKeys[i]] = record[loadPrimaryKeys[i]];
+            update[loadForeignKeys[i]] = new pqb.RawSql("");
           }
+          pqb._with(
+            q2,
+            (as) => {
+              for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
+                update[loadForeignKeys[i]]._sql = selectCteColumnMustExistSql(i, as, loadPrimaryKeys[i]);
+              }
+            },
+            pqb._queryFindBy(query.select(...loadPrimaryKeys), params.set)
+          );
         }
       } else if (params.create) {
         const q3 = query.clone();
@@ -646,6 +653,11 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
     }
   };
 };
+const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const selectCteColumnMustExistSql = (i, cteAs, column) => {
+  const selectColumn = selectCteColumnSql(cteAs, column);
+  return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
+};
 
 class HasOneVirtualColumn extends pqb.VirtualColumn {
   constructor(schema, key, state) {