houdini 1.0.0-next.1 → 1.0.0-next.3

package/build/runtime-cjs/{lib/networkUtils.js → client/plugins/fetch.js}

@@ -16,12 +16,103 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var networkUtils_exports = {};
-__export(networkUtils_exports, {
+var fetch_exports = {};
+__export(fetch_exports, {
   extractFiles: () => extractFiles,
+  fetchPlugin: () => fetchPlugin,
   isExtractableFile: () => isExtractableFile
 });
-module.exports = __toCommonJS(networkUtils_exports);
+module.exports = __toCommonJS(fetch_exports);
+var import_types = require("../../lib/types");
+const fetchPlugin = (target) => {
+  return () => {
+    return {
+      async network(ctx, { client, resolve, marshalVariables }) {
+        const fetch = ctx.fetch ?? globalThis.fetch;
+        const fetchParams = {
+          text: ctx.text,
+          hash: ctx.hash,
+          variables: marshalVariables(ctx)
+        };
+        let fetchFn = defaultFetch(client.url, ctx.fetchParams);
+        if (target) {
+          if (typeof target === "string") {
+            fetchFn = defaultFetch(target, ctx.fetchParams);
+          } else {
+            fetchFn = target;
+          }
+        }
+        const result = await fetchFn({
+          fetch: (url, args) => {
+            const newArgs = handleMultipart(fetchParams, args) ?? args;
+            return fetch(url, newArgs);
+          },
+          metadata: ctx.metadata,
+          session: ctx.session || {},
+          ...fetchParams
+        });
+        resolve(ctx, {
+          fetching: false,
+          variables: ctx.variables ?? null,
+          data: result.data,
+          errors: !result.errors || result.errors.length === 0 ? null : result.errors,
+          partial: false,
+          source: import_types.DataSource.Network
+        });
+      }
+    };
+  };
+};
+const defaultFetch = (url, params) => {
+  if (!url) {
+    throw new Error(
+      "Could not find configured client url. Please specify one in your houdini.config.js file."
+    );
+  }
+  return async ({ fetch, text, variables }) => {
+    const result = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify({ query: text, variables }),
+      ...params,
+      headers: {
+        Accept: "application/graphql+json, application/json",
+        "Content-Type": "application/json",
+        ...params?.headers
+      }
+    });
+    return await result.json();
+  };
+};
+function handleMultipart(params, args) {
+  const { clone, files } = extractFiles({
+    query: params.text,
+    variables: params.variables
+  });
+  if (files.size) {
+    const req = args;
+    let headers = {};
+    if (req?.headers) {
+      const filtered = Object.entries(req?.headers).filter(([key, value]) => {
+        return !(key.toLowerCase() == "content-type" && value.toLowerCase() == "application/json");
+      });
+      headers = Object.fromEntries(filtered);
+    }
+    const form = new FormData();
+    const operationJSON = JSON.stringify(clone);
+    form.set("operations", operationJSON);
+    const map = {};
+    let i = 0;
+    files.forEach((paths) => {
+      map[++i] = paths;
+    });
+    form.set("map", JSON.stringify(map));
+    i = 0;
+    files.forEach((paths, file) => {
+      form.set(`${++i}`, file, file.name);
+    });
+    return { ...req, headers, body: form };
+  }
+}
 function isExtractableFile(value) {
   return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
 }
@@ -81,5 +172,6 @@ function isPlainObject(value) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   extractFiles,
+  fetchPlugin,
   isExtractableFile
 });

package/build/runtime-cjs/client/plugins/fetchParams.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentArtifact } from '../../lib/types';
+import type { ClientPlugin, ClientPluginContext } from '../documentStore';
+export type FetchParamFn = (ctx: FetchParamsInput) => Required<ClientPluginContext>['fetchParams'];
+export declare const fetchParamsPlugin: (fn?: FetchParamFn) => ClientPlugin;
+export type FetchParamsInput = Pick<ClientPluginContext, 'config' | 'policy' | 'variables' | 'metadata' | 'session' | 'stuff'> & {
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+};

