houdini 0.18.3 → 0.19.1

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

@@ -0,0 +1,163 @@
+"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 list_exports = {};
+__export(list_exports, {
+  ListCollection: () => ListCollection
+});
+module.exports = __toCommonJS(list_exports);
+var import_lib = require("../lib");
+var import_cache = require("./cache");
+var import_record = require("./record");
+class ListCollection {
+  #parentID;
+  #allLists;
+  #when;
+  #cache;
+  #name;
+  constructor({
+    parentID,
+    allLists,
+    when,
+    cache,
+    name
+  }) {
+    this.#parentID = parentID;
+    this.#allLists = allLists;
+    this.#when = when;
+    this.#cache = cache;
+    this.#name = name;
+  }
+  append(...records) {
+    if (!this.#collection) {
+      return;
+    }
+    const { selection, data } = this.#listOperationPayload(records);
+    for (const entry of data) {
+      if (entry) {
+        this.#collection.append(selection, entry);
+      }
+    }
+  }
+  prepend(...records) {
+    if (!this.#collection) {
+      return;
+    }
+    const { selection, data } = this.#listOperationPayload(records);
+    for (const entry of data) {
+      if (entry) {
+        this.#collection.prepend(selection, entry);
+      }
+    }
+  }
+  toggle(where, ...records) {
+    if (!this.#collection) {
+      return;
+    }
+    const { selection, data } = this.#listOperationPayload(records);
+    for (const entry of data) {
+      if (entry) {
+        this.#collection.toggleElement(selection, entry, {}, where);
+      }
+    }
+  }
+  when(filter) {
+    if (!this.#collection) {
+      return this;
+    }
+    return new ListCollection({
+      parentID: this.#parentID,
+      allLists: this.#allLists,
+      when: this.#when,
+      cache: this.#cache,
+      name: this.#name
+    });
+  }
+  remove(...records) {
+    if (!this.#collection) {
+      return;
+    }
+    for (const record of records) {
+      if (record) {
+        this.#collection.remove(record.idFields);
+      }
+    }
+  }
+  *[Symbol.iterator]() {
+    for (const entry of this.#collection ?? []) {
+      yield entry;
+    }
+  }
+  get #collection() {
+    try {
+      const list = this.#cache._internal_unstable.list(
+        this.#name,
+        this.#parentID,
+        this.#allLists
+      );
+      if (this.#when) {
+        return list.when(this.#when);
+      }
+      return list;
+    } catch {
+      return null;
+    }
+  }
+  #listOperationPayload(records) {
+    const selection = {
+      abstractFields: {
+        fields: {},
+        typeMap: {}
+      }
+    };
+    const data = [];
+    for (const record of records) {
+      if (!(record instanceof import_record.Record)) {
+        throw new Error("You must provide a Record to a list operation");
+      }
+      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, record.type);
+      selection.abstractFields.fields[record.type] = keys.reduce(
+        (acc, key) => {
+          const keyInfo = (0, import_cache._typeInfo)(this.#cache, record.type, key);
+          return {
+            ...acc,
+            [key]: {
+              type: keyInfo.type,
+              keyRaw: key
+            }
+          };
+        },
+        {
+          __typename: {
+            type: "String",
+            keyRaw: "__typename"
+          }
+        }
+      );
+      data.push({ __typename: record.type, ...record.idFields });
+    }
+    return {
+      selection,
+      data
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ListCollection
+});

package/build/runtime-cjs/public/record.d.ts

@@ -0,0 +1,31 @@
+import { Cache } from './cache';
+import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
+export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
+    #private;
+    type: string;
+    idFields: {};
+    constructor({ cache, type, id, idFields, }: {
+        cache: Cache<Def>;
+        type: string;
+        idFields: {};
+        id: string;
+    });
+    set<Field extends TypeFieldNames<Def, Type>>({ field, args, value, }: {
+        field: Field;
+        args?: ArgType<Def, Type, Field>;
+        value: FieldType<Def, Type, Field>;
+    }): void;
+    get<Field extends TypeFieldNames<Def, Type>>({ field, args, }: {
+        field: Field;
+        args?: ArgType<Def, Type, Field>;
+    }): FieldType<Def, Type, Field>;
+    delete(): void;
+}
+export declare function computeKey({ field, args }: {
+    field: string;
+    args?: {
+        [key: string]: any;
+    };
+}): string;
+export declare const stringifyObjectWithNoQuotesOnKeys: (obj_from_json: {}) => string;
+export declare function marshalNestedList(list: any[]): any[];

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

