orchid-orm 1.59.2 → 1.59.4

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, CreateData, AddQueryDefaults, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, 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, MergeQuery, QueryReturnType } from 'pqb';
 export * from 'pqb';
 
 interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
@@ -20,32 +20,22 @@ 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 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 HasOnePopulate<T extends RelationConfigSelf, Name extends string> = T['relations'][Name]['options'] extends RelationRefsOptions ? T['relations'][Name]['options']['references'][number] : 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];
-};
+    [K in keyof TableQuery]: K extends '__defaults' ? HasOnePopulate<T, Name> : 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 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];
-};
+    [K in keyof TableQuery]: K extends '__defaults' ? HasOnePopulate<T, Name> : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K];
+} & QueryHasWhere & HasRelJoin;
 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 {
     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<{
@@ -84,17 +74,12 @@ interface HasMany extends RelationThunkBase {
     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];
-};
+    [K in keyof TableQuery]: K extends '__defaults' ? HasOnePopulate<T, Name> : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
+} & QueryHasWhere & HasRelJoin;
 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: {
@@ -132,35 +117,32 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
 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 +202,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;
+    } ? ORMTableInputToQueryBuilder<R> : never;
+} & OrchidORMMethods;
+interface OrchidORMMethods {
     /**
      * @see import('pqb').Transaction.prototype.transaction
      */
@@ -302,7 +287,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 +299,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 +307,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 +396,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;
+} ? ORMTableInputToQueryBuilder<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,11 +428,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>> {
+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>, ColumnsShape.DefaultSelectKeys<T['columns']['shape']>> {
     relations: Relations;
 }
 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;
+    [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> : TableToDb<T, EmptyObject>;
 interface ORMTableInput {
     table: string;
@@ -617,40 +599,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;
@@ -673,7 +663,7 @@ interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
     exportAs: string;
     columnTypes: ColumnTypes;
     getFilePath(): string;
-    sql<T>(...args: StaticSQLArgs): RawSQL<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
+    sql<T>(...args: StaticSQLArgs): RawSql<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
     sql<T>(...args: [DynamicSQLArg<Column.Pick.QueryColumnOfType<T>>]): DynamicRawSQL<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
     new (): BaseTableInstance<ColumnTypes>;
     instance(): BaseTableInstance<ColumnTypes>;
@@ -722,13 +712,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 {

package/dist/index.js

@@ -388,7 +388,7 @@ const combineOrdering = (result, joined) => {
 const wrapQuery = (joiningQuery, result, item) => {
   const baseOuterQuery = pqb.cloneQueryBaseUnscoped(joiningQuery);
   const outer = baseOuterQuery.clone();
-  outer.q.and = [new pqb.DynamicRawSQL(() => new pqb.RawSQL(`${item.as || "r"} = 1`))];
+  outer.q.and = [new pqb.DynamicRawSQL(() => new pqb.RawSql(`${item.as || "r"} = 1`))];
   outer.q.useFromLimitOffset = true;
   outer.shape = pqb.getShapeFromSelect(result, true);
   outer.q.select = Object.keys(outer.shape);
@@ -416,13 +416,16 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     }
     const value = item[key];
     if ("create" in value || "connectOrCreate" in value) {
-      foreignKeys.forEach((foreignKey) => item[foreignKey] = new pqb.RawSQL(""));
+      foreignKeys.forEach((foreignKey) => item[foreignKey] = new pqb.RawSql(""));
       const selectPKeys = query.select(...primaryKeys);
       pqb._with(
         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
+        item[foreignKey] = new pqb.RawSql(
+          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) {