orchid-orm 1.6.39 → 1.6.40

package/dist/index.d.ts

@@ -10,7 +10,7 @@ interface BelongsTo extends RelationThunkBase {
     returns: 'one';
     options: BelongsToRelation['options'];
 }
-declare type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
+type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
     params: Record<FK, T['columns']['shape'][FK]['type']>;
     populate: never;
     chainedCreate: false;
@@ -22,7 +22,7 @@ interface HasMany extends RelationThunkBase {
     returns: 'many';
     options: HasManyRelation['options'];
 }
-declare type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
+type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
@@ -42,7 +42,7 @@ interface HasOne extends RelationThunkBase {
     returns: 'one';
     options: HasOneRelation['options'];
 }
-declare type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
+type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
@@ -61,7 +61,7 @@ declare function transaction<T extends {
     $queryBuilder: Db;
 }, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;
 
-declare type OrchidORM<T extends TableClasses> = {
+type OrchidORM<T extends TableClasses> = {
     [K in keyof T]: DbTable<T[K]>;
 } & {
     $transaction: typeof transaction;
@@ -82,7 +82,7 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     returns: 'many';
     options: HasAndBelongsToManyRelation['options'];
 }
-declare type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
+type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
     params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
     populate: never;
     chainedCreate: true;
@@ -95,9 +95,9 @@ interface RelationThunkBase {
     fn(): TableClass;
     options: BaseRelation['options'];
 }
-declare type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
-declare type RelationThunks = Record<string, RelationThunk>;
-declare type Relation<T extends Table, Relations extends RelationThunks, K extends StringKey<keyof Relations>, M extends Query = SetQueryTableAlias<DbTable<ReturnType<Relations[K]['fn']>>, K>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
+type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
+type RelationThunks = Record<string, RelationThunk>;
+type Relation<T extends Table, Relations extends RelationThunks, K extends StringKey<keyof Relations>, M extends Query = SetQueryTableAlias<DbTable<ReturnType<Relations[K]['fn']>>, K>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
     type: Relations[K]['type'];
     returns: Relations[K]['returns'];
     key: K;
@@ -111,33 +111,33 @@ declare type Relation<T extends Table, Relations extends RelationThunks, K exten
     primaryKey: string;
     options: Relations[K]['options'];
 };
-declare type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
-declare type RelationInfo<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
-declare type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
+type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
+type RelationInfo<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
+type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
     params: Record<string, unknown>;
     populate: string;
     chainedCreate: boolean;
     chainedDelete: boolean;
 } = RelationInfo<T, Relations, Relation>> = RelationQuery<RelationName, Info['params'], Info['populate'], Relation['returns'] extends 'one' ? Relation['options']['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>, Relation['options']['required'] extends boolean ? Relation['options']['required'] : false, Info['chainedCreate'], Info['chainedDelete']>;
-declare type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
 } : EmptyObject : EmptyObject;
 
-declare type TableClass<T extends Table = Table> = new () => T;
-declare type TableClasses = Record<string, TableClass>;
-declare type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+type TableClass<T extends Table = Table> = new () => T;
+type TableClasses = Record<string, TableClass>;
+type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in StringKey<keyof T['relations']>]: Relation<T, T['relations'], K>;
 } : Query['relations'] : Query['relations'], T['columnTypes']> & {
     definedAs: string;
     db: OrchidORM<TableClasses>;
 };
-declare type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
-declare type TableConfig = {
+type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
+type TableConfig = {
     shape: ColumnsShape;
     type: unknown;
 };
-declare type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
-declare type Table = {
+type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
+type Table = {
     table: string;
     columns: TableConfig;
     schema?: string;
@@ -159,8 +159,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
             };
             timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
@@ -168,8 +168,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T_1;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
             };
             name: typeof orchid_core.name;
             raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
@@ -240,12 +240,12 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
                 nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
                 nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
-                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_16 extends object ? { [k in keyof T_16]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
-                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
                 })[k_2]; } : never>;
-                optional: <T_15 extends orchid_core.JSONTypeAny>(type: T_15) => orchid_core.JSONOptional<T_15>;
+                optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
                 record: typeof orchid_core.record;
             }) => Type)): pqb.JSONColumn<Type>;
             jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
