houdini 2.0.0-next.8 → 2.0.0

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

@@ -1,89 +0,0 @@
-"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 mutation_exports = {};
-__export(mutation_exports, {
-  mutation: () => mutation
-});
-module.exports = __toCommonJS(mutation_exports);
-var import_scalars = require("../../lib/scalars");
-var import_types = require("../../lib/types");
-var import_utils = require("../utils");
-const mutation = (cache) => (0, import_utils.documentPlugin)(import_types.ArtifactKind.Mutation, () => {
-  return {
-    async start(ctx, { next, marshalVariables }) {
-      const layerOptimistic = cache._internal_unstable.storage.createLayer(true);
-      let toNotify = [];
-      const optimisticResponse = ctx.stuff.optimisticResponse;
-      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
-          }),
-          variables: marshalVariables(ctx),
-          layer: layerOptimistic.id
-        });
-      }
-      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);
-    },
-    afterNetwork(ctx, { resolve }) {
-      if (ctx.cacheParams?.layer) {
-        cache.clearLayer(ctx.cacheParams.layer.id);
-      }
-      resolve(ctx);
-    },
-    end(ctx, { resolve, value }) {
-      const hasErrors = value.errors && value.errors.length > 0;
-      if (hasErrors) {
-        if (ctx.cacheParams?.layer) {
-          cache.clearLayer(ctx.cacheParams.layer.id);
-        }
-      }
-      if (ctx.cacheParams?.layer) {
-        cache._internal_unstable.storage.resolveLayer(ctx.cacheParams.layer.id);
-      }
-      resolve(ctx);
-    },
-    catch(ctx, { error }) {
-      if (ctx.cacheParams?.layer) {
-        const { layer } = ctx.cacheParams;
-        cache.clearLayer(layer.id);
-        cache._internal_unstable.storage.resolveLayer(layer.id);
-      }
-      throw error;
-    }
-  };
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  mutation
-});

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

@@ -1,7 +0,0 @@
-import type { Cache } from '../../cache/cache';
-import type { ClientPlugin } from '../documentStore';
-export type CallbackMap = Record<string | number, Array<(newID: any) => void>>;
-export type KeyMap = Record<number, Record<string, keyof CallbackMap>>;
-type OptimisticObjectIDMap = Record<number, Record<string, string>>;
-export declare const optimisticKeys: (cache: Cache, callbackCache?: CallbackMap, keyCache?: KeyMap, objectIDs?: OptimisticObjectIDMap, invocationCounter?: number) => ClientPlugin;
-export {};

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

