@zenstackhq/tanstack-query 3.0.0 → 3.1.1

package/dist/vue.js

@@ -1,1152 +1,238 @@
-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
-      ]
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient, } from '@tanstack/vue-query';
+import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, } from '@zenstackhq/client-helpers';
+import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
+import { lowerCaseFirst } from '@zenstackhq/common-helpers';
+import { computed, inject, provide, toValue, unref } from 'vue';
+import { getAllQueries, invalidateQueriesMatchingPredicate } from './common/client';
+import { getQueryKey } from './common/query-key';
+export const VueQueryContextKey = 'zenstack-vue-query-context';
+/**
+ * Provide context for query settings.
+ *
+ * @deprecated Use {@link provideQuerySettingsContext} instead.
+ */
+export function provideHooksContext(context) {
+    provide(VueQueryContextKey, context);
+}
+/**
+ * Provide context for query settings.
+ */
+export function provideQuerySettingsContext(context) {
+    provide(VueQueryContextKey, context);
+}
+function useQuerySettings() {
+    const { endpoint, ...rest } = inject(VueQueryContextKey, {
+        endpoint: DEFAULT_QUERY_ENDPOINT,
+        fetch: undefined,
+        logging: false,
+    });
+    return { endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT, ...rest };
+}
+/**
+ * Gets data query hooks for all models in the schema.
+ */
+export function useClientQueries(schema, options) {
+    return Object.keys(schema.models).reduce((acc, model) => {
+        acc[lowerCaseFirst(model)] = useModelQueries(schema, model, options);
+        return acc;
+    }, {});
+}
+/**
+ * Gets data query hooks for a specific model in the schema.
+ */
+export function useModelQueries(schema, model, rootOptions) {
+    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;
+    const merge = (rootOpt, opt) => {
+        return computed(() => {
+            return { ...toValue(rootOpt), ...toValue(opt) };
+        });
     };
-    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
+    return {
+        useFindUnique: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findUnique', args, merge(rootOptions, options));
+        },
+        useFindFirst: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findFirst', args, merge(rootOptions, options));
+        },
+        useFindMany: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findMany', args, merge(rootOptions, options));
+        },
+        useInfiniteFindMany: (args, options) => {
+            return useInternalInfiniteQuery(schema, modelName, 'findMany', args, merge(rootOptions, options));
+        },
+        useCreate: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'create', merge(rootOptions, options));
+        },
+        useCreateMany: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', merge(rootOptions, options));
+        },
+        useCreateManyAndReturn: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', merge(rootOptions, options));
+        },
+        useUpdate: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'update', merge(rootOptions, options));
+        },
+        useUpdateMany: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', merge(rootOptions, options));
+        },
+        useUpdateManyAndReturn: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', merge(rootOptions, options));
+        },
+        useUpsert: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', merge(rootOptions, options));
+        },
+        useDelete: (options) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', merge(rootOptions, options));
+        },
+        useDeleteMany: (options) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', merge(rootOptions, options));
+        },
+        useCount: (args, options) => {
+            return useInternalQuery(schema, modelName, 'count', args, merge(rootOptions, options));
+        },
+        useAggregate: (args, options) => {
+            return useInternalQuery(schema, modelName, 'aggregate', args, merge(rootOptions, options));
+        },
+        useGroupBy: (args, options) => {
+            return useInternalQuery(schema, modelName, 'groupBy', args, merge(rootOptions, options));
+        },
     };
