@zenstackhq/client-helpers 3.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,24 @@
+
+> @zenstackhq/client-helpers@3.1.0 build /home/runner/work/zenstack-v3/zenstack-v3/packages/clients/client-helpers
+> tsc --noEmit && tsup-node && pnpm test:typecheck
+
+CLI Building entry: {"index":"src/index.ts","fetch":"src/fetch.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.0
+CLI Using tsup config: /home/runner/work/zenstack-v3/zenstack-v3/packages/clients/client-helpers/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js     25.68 KB
+ESM dist/fetch.js     2.73 KB
+ESM dist/index.js.map 63.32 KB
+ESM dist/fetch.js.map 5.94 KB
+ESM ⚡️ Build success in 136ms
+DTS Build start
+DTS ⚡️ Build success in 5075ms
+DTS dist/index.d.ts 10.28 KB
+DTS dist/fetch.d.ts 1.24 KB
+
+> @zenstackhq/client-helpers@3.1.0 test:typecheck /home/runner/work/zenstack-v3/zenstack-v3/packages/clients/client-helpers
+> tsc --noEmit --project tsconfig.test.json
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZenStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/fetch.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Function signature for `fetch`.
+ */
+type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;
+/**
+ * A fetcher function that uses fetch API to make HTTP requests and automatically unmarshals
+ * the response using superjson.
+ */
+declare function fetcher<R>(url: string, options?: RequestInit, customFetch?: FetchFn): Promise<R>;
+/**
+ * Makes a URL for the given endpoint, model, operation, and args that matches the RPC-style server API.
+ */
+declare function makeUrl(endpoint: string, model: string, operation: string, args?: unknown): string;
+/**
+ * Serialize the given value with superjson
+ */
+declare function serialize(value: unknown): {
+    data: unknown;
+    meta: unknown;
+};
+/**
+ * Deserialize the given value with superjson using the given metadata
+ */
+declare function deserialize(value: unknown, meta: any): unknown;
+/**
+ * Marshal the given value to a string using superjson
+ */
+declare function marshal(value: unknown): string;
+/**
+ * Unmarshal the given string value using superjson, assuming the value is a JSON stringified
+ * object containing the serialized data and serialization metadata.
+ */
+declare function unmarshal(value: string): any;
+
+export { type FetchFn, deserialize, fetcher, makeUrl, marshal, serialize, unmarshal };

package/dist/fetch.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/fetch.ts
+import { lowerCaseFirst } from "@zenstackhq/common-helpers";
+import Decimal from "decimal.js";
+import SuperJSON from "superjson";
+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 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");
+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");
+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");
+function marshal(value) {
+  const { data, meta } = serialize(value);
+  if (meta) {
+    return JSON.stringify({
+      ...data,
+      meta: {
+        serialization: meta
+      }
+    });
+  } else {
+    return JSON.stringify(data);
+  }
+}
+__name(marshal, "marshal");
+function unmarshal(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed === "object" && parsed?.data && parsed?.meta?.serialization) {
+    const deserializedData = deserialize(parsed.data, parsed.meta.serialization);
+    return {
+      ...parsed,
+      data: deserializedData
+    };
+  } else {
+    return parsed;
+  }
+}
+__name(unmarshal, "unmarshal");
+export {
+  deserialize,
+  fetcher,
+  makeUrl,
+  marshal,
+  serialize,
+  unmarshal
+};
+//# sourceMappingURL=fetch.js.map

