orchid-orm 1.21.6 → 1.22.0

package/dist/index.d.ts

@@ -1,32 +1,35 @@
-import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationQueryBase, ComputedColumnsBase, MapTableScopesOption, QueryWithTable, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, MapTableScopesOption, ComputedColumnsBase, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, RelationQueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
 export * from 'pqb';
-import { ColumnsShapeBase, EmptyObject, MaybeArray, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnSchemaConfig } from 'orchid-core';
+import { ColumnsShapeBase, RecordKeyTrue, EmptyObject, MaybeArray, RecordUnknown, CoreQueryScopes, ColumnShapeOutput, ColumnShapeInput, ColumnShapeInputPartial, ColumnSchemaConfig, QueryReturnType } from 'orchid-core';
 
-type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
+interface 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> = {
+}
+interface RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> {
     columns: Column[];
     references: Ref[];
-};
-type RelationKeysOptions<PK extends PropertyKey = string, FK extends PropertyKey = string> = {
+}
+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>;
-type RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> = {
+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>;
 
-type HasOne = RelationThunkBase & {
+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']> | RelationThroughOptions<Through, Source>);
-interface HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, Name extends string, TableQuery extends Query, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, Q extends Query = Relation['options'] extends RelationThroughOptions ? {
+type HasOneParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
+    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
+} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][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 extends RecordKeyTrue = 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 ? {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
         defaults: Populate;
@@ -40,13 +43,13 @@ interface HasOneInfo<T extends Table, Relations extends RelationThunks, Relation
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
     } : K extends 'join' ? RelJoin : TableQuery[K];
-}, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
+}, NestedCreateQuery extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
     query: Q;
-    methodQuery: Relation['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
+    methodQuery: T['relations'][Name]['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
     joinQuery: RelationJoinQuery;
     one: true;
     omitForeignKeyInCreate: never;
-    optionalDataForCreate: Relation['options'] extends RelationThroughOptions ? EmptyObject : {
+    optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
         [P in Name]?: RelationToOneDataForCreate<{
             nestedCreateQuery: NestedCreateQuery;
             table: Q;
@@ -69,39 +72,40 @@ interface HasOneInfo<T extends Table, Relations extends RelationThunks, Relation
     } | {
         create: CreateData<NestedCreateQuery>;
     };
-    params: Relation['options'] extends RelationRefsOptions ? {
-        [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
-    } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']], Relation['options']['through']>['params'] : never;
+    params: HasOneParams<T, T['relations'][Name]>;
 }
 
-type HasMany = RelationThunkBase & {
+interface HasMany extends RelationThunkBase {
     type: 'hasMany';
     options: HasManyOptions;
-};
+}
 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>;
-interface HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, Name extends string, TableQuery extends Query, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, Q extends Query = Relation['options'] extends RelationThroughOptions ? {
+type HasManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
+    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
+} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][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: Populate;
+        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: Populate;
+        defaults: Record<Populate, true>;
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
     } : K extends 'join' ? RelJoin : TableQuery[K];
-}, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
+}> extends RelationConfigBase {
     query: Q;
     methodQuery: Q;
     joinQuery: RelationJoinQuery;
     one: false;
     omitForeignKeyInCreate: never;
     optionalDataForCreate: {
-        [P in Name]?: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
-            nestedCreateQuery: NestedCreateQuery;
+        [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;
         }>;
     };
@@ -115,22 +119,25 @@ interface HasManyInfo<T extends Table, Relations extends RelationThunks, Relatio
     };
     dataForUpdateOne: {
         set?: MaybeArray<WhereArg<Q>>;
-        create?: CreateData<NestedCreateQuery>[];
+        create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Record<Populate, true>>>[];
     };
-    params: Relation['options'] extends RelationRefsOptions ? {
-        [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
-    } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']], Relation['options']['through']>['params'] : never;
+    params: HasManyParams<T, T['relations'][Name]>;
 }
 
-type RelJoin = <T extends Query>(this: T) => T;
+type RelJoin = JoinQueryMethod & (<T extends Query>(this: T) => T);
 
-type BelongsTo = RelationThunkBase & {
+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'], keyof InstanceType<Related>['columns'], keyof Columns>;
-interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extends string, TableQuery extends Query, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Required = Relation['options']['required'] extends true ? true : false, Q extends Query = {
-    [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
+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> = {
+    [Name in BelongsToFKey<Relation>]: T['columns'][Name]['type'];
+};
+interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, FK extends string = BelongsToFKey<T['relations'][Name]>, Required = T['relations'][Name]['options']['required'] extends true ? true : false, Q extends Query = {
+    [K in keyof TableQuery]: K extends 'meta' ? // Omit is optimal
+    Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
         hasWhere: true;
         selectable: SelectableFromShape<TableQuery['shape'], Name>;
@@ -146,15 +153,9 @@ interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extend
             [L in FK]: T['columns'][L]['inputType'];
         };
         nested: Required extends true ? {
-            [Key in Name]: RelationToOneDataForCreate<{
-                nestedCreateQuery: Q;
-                table: Q;
-            }>;
+            [Key in Name]: RelationToOneDataForCreateSameQuery<Q>;
         } : {
-            [Key in Name]?: RelationToOneDataForCreate<{
-                nestedCreateQuery: Q;
-                table: Q;
-            }>;
+            [Key in Name]?: RelationToOneDataForCreateSameQuery<Q>;
         };
     };
     optionalDataForCreate: EmptyObject;
@@ -175,9 +176,7 @@ interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extend
             create: CreateData<Q> | (() => CreateData<Q>);
         };
     };