@@ -0,0 +1,249 @@
+"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 record_exports = {};
+__export(record_exports, {
+  Record: () => Record,
+  computeKey: () => computeKey,
+  marshalNestedList: () => marshalNestedList,
+  stringifyObjectWithNoQuotesOnKeys: () => stringifyObjectWithNoQuotesOnKeys
+});
+module.exports = __toCommonJS(record_exports);
+var import_cache = require("../cache/cache");
+var import_lib = require("../lib");
+var import_cache2 = require("./cache");
+class Record {
+  #id;
+  #cache;
+  type;
+  idFields;
+  constructor({
+    cache,
+    type,
+    id,
+    idFields
+  }) {
+    this.#cache = cache;
+    this.#id = id;
+    this.type = type;
+    this.idFields = idFields;
+    if (id !== import_cache.rootID) {
+      for (const key of (0, import_lib.keyFieldsForType)(this.#cache.config, type)) {
+        if (!(key in idFields)) {
+          throw new Error("Missing key in idFields: " + key);
+        }
+      }
+    }
+  }
+  set({
+    field,
+    args,
+    value
+  }) {
+    this.#cache.validateInstabilityWarning();
+    const key = computeKey({ field, args });
+    const typeInfo = (0, import_cache2._typeInfo)(this.#cache, this.type, field);
+    let newValue;
+    if (typeInfo.link) {
+      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, typeInfo.type);
+      typeInfo.selection = {
+        fields: keys.reduce(
+          (acc, key2) => {
+            const keyInfo = (0, import_cache2._typeInfo)(this.#cache, typeInfo.type, key2);
+            return {
+              ...acc,
+              [key2]: {
+                type: keyInfo.type,
+                keyRaw: key2
+              }
+            };
+          },
+          {
+            __typename: {
+              type: "String",
+              keyRaw: "__typename"
+            }
+          }
+        )
+      };
+    }
+    if (!typeInfo.link) {
+      const fnMarshal = this.#cache.config.scalars?.[typeInfo.type]?.marshal;
+      if (fnMarshal) {
+        newValue = fnMarshal(value);
+      } else {
+        newValue = value;
+      }
+    } else if (value instanceof Record) {
+      newValue = {
+        ...value.idFields,
+        __typename: value.type
+      };
+    } else if (Array.isArray(value)) {
+      newValue = marshalNestedList(value);
+    } else if (value !== null) {
+      throw new Error("Value must be a RecordProxy if the field is a link to another record");
+    }
+    this.#cache._internal_unstable._internal_unstable.lifetimes.resetLifetime(this.#id, key);
+    this.#cache._internal_unstable.write({
+      parent: this.#id,
+      selection: {
+        fields: {
+          [field]: {
+            keyRaw: key,
+            ...typeInfo
+          }
+        }
+      },
+      data: {
+        [field]: newValue
+      }
+    });
+  }
+  get({
+    field,
+    args
+  }) {
+    this.#cache.validateInstabilityWarning();
+    const key = computeKey({ field, args });
+    const typeInfo = (0, import_cache2._typeInfo)(this.#cache, this.type, field);
+    if (typeInfo.link) {
+      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, typeInfo.type);
+      typeInfo.selection = {
+        fields: keys.reduce(
+          (acc, key2) => {
+            const keyInfo = (0, import_cache2._typeInfo)(this.#cache, typeInfo.type, key2);
+            return {
+              ...acc,
+              [key2]: {
+                type: keyInfo.type,
+                keyRaw: key2
+              }
+            };
+          },
+          {
+            __typename: {
+              type: "String",
+              keyRaw: "__typename"
+            }
+          }
+        )
+      };
+    }
+    const result = this.#cache._internal_unstable.read({
+      parent: this.#id,
+      selection: {
+        fields: {
+          [field]: {
+            keyRaw: key,
+            ...typeInfo
+          }
+        }
+      }
+    });
+    if (!typeInfo.link) {
+      return result.data?.[field] ?? (typeInfo.nullable ? null : void 0);
+    }
+    const data = result.data?.[field] || {};
+    let finalResult = unmarshalNestedList(
+      this.#cache,
+      !Array.isArray(data) ? [data] : data
+    ).map((val) => {
+      if (typeInfo.nullable && (val === null || Object.keys(val).length === 0)) {
+        return null;
+      }
+      return val;
+    });
+    return Array.isArray(data) ? finalResult : finalResult[0];
+  }
+  delete() {
+    this.#cache._internal_unstable.delete(this.#id);
+  }
+}
+function computeKey({ field, args }) {
+  const keys = Object.keys(args ?? {});
+  keys.sort();
+  return args && keys.length > 0 ? `${field}(${keys.map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(args[key])}`).join(", ")})` : field;
+}
+const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
+  if (Array.isArray(obj_from_json)) {
+    return `[${obj_from_json.map((obj) => `${stringifyObjectWithNoQuotesOnKeys(obj)}`).join(", ")}]`;
+  }
+  if (typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null) {
+    return JSON.stringify(obj_from_json).replace(/"([^"]+)":/g, "$1: ");
+  }
+  return `{${Object.keys(obj_from_json).map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`).join(", ")}}`;
+};
+function marshalNestedList(list) {
+  const newValue = [];
+  for (const inner of list) {
+    if (Array.isArray(inner)) {
+      newValue.push(marshalNestedList(inner));
+    } else if (inner instanceof Record) {
+      newValue.push({ ...inner.idFields, __typename: inner.type });
+    } else {
+      newValue.push(inner);
+    }
+  }
+  return newValue;
+}
+function unmarshalNestedList(cache, list) {
+  const newValue = [];
+  for (const inner of list) {
+    if (Array.isArray(inner)) {
+      newValue.push(unmarshalNestedList(cache, inner));
+    } else if (inner === null) {
+      newValue.push(null);
+    } else if (inner.__typename) {
+      const type = inner.__typename;
+      let recordID = cache._internal_unstable._internal_unstable.id(type, inner);
+      if (!recordID) {
+        throw new Error("todo");
+      }
+      const typename = cache._internal_unstable.read({
+        selection: {
+          fields: {
+            __typename: {
+              keyRaw: "__typename",
+              type: "String"
+            }
+          }
+        },
+        parent: recordID
+      }).data?.__typename;
+      newValue.push(
+        new Record({
+          cache,
+          type: type || typename,
+          idFields: inner,
+          id: recordID
+        })
+      );
+    } else {
+      newValue.push(inner);
+    }
+  }
+  return newValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Record,
+  computeKey,
+  marshalNestedList,
+  stringifyObjectWithNoQuotesOnKeys
+});