@@ -1,324 +0,0 @@
-"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(
-  // 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 optimisticKeys_exports = {};
-__export(optimisticKeys_exports, {
-  optimisticKeys: () => optimisticKeys
-});
-module.exports = __toCommonJS(optimisticKeys_exports);
-var import_config = __toESM(require("../../imports/config"), 1);
-var import_lib = require("../../lib");
-var import_types = require("../../lib/types");
-const keys = {};
-const callbacks = {};
-const objectIDMap = {};
-const optimisticKeys = (cache, callbackCache = callbacks, keyCache = keys, objectIDs = objectIDMap, invocationCounter = 1) => () => {
-  return {
-    async start(ctx, { next }) {
-      const optimisticResponse = ctx.stuff.optimisticResponse;
-      const newCtx = { ...ctx };
-      if (optimisticResponse && ctx.artifact.kind === import_types.ArtifactKind.Mutation && ctx.artifact.optimisticKeys) {
-        newCtx.stuff.mutationID = invocationCounter++;
-        addKeysToResponse({
-          selection: ctx.artifact.selection,
-          response: optimisticResponse,
-          callbackStore: callbackCache,
-          keyStore: keyCache,
-          objectIDs,
-          mutationID: newCtx.stuff.mutationID
-        });
-        newCtx.stuff.optimisticResponse = optimisticResponse;
-      }
-      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);
-      }
-      const pendingVariables = extractInputKeys(
-        ctx.variables ?? {},
-        callbackCache
-      );
-      if (Object.keys(pendingVariables).length === 0) {
-        return next(ctx);
-      }
-      for (const key of Object.keys(pendingVariables)) {
-        callbackCache[key].push((newID) => {
-          pendingVariables[key] = newID;
-          if (Object.values(pendingVariables).every((value) => value !== null)) {
-            next({
-              ...ctx,
-              variables: replaceKeyWithVariable(
-                { ...ctx.variables },
-                pendingVariables
-              )
-            });
-          }
-        });
-      }
-    },
-    afterNetwork(ctx, { value, resolve }) {
-      if (ctx.artifact.kind === import_types.ArtifactKind.Mutation && ctx.artifact.optimisticKeys && typeof ctx.stuff.mutationID !== "undefined") {
-        extractResponseKeys(
-          cache,
-          value.data ?? {},
-          ctx.artifact.selection,
-          keyCache,
-          ctx.stuff.mutationID,
-          {
-            onNewKey: (optimisticValue, realValue) => {
-              callbackCache[optimisticValue].forEach((cb) => {
-                cb(realValue);
-              });
-              delete callbackCache[optimisticValue];
-            },
-            onIDChange: (optimisticValue, realValue) => {
-              cache.registerKeyMap(optimisticValue, realValue);
-            }
-          }
-        );
-      }
-      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];
-        delete objectIDs[ctx.stuff.mutationID];
-      }
-      resolve(ctx);
-    }
-  };
-};
-function addKeysToResponse(args) {
-  let targetSelection = (0, import_lib.getFieldsForType)(
-    args.selection,
-    args.response["__typename"],
-    false
-  );
-  const newKeys = [];
-  for (const [field, { type, selection: fieldSelection, optimisticKey }] of Object.entries(
-    targetSelection
-  )) {
-    const value = args.response[field];
-    const pathSoFar = `${args.path ?? ""}.${field}`;
-    if (optimisticKey) {
-      let keyValue;
-      if (value) {
-        const { marshaled } = (0, import_lib.marshalSelection)({
-          data: { marshaled: value },
-          selection: {
-            fields: {
-              value: {
-                type,
-                keyRaw: "value"
-              }
-            }
-          }
-        });
-        keyValue = marshaled;
-      } else {
-        keyValue = generateKey(type);
-      }
-      newKeys.push(keyValue);
-      args.response[field] = keyValue;
-      args.callbackStore[keyValue] = [];
-      args.keyStore[args.mutationID] = {
-        [pathSoFar]: keyValue
-      };
-    }
-    if (fieldSelection) {
-      if (Array.isArray(value)) {
-        for (const [index, item] of flattenList(value).entries()) {
-          if (item && typeof item === "object" && !Array.isArray(item)) {
-            addKeysToResponse({
-              ...args,
-              selection: fieldSelection,
-              response: item,
-              type,
-              path: `${pathSoFar}[${index}]`
-            });
-          }
-        }
-      } else if (value && typeof value == "object") {
-        addKeysToResponse({
-          ...args,
-          selection: fieldSelection,
-          response: value,
-          type,
-          path: pathSoFar
-        });
-      }
-    }
-  }
-  if (newKeys.length > 0) {
-    const objID = `${args.type}:${(0, import_lib.computeID)(import_config.default, args.type ?? "", args.response)}`;
-    for (const key of newKeys) {
-      args.objectIDs[args.mutationID] = {
-        ...args.objectIDs[args.mutationID],
-        [key]: objID
-      };
-    }
-  }
-  return args.response;
-}
-function extractInputKeys(obj, store, found = {}) {
-  for (const value of Object.values(obj)) {
-    if (typeof value === "string" && store[value]) {
-      found[value] = null;
-    }
-    if (Array.isArray(value)) {
-      for (const item of flattenList(value)) {
-        if (item && typeof item === "object") {
-          extractInputKeys(item, store, found);
-        }
-      }
-    } else if (value && typeof value === "object") {
-      extractInputKeys(value, store, found);
-    }
-  }
-  return found;
-}
-function extractResponseKeys(cache, response, selection, keyMap, mutationID, events, objectIDs = objectIDMap, path = "", type = "") {
-  let targetSelection = (0, import_lib.getFieldsForType)(
-    selection,
-    response["__typename"],
-    false
-  );
-  let optimisticID = null;
-  for (const [field, value] of Object.entries(response)) {
-    const pathSoFar = `${path ?? ""}.${field}`;
-    if (typeof value === "string" && keyMap[mutationID][pathSoFar]) {
-      const newKey = keyMap[mutationID][pathSoFar];
-      events.onNewKey(newKey, value);
-      optimisticID = objectIDs[mutationID][newKey];
-    }
-    if (!selection || !targetSelection[field]) {
-      continue;
-    }
-    let { type: type2, selection: fieldSelection } = targetSelection[field];
-    if (Array.isArray(value)) {
-      for (const [index, item] of flattenList(value).entries()) {
-        if (item && typeof item === "object" && fieldSelection) {
-          extractResponseKeys(
-            cache,
-            item,
-            fieldSelection,
-            keyMap,
-            mutationID,
-            events,
-            objectIDs,
-            `${pathSoFar}[${index}]`,
-            type2
-          );
-        }
-      }
-    } else if (value && typeof value === "object" && fieldSelection) {
-      extractResponseKeys(
-        cache,
-        value,
-        fieldSelection,
-        keyMap,
-        mutationID,
-        events,
-        objectIDs,
-        pathSoFar,
-        type2
-      );
-    }
-  }
-  if (optimisticID) {
-    const id = (0, import_lib.computeID)(import_config.default, type, response);
-    events.onIDChange(`${type}:${id}`, optimisticID);
-    cache.write({
-      selection: {
-        fields: Object.fromEntries(
-          (0, import_lib.keyFieldsForType)(import_config.default, type).map((key) => [
-            key,
-            {
-              type: "scalar",
-              keyRaw: key
-            }
-          ])
-        )
-      },
-      parent: optimisticID,
-      data: response
-    });
-  }
-}
-function flattenList(source) {
-  const result = [];
-  const left = [...source];
-  while (left.length > 0) {
-    const head = left.shift();
-    if (Array.isArray(head)) {
-      left.push(...head);
-    } else {
-      result.push(head);
-    }
-  }
-  return result;
-}
-function replaceKeyWithVariable(variables, keys2) {
-  for (const [key, value] of Object.entries(variables)) {
-    if (typeof value === "string" && keys2[value]) {
-      variables[key] = keys2[value];
-    }
-    if (Array.isArray(value)) {
-      for (const item of flattenList(value)) {
-        if (item && typeof item === "object") {
-          replaceKeyWithVariable(item, keys2);
-        }
-      }
-    } else if (value && typeof value === "object") {
-      replaceKeyWithVariable(value, keys2);
-    }
-  }
-  return variables;
-}
-function generateKey(type) {
-  if (type === "Int") {
-    return (/* @__PURE__ */ new Date()).getTime();
-  }
-  if (type === "String") {
-    return (/* @__PURE__ */ new Date()).getTime().toString();
-  }
-  if (type === "ID") {
-    return (/* @__PURE__ */ new Date()).getTime().toString();
-  }
-  throw new Error(
-    `unsupported type for optimistic key: ${type}. Please provide a value in your mutation arguments.`
-  );
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  optimisticKeys
-});

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