-    params: {
-        [Name in FK]: T['columns'][FK]['type'];
-    };
+    params: BelongsToParams<T, T['relations'][Name]>;
 }
 
 declare function transaction<T extends {
@@ -188,7 +187,7 @@ declare function transaction<T extends {
 }, Result>(this: T, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
 
 type OrchidORM<T extends TableClasses = TableClasses> = {
-    [K in keyof T]: DbTable<T[K]>;
+    [K in keyof T]: DbTable<InstanceType<T[K]>>;
 } & {
     $transaction: typeof transaction;
     $adapter: Adapter;
@@ -262,10 +261,10 @@ declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedSta
     noPrimaryKey?: NoPrimaryKeyOption | undefined;
 }, tables: T) => OrchidORM<T>;
 
-type HasAndBelongsToMany = RelationThunkBase & {
+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> & ({
     columns: (keyof Columns)[];
     references: string[];
@@ -281,7 +280,14 @@ type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeB
     associationPrimaryKey: string;
     associationForeignKey: keyof InstanceType<Related>['columns'];
 });
-interface HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, Name extends string, TableQuery extends Query, Q extends Query = {
+type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends {
+    columns: string[];
+} ? {
+    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
+} : Relation['options'] extends {
+    primaryKey: string;
+} ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
+interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Q extends Query = {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
         hasWhere: true;
@@ -310,13 +316,7 @@ interface HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelong
         create?: CreateData<Q>[];
     };
     dataForUpdateOne: EmptyObject;
-    params: Relation['options'] extends {
-        columns: string[];
-    } ? {
-        [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
-    } : Relation['options'] extends {
-        primaryKey: string;
-    } ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
+    params: HasAndBelongsToManyParams<T, T['relations'][Name]>;
 }
 
 type RelationToOneDataForCreate<Rel extends {
@@ -338,6 +338,22 @@ type RelationToOneDataForCreate<Rel extends {
         create: CreateData<Rel['nestedCreateQuery']>;
     };
 };
+type RelationToOneDataForCreateSameQuery<Q extends Query> = {
+    create: CreateData<Q>;
+    connect?: never;
+    connectOrCreate?: never;
+} | {
+    create?: never;
+    connect: WhereArg<Q>;
+    connectOrCreate?: never;
+} | {
+    create?: never;
+    connect?: never;
+    connectOrCreate: {
+        where: WhereArg<Q>;
+        create: CreateData<Q>;
+    };
+};
 type RelationToManyDataForCreate<Rel extends {
     nestedCreateQuery: Query;
     table: Query;
@@ -355,33 +371,44 @@ interface RelationThunkBase {
     options: RelationCommonOptions;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
-type RelationThunks = Record<string, RelationThunk>;
-type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : RelationQueryFromFn<Relation>;
-type RelationQueryFromFn<Relation extends RelationThunkBase, TC extends TableClass = ReturnType<Relation['fn']>, Q extends Query = DbTable<TC>> = Q;
-type RelationConfig<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk, K extends string = string, TableQuery extends Query = Query, Result extends RelationConfigBase = Relation extends BelongsTo ? BelongsToInfo<T, Relation, K, TableQuery> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation, K, TableQuery> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation, K, TableQuery> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation, K, TableQuery> : never> = Result;
-type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations & string, Relation extends RelationThunk = Relations[RelationName], TableQuery extends Query = RelationScopeOrTable<Relation>> = RelationQuery<RelationConfig<T, Relations, Relation, RelationName, TableQuery>>;
-type MapRelations<T extends Table> = T extends {
+interface RelationThunks {
+    [K: string]: RelationThunk;
+}
+type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<InstanceType<ReturnType<Relation['fn']>>>;
+interface RelationConfigSelf {
+    columns: ColumnsShapeBase;
+    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]>> : 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 MapRelations<T> = T extends {
+    columns: ColumnsShapeBase;
     relations: RelationThunks;
 } ? {
-    [K in keyof T['relations'] & string]: MapRelation<T, T['relations'], K>;
+    [K in keyof T['relations'] & string]: MapRelation<T, K>;
 } : EmptyObject;
 
-type TableClass<T extends Table = Table> = {
+interface TableClass<T extends Table = Table> {
     new (): T;
     instance(): T;
-};
-type TableClasses = Record<string, TableClass>;
-type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
+}
+interface TableClasses {
+    [K: string]: TableClass;
+}
+interface RelationQueriesBase {
+    [K: string]: RelationQueryBase;
+}
+interface TableToDb<T extends Table, RelationQueries extends RelationQueriesBase> extends Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends RecordUnknown ? T['columns'] & {
     [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
-} : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> & {
+} : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
     name: string;
-};
-type DbTable<TC extends TableClass, T extends Table = InstanceType<TC>, RelationQueries extends Record<string, RelationQueryBase> = MapRelations<T>, Q extends QueryWithTable = TableToDb<T, RelationQueries>, Result extends QueryWithTable = Q & RelationQueries> = Result;
-type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
-type Table = {
+}
+type DbTable<T extends Table> = TableToDb<T, MapRelations<T>> & MapRelations<T>;
+type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<InstanceType<Related>>) => Scope;
+interface Table {
     table: string;
     columns: ColumnsShapeBase;
     schema?: string;
@@ -395,14 +422,16 @@ type Table = {
     computed?: ComputedColumnsBase<never>;
     scopes?: CoreQueryScopes;
     readonly softDelete?: true | string;
+}
+type Queryable<T extends Table> = {
+    [K in keyof T['columns']]?: T['columns'][K]['queryType'];
 };
-type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
 type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
 type Insertable<T extends Table> = ColumnShapeInput<T['columns']>;
-type Updateable<T extends Table> = Partial<Insertable<T>>;
+type Updateable<T extends Table> = ColumnShapeInputPartial<T['columns']>;
 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'] & string)[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
+type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
 interface BaseTableInstance<ColumnTypes> {
     table: string;
     columns: ColumnsShapeBase;
@@ -580,14 +609,16 @@ declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = Defau
 }): BaseTableClass<SchemaConfig, ColumnTypes>;
 
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
-type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
-type MethodsBase<T extends Query> = {
+type QueryOne<T extends Query> = {
+    [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all'> : T[K];
+};
+interface MethodsBase<T extends Query> {
     queryMethods?: QueryMethods<T>;
     queryOneMethods?: QueryMethods<QueryOne<T>>;
     queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
     queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
-    methods?: Record<string, unknown>;
-};
+    methods?: RecordUnknown;
+}
 type MapQueryMethods<T extends Query, BaseQuery extends Query, Methods> = Methods extends QueryMethods<T> ? {
     [K in keyof Methods]: Methods[K] extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
 } : EmptyObject;

package/dist/index.js

@@ -229,7 +229,8 @@ const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuer
   const inner = reverseJoin(query, joiningQuery);
   return joiningQuery.where({
     EXISTS: {
-      args: [inner]
+      first: inner,
+      args: orchidCore.emptyArray
     }
   });
 };
@@ -360,7 +361,10 @@ const nestedInsert$3 = ({ query, primaryKeys }) => {
       for (let i = 0, len = items.length; i < len; i++) {
         items[i] = "create" in items[i] ? items[i].create : items[i].connectOrCreate.create;
       }
-      created = await pqb._queryCreateMany(t.select(...primaryKeys), items);
+      created = await pqb._queryCreateMany(
+        t.select(...primaryKeys),
+        items
+      );
     } else {
       created = orchidCore.emptyArray;
     }
@@ -711,10 +715,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
       ids
     );
     if (params.create || params.disconnect || params.set) {
-      await pqb._queryUpdate(
-        currentRelationsQuery,
-        setNulls
-      );
+      await pqb._queryUpdate(currentRelationsQuery, setNulls);
       const record = data[0];
       if (params.create) {
         const obj = __spreadValues$5({}, params.create);
@@ -734,10 +735,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
         );
       }
     } else if (params.update) {
-      await pqb._queryUpdate(
-        currentRelationsQuery,
-        params.update
-      );
+      await pqb._queryUpdate(currentRelationsQuery, params.update);
     } else if (params.delete) {
       await pqb._queryDelete(currentRelationsQuery);
     } else if (params.upsert) {
@@ -958,10 +956,7 @@ 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)
           );
         }
       }
@@ -1516,7 +1511,9 @@ const nestedUpdate = (state) => {
       );
     }
     if (params.disconnect) {
-      await pqb._queryDelete(queryJoinTable(state, data, params.disconnect));
+      await pqb._queryDelete(
+        queryJoinTable(state, data, params.disconnect)
+      );
     }
     if (params.delete) {
       const j = queryJoinTable(state, data, params.delete);
@@ -1538,7 +1535,9 @@ const nestedUpdate = (state) => {
       delete j.q[pqb.toSQLCacheKey];
       const idsRows = await pqb._queryRows(
         pqb._querySelect(
-          state.relatedTableQuery.where(conditionsToWhereArg(params.set)),
+          state.relatedTableQuery.where(
+            conditionsToWhereArg(params.set)
+          ),
           state.throughPrimaryKeys
         )
       );
@@ -1731,7 +1730,8 @@ const makeRelationQuery = (table, relationName, data, q) => {
         query = pqb._queryWhere(pqb._queryAll(toTable), [
           {
             EXISTS: {
-              args: [data.reverseJoin(this, toTable)]
+              first: data.reverseJoin(this, toTable),
+              args: orchidCore.emptyArray
             }
           }
         ]);