@zenstackhq/tanstack-query 3.0.0 → 3.1.0

package/dist/react.js

@@ -1,1197 +1,267 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/react.ts
-import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
-import { lowerCaseFirst as lowerCaseFirst2 } from "@zenstackhq/common-helpers";
-import { createContext, useContext } from "react";
-
-// 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
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseInfiniteQuery, useSuspenseQuery, } from '@tanstack/react-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 { createContext, useContext } from 'react';
+import { getAllQueries, invalidateQueriesMatchingPredicate } from './common/client';
+import { getQueryKey } from './common/query-key';
+/**
+ * React context for query settings.
+ */
+export const QuerySettingsContext = createContext({
+    endpoint: DEFAULT_QUERY_ENDPOINT,
+    fetch: undefined,
+});
+/**
+ * React context provider for configuring query settings.
+ */
+export const QuerySettingsProvider = QuerySettingsContext.Provider;
+/**
+ * React context provider for configuring query settings.
+ *
+ * @deprecated Use {@link QuerySettingsProvider} instead.
+ */
+export const Provider = QuerySettingsProvider;
+function useHooksContext() {
+    const { endpoint, ...rest } = useContext(QuerySettingsContext);
+    return { endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT, ...rest };
+}
+/**
+ * Gets data query hooks for all models in the schema.
+ *
+ * @param schema The schema.
+ * @param options Options for all queries originated from this hook.
+ */
+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;
+    return {
+        useFindUnique: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findUnique', args, { ...rootOptions, ...options });
+        },
+        useSuspenseFindUnique: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'findUnique', args, { ...rootOptions, ...options });
+        },
+        useFindFirst: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findFirst', args, { ...rootOptions, ...options });
+        },
+        useSuspenseFindFirst: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'findFirst', args, { ...rootOptions, ...options });
+        },
+        useFindMany: (args, options) => {
+            return useInternalQuery(schema, modelName, 'findMany', args, { ...rootOptions, ...options });
+        },
+        useSuspenseFindMany: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'findMany', args, { ...rootOptions, ...options });
+        },
+        useInfiniteFindMany: (args, options) => {
+            return useInternalInfiniteQuery(schema, modelName, 'findMany', args, { ...rootOptions, ...options });
+        },
+        useSuspenseInfiniteFindMany: (args, options) => {
+            return useInternalSuspenseInfiniteQuery(schema, modelName, 'findMany', args, {
+                ...rootOptions,
+                ...options,
             });
-          }
-        }
-      }
-    }
-  }
-  // 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
+        },
+        useCreate: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'create', { ...rootOptions, ...options });
+        },
+        useCreateMany: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', { ...rootOptions, ...options });
+        },
+        useCreateManyAndReturn: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', {
+                ...rootOptions,
+                ...options,
+            });
+        },
+        useUpdate: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'update', { ...rootOptions, ...options });
+        },
+        useUpdateMany: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', { ...rootOptions, ...options });
+        },
+        useUpdateManyAndReturn: (options) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', { ...rootOptions, ...options });
+        },
+        useUpsert: (options) => {
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', { ...rootOptions, ...options });
+        },
+        useDelete: (options) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', { ...rootOptions, ...options });
+        },
+        useDeleteMany: (options) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', { ...rootOptions, ...options });
+        },
+        useCount: (args, options) => {
+            return useInternalQuery(schema, modelName, 'count', args, { ...rootOptions, ...options });
+        },
+        useSuspenseCount: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'count', args, { ...rootOptions, ...options });
+        },
+        useAggregate: (args, options) => {
+            return useInternalQuery(schema, modelName, 'aggregate', args, { ...rootOptions, ...options });
+        },
+        useSuspenseAggregate: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'aggregate', args, { ...rootOptions, ...options });
+        },
+        useGroupBy: (args, options) => {
+            return useInternalQuery(schema, modelName, 'groupBy', args, { ...rootOptions, ...options });
+        },
+        useSuspenseGroupBy: (args, options) => {
+            return useInternalSuspenseQuery(schema, modelName, 'groupBy', args, { ...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) {
+    const { endpoint, fetch } = useFetchOptions(options);
+    const reqUrl = makeUrl(endpoint, model, operation, args);
+    const queryKey = getQueryKey(model, operation, args, {
+        infinite: false,
+        optimisticUpdate: options?.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 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
-    }
-  ];
+    return {
+        queryKey,
+        ...useQuery({
+            queryKey,
+            queryFn: ({ signal }) => fetcher(reqUrl, { signal }, fetch),
+            ...options,
+        }),
+    };
 }
-__name(getQueryKey, "getQueryKey");
-function marshal(value) {
-  const { data, meta } = serialize(value);
-  if (meta) {
-    return JSON.stringify({
-      ...data,
-      meta: {
-        serialization: meta
-      }
+export function useInternalSuspenseQuery(_schema, model, operation, args, options) {
+    const { endpoint, fetch } = useFetchOptions(options);
+    const reqUrl = makeUrl(endpoint, model, operation, args);
+    const queryKey = getQueryKey(model, operation, args, {
+        infinite: false,
+        optimisticUpdate: options?.optimisticUpdate !== false,
     });
-  } 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,
+        ...useSuspenseQuery({
+            queryKey,
+            queryFn: ({ signal }) => fetcher(reqUrl, { signal }, fetch),
+            ...options,
+        }),
     };
-  } 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;
+export function useInternalInfiniteQuery(_schema, model, operation, args, options) {
+    options = options ?? { getNextPageParam: () => undefined };
+    const { endpoint, fetch } = useFetchOptions(options);
+    const queryKey = getQueryKey(model, operation, args, { infinite: true, optimisticUpdate: false });
+    return {
+        queryKey,
+        ...useInfiniteQuery({
+            queryKey,
+            queryFn: ({ pageParam, signal }) => {
+                return fetcher(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
+            },
+            initialPageParam: args,
+            ...options,
+        }),
+    };
 }
-__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);
-  };
+export function useInternalSuspenseInfiniteQuery(_schema, model, operation, args, options) {
+    const { endpoint, fetch } = useFetchOptions(options);
+    const queryKey = getQueryKey(model, operation, args, { infinite: true, optimisticUpdate: false });
+    return {
+        queryKey,
+        ...useSuspenseInfiniteQuery({
+            queryKey,
+            queryFn: ({ pageParam, signal }) => {
+                return fetcher(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
+            },
+            initialPageParam: args,
+            ...options,
+        }),
+    };
 }
-__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}"`);
+/**
+ * Creates a react-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 react-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 { endpoint, fetch, logging } = useFetchOptions(options);
+    const queryClient = useQueryClient();
+    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);
+    };
+    const finalOptions = { ...options, mutationFn };
+    const invalidateQueries = options?.invalidateQueries !== false;
+    const optimisticUpdate = !!options?.optimisticUpdate;
+    if (!optimisticUpdate) {
+        // if optimistic update is not enabled, invalidate related queries on success
+        if (invalidateQueries) {
+            const invalidator = createInvalidator(model, operation, schema, (predicate) => invalidateQueriesMatchingPredicate(queryClient, predicate), logging);
+            const origOnSuccess = finalOptions.onSuccess;
+            finalOptions.onSuccess = async (...args) => {
+                // execute invalidator prior to user-provided onSuccess
+                await invalidator(...args);
+                // call user-provided onSuccess
+                await origOnSuccess?.(...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");
-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`);
+    else {
+        // schedule optimistic update on mutate
+        const optimisticUpdater = createOptimisticUpdater(model, operation, schema, { optimisticDataProvider: finalOptions.optimisticDataProvider }, () => getAllQueries(queryClient), logging);
+        const origOnMutate = finalOptions.onMutate;
+        finalOptions.onMutate = async (...args) => {
+            // execute optimistic update
+            await optimisticUpdater(...args);
+            // call user-provided onMutate
+            return origOnMutate?.(...args);
+        };
+        if (invalidateQueries) {
+            // invalidate related queries on settled (success or error)
+            const invalidator = createInvalidator(model, operation, schema, (predicate) => invalidateQueriesMatchingPredicate(queryClient, predicate), logging);
+            const origOnSettled = finalOptions.onSettled;
+            finalOptions.onSettled = async (...args) => {
+                // execute invalidator prior to user-provided onSettled
+                await invalidator(...args);
+                // call user-provided onSettled
+                return 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/react.ts
-var DEFAULT_QUERY_ENDPOINT = "/api/model";
-var QuerySettingsContext = createContext({
-  endpoint: DEFAULT_QUERY_ENDPOINT,
-  fetch: void 0
-});
-var QuerySettingsProvider = QuerySettingsContext.Provider;
-var Provider = QuerySettingsProvider;
-function useHooksContext() {
-  const { endpoint, ...rest } = useContext(QuerySettingsContext);
-  return {
-    endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT,
-    ...rest
-  };
-}
-__name(useHooksContext, "useHooksContext");
-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"),
-    useSuspenseFindUnique: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "findUnique", args, options);
-    }, "useSuspenseFindUnique"),
-    useFindFirst: /* @__PURE__ */ __name((args, options) => {
-      return useInternalQuery(schema, modelName, "findFirst", args, options);
-    }, "useFindFirst"),
-    useSuspenseFindFirst: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "findFirst", args, options);
-    }, "useSuspenseFindFirst"),
-    useFindMany: /* @__PURE__ */ __name((args, options) => {
-      return useInternalQuery(schema, modelName, "findMany", args, options);
-    }, "useFindMany"),
-    useSuspenseFindMany: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "findMany", args, options);
-    }, "useSuspenseFindMany"),
-    useInfiniteFindMany: /* @__PURE__ */ __name((args, options) => {
-      return useInternalInfiniteQuery(schema, modelName, "findMany", args, options);
-    }, "useInfiniteFindMany"),
-    useSuspenseInfiniteFindMany: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseInfiniteQuery(schema, modelName, "findMany", args, options);
-    }, "useSuspenseInfiniteFindMany"),
-    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"),
-    useSuspenseCount: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "count", args, options);
-    }, "useSuspenseCount"),
-    useAggregate: /* @__PURE__ */ __name((args, options) => {
-      return useInternalQuery(schema, modelName, "aggregate", args, options);
-    }, "useAggregate"),
-    useSuspenseAggregate: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "aggregate", args, options);
-    }, "useSuspenseAggregate"),
-    useGroupBy: /* @__PURE__ */ __name((args, options) => {
-      return useInternalQuery(schema, modelName, "groupBy", args, options);
-    }, "useGroupBy"),
-    useSuspenseGroupBy: /* @__PURE__ */ __name((args, options) => {
-      return useInternalSuspenseQuery(schema, modelName, "groupBy", args, options);
-    }, "useSuspenseGroupBy")
-  };
+    return useMutation(finalOptions);
 }
