houdini 1.5.5 → 2.0.0-next.1

package/build/runtime/lib/config.d.ts

@@ -196,6 +196,13 @@ export type WatchSchemaConfig = {
      * logic you need
      */
     headers?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+    /**
+     * Write the schema to disk on pull.
+     * Useful for IDE integration.
+     * Set to false when you have read only access to the schema or directory it's in.
+     * Defaults to true
+     */
+    writePolledSchema?: boolean;
 };
 export type ScalarSpec = {
     type: string;

package/build/runtime-cjs/cache/cache.js

@@ -38,6 +38,9 @@ var import_storage = require("./storage");
 var import_stuff = require("./stuff");
 var import_subscription = require("./subscription");
 class Cache {
+  // the internal implementation for a lot of the cache's methods are moved into
+  // a second class to avoid users from relying on unstable APIs. typescript's private
+  // label accomplishes this but would not prevent someone using vanilla js
   _internal_unstable;
   constructor({
     disabled,
@@ -60,6 +63,8 @@ class Cache {
       this.setConfig((0, import_config.defaultConfigValues)(config));
     }
   }
+  // walk down the selection and save the values that we encounter.
+  // any changes will notify subscribers. writing to an optimistic layer will resolve it
   write({
     layer: layerID,
     notifySubscribers = [],
@@ -70,6 +75,7 @@ class Cache {
     this.#notifySubscribers(subscribers.concat(notifySubscribers));
     return subscribers;
   }
+  // reconstruct an object with the fields/relations specified by a selection
   read(...args) {
     const { data, partial, stale, hasData } = this._internal_unstable.getSelection(...args);
     if (!hasData) {
@@ -81,6 +87,7 @@ class Cache {
       stale
     };
   }
+  // register the provided callbacks with the fields specified by the selection
   subscribe(spec, variables = {}) {
     if (this._internal_unstable.disabled) {
       return;
@@ -92,6 +99,7 @@ class Cache {
       variables
     });
   }
+  // stop listening to a particular subscription
   unsubscribe(spec, variables = {}) {
     return this._internal_unstable.subscriptions.remove(
       spec.parentID || import_stuff.rootID,
@@ -100,6 +108,7 @@ class Cache {
       variables
     );
   }
+  // return the list handler to mutate a named list in the cache
   list(name, parentID, allLists, skipMatches) {
     const handler = this._internal_unstable.lists.get(name, parentID, allLists, skipMatches);
     if (!handler) {
@@ -109,10 +118,12 @@ class Cache {
     }
     return handler;
   }
+  // when an optimistic key resolves, we might momentarily know the same record by different IDs
   registerKeyMap(source, mapped) {
     this._internal_unstable.storage.registerIDMapping(source, mapped);
     this._internal_unstable.subscriptions.copySubscribers(source, mapped);
   }
+  // remove the record from the cache's store and unsubscribe from it
   delete(id, layer) {
     const recordIDs = [this._internal_unstable.storage.idMaps[id], id].filter(
       Boolean
@@ -123,6 +134,7 @@ class Cache {
       this._internal_unstable.storage.delete(recordID, layer);
     }
   }
+  // set the cache's config
   setConfig(config) {
     this._internal_unstable.setConfig(config);
   }
@@ -204,6 +216,7 @@ class Cache {
     }
     this.#notifySubscribers(toNotify);
   }
+  // reset the whole cache
   reset() {
     const subSpecs = this._internal_unstable.subscriptions.reset();
     this._internal_unstable.staleManager.reset();
@@ -233,6 +246,7 @@ class Cache {
   }
 }
 class CacheInternal {
+  // for server-side requests we need to be able to flag the cache as disabled so we dont write to it
   disabled = false;
   _config;
   storage;
@@ -397,7 +411,8 @@ class CacheInternal {
             forceNotify
           });
         }
-      } else if (Array.isArray(value) && (typeof previousValue === "undefined" || previousValue === null || Array.isArray(previousValue))) {
+      } else if (Array.isArray(value) && // make typescript happy
+      (typeof previousValue === "undefined" || previousValue === null || Array.isArray(previousValue))) {
         let oldIDs = [...previousValue || []];
         const emptyEdges = !updates ? [] : oldIDs.map((id) => {
           if (!id) {
@@ -593,6 +608,7 @@ class CacheInternal {
     }
     return toNotify;
   }
+  // reconstruct an object defined by its selection
   getSelection({
     selection,
     parent = import_stuff.rootID,
@@ -781,6 +797,8 @@ class CacheInternal {
     }
     return {
       data: cascadeNull ? null : target,
+      // our value is considered true if there is some data but not everything
+      // has a full value
       partial: !generateLoading && hasData && partial,
       stale: hasData && stale,
       hasData
@@ -796,12 +814,15 @@ class CacheInternal {
     }
     return type + ":" + id;
   }
+  // the list of fields that we need in order to compute an objects id
   idFields(type) {
     return (0, import_config.keyFieldsForType)(this.config, type);
   }
   computeID(type, data) {
     return (0, import_config.computeID)(this.config, type, data);
   }
+  // figure out if this is an embedded object or a linked one by looking for all of the fields marked as
+  // required to compute the entity's id
   isEmbedded(linkedType, value) {
     const idFields = this.idFields(linkedType);
     return idFields.length === 0 || idFields.filter((field) => typeof value[field] === "undefined").length > 0;

package/build/runtime-cjs/cache/gc.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(gc_exports);
 class GarbageCollector {
   cache;
   lifetimes = /* @__PURE__ */ new Map();
+  // the number of ticks of the garbage collector that a piece of data will
   get cacheBufferSize() {
     return this.cache._internal_unstable.config.cacheBufferSize ?? 10;
   }

package/build/runtime-cjs/cache/index.js

@@ -23,5 +23,3 @@ __export(cache_exports, {
 module.exports = __toCommonJS(cache_exports);
 var import_cache = require("./cache");
 var cache_default = new import_cache.Cache();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});

package/build/runtime-cjs/cache/lists.js

@@ -32,6 +32,7 @@ class ListManager {
     this.rootID = rootID2;
     this.cache = cache;
   }
+  // associate list names with the handler that wraps the list
   lists = /* @__PURE__ */ new Map();
   listsByField = /* @__PURE__ */ new Map();
   get(listName, id, allLists, skipMatches) {
@@ -170,6 +171,8 @@ class List {
   get fieldRef() {
     return `${this.recordID}.${this.key}`;
   }
+  // looks for the collection of all of the lists in the cache that satisfies a when
+  // condition
   when(when) {
     return this.manager.lists.get(this.name).get(this.recordID).when(when);
   }
@@ -326,6 +329,8 @@ class List {
     const subscribers = this.cache._internal_unstable.subscriptions.get(this.recordID, this.key);
     this.cache._internal_unstable.subscriptions.remove(
       targetID,
+      // if we are unsubscribing from a connection, the fields we care about
+      // are tucked away under edges
       this.connection ? this.selection.fields.edges.selection : this.selection,
       subscribers.map((sub) => sub[0]),
       variables
@@ -384,6 +389,8 @@ class List {
       this.addToList(selection, data, variables, where, layer);
     }
   }
+  // iterating over the list handler should be the same as iterating over
+  // the underlying linked list
   *[Symbol.iterator]() {
     let entries = [];
     let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
@@ -442,6 +449,8 @@ class ListCollection {
   deleteListWithKey(key) {
     return this.lists = this.lists.filter((list) => list.key !== key);
   }
+  // iterating over the collection should be the same as iterating over
+  // the underlying list
   *[Symbol.iterator]() {
     for (let list of this.lists) {
       for (const entry of list) {

package/build/runtime-cjs/cache/staleManager.js

@@ -24,6 +24,15 @@ module.exports = __toCommonJS(staleManager_exports);
 var import_lib = require("../lib");
 class StaleManager {
   cache;
+  // 	id {         "User:1"    "_ROOT_"
+  //   field {      "id"        "viewer"
+  // 	  number | undefined | null
+  // 	 }
+  //  }
+  // number => data ok (not stale!)
+  // undefined => no data (not stale!)
+  // null => data stale (stale)
+  // nulls mean that the value is stale, and the number is the time that the value was set
   fieldsTime = /* @__PURE__ */ new Map();
   constructor(cache) {
     this.cache = cache;
@@ -33,13 +42,28 @@ class StaleManager {
       this.fieldsTime.set(id, /* @__PURE__ */ new Map());
     }
   };
+  /**
+   * get the FieldTime info
+   * @param id User:1
+   * @param field firstName
+   */
   getFieldTime(id, field) {
     return this.fieldsTime.get(id)?.get(field);
   }
+  /**
+   * set the date to a field
+   * @param id User:1
+   * @param field firstName
+   */
   setFieldTimeToNow(id, field) {
     this.#initMapId(id);
-    this.fieldsTime.get(id)?.set(field, new Date().valueOf());
+    this.fieldsTime.get(id)?.set(field, (/* @__PURE__ */ new Date()).valueOf());
   }
+  /**
+   * set null to a field (stale)
+   * @param id User:1
+   * @param field firstName
+   */
   markFieldStale(id, field) {
     this.#initMapId(id);
     this.fieldsTime.get(id)?.set(field, null);
@@ -80,6 +104,7 @@ class StaleManager {
       }
     }
   }
+  // clean up the stale manager
   delete(id, field) {
     if (this.fieldsTime.has(id)) {
       this.fieldsTime.get(id)?.delete(field);

package/build/runtime-cjs/cache/storage.js

@@ -43,6 +43,7 @@ class InMemoryStorage {
     this.idMaps[from] = to;
     this.idMaps[to] = from;
   }
+  // create a layer and return its id
   createLayer(optimistic = false) {
     const layer = new Layer(this.idCount++);
     layer.optimistic = optimistic;
@@ -210,6 +211,8 @@ class InMemoryStorage {
     }
     return this.data[this.data.length - 1];
   }
+  // return a string representation of all of the data and necessary state to
+  // recreate the information stored
   serialize() {
     return JSON.stringify({
       rank: this.rank,
@@ -343,6 +346,7 @@ class Layer {
       [id]: {
         ...this.operations[id],
         deleted: true,
+        // reapply any delete undos
         undoDeletesInList: []
       }
     };

package/build/runtime-cjs/cache/subscription.js

@@ -158,6 +158,7 @@ class InMemorySubscriptions {
       }, {})
     });
   }
+  // this is different from add because of the treatment of lists
   addMany({
     parent,
     variables,

package/build/runtime-cjs/client/documentStore.js

@@ -36,9 +36,14 @@ class DocumentStore extends import_store.Writable {
   artifact;
   #client;
   #configFile;
+  // the list of instantiated plugins
   #plugins;
+  // we need to track the last set of variables used so we can
+  // detect if they have changed
   #lastVariables;
+  // we need the last context value we've seen in order to pass it during cleanup
   #lastContext = null;
+  // a reference to the earliest resolving open promise that the store has sent
   pendingPromise = null;
   serverSideFallback;
   controllerKey(variables) {
@@ -77,6 +82,7 @@ class DocumentStore extends import_store.Writable {
     this.#lastVariables = null;
     this.#configFile = (0, import_config.getCurrentConfig)();
     this.#plugins = pipeline ?? [
+      // cache policy needs to always come first so that it can be the first network to fire
       (0, import_plugins.cachePolicy)({
         cache,
         enabled: enableCache,
@@ -93,6 +99,7 @@ class DocumentStore extends import_store.Writable {
       ...plugins ?? []
     ];
   }
+  // used by the client to send a new set of variables to the pipeline
   async send({
     metadata,
     session,
@@ -159,6 +166,7 @@ class DocumentStore extends import_store.Writable {
           reject,
           then: (...args) => promise.then(...args)
         },
+        // patch the context with new variables
         context
       };
       if (this.pendingPromise === null) {
@@ -237,7 +245,14 @@ class DocumentStore extends import_store.Writable {
         marshalVariables,
         updateState: this.update.bind(this),
         next: (newContext) => {
-          const nextIndex = ["forward", "error"].includes(direction) ? index + 1 : index;
+          const nextIndex = ["forward", "error"].includes(direction) ? (
+            // if we're going forward, add one
+            index + 1
+          ) : (
+            // if we're moving backwards but called next, we
+            // we need to invoke the same hook
+            index
+          );
           const nextStep = ["backwards", "error"].includes(direction) ? 0 : ctx.currentStep;
           this.#step("forward", {
             ...ctx,
@@ -247,7 +262,14 @@ class DocumentStore extends import_store.Writable {
           });
         },
         resolve: (newContext, value2) => {
-          const nextIndex = direction === "backwards" ? index - 1 : index;
+          const nextIndex = direction === "backwards" ? (
+            // if we're going backwards, subtract one
+            index - 1
+          ) : (
+            // if we're moving forwards but then call resolve
+            // we need to visit the same hook
+            index
+          );
           this.#step(
             "backwards",
             {
@@ -344,6 +366,7 @@ class DocumentStore extends import_store.Writable {
   }
 }
 class ClientPluginContextWrapper {
+  // separate the last variables from what we pass to the user
   #context;
   #lastVariables;
   constructor({
@@ -356,6 +379,8 @@ class ClientPluginContextWrapper {
   get variables() {
     return this.#context.variables;
   }
+  // draft produces a wrapper over the context so users can mutate it without
+  // actually affecting the context values
   draft() {
     const ctx = {
       ...this.#context
@@ -423,6 +448,7 @@ class ClientPluginContextWrapper {
     };
     return ctx;
   }
+  // apply applies the draft value in a new context
   apply(values, newVariables) {
     if (newVariables) {
       values = this.applyVariables(this.#context, values);

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

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -42,7 +46,9 @@ var import_injectedPlugins = __toESM(require("./plugins/injectedPlugins"), 1);
 var import_documentStore2 = require("./documentStore");
 var import_plugins2 = require("./plugins");
 class HoudiniClient {
+  // the URL of the api
   url;
+  // expose operations settings
   throwOnError_operations;
   cache = null;
   throwOnError;
@@ -50,7 +56,9 @@ class HoudiniClient {
   pipeline;
   extraPlugins;
   proxies = {};
+  // this is modified by page entries when they load in order to register the components source
   componentCache = {};
+  // we need the ability to link the client up with an external cache
   setCache(cache) {
     this.cache = cache;
   }
@@ -77,16 +85,24 @@ class HoudiniClient {
   get plugins() {
     return (0, import_flatten.flatten)(
       [].concat(
+        // if they specified a throw behavior
         this.throwOnError ? [(0, import_plugins.throwOnError)(this.throwOnError)] : [],
         (0, import_plugins.fetchParams)(this.fetchParams),
-        this.pipeline ?? [
+        // if the user wants to specify the entire pipeline, let them do so
+        this.pipeline ?? // the user doesn't have a specific pipeline so we should just add their desired plugins
+        // to the standard set
+        [
           (0, import_plugins.optimisticKeys)(this.cache ?? import_cache.default),
+          // make sure that documents always work
           (0, import_plugins.query)(this.cache ?? import_cache.default),
           (0, import_plugins.mutation)(this.cache ?? import_cache.default),
           (0, import_plugins.fragment)(this.cache ?? import_cache.default)
         ].concat(
+          // add the specified middlewares
           this.extraPlugins ?? [],
+          // and any middlewares we got from plugins
           import_injectedPlugins.default,
+          // if they provided a fetch function, use it as the body for the fetch middleware
           (0, import_plugins.fetch)()
         )
       )

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

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -49,7 +53,8 @@ const cachePolicy = ({
             variables: marshalVariables(ctx),
             fullCheck: true
           });
-          const allowed = !value.partial || artifact.kind === import_types.ArtifactKind.Query && artifact.partial;
+          const allowed = !value.partial || // or the artifact allows for partial responses
+          artifact.kind === import_types.ArtifactKind.Query && artifact.partial;
           if (policy === import_types.CachePolicy.CacheOnly) {
             return resolve(ctx, {
               fetching: false,
@@ -73,7 +78,8 @@ const cachePolicy = ({
               stale: value.stale
             });
           }
-          if (useCache && !value.partial && !value.stale && ctx.policy !== "CacheAndNetwork") {
+          if (useCache && !value.partial && !value.stale && // if the policy is CacheAndNetwork then we don't want to stop here regardless
+          ctx.policy !== "CacheAndNetwork") {
             return;
           }
         }

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

@@ -50,6 +50,8 @@ const fetch = (target) => {
           }
         }
         const result = await fetchFn({
+          // wrap the user's fetch function so we can identify SSR by checking
+          // the response.url
           fetch: (url, args) => {
             const newArgs = handleMultipart(fetchParams, args) ?? args;
             return fetch2(url, {
@@ -142,8 +144,7 @@ function isExtractableFile(value) {
   return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
 }
 function extractFiles(value) {
-  if (!arguments.length)
-    throw new TypeError("Argument 1 `value` is required.");
+  if (!arguments.length) throw new TypeError("Argument 1 `value` is required.");
   const clones = /* @__PURE__ */ new Map();
   const files = /* @__PURE__ */ new Map();
   function recurse(value2, path, recursed) {
@@ -158,8 +159,16 @@ function extractFiles(value) {
       let clone = clones.get(value2);
       const uncloned = !clone;
       if (uncloned) {
-        clone = valueIsList ? [] : value2 instanceof Object ? {} : /* @__PURE__ */ Object.create(null);
-        clones.set(value2, clone);
+        clone = valueIsList ? [] : (
+          // Replicate if the plain object is an `Object` instance.
+          value2 instanceof /** @type {any} */
+          Object ? {} : /* @__PURE__ */ Object.create(null)
+        );
+        clones.set(
+          value2,
+          /** @type {Clone} */
+          clone
+        );
       }
       if (!recursed.has(value2)) {
         const pathPrefix = path ? `${path}.` : "";
@@ -168,8 +177,7 @@ function extractFiles(value) {
           let index = 0;
           for (const item of value2) {
             const itemClone = recurse(item, pathPrefix + index++, recursedDeeper);
-            if (uncloned)
-              clone.push(itemClone);
+            if (uncloned) clone.push(itemClone);
           }
         } else
           for (const key in value2) {

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

@@ -26,11 +26,13 @@ const fetchParams = (fn = () => ({})) => () => ({
     next({
       ...ctx,
       fetchParams: fn({
+        // most of the stuff comes straight from the context
         config: ctx.config,
         policy: ctx.policy,
         metadata: ctx.metadata,
         session: ctx.session,
         stuff: ctx.stuff,
+        // a few fields are renamed or modified
         document: ctx.artifact,
         variables: marshalVariables(ctx),
         text: ctx.text,

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

@@ -28,6 +28,7 @@ const fragment = (cache) => (0, import_utils.documentPlugin)(import_types.Artifa
   let subscriptionSpec = null;
   let lastReference = null;
   return {
+    // establish the cache subscription
     start(ctx, { next, resolve, variablesChanged, marshalVariables }) {
       if (!ctx.stuff.parentID) {
         return next(ctx);

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

@@ -33,5 +33,13 @@ __reExport(plugins_exports, require("./fetchParams"), module.exports);
 var import_optimisticKeys = require("./optimisticKeys");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  optimisticKeys
+  optimisticKeys,
+  ...require("./fetch"),
+  ...require("./cache"),
+  ...require("./query"),
+  ...require("./fragment"),
+  ...require("./mutation"),
+  ...require("./subscription"),
+  ...require("./throwOnError"),
+  ...require("./fetchParams")
 });

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

@@ -23,5 +23,3 @@ __export(injectedPlugins_exports, {
 module.exports = __toCommonJS(injectedPlugins_exports);
 const plugins = [];
 var injectedPlugins_default = plugins;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});

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

@@ -33,6 +33,7 @@ const mutation = (cache) => (0, import_utils.documentPlugin)(import_types.Artifa
       if (optimisticResponse) {
         toNotify = cache.write({
           selection: ctx.artifact.selection,
+          // make sure that any scalar values get processed into something we can cache
           data: await (0, import_scalars.marshalSelection)({
             selection: ctx.artifact.selection,
             data: optimisticResponse
@@ -43,8 +44,13 @@ const mutation = (cache) => (0, import_utils.documentPlugin)(import_types.Artifa
       }
       ctx.cacheParams = {
         ...ctx.cacheParams,
+        // write to the mutation's layer
         layer: layerOptimistic,
+        // notify any subscribers that we updated with the optimistic response
+        // in order to address situations where the optimistic update was wrong
         notifySubscribers: toNotify,
+        // make sure that we notify subscribers for any values that we compare
+        // in order to address any race conditions when comparing the previous value
         forceNotify: true
       };
       next(ctx);

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

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -52,6 +56,8 @@ const optimisticKeys = (cache, callbackCache = callbacks, keyCache = keys, objec
       }
       next(newCtx);
     },
+    // if a request has variables that contain an optimistic key we need to block the
+    // request before it is sent to the server
     beforeNetwork(ctx, { next }) {
       if (Object.keys(keyCache).length === 0) {
         return next(ctx);
@@ -101,6 +107,7 @@ const optimisticKeys = (cache, callbackCache = callbacks, keyCache = keys, objec
       }
       resolve(ctx);
     },
+    // when the mutation ends, we no longer have any dependents that we have to track
     end(ctx, { resolve }) {
       if (typeof ctx.stuff.mutationID !== "undefined") {
         delete keyCache[ctx.stuff.mutationID];
@@ -299,13 +306,13 @@ function replaceKeyWithVariable(variables, keys2) {
 }
 function generateKey(type) {
   if (type === "Int") {
-    return new Date().getTime();
+    return (/* @__PURE__ */ new Date()).getTime();
   }
   if (type === "String") {
-    return new Date().getTime().toString();
+    return (/* @__PURE__ */ new Date()).getTime().toString();
   }
   if (type === "ID") {
-    return new Date().getTime().toString();
+    return (/* @__PURE__ */ new Date()).getTime().toString();
   }
   throw new Error(
     `unsupported type for optimistic key: ${type}. Please provide a value in your mutation arguments.`

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

@@ -33,6 +33,8 @@ const query = (cache) => (0, import_utils.documentPlugin)(import_types.ArtifactK
       };
       ctx.variables = {
         ...lastVariables,
+        // we need to evaluate any runtime scalars but allow the user to overwrite them
+        // by explicitly passing variables
         ...Object.fromEntries(
           Object.entries(ctx.artifact.input?.runtimeScalars ?? {}).map(
             ([field, type]) => {
@@ -48,6 +50,8 @@ const query = (cache) => (0, import_utils.documentPlugin)(import_types.ArtifactK
       };
       next(ctx);
     },
+    // patch subscriptions on the way out so that we don't get a cache update
+    // before the promise resolves
     end(ctx, { resolve, marshalVariables, variablesChanged }) {
       if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
         if (subscriptionSpec) {

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

@@ -16,3 +16,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 module.exports = __toCommonJS(utils_exports);
 __reExport(utils_exports, require("./documentPlugins"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./documentPlugins")
+});

package/build/runtime-cjs/imports/config.js

@@ -22,5 +22,3 @@ __export(config_exports, {
 });
 module.exports = __toCommonJS(config_exports);
 var config_default = {};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});