@gqloom/core 0.7.2 → 0.8.1

package/dist/index.js

@@ -4,6 +4,321 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/args.ts
+function getOperationOptions(resolveOrOptions) {
+  if (typeof resolveOrOptions === "function") {
+    return { resolve: resolveOrOptions };
+  }
+  return resolveOrOptions;
+}
+function getSubscriptionOptions(subscribeOrOptions) {
+  if (typeof subscribeOrOptions === "function") {
+    return { subscribe: subscribeOrOptions };
+  }
+  return subscribeOrOptions;
+}
+function getFieldOptions({
+  description,
+  deprecationReason,
+  extensions
+}) {
+  return {
+    description,
+    deprecationReason,
+    extensions
+  };
+}
+
+// src/utils/middleware.ts
+function applyMiddlewares(middlewares, resolveFunction, options) {
+  const next = (index) => {
+    if (index >= middlewares.length) {
+      return resolveFunction();
+    }
+    const middleware = middlewares[index];
+    const callableOptions = Object.assign(() => next(index + 1), {
+      ...options,
+      next: () => next(index + 1)
+    });
+    return middleware(callableOptions);
+  };
+  return next(0);
+}
+function compose(...lists) {
+  const list = [];
+  for (const item of lists) {
+    if (item != null) {
+      list.push(...item);
+    }
+  }
+  return list;
+}
+
+// src/utils/context.ts
+import { AsyncLocalStorage } from "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 };
+}
+function isOnlyMemoryPayload(payload) {
+  return payload.isMemoization === true;
+}
+var resolverPayloadStorage = new AsyncLocalStorage();
+function useResolverPayload() {
+  const payload = resolverPayloadStorage.getStore();
+  if (payload === void 0 || isOnlyMemoryPayload(payload)) return;
+  return payload;
+}
+function useContext() {
+  return useResolverPayload()?.context;
+}
+function useMemoizationMap() {
+  const payload = resolverPayloadStorage.getStore();
+  if (payload == null) return;
+  if (isOnlyMemoryPayload(payload)) return payload.memoization;
+  return ContextMemoization.assignMemoizationMap(payload.context);
+}
+var ContextMemoization = class {
+  constructor(getter, options = {}) {
+    this.getter = getter;
+    this.getter = getter;
+    this.getMemoizationMap = options.getMemoizationMap ?? useMemoizationMap;
+    this.key = options.key ?? this.getter;
+  }
+  getMemoizationMap;
+  key;
+  /**
+   * Get the value in memoization or call the getter function
+   * @returns the value of the getter function
+   */
+  get() {
+    const map = this.getMemoizationMap();
+    if (!map) return this.getter();
+    if (!map.has(this.key)) {
+      map.set(this.key, this.getter());
+    }
+    return map.get(this.key);
+  }
+  /**
+   * Clear the memoization
+   * @returns true if the memoization is cleared, undefined if the context is not found
+   */
+  clear() {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.delete(this.key);
+  }
+  /**
+   * Check if the memoization exists
+   * @returns true if the memoization exists, undefined if the context is not found
+   */
+  exists() {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.has(this.key);
+  }
+  /**
+   * Set a new value to the memoization
+   * @param value  the new value to set
+   * @returns the memoization map or undefined if the context is not found
+   */
+  set(value) {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.set(this.key, value);
+  }
+  static assignMemoizationMap(target) {
+    target[CONTEXT_MEMORY_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
+    return target[CONTEXT_MEMORY_MAP_KEY];
+  }
+};
+function createMemoization(...args) {
+  const memoization = new ContextMemoization(...args);
+  const callable = () => memoization.get();
+  return Object.assign(callable, {
+    get: () => memoization.get(),
+    set: (value) => memoization.set(value),
+    clear: () => memoization.clear(),
+    exists: () => memoization.exists(),
+    getter: memoization.getter
+  });
+}
+
+// src/utils/object.ts
+function mapValue(record, fn) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(record)) {
+    const value = fn(record[key], key);
+    if (value === SKIP) continue;
+    result[key] = value;
+  }
+  return result;
+}
+var SKIP = Symbol.for("mapValue.skip");
+mapValue.SKIP = SKIP;
+function toObjMap(obj) {
+  if (obj == null) {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  if (Object.getPrototypeOf(obj) === null) {
+    return obj;
+  }
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(obj)) {
+    map[key] = value;
+  }
+  return map;
+}
+function notNullish(x) {
+  return x != null;
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (obj == null) continue;
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== null && typeof value === "object") {
+        if (Array.isArray(value)) {
+          if (!Array.isArray(result[key])) {
+            result[key] = [];
+          }
+          result[key] = [...result[key], ...value];
+        } else {
+          result[key] = deepMerge(result[key], value);
+        }
+      } else {
+        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
 import {
   GraphQLList,
@@ -17,23 +332,6 @@ import {
   isScalarType,
   isUnionType
 } from "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() {
@@ -205,331 +503,38 @@ function nullableSilk(origin) {
   return {
     ...origin,
     [GET_GRAPHQL_TYPE]: () => {
-      const originType = getGraphQLType(origin);
-      if (originType instanceof 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") {
-    return { resolve: resolveOrOptions };
-  }
-  return resolveOrOptions;
-}
-function getSubscriptionOptions(subscribeOrOptions) {
-  if (typeof subscribeOrOptions === "function") {
-    return { subscribe: subscribeOrOptions };
-  }
-  return subscribeOrOptions;
-}
-function getFieldOptions({
-  description,
-  deprecationReason,
-  extensions
-}) {
-  return {
-    description,
-    deprecationReason,
-    extensions
-  };
-}
-
-// src/utils/middleware.ts
-function applyMiddlewares(middlewares, resolveFunction, options) {
-  const next = (index) => {
-    if (index >= middlewares.length) {
-      return resolveFunction();
-    }
-    const middleware = middlewares[index];
-    const callableOptions = Object.assign(() => next(index + 1), {
-      ...options,
-      next: () => next(index + 1)
-    });
-    return middleware(callableOptions);
-  };
-  return next(0);
-}
-function compose(...lists) {
-  const list = [];
-  for (const item of lists) {
-    if (item != null) {
-      list.push(...item);
-    }
-  }
-  return list;
-}
-
-// src/utils/context.ts
-import { AsyncLocalStorage } from "async_hooks";
-function onlyMemoization() {
-  return { memoization: /* @__PURE__ */ new WeakMap(), isMemoization: true };
-}
-function isOnlyMemoryPayload(payload) {
-  return payload.isMemoization === true;
-}
-var resolverPayloadStorage = new AsyncLocalStorage();
-function useResolverPayload() {
-  const payload = resolverPayloadStorage.getStore();
-  if (payload === void 0 || isOnlyMemoryPayload(payload)) return;
-  return payload;
-}
-function useContext() {
-  return useResolverPayload()?.context;
-}
-function useMemoizationMap() {
-  const payload = resolverPayloadStorage.getStore();
-  if (payload == null) return;
-  if (isOnlyMemoryPayload(payload)) return payload.memoization;
-  return ContextMemoization.assignMemoizationMap(payload.context);
-}
-var ContextMemoization = class {
-  constructor(getter, options = {}) {
-    this.getter = getter;
-    this.getter = getter;
-    this.getMemoizationMap = options.getMemoizationMap ?? useMemoizationMap;
-    this.key = options.key ?? this.getter;
-  }
-  getMemoizationMap;
-  key;
-  /**
-   * Get the value in memoization or call the getter function
-   * @returns the value of the getter function
-   */
-  get() {
-    const map = this.getMemoizationMap();
-    if (!map) return this.getter();
-    if (!map.has(this.key)) {
-      map.set(this.key, this.getter());
-    }
-    return map.get(this.key);
-  }
-  /**
-   * Clear the memoization
-   * @returns true if the memoization is cleared, undefined if the context is not found
-   */
-  clear() {
-    const map = this.getMemoizationMap();
-    if (!map) return;
-    return map.delete(this.key);
-  }
-  /**
-   * Check if the memoization exists
-   * @returns true if the memoization exists, undefined if the context is not found
-   */
-  exists() {
-    const map = this.getMemoizationMap();
-    if (!map) return;
-    return map.has(this.key);
-  }
-  /**
-   * Set a new value to the memoization
-   * @param value  the new value to set
-   * @returns the memoization map or undefined if the context is not found
-   */
-  set(value) {
-    const map = this.getMemoizationMap();
-    if (!map) return;
-    return map.set(this.key, value);
-  }
-  static assignMemoizationMap(target) {
-    target[CONTEXT_MEMORY_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
-    return target[CONTEXT_MEMORY_MAP_KEY];
-  }
-};
-function createMemoization(...args) {
-  const memoization = new ContextMemoization(...args);
-  const callable = () => memoization.get();
-  return Object.assign(callable, {
-    get: () => memoization.get(),
-    set: (value) => memoization.set(value),
-    clear: () => memoization.clear(),
-    exists: () => memoization.exists(),
-    getter: memoization.getter
-  });
-}
-
-// src/utils/object.ts
-function mapValue(record, fn) {
-  const result = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(record)) {
-    const value = fn(record[key], key);
-    if (value === SKIP) continue;
-    result[key] = value;
-  }
-  return result;
-}
-var SKIP = Symbol.for("mapValue.skip");
-mapValue.SKIP = SKIP;
-function toObjMap(obj) {
-  if (obj == null) {
-    return /* @__PURE__ */ Object.create(null);
-  }
-  if (Object.getPrototypeOf(obj) === null) {
-    return obj;
-  }
-  const map = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(obj)) {
-    map[key] = value;
-  }
-  return map;
-}
-function notNullish(x) {
-  return x != null;
-}
-function deepMerge(...objects) {
-  const result = {};
-  for (const obj of objects) {
-    if (obj == null) continue;
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== null && typeof value === "object") {
-        if (Array.isArray(value)) {
-          if (!Array.isArray(result[key])) {
-            result[key] = [];
-          }
-          result[key] = [...result[key], ...value];
-        } else {
-          result[key] = deepMerge(result[key], value);
-        }
+      const originType = getGraphQLType(origin);
+      if (originType instanceof GraphQLNonNull) {
+        return originType.ofType;
       } else {
-        result[key] = value;
+        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
 import { GraphQLError } from "graphql";
 function createInputParser(schema, value) {
@@ -544,6 +549,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) {
@@ -623,9 +631,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 });
   }
@@ -633,11 +638,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() {
@@ -652,9 +690,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 });
   }
@@ -662,7 +697,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
     });
