orchid-orm 1.40.1 → 1.41.0

package/dist/index.d.ts

@@ -1,16 +1,14 @@
-import { Query, TableData, SelectableFromShape, CreateMethodsNames, CreateData, CreateBelongsToData, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, UpdateData, WhereArg, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, TableDataFn, DbTableOptionScopes, RawSQL, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
+import { TableData, Query, SelectableFromShape, CreateMethodsNames, CreateData, CreateBelongsToData, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, UpdateData, WhereArg, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, TableDataFn, DbTableOptionScopes, RawSQL, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
 export * from 'pqb';
-import { ColumnsShapeBase, EmptyObject, MaybeArray, RecordUnknown, ShallowSimplify, ColumnShapeOutput, DefaultSelectColumns, ColumnShapeInput, ColumnShapeInputPartial, IsQuery, CoreQueryScopes, ColumnSchemaConfig, StaticSQLArgs, QueryColumn, DynamicSQLArg, QueryColumns, QueryReturnType } from 'orchid-core';
+import { ColumnsShapeBase, ColumnShapeInputPartial, EmptyObject, MaybeArray, RecordUnknown, ShallowSimplify, ColumnShapeOutput, DefaultSelectColumns, ColumnShapeInput, IsQuery, CoreQueryScopes, ColumnSchemaConfig, StaticSQLArgs, QueryColumn, DynamicSQLArg, QueryColumns, QueryReturnType } from 'orchid-core';
 export * from 'orchid-core';
 
-interface RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> {
-    scope?: ScopeFn<Related, Scope>;
+interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends ColumnsShapeBase = ColumnsShapeBase> {
     required?: boolean;
-}
-interface RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> {
     columns: Column[];
-    references: Ref[];
+    references: (keyof Shape)[];
     foreignKey?: boolean | TableData.References.Options;
+    on?: ColumnShapeInputPartial<Shape>;
 }
 interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
     through: Through;
@@ -21,7 +19,10 @@ 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> & (RelationRefsOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape']> | RelationThroughOptions<Through, Source>);
+interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
+    required?: boolean;
+}
+type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, 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;
@@ -114,6 +115,7 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
             data: UpdateData<Q>;
         };
         set?: MaybeArray<WhereArg<Q>>;
+        add?: MaybeArray<WhereArg<Q>>;
         create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, HasOnePopulate<T, Name>>>[];
     };
 }
@@ -126,8 +128,7 @@ interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     options: BelongsToOptions;
 }