package/build/runtime-cjs/public/tests/test.d.ts

@@ -0,0 +1,114 @@
+import { Cache } from '../cache';
+import { Record } from '../record';
+type CacheTypeDef = {
+    types: {
+        __ROOT__: {
+            idFields: {};
+            fields: {
+                test: {
+                    type: number | null;
+                    args: never;
+                };
+                testDate: {
+                    type: Date;
+                    args: never;
+                };
+                viewer: {
+                    type: Record<CacheTypeDef, 'User'> | null;
+                    args: never;
+                };
+                pets: {
+                    type: (Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>)[];
+                    args: never;
+                };
+                listOfLists: {
+                    type: ((Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null | (null | Record<CacheTypeDef, 'User'>)[])[] | Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null)[];
+                    args: never;
+                };
+                users: {
+                    type: Record<CacheTypeDef, 'User'>[] | null;
+                    args: never;
+                };
+                pet: {
+                    type: Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>;
+                    args: never;
+                };
+            };
+        };
+        User: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                firstName: {
+                    type: string;
+                    args: never;
+                };
+                parent: {
+                    type: Record<CacheTypeDef, 'User'>;
+                    args: never;
+                };
+                id: {
+                    type: string;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+        Cat: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                name: {
+                    type: string | null;
+                    args: never;
+                };
+                parent: {
+                    type: Record<CacheTypeDef, 'User'> | null;
+                    args: never;
+                };
+                id: {
+                    type: string;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+        Ghost: {
+            idFields: {
+                id: string;
+            };
+            fields: {
+                name: {
+                    type: string | null;
+                    args: never;
+                };
+                __typename: {
+                    type: string;
+                    args: never;
+                };
+            };
+        };
+    };
+    lists: {
+        All_Pets: {
+            types: 'User' | 'Cat';
+            filters: never;
+        };
+        All_Users: {
+            types: 'User';
+            filters: {
+                foo?: string;
+            };
+        };
+    };
+};
+export declare const testCache: () => Cache<CacheTypeDef>;
+export {};

package/build/runtime-cjs/public/tests/test.js

@@ -0,0 +1,31 @@
+"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 test_exports = {};
+__export(test_exports, {
+  testCache: () => testCache
+});
+module.exports = __toCommonJS(test_exports);
+var import_test = require("../../../test");
+var import_cache = require("../../cache/cache");
+var import_cache2 = require("../cache");
+const testCache = () => new import_cache2.Cache(new import_cache.Cache((0, import_test.testConfigFile)()));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  testCache
+});

