@zenstackhq/runtime 2.16.0 → 3.0.0-alpha.1

package/cross/index.mjs

@@ -1,881 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/local-helpers/is-plain-object.ts
-function isObject(o) {
-  return Object.prototype.toString.call(o) === "[object Object]";
-}
-function isPlainObject(o) {
-  if (isObject(o) === false) return false;
-  const ctor = o.constructor;
-  if (ctor === void 0) return true;
-  const prot = ctor.prototype;
-  if (isObject(prot) === false) return false;
-  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
-    return false;
-  }
-  return true;
-}
-
-// src/local-helpers/lower-case-first.ts
-function lowerCaseFirst(input) {
-  return input.charAt(0).toLowerCase() + input.slice(1);
-}
-
-// src/local-helpers/tiny-invariant.ts
-var isProduction = process.env.NODE_ENV === "production";
-
-// src/cross/clone.ts
-function clone(value) {
-  if (Array.isArray(value)) {
-    return value.map((v) => clone(v));
-  }
-  if (typeof value === "object") {
-    if (!value || !isPlainObject(value)) {
-      return value;
-    }
-    const result = {};
-    for (const key of Object.keys(value)) {
-      result[key] = clone(value[key]);
-    }
-    return result;
-  }
-  return value;
-}
-
-// src/cross/model-data-visitor.ts
-var ModelDataVisitor = class {
-  constructor(modelMeta) {
-    this.modelMeta = modelMeta;
-  }
-  /**
-   * Visits the given model data.
-   */
-  visit(model, data, callback) {
-    if (!data || typeof data !== "object") {
-      return;
-    }
-    const scalarData = {};
-    const subTasks = [];
-    for (const [k, v] of Object.entries(data)) {
-      const field = resolveField(this.modelMeta, model, k);
-      if (field && field.isDataModel) {
-        if (field.isArray && Array.isArray(v)) {
-          subTasks.push(...v.map((item) => ({ model: field.type, data: item })));
-        } else {
-          subTasks.push({ model: field.type, data: v });
-        }
-      } else {
-        scalarData[k] = v;
-      }
-    }
-    callback(model, data, scalarData);
-    subTasks.forEach(({ model: model2, data: data2 }) => this.visit(model2, data2, callback));
-  }
-};
-
-// src/cross/model-meta.ts
-function resolveField(modelMeta, modelOrTypeDef, field, isTypeDef = false) {
-  var _a, _b;
-  const container = isTypeDef ? modelMeta.typeDefs : modelMeta.models;
-  return (_b = (_a = container == null ? void 0 : container[lowerCaseFirst(modelOrTypeDef)]) == null ? void 0 : _a.fields) == null ? void 0 : _b[field];
-}
-function requireField(modelMeta, model, field, isTypeDef = false) {
-  const f = resolveField(modelMeta, model, field, isTypeDef);
-  if (!f) {
-    throw new Error(`Field ${model}.${field} cannot be resolved`);
-  }
-  return f;
-}
-function getFields(modelMeta, model) {
-  var _a;
-  return (_a = modelMeta.models[lowerCaseFirst(model)]) == null ? void 0 : _a.fields;
-}
-function getUniqueConstraints(modelMeta, model) {
-  var _a;
-  return (_a = modelMeta.models[lowerCaseFirst(model)]) == null ? void 0 : _a.uniqueConstraints;
-}
-
-// src/cross/mutator.ts
-import { v4 as uuid } from "uuid";
-function applyMutation(queryModel, queryOp, queryData, mutationModel, mutationOp, mutationArgs, modelMeta, logging) {
-  return __async(this, null, function* () {
-    if (!queryData || typeof queryData !== "object" && !Array.isArray(queryData)) {
-      return void 0;
-    }
-    if (!queryOp.startsWith("find")) {
-      return void 0;
-    }
-    return yield doApplyMutation(queryModel, queryData, mutationModel, mutationOp, mutationArgs, modelMeta, logging);
-  });
-}
-function doApplyMutation(queryModel, queryData, mutationModel, mutationOp, mutationArgs, modelMeta, logging) {
-  return __async(this, null, function* () {
-    let resultData = queryData;
-    let updated = false;
-    const visitor = new NestedWriteVisitor(modelMeta, {
-      create: (model, args) => {
-        if (model === queryModel && Array.isArray(resultData)) {
-          const r = createMutate(queryModel, resultData, args, modelMeta, logging);
-          if (r) {
-            resultData = r;
-            updated = true;
-          }
-        }
-      },
-      createMany: (model, args) => {
-        if (model === queryModel && (args == null ? void 0 : args.data) && Array.isArray(resultData)) {
-          for (const oneArg of enumerate(args.data)) {
-            const r = createMutate(queryModel, resultData, oneArg, modelMeta, logging);
-            if (r) {
-              resultData = r;
-              updated = true;
-            }
-          }
-        }
-      },
-      update: (model, args) => {
-        if (model === queryModel && !Array.isArray(resultData)) {
-          const r = updateMutate(queryModel, resultData, model, args, modelMeta, logging);
-          if (r) {
-            resultData = r;
-            updated = true;
-          }
-        }
-      },
-      upsert: (model, args) => {
-        if (model === queryModel && (args == null ? void 0 : args.where) && (args == null ? void 0 : args.create) && (args == null ? void 0 : args.update)) {
-          const r = upsertMutate(queryModel, resultData, model, args, modelMeta, logging);
-          if (r) {
-            resultData = r;
-            updated = true;
-          }
-        }
-      },
-      delete: (model, args) => {
-        if (model === queryModel) {
-          const r = deleteMutate(queryModel, resultData, model, args, modelMeta, logging);
-          if (r) {
-            resultData = r;
-            updated = true;
-          }
-        }
-      }
-    });
-    yield visitor.visit(mutationModel, mutationOp, mutationArgs);
-    const modelFields = getFields(modelMeta, queryModel);
-    if (Array.isArray(resultData)) {
-      let arrayCloned = false;
-      for (let i = 0; i < resultData.length; i++) {
-        const item = resultData[i];
-        if (!item || typeof item !== "object" || item.$optimistic) {
-          continue;
-        }
-        const r = yield doApplyMutation(
-          queryModel,
-          item,
-          mutationModel,
-          mutationOp,
-          mutationArgs,
-          modelMeta,
-          logging
-        );
-        if (r && typeof r === "object") {
-          if (!arrayCloned) {
-            resultData = [...resultData];
-            arrayCloned = true;
-          }
-          resultData[i] = r;
-          updated = true;
-        }
-      }
-    } else if (resultData !== null && typeof resultData === "object") {
-      const currentData = __spreadValues({}, resultData);
-      for (const [key, value] of Object.entries(currentData)) {
-        const fieldInfo = modelFields[key];
-        if (!(fieldInfo == null ? void 0 : fieldInfo.isDataModel)) {
-          continue;
-        }
-        const r = yield doApplyMutation(
-          fieldInfo.type,
-          value,
-          mutationModel,
-          mutationOp,
-          mutationArgs,
-          modelMeta,
-          logging
-        );
-        if (r && typeof r === "object") {
-          resultData = __spreadProps(__spreadValues({}, resultData), { [key]: r });
-          updated = true;
-        }
-      }
-    }
-    return updated ? resultData : void 0;
-  });
-}
-function createMutate(queryModel, currentData, newData, modelMeta, logging) {
-  if (!newData) {
-    return void 0;
-  }
-  const modelFields = getFields(modelMeta, queryModel);
-  if (!modelFields) {
-    return void 0;
-  }
-  const insert = {};
-  const newDataFields = Object.keys(newData);
-  Object.entries(modelFields).forEach(([name, field]) => {
-    var _a, _b, _c, _d;
-    if (field.isDataModel && newData[name]) {
-      assignForeignKeyFields(field, insert, newData[name]);
-      return;
-    }
-    if (newDataFields.includes(name)) {
-      insert[name] = clone(newData[name]);
-    } else {
-      const defaultAttr = (_a = field.attributes) == null ? void 0 : _a.find((attr) => attr.name === "@default");
-      if (field.type === "DateTime") {
-        if (defaultAttr || ((_b = field.attributes) == null ? void 0 : _b.some((attr) => attr.name === "@updatedAt"))) {
-          insert[name] = /* @__PURE__ */ new Date();
-        }
-      } else if (((_d = (_c = defaultAttr == null ? void 0 : defaultAttr.args) == null ? void 0 : _c[0]) == null ? void 0 : _d.value) !== void 0) {
-        insert[name] = defaultAttr.args[0].value;
-      }
-    }
-  });
-  const idFields = getIdFields(modelMeta, queryModel, false);
-  idFields.forEach((f) => {
-    if (insert[f.name] === void 0) {
-      if (f.type === "Int" || f.type === "BigInt") {
-        const currMax = Array.isArray(currentData) ? Math.max(
-          ...[...currentData].map((item) => {
-            const idv = parseInt(item[f.name]);
-            return isNaN(idv) ? 0 : idv;
-          })
-        ) : 0;
-        insert[f.name] = currMax + 1;
-      } else {
-        insert[f.name] = uuid();
-      }
-    }
-  });
-  insert.$optimistic = true;
-  if (logging) {
-    console.log(`Optimistic create for ${queryModel}:`, insert);
-  }
-  return [insert, ...Array.isArray(currentData) ? currentData : []];
-}
-function updateMutate(queryModel, currentData, mutateModel, mutateArgs, modelMeta, logging) {
-  if (!currentData || typeof currentData !== "object") {
-    return void 0;
-  }
-  if (!(mutateArgs == null ? void 0 : mutateArgs.where) || typeof mutateArgs.where !== "object") {
-    return void 0;
-  }
-  if (!(mutateArgs == null ? void 0 : mutateArgs.data) || typeof mutateArgs.data !== "object") {
-    return void 0;
-  }
-  if (!idFieldsMatch(mutateModel, currentData, mutateArgs.where, modelMeta)) {
-    return void 0;
-  }
-  const modelFields = getFields(modelMeta, queryModel);
-  if (!modelFields) {
-    return void 0;
-  }
-  let updated = false;
-  let resultData = currentData;
-  for (const [key, value] of Object.entries(mutateArgs.data)) {
-    const fieldInfo = modelFields[key];
-    if (!fieldInfo) {
-      continue;
-    }
-    if (fieldInfo.isDataModel && !(value == null ? void 0 : value.connect)) {
-      continue;
-    }
-    if (!updated) {
-      resultData = __spreadValues({}, currentData);
-    }
-    if (fieldInfo.isDataModel) {
-      assignForeignKeyFields(fieldInfo, resultData, value);
-    } else {
-      resultData[key] = clone(value);
-    }
-    resultData.$optimistic = true;
-    updated = true;
-    if (logging) {
-      console.log(`Optimistic update for ${queryModel}:`, resultData);
-    }
-  }
-  return updated ? resultData : void 0;
-}
-function upsertMutate(queryModel, currentData, model, args, modelMeta, logging) {
-  let updated = false;
-  let resultData = currentData;
-  if (Array.isArray(resultData)) {
-    const foundIndex = resultData.findIndex((x) => idFieldsMatch(model, x, args.where, modelMeta));
-    if (foundIndex >= 0) {
-      const updateResult = updateMutate(
-        queryModel,
-        resultData[foundIndex],
-        model,
-        { where: args.where, data: args.update },
-        modelMeta,
-        logging
-      );
-      if (updateResult) {
-        resultData = [...resultData.slice(0, foundIndex), updateResult, ...resultData.slice(foundIndex + 1)];
-        updated = true;
-      }
-    } else {
-      const createResult = createMutate(queryModel, resultData, args.create, modelMeta, logging);
-      if (createResult) {
-        resultData = createResult;
-        updated = true;
-      }
-    }
-  } else {
-    const updateResult = updateMutate(
-      queryModel,
-      resultData,
-      model,
-      { where: args.where, data: args.update },
-      modelMeta,
-      logging
-    );
-    if (updateResult) {
-      resultData = updateResult;
-      updated = true;
-    }
-  }
-  return updated ? resultData : void 0;
-}
-function deleteMutate(queryModel, currentData, mutateModel, mutateArgs, modelMeta, logging) {
-  if (!currentData || !mutateArgs) {
-    return void 0;
-  }
-  if (queryModel !== mutateModel) {
-    return void 0;
-  }
-  let updated = false;
-  let result = currentData;
-  if (Array.isArray(currentData)) {
-    for (const item of currentData) {
-      if (idFieldsMatch(mutateModel, item, mutateArgs, modelMeta)) {
-        result = result.filter((x) => x !== item);
-        updated = true;
-        if (logging) {
-          console.log(`Optimistic delete for ${queryModel}:`, item);
-        }
-      }
-    }
-  } else {
-    if (idFieldsMatch(mutateModel, currentData, mutateArgs, modelMeta)) {
-      result = null;
-      updated = true;
-      if (logging) {
-        console.log(`Optimistic delete for ${queryModel}:`, currentData);
-      }
-    }
-  }
-  return updated ? result : void 0;
-}
-function idFieldsMatch(model, x, y, modelMeta) {
-  if (!x || !y || typeof x !== "object" || typeof y !== "object") {
-    return false;
-  }
-  const idFields = getIdFields(modelMeta, model, false);
-  if (idFields.length === 0) {
-    return false;
-  }
-  return idFields.every((f) => x[f.name] === y[f.name]);
-}
-function assignForeignKeyFields(field, resultData, mutationData) {
-  if (!(mutationData == null ? void 0 : mutationData.connect)) {
-    return;
-  }
-  if (!field.foreignKeyMapping) {
-    return;
-  }
-  for (const [idField, fkField] of Object.entries(field.foreignKeyMapping)) {
-    if (idField in mutationData.connect) {
-      resultData[fkField] = mutationData.connect[idField];
-    }
-  }
-}
-
-// src/cross/nested-read-visitor.ts
-var NestedReadVisitor = class {
-  constructor(modelMeta, callback) {
-    this.modelMeta = modelMeta;
-    this.callback = callback;
-  }
-  doVisit(model, field, kind, args) {
-    if (this.callback.field) {
-      const r = this.callback.field(model, field, kind, args);
-      if (r === false) {
-        return;
-      }
-    }
-    if (!args || typeof args !== "object") {
-      return;
-    }
-    let selectInclude;
-    let nextKind;
-    if (args.select) {
-      selectInclude = args.select;
-      nextKind = "select";
-    } else if (args.include) {
-      selectInclude = args.include;
-      nextKind = "include";
-    }
-    if (selectInclude && typeof selectInclude === "object") {
-      for (const [k, v] of Object.entries(selectInclude)) {
-        if (k === "_count" && typeof v === "object" && v) {
-          this.doVisit(model, field, kind, v);
-        } else {
-          const field2 = resolveField(this.modelMeta, model, k);
-          if (field2) {
-            this.doVisit(field2.type, field2, nextKind, v);
-          }
-        }
-      }
-    }
-  }
-  visit(model, args) {
-    this.doVisit(model, void 0, void 0, args);
-  }
-};
-
-// src/cross/types.ts
-var PrismaWriteActions = [
-  "create",
-  "createMany",
-  "createManyAndReturn",
-  "connectOrCreate",
-  "update",
-  "updateMany",
-  "updateManyAndReturn",
-  "upsert",
-  "connect",
-  "disconnect",
-  "set",
-  "delete",
-  "deleteMany"
-];
-
-// src/cross/utils.ts
-function getModelFields(data) {
-  return data ? Object.keys(data) : [];
-}
-function enumerate(x) {
-  if (x === null || x === void 0) {
-    return [];
-  } else if (Array.isArray(x)) {
-    return x;
-  } else {
-    return [x];
-  }
-}
-function zip(x, y) {
-  if (Array.isArray(x)) {
-    if (!Array.isArray(y)) {
-      throw new Error("x and y should be both array or both scalar");
-    }
-    if (x.length !== y.length) {
-      throw new Error("x and y should have the same length");
-    }
-    return x.map((_, i) => [x[i], y[i]]);
-  } else {
-    if (Array.isArray(y)) {
-      throw new Error("x and y should be both array or both scalar");
-    }
-    return [[x, y]];
-  }
-}
-function getIdFields(modelMeta, model, throwIfNotFound = false) {
-  var _a, _b;
-  const uniqueConstraints = (_b = (_a = modelMeta.models[lowerCaseFirst(model)]) == null ? void 0 : _a.uniqueConstraints) != null ? _b : {};
-  const entries = Object.values(uniqueConstraints);
-  if (entries.length === 0) {
-    if (throwIfNotFound) {
-      throw new Error(`Model ${model} does not have any id field`);
-    }
-    return [];
-  }
-  return entries[0].fields.map((f) => requireField(modelMeta, model, f));
-}
-function getModelInfo(modelMeta, model, throwIfNotFound = false) {
-  const info = modelMeta.models[lowerCaseFirst(model)];
-  if (!info && throwIfNotFound) {
-    throw new Error(`Unable to load info for ${model}`);
-  }
-  return info;
-}
-function getTypeDefInfo(modelMeta, typeDef, throwIfNotFound = false) {
-  var _a;
-  const info = (_a = modelMeta.typeDefs) == null ? void 0 : _a[lowerCaseFirst(typeDef)];
-  if (!info && throwIfNotFound) {
-    throw new Error(`Unable to load info for ${typeDef}`);
-  }
-  return info;
-}
-function isDelegateModel(modelMeta, model) {
-  var _a, _b;
-  return !!((_b = (_a = getModelInfo(modelMeta, model)) == null ? void 0 : _a.attributes) == null ? void 0 : _b.some((attr) => attr.name === "@@delegate"));
-}
-
-// src/cross/nested-write-visitor.ts
-var NestedWriteVisitor = class {
-  constructor(modelMeta, callback) {
-    this.modelMeta = modelMeta;
-    this.callback = callback;
-  }
-  isPrismaWriteAction(value) {
-    return PrismaWriteActions.includes(value);
-  }
-  /**
-   * Start visiting
-   *
-   * @see NestedWriterVisitorCallback
-   */
-  visit(model, action, args) {
-    return __async(this, null, function* () {
-      if (!args) {
-        return;
-      }
-      let topData = args;
-      switch (action) {
-        case "create":
-          topData = topData.data;
-          break;
-        case "delete":
-        case "deleteMany":
-          topData = topData.where;
-          break;
-      }
-      yield this.doVisit(model, action, topData, void 0, void 0, []);
-    });
-  }
-  doVisit(model, action, data, parent, field, nestingPath) {
-    return __async(this, null, function* () {
-      if (!data) {
-        return;
-      }
-      const toplevel = field == void 0;
-      const context = { parent, field, nestingPath: [...nestingPath] };
-      const pushNewContext = (field2, model2, where, unique = false) => {
-        return __spreadProps(__spreadValues({}, context), { nestingPath: [...context.nestingPath, { field: field2, model: model2, where, unique }] });
-      };
-      switch (action) {
-        case "create":
-          for (const item of this.enumerateReverse(data)) {
-            const newContext = pushNewContext(field, model, {});
-            let callbackResult;
-            if (this.callback.create) {
-              callbackResult = yield this.callback.create(model, item, newContext);
-            }
-            if (callbackResult !== false) {
-              const subPayload = typeof callbackResult === "object" ? callbackResult : item;
-              yield this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
-            }
-          }
-          break;
-        case "createMany":
-        case "createManyAndReturn":
-          if (data) {
-            const newContext = pushNewContext(field, model, {});
-            let callbackResult;
-            if (this.callback.createMany) {
-              callbackResult = yield this.callback.createMany(model, data, newContext);
-            }
-            if (callbackResult !== false) {
-              const subPayload = typeof callbackResult === "object" ? callbackResult : data.data;
-              yield this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
-            }
-          }
-          break;
-        case "connectOrCreate":
-          for (const item of this.enumerateReverse(data)) {
-            const newContext = pushNewContext(field, model, item.where);
-            let callbackResult;
-            if (this.callback.connectOrCreate) {
-              callbackResult = yield this.callback.connectOrCreate(model, item, newContext);
-            }
-            if (callbackResult !== false) {
-              const subPayload = typeof callbackResult === "object" ? callbackResult : item.create;
-              yield this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
-            }
-          }
-          break;
-        case "connect":
-          if (this.callback.connect) {
-            for (const item of this.enumerateReverse(data)) {
-              const newContext = pushNewContext(field, model, item, true);
-              yield this.callback.connect(model, item, newContext);
-            }
-          }
-          break;
-        case "disconnect":
-          if (this.callback.disconnect) {
-            for (const item of this.enumerateReverse(data)) {
-              const newContext = pushNewContext(field, model, item, typeof item === "object");
-              yield this.callback.disconnect(model, item, newContext);
-            }
-          }
-          break;
-        case "set":
-          if (this.callback.set) {
-            for (const item of this.enumerateReverse(data)) {
-              const newContext = pushNewContext(field, model, item, true);
-              yield this.callback.set(model, item, newContext);
-            }
-          }
-          break;
-        case "update":
-          for (const item of this.enumerateReverse(data)) {
-            const newContext = pushNewContext(field, model, item.where);
-            let callbackResult;
-            if (this.callback.update) {
-              callbackResult = yield this.callback.update(model, item, newContext);
-            }
-            if (callbackResult !== false) {
-              const subPayload = typeof callbackResult === "object" ? callbackResult : typeof item.data === "object" ? item.data : item;
-              yield this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
-            }
-          }
-          break;
-        case "updateMany":
-        case "updateManyAndReturn":
-          for (const item of this.enumerateReverse(data)) {
-            const newContext = pushNewContext(field, model, item.where);
-            let callbackResult;
-            if (this.callback.updateMany) {
-              callbackResult = yield this.callback.updateMany(model, item, newContext);
-            }
-            if (callbackResult !== false) {
-              const subPayload = typeof callbackResult === "object" ? callbackResult : item;
-              yield this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
-            }
-          }
-          break;
-        case "upsert": {
-          for (const item of this.enumerateReverse(data)) {
-            const newContext = pushNewContext(field, model, item.where);
-            let callbackResult;
-            if (this.callback.upsert) {
-              callbackResult = yield this.callback.upsert(model, item, newContext);
-            }
-            if (callbackResult !== false) {
-              if (typeof callbackResult === "object") {
-                yield this.visitSubPayload(model, action, callbackResult, newContext.nestingPath);
-              } else {
-                yield this.visitSubPayload(model, action, item.create, newContext.nestingPath);
-                yield this.visitSubPayload(model, action, item.update, newContext.nestingPath);
-              }
-            }
-          }
-          break;
-        }
-        case "delete": {
-          if (this.callback.delete) {
-            for (const item of this.enumerateReverse(data)) {
-              const newContext = pushNewContext(field, model, toplevel ? item.where : item);
-              yield this.callback.delete(model, item, newContext);
-            }
-          }
-          break;
-        }
-        case "deleteMany":
-          if (this.callback.deleteMany) {
-            for (const item of this.enumerateReverse(data)) {
-              const newContext = pushNewContext(field, model, toplevel ? item.where : item);
-              yield this.callback.deleteMany(model, item, newContext);
-            }
-          }
-          break;
-        default: {
-          throw new Error(`unhandled action type ${action}`);
-        }
-      }
-    });
-  }
-  visitSubPayload(model, action, payload, nestingPath) {
-    return __async(this, null, function* () {
-      for (const item of enumerate(payload)) {
-        for (const field of getModelFields(item)) {
-          const fieldInfo = resolveField(this.modelMeta, model, field);
-          if (!fieldInfo) {
-            continue;
-          }
-          if (fieldInfo.isDataModel) {
-            if (item[field]) {
-              for (const [subAction, subData] of Object.entries(item[field])) {
-                if (this.isPrismaWriteAction(subAction) && subData) {
-                  yield this.doVisit(fieldInfo.type, subAction, subData, item[field], fieldInfo, [
-                    ...nestingPath
-                  ]);
-                }
-              }
-            }
-          } else {
-            if (this.callback.field) {
-              yield this.callback.field(fieldInfo, action, item[field], {
-                parent: item,
-                nestingPath,
-                field: fieldInfo
-              });
-            }
-          }
-        }
-      }
-    });
-  }
-  // enumerate a (possible) array in reverse order, so that the enumeration
-  // callback can safely delete the current item
-  *enumerateReverse(data) {
-    if (Array.isArray(data)) {
-      for (let i = data.length - 1; i >= 0; i--) {
-        yield data[i];
-      }
-    } else {
-      yield data;
-    }
-  }
-};
-
-// src/cross/query-analyzer.ts
-function getReadModels(model, modelMeta, args) {
-  const result = /* @__PURE__ */ new Set();
-  result.add(model);
-  const visitor = new NestedReadVisitor(modelMeta, {
-    field: (model2) => {
-      result.add(model2);
-      return true;
-    }
-  });
-  visitor.visit(model, args);
-  return [...result];
-}
-function getMutatedModels(model, operation, mutationArgs, modelMeta) {
-  return __async(this, null, function* () {
-    const result = /* @__PURE__ */ new Set();
-    result.add(model);
-    if (mutationArgs) {
-      const addModel = (model2) => void result.add(model2);
-      const addCascades = (model2) => {
-        const cascades = /* @__PURE__ */ new Set();
-        const visited = /* @__PURE__ */ new Set();
-        collectDeleteCascades(model2, modelMeta, cascades, visited);
-        cascades.forEach((m) => addModel(m));
-      };
-      const visitor = new NestedWriteVisitor(modelMeta, {
-        create: addModel,
-        createMany: addModel,
-        connectOrCreate: addModel,
-        connect: addModel,
-        disconnect: addModel,
-        set: addModel,
-        update: addModel,
-        updateMany: addModel,
-        upsert: addModel,
-        delete: (model2) => {
-          addModel(model2);
-          addCascades(model2);
-        },
-        deleteMany: (model2) => {
-          addModel(model2);
-          addCascades(model2);
-        }
-      });
-      yield visitor.visit(model, operation, mutationArgs);
-    }
-    result.forEach((m) => {
-      getBaseRecursively(m, modelMeta, result);
-    });
-    return [...result];
-  });
-}
-function collectDeleteCascades(model, modelMeta, result, visited) {
-  var _a;
-  if (visited.has(model)) {
-    return;
-  }
-  visited.add(model);
-  const cascades = (_a = modelMeta.deleteCascade) == null ? void 0 : _a[lowerCaseFirst(model)];
-  if (!cascades) {
-    return;
-  }
-  cascades.forEach((m) => {
-    result.add(m);
-    collectDeleteCascades(m, modelMeta, result, visited);
-  });
-}
-function getBaseRecursively(model, modelMeta, result) {
-  var _a;
-  const bases = (_a = getModelInfo(modelMeta, model)) == null ? void 0 : _a.baseTypes;
-  if (bases) {
-    bases.forEach((base) => {
-      result.add(base);
-      getBaseRecursively(base, modelMeta, result);
-    });
-  }
-}
-export {
-  ModelDataVisitor,
-  NestedReadVisitor,
-  NestedWriteVisitor,
-  PrismaWriteActions,
-  applyMutation,
-  clone,
-  enumerate,
-  getFields,
-  getIdFields,
-  getModelFields,
-  getModelInfo,
-  getMutatedModels,
-  getReadModels,
-  getTypeDefInfo,
-  getUniqueConstraints,
-  isDelegateModel,
-  requireField,
-  resolveField,
-  zip
-};
-//# sourceMappingURL=index.mjs.map