orchid-orm 1.59.5 → 1.60.1

package/dist/index.js

@@ -191,7 +191,7 @@ const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
     );
   });
 };
-const selectIfNotSelected = (q, columns) => {
+const _selectIfNotSelected = (q, columns) => {
   const select = q.q.select || [];
   if (!select.includes("*")) {
     for (const column of columns) {
@@ -287,6 +287,8 @@ const getColumnKeyFromDbName = (query, name) => {
   }
   return name;
 };
+const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
+const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
 
 const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, baseQuery) => {
   const jq = joiningQuery;
@@ -402,7 +404,7 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     super(schema);
     this.key = key;
     this.state = state;
-    this.nestedUpdate = nestedUpdate$3(this.state);
+    this.nestedUpdate = nestedUpdate$2(this.state);
   }
   create(q, ctx, item) {
     const {
@@ -416,18 +418,11 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     }
     const value = item[key];
     if ("create" in value || "connectOrCreate" in value) {
-      foreignKeys.forEach((foreignKey) => item[foreignKey] = new pqb.RawSql(""));
+      const asFn = setForeignKeysFromCte(item, primaryKeys, foreignKeys);
       const selectPKeys = query.select(...primaryKeys);
-      pqb._with(
+      pqb._prependWith(
         q,
-        (as) => {
-          foreignKeys.forEach((foreignKey, i) => {
-            item[foreignKey]._sql = selectCteColumnSql(
-              as,
-              primaryKeys[i]
-            );
-          });
-        },
+        asFn,
         "create" in value ? pqb._queryCreate(selectPKeys, value.create) : pqb._orCreate(
           pqb._queryWhere(selectPKeys, [
             value.connectOrCreate.where
@@ -438,7 +433,7 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
       return;
     } else if ("connect" in value) {
       const as = pqb.getFreeAlias(q.q.withShapes, "q");
-      pqb._with(q, as, query.select(...primaryKeys).findBy(value.connect));
+      pqb._prependWith(q, as, query.select(...primaryKeys).findBy(value.connect));
       foreignKeys.map((foreignKey, i) => {
         item[foreignKey] = new pqb.RawSql(
           selectCteColumnMustExistSql(i, as, primaryKeys[i])
@@ -447,10 +442,10 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
       return;
     }
   }
-  update(q, ctx, set) {
+  update(q, set) {
     q.q.wrapInTransaction = true;
     const data = set[this.key];
-    this.nestedUpdate(q, set, data, ctx);
+    this.nestedUpdate(q, set, data);
   }
 }
 const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
@@ -521,139 +516,138 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
     reverseJoin
   };
 };
-const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
-  return (q, update, params, state) => {
-    if (params.upsert && pqb.isQueryReturnsAll(q)) {
-      throw new Error("`upsert` option is not allowed in a batch update");
-    }
-    let idsForDelete;
-    pqb._queryHookBeforeUpdate(q, async ({ query: q2 }) => {
-      if (params.disconnect) {
-        for (const key of foreignKeys) {
-          update[key] = null;
-        }
-      } else if (params.set) {
-        let loadPrimaryKeys;
-        let loadForeignKeys;
-        for (let i = 0; i < len; i++) {
-          const primaryKey = primaryKeys[i];
-          if (primaryKey in params.set) {
-            update[foreignKeys[i]] = params.set[primaryKey];
-          } else {
-            (loadPrimaryKeys ?? (loadPrimaryKeys = [])).push(primaryKey);
-            (loadForeignKeys ?? (loadForeignKeys = [])).push(foreignKeys[i]);
-          }
-        }
-        if (loadPrimaryKeys) {
-          for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
-            update[loadForeignKeys[i]] = new pqb.RawSql("");
-          }
-          pqb._with(
-            q2,
-            (as) => {
-              for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
-                update[loadForeignKeys[i]]._sql = selectCteColumnMustExistSql(i, as, loadPrimaryKeys[i]);
-              }
-            },
-            pqb._queryFindBy(query.select(...loadPrimaryKeys), params.set)
-          );
+const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
+  return (self, update, params) => {
+    if (params.create) {
+      const createQuery = pqb._querySelect(
+        pqb._queryCreate(query.clone(), params.create),
+        primaryKeys
+      );
+      const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+      pqb._prependWith(self, asFn, createQuery);
+    } else if (params.update) {
+      _selectIfNotSelected(self, foreignKeys);
+      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);
+      });
+    } else if (params.upsert) {
+      if (pqb.isQueryReturnsAll(self)) {
+        throw new Error("`upsert` option is not allowed in a batch update");
+      }
+      const { relQuery } = relWithSelectIds(
+        self,
+        query,
+        primaryKeys,
+        foreignKeys
+      );
+      const upsertQuery = pqb._querySelect(
+        pqb._queryUpsert(
+          relQuery,
+          params.upsert
+        ),
+        primaryKeys
+      );
+      const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+      pqb._prependWith(self, asFn, upsertQuery);
+    } else if (params.delete) {
+      _selectIfNotSelected(self, foreignKeys);
+      disconnect(update, foreignKeys);
+      const { selectIdsSql, relQuery } = relWithSelectIds(
+        self,
+        query,
+        primaryKeys,
+        foreignKeys
+      );
+      self.q.and = self.q.or = void 0;
+      pqb._queryWhereIn(self, true, foreignKeys, selectIdsSql);
+      const deleteQuery = pqb._queryDelete(relQuery);
+      deleteQuery.q.returnType = "value";
+      pqb._appendQuery(self, deleteQuery, pqb.noop);
+    } else if (params.disconnect) {
+      disconnect(update, foreignKeys);
+    } else if (params.set) {
+      let loadPrimaryKeys;
+      let loadForeignKeys;
+      for (let i = 0; i < len; i++) {
+        const primaryKey = primaryKeys[i];
+        if (primaryKey in params.set) {
+          update[foreignKeys[i]] = params.set[primaryKey];
+        } else {
+          (loadPrimaryKeys ?? (loadPrimaryKeys = [])).push(primaryKey);
+          (loadForeignKeys ?? (loadForeignKeys = [])).push(foreignKeys[i]);
         }
-      } else if (params.create) {
-        const q3 = query.clone();
-        q3.q.select = primaryKeys;
-        const record = await pqb._queryCreate(
-          q3,
-          params.create
+      }
+      if (loadPrimaryKeys) {
+        const asFn = setForeignKeysFromCte(
+          update,
+          loadPrimaryKeys,
+          loadForeignKeys,
+          true
+        );
+        pqb._prependWith(
+          self,
+          asFn,
+          pqb._queryFindBy(query.select(...loadPrimaryKeys), params.set)
         );
-        for (let i = 0; i < len; i++) {
-          update[foreignKeys[i]] = record[primaryKeys[i]];
-        }
-      } else if (params.delete) {
-        const selectQuery = q2.clone();
-        selectQuery.q.type = void 0;
-        selectQuery.q.distinct = pqb.emptyArray;
-        selectIfNotSelected(selectQuery, foreignKeys);
-        idsForDelete = await pqb._queryRows(selectQuery);
-        for (const foreignKey of foreignKeys) {
-          update[foreignKey] = null;
-        }
       }
-    });
-    const { upsert } = params;
-    if (upsert || params.update || params.delete) {
-      selectIfNotSelected(q, foreignKeys);
-    }
-    if (upsert) {
-      (state.queries ?? (state.queries = [])).push(async (queryResult) => {
-        const row = queryResult.rows[0];
-        let obj = {};
-        for (let i = 0; i < len; i++) {
-          const id = row[foreignKeys[i]];
-          if (id === null) {
-            obj = void 0;
-            break;
-          }
-          obj[primaryKeys[i]] = id;
-        }
-        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),
-            data
-          );
-          const collectData = {};
-          state.collect = {
-            data: collectData
-          };
-          for (let i = 0; i < len; i++) {
-            collectData[foreignKeys[i]] = result[primaryKeys[i]];
-          }
-        }
-      });
-    } else if (params.delete || params.update) {
-      pqb._queryHookAfterUpdate(
-        q,
-        params.update ? foreignKeys : pqb.emptyArray,
-        async (data) => {
-          let ids;
-          if (params.delete) {
-            ids = idsForDelete;
-          } else {
-            ids = [];
-            for (const item of data) {
-              let row;
-              for (const foreignKey of foreignKeys) {
-                const id = item[foreignKey];
-                if (id === null) {
-                  row = void 0;
-                  break;
-                } else {
-                  (row ?? (row = [])).push(id);
-                }
-              }
-              if (row) ids.push(row);
-            }
-          }
-          if (!ids?.length) return;
-          const t = query.whereIn(
-            primaryKeys,
-            ids
-          );
-          if (params.delete) {
-            await pqb._queryDelete(t);
-          } else {
-            await pqb._queryUpdate(t, params.update);
-          }
-        }
-      );
     }
   };
 };
-const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const disconnect = (update, foreignKeys) => {
+  for (const foreignKey of foreignKeys) {
+    update[foreignKey] = null;
+  }
+};
+const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
+  const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
+  const selectIdsSql = new pqb.RawSql("");
+  pqb._prependWith(
+    self,
+    (as) => {
+      selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
+    },
+    selectIdsQuery
+  );
+  return {
+    selectIdsSql,
+    relQuery: pqb._queryWhereIn(rel.clone(), true, primaryKeys, selectIdsSql)
+  };
+};
+const makeSelectIdsQuery = (self, foreignKeys) => {
+  const selectIdsQuery = self.baseQuery.clone();
+  selectIdsQuery.q.distinct = pqb.emptyArray;
+  selectIdsQuery.q.select = foreignKeys;
+  selectIdsQuery.q.and = self.q.and;
+  selectIdsQuery.q.or = self.q.or;
+  return selectIdsQuery;
+};
+const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
+  for (const key of foreignKeys) {
+    record[key] = new pqb.RawSql("");
+  }
+  return (as) => {
+    foreignKeys.forEach(
+      mustExist ? (foreignKey, i) => {
+        record[foreignKey]._sql = selectCteColumnMustExistSql(
+          i,
+          as,
+          primaryKeys[i]
+        );
+      } : (foreignKey, i) => {
+        record[foreignKey]._sql = selectCteColumnSql(
+          as,
+          primaryKeys[i]
+        );
+      }
+    );
+  };
+};
 const selectCteColumnMustExistSql = (i, cteAs, column) => {
   const selectColumn = selectCteColumnSql(cteAs, column);
   return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
@@ -665,32 +659,107 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$2(state);
-    this.nestedUpdate = nestedUpdate$2(state);
+    this.setNulls = {};
+    for (const foreignKey of state.foreignKeys) {
+      this.setNulls[foreignKey] = null;
+    }
   }
-  create(q, ctx, item, rowIndex) {
-    hasRelationHandleCreate(
-      q,
-      ctx,
-      item,
-      rowIndex,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedInsert
-    );
+  create(self, ctx, item, rowIndex, one) {
+    if (one) {
+      const value = item[this.key];
+      if (!value.create && !value.connect && !value.connectOrCreate) {
+        return;
+      }
+      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
+        }
+      }) : void 0;
+      pqb._appendQuery(self, query, (as) => {
+        foreignKeys.forEach((key, i) => {
+          data[key]._sql = selectCteColumnSql(as, primaryKeys[i]);
+        });
+      });
+    } else {
+      hasRelationHandleCreate(
+        self,
+        ctx,
+        item,
+        rowIndex,
+        this.key,
+        this.state.primaryKeys,
+        this.nestedInsert
+      );
+    }
   }