package/build/runtime-cjs/public/types.d.ts

@@ -0,0 +1,36 @@
+import type { Record } from './record';
+export type CacheTypeDef = {
+    types: {
+        [typeName: string]: {
+            idFields: {
+                [fieldName: string]: any;
+            };
+            fields: {
+                [fieldName: string]: {
+                    args: any;
+                    type: any;
+                };
+            };
+        };
+    };
+    lists: {
+        [listName: string]: {
+            types: any;
+            filters: any;
+        };
+    };
+};
+export type ValidTypes<Def extends CacheTypeDef> = keyof Def['types'];
+export type TypeFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['fields'];
+export type TypeFieldNames<Def extends CacheTypeDef, Type extends keyof Def['types']> = Extract<keyof TypeFields<Def, Type>, string>;
+export type TypeNames<Def extends CacheTypeDef> = Extract<Exclude<ValidTypes<Def>, '__ROOT__'>, string>;
+export type IDFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['idFields'];
+export type ProxyUnion<Def extends CacheTypeDef, U> = U extends null ? null : U extends TypeNames<Def> ? Record<Def, U> : never;
+export type FieldType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['type'];
+export type ArgType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['args'];
+export type ValidLists<Def extends CacheTypeDef> = Extract<keyof Def['lists'], string>;
+export type ListFilters<Def extends CacheTypeDef, ListName extends ValidLists<Def>> = Def['lists'][ListName]['filters'] extends any ? {
+    must?: Def['lists'][ListName]['filters'];
+    must_not?: Def['lists'][ListName]['filters'];
+} : never;
+export type ListType<Def extends CacheTypeDef, Name extends ValidLists<Def>> = ProxyUnion<Def, Def['lists'][Name]['types']>;

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

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/build/runtime-esm/cache/cache.d.ts

@@ -2,6 +2,7 @@ import { ConfigFile } from '../lib/config';
 import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
 import { ListCollection, ListManager } from './lists';
+import { SchemaManager } from './schema';
 import { InMemoryStorage, Layer, LayerID } from './storage';
 import { InMemorySubscriptions } from './subscription';
 export declare class Cache {
@@ -37,15 +38,17 @@ declare class CacheInternal {
     lists: ListManager;
     cache: Cache;
     lifetimes: GarbageCollector;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, }: {
+    schema: SchemaManager;
+    constructor({ storage, subscriptions, lists, cache, lifetimes, schema, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
+        schema: SchemaManager;
     });
     setConfig(config: ConfigFile): void;
-    writeSelection({ data, selection, variables, root, parent, applyUpdates, layer, toNotify, forceNotify, }: {
+    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, }: {
         data: {
             [key: string]: GraphQLValue;
         };