@zenstackhq/tanstack-query 3.0.0-beta.17 → 3.0.0-beta.19

package/dist/vue.js

@@ -0,0 +1,1152 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/vue.ts
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/vue-query";
+import { lowerCaseFirst as lowerCaseFirst2 } from "@zenstackhq/common-helpers";
+import { inject, provide, toValue } from "vue";
+
+// src/utils/common.ts
+import { lowerCaseFirst } from "@zenstackhq/common-helpers";
+
+// src/utils/mutator.ts
+import { clone, enumerate as enumerate2, invariant, zip } from "@zenstackhq/common-helpers";
+
+// src/utils/nested-write-visitor.ts
+import { enumerate } from "@zenstackhq/common-helpers";
+
+// src/utils/types.ts
+var ORMWriteActions = [
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "connectOrCreate",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "connect",
+  "disconnect",
+  "set",
+  "delete",
+  "deleteMany"
+];
+
+// src/utils/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 NestedWriterVisitorCallback
+   */
+  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/utils/mutator.ts
+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) {
+    console.log(`Optimistic create for ${queryModel}:`, 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) {
+      console.log(`Optimistic update for ${queryModel}:`, 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) {
+          console.log(`Optimistic delete for ${queryModel}:`, item);
+        }
+      }
+    }
+  } else {
+    if (idFieldsMatch(mutateModel, currentData, mutateArgs, schema)) {
+      result = null;
+      updated = true;
+      if (logging) {
+        console.log(`Optimistic delete for ${queryModel}:`, 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/utils/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/utils/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/utils/serialization.ts
+import { Buffer as Buffer2 } from "buffer";
+import Decimal from "decimal.js";
+import SuperJSON from "superjson";
+SuperJSON.registerCustom({
+  isApplicable: /* @__PURE__ */ __name((v) => v instanceof Decimal || // interop with decimal.js
+  v?.toStringTag === "[object Decimal]", "isApplicable"),
+  serialize: /* @__PURE__ */ __name((v) => v.toJSON(), "serialize"),
+  deserialize: /* @__PURE__ */ __name((v) => new Decimal(v), "deserialize")
+}, "Decimal");
+SuperJSON.registerCustom({
+  isApplicable: /* @__PURE__ */ __name((v) => Buffer2.isBuffer(v), "isApplicable"),
+  serialize: /* @__PURE__ */ __name((v) => v.toString("base64"), "serialize"),
+  deserialize: /* @__PURE__ */ __name((v) => Buffer2.from(v, "base64"), "deserialize")
+}, "Bytes");
+function serialize(value) {
+  const { json, meta } = SuperJSON.serialize(value);
+  return {
+    data: json,
+    meta
+  };
+}
+__name(serialize, "serialize");
+function deserialize(value, meta) {
+  return SuperJSON.deserialize({
+    json: value,
+    meta
+  });
+}
+__name(deserialize, "deserialize");
+
+// src/utils/common.ts
+var DEFAULT_QUERY_ENDPOINT = "/api/model";
+var QUERY_KEY_PREFIX = "zenstack";
+async function fetcher(url, options, customFetch) {
+  const _fetch = customFetch ?? fetch;
+  const res = await _fetch(url, options);
+  if (!res.ok) {
+    const errData = unmarshal(await res.text());
+    if (errData.error?.rejectedByPolicy && errData.error?.rejectReason === "cannot-read-back") {
+      return void 0;
+    }
+    const error = new Error("An error occurred while fetching the data.");
+    error.info = errData.error;
+    error.status = res.status;
+    throw error;
+  }
+  const textResult = await res.text();
+  try {
+    return unmarshal(textResult).data;
+  } catch (err) {
+    console.error(`Unable to deserialize data:`, textResult);
+    throw err;
+  }
+}
+__name(fetcher, "fetcher");
+function getQueryKey(model, operation, args, options = {
+  infinite: false,
+  optimisticUpdate: true
+}) {
+  const infinite = options.infinite;
+  const optimisticUpdate2 = options.infinite ? false : options.optimisticUpdate;
+  return [
+    QUERY_KEY_PREFIX,
+    model,
+    operation,
+    args,
+    {
+      infinite,
+      optimisticUpdate: optimisticUpdate2
+    }
+  ];
+}
+__name(getQueryKey, "getQueryKey");
+function marshal(value) {
+  const { data, meta } = serialize(value);
+  if (meta) {
+    return JSON.stringify({
+      ...data,
+      meta: {
+        serialization: meta
+      }
+    });
+  } else {
+    return JSON.stringify(data);
+  }
+}
+__name(marshal, "marshal");
+function unmarshal(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed === "object" && parsed?.data && parsed?.meta?.serialization) {
+    const deserializedData = deserialize(parsed.data, parsed.meta.serialization);
+    return {
+      ...parsed,
+      data: deserializedData
+    };
+  } else {
+    return parsed;
+  }
+}
+__name(unmarshal, "unmarshal");
+function makeUrl(endpoint, model, operation, args) {
+  const baseUrl = `${endpoint}/${lowerCaseFirst(model)}/${operation}`;
+  if (!args) {
+    return baseUrl;
+  }
+  const { data, meta } = serialize(args);
+  let result = `${baseUrl}?q=${encodeURIComponent(JSON.stringify(data))}`;
+  if (meta) {
+    result += `&meta=${encodeURIComponent(JSON.stringify({
+      serialization: meta
+    }))}`;
+  }
+  return result;
+}
+__name(makeUrl, "makeUrl");
+function setupInvalidation(model, operation, schema, options, invalidate, logging = false) {
+  const origOnSuccess = options?.onSuccess;
+  options.onSuccess = async (...args) => {
+    const [_, variables] = args;
+    const predicate = await getInvalidationPredicate(model, operation, variables, schema, logging);
+    await invalidate(predicate);
+    return origOnSuccess?.(...args);
+  };
+}
+__name(setupInvalidation, "setupInvalidation");
+async function getInvalidationPredicate(model, operation, mutationArgs, schema, logging = false) {
+  const mutatedModels = await getMutatedModels(model, operation, mutationArgs, schema);
+  return ({ queryKey }) => {
+    const [_, queryModel, , args] = queryKey;
+    if (mutatedModels.includes(queryModel)) {
+      if (logging) {
+        console.log(`Invalidating query ${JSON.stringify(queryKey)} due to mutation "${model}.${operation}"`);
+      }
+      return true;
+    }
+    if (args) {
+      if (findNestedRead(queryModel, mutatedModels, schema, args)) {
+        if (logging) {
+          console.log(`Invalidating query ${JSON.stringify(queryKey)} due to mutation "${model}.${operation}"`);
+        }
+        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");
+function setupOptimisticUpdate(model, operation, schema, options, queryCache, setCache, invalidate, logging = false) {
+  const origOnMutate = options?.onMutate;
+  const origOnSettled = options?.onSettled;
+  options.onMutate = async (...args) => {
+    const [variables] = args;
+    await optimisticUpdate(model, operation, variables, options, schema, queryCache, setCache, logging);
+    return origOnMutate?.(...args);
+  };
+  options.onSettled = async (...args) => {
+    if (invalidate) {
+      const [, , variables] = args;
+      const predicate = await getInvalidationPredicate(model, operation, variables, schema, logging);
+      await invalidate(predicate);
+    }
+    return origOnSettled?.(...args);
+  };
+}
+__name(setupOptimisticUpdate, "setupOptimisticUpdate");
+async function optimisticUpdate(mutationModel, mutationOp, mutationArgs, options, schema, queryCache, setCache, logging = false) {
+  for (const cacheItem of queryCache) {
+    const { queryKey, state: { data, error } } = cacheItem;
+    if (!isZenStackQueryKey(queryKey)) {
+      continue;
+    }
+    if (error) {
+      if (logging) {
+        console.warn(`Skipping optimistic update for ${JSON.stringify(queryKey)} due to error:`, error);
+      }
+      continue;
+    }
+    const [_, queryModel, queryOperation, queryArgs, queryOptions] = queryKey;
+    if (!queryOptions?.optimisticUpdate) {
+      if (logging) {
+        console.log(`Skipping optimistic update for ${JSON.stringify(queryKey)} due to opt-out`);
+      }
+      continue;
+    }
+    if (options.optimisticDataProvider) {
+      const providerResult = await options.optimisticDataProvider({
+        queryModel,
+        queryOperation,
+        queryArgs,
+        currentData: data,
+        mutationArgs
+      });
+      if (providerResult?.kind === "Skip") {
+        if (logging) {
+          console.log(`Skipping optimistic update for ${JSON.stringify(queryKey)} due to provider`);
+        }
+        continue;
+      } else if (providerResult?.kind === "Update") {
+        if (logging) {
+          console.log(`Optimistically updating query ${JSON.stringify(queryKey)} due to provider`);
+        }
+        setCache(queryKey, providerResult.data);
+        continue;
+      }
+    }
+    const mutatedData = await applyMutation(queryModel, queryOperation, data, mutationModel, mutationOp, mutationArgs, schema, logging);
+    if (mutatedData !== void 0) {
+      if (logging) {
+        console.log(`Optimistically updating query ${JSON.stringify(queryKey)} due to mutation "${mutationModel}.${mutationOp}"`);
+      }
+      setCache(queryKey, mutatedData);
+    }
+  }
+}
+__name(optimisticUpdate, "optimisticUpdate");
+function isZenStackQueryKey(queryKey) {
+  if (queryKey.length < 5) {
+    return false;
+  }
+  if (queryKey[0] !== QUERY_KEY_PREFIX) {
+    return false;
+  }
+  return true;
+}
+__name(isZenStackQueryKey, "isZenStackQueryKey");
+
+// src/vue.ts
+var VueQueryContextKey = "zenstack-vue-query-context";
+function provideHooksContext(context) {
+  provide(VueQueryContextKey, context);
+}
+__name(provideHooksContext, "provideHooksContext");
+function provideQuerySettingsContext(context) {
+  provide(VueQueryContextKey, context);
+}
+__name(provideQuerySettingsContext, "provideQuerySettingsContext");
+function getQuerySettings() {
+  const { endpoint, ...rest } = inject(VueQueryContextKey, {
+    endpoint: DEFAULT_QUERY_ENDPOINT,
+    fetch: void 0,
+    logging: false
+  });
+  return {
+    endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT,
+    ...rest
+  };
+}
+__name(getQuerySettings, "getQuerySettings");
+function useClientQueries(schema) {
+  return Object.keys(schema.models).reduce((acc, model) => {
+    acc[lowerCaseFirst2(model)] = useModelQueries(schema, model);
+    return acc;
+  }, {});
+}
+__name(useClientQueries, "useClientQueries");
+function useModelQueries(schema, model) {
+  const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
+  if (!modelDef) {
+    throw new Error(`Model "${model}" not found in schema`);
+  }
+  const modelName = modelDef.name;
+  return {
+    useFindUnique: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "findUnique", args, options);
+    }, "useFindUnique"),
+    useFindFirst: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "findFirst", args, options);
+    }, "useFindFirst"),
+    useFindMany: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "findMany", args, options);
+    }, "useFindMany"),
+    useInfiniteFindMany: /* @__PURE__ */ __name((args, options) => {
+      return useInternalInfiniteQuery(schema, modelName, "findMany", args, options);
+    }, "useInfiniteFindMany"),
+    useCreate: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "POST", "create", options);
+    }, "useCreate"),
+    useCreateMany: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "POST", "createMany", options);
+    }, "useCreateMany"),
+    useCreateManyAndReturn: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "POST", "createManyAndReturn", options);
+    }, "useCreateManyAndReturn"),
+    useUpdate: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "PUT", "update", options);
+    }, "useUpdate"),
+    useUpdateMany: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "PUT", "updateMany", options);
+    }, "useUpdateMany"),
+    useUpdateManyAndReturn: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "PUT", "updateManyAndReturn", options);
+    }, "useUpdateManyAndReturn"),
+    useUpsert: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "POST", "upsert", options);
+    }, "useUpsert"),
+    useDelete: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "DELETE", "delete", options);
+    }, "useDelete"),
+    useDeleteMany: /* @__PURE__ */ __name((options) => {
+      return useInternalMutation(schema, modelName, "DELETE", "deleteMany", options);
+    }, "useDeleteMany"),
+    useCount: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "count", args, options);
+    }, "useCount"),
+    useAggregate: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "aggregate", args, options);
+    }, "useAggregate"),
+    useGroupBy: /* @__PURE__ */ __name((args, options) => {
+      return useInternalQuery(schema, modelName, "groupBy", args, options);
+    }, "useGroupBy")
+  };
+}
+__name(useModelQueries, "useModelQueries");
+function useInternalQuery(_schema, model, operation, args, options) {
+  const argsValue = toValue(args);
+  const { optimisticUpdate: optimisticUpdate2, ...restOptions } = toValue(options) ?? {};
+  const queryKey = getQueryKey(model, operation, argsValue, {
+    infinite: false,
+    optimisticUpdate: optimisticUpdate2 !== false
+  });
+  const { endpoint, fetch: fetch2 } = getQuerySettings();
+  const finalOptions = {
+    queryKey,
+    queryFn: /* @__PURE__ */ __name(({ queryKey: queryKey2, signal }) => {
+      const [_prefix, _model, _op, args2] = queryKey2;
+      const reqUrl = makeUrl(endpoint, model, operation, args2);
+      return fetcher(reqUrl, {
+        signal
+      }, fetch2);
+    }, "queryFn"),
+    ...restOptions
+  };
+  return {
+    queryKey,
+    ...useQuery(finalOptions)
+  };
+}
+__name(useInternalQuery, "useInternalQuery");
+function useInternalInfiniteQuery(_schema, model, operation, args, options) {
+  options = options ?? {
+    getNextPageParam: /* @__PURE__ */ __name(() => void 0, "getNextPageParam")
+  };
+  const { endpoint, fetch: fetch2 } = getQuerySettings();
+  const argsValue = toValue(args);
+  const optionsValue = toValue(options);
+  const queryKey = getQueryKey(model, operation, argsValue, {
+    infinite: true,
+    optimisticUpdate: false
+  });
+  const finalOptions = {
+    queryKey,
+    queryFn: /* @__PURE__ */ __name(({ queryKey: queryKey2, signal }) => {
+      const [_prefix, _model, _op, args2] = queryKey2;
+      const reqUrl = makeUrl(endpoint, model, operation, args2);
+      return fetcher(reqUrl, {
+        signal
+      }, fetch2);
+    }, "queryFn"),
+    initialPageParam: argsValue,
+    ...optionsValue
+  };
+  return {
+    queryKey,
+    ...useInfiniteQuery(finalOptions)
+  };
+}
+__name(useInternalInfiniteQuery, "useInternalInfiniteQuery");
+function useInternalMutation(schema, model, method, operation, options) {
+  const { endpoint, fetch: fetch2, logging } = getQuerySettings();
+  const queryClient = useQueryClient();
+  const mutationFn = /* @__PURE__ */ __name((data) => {
+    const reqUrl = method === "DELETE" ? makeUrl(endpoint, model, operation, data) : makeUrl(endpoint, model, operation);
+    const fetchInit = {
+      method,
+      ...method !== "DELETE" && {
+        headers: {
+          "content-type": "application/json"
+        },
+        body: marshal(data)
+      }
+    };
+    return fetcher(reqUrl, fetchInit, fetch2);
+  }, "mutationFn");
+  const optionsValue = toValue(options);
+  const finalOptions = {
+    ...optionsValue,
+    mutationFn
+  };
+  const invalidateQueries = optionsValue?.invalidateQueries !== false;
+  const optimisticUpdate2 = !!optionsValue?.optimisticUpdate;
+  if (operation) {
+    if (invalidateQueries) {
+      setupInvalidation(model, operation, schema, finalOptions, (predicate) => queryClient.invalidateQueries({
+        predicate
+      }), logging);
+    }
+    if (optimisticUpdate2) {
+      setupOptimisticUpdate(model, operation, schema, finalOptions, queryClient.getQueryCache().getAll(), (queryKey, data) => {
+        queryClient.setQueryData(queryKey, data);
+        queryClient.cancelQueries({
+          queryKey
+        }, {
+          revert: false,
+          silent: true
+        });
+      }, invalidateQueries ? (predicate) => queryClient.invalidateQueries({
+        predicate
+      }) : void 0, logging);
+    }
+  }
+  return useMutation(finalOptions);
+}
+__name(useInternalMutation, "useInternalMutation");
+export {
+  VueQueryContextKey,
+  provideHooksContext,
+  provideQuerySettingsContext,
+  useClientQueries,
+  useInternalInfiniteQuery,
+  useInternalMutation,
+  useInternalQuery,
+  useModelQueries
+};
+//# sourceMappingURL=vue.js.map