-  update(q, _, set) {
+  update(self, set) {
     const params = set[this.key];
-    if ((params.set || params.create || params.upsert) && pqb.isQueryReturnsAll(q)) {
+    if ((params.set || params.create || params.upsert) && pqb.isQueryReturnsAll(self)) {
       const key = params.set ? "set" : params.create ? "create" : "upsert";
       throw new Error(`\`${key}\` option is not allowed in a batch update`);
     }
-    hasRelationHandleUpdate(
-      q,
-      set,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedUpdate
-    );
+    const { primaryKeys, foreignKeys, query: relQuery } = this.state;
+    if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
+      _selectIfNotSelected(self, primaryKeys);
+      const selectIdsSql = new pqb.RawSql("");
+      const existingRelQuery = pqb._queryWhereIn(
+        pqb._clone(relQuery),
+        true,
+        foreignKeys,
+        selectIdsSql
+      );
+      let setIds = void 0;
+      if (params.create || params.set || params.upsert) {
+        setIds = {};
+        foreignKeys.forEach((foreignKey) => {
+          setIds[foreignKey] = new pqb.RawSql("");
+        });
+      }
+      const nullifyOrDeleteQuery = params.update ? pqb._queryUpdate(existingRelQuery, params.update) : params.upsert ? pqb._queryUpsert(existingRelQuery, {
+        update: params.upsert.update,
+        create: {
+          ...typeof params.upsert.create === "function" ? params.upsert.create() : params.upsert.create,
+          ...setIds
+        }
+      }) : 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]
+            );
+          });
+        }
+      });
+      if (params.create) {
+        const createQuery = pqb._queryInsert(pqb._clone(relQuery), {
+          ...params.create,
+          ...setIds
+        });
+        pqb._appendQuery(self, createQuery, pqb.noop);
+      } else if (params.set) {
+        const setQuery = pqb._queryUpdate(
+          pqb._queryWhere(pqb._clone(relQuery), [params.set]),
+          setIds
+        );
+        setQuery.q.returnType = "void";
+        pqb._appendQuery(self, setQuery, pqb.noop);
+      }
+    }
   }
 }
 const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