package/build/runtime-cjs/client/plugins/fetchParams.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetchParams_exports = {};
+__export(fetchParams_exports, {
+  fetchParamsPlugin: () => fetchParamsPlugin
+});
+module.exports = __toCommonJS(fetchParams_exports);
+const fetchParamsPlugin = (fn = () => ({})) => () => ({
+  beforeNetwork(ctx, { next, marshalVariables }) {
+    next({
+      ...ctx,
+      fetchParams: fn({
+        ...ctx,
+        variables: marshalVariables(ctx),
+        text: ctx.artifact.raw,
+        hash: ctx.artifact.hash
+      })
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchParamsPlugin
+});

package/build/runtime-cjs/client/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export * from './fetch';
+export * from './cache';
+export * from './query';
+export * from './mutation';
+export * from './subscription';
+export * from './throwOnError';
+export * from './fetchParams';

package/build/runtime-cjs/client/plugins/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./fetch"), module.exports);
+__reExport(plugins_exports, require("./cache"), module.exports);
+__reExport(plugins_exports, require("./query"), module.exports);
+__reExport(plugins_exports, require("./mutation"), module.exports);
+__reExport(plugins_exports, require("./subscription"), module.exports);
+__reExport(plugins_exports, require("./throwOnError"), module.exports);
+__reExport(plugins_exports, require("./fetchParams"), module.exports);

package/build/runtime-cjs/client/plugins/injectedPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { ClientPlugin } from '../documentStore';
+declare const plugins: ClientPlugin[];
+export default plugins;

package/build/runtime-cjs/{lib/errors.js → client/plugins/injectedPlugins.js}

@@ -16,20 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var errors_exports = {};
-__export(errors_exports, {
-  errorsToGraphQLLayout: () => errorsToGraphQLLayout
+var injectedPlugins_exports = {};
+__export(injectedPlugins_exports, {
+  default: () => injectedPlugins_default
 });
-module.exports = __toCommonJS(errors_exports);
-function errorsToGraphQLLayout(errors) {
-  if (Array.isArray(errors)) {
-    return errors.map((error) => {
-      return { message: error };
-    });
-  }
-  return [{ message: errors }];
-}
+module.exports = __toCommonJS(injectedPlugins_exports);
+const plugins = [];
+var injectedPlugins_default = plugins;
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  errorsToGraphQLLayout
-});
+0 && (module.exports = {});

package/build/runtime-cjs/client/plugins/mutation.d.ts

@@ -0,0 +1 @@
+export declare const mutationPlugin: import("..").ClientPlugin;

package/build/runtime-cjs/client/plugins/mutation.js

@@ -0,0 +1,86 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mutation_exports = {};
+__export(mutation_exports, {
+  mutationPlugin: () => mutationPlugin
+});
+module.exports = __toCommonJS(mutation_exports);
+var import_cache = __toESM(require("../../cache"), 1);
+var import_scalars = require("../../lib/scalars");
+var import_types = require("../../lib/types");
+var import_utils = require("../utils");
+const mutationPlugin = (0, import_utils.documentPlugin)(import_types.ArtifactKind.Mutation, () => {
+  return {
+    async start(ctx, { next, marshalVariables }) {
+      const layer = import_cache.default._internal_unstable.storage.createLayer(true);
+      const optimisticResponse = ctx.stuff.optimisticResponse;
+      let toNotify = [];
+      if (optimisticResponse) {
+        toNotify = import_cache.default.write({
+          selection: ctx.artifact.selection,
+          data: await (0, import_scalars.marshalSelection)({
+            selection: ctx.artifact.selection,
+            data: optimisticResponse
+          }),
+          variables: marshalVariables(ctx),
+          layer: layer.id
+        });
+      }
+      ctx.cacheParams = {
+        ...ctx.cacheParams,
+        layer,
+        notifySubscribers: toNotify,
+        forceNotify: true
+      };
+      next(ctx);
+    },
+    afterNetwork(ctx, { resolve }) {
+      ctx.cacheParams?.layer?.clear();
+      resolve(ctx);
+    },
+    end(ctx, { resolve, value }) {
+      const hasErrors = value.errors && value.errors.length > 0;
+      if (hasErrors) {
+        ctx.cacheParams?.layer?.clear();
+      }
+      if (ctx.cacheParams?.layer) {
+        import_cache.default._internal_unstable.storage.resolveLayer(ctx.cacheParams.layer.id);
+      }
+      resolve(ctx);
+    },
+    catch(ctx, { error }) {
+      if (ctx.cacheParams?.layer) {
+        const { layer } = ctx.cacheParams;
+        layer.clear();
+        import_cache.default._internal_unstable.storage.resolveLayer(layer.id);
+      }
+      throw error;
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mutationPlugin
+});

package/build/runtime-cjs/client/plugins/query.d.ts

@@ -0,0 +1,2 @@
+import type { ClientPlugin } from '../documentStore';
+export declare const queryPlugin: ClientPlugin;

package/build/runtime-cjs/client/plugins/query.js

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_exports = {};
+__export(query_exports, {
+  queryPlugin: () => queryPlugin
+});
+module.exports = __toCommonJS(query_exports);
+var import_cache = __toESM(require("../../cache"), 1);
+var import_types = require("../../lib/types");
+var import_utils = require("../utils");
+const queryPlugin = (0, import_utils.documentPlugin)(import_types.ArtifactKind.Query, function() {
+  let subscriptionSpec = null;
+  let lastVariables = null;
+  let artifactName = "";
+  return {
+    start(ctx, { next }) {
+      ctx.variables = {
+        ...lastVariables,
+        ...ctx.variables
+      };
+      next(ctx);
+    },
+    end(ctx, { resolve, marshalVariables, variablesChanged }) {
+      if (variablesChanged(ctx)) {
+        artifactName = ctx.artifact.name;
+        if (subscriptionSpec) {
+          import_cache.default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        lastVariables = { ...marshalVariables(ctx) };
+        subscriptionSpec = {
+          rootType: ctx.artifact.rootType,
+          selection: ctx.artifact.selection,
+          variables: () => lastVariables,
+          set: (newValue) => {
+            console.log("setting from cache update");
+            resolve(ctx, {
+              data: newValue,
+              errors: null,
+              fetching: false,
+              partial: false,
+              source: import_types.DataSource.Cache,
+              variables: ctx.variables ?? null
+            });
+          }
+        };
+        import_cache.default.subscribe(subscriptionSpec, lastVariables ?? {});
+      }
+      resolve(ctx);
+    },
+    cleanup() {
+      if (subscriptionSpec) {
+        import_cache.default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() ?? {});
+        lastVariables = null;
+      }
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  queryPlugin
+});

package/build/runtime-cjs/client/plugins/subscription.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLObject } from '../../lib/types';
+import type { ClientPluginContext } from '../documentStore';
+export declare function subscriptionPlugin(factory: SubscriptionHandler): import("../documentStore").ClientPlugin;
+export type SubscriptionHandler = (ctx: ClientPluginContext) => {
+    subscribe: (payload: {
+        query: string;
+        variables?: {};
+    }, handlers: {
+        next: (payload: {
+            data?: GraphQLObject;
+            errors?: readonly {
+                message: string;
+            }[];
+        }) => void;
+        error: (data: {}) => void;
+        complete: () => void;
+    }) => () => void;
+};

package/build/runtime-cjs/client/plugins/subscription.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subscription_exports = {};
+__export(subscription_exports, {
+  subscriptionPlugin: () => subscriptionPlugin
+});
+module.exports = __toCommonJS(subscription_exports);
+var import_deepEquals = require("../../lib/deepEquals");
+var import_types = require("../../lib/types");
+var import_utils = require("../utils");
+function subscriptionPlugin(factory) {
+  return (0, import_utils.documentPlugin)(import_types.ArtifactKind.Subscription, () => {
+    let clearSubscription = null;
+    let socketClient = null;
+    let check = null;
+    return {
+      start(ctx, { resolve, next, initialValue }) {
+        if (typeof globalThis.window === "undefined") {
+          resolve(ctx, initialValue);
+          return;
+        }
+        next(ctx);
+      },
+      network(ctx, { resolve, initialValue, variablesChanged, marshalVariables }) {
+        const checkValue = {
+          fetchParams: ctx.fetchParams ?? {},
+          session: ctx.session ?? {},
+          metadata: ctx.metadata ?? {}
+        };
+        const changed = variablesChanged(ctx);
+        const sessionChange = !(0, import_deepEquals.deepEquals)(check, checkValue);
+        if (!changed && !sessionChange) {
+          resolve(ctx, initialValue);
+          return;
+        }
+        check = checkValue;
+        clearSubscription?.();
+        if (!socketClient || sessionChange) {
+          socketClient = factory(ctx);
+        }
+        clearSubscription = socketClient.subscribe(
+          {
+            query: ctx.artifact.raw,
+            variables: marshalVariables(ctx)
+          },
+          {
+            next: ({ data, errors }) => {
+              resolve(ctx, {
+                data: data ?? null,
+                errors: [...errors ?? []],
+                fetching: false,
+                partial: true,
+                source: import_types.DataSource.Network,
+                variables: ctx.variables ?? null
+              });
+            },
+            error(data) {
+              clearSubscription?.();
+              resolve(ctx, {
+                partial: true,
+                source: import_types.DataSource.Network,
+                data: null,
+                errors: [data],
+                fetching: false,
+                variables: ctx.variables ?? null
+              });
+            },
+            complete() {
+            }
+          }
+        );
+      },
+      cleanup() {
+        clearSubscription?.();
+      }
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  subscriptionPlugin
+});

package/build/runtime-cjs/client/plugins/throwOnError.d.ts

@@ -0,0 +1,7 @@
+import type { QueryResult } from '../../lib';
+import type { ClientPlugin } from '../documentStore';
+export type ThrowOnErrorParams = {
+    operations: ('all' | 'query' | 'mutation' | 'subscription')[];
+    error?: (errors: NonNullable<QueryResult<any, any>['errors']>) => unknown;
+};
+export declare const throwOnErrorPlugin: ({ operations, error }: ThrowOnErrorParams) => ClientPlugin;

package/build/runtime-cjs/client/plugins/throwOnError.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var throwOnError_exports = {};
+__export(throwOnError_exports, {
+  throwOnErrorPlugin: () => throwOnErrorPlugin
+});
+module.exports = __toCommonJS(throwOnError_exports);
+var import_lib = require("../../lib");
+const throwOnErrorPlugin = ({ operations, error }) => () => {
+  const all = operations.includes("all");
+  const throwOnKind = (kind) => all || {
+    [import_lib.ArtifactKind.Query]: operations.includes("query"),
+    [import_lib.ArtifactKind.Mutation]: operations.includes("mutation"),
+    [import_lib.ArtifactKind.Fragment]: false,
+    [import_lib.ArtifactKind.Subscription]: operations.includes("subscription")
+  }[kind];
+  return {
+    async end(ctx, { value, resolve }) {
+      if (value.errors && value.errors.length > 0 && throwOnKind(ctx.artifact.kind)) {
+        const result = await (error ?? defaultErrorFn)(value.errors);
+        throw result;
+      }
+      resolve(ctx);
+    }
+  };
+};
+const defaultErrorFn = async (errors) => new Error(errors.map((error) => error.message).join(". ") + ".");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  throwOnErrorPlugin
+});

package/build/runtime-cjs/client/utils/documentPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactKind } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const documentPlugin: (kind: ArtifactKind, source: ClientPlugin) => ClientPlugin;

package/build/runtime-cjs/client/utils/documentPlugins.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var documentPlugins_exports = {};
+__export(documentPlugins_exports, {
+  documentPlugin: () => documentPlugin
+});
+module.exports = __toCommonJS(documentPlugins_exports);
+const documentPlugin = (kind, source) => {
+  return () => {
+    const sourceHandlers = source();
+    const enterWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.next(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    const exitWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.resolve(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    return {
+      start: enterWrapper(sourceHandlers.start),
+      network: enterWrapper(sourceHandlers.network),
+      afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
+      end: exitWrapper(sourceHandlers.end),
+      catch: sourceHandlers.catch ? (ctx, handlers) => sourceHandlers.catch(ctx, handlers) : void 0,
+      cleanup: (...args) => sourceHandlers.cleanup?.(...args)
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  documentPlugin
+});

package/build/runtime-cjs/client/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './documentPlugins';

package/build/runtime-cjs/client/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./documentPlugins"), module.exports);

package/build/runtime-cjs/generated.d.ts

@@ -1,4 +1,5 @@
 export type CacheTypeDef = {
     types: {};
     lists: {};
+    queries: [];
 };