@zenstackhq/client-helpers 3.1.0

package/dist/index.js

@@ -0,0 +1,822 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/constants.ts
+var DEFAULT_QUERY_ENDPOINT = "/api/model";
+
+// src/logging.ts
+function log(logger, message) {
+  if (typeof logger === "function") {
+    logger(message);
+  } else if (logger) {
+    console.log(message);
+  }
+}
+__name(log, "log");
+
+// src/nested-read-visitor.ts
+var NestedReadVisitor = class {
+  static {
+    __name(this, "NestedReadVisitor");
+  }
+  schema;
+  callback;
+  constructor(schema, callback) {
+    this.schema = schema;
+    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 = this.schema.models[model]?.fields[k];
+          if (field2) {
+            this.doVisit(field2.type, field2, nextKind, v);
+          }
+        }
+      }
+    }
+  }
+  visit(model, args) {
+    this.doVisit(model, void 0, void 0, args);
+  }
+};
+
+// src/nested-write-visitor.ts
+import { enumerate } from "@zenstackhq/common-helpers";
+
+// src/types.ts
+var ORMWriteActions = [
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "connectOrCreate",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "connect",
+  "disconnect",
+  "set",
+  "delete",
+  "deleteMany"
+];
+
+// src/nested-write-visitor.ts
+var NestedWriteVisitor = class {
+  static {
+    __name(this, "NestedWriteVisitor");
+  }
+  schema;
+  callback;
+  constructor(schema, callback) {
+    this.schema = schema;
+    this.callback = callback;
+  }
+  isWriteAction(value) {
+    return ORMWriteActions.includes(value);
+  }
+  /**
+   * Start visiting
+   *
+   * @see NestedWriteVisitorCallback
+   */
+  async visit(model, action, args) {
+    if (!args) {
+      return;
+    }
+    let topData = args;
+    switch (action) {
+      // create has its data wrapped in 'data' field
+      case "create":
+        topData = topData.data;
+        break;
+      case "delete":
+      case "deleteMany":
+        topData = topData.where;
+        break;
+    }
+    await this.doVisit(model, action, topData, void 0, void 0, []);
+  }
+  async doVisit(model, action, data, parent, field, nestingPath) {
+    if (!data) {
+      return;
+    }
+    const toplevel = field == void 0;
+    const context = {
+      parent,
+      field,
+      nestingPath: [
+        ...nestingPath
+      ]
+    };
+    const pushNewContext = /* @__PURE__ */ __name((field2, model2, where, unique = false) => {
+      return {
+        ...context,
+        nestingPath: [
+          ...context.nestingPath,
+          {
+            field: field2,
+            model: model2,
+            where,
+            unique
+          }
+        ]
+      };
+    }, "pushNewContext");
+    switch (action) {
+      case "create":
+        for (const item of this.enumerateReverse(data)) {
+          const newContext = pushNewContext(field, model, {});
+          let callbackResult;
+          if (this.callback.create) {
+            callbackResult = await this.callback.create(model, item, newContext);
+          }
+          if (callbackResult !== false) {
+            const subPayload = typeof callbackResult === "object" ? callbackResult : item;
+            await this.visitSubPayload(model, action, subPayload, newContext.nestingPath);
+          }
+        }
+        break;
+      case "createMany":
+      case "createManyAndReturn":
+        {
+          const newContext = pushNewContext(field, model, {});
+          let callbackResult;
+          if (this.callback.createMany) {
+            callbackResult = await this.callback.createMany(model, data, newContext);
+          }
+          if (callbackResult !== false) {
+            const subPayload = typeof callbackResult === "object" ? callbackResult : data.data;
+            await 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 = await this.callback.connectOrCreate(model, item, newContext);
+          }
+          if (callbackResult !== false) {
+            const subPayload = typeof callbackResult === "object" ? callbackResult : item.create;
+            await 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);
+            await 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");
+            await 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);
+            await 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 = await this.callback.update(model, item, newContext);
+          }
+          if (callbackResult !== false) {
+            const subPayload = typeof callbackResult === "object" ? callbackResult : typeof item.data === "object" ? item.data : item;
+            await 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 = await this.callback.updateMany(model, item, newContext);
+          }
+          if (callbackResult !== false) {
+            const subPayload = typeof callbackResult === "object" ? callbackResult : item;
+            await 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 = await this.callback.upsert(model, item, newContext);
+          }
+          if (callbackResult !== false) {
+            if (typeof callbackResult === "object") {
+              await this.visitSubPayload(model, action, callbackResult, newContext.nestingPath);
+            } else {
+              await this.visitSubPayload(model, action, item.create, newContext.nestingPath);
+              await 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);
+            await 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);
+            await this.callback.deleteMany(model, item, newContext);
+          }
+        }
+        break;
+      default: {
+        throw new Error(`unhandled action type ${action}`);
+      }
+    }
+  }
+  async visitSubPayload(model, action, payload, nestingPath) {
+    for (const item of enumerate(payload)) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      for (const field of Object.keys(item)) {
+        const fieldDef = this.schema.models[model]?.fields[field];
+        if (!fieldDef) {
+          continue;
+        }
+        if (fieldDef.relation) {
+          if (item[field]) {
+            for (const [subAction, subData] of Object.entries(item[field])) {
+              if (this.isWriteAction(subAction) && subData) {
+                await this.doVisit(fieldDef.type, subAction, subData, item[field], fieldDef, [
+                  ...nestingPath
+                ]);
+              }
+            }
+          }
+        } else {
+          if (this.callback.field) {
+            await this.callback.field(fieldDef, action, item[field], {
+              parent: item,
+              nestingPath,
+              field: fieldDef
+            });
+          }
+        }
+      }
+    }
+  }
+  // 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/query-analysis.ts
+function getReadModels(model, schema, args) {
+  const result = /* @__PURE__ */ new Set();
+  result.add(model);
+  const visitor = new NestedReadVisitor(schema, {
+    field: /* @__PURE__ */ __name((model2) => {
+      result.add(model2);
+      return true;
+    }, "field")
+  });
+  visitor.visit(model, args);
+  return [
+    ...result
+  ];
+}
+__name(getReadModels, "getReadModels");
+async function getMutatedModels(model, operation, mutationArgs, schema) {
+  const result = /* @__PURE__ */ new Set();
+  result.add(model);
+  if (mutationArgs) {
+    const addModel = /* @__PURE__ */ __name((model2) => void result.add(model2), "addModel");
+    const addCascades = /* @__PURE__ */ __name((model2) => {
+      const cascades = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new Set();
+      collectDeleteCascades(model2, schema, cascades, visited);
+      cascades.forEach((m) => addModel(m));
+    }, "addCascades");
+    const visitor = new NestedWriteVisitor(schema, {
+      create: addModel,
+      createMany: addModel,
+      connectOrCreate: addModel,
+      connect: addModel,
+      disconnect: addModel,
+      set: addModel,
+      update: addModel,
+      updateMany: addModel,
+      upsert: addModel,
+      delete: /* @__PURE__ */ __name((model2) => {
+        addModel(model2);
+        addCascades(model2);
+      }, "delete"),
+      deleteMany: /* @__PURE__ */ __name((model2) => {
+        addModel(model2);
+        addCascades(model2);
+      }, "deleteMany")
+    });
+    await visitor.visit(model, operation, mutationArgs);
+  }
+  result.forEach((m) => {
+    getBaseRecursively(m, schema, result);
+  });
+  return [
+    ...result
+  ];
+}
+__name(getMutatedModels, "getMutatedModels");
+function collectDeleteCascades(model, schema, result, visited) {
+  if (visited.has(model)) {
+    return;
+  }
+  visited.add(model);
+  const modelDef = schema.models[model];
+  if (!modelDef) {
+    return;
+  }
+  for (const [modelName, modelDef2] of Object.entries(schema.models)) {
+    if (!modelDef2) {
+      continue;
+    }
+    for (const fieldDef of Object.values(modelDef2.fields)) {
+      if (fieldDef.relation?.onDelete === "Cascade" && fieldDef.type === model) {
+        if (!result.has(modelName)) {
+          result.add(modelName);
+        }
+        collectDeleteCascades(modelName, schema, result, visited);
+      }
+    }
+  }
+}
+__name(collectDeleteCascades, "collectDeleteCascades");
+function getBaseRecursively(model, schema, result) {
+  const modelDef = schema.models[model];
+  if (!modelDef) {
+    return;
+  }
+  if (modelDef.baseModel) {
+    result.add(modelDef.baseModel);
+    getBaseRecursively(modelDef.baseModel, schema, result);
+  }
+}
+__name(getBaseRecursively, "getBaseRecursively");
+
+// src/invalidation.ts
+function createInvalidator(model, operation, schema, invalidator, logging) {
+  return async (...args) => {
+    const [_, variables] = args;
+    const predicate = await getInvalidationPredicate(model, operation, variables, schema, logging);
+    await invalidator(predicate);
+  };
+}
+__name(createInvalidator, "createInvalidator");
+async function getInvalidationPredicate(model, operation, mutationArgs, schema, logging) {
+  const mutatedModels = await getMutatedModels(model, operation, mutationArgs, schema);
+  return ({ model: model2, args }) => {
+    if (mutatedModels.includes(model2)) {
+      if (logging) {
+        log(logging, `Marking "${model2}" query for invalidation due to mutation "${operation}", query args: ${JSON.stringify(args)}`);
+      }
+      return true;
+    }
+    if (args) {
+      if (findNestedRead(model2, mutatedModels, schema, args)) {
+        if (logging) {
+          log(logging, `Marking "${model2}" query for invalidation due to mutation "${operation}", query args: ${JSON.stringify(args)}`);
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+}
+__name(getInvalidationPredicate, "getInvalidationPredicate");
+function findNestedRead(visitingModel, targetModels, schema, args) {
+  const modelsRead = getReadModels(visitingModel, schema, args);
+  return targetModels.some((m) => modelsRead.includes(m));
+}
+__name(findNestedRead, "findNestedRead");
+
+// src/mutator.ts
+import { clone, enumerate as enumerate2, invariant, zip } from "@zenstackhq/common-helpers";
+async function applyMutation(queryModel, queryOp, queryData, mutationModel, mutationOp, mutationArgs, schema, logging) {
+  if (!queryData || typeof queryData !== "object" && !Array.isArray(queryData)) {
+    return void 0;
+  }
+  if (!queryOp.startsWith("find")) {
+    return void 0;
+  }
+  return await doApplyMutation(queryModel, queryData, mutationModel, mutationOp, mutationArgs, schema, logging);
+}
+__name(applyMutation, "applyMutation");
+async function doApplyMutation(queryModel, queryData, mutationModel, mutationOp, mutationArgs, schema, logging) {
+  let resultData = queryData;
+  let updated = false;
+  const visitor = new NestedWriteVisitor(schema, {
+    create: /* @__PURE__ */ __name((model, args) => {
+      if (model === queryModel && Array.isArray(resultData)) {
+        const r = createMutate(queryModel, resultData, args, schema, logging);
+        if (r) {
+          resultData = r;
+          updated = true;
+        }
+      }
+    }, "create"),
+    createMany: /* @__PURE__ */ __name((model, args) => {
+      if (model === queryModel && args?.data && Array.isArray(resultData)) {
+        for (const oneArg of enumerate2(args.data)) {
+          const r = createMutate(queryModel, resultData, oneArg, schema, logging);
+          if (r) {
+            resultData = r;
+            updated = true;
+          }
+        }
+      }
+    }, "createMany"),
+    update: /* @__PURE__ */ __name((model, args) => {
+      if (model === queryModel && !Array.isArray(resultData)) {
+        const r = updateMutate(queryModel, resultData, model, args, schema, logging);
+        if (r) {
+          resultData = r;
+          updated = true;
+        }
+      }
+    }, "update"),
+    upsert: /* @__PURE__ */ __name((model, args) => {
+      if (model === queryModel && args?.where && args?.create && args?.update) {
+        const r = upsertMutate(queryModel, resultData, model, args, schema, logging);
+        if (r) {
+          resultData = r;
+          updated = true;
+        }
+      }
+    }, "upsert"),
+    delete: /* @__PURE__ */ __name((model, args) => {
+      if (model === queryModel) {
+        const r = deleteMutate(queryModel, resultData, model, args, schema, logging);
+        if (r) {
+          resultData = r;
+          updated = true;
+        }
+      }
+    }, "delete")
+  });
+  await visitor.visit(mutationModel, mutationOp, mutationArgs);
+  const modelFields = schema.models[queryModel]?.fields;
+  invariant(modelFields, `Model ${queryModel} not found in schema`);
+  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 = await doApplyMutation(queryModel, item, mutationModel, mutationOp, mutationArgs, schema, 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 = {
+      ...resultData
+    };
+    for (const [key, value] of Object.entries(currentData)) {
+      const fieldDef = modelFields[key];
+      if (!fieldDef?.relation) {
+        continue;
+      }
+      const r = await doApplyMutation(fieldDef.type, value, mutationModel, mutationOp, mutationArgs, schema, logging);
+      if (r && typeof r === "object") {
+        resultData = {
+          ...resultData,
+          [key]: r
+        };
+        updated = true;
+      }
+    }
+  }
+  return updated ? resultData : void 0;
+}
+__name(doApplyMutation, "doApplyMutation");
+function createMutate(queryModel, currentData, newData, schema, logging) {
+  if (!newData) {
+    return void 0;
+  }
+  const modelFields = schema.models[queryModel]?.fields;
+  if (!modelFields) {
+    return void 0;
+  }
+  const insert = {};
+  const newDataFields = Object.keys(newData);
+  Object.entries(modelFields).forEach(([name, field]) => {
+    if (field.relation && newData[name]) {
+      assignForeignKeyFields(field, insert, newData[name]);
+      return;
+    }
+    if (newDataFields.includes(name)) {
+      insert[name] = clone(newData[name]);
+    } else {
+      const defaultAttr = field.attributes?.find((attr) => attr.name === "@default");
+      if (field.type === "DateTime") {
+        if (defaultAttr || field.attributes?.some((attr) => attr.name === "@updatedAt")) {
+          insert[name] = /* @__PURE__ */ new Date();
+          return;
+        }
+      }
+      const defaultArg = defaultAttr?.args?.[0]?.value;
+      if (defaultArg?.kind === "literal") {
+        insert[name] = defaultArg.value;
+      }
+    }
+  });
+  const idFields = getIdFields(schema, queryModel);
+  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] = crypto.randomUUID();
+      }
+    }
+  });
+  insert.$optimistic = true;
+  if (logging) {
+    log(logging, `Applying optimistic create for ${queryModel}: ${JSON.stringify(insert)}`);
+  }
+  return [
+    insert,
+    ...Array.isArray(currentData) ? currentData : []
+  ];
+}
+__name(createMutate, "createMutate");
+function updateMutate(queryModel, currentData, mutateModel, mutateArgs, schema, logging) {
+  if (!currentData || typeof currentData !== "object") {
+    return void 0;
+  }
+  if (!mutateArgs?.where || typeof mutateArgs.where !== "object") {
+    return void 0;
+  }
+  if (!mutateArgs?.data || typeof mutateArgs.data !== "object") {
+    return void 0;
+  }
+  if (!idFieldsMatch(mutateModel, currentData, mutateArgs.where, schema)) {
+    return void 0;
+  }
+  const modelFields = schema.models[queryModel]?.fields;
+  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.relation && !value?.connect) {
+      continue;
+    }
+    if (!updated) {
+      resultData = {
+        ...currentData
+      };
+    }
+    if (fieldInfo.relation) {
+      assignForeignKeyFields(fieldInfo, resultData, value);
+    } else {
+      resultData[key] = clone(value);
+    }
+    resultData.$optimistic = true;
+    updated = true;
+    if (logging) {
+      log(logging, `Applying optimistic update for ${queryModel}: ${JSON.stringify(resultData)}`);
+    }
+  }
+  return updated ? resultData : void 0;
+}
+__name(updateMutate, "updateMutate");
+function upsertMutate(queryModel, currentData, model, args, schema, logging) {
+  let updated = false;
+  let resultData = currentData;
+  if (Array.isArray(resultData)) {
+    const foundIndex = resultData.findIndex((x) => idFieldsMatch(model, x, args.where, schema));
+    if (foundIndex >= 0) {
+      const updateResult = updateMutate(queryModel, resultData[foundIndex], model, {
+        where: args.where,
+        data: args.update
+      }, schema, logging);
+      if (updateResult) {
+        resultData = [
+          ...resultData.slice(0, foundIndex),
+          updateResult,
+          ...resultData.slice(foundIndex + 1)
+        ];
+        updated = true;
+      }
+    } else {
+      const createResult = createMutate(queryModel, resultData, args.create, schema, logging);
+      if (createResult) {
+        resultData = createResult;
+        updated = true;
+      }
+    }
+  } else {
+    const updateResult = updateMutate(queryModel, resultData, model, {
+      where: args.where,
+      data: args.update
+    }, schema, logging);
+    if (updateResult) {
+      resultData = updateResult;
+      updated = true;
+    }
+  }
+  return updated ? resultData : void 0;
+}
+__name(upsertMutate, "upsertMutate");
+function deleteMutate(queryModel, currentData, mutateModel, mutateArgs, schema, 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, schema)) {
+        result = result.filter((x) => x !== item);
+        updated = true;
+        if (logging) {
+          log(logging, `Applying optimistic delete for ${queryModel}: ${JSON.stringify(item)}`);
+        }
+      }
+    }
+  } else {
+    if (idFieldsMatch(mutateModel, currentData, mutateArgs, schema)) {
+      result = null;
+      updated = true;
+      if (logging) {
+        log(logging, `Applying optimistic delete for ${queryModel}: ${JSON.stringify(currentData)}`);
+      }
+    }
+  }
+  return updated ? result : void 0;
+}
+__name(deleteMutate, "deleteMutate");
+function idFieldsMatch(model, x, y, schema) {
+  if (!x || !y || typeof x !== "object" || typeof y !== "object") {
+    return false;
+  }
+  const idFields = getIdFields(schema, model);
+  if (idFields.length === 0) {
+    return false;
+  }
+  return idFields.every((f) => x[f.name] === y[f.name]);
+}
+__name(idFieldsMatch, "idFieldsMatch");
+function assignForeignKeyFields(field, resultData, mutationData) {
+  if (!mutationData?.connect) {
+    return;
+  }
+  if (!field.relation?.fields || !field.relation.references) {
+    return;
+  }
+  for (const [idField, fkField] of zip(field.relation.references, field.relation.fields)) {
+    if (idField in mutationData.connect) {
+      resultData[fkField] = mutationData.connect[idField];
+    }
+  }
+}
+__name(assignForeignKeyFields, "assignForeignKeyFields");
+function getIdFields(schema, model) {
+  return (schema.models[model]?.idFields ?? []).map((f) => schema.models[model].fields[f]);
+}
+__name(getIdFields, "getIdFields");
+
+// src/optimistic.ts
+function createOptimisticUpdater(model, operation, schema, options, getAllQueries, logging) {
+  return async (...args) => {
+    const [mutationArgs] = args;
+    for (const queryInfo of getAllQueries()) {
+      const logInfo = JSON.stringify({
+        model: queryInfo.model,
+        operation: queryInfo.operation,
+        args: queryInfo.args
+      });
+      if (!queryInfo.optimisticUpdate) {
+        if (logging) {
+          log(logging, `Skipping optimistic update for ${logInfo} due to opt-out`);
+        }
+        continue;
+      }
+      if (options.optimisticDataProvider) {
+        const providerResult = await options.optimisticDataProvider({
+          queryModel: queryInfo.model,
+          queryOperation: queryInfo.operation,
+          queryArgs: queryInfo.args,
+          currentData: queryInfo.data,
+          mutationArgs
+        });
+        if (providerResult?.kind === "Skip") {
+          if (logging) {
+            log(logging, `Skipping optimistic updating due to provider result: ${logInfo}`);
+          }
+          continue;
+        } else if (providerResult?.kind === "Update") {
+          if (logging) {
+            log(logging, `Optimistically updating due to provider result: ${logInfo}`);
+          }
+          queryInfo.updateData(providerResult.data, true);
+          continue;
+        }
+      }
+      const mutatedData = await applyMutation(queryInfo.model, queryInfo.operation, queryInfo.data, model, operation, mutationArgs, schema, logging);
+      if (mutatedData !== void 0) {
+        if (logging) {
+          log(logging, `Optimistically updating due to mutation "${model}.${operation}": ${logInfo}`);
+        }
+        queryInfo.updateData(mutatedData, true);
+      }
+    }
+  };
+}
+__name(createOptimisticUpdater, "createOptimisticUpdater");
+export {
+  DEFAULT_QUERY_ENDPOINT,
+  NestedReadVisitor,
+  NestedWriteVisitor,
+  ORMWriteActions,
+  applyMutation,
+  createInvalidator,
+  createOptimisticUpdater,
+  getMutatedModels,
+  getReadModels,
+  log
+};
+//# sourceMappingURL=index.js.map