orchid-orm 1.60.5 → 1.61.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Column, TableData, ColumnsShape, Query, SelectableFromShape, CreateManyMethodsNames, QueryHasWhere, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, EmptyObject, CreateData, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ComputedOptionsConfig, QueryOrExpression, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, QueryScopes, ColumnSchemaConfig, DbSqlMethod, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryBeforeActionHook, QueryAfterHook, AfterHook, MergeQuery, QueryReturnType } from 'pqb';
+import { Column, TableData, ColumnsShape, Query, SelectableFromShape, CreateManyMethodsNames, QueryHasWhere, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, EmptyObject, CreateData, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, QuerySchema, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ComputedOptionsConfig, QueryOrExpression, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, QueryScopes, ColumnSchemaConfig, DbSqlMethod, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryBeforeActionHook, QueryAfterHook, AfterHook, MergeQuery, QueryReturnType } from 'pqb';
 export * from 'pqb';
 
 interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
@@ -292,7 +292,7 @@ interface OrchidORMMethods {
     $close(): Promise<void>;
 }
 type OrchidOrmParam<Options> = true | null extends true ? 'Set strict: true to tsconfig' : Options;
-declare const orchidORMWithAdapter: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: OrchidOrmParam<({
+declare const orchidORMWithAdapter: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, schema, ...options }: OrchidOrmParam<({
     db: Query;
 } | {
     adapter: AdapterBase;
@@ -308,6 +308,7 @@ interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Co
     references: string[];
     foreignKey?: boolean | TableData.References.Options;
     through: {
+        schema?: QuerySchema;
         table: string;
         columns: string[];
         references: (keyof Related['columns']['shape'])[];
@@ -442,7 +443,7 @@ interface ORMTableInput {
         shape: Column.Shape.QueryInit;
         data: MaybeArray<TableDataItem>;
     };
-    schema?: string;
+    schema?: QuerySchema;
     types: unknown;
     noPrimaryKey?: boolean;
     filePath: string;
@@ -487,7 +488,7 @@ interface BaseTableInstance<ColumnTypes> {
         shape: Column.Shape.QueryInit;
         data: MaybeArray<TableDataItem>;
     };
-    schema?: string;
+    schema?: QuerySchema;
     noPrimaryKey?: boolean;
     snakeCase?: boolean;
     types: ColumnTypes;

package/dist/index.js

@@ -147,31 +147,33 @@ const getThroughRelation = (table, through) => {
 const getSourceRelation = (throughRelation, source) => {
   return throughRelation.query.relations[source];
 };
-const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKeys, nestedInsert) => {
-  const value = item[key];
-  if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0))
-    return;
-  const store = ctx;
-  if (!store.hasRelation) store.hasRelation = {};
-  const values = [rowIndex, value];
-  if (store.hasRelation[key]) {
-    store.hasRelation[key].push(values);
-    return;
-  }
+const hasRelationHandleCreate = (q, ctx, items, rowIndexes, key, primaryKeys, nestedInsert) => {
   q.q.wrapInTransaction = true;
-  const relationData = [values];
-  store.hasRelation[key] = relationData;
-  pqb._queryHookAfterCreate(
-    q,
-    primaryKeys,
-    (rows, q2) => nestedInsert(
-      q2,
-      relationData.map(([rowIndex2, data]) => [
-        rows[rowIndex2],
-        data
-      ])
-    )
-  );
+  items.forEach((item, i) => {
+    const value = item[key];
+    if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0))
+      return;
+    const store = ctx;
+    if (!store.hasRelation) store.hasRelation = {};
+    const values = [rowIndexes[i], value];
+    if (store.hasRelation[key]) {
+      store.hasRelation[key].push(values);
+      return;
+    }
+    const relationData = [values];
+    store.hasRelation[key] = relationData;
+    pqb._queryHookAfterCreate(
+      q,
+      primaryKeys,
+      (rows, q2) => nestedInsert(
+        q2,
+        relationData.map(([rowIndex, data]) => [
+          rows[rowIndex],
+          data
+        ])
+      )
+    );
+  });
 };
 const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
   const value = set[key];
@@ -186,17 +188,6 @@ const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
     );
   });
 };