@@ -1,2 +0,0 @@
-import type { Cache } from '../../cache/cache';
-export declare const query: (cache: Cache) => import("..").ClientPlugin;

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

@@ -1,93 +0,0 @@
-"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 query_exports = {};
-__export(query_exports, {
-  query: () => query
-});
-module.exports = __toCommonJS(query_exports);
-var import_types = require("../../lib/types");
-var import_utils = require("../utils");
-const query = (cache) => (0, import_utils.documentPlugin)(import_types.ArtifactKind.Query, function() {
-  let subscriptionSpec = null;
-  let lastVariables = null;
-  return {
-    start(ctx, { next }) {
-      const runtimeScalarPayload = {
-        session: ctx.session
-      };
-      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]) => {
-              const runtimeScalar = ctx.config.features?.runtimeScalars?.[type];
-              if (!runtimeScalar) {
-                return [field, type];
-              }
-              return [field, runtimeScalar.resolve(runtimeScalarPayload)];
-            }
-          )
-        ),
-        ...ctx.variables
-      };
-      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) {
-          cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
-        }
-        lastVariables = { ...marshalVariables(ctx) };
-        const variables = lastVariables;
-        subscriptionSpec = {
-          rootType: ctx.artifact.rootType,
-          selection: ctx.artifact.selection,
-          variables: () => variables,
-          set: (newValue) => {
-            resolve(ctx, {
-              data: newValue,
-              errors: null,
-              fetching: false,
-              partial: false,
-              stale: false,
-              source: import_types.DataSource.Cache,
-              variables: ctx.variables ?? {}
-            });
-          }
-        };
-        cache.subscribe(subscriptionSpec, lastVariables);
-      }
-      resolve(ctx);
-    },
-    cleanup() {
-      if (subscriptionSpec) {
-        cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
-        lastVariables = null;
-      }
-    }
-  };
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  query
-});

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