-interface BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> extends RelationCommonOptions<Related, Scope>, RelationRefsOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape']> {
-}
+type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass> = RelationRefsOptions<keyof Columns, InstanceType<Related>['columns']['shape']>;
 type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : never;
 type BelongsToParams<T extends RelationConfigSelf, Relation extends BelongsTo> = {
     [Name in BelongsToFKey<Relation>]: T['columns']['shape'][Name]['type'];
@@ -290,8 +291,7 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 }
-interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> {
-    scope?: ScopeFn<Related, Scope>;
+interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass> {
     required?: boolean;
     columns: (keyof Columns)[];
     references: string[];
@@ -302,6 +302,7 @@ interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsS
         references: (keyof InstanceType<Related>['columns']['shape'])[];
         foreignKey?: boolean | TableData.References.Options;
     };
+    on?: ColumnShapeInputPartial<InstanceType<Related>['columns']['shape']>;
 }
 type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends HasAndBelongsToMany> = {
     [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
@@ -332,6 +333,7 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends str
     dataForUpdate: {
         disconnect?: MaybeArray<WhereArg<Q>>;
         set?: MaybeArray<WhereArg<Q>>;
+        add?: MaybeArray<WhereArg<Q>>;
         delete?: MaybeArray<WhereArg<Q>>;
         update?: {
             where: MaybeArray<WhereArg<Q>>;
@@ -342,6 +344,7 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends str
     dataForUpdateOne: {
         disconnect?: MaybeArray<WhereArg<Q>>;
         set?: MaybeArray<WhereArg<Q>>;
+        add?: MaybeArray<WhereArg<Q>>;
         delete?: MaybeArray<WhereArg<Q>>;
         update?: {
             where: MaybeArray<WhereArg<Q>>;
@@ -389,13 +392,13 @@ type RelationToOneDataForCreateSameQuery<Q extends Query> = {
 interface RelationThunkBase {
     type: string;
     fn(): TableClass;
-    options: RelationCommonOptions;
+    options: unknown;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 interface RelationThunks {
     [K: string]: RelationThunk;
 }
-type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : ORMTableInputToQueryBuilder<InstanceType<ReturnType<Relation['fn']>>>;
+type RelationTableToQuery<Relation extends RelationThunkBase> = ORMTableInputToQueryBuilder<InstanceType<ReturnType<Relation['fn']>>>;
 interface RelationConfigSelf {
     columns: {
         shape: ColumnsShapeBase;
@@ -404,13 +407,13 @@ interface RelationConfigSelf {
 }
 type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation> : never;
 type MapRelation<T extends RelationConfigSelf, K extends keyof T['relations'] & string> = T['relations'][K] extends BelongsTo ? {
-    relationConfig: BelongsToInfo<T, K, T['relations'][K], T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationScopeOrTable<T['relations'][K]>, K>>;
+    relationConfig: 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 ? {
-    relationConfig: HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationScopeOrTable<T['relations'][K]>>>;
+    relationConfig: HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>>;
 } : T['relations'][K] extends HasMany ? {
-    relationConfig: HasManyInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationScopeOrTable<T['relations'][K]>>>;
+    relationConfig: HasManyInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>>;
 } : T['relations'][K] extends HasAndBelongsToMany ? {
-    relationConfig: HasAndBelongsToManyInfo<T, K, T['relations'][K], HasAndBelongsToManyQuery<K, RelationScopeOrTable<T['relations'][K]>>>;
+    relationConfig: HasAndBelongsToManyInfo<T, K, T['relations'][K], HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>>;
 } : never;
 type MapRelations<T> = T extends RelationConfigSelf ? {
     [K in keyof T['relations'] & string]: MapRelation<T, K>;
@@ -437,7 +440,6 @@ interface TableToDb<T extends ORMTableInput, Relations extends RelationsBase> ex
     };
 }
 type ORMTableInputToQueryBuilder<T extends ORMTableInput> = T extends RelationConfigSelf ? TableToDb<T, MapRelations<T>> : TableToDb<T, EmptyObject>;
-type ScopeFn<Related extends TableClass, Scope extends Query> = (q: ORMTableInputToQueryBuilder<InstanceType<Related>>) => Scope;
 interface ORMTableInput {
     table: string;
     columns: {
@@ -596,7 +598,7 @@ interface BaseTableInstance<ColumnTypes> {
             shape: Shape;
         };
     }, scopes: DbTableOptionScopes<Table, Shape, Keys>): CoreQueryScopes<Keys>;
-    belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Columns, Related, Scope>>(this: {
+    belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Options extends BelongsToOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
@@ -605,7 +607,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
+    hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
@@ -614,7 +616,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
+    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
@@ -623,7 +625,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Columns, Related, Scope>>(this: {
+    hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
@@ -715,4 +717,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 Insertable, type MapMethods, type MapQueryMethods, type MethodsBase, type ORMTableInput, type ORMTableInputToQueryBuilder, type OrchidORM, type Queryable, type Repo, type ScopeFn, type Selectable, type SetColumnsResult, type Table, type TableClass, type TableClasses, type TableInfo, type TableToDb, type Updatable, createBaseTable, createRepo, orchidORM };
+export { type BaseTableClass, type BaseTableInstance, type Insertable, type MapMethods, type MapQueryMethods, type MethodsBase, type ORMTableInput, type ORMTableInputToQueryBuilder, type OrchidORM, type Queryable, type Repo, type Selectable, type SetColumnsResult, type Table, type TableClass, type TableClasses, type TableInfo, type TableToDb, type Updatable, createBaseTable, createRepo, orchidORM };

package/dist/index.js

@@ -181,7 +181,7 @@ const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKeys, neste
 };
 const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
   const value = set[key];
-  if (!value.set && !("upsert" in value) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
+  if (!value.set && !("upsert" in value) && (!value.add || Array.isArray(value.add) && value.add.length === 0) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
     return;
   selectIfNotSelected(q, primaryKeys);
   q.q.wrapInTransaction = true;
@@ -204,13 +204,6 @@ const selectIfNotSelected = (q, columns) => {
     q.q.select = select;
   }
 };
-const relationWhere = (len, keys, valueKeys) => (params) => {
-  const obj = {};
-  for (let i = 0; i < len; i++) {
-    obj[keys[i]] = params[valueKeys[i]];
-  }
-  return obj;
-};
 function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelation) {
   return q.whereExists(
     throughRelation.joinQuery(throughRelation.query, baseQuery),
@@ -224,14 +217,9 @@ function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelat
   );
 }
 function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len) {
-  const q = joiningQuery.clone();
-  pqb.setQueryObjectValue(
-    q,
-    "joinedShapes",
-    baseQuery.q.as || baseQuery.table,
-    baseQuery.q.shape
-  );
   const baseAs = pqb.getQueryAs(baseQuery);
+  const q = joiningQuery.clone();
+  pqb.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
   for (let i = 0; i < len; i++) {
     pqb.pushQueryOnForOuter(
       q,
@@ -340,7 +328,7 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     const relationData = [values];
     store.belongsTo[key] = relationData;
     q.q.wrapInTransaction = true;
-    pqb.pushQueryValue(q, "beforeCreate", async (q2) => {
+    pqb.pushQueryValueImmutable(q, "beforeCreate", async (q2) => {
       const inserted = await this.nestedInsert(
         q2,
         relationData.map(([, , data]) => data)
@@ -364,9 +352,13 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
 const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
   const primaryKeys = relation.options.references;
   const foreignKeys = relation.options.columns;
+  const { on } = relation.options;
+  if (on) {
+    pqb._queryWhere(query, [on]);
+    pqb._queryDefaults(query, on);
+  }
   const len = primaryKeys.length;
-  const state = { query, primaryKeys, foreignKeys, len };
-  const makeWhere = relationWhere(len, primaryKeys, foreignKeys);
+  const state = { query, primaryKeys, foreignKeys, len, on };
   addAutoForeignKey(
     tableConfig,
     table,
@@ -376,14 +368,9 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
     relation.options
   );
   const join = (baseQuery, joiningQuery, primaryKeys2, foreignKeys2) => {
-    const q = joiningQuery.clone();
-    pqb.setQueryObjectValue(
-      q,
-      "joinedShapes",
-      baseQuery.q.as || baseQuery.table,
-      baseQuery.q.shape
-    );
     const baseAs = pqb.getQueryAs(baseQuery);
+    const q = joiningQuery.clone();
+    pqb.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
     for (let i = 0; i < len; i++) {
       pqb.pushQueryOnForOuter(
         q,
@@ -406,7 +393,11 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
   return {
     returns: "one",
     queryRelated(params) {
-      return query.where(makeWhere(params));
+      const obj = {};
+      for (let i = 0; i < len; i++) {
+        obj[primaryKeys[i]] = params[foreignKeys[i]];
+      }
+      return query.where(obj);
     },
     virtualColumn: new BelongsToVirtualColumn(
       pqb.defaultSchemaConfig,
@@ -420,13 +411,21 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
     reverseJoin
   };
 };
-const nestedInsert$3 = ({ query, primaryKeys }) => {
+const nestedInsert$3 = ({ query, primaryKeys, on }) => {
   return async (_, data) => {
     const t = query.clone();
     const items = [];
     for (const item of data) {
       if (item.connectOrCreate) {
-        items.push(item);
+        items.push(
+          on ? {
+            ...item,
+            connectOrCreate: {
+              ...item.connectOrCreate,
+              where: { ...item.connectOrCreate.where, ...on }
+            }
+          } : item
+        );
       }
     }
     let connectOrCreated;
@@ -464,7 +463,9 @@ const nestedInsert$3 = ({ query, primaryKeys }) => {
     items.length = 0;
     for (const item of data) {
       if (item.connect) {
-        items.push(item);
+        items.push(
+          on ? { ...item, connect: { ...item.connect, ...on } } : item
+        );
       }
     }
     let connected;
@@ -551,12 +552,11 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
           }
           obj[primaryKeys[i]] = id;
         }
-        if (obj) {
-          await pqb._queryUpdate(
-            query.findBy(obj),
-            upsert.update
-          );
-        } else {
+        const count = obj ? await pqb._queryUpdate(
+          query.findBy(obj),
+          upsert.update
+        ) : 0;
+        if (!count) {
           const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
           const result = await pqb._queryCreate(
             query.select(...primaryKeys),
@@ -647,10 +647,13 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
+    const sourceRelationQuery = sourceRelation.query.as(
+      relationName
+    );
     const sourceQuery = sourceRelation.joinQuery(
-      sourceRelation.query,
+      sourceRelationQuery,
       throughRelation.query
-    ).as(relationName);
+    );
     const whereExistsCallback = () => sourceQuery;
     const reverseJoin2 = (baseQuery, joiningQuery) => {
       return joinHasThrough(
@@ -682,6 +685,11 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
   }
   const primaryKeys = relation.options.columns;
   const foreignKeys = relation.options.references;
+  const { on } = relation.options;
+  if (on) {
+    pqb._queryWhere(query, [on]);
+    pqb._queryDefaults(query, on);
+  }
   addAutoForeignKey(
     tableConfig,
     query,
@@ -690,7 +698,7 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
     foreignKeys,
     relation.options
   );
-  const state = { query, primaryKeys, foreignKeys };
+  const state = { query, primaryKeys, foreignKeys, on };
   const len = primaryKeys.length;
   const reversedOn = {};
   for (let i = 0; i < len; i++) {
@@ -713,7 +721,7 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return pqb._queryDefaults(query.where(values), values);
+      return pqb._queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasOneVirtualColumn(
       pqb.defaultSchemaConfig,
@@ -837,7 +845,9 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
     } else if (params.update) {
       await pqb._queryUpdate(currentRelationsQuery, params.update);
     } else if (params.delete) {
-      await pqb._queryDelete(currentRelationsQuery);
+      const q = pqb._queryDelete(currentRelationsQuery);
+      q.q.returnType = "value";
+      await q;
     } else if (params.upsert) {
       const { update, create } = params.upsert;
       currentRelationsQuery.q.select = foreignKeys;
@@ -946,6 +956,11 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
   }
   const primaryKeys = relation.options.columns;
   const foreignKeys = relation.options.references;
+  const { on } = relation.options;
+  if (on) {
+    pqb._queryWhere(query, [on]);
+    pqb._queryDefaults(query, on);
+  }
   addAutoForeignKey(
     tableConfig,
     query,
@@ -954,7 +969,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
     foreignKeys,
     relation.options
   );
-  const state = { query, primaryKeys, foreignKeys };
+  const state = { query, primaryKeys, foreignKeys, on };
   const len = primaryKeys.length;
   const reversedOn = {};
   for (let i = 0; i < len; i++) {
@@ -977,7 +992,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return pqb._queryDefaults(query.where(values), values);
+      return pqb._queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasManyVirtualColumn(
       pqb.defaultSchemaConfig,
@@ -1033,7 +1048,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
           obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
         }
         items[i] = pqb._queryUpdateOrThrow(
-          t.orWhere(...connect),
+          t.where({ OR: connect }),
           obj
         );
       }
@@ -1131,6 +1146,29 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
       );
       delete t.q.sqlCache;
     }
+    if (params.add) {
+      if (data.length > 1) {
+        throw new pqb.OrchidOrmInternalError(
+          query,
+          "`connect` is not available when updating multiple records, it is only applicable for a single record update"
+        );
+      }
+      const obj = {};
+      for (let i = 0; i < len; i++) {
+        obj[foreignKeys[i]] = data[0][primaryKeys[i]];
+      }
+      const relatedWheres = orchidCore.toArray(params.add);
+      const count = await pqb._queryUpdate(
+        t.where({ OR: relatedWheres }),
+        obj
+      );
+      if (count < relatedWheres.length) {
+        throw new pqb.OrchidOrmInternalError(
+          query,
+          `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`
+        );
+      }
+    }
     if (params.disconnect || params.set) {
       const obj = {};
       for (const foreignKey of foreignKeys) {
@@ -1223,6 +1261,11 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   const joinTable = options.through.table;
   const throughForeignKeys = options.through.columns;
   const throughPrimaryKeys = options.through.references;
+  const { on } = options;
+  if (on) {
+    pqb._queryWhere(query, [on]);
+    pqb._queryDefaults(query, on);
+  }
   const { snakeCase } = table.internal;
   const foreignKeysFull = foreignKeys.map((key, i) => {
     if (snakeCase) key = foreignKeys[i] = orchidCore.toSnakeCase(key);
@@ -1242,10 +1285,11 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   baseQuery.baseQuery = baseQuery;
   baseQuery.table = joinTable;
   const shape = {};
+  const primaryKeysShape = {};
   for (let i = 0; i < len; i++) {
-    shape[foreignKeys[i]] = removeColumnName(
-      table.shape[primaryKeys[i]]
-    );
+    const pk = primaryKeys[i];
+    shape[foreignKeys[i]] = removeColumnName(table.shape[pk]);
+    primaryKeysShape[pk] = table.shape[pk];
   }
   for (let i = 0; i < throughLen; i++) {
     shape[throughForeignKeys[i]] = removeColumnName(
@@ -1283,7 +1327,9 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
     throughPrimaryKeys,
     foreignKeysFull,
     throughForeignKeysFull,
-    throughPrimaryKeysFull
+    throughPrimaryKeysFull,
+    primaryKeysShape,
+    on
   };
   const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
     const cloned = joiningQuery.clone();
@@ -1323,20 +1369,21 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   return {
     returns: "many",
     queryRelated(params) {
-      return query.whereExists(subQuery, (q) => {
-        q = q.clone();
+      const q = query.whereExists(subQuery, (q2) => {
+        q2 = q2.clone();
         const where = {};
         for (let i = 0; i < len; i++) {
           where[foreignKeysFull[i]] = params[primaryKeys[i]];
         }
         for (let i = 0; i < throughLen; i++) {
-          pqb._queryJoinOn(q, [
+          pqb._queryJoinOn(q2, [
             throughForeignKeysFull[i],
             throughPrimaryKeysFull[i]
           ]);
         }
-        return pqb._queryWhere(q, [where]);
+        return pqb._queryWhere(q2, [where]);
       });
+      return on ? pqb._queryDefaults(q, on) : q;
     },
     virtualColumn: new HasAndBelongsToManyVirtualColumn(
       subQuery,
@@ -1411,6 +1458,19 @@ const queryJoinTable = (state, data, conditions) => {
       }
     ]);
   }
+  if (state.on) {
+    pqb._queryWhereExists(t, state.relatedTableQuery, [
+      (q) => {
+        for (let i = 0; i < state.throughPrimaryKeys.length; i++) {
+          pqb._queryJoinOn(q, [
+            state.throughPrimaryKeysFull[i],
+            state.throughForeignKeysFull[i]
+          ]);
+        }
+        return q;
+      }
+    ]);
+  }
   return t;
 };
 const conditionsToWhereArg = (conditions) => Array.isArray(conditions) ? { OR: conditions } : conditions;
@@ -1580,7 +1640,7 @@ const nestedInsert = ({
 const nestedUpdate = (state) => {
   const len = state.primaryKeys.length;
   const throughLen = state.throughPrimaryKeys.length;
-  return async (_, data, params) => {
+  return async (query, data, params) => {
     if (params.create) {
       const idsRows = await pqb._queryCreateMany(
         pqb._queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)),
@@ -1628,6 +1688,58 @@ const nestedUpdate = (state) => {
         params.update.data
       );
     }
+    if (params.add) {
+      const as = query.table;
+      const relatedWheres = orchidCore.toArray(params.add);
+      const joinTableColumns = [
+        ...state.foreignKeys,
+        ...state.throughForeignKeys
+      ];
+      try {
+        const count = await state.joinTableQuery.insertManyFrom(
+          pqb._querySelect(
+            state.relatedTableQuery.whereOneOf(...relatedWheres),
+            [
+              Object.fromEntries([
+                ...state.primaryKeys.map((key, i) => [
+                  state.foreignKeys[i],
+                  as + "." + (state.primaryKeysShape[key].data.name || key)
+                ]),
+                ...state.throughForeignKeys.map((key, i) => [
+                  key,
+                  state.throughPrimaryKeys[i]
+                ])
+              ])
+            ]
+          ).joinData(
+            as,
+            () => Object.fromEntries(
+              state.primaryKeys.map((key) => [
+                key,
+                state.primaryKeysShape[key]
+              ])
+            ),
+            data.map((x) => orchidCore.pick(x, state.primaryKeys))
+          )
+        ).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
+        if (count < data.length * relatedWheres.length) {
+          throw new pqb.OrchidOrmInternalError(
+            query,
+            `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count / data.length}`
+          );
+        }
+      } catch (err) {
+        if (err.code === "42P10") {
+          throw new pqb.OrchidOrmInternalError(
+            query,
+            `"${state.joinTableQuery.table}" must have a primary key or a unique index on columns (${joinTableColumns.join(
+              ", "
+            )}) for this kind of query.`
+          );
+        }
+        throw err;
+      }
+    }
     if (params.disconnect) {
       await pqb._queryDelete(
         queryJoinTable(state, data, params.disconnect)
@@ -1755,7 +1867,7 @@ const delayRelation = (delayedRelations, table, relationName, data) => {
 const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
   const baseQuery = Object.create(otherDbTable);
   baseQuery.baseQuery = baseQuery;
-  const query = (relation.options.scope ? relation.options.scope(baseQuery) : baseQuery).as(relationName);
+  const query = baseQuery.as(relationName);
   const definedAs = query.definedAs;
   if (!definedAs) {
     throw new Error(