-const _selectIfNotSelected = (q, columns) => {
-  const select = q.q.select || [];
-  if (!select.includes("*")) {
-    for (const column of columns) {
-      if (!select.includes(column)) {
-        select.push(column);
-      }
-    }
-    q.q.select = select;
-  }
-};
 function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelation) {
   return q.whereExists(
     throughRelation.joinQuery(
@@ -284,6 +275,14 @@ const getColumnKeyFromDbName = (query, name) => {
 };
 const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
 const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const selectCteColumnFromManySql = (cteAs, column, rowIndex, count) => {
+  let sql = `(SELECT "${cteAs}"."${column}" FROM "${cteAs}"`;
+  if (count > 1) {
+    sql += ` LIMIT 1`;
+    if (rowIndex) sql += ` OFFSET ${rowIndex}`;
+  }
+  return sql + ")";
+};
 
 const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, baseQuery) => {
   const jq = joiningQuery;
@@ -401,40 +400,88 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     this.state = state;
     this.nestedUpdate = nestedUpdate$2(this.state);
   }
-  create(q, ctx, item) {
+  create(q, ctx, items) {
     const {
       key,
       state: { query, primaryKeys, foreignKeys }
     } = this;
+    let nestedCreateItems;
+    items.forEach((item) => {
+      var _a;
+      const value = item[key];
+      const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+      if (kind) {
+        const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_a[kind] = {
+          items: [],
+          values: []
+        });
+        nestedCreateItem.items.push(item);
+        nestedCreateItem.values.push(value[kind]);
+        if (kind !== "connect") {
+          for (const key2 of foreignKeys) {
+            item[key2] = new pqb.RawSql("");
+          }
+        }
+      }
+    });
+    if (!nestedCreateItems) {
+      return;
+    }
     for (const key2 of foreignKeys) {
       if (!ctx.columns.has(key2)) {
         ctx.columns.set(key2, ctx.columns.size);
       }
     }
-    const value = item[key];
-    if ("create" in value || "connectOrCreate" in value) {
-      const asFn = setForeignKeysFromCte(item, primaryKeys, foreignKeys);
+    const { create, connect, connectOrCreate } = nestedCreateItems;
+    if (create) {
       const selectPKeys = query.select(...primaryKeys);
       pqb._prependWith(
         q,
-        asFn,
-        "create" in value ? pqb._queryCreate(selectPKeys, value.create) : pqb._orCreate(
-          pqb._queryWhere(selectPKeys, [
-            value.connectOrCreate.where
-          ]),
-          value.connectOrCreate.create
-        )
+        (as) => {
+          const count = create.items.length;
+          foreignKeys.forEach((foreignKey, i) => {
+            const primaryKey = primaryKeys[i];
+            create.items.forEach((item, i2) => {
+              item[foreignKey]._sql = selectCteColumnFromManySql(
+                as,
+                primaryKey,
+                i2,
+                count
+              );
+            });
+          });
+        },
+        pqb._queryInsertMany(selectPKeys, create.values)
       );
-      return;
-    } else if ("connect" in value) {
-      const as = pqb.getFreeAlias(q.q.withShapes, "q");
-      pqb._prependWith(q, as, query.select(...primaryKeys).findBy(value.connect));
-      foreignKeys.map((foreignKey, i) => {
-        item[foreignKey] = new pqb.RawSql(
-          selectCteColumnMustExistSql(i, as, primaryKeys[i])
+    }
+    if (connect) {
+      connect.values.forEach((value, itemI) => {
+        const as = pqb.getFreeAlias(q.q.withShapes, "q");
+        pqb._prependWith(q, as, query.select(...primaryKeys).findBy(value));
+        foreignKeys.map((foreignKey, i) => {
+          connect.items[itemI][foreignKey] = new pqb.RawSql(
+            selectCteColumnMustExistSql(i, as, primaryKeys[i])
+          );
+        });
+      });
+    }
+    if (connectOrCreate) {
+      connectOrCreate.values.forEach((value, itemI) => {
+        const asFn = setForeignKeysFromCte(
+          connectOrCreate.items[itemI],
+          primaryKeys,
+          foreignKeys
+        );
+        const selectPKeys = query.select(...primaryKeys);
+        pqb._prependWith(
+          q,
+          asFn,
+          pqb._orCreate(
+            pqb._queryWhere(selectPKeys, [value.where]),
+            value.create
+          )
         );
       });
-      return;
     }
   }
   update(q, set) {
@@ -521,16 +568,20 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
       const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
       pqb._prependWith(self, asFn, createQuery);
     } else if (params.update) {
-      _selectIfNotSelected(self, foreignKeys);
+      let appendedAs;
+      pqb._hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
+        selectIdsSql._sql = selectCteColumnsSql(
+          appendedAs,
+          aliasedForeignKeys
+        );
+      });
       const selectIdsSql = new pqb.RawSql("");
       const updateQuery = pqb._queryUpdate(
         pqb._queryWhereIn(query.clone(), true, primaryKeys, selectIdsSql),
         params.update
       );
       updateQuery.q.returnType = "value";
-      pqb._appendQuery(self, updateQuery, (as) => {
-        selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
-      });
+      pqb._appendQuery(self, updateQuery, (as) => appendedAs = as);
     } else if (params.upsert) {
       if (pqb.isQueryReturnsAll(self)) {
         throw new Error("`upsert` option is not allowed in a batch update");
@@ -551,7 +602,9 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
       const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
       pqb._prependWith(self, asFn, upsertQuery);
     } else if (params.delete) {
-      _selectIfNotSelected(self, foreignKeys);
+      pqb._hookSelectColumns(self, foreignKeys, (a) => {
+        console.log(a);
+      });
       disconnect(update, foreignKeys);
       const { selectIdsSql, relQuery } = relWithSelectIds(
         self,
@@ -659,39 +712,103 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
       this.setNulls[foreignKey] = null;
     }
   }
-  create(self, ctx, item, rowIndex, one) {
-    if (one) {
-      const value = item[this.key];
-      if (!value.create && !value.connect && !value.connectOrCreate) {
-        return;
-      }
+  create(self, ctx, items, rowIndexes, count) {
+    if (count <= self.qb.internal.nestedCreateBatchMax) {
       const { query: rel, primaryKeys, foreignKeys } = this.state;
-      _selectIfNotSelected(self, primaryKeys);
-      const data = value.create ? { ...value.create } : {};
-      foreignKeys.forEach((key) => {
-        data[key] = new pqb.RawSql("");
-      });
-      const query = value.create ? pqb._queryCreate(pqb._clone(rel), data) : value.connect ? pqb._queryUpdateOrThrow(
-        rel.where(value.connect),
-        data
-      ) : value.connectOrCreate ? pqb._queryUpsert(rel.where(value.connectOrCreate.where), {
-        update: data,
-        create: {
-          ...value.connectOrCreate.create,
-          ...data
+      let nestedCreateItems;
+      items.forEach((item, i) => {
+        var _a;
+        const value = item[this.key];
+        const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+        if (kind) {
+          const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_a[kind] = {
+            indexes: [],
+            items: [],
+            values: []
+          });
+          nestedCreateItem.indexes.push(rowIndexes[i]);
+          nestedCreateItem.values.push(value[kind]);
+          const data = value.create ? { ...value.create } : {};
+          for (const key of foreignKeys) {
+            data[key] = new pqb.RawSql("");
+          }
+          nestedCreateItem.items.push(data);
         }
-      }) : void 0;
-      pqb._appendQuery(self, query, (as) => {
-        foreignKeys.forEach((key, i) => {
-          data[key]._sql = selectCteColumnSql(as, primaryKeys[i]);
+      });
+      if (!nestedCreateItems) {
+        return;
+      }
+      let createAs;
+      let connectAs;
+      let connectOrCreateAs;
+      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+        foreignKeys.forEach((key, keyI) => {
+          const primaryKey = aliasedPrimaryKeys[keyI];
+          if (create && createAs) {
+            for (let i = 0; i < create.items.length; i++) {
+              create.items[i][key]._sql = selectCteColumnFromManySql(
+                createAs,
+                primaryKey,
+                create.indexes[i],
+                count
+              );
+            }
+          }
+          if (connect && connectAs) {
+            for (let i = 0; i < connect.items.length; i++) {
+              connect.items[i][key]._sql = selectCteColumnFromManySql(
+                connectAs,
+                primaryKey,
+                connect.indexes[i],
+                count
+              );
+            }
+          }
+          if (connectOrCreate && connectOrCreateAs) {
+            for (let i = 0; i < connectOrCreate.items.length; i++) {
+              connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(
+                connectOrCreateAs,
+                primaryKey,
+                connectOrCreate.indexes[i],
+                count
+              );
+            }
+          }
         });
       });
+      const { create, connect, connectOrCreate } = nestedCreateItems;
+      if (create) {
+        const query = pqb._queryInsertMany(pqb._clone(rel), create.items);
+        pqb._appendQuery(self, query, (as) => createAs = as);
+      }
+      if (connect) {
+        connect.values.forEach((value, i) => {
+          const query = pqb._queryUpdateOrThrow(
+            rel.where(value),
+            connect.items[i]
+          );
+          query.q.ensureCount = 1;
+          pqb._appendQuery(self, query, (as) => connectAs = as);
+        });
+      }
+      if (connectOrCreate) {
+        connectOrCreate.values.forEach((value, i) => {
+          const query = pqb._queryUpsert(rel.where(value.where), {
+            update: connectOrCreate.items[i],
+            create: {
+              ...value.create,
+              ...connectOrCreate.items[i]
+            }
+          });
+          pqb._appendQuery(self, query, (as) => connectOrCreateAs = as);
+        });
+      }
     } else {
       hasRelationHandleCreate(
         self,
         ctx,
-        item,
-        rowIndex,
+        items,
+        rowIndexes,
         this.key,
         this.state.primaryKeys,
         this.nestedInsert
@@ -706,7 +823,21 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
     }
     const { primaryKeys, foreignKeys, query: relQuery } = this.state;
     if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
-      _selectIfNotSelected(self, primaryKeys);
+      let appendedAs;
+      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+        selectIdsSql._sql = selectCteColumnsSql(
+          appendedAs,
+          aliasedPrimaryKeys
+        );
+        if (params.create || params.set || params.upsert) {
+          foreignKeys.forEach((foreignKey, i) => {
+            setIds[foreignKey]._sql = selectCteColumnSql(
+              appendedAs,
+              aliasedPrimaryKeys[i]
+            );
+          });
+        }
+      });
       const selectIdsSql = new pqb.RawSql("");
       const existingRelQuery = pqb._queryWhereIn(
         pqb._clone(relQuery),
@@ -729,17 +860,7 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
         }
       }) : params.delete ? pqb._queryDelete(existingRelQuery) : pqb._queryUpdate(existingRelQuery, this.setNulls);
       nullifyOrDeleteQuery.q.returnType = "void";
-      pqb._appendQuery(self, nullifyOrDeleteQuery, (as) => {
-        selectIdsSql._sql = selectCteColumnsSql(as, primaryKeys);
-        if (params.create || params.set || params.upsert) {
-          foreignKeys.forEach((foreignKey, i) => {
-            setIds[foreignKey]._sql = selectCteColumnSql(
-              as,
-              primaryKeys[i]
-            );
-          });
-        }
-      });
+      pqb._appendQuery(self, nullifyOrDeleteQuery, (as) => appendedAs = as);
       if (params.create) {
         const createQuery = pqb._queryInsert(pqb._clone(relQuery), {
           ...params.create,
@@ -934,16 +1055,133 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
     this.nestedInsert = nestedInsert$1(state);
     this.nestedUpdate = nestedUpdate$1(state);
   }
-  create(q, ctx, item, rowIndex) {
-    hasRelationHandleCreate(
-      q,
-      ctx,
-      item,
-      rowIndex,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedInsert
-    );
+  create(self, ctx, items, rowIndexes, count) {
+    if (count <= self.qb.internal.nestedCreateBatchMax) {
+      const { query: rel, primaryKeys, foreignKeys } = this.state;
+      let nestedCreateItems;
+      items.forEach((item, i) => {
+        var _a, _b;
+        const value = item[this.key];
+        if (value.create?.length) {
+          const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {})).create ?? (_a.create = {
+            indexes: [],
+            items: []
+          });
+          nestedCreateItem.indexes.push(rowIndexes[i]);
+          const data = value.create.map((obj) => {
+            const data2 = { ...obj };
+            for (const key of foreignKeys) {
+              data2[key] = new pqb.RawSql("");
+            }
+            return data2;
+          });
+          nestedCreateItem.items.push(data);
+        } else {
+          const kind = value.connect?.length ? "connect" : value.connectOrCreate?.length ? "connectOrCreate" : void 0;
+          if (kind) {
+            const nestedCreateItem = (_b = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_b[kind] = {
+              indexes: [],
+              items: [],
+              values: []
+            });
+            nestedCreateItem.indexes.push(rowIndexes[i]);
+            nestedCreateItem.values.push(value[kind]);
+            const data = {};
+            for (const key of foreignKeys) {
+              data[key] = new pqb.RawSql("");
+            }
+            nestedCreateItem.items.push(data);
+          }
+        }
+      });
+      if (!nestedCreateItems) {
+        return;
+      }
+      let createAs;
+      let connectAs;
+      let connectOrCreateAs;
+      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+        foreignKeys.forEach((key, keyI) => {
+          const primaryKey = aliasedPrimaryKeys[keyI];
+          if (create && createAs) {
+            for (let i = 0; i < create.items.length; i++) {
+              const sql = selectCteColumnFromManySql(
+                createAs,
+                primaryKey,
+                create.indexes[i],
+                count
+              );
+              for (const item of create.items[i]) {
+                item[key]._sql = sql;
+              }
+            }
+          }
+          if (connect && connectAs) {
+            for (let i = 0; i < connect.items.length; i++) {
+              connect.items[i][key]._sql = selectCteColumnFromManySql(
+                connectAs,
+                primaryKey,
+                connect.indexes[i],
+                count
+              );
+            }
+          }
+          if (connectOrCreate && connectOrCreateAs) {
+            for (let i = 0; i < connectOrCreate.items.length; i++) {
+              connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(
+                connectOrCreateAs,
+                primaryKey,
+                connectOrCreate.indexes[i],
+                count
+              );
+            }
+          }
+        });
+      });
+      const { create, connect, connectOrCreate } = nestedCreateItems;
+      if (create) {
+        const query = pqb._queryInsertMany(
+          pqb._clone(rel),
+          create.items.flat()
+        );
+        pqb._appendQuery(self, query, (as) => createAs = as);
+      }
+      if (connect) {
+        connect.values.forEach((value, i) => {
+          const query = pqb._queryUpdateOrThrow(
+            rel.whereOneOf(...value),
+            connect.items[i]
+          );
+          query.q.ensureCount = value.length;
+          pqb._appendQuery(self, query, (as) => connectAs = as);
+        });
+      }
+      if (connectOrCreate) {
+        connectOrCreate.values.forEach((array, i) => {
+          const foreignKeyValues = connectOrCreate.items[i];
+          for (const value of array) {
+            const query = pqb._queryUpsert(rel.where(value.where), {
+              update: foreignKeyValues,
+              create: {
+                ...value.create,
+                ...foreignKeyValues
+              }
+            });
+            pqb._appendQuery(self, query, (as) => connectOrCreateAs = as);
+          }
+        });
+      }
+    } else {
+      hasRelationHandleCreate(
+        self,
+        ctx,
+        items,
+        rowIndexes,
+        this.key,
+        this.state.primaryKeys,
+        this.nestedInsert
+      );
+    }
   }
   update(q, set) {
     const params = set[this.key];
@@ -1277,12 +1515,12 @@ class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
     this.nestedInsert = nestedInsert(state);
     this.nestedUpdate = nestedUpdate(state);
   }
-  create(q, ctx, item, rowIndex) {
+  create(q, ctx, items, rowIndexes) {
     hasRelationHandleCreate(
       q,
       ctx,
-      item,
-      rowIndex,
+      items,
+      rowIndexes,
       this.key,
       this.state.primaryKeys,
       this.nestedInsert
@@ -1304,7 +1542,7 @@ const removeColumnName = (column) => {
   cloned.data = { ...column.data, name: void 0 };
   return cloned;
 };
-const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query) => {
+const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query, schema) => {
   const { options } = relation;
   const { snakeCase } = table.internal;
   const primaryKeys = options.columns;
@@ -1353,6 +1591,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   baseQuery.shape = shape;
   baseQuery.q = {
     ...baseQuery.q,
+    schema: options.through.schema || schema,
     shape: baseQuery.shape
   };
   const subQuery = Object.create(baseQuery);
@@ -1833,7 +2072,7 @@ const nestedUpdate = (state) => {
   };
 };
 
-const applyRelations = (qb, tables, result) => {
+const applyRelations = (qb, tables, result, schema) => {
   const tableEntries = Object.entries(tables);
   const delayedRelations = /* @__PURE__ */ new Map();
   for (const name in tables) {
@@ -1883,7 +2122,7 @@ const applyRelations = (qb, tables, result) => {
           continue;
         }
       }
-      applyRelation(table, qb, data, delayedRelations);
+      applyRelation(table, qb, data, delayedRelations, schema);
     }
   }
   if (delayedRelations.size) {
@@ -1919,7 +2158,7 @@ const delayRelation = (delayedRelations, table, relationName, data) => {
     tableRelations[relationName] = [data];
   }
 };
-const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
+const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations, schema) => {
   const baseQuery = Object.create(otherDbTable);
   baseQuery.baseQuery = baseQuery;
   const query = baseQuery.as(relationName);
@@ -1944,7 +2183,8 @@ const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTabl
       qb,
       relation,
       relationName,
-      query
+      query,
+      schema
     );
   } else {
     throw new Error(`Unknown relation type ${type}`);
@@ -1983,7 +2223,7 @@ const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTabl
   const tableRelations = delayedRelations.get(dbTable);
   if (!tableRelations) return;
   tableRelations[relationName]?.forEach((data2) => {
-    applyRelation(table, qb, data2, delayedRelations);
+    applyRelation(table, qb, data2, delayedRelations, schema);
   });
 };
 
@@ -2008,6 +2248,7 @@ const orchidORMWithAdapter = ({
   logger,
   autoPreparedStatements,
   noPrimaryKey = "error",
+  schema,
   ...options
 }, tables) => {
   const commonOptions = {
@@ -2061,7 +2302,7 @@ const orchidORMWithAdapter = ({
     tableInstances[key] = table;
     const options2 = {
       ...commonOptions,
-      schema: table.schema,
+      schema: table.schema || schema,
       language: table.language,
       scopes: table.scopes,
       softDelete: table.softDelete,
@@ -2088,7 +2329,7 @@ const orchidORMWithAdapter = ({
     dbTable.name = table.constructor.name;
     result[key] = dbTable;
   }
-  applyRelations(qb, tableInstances, result);
+  applyRelations(qb, tableInstances, result, schema);
   for (const key in tables) {
     const table = tableInstances[key];
     if (table.init) {