@@ -257,29 +257,29 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
             } | undefined): {};
             index(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
             unique(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
-            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
                 name?: string | undefined;
                 references?: [columns: string[], fnOrTable: Table_1, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
-                check?: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | undefined;
+                check?: orchid_core.RawExpression | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }): {};
-            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_2>>, ...pqb.ColumnNameOfTable<ReturnType<Table_2>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
                 name?: string | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }) | undefined): {};
-            check(check: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>): {};
+            check(check: orchid_core.RawExpression): {};
         } : CT;
         noPrimaryKey?: boolean | undefined;
         snakeCase: boolean | undefined;
-        setColumns: <T_16 extends ColumnsShape>(fn: (t: ColumnTypesBase extends CT ? {
+        setColumns: <T_18 extends ColumnsShape>(fn: (t: ColumnTypesBase extends CT ? {
             timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
                     timestamp(): T;
                 };
                 timestamp(): T;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression>;
             };
             timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
@@ -287,8 +287,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 };
                 timestamp(): T_1;
             }) => {
-                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
-                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
+                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression>;
             };
             name: typeof orchid_core.name;
             raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
@@ -359,12 +359,12 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
                 nativeEnum: <T_9 extends orchid_core.EnumLike>(givenEnum: T_9) => orchid_core.JSONNativeEnum<T_9>;
                 nullable: <T_10 extends orchid_core.JSONTypeAny>(type: T_10) => orchid_core.JSONNullable<T_10>;
                 nullish: <T_11 extends orchid_core.JSONTypeAny>(type: T_11) => orchid_core.JSONNullish<T_11>;
-                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                object: <T_12 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_12) => orchid_core.JSONObject<T_12, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_19 extends object ? { [k in keyof T_19]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_22 extends object ? { [k in keyof T_22]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
-                } extends infer T_14 extends object ? { [k_2 in keyof T_14]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_13 extends object ? { [k in keyof T_13]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
+                } extends infer T_20 extends object ? { [k_2 in keyof T_20]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }> extends infer T_21 extends object ? { [k in keyof T_21]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_12]: T_12[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
                 })[k_2]; } : never>;
-                optional: <T_15 extends orchid_core.JSONTypeAny>(type: T_15) => orchid_core.JSONOptional<T_15>;
+                optional: <T_17 extends orchid_core.JSONTypeAny>(type: T_17) => orchid_core.JSONOptional<T_17>;
                 record: typeof orchid_core.record;
             }) => Type)): pqb.JSONColumn<Type>;
             jsonText(this: ColumnTypesBase): pqb.JSONTextColumn;
@@ -376,20 +376,20 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
             } | undefined): {};
             index(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
             unique(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
-            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_1>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+            constraint<Table_1 extends string | (() => pqb.ForeignKeyTable), Columns extends Table_1 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_1>>, ...pqb.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
                 name?: string | undefined;
                 references?: [columns: string[], fnOrTable: Table_1, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
-                check?: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | undefined;
+                check?: orchid_core.RawExpression | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }): {};
-            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<ReturnType<Table_2>>["columns"]["shape"], number | symbol>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+            foreignKey<Table_2 extends string | (() => pqb.ForeignKeyTable), Columns_1 extends Table_2 extends () => pqb.ForeignKeyTable ? [pqb.ColumnNameOfTable<ReturnType<Table_2>>, ...pqb.ColumnNameOfTable<ReturnType<Table_2>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
                 name?: string | undefined;
                 dropMode?: pqb.DropMode | undefined;
             }) | undefined): {};
-            check(check: orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>): {};
-        } : CT) => T_16) => {
-            shape: T_16;
-            type: ColumnShapeOutput<T_16>;
+            check(check: orchid_core.RawExpression): {};
+        } : CT) => T_18) => {
+            shape: T_18;
+            type: ColumnShapeOutput<T_18>;
         };
         belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
             primaryKey: keyof InstanceType<Related>["columns"]["shape"];
@@ -449,20 +449,20 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
     };
 };
 