@@ -681,9 +717,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 });
   }
@@ -691,7 +724,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
     });
@@ -710,9 +744,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 });
   }
@@ -721,14 +752,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
@@ -739,6 +772,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) => {
@@ -746,8 +839,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,
@@ -756,11 +849,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,
@@ -771,8 +864,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,
@@ -781,11 +874,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,
@@ -796,8 +889,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,
@@ -806,11 +899,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,
@@ -818,13 +911,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,
@@ -836,62 +929,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
     )
   }
 );
@@ -902,93 +999,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
 import {
@@ -1191,13 +1264,13 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
   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),
@@ -1208,27 +1281,31 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
     }
   }
   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
+        )
       )
     };
   }
@@ -1240,11 +1317,8 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
     return { resolverOptions, weaverContext: weaverContext2 };
   }
 };
-function extract({
-  deprecationReason,
-  description,
-  extensions
-}) {
+function extract(field2) {
+  const { deprecationReason, description, extensions } = field2["~meta"];
   return {
     description,
     deprecationReason,
@@ -1324,6 +1398,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;
@@ -1415,8 +1490,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);
@@ -1435,16 +1510,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;
@@ -1498,7 +1575,7 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
         }
       } else if (isSilk(item)) {
         silks.add(item);
-      } else {
+      } else if (item["~meta"][IS_RESOLVER]) {
         resolvers.add(item);
       }
     }
@@ -1552,31 +1629,33 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   return interfaceType;
 }
 export {
+  BaseChainFactory,
+  ChainResolver,
   ContextMemoization,
   EasyDataLoader,
+  FieldChainFactory,
+  FieldFactoryWithResolve,
   GraphQLSchemaLoom,
   LoomObjectType,
+  MutationChainFactory,
+  MutationFactoryWithResolve,
   OPERATION_OBJECT_NAMES,
-  ResolverOptionsMap,
+  ObjectChainResolver,
+  QueryChainFactory,
+  QueryFactoryWithResolve,
   symbols_exports as SYMBOLS,
+  SubscriptionChainFactory,
   applyMiddlewares,
-  baseResolver,
   capitalize,
   collectName,
   collectNames,
   compose,
   createField,
-  createFieldFactory,
   createInputParser,
-  createLoom,
   createMemoization,
   createMutation,
-  createMutationFactory,
   createQuery,
-  createQueryFactory,
-  createResolverFactory,
   createSubscription,
-  createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,
   ensureInputObjectType,
@@ -1599,6 +1678,7 @@ export {
   mapValue,
   markErrorLocation,
   markLocation,
+  meta,
   mutation,
   nonNullSilk,
   notNullish,