orchid-orm 1.40.1 → 1.41.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { makeColumnTypes, QueryHooks, defaultSchemaConfig, raw, getColumnTypes, parseTableData, _queryHookAfterCreate, _queryHookAfterUpdate, getQueryAs, setQueryObjectValue, pushQueryOnForOuter, VirtualColumn, pushQueryValue, _queryCreateMany, isQueryReturnsAll, _queryHookBeforeUpdate, _queryFindBy, _queryCreate, _queryRows, _queryUpdate, _queryDelete, _queryDefaults, _queryUpdateOrThrow, _queryWhere, _queryJoinOn, OrchidOrmInternalError, _queryCreateFrom, NotFoundError, _queryFindByOptional, _querySelect, _queryWhereExists, _queryTake, _queryTakeOptional, Adapter, _initQueryBuilder, Db, getClonedQueryData } from 'pqb';
+import { makeColumnTypes, QueryHooks, defaultSchemaConfig, raw, getColumnTypes, parseTableData, _queryHookAfterCreate, _queryHookAfterUpdate, getQueryAs, setQueryObjectValueImmutable, pushQueryOnForOuter, _queryWhere, _queryDefaults, VirtualColumn, pushQueryValueImmutable, _queryCreateMany, isQueryReturnsAll, _queryHookBeforeUpdate, _queryFindBy, _queryCreate, _queryRows, _queryUpdate, _queryDelete, _queryUpdateOrThrow, OrchidOrmInternalError, _queryJoinOn, _queryCreateFrom, NotFoundError, _queryFindByOptional, _querySelect, _queryWhereExists, _queryTake, _queryTakeOptional, Adapter, _initQueryBuilder, Db, getClonedQueryData } from 'pqb';
 export * from 'pqb';
-import { getStackTrace, applyMixins, getCallerFilePath, snakeCaseKey, toSnakeCase, emptyObject, emptyArray, objectHasValues, toArray } from 'orchid-core';
+import { getStackTrace, applyMixins, getCallerFilePath, snakeCaseKey, toSnakeCase, emptyObject, emptyArray, toArray, objectHasValues, pick } from 'orchid-core';
 export * from 'orchid-core';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
@@ -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();
-  setQueryObjectValue(
-    q,
-    "joinedShapes",
-    baseQuery.q.as || baseQuery.table,
-    baseQuery.q.shape
-  );
   const baseAs = getQueryAs(baseQuery);
+  const q = joiningQuery.clone();
+  setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
   for (let i = 0; i < len; i++) {
     pushQueryOnForOuter(
       q,
@@ -340,7 +328,7 @@ class BelongsToVirtualColumn extends VirtualColumn {
     const relationData = [values];
     store.belongsTo[key] = relationData;
     q.q.wrapInTransaction = true;
-    pushQueryValue(q, "beforeCreate", async (q2) => {
+    pushQueryValueImmutable(q, "beforeCreate", async (q2) => {
       const inserted = await this.nestedInsert(
         q2,
         relationData.map(([, , data]) => data)
@@ -364,9 +352,13 @@ class BelongsToVirtualColumn extends VirtualColumn {
 const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
   const primaryKeys = relation.options.references;
   const foreignKeys = relation.options.columns;
+  const { on } = relation.options;
+  if (on) {
+    _queryWhere(query, [on]);
+    _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();
-    setQueryObjectValue(
-      q,
-      "joinedShapes",
-      baseQuery.q.as || baseQuery.table,
-      baseQuery.q.shape
-    );
     const baseAs = getQueryAs(baseQuery);
+    const q = joiningQuery.clone();
+    setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
     for (let i = 0; i < len; i++) {
       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(
       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 _queryUpdate(
-            query.findBy(obj),
-            upsert.update
-          );
-        } else {
+        const count = obj ? await _queryUpdate(
+          query.findBy(obj),
+          upsert.update
+        ) : 0;
+        if (!count) {
           const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
           const result = await _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) {
+    _queryWhere(query, [on]);
+    _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 _queryDefaults(query.where(values), values);
+      return _queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasOneVirtualColumn(
       defaultSchemaConfig,
@@ -837,7 +845,9 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
     } else if (params.update) {
       await _queryUpdate(currentRelationsQuery, params.update);
     } else if (params.delete) {
-      await _queryDelete(currentRelationsQuery);
+      const q = _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) {
+    _queryWhere(query, [on]);
+    _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 _queryDefaults(query.where(values), values);
+      return _queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasManyVirtualColumn(
       defaultSchemaConfig,
@@ -1033,7 +1048,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
           obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
         }
         items[i] = _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 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 = toArray(params.add);
+      const count = await _queryUpdate(
+        t.where({ OR: relatedWheres }),
+        obj
+      );
+      if (count < relatedWheres.length) {
+        throw new 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) {
+    _queryWhere(query, [on]);
+    _queryDefaults(query, on);
+  }
   const { snakeCase } = table.internal;
   const foreignKeysFull = foreignKeys.map((key, i) => {
     if (snakeCase) key = foreignKeys[i] = 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++) {
-          _queryJoinOn(q, [
+          _queryJoinOn(q2, [
             throughForeignKeysFull[i],
             throughPrimaryKeysFull[i]
           ]);
         }
-        return _queryWhere(q, [where]);
+        return _queryWhere(q2, [where]);
       });
+      return on ? _queryDefaults(q, on) : q;
     },
     virtualColumn: new HasAndBelongsToManyVirtualColumn(
       subQuery,
@@ -1411,6 +1458,19 @@ const queryJoinTable = (state, data, conditions) => {
       }
     ]);
   }
+  if (state.on) {
+    _queryWhereExists(t, state.relatedTableQuery, [
+      (q) => {
+        for (let i = 0; i < state.throughPrimaryKeys.length; i++) {
+          _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 _queryCreateMany(
         _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 = toArray(params.add);
+      const joinTableColumns = [
+        ...state.foreignKeys,
+        ...state.throughForeignKeys
+      ];
+      try {
+        const count = await state.joinTableQuery.insertManyFrom(
+          _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) => pick(x, state.primaryKeys))
+          )
+        ).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
+        if (count < data.length * relatedWheres.length) {
+          throw new 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 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 _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(