@@ -818,9 +887,9 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
       for (let i = 0, len = items.length; i < len; i++) {
         const [selfData, item] = items[i];
         const data2 = {};
-        for (let i2 = 0; i2 < len; i2++) {
-          data2[foreignKeys[i2]] = selfData[primaryKeys[i2]];
-        }
+        primaryKeys.forEach((primaryKey, i2) => {
+          data2[foreignKeys[i2]] = selfData[primaryKey];
+        });
         items[i] = "connect" in item ? pqb._queryUpdateOrThrow(
           t.where(item.connect),
           data2
@@ -861,78 +930,6 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
     }
   };
 };
-const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
-  const len = primaryKeys.length;
-  const setNulls = {};
-  for (const foreignKey of foreignKeys) {
-    setNulls[foreignKey] = null;
-  }
-  return async (_, data, params) => {
-    const t = query.clone();
-    const ids = data.map(
-      (item) => primaryKeys.map((primaryKey) => item[primaryKey])
-    );
-    const currentRelationsQuery = t.whereIn(
-      foreignKeys,
-      ids
-    );
-    if (params.create || params.disconnect || params.set) {
-      let queryToDisconnect = currentRelationsQuery;
-      if (params.set) {
-        queryToDisconnect = queryToDisconnect.whereNot(params.set);
-      }
-      await pqb._queryUpdate(queryToDisconnect, setNulls);
-      const record = data[0];
-      if (params.create) {
-        const obj = { ...params.create };
-        for (let i = 0; i < len; i++) {
-          obj[foreignKeys[i]] = record[primaryKeys[i]];
-        }
-        await t.insert(obj);
-      }
-      if (params.set) {
-        const obj = {};
-        for (let i = 0; i < len; i++) {
-          obj[foreignKeys[i]] = record[primaryKeys[i]];
-        }
-        await pqb._queryUpdate(
-          pqb._queryWhere(t, [params.set]),
-          obj
-        );
-      }
-    } else if (params.update) {
-      await pqb._queryUpdate(currentRelationsQuery, params.update);
-    } else if (params.delete) {
-      const q = pqb._queryDelete(currentRelationsQuery);
-      q.q.returnType = "value";
-      await q;
-    } else if (params.upsert) {
-      const { update, create } = params.upsert;
-      currentRelationsQuery.q.select = foreignKeys;
-      const updatedIds = await pqb._queryUpdate(
-        pqb._queryRows(currentRelationsQuery),
-        update
-      );
-      if (updatedIds.length < ids.length) {
-        const data2 = typeof create === "function" ? create() : create;
-        await t.createMany(
-          ids.reduce((rows, ids2) => {
-            if (!updatedIds.some(
-              (updated) => updated.every((value, i) => value === ids2[i])
-            )) {
-              const obj = { ...data2 };
-              for (let i = 0; i < len; i++) {
-                obj[foreignKeys[i]] = ids2[i];
-              }
-              rows.push(obj);
-            }
-            return rows;
-          }, [])
-        );
-      }
-    }
-  };
-};
 
 class HasManyVirtualColumn extends pqb.VirtualColumn {
   constructor(schema, key, state) {
@@ -953,7 +950,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
       this.nestedInsert
     );
   }
-  update(q, _, set) {
+  update(q, set) {
     const params = set[this.key];
     if ((params.set || params.create) && pqb.isQueryReturnsAll(q)) {
       const key = params.set ? "set" : "create";
@@ -1296,7 +1293,7 @@ class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
       this.nestedInsert
     );
   }
-  update(q, _, set) {
+  update(q, set) {
     hasRelationHandleUpdate(
       q,
       set,