package/dist/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fetch.ts"],"sourcesContent":["import { lowerCaseFirst } from '@zenstackhq/common-helpers';\nimport Decimal from 'decimal.js';\nimport SuperJSON from 'superjson';\nimport type { QueryError } from './types';\n\n/**\n * Function signature for `fetch`.\n */\nexport type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;\n\n/**\n * A fetcher function that uses fetch API to make HTTP requests and automatically unmarshals\n * the response using superjson.\n */\nexport async function fetcher<R>(url: string, options?: RequestInit, customFetch?: FetchFn): Promise<R> {\n    const _fetch = customFetch ?? fetch;\n    const res = await _fetch(url, options);\n    if (!res.ok) {\n        const errData = unmarshal(await res.text());\n        if (errData.error?.rejectedByPolicy && errData.error?.rejectReason === 'cannot-read-back') {\n            // policy doesn't allow mutation result to be read back, just return undefined\n            return undefined as any;\n        }\n        const error: QueryError = new Error('An error occurred while fetching the data.');\n        error.info = errData.error;\n        error.status = res.status;\n        throw error;\n    }\n\n    const textResult = await res.text();\n    try {\n        return unmarshal(textResult).data as R;\n    } catch (err) {\n        console.error(`Unable to deserialize data:`, textResult);\n        throw err;\n    }\n}\n\n/**\n * Makes a URL for the given endpoint, model, operation, and args that matches the RPC-style server API.\n */\nexport function makeUrl(endpoint: string, model: string, operation: string, args?: unknown) {\n    const baseUrl = `${endpoint}/${lowerCaseFirst(model)}/${operation}`;\n    if (!args) {\n        return baseUrl;\n    }\n\n    const { data, meta } = serialize(args);\n    let result = `${baseUrl}?q=${encodeURIComponent(JSON.stringify(data))}`;\n    if (meta) {\n        result += `&meta=${encodeURIComponent(JSON.stringify({ serialization: meta }))}`;\n    }\n    return result;\n}\n\nSuperJSON.registerCustom<Decimal, string>(\n    {\n        isApplicable: (v): v is Decimal =>\n            v instanceof Decimal ||\n            // interop with decimal.js\n            v?.toStringTag === '[object Decimal]',\n        serialize: (v) => v.toJSON(),\n        deserialize: (v) => new Decimal(v),\n    },\n    'Decimal',\n);\n\n/**\n * Serialize the given value with superjson\n */\nexport function serialize(value: unknown): { data: unknown; meta: unknown } {\n    const { json, meta } = SuperJSON.serialize(value);\n    return { data: json, meta };\n}\n\n/**\n * Deserialize the given value with superjson using the given metadata\n */\nexport function deserialize(value: unknown, meta: any): unknown {\n    return SuperJSON.deserialize({ json: value as any, meta });\n}\n\n/**\n * Marshal the given value to a string using superjson\n */\nexport function marshal(value: unknown) {\n    const { data, meta } = serialize(value);\n    if (meta) {\n        return JSON.stringify({ ...(data as any), meta: { serialization: meta } });\n    } else {\n        return JSON.stringify(data);\n    }\n}\n\n/**\n * Unmarshal the given string value using superjson, assuming the value is a JSON stringified\n * object containing the serialized data and serialization metadata.\n */\nexport function unmarshal(value: string) {\n    const parsed = JSON.parse(value);\n    if (typeof parsed === 'object' && parsed?.data && parsed?.meta?.serialization) {\n        const deserializedData = deserialize(parsed.data, parsed.meta.serialization);\n        return { ...parsed, data: deserializedData };\n    } else {\n        return parsed;\n    }\n}\n"],"mappings":";;;;AAAA,SAASA,sBAAsB;AAC/B,OAAOC,aAAa;AACpB,OAAOC,eAAe;AAYtB,eAAsBC,QAAWC,KAAaC,SAAuBC,aAAqB;AACtF,QAAMC,SAASD,eAAeE;AAC9B,QAAMC,MAAM,MAAMF,OAAOH,KAAKC,OAAAA;AAC9B,MAAI,CAACI,IAAIC,IAAI;AACT,UAAMC,UAAUC,UAAU,MAAMH,IAAII,KAAI,CAAA;AACxC,QAAIF,QAAQG,OAAOC,oBAAoBJ,QAAQG,OAAOE,iBAAiB,oBAAoB;AAEvF,aAAOC;IACX;AACA,UAAMH,QAAoB,IAAII,MAAM,4CAAA;AACpCJ,UAAMK,OAAOR,QAAQG;AACrBA,UAAMM,SAASX,IAAIW;AACnB,UAAMN;EACV;AAEA,QAAMO,aAAa,MAAMZ,IAAII,KAAI;AACjC,MAAI;AACA,WAAOD,UAAUS,UAAAA,EAAYC;EACjC,SAASC,KAAK;AACVC,YAAQV,MAAM,+BAA+BO,UAAAA;AAC7C,UAAME;EACV;AACJ;AAtBsBpB;AA2Bf,SAASsB,QAAQC,UAAkBC,OAAeC,WAAmBC,MAAc;AACtF,QAAMC,UAAU,GAAGJ,QAAAA,IAAYK,eAAeJ,KAAAA,CAAAA,IAAUC,SAAAA;AACxD,MAAI,CAACC,MAAM;AACP,WAAOC;EACX;AAEA,QAAM,EAAER,MAAMU,KAAI,IAAKC,UAAUJ,IAAAA;AACjC,MAAIK,SAAS,GAAGJ,OAAAA,MAAaK,mBAAmBC,KAAKC,UAAUf,IAAAA,CAAAA,CAAAA;AAC/D,MAAIU,MAAM;AACNE,cAAU,SAASC,mBAAmBC,KAAKC,UAAU;MAAEC,eAAeN;IAAK,CAAA,CAAA,CAAA;EAC/E;AACA,SAAOE;AACX;AAZgBT;AAchBc,UAAUC,eACN;EACIC,cAAc,wBAACC,MACXA,aAAaC;EAEbD,GAAGE,gBAAgB,oBAHT;EAIdX,WAAW,wBAACS,MAAMA,EAAEG,OAAM,GAAf;EACXC,aAAa,wBAACJ,MAAM,IAAIC,QAAQD,CAAAA,GAAnB;AACjB,GACA,SAAA;AAMG,SAAST,UAAUc,OAAc;AACpC,QAAM,EAAEC,MAAMhB,KAAI,IAAKO,UAAUN,UAAUc,KAAAA;AAC3C,SAAO;IAAEzB,MAAM0B;IAAMhB;EAAK;AAC9B;AAHgBC;AAQT,SAASa,YAAYC,OAAgBf,MAAS;AACjD,SAAOO,UAAUO,YAAY;IAAEE,MAAMD;IAAcf;EAAK,CAAA;AAC5D;AAFgBc;AAOT,SAASG,QAAQF,OAAc;AAClC,QAAM,EAAEzB,MAAMU,KAAI,IAAKC,UAAUc,KAAAA;AACjC,MAAIf,MAAM;AACN,WAAOI,KAAKC,UAAU;MAAE,GAAIf;MAAcU,MAAM;QAAEM,eAAeN;MAAK;IAAE,CAAA;EAC5E,OAAO;AACH,WAAOI,KAAKC,UAAUf,IAAAA;EAC1B;AACJ;AAPgB2B;AAaT,SAASrC,UAAUmC,OAAa;AACnC,QAAMG,SAASd,KAAKe,MAAMJ,KAAAA;AAC1B,MAAI,OAAOG,WAAW,YAAYA,QAAQ5B,QAAQ4B,QAAQlB,MAAMM,eAAe;AAC3E,UAAMc,mBAAmBN,YAAYI,OAAO5B,MAAM4B,OAAOlB,KAAKM,aAAa;AAC3E,WAAO;MAAE,GAAGY;MAAQ5B,MAAM8B;IAAiB;EAC/C,OAAO;AACH,WAAOF;EACX;AACJ;AARgBtC;","names":["lowerCaseFirst","Decimal","SuperJSON","fetcher","url","options","customFetch","_fetch","fetch","res","ok","errData","unmarshal","text","error","rejectedByPolicy","rejectReason","undefined","Error","info","status","textResult","data","err","console","makeUrl","endpoint","model","operation","args","baseUrl","lowerCaseFirst","meta","serialize","result","encodeURIComponent","JSON","stringify","serialization","SuperJSON","registerCustom","isApplicable","v","Decimal","toStringTag","toJSON","deserialize","value","json","marshal","parsed","parse","deserializedData"]}

package/dist/index.d.ts

@@ -0,0 +1,278 @@
+import { SchemaDef, FieldDef } from '@zenstackhq/schema';
+
+/**
+ * The default query endpoint.
+ */
+declare const DEFAULT_QUERY_ENDPOINT = "/api/model";
+
+/**
+ * Logger configuration. `true` enables console logging. A function can be provided for custom logging.
+ */
+type Logger = boolean | ((message: string) => void);
+/**
+ * Logs a message using the provided logger.
+ */
+declare function log(logger: Logger, message: string): void;
+
+/**
+ * A type that represents either a value of type T or a Promise that resolves to type T.
+ */
+type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
+/**
+ * List of ORM write actions.
+ */
+declare const ORMWriteActions: readonly ["create", "createMany", "createManyAndReturn", "connectOrCreate", "update", "updateMany", "updateManyAndReturn", "upsert", "connect", "disconnect", "set", "delete", "deleteMany"];
+/**
+ * Type representing ORM write action types.
+ */
+type ORMWriteActionType = (typeof ORMWriteActions)[number];
+/**
+ * Type for query and mutation errors.
+ */
+type QueryError = Error & {
+    /**
+     * Additional error information.
+     */
+    info?: unknown;
+    /**
+     * HTTP status code.
+     */
+    status?: number;
+};
+/**
+ * Information about a cached query.
+ */
+type QueryInfo = {
+    /**
+     * Model of the query.
+     */
+    model: string;
+    /**
+     * Query operation, e.g., `findUnique`
+     */
+    operation: string;
+    /**
+     * Query arguments.
+     */
+    args: unknown;
+    /**
+     * Current data cached for this query.
+     */
+    data: unknown;
+    /**
+     * Whether optimistic update is enabled for this query.
+     */
+    optimisticUpdate: boolean;
+    /**
+     * Function to update the cached data.
+     *
+     * @param data New data to set.
+     * @param cancelOnTheFlyQueries Whether to cancel on-the-fly queries to avoid accidentally
+     * overwriting the optimistic update.
+     */
+    updateData: (data: unknown, cancelOnTheFlyQueries: boolean) => void;
+};
+
+/**
+ * Type for a predicate that determines whether a query should be invalidated.
+ */
+type InvalidationPredicate = ({ model, args }: {
+    model: string;
+    args: unknown;
+}) => boolean;
+/**
+ * Type for a function that invalidates queries matching the given predicate.
+ */
+type InvalidateFunc = (predicate: InvalidationPredicate) => MaybePromise<void>;
+/**
+ * Create a function that invalidates queries affected by the given mutation operation.
+ *
+ * @param model Model under mutation.
+ * @param operation Mutation operation (e.g, `update`).
+ * @param schema The schema.
+ * @param invalidator Function to invalidate queries matching a predicate. It should internally
+ * enumerate all query cache entries and invalidate those for which the predicate returns true.
+ * @param logging Logging option.
+ */
+declare function createInvalidator(model: string, operation: string, schema: SchemaDef, invalidator: InvalidateFunc, logging: Logger | undefined): (...args: unknown[]) => Promise<void>;
+
+/**
+ * Tries to apply a mutation to a query result.
+ *
+ * @param queryModel the model of the query
+ * @param queryOp the operation of the query
+ * @param queryData the result data of the query
+ * @param mutationModel the model of the mutation
+ * @param mutationOp the operation of the mutation
+ * @param mutationArgs the arguments of the mutation
+ * @param schema the schema
+ * @param logging logging configuration
+ * @returns the updated query data if the mutation is applicable, otherwise undefined
+ */
+declare function applyMutation(queryModel: string, queryOp: string, queryData: any, mutationModel: string, mutationOp: ORMWriteActionType, mutationArgs: any, schema: SchemaDef, logging: Logger | undefined): Promise<any>;
+
+/**
+ * Callback functions for nested read visitor.
+ */
+type NestedReadVisitorCallback = {
+    /**
+     * Callback for each field visited.
+     * @returns If returns false, traversal will not continue into this field.
+     */
+    field?: (model: string, field: FieldDef | undefined, kind: 'include' | 'select' | undefined, args: unknown) => void | boolean;
+};
+/**
+ * Visitor for nested read payload.
+ */
+declare class NestedReadVisitor {
+    private readonly schema;
+    private readonly callback;
+    constructor(schema: SchemaDef, callback: NestedReadVisitorCallback);
+    private doVisit;
+    visit(model: string, args: unknown): void;
+}
+
+type NestingPathItem = {
+    field?: FieldDef;
+    model: string;
+    where: any;
+    unique: boolean;
+};
+/**
+ * Context for visiting
+ */
+type NestedWriteVisitorContext = {
+    /**
+     * Parent data, can be used to replace fields
+     */
+    parent: any;
+    /**
+     * Current field, undefined if toplevel
+     */
+    field?: FieldDef;
+    /**
+     * A top-down path of all nested update conditions and corresponding field till now
+     */
+    nestingPath: NestingPathItem[];
+};
+/**
+ * NestedWriteVisitor's callback actions. A call back function should return true or void to indicate
+ * that the visitor should continue traversing its children, or false to stop. It can also return an object
+ * to let the visitor traverse it instead of its original children.
+ */
+type NestedWriteVisitorCallback = {
+    create?: (model: string, data: any, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    createMany?: (model: string, args: {
+        data: any;
+        skipDuplicates?: boolean;
+    }, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    connectOrCreate?: (model: string, args: {
+        where: object;
+        create: any;
+    }, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    connect?: (model: string, args: object, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    disconnect?: (model: string, args: object, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    set?: (model: string, args: object, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    update?: (model: string, args: object, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    updateMany?: (model: string, args: {
+        where?: object;
+        data: any;
+    }, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    upsert?: (model: string, args: {
+        where: object;
+        create: any;
+        update: any;
+    }, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    delete?: (model: string, args: object | boolean, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    deleteMany?: (model: string, args: any | object, context: NestedWriteVisitorContext) => MaybePromise<boolean | object | void>;
+    field?: (field: FieldDef, action: ORMWriteActionType, data: any, context: NestedWriteVisitorContext) => MaybePromise<void>;
+};
+/**
+ * Recursive visitor for nested write (create/update) payload.
+ */
+declare class NestedWriteVisitor {
+    private readonly schema;
+    private readonly callback;
+    constructor(schema: SchemaDef, callback: NestedWriteVisitorCallback);
+    private isWriteAction;
+    /**
+     * Start visiting
+     *
+     * @see NestedWriteVisitorCallback
+     */
+    visit(model: string, action: ORMWriteActionType, args: any): Promise<void>;
+    private doVisit;
+    private visitSubPayload;
+    private enumerateReverse;
+}
+
+/**
+ * Custom optimistic data provider. It takes query information (usually fetched from query cache)
+ * and returns a verdict on how to optimistically update the query data.
+ *
+ * @param args Arguments.
+ * @param args.queryModel The model of the query.
+ * @param args.queryOperation The operation of the query, `findMany`, `count`, etc.
+ * @param args.queryArgs The arguments of the query.
+ * @param args.currentData The current cache data for the query.
+ * @param args.mutationArgs The arguments of the mutation.
+ */
+type OptimisticDataProvider = (args: {
+    queryModel: string;
+    queryOperation: string;
+    queryArgs: any;
+    currentData: any;
+    mutationArgs: any;
+}) => OptimisticDataProviderResult | Promise<OptimisticDataProviderResult>;
+/**
+ * Result of optimistic data provider.
+ */
+type OptimisticDataProviderResult = {
+    /**
+     * Kind of the result.
+     *   - Update: use the `data` field to update the query cache.
+     *   - Skip: skip the optimistic update for this query.
+     *   - ProceedDefault: proceed with the default optimistic update.
+     */
+    kind: 'Update' | 'Skip' | 'ProceedDefault';
+    /**
+     * Data to update the query cache. Only applicable if `kind` is 'Update'.
+     *
+     * If the data is an object with fields updated, it should have a `$optimistic`
+     * field set to `true`. If it's an array and an element object is created or updated,
+     * the element should have a `$optimistic` field set to `true`.
+     */
+    data?: any;
+};
+/**
+ * Options for optimistic update.
+ */
+type OptimisticUpdateOptions = {
+    /**
+     * A custom optimistic data provider.
+     */
+    optimisticDataProvider?: OptimisticDataProvider;
+};
+/**
+ * Creates a function that performs optimistic updates for queries potentially
+ * affected by the given mutation operation.
+ *
+ * @param model Model under mutation.
+ * @param operation Mutation operation (e.g, `update`).
+ * @param schema The schema.
+ * @param options Optimistic update options.
+ * @param getAllQueries Callback to get all cached queries.
+ * @param logging Logging option.
+ */
+declare function createOptimisticUpdater(model: string, operation: string, schema: SchemaDef, options: OptimisticUpdateOptions, getAllQueries: () => readonly QueryInfo[], logging: Logger | undefined): (...args: unknown[]) => Promise<void>;
+
+/**
+ * Gets models read (including nested ones) given a query args.
+ */
+declare function getReadModels(model: string, schema: SchemaDef, args: any): string[];
+/**
+ * Gets mutated models (including nested ones) given a mutation args.
+ */
+declare function getMutatedModels(model: string, operation: ORMWriteActionType, mutationArgs: any, schema: SchemaDef): Promise<string[]>;
+
+export { DEFAULT_QUERY_ENDPOINT, type InvalidateFunc, type InvalidationPredicate, type Logger, type MaybePromise, NestedReadVisitor, type NestedReadVisitorCallback, NestedWriteVisitor, type NestedWriteVisitorCallback, type NestedWriteVisitorContext, type ORMWriteActionType, ORMWriteActions, type OptimisticDataProvider, type OptimisticDataProviderResult, type OptimisticUpdateOptions, type QueryError, type QueryInfo, applyMutation, createInvalidator, createOptimisticUpdater, getMutatedModels, getReadModels, log };