-    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")
+export function useInternalQuery(_schema, model, operation, args, options) {
+    // reactive query key
+    const queryKey = computed(() => {
+        const argsValue = toValue(args);
+        const { optimisticUpdate } = toValue(options) ?? {};
+        return getQueryKey(model, operation, argsValue, {
+            infinite: false,
+            optimisticUpdate: optimisticUpdate !== false,
+        });
     });
-    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
-      }
+    const { endpoint, fetch } = useFetchOptions(options);
+    // reactive query options
+    const finalOptions = computed(() => {
+        const { optimisticUpdate: _, ...restOptions } = toValue(options) ?? {};
+        return {
+            queryKey: queryKey.value,
+            queryFn: ({ signal }) => {
+                const reqUrl = makeUrl(endpoint, model, operation, toValue(args));
+                return fetcher(reqUrl, { signal }, fetch);
+            },
+            ...restOptions,
+        };
+    });
+    return { queryKey, ...useQuery(finalOptions) };
+}
+export function useInternalInfiniteQuery(_schema, model, operation, args, options) {
+    options = options ?? { getNextPageParam: () => undefined };
+    // reactive query key
+    const queryKey = computed(() => {
+        const argsValue = toValue(args);
+        return getQueryKey(model, operation, argsValue, { infinite: true, optimisticUpdate: false });
+    });
+    const { endpoint, fetch } = useFetchOptions(options);
+    // reactive query options
+    const finalOptions = computed(() => {
+        const argsValue = toValue(args);
+        return {
+            queryKey: queryKey.value,
+            queryFn: ({ signal }) => {
+                const reqUrl = makeUrl(endpoint, model, operation, argsValue);
+                return fetcher(reqUrl, { signal }, fetch);
+            },
+            initialPageParam: toValue(argsValue),
+            ...toValue(options),
+        };
     });
-  } 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
+        queryKey,
+        ...useInfiniteQuery(finalOptions),
     };
-  } 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`);
+/**
+ * Creates a vue-query mutation
+ *
+ * @private
+ *
+ * @param model The name of the model under mutation.
+ * @param method The HTTP method.
+ * @param operation The mutation operation (e.g. `create`).
+ * @param options The vue-query options.
+ * @param checkReadBack Whether to check for read back errors and return undefined if found.
+ */
+export function useInternalMutation(schema, model, method, operation, options) {
+    const queryClient = useQueryClient();
+    const { endpoint, fetch, logging } = useFetchOptions(options);
+    const mutationFn = (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, fetch);
+    };
+    // reactive mutation options
+    const finalOptions = computed(() => {
+        const optionsValue = toValue(options);
+        const result = {
+            ...optionsValue,
+            mutationFn,
+        };
+        const invalidateQueries = optionsValue?.invalidateQueries !== false;
+        const optimisticUpdate = !!optionsValue?.optimisticUpdate;
+        if (!optimisticUpdate) {
+            if (invalidateQueries) {
+                const invalidator = createInvalidator(model, operation, schema, (predicate) => invalidateQueriesMatchingPredicate(queryClient, predicate), logging);
+                // execute invalidator prior to user-provided onSuccess
+                result.onSuccess = async (...args) => {
+                    await invalidator(...args);
+                    const origOnSuccess = toValue(optionsValue?.onSuccess);
+                    await origOnSuccess?.(...args);
+                };
+            }
         }
-        continue;
-      } else if (providerResult?.kind === "Update") {
-        if (logging) {
-          console.log(`Optimistically updating query ${JSON.stringify(queryKey)} due to provider`);
+        else {
+            const optimisticUpdater = createOptimisticUpdater(model, operation, schema, { optimisticDataProvider: result.optimisticDataProvider }, () => getAllQueries(queryClient), logging);
+            // optimistic update on mutate
+            const origOnMutate = result.onMutate;
+            result.onMutate = async (...args) => {
+                // execute optimistic updater prior to user-provided onMutate
+                await optimisticUpdater(...args);
+                // call user-provided onMutate
+                return unref(origOnMutate)?.(...args);
+            };
+            if (invalidateQueries) {
+                const invalidator = createInvalidator(model, operation, schema, (predicate) => invalidateQueriesMatchingPredicate(queryClient, predicate), logging);
+                const origOnSettled = result.onSettled;
+                result.onSettled = async (...args) => {
+                    // execute invalidator prior to user-provided onSettled
+                    await invalidator(...args);
+                    // call user-provided onSettled
+                    return unref(origOnSettled)?.(...args);
+                };
+            }
         }
-        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)
-  };
+        return result;
+    });
+    return useMutation(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)
-      }
+function useFetchOptions(options) {
+    const { endpoint, fetch, logging } = useQuerySettings();
+    const optionsValue = toValue(options);
+    // options take precedence over context
+    return {
+        endpoint: optionsValue?.endpoint ?? endpoint,
+        fetch: optionsValue?.fetch ?? fetch,
+        logging: optionsValue?.logging ?? logging,
     };
-    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