@gqloom/core 0.7.2 → 0.8.0

package/dist/index.cjs

@@ -20,31 +20,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BaseChainFactory: () => BaseChainFactory,
+  ChainResolver: () => ChainResolver,
   ContextMemoization: () => ContextMemoization,
   EasyDataLoader: () => EasyDataLoader,
+  FieldChainFactory: () => FieldChainFactory,
+  FieldFactoryWithResolve: () => FieldFactoryWithResolve,
   GraphQLSchemaLoom: () => GraphQLSchemaLoom,
   LoomObjectType: () => LoomObjectType,
+  MutationChainFactory: () => MutationChainFactory,
+  MutationFactoryWithResolve: () => MutationFactoryWithResolve,
   OPERATION_OBJECT_NAMES: () => OPERATION_OBJECT_NAMES,
-  ResolverOptionsMap: () => ResolverOptionsMap,
+  ObjectChainResolver: () => ObjectChainResolver,
+  QueryChainFactory: () => QueryChainFactory,
+  QueryFactoryWithResolve: () => QueryFactoryWithResolve,
   SYMBOLS: () => symbols_exports,
+  SubscriptionChainFactory: () => SubscriptionChainFactory,
   applyMiddlewares: () => applyMiddlewares,
-  baseResolver: () => baseResolver,
   capitalize: () => capitalize,
   collectName: () => collectName,
   collectNames: () => collectNames,
   compose: () => compose,
   createField: () => createField,
-  createFieldFactory: () => createFieldFactory,
   createInputParser: () => createInputParser,
-  createLoom: () => createLoom,
   createMemoization: () => createMemoization,
   createMutation: () => createMutation,
-  createMutationFactory: () => createMutationFactory,
   createQuery: () => createQuery,
-  createQueryFactory: () => createQueryFactory,
-  createResolverFactory: () => createResolverFactory,
   createSubscription: () => createSubscription,
-  createSubscriptionFactory: () => createSubscriptionFactory,
   deepMerge: () => deepMerge,
   defaultSubscriptionResolve: () => defaultSubscriptionResolve,
   ensureInputObjectType: () => ensureInputObjectType,