-declare type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
-declare type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
-declare type MethodsBase<T extends Query> = {
+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> = {
     queryMethods?: QueryMethods<T>;
     queryOneMethods?: QueryMethods<QueryOne<T>>;
     queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
     queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
     methods?: Record<string, unknown>;
 };
-declare type MapQueryMethods<T extends Query, BaseQuery extends Query, Methods> = Methods extends QueryMethods<T> ? {
+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;
-declare type MapMethods<T extends Query, Methods extends MethodsBase<T>> = MapQueryMethods<T, Query, Methods['queryMethods']> & MapQueryMethods<QueryOne<T>, QueryOne<Query>, Methods['queryOneMethods']> & MapQueryMethods<WhereResult<T>, WhereResult<Query>, Methods['queryWithWhereMethods']> & MapQueryMethods<QueryOne<WhereResult<T>>, QueryOne<WhereResult<Query>>, Methods['queryOneWithWhereMethods']> & (Methods['methods'] extends Record<string, unknown> ? Methods['methods'] : EmptyObject);
-declare type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T, Methods>> = (<Q extends {
+type MapMethods<T extends Query, Methods extends MethodsBase<T>> = MapQueryMethods<T, Query, Methods['queryMethods']> & MapQueryMethods<QueryOne<T>, QueryOne<Query>, Methods['queryOneMethods']> & MapQueryMethods<WhereResult<T>, WhereResult<Query>, Methods['queryWithWhereMethods']> & MapQueryMethods<QueryOne<WhereResult<T>>, QueryOne<WhereResult<Query>>, Methods['queryOneWithWhereMethods']> & (Methods['methods'] extends Record<string, unknown> ? Methods['methods'] : EmptyObject);
+type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T, Methods>> = (<Q extends {
     table: T['table'];
     shape: T['shape'];
 }>(q: Q) => Q & Mapped) & T & Mapped;
@@ -470,7 +470,7 @@ declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(tabl
 
 declare class AppCodeUpdaterError extends Error {
 }
-declare type AppCodeUpdaterConfig = {
+type AppCodeUpdaterConfig = {
     tablePath(tableName: string): string;
     baseTablePath: string;
     baseTableName: string;

package/dist/index.js

@@ -1,17 +1,12 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var pqb = require('pqb');
 var orchidCore = require('orchid-core');
 var path = require('path');
 var fs = require('fs/promises');
 var typescript = require('typescript');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -24,14 +19,11 @@ function _interopNamespace(e) {
       }
     });
   }
-  n["default"] = e;
+  n.default = e;
   return Object.freeze(n);
 }
 
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var typescript__default = /*#__PURE__*/_interopDefaultLegacy(typescript);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 const createBaseTable = ({
   columnTypes,
@@ -898,6 +890,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       relationName,
       state
     ),
+    // joinQuery can be a property of RelationQuery and be used by whereExists and other stuff which needs it
+    // and the chained query itself may be a query around this joinQuery
     joinQuery(fromQuery, toQuery) {
       const join = toQuery.whereExists(
         subQuery,
@@ -924,6 +918,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
           const fromQuery = ref.query.clone();
           fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
           const createdCount = await subQuery.transacting(q).count()._createFrom(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             fromQuery,
             {
               [afk]: result[apk]
@@ -1091,15 +1086,18 @@ const nestedUpdate = (state) => {
     if (params.update) {
       await state.relatedTableQuery.transacting(q)._whereExists(
         state.joinTableQuery,
-        (q2) => q2._on(
-          state.associationForeignKeyFull,
-          state.associationPrimaryKeyFull
-        )._where({
-          IN: {
-            columns: [state.foreignKeyFull],
-            values: [data.map((item) => item[state.primaryKey])]
-          }
-        })
+        (q2) => (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          q2._on(
+            state.associationForeignKeyFull,
+            state.associationPrimaryKeyFull
+          )._where({
+            IN: {
+              columns: [state.foreignKeyFull],
+              values: [data.map((item) => item[state.primaryKey])]
+            }
+          })
+        )
       )._where(
         Array.isArray(params.update.where) ? { OR: params.update.where } : params.update.where
       )._update(params.update.data);
@@ -1396,6 +1394,7 @@ const orchidORM = (_a, tables) => {
       options2.noPrimaryKey = "ignore";
     const dbTable = new pqb.Db(
       adapter,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb,
       table.table,
       table.columns.shape,
@@ -1486,7 +1485,7 @@ class FileChanges {
   }
 }
 
-const { createSourceFile, ScriptTarget, SyntaxKind } = typescript__default["default"];
+const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
 const iterate = (kind) => {
   return function* (statements) {
     for (const node of statements) {
@@ -1626,7 +1625,7 @@ const ts = {
 };
 
 const getImportPath = (from, to) => {
-  const rel = path__default["default"].relative(path__default["default"].dirname(from), to).split(path__default["default"].sep).join(path__default["default"].posix.sep);
+  const rel = path.relative(path.dirname(from), to).split(path.sep).join(path.posix.sep);
   const importPath = rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
   return importPath.replace(/\.[tj]s$/, "");
 };
@@ -1656,7 +1655,7 @@ const optionsToString = (options) => {
   return lines.join("\n    ");
 };
 const updateMainFile = async (filePath, tablePath, ast, options, logger) => {
-  const result = await fs__default["default"].readFile(filePath, "utf-8").then(
+  const result = await fs.readFile(filePath, "utf-8").then(
     (content2) => ({ error: void 0, content: content2 }),
     (error) => {
       return { error, content: void 0 };
@@ -1699,9 +1698,9 @@ const updateMainFile = async (filePath, tablePath, ast, options, logger) => {
   }
   if (write) {
     if (result.error) {
-      await fs__default["default"].mkdir(path__default["default"].dirname(filePath), { recursive: true });
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
     }
-    await fs__default["default"].writeFile(filePath, write);
+    await fs.writeFile(filePath, write);
     logger == null ? void 0 : logger.log(
       `${result.content ? "Updated" : "Created"} ${orchidCore.pathToLog(filePath)}`
     );
@@ -1828,9 +1827,9 @@ const createTable = async (_a) => {
     props,
     "}\n"
   ];
-  await fs__default["default"].mkdir(path__default["default"].dirname(tablePath), { recursive: true });
+  await fs.mkdir(path.dirname(tablePath), { recursive: true });
   try {
-    await fs__default["default"].writeFile(tablePath, orchidCore.codeToString(code, "", "  "), { flag: "wx" });
+    await fs.writeFile(tablePath, orchidCore.codeToString(code, "", "  "), { flag: "wx" });
     logger == null ? void 0 : logger.log(`Created ${orchidCore.pathToLog(tablePath)}`);
   } catch (err) {
     if (err.code !== "EEXIST") {
@@ -1876,7 +1875,7 @@ const changeTable = async (_a) => {
     "logger"
   ]);
   const tablePath = params.tablePath(orchidCore.toCamelCase(ast.name));
-  const content = await fs__default["default"].readFile(tablePath, "utf-8").catch(() => void 0);
+  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
   if (!content)
     return;
   const changes = new FileChanges(content);
@@ -1890,7 +1889,7 @@ const changeTable = async (_a) => {
     addColumns(context);
     addTableData(context);
   }
-  await fs__default["default"].writeFile(tablePath, changes.apply());
+  await fs.writeFile(tablePath, changes.apply());
   logger == null ? void 0 : logger.log(`Updated ${orchidCore.pathToLog(tablePath)}`);
 };
 function* iterateColumnsShapes(statements, className) {
@@ -2151,7 +2150,9 @@ const getColumnMethodArgs = (t, to, key, dataType) => {
   if (!value)
     return;
   if (key === "indexes") {
-    return pqb.columnIndexesToCode(value);
+    return pqb.columnIndexesToCode(
+      value
+    );
   }
   if (key === "foreignKeys") {
     return pqb.columnForeignKeysToCode(value);
@@ -2359,7 +2360,7 @@ const renameTable = async (_a) => {
   ]);
   var _a2;
   const tablePath = params.tablePath(orchidCore.toCamelCase(ast.from));
-  const content = await fs__default["default"].readFile(tablePath, "utf-8").catch(() => void 0);
+  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
   if (!content)
     return;
   const changes = new FileChanges(content);
@@ -2399,7 +2400,7 @@ const renameTable = async (_a) => {
       }
     }
   }
-  await fs__default["default"].writeFile(tablePath, changes.apply());
+  await fs.writeFile(tablePath, changes.apply());
   logger == null ? void 0 : logger.log(`Updated ${orchidCore.pathToLog(tablePath)}`);
 };
 
@@ -2438,8 +2439,8 @@ const createBaseTableFile = async ({
   baseTablePath,
   logger
 }) => {
-  await fs__default["default"].mkdir(path__default["default"].dirname(baseTablePath), { recursive: true });
-  await fs__default["default"].writeFile(
+  await fs.mkdir(path.dirname(baseTablePath), { recursive: true });
+  await fs.writeFile(
     baseTablePath,
     `import { createBaseTable } from 'orchid-orm';