houdini 1.5.4 → 2.0.0-next.0

package/build/runtime-cjs/index.js

@@ -19,21 +19,25 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var runtime_exports = {};
-__export(runtime_exports, {
+var index_exports = {};
+__export(index_exports, {
   cache: () => cache,
   getCache: () => getCache,
   graphql: () => graphql
 });
-module.exports = __toCommonJS(runtime_exports);
+module.exports = __toCommonJS(index_exports);
 var import_cache = __toESM(require("./cache"), 1);
 var import_public = require("./public");
-__reExport(runtime_exports, require("./client"), module.exports);
-__reExport(runtime_exports, require("./lib"), module.exports);
+__reExport(index_exports, require("./client"), module.exports);
+__reExport(index_exports, require("./lib"), module.exports);
 function graphql(str) {
   if (globalThis?.process?.env?.HOUDINI_PLUGIN) {
     return str;
@@ -51,5 +55,7 @@ function getCache() {
 0 && (module.exports = {
   cache,
   getCache,
-  graphql
+  graphql,
+  ...require("./client"),
+  ...require("./lib")
 });

package/build/runtime-cjs/lib/config.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
 ));

package/build/runtime-cjs/lib/deepEquals.js

@@ -22,8 +22,7 @@ __export(deepEquals_exports, {
 });
 module.exports = __toCommonJS(deepEquals_exports);
 function deepEquals(objA, objB, map = /* @__PURE__ */ new WeakMap()) {
-  if (Object.is(objA, objB))
-    return true;
+  if (Object.is(objA, objB)) return true;
   if (objA instanceof Date && objB instanceof Date) {
     return objA.getTime() === objB.getTime();
   }
@@ -33,8 +32,7 @@ function deepEquals(objA, objB, map = /* @__PURE__ */ new WeakMap()) {
   if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
     return false;
   }
-  if (map.get(objA) === objB)
-    return true;
+  if (map.get(objA) === objB) return true;
   map.set(objA, objB);
   const keysA = Reflect.ownKeys(objA);
   const keysB = Reflect.ownKeys(objB);

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

@@ -25,3 +25,16 @@ __reExport(lib_exports, require("./store"), module.exports);
 __reExport(lib_exports, require("./key"), module.exports);
 __reExport(lib_exports, require("./lru"), module.exports);
 __reExport(lib_exports, require("./selection"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./config"),
+  ...require("./constants"),
+  ...require("./deepEquals"),
+  ...require("./log"),
+  ...require("./scalars"),
+  ...require("./types"),
+  ...require("./store"),
+  ...require("./key"),
+  ...require("./lru"),
+  ...require("./selection")
+});

package/build/runtime-cjs/lib/pagination.js

@@ -143,7 +143,8 @@ function cursorHandlers({
       const queryVariables = {};
       const count = (0, import_pageInfo.countPage)(artifact.refetch.path.concat("edges"), getState()) || artifact.refetch.pageSize;
       if (count && count > artifact.refetch.pageSize) {
-        if (currentPageInfo.hasPreviousPage && currentPageInfo.hasNextPage && !(variables?.["first"] && variables?.["after"] || variables?.["last"] && variables?.["before"])) {
+        if (currentPageInfo.hasPreviousPage && currentPageInfo.hasNextPage && // only log if they haven't provided special parameters
+        !(variables?.["first"] && variables?.["after"] || variables?.["last"] && variables?.["before"])) {
           console.warn(`\u26A0\uFE0F Encountered a fetch() in the middle of the connection.
 Make sure to pass a cursor value by hand that includes the current set (ie the entry before startCursor)
 `);

package/build/runtime-cjs/lib/types.js

@@ -67,8 +67,17 @@ const RefetchUpdateMode = {
   replace: "replace"
 };
 const DataSource = {
+  /**
+   * from the browser cache
+   */
   Cache: "cache",
+  /**
+   * from a browser side `fetch`
+   */
   Network: "network",
+  /**
+   * from a server side `fetch`
+   */
   Ssr: "ssr"
 };
 const fragmentKey = " $fragments";
@@ -90,5 +99,6 @@ function isPending(value) {
   PendingValue,
   RefetchUpdateMode,
   fragmentKey,
-  isPending
+  isPending,
+  ...require("../router/types")
 });

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

@@ -29,6 +29,9 @@ class Cache {
   constructor(cache) {
     this._internal_unstable = cache;
   }
+  // if the user is using the imperative API, we want the ability to break the API
+  // with any minor version. In order to do this, we require them to accept this contract
+  // through their config file
   validateInstabilityWarning() {
     if (!this.config.acceptImperativeInstability && !this.config.features?.imperativeCache) {
       console.warn(`\u26A0\uFE0F  The imperative cache API is considered unstable and will change in any minor version release
@@ -36,6 +39,7 @@ Please acknowledge this by enabling the imperative cache feature flage in your c
 For more information: https://houdinigraphql.com/api/cache`);
     }
   }
+  // return the record proxy for the given type/id combo
   get(type, data) {
     this.validateInstabilityWarning();
     let recordID = this._internal_unstable._internal_unstable.id(type, data);
@@ -79,6 +83,7 @@ For more information: https://houdinigraphql.com/api/cache`);
     this.validateInstabilityWarning();
     this._internal_unstable.write({
       selection: query.artifact.selection,
+      // @ts-expect-error
       data,
       variables: (0, import_lib.marshalInputs)({
         config: this.config,
@@ -88,9 +93,15 @@ For more information: https://houdinigraphql.com/api/cache`);
     });
     return;
   }
+  /**
+   * Mark some elements of the cache stale.
+   */
   markStale(type, options) {
     return this._internal_unstable.markTypeStale(type ? { ...options, type } : void 0);
   }
+  /**
+   * Reset the entire cache by clearing all records and lists
+   */
   reset() {
     return this._internal_unstable.reset();
   }

package/build/runtime-cjs/public/record.js

@@ -77,6 +77,11 @@ class Record {
   delete() {
     this.#cache._internal_unstable.delete(this.#id);
   }
+  /**
+   * Mark some elements of the record stale in the cache.
+   * @param field
+   * @param when
+   */
   markStale(field, {
     when
   } = {}) {

package/build/runtime-cjs/router/jwt.js

@@ -25,6 +25,7 @@ __export(jwt_exports, {
 module.exports = __toCommonJS(jwt_exports);
 function base64UrlParse(s) {
   return new Uint8Array(
+    // @ts-ignore
     Array.prototype.map.call(
       atob(s.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "")),
       (c) => c.charCodeAt(0)
@@ -77,20 +78,16 @@ function _decodePayload(raw) {
   }
 }
 async function encode(payload, secret, options = { algorithm: "HS256", header: { typ: "JWT" } }) {
-  if (typeof options === "string")
-    options = { algorithm: options, header: { typ: "JWT" } };
+  if (typeof options === "string") options = { algorithm: options, header: { typ: "JWT" } };
   options = { algorithm: "HS256", header: { typ: "JWT" }, ...options };
   if (payload === null || typeof payload !== "object")
     throw new Error("payload must be an object");
   if (typeof secret !== "string" && typeof secret !== "object")
     throw new Error("secret must be a string or a JWK object");
-  if (typeof options.algorithm !== "string")
-    throw new Error("options.algorithm must be a string");
+  if (typeof options.algorithm !== "string") throw new Error("options.algorithm must be a string");
   const algorithm = algorithms[options.algorithm];
-  if (!algorithm)
-    throw new Error("algorithm not found");
-  if (!payload.iat)
-    payload.iat = Math.floor(Date.now() / 1e3);
+  if (!algorithm) throw new Error("algorithm not found");
+  if (!payload.iat) payload.iat = Math.floor(Date.now() / 1e3);
   const payloadAsJSON = JSON.stringify(payload);
   const partialToken = `${base64UrlStringify(
     _utf8ToUint8Array(JSON.stringify({ ...options.header, alg: options.algorithm }))
@@ -105,42 +102,33 @@ async function encode(payload, secret, options = { algorithm: "HS256", header: {
     keyData = _str2ab(
       secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
     );
-  } else
-    keyData = _utf8ToUint8Array(secret);
+  } else keyData = _utf8ToUint8Array(secret);
   const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["sign"]);
   const signature = await crypto.subtle.sign(algorithm, key, _utf8ToUint8Array(partialToken));
   return `${partialToken}.${base64UrlStringify(new Uint8Array(signature))}`;
 }
 async function verify(token, secret, options = { algorithm: "HS256", throwError: false }) {
-  if (typeof options === "string")
-    options = { algorithm: options, throwError: false };
+  if (typeof options === "string") options = { algorithm: options, throwError: false };
   options = { algorithm: "HS256", throwError: false, ...options };
-  if (typeof token !== "string")
-    throw new Error("token must be a string");
+  if (typeof token !== "string") throw new Error("token must be a string");
   if (typeof secret !== "string" && typeof secret !== "object")
     throw new Error("secret must be a string or a JWK object");
-  if (typeof options.algorithm !== "string")
-    throw new Error("options.algorithm must be a string");
+  if (typeof options.algorithm !== "string") throw new Error("options.algorithm must be a string");
   const tokenParts = token.split(".");
-  if (tokenParts.length !== 3)
-    throw new Error("token must consist of 3 parts");
+  if (tokenParts.length !== 3) throw new Error("token must consist of 3 parts");
   const algorithm = algorithms[options.algorithm];
-  if (!algorithm)
-    throw new Error("algorithm not found");
+  if (!algorithm) throw new Error("algorithm not found");
   const { payload } = decode(token);
   if (!payload) {
-    if (options.throwError)
-      throw "PARSE_ERROR";
+    if (options.throwError) throw "PARSE_ERROR";
     return false;
   }
   if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1e3)) {
-    if (options.throwError)
-      throw "NOT_YET_VALID";
+    if (options.throwError) throw "NOT_YET_VALID";
     return false;
   }
   if (payload.exp && payload.exp <= Math.floor(Date.now() / 1e3)) {
-    if (options.throwError)
-      throw "EXPIRED";
+    if (options.throwError) throw "EXPIRED";
     return false;
   }
   let keyFormat = "raw";
@@ -153,8 +141,7 @@ async function verify(token, secret, options = { algorithm: "HS256", throwError:
     keyData = _str2ab(
       secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
     );
-  } else
-    keyData = _utf8ToUint8Array(secret);
+  } else keyData = _utf8ToUint8Array(secret);
   const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["verify"]);
   return await crypto.subtle.verify(
     algorithm,

package/build/runtime-cjs/router/match.js

@@ -138,14 +138,12 @@ function exec(match, params) {
     }
     buffered = "";
     if (value === void 0) {
-      if (param.rest)
-        result[param.name] = "";
+      if (param.rest) result[param.name] = "";
     } else {
       result[param.name] = decodeURIComponent(value);
     }
   }
-  if (buffered)
-    return;
+  if (buffered) return;
   return result;
 }
 function escape(str) {

package/build/runtime-cjs/router/server.js

@@ -51,7 +51,12 @@ function _serverHandler({
   if (schema) {
     client.registerProxy(graphqlEndpoint, async ({ query, variables, session }) => {
       const parsed = (0, import_graphql.parse)(query);
-      return await (0, import_graphql.execute)(schema, parsed, null, session, variables);
+      return await (0, import_graphql.execute)({
+        schema,
+        document: parsed,
+        contextValue: session,
+        variableValues: variables
+      });
     });
   }
   return async (request) => {

package/build/runtime-cjs/router/session.js

@@ -59,7 +59,7 @@ async function redirect_auth(args) {
 }
 const session_cookie_name = "__houdini__";
 async function set_session(req, response, value) {
-  const today = new Date();
+  const today = /* @__PURE__ */ new Date();
   const expires = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1e3);
   const serialized = await (0, import_jwt.encode)(value, req.session_keys[0]);
   response.headers.set(

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

@@ -11,6 +11,9 @@ import { InMemoryStorage } from "./storage";
 import { evaluateKey, rootID } from "./stuff";
 import { InMemorySubscriptions } from "./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,
@@ -33,6 +36,8 @@ class Cache {
       this.setConfig(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 = [],
@@ -43,6 +48,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) {
@@ -54,6 +60,7 @@ class Cache {
       stale
     };
   }
+  // register the provided callbacks with the fields specified by the selection
   subscribe(spec, variables = {}) {
     if (this._internal_unstable.disabled) {
       return;
@@ -65,6 +72,7 @@ class Cache {
       variables
     });
   }
+  // stop listening to a particular subscription
   unsubscribe(spec, variables = {}) {
     return this._internal_unstable.subscriptions.remove(
       spec.parentID || rootID,
@@ -73,6 +81,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) {
@@ -82,10 +91,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
@@ -96,6 +107,7 @@ class Cache {
       this._internal_unstable.storage.delete(recordID, layer);
     }
   }
+  // set the cache's config
   setConfig(config) {
     this._internal_unstable.setConfig(config);
   }
@@ -177,6 +189,7 @@ class Cache {
     }
     this.#notifySubscribers(toNotify);
   }
+  // reset the whole cache
   reset() {
     const subSpecs = this._internal_unstable.subscriptions.reset();
     this._internal_unstable.staleManager.reset();
@@ -206,6 +219,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;
@@ -370,7 +384,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) {
@@ -566,6 +581,7 @@ class CacheInternal {
     }
     return toNotify;
   }
+  // reconstruct an object defined by its selection
   getSelection({
     selection,
     parent = rootID,
@@ -754,6 +770,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
@@ -769,12 +787,15 @@ class CacheInternal {
     }
     return type + ":" + id;
   }
+  // the list of fields that we need in order to compute an objects id
   idFields(type) {
     return keyFieldsForType(this.config, type);
   }
   computeID(type, data) {
     return 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-esm/cache/gc.js

@@ -1,6 +1,7 @@
 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-esm/cache/lists.js

@@ -7,6 +7,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) {
@@ -145,6 +146,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);
   }
@@ -301,6 +304,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
@@ -359,6 +364,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;
@@ -417,6 +424,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-esm/cache/staleManager.js

@@ -1,6 +1,15 @@
 import { computeKey } from "../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;
@@ -10,13 +19,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);
@@ -57,6 +81,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-esm/cache/storage.js

@@ -17,6 +17,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;
@@ -184,6 +185,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,
@@ -317,6 +320,7 @@ class Layer {
       [id]: {
         ...this.operations[id],
         deleted: true,
+        // reapply any delete undos
         undoDeletesInList: []
       }
     };

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

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