@@ -1,20 +0,0 @@
-import type { ClientPluginContext } from '../documentStore';
-export declare function subscription(factory: SubscriptionHandler): import("../documentStore").ClientPlugin;
-export type SubscriptionHandler = (ctx: ClientPluginContext) => SubscriptionClient;
-export type SubscriptionClient = {
-    subscribe: (payload: {
-        operationName?: string;
-        query: string;
-        variables?: Record<string, unknown>;
-        extensions?: Record<'persistedQuery', string> | Record<string, unknown>;
-    }, handlers: {
-        next: (payload: {
-            data?: {} | null;
-            errors?: readonly {
-                message: string;
-            }[];
-        }) => void;
-        error: (data: {}) => void;
-        complete: () => void;
-    }) => () => void;
-};

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

@@ -1,114 +0,0 @@
-"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, {
-  subscription: () => subscription
-});
-module.exports = __toCommonJS(subscription_exports);
-var import_deepEquals = require("../../lib/deepEquals");
-var import_types = require("../../lib/types");
-var import_utils = require("../utils");
-function subscription(factory) {
-  return (0, import_utils.documentPlugin)(import_types.ArtifactKind.Subscription, () => {
-    let clearSubscription = null;
-    let check = null;
-    return {
-      start(ctx, { resolve, next, initialValue }) {
-        if (typeof globalThis.window === "undefined") {
-          resolve(ctx, initialValue);
-          return;
-        }
-        next(ctx);
-      },
-      async 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;
-        if (sessionChange) {
-          await loadClient(ctx, factory);
-        }
-        clearSubscription?.();
-        clearSubscription = client.subscribe(
-          {
-            operationName: ctx.name,
-            query: ctx.text,
-            variables: marshalVariables(ctx)
-          },
-          {
-            next: ({ data, errors }) => {
-              resolve(ctx, {
-                data: data ?? null,
-                errors: [...errors ?? []],
-                fetching: false,
-                partial: true,
-                stale: false,
-                source: import_types.DataSource.Network,
-                variables: ctx.variables ?? {}
-              });
-            },
-            error(data) {
-              clearSubscription?.();
-              resolve(ctx, {
-                partial: true,
-                stale: false,
-                source: import_types.DataSource.Network,
-                data: null,
-                errors: [data],
-                fetching: false,
-                variables: ctx.variables ?? {}
-              });
-            },
-            complete() {
-            }
-          }
-        );
-      },
-      cleanup() {
-        clearSubscription?.();
-        check = null;
-      }
-    };
-  });
-}
-let pendingCreate = null;
-let client;
-function loadClient(ctx, factory) {
-  if (pendingCreate) {
-    return pendingCreate;
-  }
-  pendingCreate = new Promise((resolve) => {
-    client = factory(ctx);
-    resolve();
-    pendingCreate = null;
-  });
-  return pendingCreate;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  subscription
-});

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

@@ -1,15 +0,0 @@
-import { type HoudiniClientConstructorArgs } from '..';
-import type { DocumentArtifact, GraphQLObject } from '../../lib';
-import type { ClientPlugin, ClientPluginContext } from '../documentStore';
-import { DocumentStore } from '../documentStore';
-/**
- * Utilities for testing the cache plugin
- */
-export declare function createStore(args?: Partial<HoudiniClientConstructorArgs> & {
-    artifact?: DocumentArtifact;
-}): DocumentStore<any, any>;
-export declare function fakeFetch({ data, spy, onRequest, }: {
-    data?: any;
-    spy?: (ctx: ClientPluginContext) => void;
-    onRequest?: (variables: GraphQLObject, cb: () => void) => void;
-}): ClientPlugin;