-__name(useModelQueries, "useModelQueries");
-function useInternalQuery(_schema, model, operation, args, options) {
-  const { endpoint, fetch: fetch2 } = useHooksContext();
-  const reqUrl = makeUrl(endpoint, model, operation, args);
-  const queryKey = getQueryKey(model, operation, args, {
-    infinite: false,
-    optimisticUpdate: options?.optimisticUpdate !== false
-  });
-  return {
-    queryKey,
-    ...useQuery({
-      queryKey,
-      queryFn: /* @__PURE__ */ __name(({ signal }) => fetcher(reqUrl, {
-        signal
-      }, fetch2), "queryFn"),
-      ...options
-    })
-  };
-}
-__name(useInternalQuery, "useInternalQuery");
-function useInternalSuspenseQuery(_schema, model, operation, args, options) {
-  const { endpoint, fetch: fetch2 } = useHooksContext();
-  const reqUrl = makeUrl(endpoint, model, operation, args);
-  const queryKey = getQueryKey(model, operation, args, {
-    infinite: false,
-    optimisticUpdate: options?.optimisticUpdate !== false
-  });
-  return {
-    queryKey,
-    ...useSuspenseQuery({
-      queryKey,
-      queryFn: /* @__PURE__ */ __name(({ signal }) => fetcher(reqUrl, {
-        signal
-      }, fetch2), "queryFn"),
-      ...options
-    })
-  };
-}
-__name(useInternalSuspenseQuery, "useInternalSuspenseQuery");
-function useInternalInfiniteQuery(_schema, model, operation, args, options) {
-  options = options ?? {
-    getNextPageParam: /* @__PURE__ */ __name(() => void 0, "getNextPageParam")
-  };
-  const { endpoint, fetch: fetch2 } = useHooksContext();
-  const queryKey = getQueryKey(model, operation, args, {
-    infinite: true,
-    optimisticUpdate: false
-  });
-  return {
-    queryKey,
-    ...useInfiniteQuery({
-      queryKey,
-      queryFn: /* @__PURE__ */ __name(({ pageParam, signal }) => {
-        return fetcher(makeUrl(endpoint, model, operation, pageParam ?? args), {
-          signal
-        }, fetch2);
-      }, "queryFn"),
-      initialPageParam: args,
-      ...options
-    })
-  };
-}
-__name(useInternalInfiniteQuery, "useInternalInfiniteQuery");
-function useInternalSuspenseInfiniteQuery(_schema, model, operation, args, options) {
-  const { endpoint, fetch: fetch2 } = useHooksContext();
-  const queryKey = getQueryKey(model, operation, args, {
-    infinite: true,
-    optimisticUpdate: false
-  });
-  return {
-    queryKey,
-    ...useSuspenseInfiniteQuery({
-      queryKey,
-      queryFn: /* @__PURE__ */ __name(({ pageParam, signal }) => {
-        return fetcher(makeUrl(endpoint, model, operation, pageParam ?? args), {
-          signal
-        }, fetch2);
-      }, "queryFn"),
-      initialPageParam: args,
-      ...options
-    })
-  };
-}
-__name(useInternalSuspenseInfiniteQuery, "useInternalSuspenseInfiniteQuery");
-function useInternalMutation(schema, model, method, operation, options) {
-  const { endpoint, fetch: fetch2, logging } = useHooksContext();
-  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 } = useHooksContext();
+    // options take precedence over context
+    return {
+        endpoint: options?.endpoint ?? endpoint,
+        fetch: options?.fetch ?? fetch,
+        logging: options?.logging ?? logging,
     };
-    return fetcher(reqUrl, fetchInit, fetch2);
-  }, "mutationFn");
-  const finalOptions = {
-    ...options,
-    mutationFn
-  };
-  const invalidateQueries = options?.invalidateQueries !== false;
-  const optimisticUpdate2 = !!options?.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 {
-  DEFAULT_QUERY_ENDPOINT,
-  Provider,
-  QuerySettingsContext,
-  QuerySettingsProvider,
-  useClientQueries,
-  useInternalInfiniteQuery,
-  useInternalMutation,
-  useInternalQuery,
-  useInternalSuspenseInfiniteQuery,
-  useInternalSuspenseQuery,
-  useModelQueries
-};
 //# sourceMappingURL=react.js.map