@@ -67,6 +69,7 @@ __export(src_exports, {
   mapValue: () => mapValue,
   markErrorLocation: () => markErrorLocation,
   markLocation: () => markLocation,
+  meta: () => meta,
   mutation: () => mutation,
   nonNullSilk: () => nonNullSilk,
   notNullish: () => notNullish,
@@ -91,231 +94,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/resolver/silk.ts
-var import_graphql2 = require("graphql");
-
-// src/schema/weaver-context.ts
-var import_graphql = require("graphql");
-
-// src/utils/symbols.ts
-var symbols_exports = {};
-__export(symbols_exports, {
-  CONTEXT_MEMORY_MAP_KEY: () => CONTEXT_MEMORY_MAP_KEY,
-  FIELD_HIDDEN: () => FIELD_HIDDEN,
-  GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
-  RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
-  WEAVER_CONFIG: () => WEAVER_CONFIG
-});
-var GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
-var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
-var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
-var CONTEXT_MEMORY_MAP_KEY = Symbol.for("gqloom.context-memory");
-var FIELD_HIDDEN = Symbol.for("gqloom.field-hidden");
-
-// src/schema/weaver-context.ts
-var ref;
-var names = /* @__PURE__ */ new WeakMap();
-function initWeaverContext() {
-  return {
-    id: initWeaverContext.increasingID++,
-    loomObjectMap: /* @__PURE__ */ new Map(),
-    loomUnionMap: /* @__PURE__ */ new Map(),
-    inputMap: /* @__PURE__ */ new Map(),
-    interfaceMap: /* @__PURE__ */ new Map(),
-    configs: /* @__PURE__ */ new Map(),
-    getConfig(key) {
-      return this.configs.get(key);
-    },
-    setConfig(config) {
-      const key = config[WEAVER_CONFIG];
-      this.configs.set(key, config);
-    },
-    deleteConfig(key) {
-      this.configs.delete(key);
-    },
-    names,
-    namedTypes: /* @__PURE__ */ new Map(),
-    memoNamedType(gqlTypeValue) {
-      const gqlType = gqlTypeValue;
-      if ((0, import_graphql.isObjectType)(gqlType) || (0, import_graphql.isUnionType)(gqlType) || (0, import_graphql.isEnumType)(gqlType) || (0, import_graphql.isScalarType)(gqlType)) {
-        this.namedTypes.set(gqlType.name, gqlType);
-      }
-      return gqlTypeValue;
-    },
-    getNamedType(name) {
-      return this.namedTypes.get(name);
-    },
-    vendorWeavers: /* @__PURE__ */ new Map()
-  };
-}
-initWeaverContext.increasingID = 1;
-var weaverContext = {
-  get id() {
-    return ref?.id;
-  },
-  get loomObjectMap() {
-    return ref?.loomObjectMap;
-  },
-  get loomUnionMap() {
-    return ref?.loomUnionMap;
-  },
-  get inputMap() {
-    return ref?.inputMap;
-  },
-  get interfaceMap() {
-    return ref?.interfaceMap;
-  },
-  get configs() {
-    return ref?.configs;
-  },
-  get vendorWeavers() {
-    return ref?.vendorWeavers;
-  },
-  getConfig(key) {
-    return ref?.getConfig(key);
-  },
-  setConfig(config) {
-    ref?.setConfig(config);
-  },
-  deleteConfig(key) {
-    ref?.deleteConfig(key);
-  },
-  get value() {
-    return ref;
-  },
-  useConfig(config, callback) {
-    const context = weaverContext.value ?? initWeaverContext();
-    context.setConfig(config);
-    const result = provideWeaverContext(callback, context);
-    context.deleteConfig(config[WEAVER_CONFIG]);
-    return result;
-  },
-  names,
-  getNamedType(name) {
-    return ref?.getNamedType(name);
-  },
-  memoNamedType(gqlType) {
-    return ref?.memoNamedType(gqlType) ?? gqlType;
-  },
-  GraphQLTypes: /* @__PURE__ */ new WeakMap(),
-  getGraphQLType(origin) {
-    return this.GraphQLTypes.get(origin);
-  },
-  memoGraphQLType(origin, gqlType) {
-    this.GraphQLTypes.set(origin, gqlType);
-    return gqlType;
-  }
-};
-function provideWeaverContext(func, value) {
-  const lastRef = ref;
-  ref = value;
-  try {
-    return func();
-  } finally {
-    ref = lastRef;
-  }
-}
-provideWeaverContext.inherit = (func) => {
-  const weaverContextRef = weaverContext.value;
-  return () => provideWeaverContext(func, weaverContextRef);
-};
-function collectNames(...namesList) {
-  const namesRecord = {};
-  for (const namesItem of namesList) {
-    for (const [name, schema] of Object.entries(namesItem)) {
-      names.set(schema, name);
-      namesRecord[name] = schema;
-    }
-  }
-  return namesRecord;
-}
-function collectName(name, schema) {
-  names.set(schema, name);
-  return schema;
-}
-
-// src/resolver/silk.ts
-function silk(type, validate = (value) => ({
-  value: value ?? void 0
-})) {
-  return {
-    [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
-    "~standard": {
-      version: 1,
-      vendor: "gqloom.silk",
-      validate
-    }
-  };
-}
-silk.parse = parseSilk;
-silk.getType = getGraphQLType;
-silk.nonNull = nonNullSilk;
-silk.list = listSilk;
-silk.nullable = nullableSilk;
-function nonNullSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull) {
-        return originType;
-      } else {
-        return new import_graphql2.GraphQLNonNull(originType);
-      }
-    }
-  };
-}
-function listSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      let originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull && originType.ofType instanceof import_graphql2.GraphQLList) {
-        originType = originType.ofType.ofType;
-      }
-      if (originType instanceof import_graphql2.GraphQLList) {
-        originType = originType.ofType;
-      }
-      return new import_graphql2.GraphQLNonNull(new import_graphql2.GraphQLList(originType));
-    }
-  };
-}
-function nullableSilk(origin) {
-  return {
-    ...origin,
-    [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull) {
-        return originType.ofType;
-      } else {
-        return originType;
-      }
-    }
-  };
-}
-function getGraphQLType(silk2) {
-  if (GET_GRAPHQL_TYPE in silk2 && silk2[GET_GRAPHQL_TYPE] != null)
-    return silk2[GET_GRAPHQL_TYPE]();
-  const vendorWeavers = weaverContext.vendorWeavers;
-  if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
-  const weaver = vendorWeavers.get(silk2["~standard"].vendor);
-  if (weaver == null)
-    throw new Error(
-      `Schema Weaver for ${silk2["~standard"].vendor} is not found`
-    );
-  return weaver.getGraphQLType(silk2);
-}
-function parseSilk(silk2, input) {
-  return silk2["~standard"].validate(input);
-}
-function isSilk(target) {
-  if (typeof target !== "object") return false;
-  if (target == null) return false;
-  if (GET_GRAPHQL_TYPE in target) return true;
-  if (!("~standard" in target)) return false;
-  return "vendor" in target["~standard"] && typeof target["~standard"].vendor === "string" && "version" in target["~standard"] && typeof target["~standard"].version === "number";
-}
-
 // src/utils/args.ts
 function getOperationOptions(resolveOrOptions) {
   if (typeof resolveOrOptions === "function") {
@@ -368,6 +146,25 @@ function compose(...lists) {
 
 // src/utils/context.ts
 var import_async_hooks = require("async_hooks");
+
+// src/utils/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  CONTEXT_MEMORY_MAP_KEY: () => CONTEXT_MEMORY_MAP_KEY,
+  FIELD_HIDDEN: () => FIELD_HIDDEN,
+  GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
+  IS_RESOLVER: () => IS_RESOLVER,
+  RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
+  WEAVER_CONFIG: () => WEAVER_CONFIG
+});
+var GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
+var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
+var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
+var IS_RESOLVER = Symbol.for("gqloom.is-resolver");
+var CONTEXT_MEMORY_MAP_KEY = Symbol.for("gqloom.context-memory");
+var FIELD_HIDDEN = Symbol.for("gqloom.field-hidden");
+
+// src/utils/context.ts
 function onlyMemoization() {
   return { memoization: /* @__PURE__ */ new WeakMap(), isMemoization: true };
 }
@@ -498,117 +295,328 @@ function deepMerge(...objects) {
           result[key] = deepMerge(result[key], value);
         }
       } else {
-        result[key] = value;
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function meta(data) {
+  return { "~meta": data };
+}
+
+// src/utils/string.ts
+function pascalCase(str) {
+  return str.split(/[\s-_]+/).map(
+    (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
+  ).join("");
+}
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+
+// src/utils/error.ts
+function markErrorLocation(error, ...locations) {
+  if (error instanceof Error) {
+    error.message = markLocation(error.message, ...locations);
+  }
+  return error;
+}
+function tryIn(func, ...locations) {
+  try {
+    return func();
+  } catch (error) {
+    throw markErrorLocation(error, ...locations);
+  }
+}
+function markLocation(message, ...locations) {
+  if (locations.length === 0) {
+    return message;
+  }
+  const [existingPrefix, newMessage] = (() => {
+    const existingPrefixPattern = /^\[(.*?)\]/;
+    const match = existingPrefixPattern.exec(message);
+    if (match) return [match[1], message.slice(match[0].length).trim()];
+    return [void 0, message];
+  })();
+  const combinedLocation = locations.concat(existingPrefix ? [existingPrefix] : []).join(".");
+  return `[${combinedLocation}] ${newMessage}`;
+}
+
+// src/utils/loader.ts
+var EasyDataLoader = class _EasyDataLoader {
+  constructor(batchLoadFn) {
+    this.batchLoadFn = batchLoadFn;
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  queue;
+  cache;
+  resolvers;
+  load(key) {
+    const existing = this.cache.get(key);
+    if (existing) return existing;
+    const promise = new Promise((resolve, reject) => {
+      this.queue.push(key);
+      this.resolvers.set(key, [resolve, reject]);
+      this.nextTickBatchLoad();
+    });
+    this.cache.set(key, promise);
+    return promise;
+  }
+  clear() {
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  clearByKey(key) {
+    this.queue = this.queue.filter((k) => k !== key);
+    this.cache.delete(key);
+    this.resolvers.delete(key);
+  }
+  async executeBatchLoad() {
+    if (this.queue.length === 0) return;
+    const [keys, resolvers] = [this.queue, this.resolvers];
+    this.queue = [];
+    this.resolvers = /* @__PURE__ */ new Map();
+    try {
+      const list = await this.batchLoadFn(keys);
+      for (let i = 0; i < list.length; i++) {
+        const data = list[i];
+        const resolve = resolvers.get(keys[i])?.[0];
+        const reject = resolvers.get(keys[i])?.[1];
+        if (data instanceof Error) {
+          reject?.(data);
+        } else {
+          resolve?.(data);
+        }
+      }
+    } catch (error) {
+      for (const key of keys) {
+        const reject = resolvers.get(key)?.[1];
+        reject?.(error);
+      }
+    }
+  }
+  nextTickPromise;
+  nextTickBatchLoad() {
+    this.nextTickPromise ??= _EasyDataLoader.nextTick().then(() => this.executeBatchLoad()).finally(() => this.nextTickPromise = void 0);
+    return this.nextTickPromise;
+  }
+  static nextTick() {
+    return new Promise((resolve) => setTimeout(resolve));
+  }
+};
+
+// src/resolver/silk.ts
+var import_graphql2 = require("graphql");
+
+// src/schema/weaver-context.ts
+var import_graphql = require("graphql");
+var ref;
+var names = /* @__PURE__ */ new WeakMap();
+function initWeaverContext() {
+  return {
+    id: initWeaverContext.increasingID++,
+    loomObjectMap: /* @__PURE__ */ new Map(),
+    loomUnionMap: /* @__PURE__ */ new Map(),
+    inputMap: /* @__PURE__ */ new Map(),
+    interfaceMap: /* @__PURE__ */ new Map(),
+    configs: /* @__PURE__ */ new Map(),
+    getConfig(key) {
+      return this.configs.get(key);
+    },
+    setConfig(config) {
+      const key = config[WEAVER_CONFIG];
+      this.configs.set(key, config);
+    },
+    deleteConfig(key) {
+      this.configs.delete(key);
+    },
+    names,
+    namedTypes: /* @__PURE__ */ new Map(),
+    memoNamedType(gqlTypeValue) {
+      const gqlType = gqlTypeValue;
+      if ((0, import_graphql.isObjectType)(gqlType) || (0, import_graphql.isUnionType)(gqlType) || (0, import_graphql.isEnumType)(gqlType) || (0, import_graphql.isScalarType)(gqlType)) {
+        this.namedTypes.set(gqlType.name, gqlType);
+      }
+      return gqlTypeValue;
+    },
+    getNamedType(name) {
+      return this.namedTypes.get(name);
+    },
+    vendorWeavers: /* @__PURE__ */ new Map()
+  };
+}
+initWeaverContext.increasingID = 1;
+var weaverContext = {
+  get id() {
+    return ref?.id;
+  },
+  get loomObjectMap() {
+    return ref?.loomObjectMap;
+  },
+  get loomUnionMap() {
+    return ref?.loomUnionMap;
+  },
+  get inputMap() {
+    return ref?.inputMap;
+  },
+  get interfaceMap() {
+    return ref?.interfaceMap;
+  },
+  get configs() {
+    return ref?.configs;
+  },
+  get vendorWeavers() {
+    return ref?.vendorWeavers;
+  },
+  getConfig(key) {
+    return ref?.getConfig(key);
+  },
+  setConfig(config) {
+    ref?.setConfig(config);
+  },
+  deleteConfig(key) {
+    ref?.deleteConfig(key);
+  },
+  get value() {
+    return ref;
+  },
+  useConfig(config, callback) {
+    const context = weaverContext.value ?? initWeaverContext();
+    context.setConfig(config);
+    const result = provideWeaverContext(callback, context);
+    context.deleteConfig(config[WEAVER_CONFIG]);
+    return result;
+  },
+  names,
+  getNamedType(name) {
+    return ref?.getNamedType(name);
+  },
+  memoNamedType(gqlType) {
+    return ref?.memoNamedType(gqlType) ?? gqlType;
+  },
+  GraphQLTypes: /* @__PURE__ */ new WeakMap(),
+  getGraphQLType(origin) {
+    return this.GraphQLTypes.get(origin);
+  },
+  memoGraphQLType(origin, gqlType) {
+    this.GraphQLTypes.set(origin, gqlType);
+    return gqlType;
+  }
+};
+function provideWeaverContext(func, value) {
+  const lastRef = ref;
+  ref = value;
+  try {
+    return func();
+  } finally {
+    ref = lastRef;
+  }
+}
+provideWeaverContext.inherit = (func) => {
+  const weaverContextRef = weaverContext.value;
+  return () => provideWeaverContext(func, weaverContextRef);
+};
+function collectNames(...namesList) {
+  const namesRecord = {};
+  for (const namesItem of namesList) {
+    for (const [name, schema] of Object.entries(namesItem)) {
+      names.set(schema, name);
+      namesRecord[name] = schema;
+    }
+  }
+  return namesRecord;
+}
+function collectName(name, schema) {
+  names.set(schema, name);
+  return schema;
+}
+
+// src/resolver/silk.ts
+function silk(type, validate = (value) => ({
+  value: value ?? void 0
+})) {
+  return {
+    [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
+    "~standard": {
+      version: 1,
+      vendor: "gqloom.silk",
+      validate
+    }
+  };
+}
+silk.parse = parseSilk;
+silk.getType = getGraphQLType;
+silk.nonNull = nonNullSilk;
+silk.list = listSilk;
+silk.nullable = nullableSilk;
+function nonNullSilk(origin) {
+  return {
+    ...origin,
+    [GET_GRAPHQL_TYPE]: () => {
+      const originType = getGraphQLType(origin);
+      if (originType instanceof import_graphql2.GraphQLNonNull) {
+        return originType;
+      } else {
+        return new import_graphql2.GraphQLNonNull(originType);
+      }
+    }
+  };
+}
+function listSilk(origin) {
+  return {
+    ...origin,
+    [GET_GRAPHQL_TYPE]: () => {
+      let originType = getGraphQLType(origin);
+      if (originType instanceof import_graphql2.GraphQLNonNull && originType.ofType instanceof import_graphql2.GraphQLList) {
+        originType = originType.ofType.ofType;
+      }
+      if (originType instanceof import_graphql2.GraphQLList) {
+        originType = originType.ofType;
+      }
+      return new import_graphql2.GraphQLNonNull(new import_graphql2.GraphQLList(originType));
+    }
+  };
+}
+function nullableSilk(origin) {
+  return {
+    ...origin,
+    [GET_GRAPHQL_TYPE]: () => {
+      const originType = getGraphQLType(origin);
+      if (originType instanceof import_graphql2.GraphQLNonNull) {
+        return originType.ofType;
+      } else {
+        return originType;
       }
     }
-  }
-  return result;
-}
-
-// src/utils/string.ts
-function pascalCase(str) {
-  return str.split(/[\s-_]+/).map(
-    (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
-  ).join("");
-}
-function capitalize(str) {
-  return str.slice(0, 1).toUpperCase() + str.slice(1);
+  };
 }
-
-// src/utils/error.ts
-function markErrorLocation(error, ...locations) {
-  if (error instanceof Error) {
-    error.message = markLocation(error.message, ...locations);
-  }
-  return error;
+function getGraphQLType(silk2) {
+  if (GET_GRAPHQL_TYPE in silk2 && silk2[GET_GRAPHQL_TYPE] != null)
+    return silk2[GET_GRAPHQL_TYPE]();
+  const vendorWeavers = weaverContext.vendorWeavers;
+  if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
+  const weaver = vendorWeavers.get(silk2["~standard"].vendor);
+  if (weaver == null)
+    throw new Error(
+      `Schema Weaver for ${silk2["~standard"].vendor} is not found`
+    );
+  return weaver.getGraphQLType(silk2);
 }
-function tryIn(func, ...locations) {
-  try {
-    return func();
-  } catch (error) {
-    throw markErrorLocation(error, ...locations);
-  }
+function parseSilk(silk2, input) {
+  return silk2["~standard"].validate(input);
 }
-function markLocation(message, ...locations) {
-  if (locations.length === 0) {
-    return message;
-  }
-  const [existingPrefix, newMessage] = (() => {
-    const existingPrefixPattern = /^\[(.*?)\]/;
-    const match = existingPrefixPattern.exec(message);
-    if (match) return [match[1], message.slice(match[0].length).trim()];
-    return [void 0, message];
-  })();
-  const combinedLocation = locations.concat(existingPrefix ? [existingPrefix] : []).join(".");
-  return `[${combinedLocation}] ${newMessage}`;
+function isSilk(target) {
+  if (typeof target !== "object") return false;
+  if (target == null) return false;
+  if (GET_GRAPHQL_TYPE in target) return true;
+  if (!("~standard" in target)) return false;
+  return "vendor" in target["~standard"] && typeof target["~standard"].vendor === "string" && "version" in target["~standard"] && typeof target["~standard"].version === "number";
 }
 
-// src/utils/loader.ts
-var EasyDataLoader = class _EasyDataLoader {
-  constructor(batchLoadFn) {
-    this.batchLoadFn = batchLoadFn;
-    this.queue = [];
-    this.cache = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-  }
-  queue;
-  cache;
-  resolvers;
-  load(key) {
-    const existing = this.cache.get(key);
-    if (existing) return existing;
-    const promise = new Promise((resolve, reject) => {
-      this.queue.push(key);
-      this.resolvers.set(key, [resolve, reject]);
-      this.nextTickBatchLoad();
-    });
-    this.cache.set(key, promise);
-    return promise;
-  }
-  clear() {
-    this.queue = [];
-    this.cache = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-  }
-  clearByKey(key) {
-    this.queue = this.queue.filter((k) => k !== key);
-    this.cache.delete(key);
-    this.resolvers.delete(key);
-  }
-  async executeBatchLoad() {
-    if (this.queue.length === 0) return;
-    const [keys, resolvers] = [this.queue, this.resolvers];
-    this.queue = [];
-    this.resolvers = /* @__PURE__ */ new Map();
-    try {
-      const list = await this.batchLoadFn(keys);
-      for (let i = 0; i < list.length; i++) {
-        const data = list[i];
-        const resolve = resolvers.get(keys[i])?.[0];
-        const reject = resolvers.get(keys[i])?.[1];
-        if (data instanceof Error) {
-          reject?.(data);
-        } else {
-          resolve?.(data);
-        }
-      }
-    } catch (error) {
-      for (const key of keys) {
-        const reject = resolvers.get(key)?.[1];
-        reject?.(error);
-      }
-    }
-  }
-  nextTickPromise;
-  nextTickBatchLoad() {
-    this.nextTickPromise ??= _EasyDataLoader.nextTick().then(() => this.executeBatchLoad()).finally(() => this.nextTickPromise = void 0);
-    return this.nextTickPromise;
-  }
-  static nextTick() {
-    return new Promise((resolve) => setTimeout(resolve));
-  }
-};
-
 // src/resolver/input.ts
 var import_graphql3 = require("graphql");
 function createInputParser(schema, value) {
@@ -623,6 +631,9 @@ function createInputParser(schema, value) {
     get: () => result,
     set: (value2) => result = value2
   });
+  Object.defineProperty(parse, "getResult", {
+    value: async () => getStandardValue(await parse())
+  });
   return parse;
 }
 function parseInputValue(inputSchema, input) {
@@ -702,9 +713,6 @@ var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
   clone(options) {
     return new _FieldChainFactory({ ...this.options, ...options });
   }
-  use(...middlewares) {
-    return super.use(...middlewares);
-  }
   output(output) {
     return new _FieldChainFactory({ ...this.options, output });
   }
@@ -712,11 +720,44 @@ var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
     return new _FieldChainFactory({ ...this.options, input });
   }
   resolve(resolve) {
-    return createField(this.options?.output, {
+    if (!this.options?.output) throw new Error("Output is required");
+    return createField(this.options.output, {
       ...this.options,
       resolve
     });
   }
+  load(resolve) {
+    if (!this.options?.output) throw new Error("Output is required");
+    const useUnifiedParseInput = createMemoization(() => ({ current: void 0 }));
+    const useUserLoader = createMemoization(
+      () => new EasyDataLoader(
+        async (parents) => resolve(
+          parents,
+          await useUnifiedParseInput().current?.getResult()
+        )
+      )
+    );
+    const operation = "field";
+    return meta({
+      ...getFieldOptions(this.options),
+      operation,
+      input: this.options.input,
+      output: this.options.output,
+      resolve: async (parent, inputValue, extraOptions) => {
+        const unifiedParseInput = useUnifiedParseInput();
+        unifiedParseInput.current ??= createInputParser(
+          this.options?.input,
+          inputValue
+        );
+        const parseInput = unifiedParseInput.current;
+        return applyMiddlewares(
+          compose(extraOptions?.middlewares, this.options?.middlewares),
+          async () => useUserLoader().load(parent),
+          { parseInput, parent, outputSilk: this.output, operation }
+        );
+      }
+    });
+  }
 };
 var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
   static methods() {
@@ -731,9 +772,6 @@ var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
   clone(options) {
     return new _QueryChainFactory({ ...this.options, ...options });
   }
-  use(...middlewares) {
-    return super.use(...middlewares);
-  }
   output(output) {
     return new _QueryChainFactory({ ...this.options, output });
   }
@@ -741,7 +779,8 @@ var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
     return new _QueryChainFactory({ ...this.options, input });
   }
   resolve(resolve) {
-    return createQuery(this.options?.output, {
+    if (!this.options?.output) throw new Error("Output is required");
+    return createQuery(this.options.output, {
       ...this.options,
       resolve
     });
@@ -760,9 +799,6 @@ var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory
   clone(options) {
     return new _MutationChainFactory({ ...this.options, ...options });
   }
-  use(...middlewares) {
-    return super.use(...middlewares);
-  }
   output(output) {
     return new _MutationChainFactory({ ...this.options, output });
   }
@@ -770,7 +806,8 @@ var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory
     return new _MutationChainFactory({ ...this.options, input });
   }
   resolve(resolve) {
-    return createMutation(this.options?.output, {
+    if (!this.options?.output) throw new Error("Output is required");
+    return createMutation(this.options.output, {
       ...this.options,
       resolve
     });
@@ -789,9 +826,6 @@ var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChain
   clone(options) {
     return new _SubscriptionChainFactory({ ...this.options, ...options });
   }
-  use(...middlewares) {
-    return super.use(...middlewares);
-  }
   output(output) {
     return new _SubscriptionChainFactory({ ...this.options, output });
   }
@@ -800,14 +834,16 @@ var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChain
   }
   subscribe(subscribe) {
     const options = this.options;
-    const subscription2 = createSubscription(options?.output, {
+    const output = this.options?.output;
+    if (!output) throw new Error("Output is required");
+    const subscription2 = createSubscription(output, {
       ...options,
       subscribe
     });
-    const subscriptionResolve = subscription2.resolve;
+    const subscriptionResolve = subscription2["~meta"].resolve;
     const resolve = (...args) => {
       if (args.length === 1 && typeof args[0] === "function") {
-        return createSubscription(options?.output, {
+        return createSubscription(output, {
           ...options,
           resolve: args[0],
           subscribe
@@ -818,6 +854,66 @@ var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChain
     return Object.assign(subscription2, { resolve });
   }
 };
+var QueryFactoryWithResolve = class _QueryFactoryWithResolve extends BaseChainFactory {
+  constructor(output, options) {
+    super(options);
+    this.output = output;
+    this.options = options;
+  }
+  get "~meta"() {
+    return loom.query(this.output, this.options)["~meta"];
+  }
+  clone(options) {
+    return new _QueryFactoryWithResolve(this.output, {
+      ...this.options,
+      ...options
+    });
+  }
+  input(input) {
+    return new _QueryFactoryWithResolve(this.output, {
+      ...this.options,
+      input
+    });
+  }
+};
+var MutationFactoryWithResolve = class _MutationFactoryWithResolve extends BaseChainFactory {
+  constructor(output, options) {
+    super(options);
+    this.output = output;
+    this.options = options;
+  }
+  get "~meta"() {
+    return loom.mutation(this.output, this.options)["~meta"];
+  }
+  clone(options) {
+    return new _MutationFactoryWithResolve(this.output, {
+      ...this.options,
+      ...options
+    });
+  }
+  input(input) {
+    return new _MutationFactoryWithResolve(this.output, {
+      ...this.options,
+      input
+    });
+  }
+};
+var FieldFactoryWithResolve = class _FieldFactoryWithResolve extends BaseChainFactory {
+  constructor(output, options) {
+    super(options);
+    this.output = output;
+    this.options = options;
+  }
+  get "~meta"() {
+    return loom.field(this.output, this.options)["~meta"];
+  }
+  clone(options) {
+    return new _FieldFactoryWithResolve(this.output, {
+      ...this.options,
+      ...options
+    });
+  }
+};
 
 // src/resolver/resolver.ts
 var createQuery = (output, resolveOrOptions) => {
@@ -825,8 +921,8 @@ var createQuery = (output, resolveOrOptions) => {
     return new QueryChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const type = "query";
-  return {
+  const operation = "query";
+  return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
@@ -835,11 +931,11 @@ var createQuery = (output, resolveOrOptions) => {
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
         async () => options.resolve(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, type }
+        { parseInput, parent: void 0, outputSilk: output, operation }
       );
     },
-    type
-  };
+    operation
+  });
 };
 var query = Object.assign(
   createQuery,
@@ -850,8 +946,8 @@ var createMutation = (output, resolveOrOptions) => {
     return new MutationChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const type = "mutation";
-  return {
+  const operation = "mutation";
+  return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
@@ -860,11 +956,11 @@ var createMutation = (output, resolveOrOptions) => {
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
         async () => options.resolve(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, type }
+        { parseInput, parent: void 0, outputSilk: output, operation }
       );
     },
-    type
-  };
+    operation
+  });
 };
 var mutation = Object.assign(
   createMutation,
@@ -875,8 +971,8 @@ var createField = (output, resolveOrOptions) => {
     return new FieldChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const type = "field";
-  return {
+  const operation = "field";
+  return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
@@ -885,11 +981,11 @@ var createField = (output, resolveOrOptions) => {
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
         async () => options.resolve(parent, getStandardValue(await parseInput())),
-        { parseInput, parent, outputSilk: output, type }
+        { parseInput, parent, outputSilk: output, operation }
       );
     },
-    type
-  };
+    operation
+  });
 };
 var field = Object.assign(
   createField,
@@ -897,13 +993,13 @@ var field = Object.assign(
   FieldChainFactory.methods()
 );
 var defaultSubscriptionResolve = (source) => source;
-var createSubscription = (output, subscribeOrOptions) => {
+function createSubscription(output, subscribeOrOptions) {
   if (subscribeOrOptions == null) {
     return new SubscriptionChainFactory({ output });
   }
   const options = getSubscriptionOptions(subscribeOrOptions);
-  const type = "subscription";
-  return {
+  const operation = "subscription";
+  return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
@@ -915,62 +1011,66 @@ var createSubscription = (output, subscribeOrOptions) => {
           options.middlewares
         ),
         async () => options.subscribe(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, type }
+        { parseInput, parent: void 0, outputSilk: output, operation }
       );
     },
     resolve: options.resolve ?? defaultSubscriptionResolve,
-    type
-  };
-};
+    operation
+  });
+}
 var subscription = Object.assign(
   createSubscription,
   SubscriptionChainFactory.methods()
 );
-var ResolverOptionsMap = /* @__PURE__ */ new WeakMap();
-function baseResolver(operations, options) {
-  const record = {};
-  Object.entries(operations).forEach(([name, operation]) => {
-    record[name] = extraOperationOptions(operation, options);
-  });
-  if (options) ResolverOptionsMap.set(record, options);
-  return record;
-}
-function extraOperationOptions(operation, options) {
+function extraOperationOptions(field2, options) {
+  if (typeof field2 === "symbol") return field2;
   const composeMiddlewares = (extraOptions) => compose(extraOptions?.middlewares, options?.middlewares);
-  if (typeof operation === "symbol") return operation;
-  switch (operation.type) {
+  switch (field2["~meta"].operation) {
     case "field":
       return {
-        ...operation,
-        resolve: (parent, input, extraOptions) => operation.resolve(parent, input, {
-          ...extraOptions,
-          middlewares: composeMiddlewares(extraOptions)
-        })
+        ...field2,
+        "~meta": {
+          ...field2["~meta"],
+          resolve: (parent, input, extraOptions) => field2["~meta"].resolve(parent, input, {
+            ...extraOptions,
+            middlewares: composeMiddlewares(extraOptions)
+          })
+        }
       };
     case "subscription":
       return {
-        ...operation,
-        subscribe: (input, extraOptions) => operation.subscribe(input, {
-          ...extraOptions,
-          middlewares: composeMiddlewares(extraOptions)
-        })
+        ...field2,
+        "~meta": {
+          ...field2["~meta"],
+          subscribe: (input, extraOptions) => field2["~meta"].subscribe(
+            input,
+            {
+              ...extraOptions,
+              middlewares: composeMiddlewares(extraOptions)
+            }
+          )
+        }
       };
     default:
       return {
-        ...operation,
-        resolve: (input, extraOptions) => operation.resolve(input, {
-          ...extraOptions,
-          middlewares: composeMiddlewares(extraOptions)
-        })
+        ...field2,
+        "~meta": {
+          ...field2["~meta"],
+          resolve: (input, extraOptions) => field2["~meta"].resolve(input, {
+            ...extraOptions,
+            middlewares: composeMiddlewares(extraOptions)
+          })
+        }
       };
   }
 }
 var resolver = Object.assign(
-  baseResolver,
+  (operations, options) => new ChainResolver(operations, options),
   {
-    of: (parent, operations, options) => baseResolver(
+    of: (parent, operations, options) => new ObjectChainResolver(
+      parent,
       operations,
-      { ...options, parent }
+      options
     )
   }
 );
@@ -981,93 +1081,69 @@ var loom = {
   subscription,
   mutation
 };
-
-// src/helper/create-loom.ts
-function toSilkInput(schema, toSilk, isSchema) {
-  if (schema == null) {
-    return schema;
+var ChainResolver = class {
+  meta;
+  constructor(fields, options) {
+    this.meta = {
+      [IS_RESOLVER]: true,
+      fields,
+      options
+    };
   }
-  if (isSchema(schema)) {
-    return toSilk(schema);
+  get "~meta"() {
+    const fields = {};
+    Object.entries(this.meta.fields).forEach(([name, field2]) => {
+      if (field2 === FIELD_HIDDEN) {
+        fields[name] = field2;
+      } else {
+        fields[name] = extraOperationOptions(field2, this.meta.options);
+      }
+    });
+    return {
+      ...this.meta,
+      fields
+    };
   }
-  const record = {};
-  for (const [key, value] of Object.entries(schema)) {
-    record[key] = toSilk(value);
+  use(...middlewares) {
+    this.meta.options ??= {};
+    this.meta.options.middlewares ??= [];
+    this.meta.options.middlewares.push(...middlewares);
+    return this;
   }
-  return record;
-}
-function createResolverFactory(toSilk) {
-  return Object.assign(baseResolver, {
-    of: (parent, operations, options) => baseResolver(
-      operations,
-      { ...options, parent: toSilk(parent) }
-    )
-  });
-}
-function createFieldFactory(toSilk, isSchema) {
-  const baseFieldFunc = (output, resolveOrOptions) => {
-    if (resolveOrOptions == null) {
-      return new FieldChainFactory({ output: toSilk(output) });
-    }
-    const options = getOperationOptions(
-      resolveOrOptions
-    );
-    return field(toSilk(output), {
-      ...options,
-      input: toSilkInput(options.input, toSilk, isSchema)
-    });
-  };
-  return Object.assign(
-    baseFieldFunc,
-    { hidden: FIELD_HIDDEN },
-    FieldChainFactory.methods()
-  );
-}
-function createQueryFactory(toSilk, isSchema) {
-  return (output, resolveOrOptions) => {
-    if (resolveOrOptions == null) {
-      return new QueryChainFactory({ output: toSilk(output) });
-    }
-    const options = getOperationOptions(resolveOrOptions);
-    return query(toSilk(output), {
-      ...options,
-      input: toSilkInput(options.input, toSilk, isSchema)
-    });
-  };
-}
-function createMutationFactory(toSilk, isSchema) {
-  return (output, resolveOrOptions) => {
-    if (resolveOrOptions == null) {
-      return new MutationChainFactory({ output: toSilk(output) });
-    }
-    const options = getOperationOptions(resolveOrOptions);
-    return mutation(toSilk(output), {
-      ...options,
-      input: toSilkInput(options.input, toSilk, isSchema)
-    });
-  };
-}
-function createSubscriptionFactory(toSilk, isSchema) {
-  return (output, resolveOrOptions) => {
-    if (resolveOrOptions == null) {
-      return new SubscriptionChainFactory({ output: toSilk(output) });
-    }
-    const options = getSubscriptionOptions(resolveOrOptions);
-    return subscription(toSilk(output), {
-      ...options,
-      input: toSilkInput(options.input, toSilk, isSchema)
+  toExecutor() {
+    const fields = this["~meta"].fields;
+    const executor = {};
+    Object.entries(fields).forEach(([name, field2]) => {
+      if (field2 === FIELD_HIDDEN) return;
+      executor[name] = field2["~meta"].resolve;
     });
-  };
-}
-function createLoom(toSilk, isSchema) {
-  return {
-    query: createQueryFactory(toSilk, isSchema),
-    mutation: createMutationFactory(toSilk, isSchema),
-    field: createFieldFactory(toSilk, isSchema),
-    resolver: createResolverFactory(toSilk),
-    subscription: createSubscriptionFactory(toSilk, isSchema)
-  };
-}
+    return executor;
+  }
+};
+var ObjectChainResolver = class extends ChainResolver {
+  meta;
+  constructor(parent, fields, options) {
+    super(fields, options);
+    this.meta = {
+      [IS_RESOLVER]: true,
+      fields,
+      parent,
+      options
+    };
+  }
+  get "~meta"() {
+    return super["~meta"];
+  }
+  extensions(extensions) {
+    this.meta.options ??= {};
+    this.meta.options.extensions ??= {};
+    this.meta.options.extensions = {
+      ...this.meta.options.extensions,
+      ...extensions
+    };
+    return this;
+  }
+};
 
 // src/schema/object.ts
 var import_graphql5 = require("graphql");
@@ -1249,13 +1325,13 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
   toFieldConfig(field2, fieldName) {
     try {
       const outputType = this.getCacheType(
-        getGraphQLType(field2.output),
+        getGraphQLType(field2["~meta"].output),
         fieldName
       );
       return {
         ...extract(field2),
         type: outputType,
-        args: inputToArgs(field2.input, {
+        args: inputToArgs(field2["~meta"].input, {
           fieldName: fieldName ? parentName(this.name) + fieldName : void 0
         }),
         ...this.provideForResolve(field2),
@@ -1266,27 +1342,31 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
     }
   }
   provideForResolve(field2) {
-    if (field2?.resolve == null) return;
-    if (field2.resolve === defaultSubscriptionResolve)
+    if (field2?.["~meta"]?.resolve == null) return;
+    if (field2["~meta"].resolve === defaultSubscriptionResolve)
       return { resolve: defaultSubscriptionResolve };
-    const resolve = field2.type === "field" ? (root, args, context, info) => resolverPayloadStorage.run(
+    const resolve = field2["~meta"].operation === "field" ? (root, args, context, info) => resolverPayloadStorage.run(
       { root, args, context, info, field: field2 },
-      () => field2.resolve(root, args, this.resolverOptions)
-    ) : field2.type === "subscription" ? (root, args, context, info) => resolverPayloadStorage.run(
+      () => field2["~meta"].resolve(root, args, this.resolverOptions)
+    ) : field2["~meta"].operation === "subscription" ? (root, args, context, info) => resolverPayloadStorage.run(
       { root, args, context, info, field: field2 },
-      () => field2.resolve(root, args)
+      () => field2["~meta"].resolve(root, args)
     ) : (root, args, context, info) => resolverPayloadStorage.run(
       { root, args, context, info, field: field2 },
-      () => field2.resolve(args, this.resolverOptions)
+      () => field2["~meta"].resolve(args, this.resolverOptions)
     );
     return { resolve };
   }
   provideForSubscribe(field2) {
-    if (field2?.subscribe == null) return;
+    if (field2?.["~meta"]?.subscribe == null)
+      return;
     return {
       subscribe: (root, args, context, info) => resolverPayloadStorage.run(
         { root, args, context, info, field: field2 },
-        () => field2.subscribe?.(args, this.resolverOptions)
+        () => field2["~meta"].subscribe?.(
+          args,
+          this.resolverOptions
+        )
       )
     };
   }
@@ -1298,11 +1378,8 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
     return { resolverOptions, weaverContext: weaverContext2 };
   }
 };
-function extract({
-  deprecationReason,
-  description,
-  extensions
-}) {
+function extract(field2) {
+  const { deprecationReason, description, extensions } = field2["~meta"];
   return {
     description,
     deprecationReason,
@@ -1382,6 +1459,7 @@ function parentName(name) {
 
 // src/schema/schema-weaver.ts
 function isSchemaVendorWeaver(some) {
+  if (some == null) return false;
   if (typeof some !== "object" && typeof some !== "function") return false;
   if (!("getGraphQLType" in some) || typeof some.getGraphQLType !== "function")
     return false;
@@ -1467,8 +1545,8 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     return schema;
   }
   addResolver(resolver2) {
-    const resolverOptions = ResolverOptionsMap.get(resolver2);
-    const parent = resolverOptions?.parent;
+    const resolverOptions = resolver2["~meta"].options;
+    const parent = resolver2["~meta"].parent;
     const parentObject = (() => {
       if (parent == null) return void 0;
       let gqlType = getGraphQLType(parent);
@@ -1487,16 +1565,18 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     })();
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
-    Object.entries(resolver2).forEach(([name, operation]) => {
-      if (operation === FIELD_HIDDEN) {
+    Object.entries(resolver2["~meta"].fields).forEach(([name, field2]) => {
+      if (field2 === FIELD_HIDDEN) {
         if (parentObject == null) return;
         parentObject.hideField(name);
-      } else if (operation.type === "field") {
+      } else if (field2["~meta"].operation === "field") {
         if (parentObject == null) return;
-        parentObject.addField(name, operation);
+        parentObject.addField(name, field2);
       } else {
-        const operationObject = this.getOperationObject(operation.type);
-        operationObject.addField(name, operation);
+        const operationObject = this.getOperationObject(
+          field2["~meta"].operation
+        );
+        operationObject.addField(name, field2);
       }
     });
     return this;
@@ -1550,7 +1630,7 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
         }
       } else if (isSilk(item)) {
         silks.add(item);
-      } else {
+      } else if (item["~meta"][IS_RESOLVER]) {
         resolvers.add(item);
       }
     }
@@ -1601,31 +1681,33 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseChainFactory,
+  ChainResolver,
   ContextMemoization,
   EasyDataLoader,
+  FieldChainFactory,
+  FieldFactoryWithResolve,
   GraphQLSchemaLoom,
   LoomObjectType,
+  MutationChainFactory,
+  MutationFactoryWithResolve,
   OPERATION_OBJECT_NAMES,
-  ResolverOptionsMap,
+  ObjectChainResolver,
+  QueryChainFactory,
+  QueryFactoryWithResolve,
   SYMBOLS,
+  SubscriptionChainFactory,
   applyMiddlewares,
-  baseResolver,
   capitalize,
   collectName,
   collectNames,
   compose,
   createField,
-  createFieldFactory,
   createInputParser,
-  createLoom,
   createMemoization,
   createMutation,
-  createMutationFactory,
   createQuery,
-  createQueryFactory,
-  createResolverFactory,
   createSubscription,
-  createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,
   ensureInputObjectType,
@@ -1648,6 +1730,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   mapValue,
   markErrorLocation,
   markLocation,
+  meta,
   mutation,
   nonNullSilk,
   notNullish,