@gqloom/core 0.8.4 → 0.9.1

package/dist/index.cjs

@@ -22,7 +22,6 @@ var src_exports = {};
 __export(src_exports, {
   BaseChainFactory: () => BaseChainFactory,
   ChainResolver: () => ChainResolver,
-  ContextMemoization: () => ContextMemoization,
   EasyDataLoader: () => EasyDataLoader,
   FieldChainFactory: () => FieldChainFactory,
   FieldFactoryWithResolve: () => FieldFactoryWithResolve,
@@ -37,13 +36,12 @@ __export(src_exports, {
   SYMBOLS: () => symbols_exports,
   SubscriptionChainFactory: () => SubscriptionChainFactory,
   applyMiddlewares: () => applyMiddlewares,
+  assignContextMap: () => assignContextMap,
   capitalize: () => capitalize,
   collectName: () => collectName,
   collectNames: () => collectNames,
-  compose: () => compose,
   createField: () => createField,
   createInputParser: () => createInputParser,
-  createMemoization: () => createMemoization,
   createMutation: () => createMutation,
   createQuery: () => createQuery,
   createSubscription: () => createSubscription,
@@ -53,10 +51,13 @@ __export(src_exports, {
   ensureInputType: () => ensureInputType,
   ensureInterfaceType: () => ensureInterfaceType,
   field: () => field,
+  filterMiddlewares: () => filterMiddlewares,
   getCacheType: () => getCacheType,
   getFieldOptions: () => getFieldOptions,
   getGraphQLType: () => getGraphQLType,
+  getMemoizationMap: () => getMemoizationMap,
   getOperationOptions: () => getOperationOptions,
+  getResolvingFields: () => getResolvingFields,
   getStandardValue: () => getStandardValue,
   getSubscriptionOptions: () => getSubscriptionOptions,
   initWeaverContext: () => initWeaverContext,
@@ -76,20 +77,17 @@ __export(src_exports, {
   nullableSilk: () => nullableSilk,
   onlyMemoization: () => onlyMemoization,
   parseInputValue: () => parseInputValue,
+  parseResolvingFields: () => parseResolvingFields,
   parseSilk: () => parseSilk,
   pascalCase: () => pascalCase,
   provideWeaverContext: () => provideWeaverContext,
   query: () => query,
   resolver: () => resolver,
-  resolverPayloadStorage: () => resolverPayloadStorage,
   screamingSnakeCase: () => screamingSnakeCase,
   silk: () => silk,
   subscription: () => subscription,
   toObjMap: () => toObjMap,
   tryIn: () => tryIn,
-  useContext: () => useContext,
-  useMemoizationMap: () => useMemoizationMap,
-  useResolverPayload: () => useResolverPayload,
   weave: () => weave,
   weaverContext: () => weaverContext
 });
@@ -108,20 +106,22 @@ function getSubscriptionOptions(subscribeOrOptions) {
   }
   return subscribeOrOptions;
 }
-function getFieldOptions({
-  description,
-  deprecationReason,
-  extensions
-}) {
+function getFieldOptions({ description, deprecationReason, extensions }, extraExtensions) {
   return {
     description,
     deprecationReason,
-    extensions
+    extensions: extraExtensions ? { ...extensions, ...extraExtensions } : extensions
   };
 }
 
 // src/utils/middleware.ts
-function applyMiddlewares(middlewares, resolveFunction, options) {
+var defaultOperations = [
+  "field",
+  "mutation",
+  "query",
+  "subscription.subscribe"
+];
+function applyMiddlewares(options, resolveFunction, middlewares) {
   const next = (index) => {
     if (index >= middlewares.length) {
       return resolveFunction();
@@ -135,122 +135,23 @@ function applyMiddlewares(middlewares, resolveFunction, options) {
   };
   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
-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 };
-}
-function isOnlyMemoryPayload(payload) {
-  return payload.isMemoization === true;
-}
-var resolverPayloadStorage = new import_async_hooks.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);
+function filterMiddlewares(operation, ...middlewareList) {
+  return middlewareList.reduce((acc, m) => {
+    if (!m) return acc;
+    acc.push(
+      ...ensureArray(m).filter((m2) => {
+        const ops = m2.operations ?? defaultOperations;
+        return ops.includes(operation);
+      })
+    );
+    return acc;
+  }, []);
 }
-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 ensureArray(value) {
+  if (value != null && typeof value === "object" && Symbol.iterator in value) {
+    return Array.from(value);
   }
-};
-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
-  });
+  return [value];
 }
 
 // src/utils/object.ts
@@ -306,6 +207,167 @@ function meta(data) {
   return { "~meta": data };
 }
 
+// src/utils/parse-resolving-fields.ts
+var import_graphql3 = require("graphql");
+
+// src/utils/constants.ts
+var DERIVED_DEPENDENCIES = "loom.derived-from-dependencies";
+
+// src/utils/type.ts
+var import_graphql = require("graphql");
+var import_graphql2 = require("graphql");
+function unwrapType(gqlType) {
+  if ((0, import_graphql2.isNonNullType)(gqlType)) {
+    return unwrapType(gqlType.ofType);
+  }
+  if ((0, import_graphql.isListType)(gqlType)) {
+    return unwrapType(gqlType.ofType);
+  }
+  return gqlType;
+}
+
+// src/utils/parse-resolving-fields.ts
+function getResolvingFields(payload) {
+  const requestedFields = parseResolvingFields(payload.info);
+  const derivedFields = /* @__PURE__ */ new Set();
+  const derivedDependencies = /* @__PURE__ */ new Set();
+  const resolvingObject = unwrapType(payload.info.returnType);
+  if ((0, import_graphql3.isObjectType)(resolvingObject)) {
+    const objectFields = resolvingObject.getFields();
+    for (const requestedFieldName of requestedFields) {
+      const field2 = objectFields[requestedFieldName];
+      if (field2) {
+        const deps = field2.extensions?.[DERIVED_DEPENDENCIES];
+        if (deps && Array.isArray(deps) && deps.length > 0) {
+          derivedFields.add(requestedFieldName);
+          for (const d of deps) derivedDependencies.add(d);
+        }
+      }
+    }
+  }
+  const selectedFields = new Set(requestedFields);
+  for (const f of derivedFields) selectedFields.delete(f);
+  for (const d of derivedDependencies) selectedFields.add(d);
+  return { requestedFields, derivedFields, derivedDependencies, selectedFields };
+}
+function parseResolvingFields(info, maxDepth = 1) {
+  return new ResolvingFieldsParser(info, maxDepth).parse();
+}
+var ResolvingFieldsParser = class {
+  /** Store unique field paths */
+  fields = /* @__PURE__ */ new Set();
+  /** Track visited fragments to prevent circular references */
+  visitedFragments = /* @__PURE__ */ new Set();
+  /** The GraphQL resolve info object */
+  info;
+  /** Maximum depth of nested fields to parse */
+  maxDepth;
+  constructor(info, maxDepth) {
+    this.info = info;
+    this.maxDepth = maxDepth;
+  }
+  /**
+   * Parses the GraphQL resolve info to extract all requested fields.
+   * @returns A Set of field paths
+   */
+  parse() {
+    for (const fieldNode of this.info.fieldNodes) {
+      this.collectFields(fieldNode.selectionSet);
+    }
+    return this.fields;
+  }
+  /**
+   * Recursively collects fields from a selection set.
+   * Handles fields, inline fragments, and fragment spreads.
+   *
+   * @param selectionSet - The selection set to process
+   * @param parentPath - The path of the parent field (for nested fields)
+   * @param currentDepth - Current depth of recursion
+   */
+  collectFields(selectionSet, parentPath = "", currentDepth = 0) {
+    if (!selectionSet?.selections.length || currentDepth >= this.maxDepth)
+      return;
+    for (const selection of selectionSet.selections) {
+      if (!this.shouldIncludeNode(selection)) continue;
+      switch (selection.kind) {
+        case import_graphql3.Kind.FIELD: {
+          const fieldName = selection.name.value;
+          const fieldPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
+          this.fields.add(fieldPath);
+          const hasSelectionSet = selection.selectionSet != null;
+          if (hasSelectionSet) {
+            this.collectFields(
+              selection.selectionSet,
+              fieldPath,
+              currentDepth + 1
+            );
+          }
+          break;
+        }
+        case import_graphql3.Kind.INLINE_FRAGMENT: {
+          if (selection.selectionSet) {
+            this.collectFields(selection.selectionSet, parentPath, currentDepth);
+          }
+          break;
+        }
+        case import_graphql3.Kind.FRAGMENT_SPREAD: {
+          const fragmentName = selection.name.value;
+          if (this.visitedFragments.has(fragmentName)) continue;
+          this.visitedFragments.add(fragmentName);
+          const fragment = this.info.fragments[fragmentName];
+          if (fragment) {
+            this.collectFields(fragment.selectionSet, parentPath, currentDepth);
+          }
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Extracts the boolean value from a directive's 'if' argument.
+   * Handles both literal boolean values and variables.
+   *
+   * @param directive - The directive node to extract value from
+   * @returns The boolean value of the directive's condition
+   */
+  getDirectiveValue(directive) {
+    const ifArg = directive.arguments?.find(
+      (arg) => arg.name.value === "if"
+    );
+    if (!ifArg) return true;
+    const value = ifArg.value;
+    if (value.kind === import_graphql3.Kind.BOOLEAN) {
+      return value.value;
+    }
+    if (value.kind === import_graphql3.Kind.VARIABLE) {
+      const variableName = value.name.value;
+      const variableValue = this.info.variableValues?.[variableName];
+      return variableValue === true;
+    }
+    return true;
+  }
+  /**
+   * Determines if a selection node should be included based on its directives.
+   * Handles both @include and @skip directives.
+   *
+   * @param node - The selection node to check
+   * @returns Whether the node should be included
+   */
+  shouldIncludeNode(node) {
+    if (!node.directives?.length) return true;
+    return node.directives.every((directive) => {
+      const isIncludeDirective = directive.name.value === "include";
+      if (isIncludeDirective) {
+        return this.getDirectiveValue(directive);
+      }
+      if (directive.name.value === "skip") {
+        return !this.getDirectiveValue(directive);
+      }
+      return true;
+    });
+  }
+};
+
 // src/utils/string.ts
 function pascalCase(str) {
   return str.split(/[\s-_]+/).map(
@@ -413,11 +475,47 @@ var EasyDataLoader = class _EasyDataLoader {
   }
 };
 
+// src/utils/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  CONTEXT_MAP_KEY: () => CONTEXT_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_MAP_KEY = Symbol.for("gqloom.context-map");
+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;
+}
+function getMemoizationMap(payload) {
+  if (isOnlyMemoryPayload(payload)) return payload.memoization;
+  if (typeof payload.context === "undefined") {
+    Object.defineProperty(payload, "context", { value: {} });
+  }
+  return assignContextMap(payload.context);
+}
+function assignContextMap(target) {
+  target[CONTEXT_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
+  return target[CONTEXT_MAP_KEY];
+}
+
 // src/resolver/silk.ts
-var import_graphql2 = require("graphql");
+var import_graphql5 = require("graphql");
 
 // src/schema/weaver-context.ts
-var import_graphql = require("graphql");
+var import_graphql4 = require("graphql");
 var ref;
 var names = /* @__PURE__ */ new WeakMap();
 function initWeaverContext() {
@@ -442,7 +540,7 @@ function initWeaverContext() {
     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)) {
+      if ((0, import_graphql4.isObjectType)(gqlType) || (0, import_graphql4.isUnionType)(gqlType) || (0, import_graphql4.isEnumType)(gqlType) || (0, import_graphql4.isScalarType)(gqlType)) {
         this.namedTypes.set(gqlType.name, gqlType);
       }
       return gqlTypeValue;
@@ -562,10 +660,10 @@ function nonNullSilk(origin) {
     ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull) {
+      if (originType instanceof import_graphql5.GraphQLNonNull) {
         return originType;
       } else {
-        return new import_graphql2.GraphQLNonNull(originType);
+        return new import_graphql5.GraphQLNonNull(originType);
       }
     }
   };
@@ -575,13 +673,13 @@ function listSilk(origin) {
     ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       let originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull && originType.ofType instanceof import_graphql2.GraphQLList) {
+      if (originType instanceof import_graphql5.GraphQLNonNull && originType.ofType instanceof import_graphql5.GraphQLList) {
         originType = originType.ofType.ofType;
       }
-      if (originType instanceof import_graphql2.GraphQLList) {
+      if (originType instanceof import_graphql5.GraphQLList) {
         originType = originType.ofType;
       }
-      return new import_graphql2.GraphQLNonNull(new import_graphql2.GraphQLList(originType));
+      return new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(originType));
     }
   };
 }
@@ -590,7 +688,7 @@ function nullableSilk(origin) {
     ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql2.GraphQLNonNull) {
+      if (originType instanceof import_graphql5.GraphQLNonNull) {
         return originType.ofType;
       } else {
         return originType;
@@ -622,7 +720,7 @@ function isSilk(target) {
 }
 
 // src/resolver/input.ts
-var import_graphql3 = require("graphql");
+var import_graphql6 = require("graphql");
 function createInputParser(schema, value) {
   let result;
   const parse = async () => {
@@ -669,19 +767,26 @@ function getStandardValue(result) {
   if (result == null) return result;
   const { issues } = result;
   if (issues?.length) {
-    throw new import_graphql3.GraphQLError(issues?.[0]?.message ?? "Invalid input", {
+    throw new import_graphql6.GraphQLError(issues?.[0]?.message ?? "Invalid input", {
       extensions: { issues }
     });
   }
   if ("value" in result) return result.value;
-  else throw new import_graphql3.GraphQLError("Invalid input");
+  else throw new import_graphql6.GraphQLError("Invalid input");
 }
 
 // src/resolver/resolver-chain-factory.ts
 var BaseChainFactory = class _BaseChainFactory {
+  /**
+   * Creates a new instance of the chain factory
+   * @param options - Configuration options for the factory
+   */
   constructor(options) {
     this.options = options;
   }
+  /**
+   * Returns the available methods for the chain factory
+   */
   static methods() {
     return {
       description: _BaseChainFactory.prototype.description,
@@ -689,15 +794,31 @@ var BaseChainFactory = class _BaseChainFactory {
       extensions: _BaseChainFactory.prototype.extensions
     };
   }
+  /**
+   * Sets the description for the field
+   * @param description - The description text
+   */
   description(description) {
     return this.clone({ description });
   }
+  /**
+   * Sets the deprecation reason for the field
+   * @param deprecationReason - The reason for deprecation
+   */
   deprecationReason(deprecationReason) {
     return this.clone({ deprecationReason });
   }
+  /**
+   * Sets custom extensions for the field
+   * @param extensions - Custom extensions to add
+   */
   extensions(extensions) {
     return this.clone({ extensions });
   }
+  /**
+   * Adds middleware functions to the field
+   * @param middlewares - Middleware functions to add
+   */
   use(...middlewares) {
     return this.clone({
       middlewares: [...this.options?.middlewares ?? [], ...middlewares]
@@ -705,6 +826,9 @@ var BaseChainFactory = class _BaseChainFactory {
   }
 };
 var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
+  /**
+   * Returns the available methods for the field chain factory
+   */
   static methods() {
     return {
       ...BaseChainFactory.methods(),
@@ -714,15 +838,42 @@ var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
       clone: _FieldChainFactory.prototype.clone
     };
   }
+  /**
+   * Creates a clone of the current factory with new options
+   * @param options - New options to apply to the clone
+   */
   clone(options) {
     return new _FieldChainFactory({ ...this.options, ...options });
   }
+  /**
+   * Sets the output type for the field
+   * @template TOutputNew - The new output type
+   * @param output - The output type definition
+   */
   output(output) {
     return new _FieldChainFactory({ ...this.options, output });
   }
+  /**
+   * Sets the input type for the field
+   * @template TInputNew - The new input type
+   * @param input - The input type definition
+   */
   input(input) {
     return new _FieldChainFactory({ ...this.options, input });
   }
+  /**
+   * Specifies the dependencies for the field
+   * @template TDependencies - The dependencies type
+   * @param dependencies - The dependencies to add
+   */
+  derivedFrom(...dependencies) {
+    return this.clone({ dependencies });
+  }
+  /**
+   * Sets the resolve function for the field
+   * @template TParent - The parent type
+   * @param resolve - The resolve function
+   */
   resolve(resolve) {
     if (!this.options?.output) throw new Error("Output is required");
     return createField(this.options.output, {
@@ -730,40 +881,47 @@ var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
       resolve
     });
   }
+  /**
+   * Creates a field resolver that uses DataLoader for batch loading data.
+   * This method is particularly useful for optimizing performance when dealing with multiple data requests
+   * by batching them together and handling caching automatically.
+   *
+   * @template TParent - The parent type that extends GraphQLSilk
+   * @param resolve - A function that handles batch loading of data. The function receives:
+   *   - When no input type is defined: An array of parent objects
+   *   - When input type is defined: An array of tuples containing [parent, input]
+   *   - An array of resolver payloads
+   * @returns A GraphQL field resolver that implements batch loading
+   */
   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 }
-        );
+    const hasInput = typeof this.options.input !== "undefined";
+    const initLoader = () => new EasyDataLoader((args) => {
+      const parents = args.map(
+        ([parent, input]) => hasInput ? [parent, input] : parent
+      );
+      const payloads = args.map(([, , payload]) => payload);
+      return resolve(parents, payloads);
+    });
+    return createField(this.options.output, {
+      ...this.options,
+      resolve: (parent, input, payload) => {
+        const loader = (() => {
+          if (!payload) return initLoader();
+          const memoMap = getMemoizationMap(payload);
+          if (!memoMap.has(resolve)) memoMap.set(resolve, initLoader());
+          return memoMap.get(resolve);
+        })();
+        return loader.load([parent, input, payload]);
       }
     });
   }
 };
 var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
+  /**
+   * Returns the available methods for the query chain factory
+   * @returns An object containing all available methods
+   */
   static methods() {
     return {
       ...BaseChainFactory.methods(),
@@ -773,15 +931,38 @@ var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
       clone: _QueryChainFactory.prototype.clone
     };
   }
+  /**
+   * Creates a clone of the current factory with new options
+   * @param options - New options to apply to the clone
+   * @returns A new instance of QueryChainFactory with the updated options
+   */
   clone(options) {
     return new _QueryChainFactory({ ...this.options, ...options });
   }
+  /**
+   * Sets the output type for the query
+   * @template TOutputNew - The new output type
+   * @param output - The output type definition
+   * @returns A new QueryChainFactory instance with the updated output type
+   */
   output(output) {
     return new _QueryChainFactory({ ...this.options, output });
   }
+  /**
+   * Sets the input type for the query
+   * @template TInputNew - The new input type
+   * @param input - The input type definition
+   * @returns A new QueryChainFactory instance with the updated input type
+   */
   input(input) {
     return new _QueryChainFactory({ ...this.options, input });
   }
+  /**
+   * Sets the resolve function for the query
+   * @param resolve - The resolve function that processes the input and returns the output
+   * @returns A GraphQL query resolver
+   * @throws {Error} If output type is not set
+   */
   resolve(resolve) {
     if (!this.options?.output) throw new Error("Output is required");
     return createQuery(this.options.output, {
@@ -791,6 +972,10 @@ var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
   }
 };
 var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory {
+  /**
+   * Returns the available methods for the mutation chain factory
+   * @returns An object containing all available methods
+   */
   static methods() {
     return {
       ...BaseChainFactory.methods(),
@@ -800,15 +985,38 @@ var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory
       clone: _MutationChainFactory.prototype.clone
     };
   }
+  /**
+   * Creates a clone of the current factory with new options
+   * @param options - New options to apply to the clone
+   * @returns A new instance of MutationChainFactory with the updated options
+   */
   clone(options) {
     return new _MutationChainFactory({ ...this.options, ...options });
   }
+  /**
+   * Sets the output type for the mutation
+   * @template TOutputNew - The new output type
+   * @param output - The output type definition
+   * @returns A new MutationChainFactory instance with the updated output type
+   */
   output(output) {
     return new _MutationChainFactory({ ...this.options, output });
   }
+  /**
+   * Sets the input type for the mutation
+   * @template TInputNew - The new input type
+   * @param input - The input type definition
+   * @returns A new MutationChainFactory instance with the updated input type
+   */
   input(input) {
     return new _MutationChainFactory({ ...this.options, input });
   }
+  /**
+   * Sets the resolve function for the mutation
+   * @param resolve - The resolve function that processes the input and returns the output
+   * @returns A GraphQL mutation resolver
+   * @throws {Error} If output type is not set
+   */
   resolve(resolve) {
     if (!this.options?.output) throw new Error("Output is required");
     return createMutation(this.options.output, {
@@ -818,6 +1026,10 @@ var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory
   }
 };
 var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChainFactory {
+  /**
+   * Returns the available methods for the subscription chain factory
+   * @returns An object containing all available methods
+   */
   static methods() {
     return {
       ...BaseChainFactory.methods(),
@@ -827,15 +1039,39 @@ var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChain
       clone: _SubscriptionChainFactory.prototype.clone
     };
   }
+  /**
+   * Creates a clone of the current factory with new options
+   * @param options - New options to apply to the clone
+   * @returns A new instance of SubscriptionChainFactory with the updated options
+   */
   clone(options) {
     return new _SubscriptionChainFactory({ ...this.options, ...options });
   }
+  /**
+   * Sets the output type for the subscription
+   * @template TOutputNew - The new output type
+   * @param output - The output type definition
+   * @returns A new SubscriptionChainFactory instance with the updated output type
+   */
   output(output) {
     return new _SubscriptionChainFactory({ ...this.options, output });
   }
+  /**
+   * Sets the input type for the subscription
+   * @template TInputNew - The new input type
+   * @param input - The input type definition
+   * @returns A new SubscriptionChainFactory instance with the updated input type
+   */
   input(input) {
     return new _SubscriptionChainFactory({ ...this.options, input });
   }
+  /**
+   * Sets the subscribe function for the subscription
+   * @template TValue - The value type of the subscription
+   * @param subscribe - The subscribe function that returns an AsyncIterator
+   * @returns A subscription resolver that can be further configured with a resolve function
+   * @throws {Error} If output type is not set
+   */
   subscribe(subscribe) {
     const options = this.options;
     const output = this.options?.output;
@@ -925,20 +1161,13 @@ var createQuery = (output, resolveOrOptions) => {
     return new QueryChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const operation = "query";
   return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
-    resolve: (inputValue, extraOptions) => {
-      const parseInput = createInputParser(options.input, inputValue);
-      return applyMiddlewares(
-        compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, operation }
-      );
-    },
-    operation
+    resolve: options.resolve,
+    middlewares: options.middlewares,
+    operation: "query"
   });
 };
 var query = Object.assign(
@@ -950,20 +1179,13 @@ var createMutation = (output, resolveOrOptions) => {
     return new MutationChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const operation = "mutation";
   return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
-    resolve: (inputValue, extraOptions) => {
-      const parseInput = createInputParser(options.input, inputValue);
-      return applyMiddlewares(
-        compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, operation }
-      );
-    },
-    operation
+    resolve: options.resolve,
+    middlewares: options.middlewares,
+    operation: "mutation"
   });
 };
 var mutation = Object.assign(
@@ -975,20 +1197,16 @@ var createField = (output, resolveOrOptions) => {
     return new FieldChainFactory({ output });
   }
   const options = getOperationOptions(resolveOrOptions);
-  const operation = "field";
   return meta({
-    ...getFieldOptions(options),
+    ...getFieldOptions(options, {
+      [DERIVED_DEPENDENCIES]: options.dependencies
+    }),
     input: options.input,
+    dependencies: options.dependencies,
     output,
-    resolve: (parent, inputValue, extraOptions) => {
-      const parseInput = createInputParser(options.input, inputValue);
-      return applyMiddlewares(
-        compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(parent, getStandardValue(await parseInput())),
-        { parseInput, parent, outputSilk: output, operation }
-      );
-    },
-    operation
+    resolve: options.resolve,
+    middlewares: options.middlewares,
+    operation: "field"
   });
 };
 var field = Object.assign(
@@ -1002,72 +1220,20 @@ function createSubscription(output, subscribeOrOptions) {
     return new SubscriptionChainFactory({ output });
   }
   const options = getSubscriptionOptions(subscribeOrOptions);
-  const operation = "subscription";
   return meta({
     ...getFieldOptions(options),
     input: options.input,
     output,
-    subscribe: (inputValue, extraOptions) => {
-      const parseInput = createInputParser(options.input, inputValue);
-      return applyMiddlewares(
-        compose(
-          extraOptions?.middlewares,
-          options.middlewares
-        ),
-        async () => options.subscribe(getStandardValue(await parseInput())),
-        { parseInput, parent: void 0, outputSilk: output, operation }
-      );
-    },
+    subscribe: options.subscribe,
     resolve: options.resolve ?? defaultSubscriptionResolve,
-    operation
+    middlewares: options.middlewares,
+    operation: "subscription"
   });
 }
 var subscription = Object.assign(
   createSubscription,
   SubscriptionChainFactory.methods()
 );
-function extraOperationOptions(field2, options) {
-  if (typeof field2 === "symbol") return field2;
-  const composeMiddlewares = (extraOptions) => compose(extraOptions?.middlewares, options?.middlewares);
-  switch (field2["~meta"].operation) {
-    case "field":
-      return {
-        ...field2,
-        "~meta": {
-          ...field2["~meta"],
-          resolve: (parent, input, extraOptions) => field2["~meta"].resolve(parent, input, {
-            ...extraOptions,
-            middlewares: composeMiddlewares(extraOptions)
-          })
-        }
-      };
-    case "subscription":
-      return {
-        ...field2,
-        "~meta": {
-          ...field2["~meta"],
-          subscribe: (input, extraOptions) => field2["~meta"].subscribe(
-            input,
-            {
-              ...extraOptions,
-              middlewares: composeMiddlewares(extraOptions)
-            }
-          )
-        }
-      };
-    default:
-      return {
-        ...field2,
-        "~meta": {
-          ...field2["~meta"],
-          resolve: (input, extraOptions) => field2["~meta"].resolve(input, {
-            ...extraOptions,
-            middlewares: composeMiddlewares(extraOptions)
-          })
-        }
-      };
-  }
-}
 var resolver = Object.assign(
   (operations, options) => new ChainResolver(operations, options),
   {
@@ -1087,6 +1253,11 @@ var loom = {
 };
 var ChainResolver = class {
   meta;
+  /**
+   * Creates a new chain resolver
+   * @param fields - The fields or operations to resolve
+   * @param options - Optional resolver options
+   */
   constructor(fields, options) {
     this.meta = {
       [IS_RESOLVER]: true,
@@ -1094,38 +1265,83 @@ var ChainResolver = class {
       options
     };
   }
+  /**
+   * Gets the metadata for the resolver
+   */
   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
-    };
+    return this.meta;
   }
+  /**
+   * Adds middleware functions to the resolver
+   * @param middlewares - The middleware functions to add
+   */
   use(...middlewares) {
     this.meta.options ??= {};
     this.meta.options.middlewares ??= [];
     this.meta.options.middlewares.push(...middlewares);
     return this;
   }
-  toExecutor() {
-    const fields = this["~meta"].fields;
-    const executor = {};
-    Object.entries(fields).forEach(([name, field2]) => {
-      if (field2 === FIELD_HIDDEN) return;
-      executor[name] = field2["~meta"].resolve;
-    });
+  toExecutor(...middlewares) {
+    const executor = mapValue(
+      this["~meta"].fields,
+      (field2) => this.toExecutorOperation(field2, middlewares) ?? mapValue.SKIP
+    );
     return executor;
   }
+  toExecutorOperation(field2, executorMiddlewares) {
+    if (field2 === FIELD_HIDDEN || field2["~meta"].operation === "subscription") {
+      return void 0;
+    }
+    const operation = field2["~meta"].operation;
+    const middlewares = filterMiddlewares(
+      operation,
+      executorMiddlewares,
+      this.meta.options?.middlewares,
+      field2["~meta"].middlewares
+    );
+    if (field2["~meta"].operation === "field") {
+      const resolve = field2["~meta"].resolve;
+      return (parent, args, payload) => {
+        const parseInput = createInputParser(field2["~meta"].input, args);
+        return applyMiddlewares(
+          {
+            outputSilk: field2["~meta"].output,
+            parent,
+            payload,
+            parseInput,
+            operation
+          },
+          async () => resolve(parent, await parseInput.getResult(), payload),
+          middlewares
+        );
+      };
+    } else {
+      const resolve = field2["~meta"].resolve;
+      return (args, payload) => {
+        const parseInput = createInputParser(field2["~meta"].input, args);
+        return applyMiddlewares(
+          {
+            outputSilk: field2["~meta"].output,
+            parent: void 0,
+            payload,
+            parseInput,
+            operation
+          },
+          async () => resolve(await parseInput.getResult(), payload),
+          middlewares
+        );
+      };
+    }
+  }
 };
 var ObjectChainResolver = class extends ChainResolver {
   meta;
+  /**
+   * Creates a new object chain resolver
+   * @param parent - The parent type definition
+   * @param fields - The fields to resolve
+   * @param options - Optional resolver options
+   */
   constructor(parent, fields, options) {
     super(fields, options);
     this.meta = {
@@ -1135,9 +1351,16 @@ var ObjectChainResolver = class extends ChainResolver {
       options
     };
   }
+  /**
+   * Gets the metadata for the resolver
+   */
   get "~meta"() {
     return super["~meta"];
   }
+  /**
+   * Sets custom extensions for the resolver
+   * @param extensions - The extensions to add
+   */
   extensions(extensions) {
     this.meta.options ??= {};
     this.meta.options.extensions ??= {};
@@ -1150,27 +1373,16 @@ var ObjectChainResolver = class extends ChainResolver {
 };
 
 // src/schema/object.ts
-var import_graphql5 = require("graphql");
-
-// src/utils/async-iterator.ts
-function bindAsyncIterator(storage, generator) {
-  const store = storage.getStore();
-  const next = generator.next;
-  Object.defineProperty(generator, "next", {
-    value: (...args) => storage.run(store, () => next.apply(generator, args)),
-    writable: false
-  });
-  return generator;
-}
+var import_graphql8 = require("graphql");
 
 // src/schema/input.ts
-var import_graphql4 = require("graphql");
+var import_graphql7 = require("graphql");
 function inputToArgs(input, options) {
   if (input === void 0) return void 0;
   if (isSilk(input)) {
     let inputType = getGraphQLType(input);
-    if ((0, import_graphql4.isNonNullType)(inputType)) inputType = inputType.ofType;
-    if ((0, import_graphql4.isObjectType)(inputType)) {
+    if ((0, import_graphql7.isNonNullType)(inputType)) inputType = inputType.ofType;
+    if ((0, import_graphql7.isObjectType)(inputType)) {
       return mapValue(inputType.toConfig().fields, (it, key) => {
         let fieldName;
         if (options?.fieldName) {
@@ -1203,20 +1415,20 @@ function ensureInputType(silkOrType, options) {
     }
     return silkOrType;
   })();
-  if ((0, import_graphql4.isUnionType)(gqlType))
+  if ((0, import_graphql7.isUnionType)(gqlType))
     throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
-  if ((0, import_graphql4.isNonNullType)(gqlType)) {
-    return new import_graphql4.GraphQLNonNull(ensureInputType(gqlType.ofType, options));
+  if ((0, import_graphql7.isNonNullType)(gqlType)) {
+    return new import_graphql7.GraphQLNonNull(ensureInputType(gqlType.ofType, options));
   }
-  if ((0, import_graphql4.isListType)(gqlType)) {
-    return new import_graphql4.GraphQLList(ensureInputType(gqlType.ofType, options));
+  if ((0, import_graphql7.isListType)(gqlType)) {
+    return new import_graphql7.GraphQLList(ensureInputType(gqlType.ofType, options));
   }
-  if ((0, import_graphql4.isObjectType)(gqlType) || (0, import_graphql4.isInterfaceType)(gqlType))
+  if ((0, import_graphql7.isObjectType)(gqlType) || (0, import_graphql7.isInterfaceType)(gqlType))
     return ensureInputObjectType(gqlType, options);
   return gqlType;
 }
 function ensureInputObjectType(object, options) {
-  if ((0, import_graphql4.isInputObjectType)(object)) return object;
+  if ((0, import_graphql7.isInputObjectType)(object)) return object;
   const existing = weaverContext.inputMap?.get(object);
   if (existing != null) return existing;
   const { astNode, extensionASTNodes, fields, ...config } = object.toConfig();
@@ -1226,7 +1438,7 @@ function ensureInputObjectType(object, options) {
   }
   const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((n) => n);
   name = getInputObjectName(name);
-  const input = new import_graphql4.GraphQLInputObjectType({
+  const input = new import_graphql7.GraphQLInputObjectType({
     ...config,
     name,
     fields: provideWeaverContext.inherit(
@@ -1252,16 +1464,20 @@ function inputFieldName(name) {
 }
 
 // src/schema/object.ts
-var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObjectType {
+var LoomObjectType = class _LoomObjectType extends import_graphql8.GraphQLObjectType {
   extraFields = /* @__PURE__ */ new Map();
   hiddenFields = /* @__PURE__ */ new Set();
   static AUTO_ALIASING = "__gqloom_auto_aliasing";
   weaverContext;
-  resolverOptions;
+  globalOptions;
+  /**
+   * field name -> resolver
+   */
+  resolvers;
   constructor(objectOrGetter, options = {}) {
     const origin = typeof objectOrGetter === "function" ? objectOrGetter() : objectOrGetter;
     const config = (() => {
-      if ((0, import_graphql5.isObjectType)(origin)) {
+      if ((0, import_graphql8.isObjectType)(origin)) {
         return origin.toConfig();
       } else if (typeof origin === "string") {
         return { name: origin, fields: {} };
@@ -1270,8 +1486,9 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
       }
     })();
     super(config);
-    this.resolverOptions = options.resolverOptions;
+    this.globalOptions = options.globalOptions;
     this.weaverContext = options.weaverContext ?? initWeaverContext();
+    this.resolvers = /* @__PURE__ */ new Map();
     if (this.name !== _LoomObjectType.AUTO_ALIASING) {
       this.hasExplicitName = true;
     }
@@ -1298,12 +1515,13 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
   hideField(name) {
     this.hiddenFields.add(name);
   }
-  addField(name, resolver2) {
+  addField(name, field2, resolver2) {
     const existing = this.extraFields.get(name);
-    if (existing && existing !== resolver2) {
+    if (existing && existing !== field2) {
       throw new Error(`Field ${name} already exists in ${this.name}`);
     }
-    this.extraFields.set(name, resolver2);
+    this.extraFields.set(name, field2);
+    if (resolver2) this.resolvers.set(name, resolver2);
   }
   mergeExtensions(extensions) {
     this.extensions = deepMerge(this.extensions, extensions);
@@ -1338,58 +1556,140 @@ var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObject
     return record;
   }
   toFieldConfig(field2, fieldName) {
-    try {
-      const outputType = this.getCacheType(
-        getGraphQLType(field2["~meta"].output),
-        fieldName
-      );
-      return {
-        ...extract(field2),
-        type: outputType,
-        args: inputToArgs(field2["~meta"].input, {
-          fieldName: fieldName ? parentName(this.name) + fieldName : void 0
-        }),
-        ...this.provideForResolve(field2),
-        ...this.provideForSubscribe(field2)
-      };
-    } catch (error) {
-      throw markErrorLocation(error);
-    }
-  }
-  provideForResolve(field2) {
-    if (field2?.["~meta"]?.resolve == null) return;
-    if (field2["~meta"].resolve === defaultSubscriptionResolve)
-      return { resolve: defaultSubscriptionResolve };
-    const resolve = field2["~meta"].operation === "field" ? (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field: field2 },
-      () => field2["~meta"].resolve(root, args, this.resolverOptions)
-    ) : field2["~meta"].operation === "subscription" ? (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field: field2 },
-      () => field2["~meta"].resolve(root, args)
-    ) : (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field: field2 },
-      () => field2["~meta"].resolve(args, this.resolverOptions)
+    const outputType = this.getCacheType(
+      getGraphQLType(field2["~meta"].output),
+      fieldName
     );
-    return { resolve };
+    const resolve = this.provideForResolve(field2, fieldName);
+    const subscribe = this.provideForSubscribe(field2, fieldName);
+    return {
+      ...extract(field2),
+      type: outputType,
+      args: inputToArgs(field2["~meta"].input, {
+        fieldName: fieldName ? parentName(this.name) + fieldName : void 0
+      }),
+      resolve,
+      ...subscribe ? { subscribe } : {}
+    };
+  }
+  provideForResolve(field2, fieldName) {
+    const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
+    switch (field2["~meta"].operation) {
+      case "query":
+      case "mutation": {
+        const operation = field2["~meta"].operation;
+        const middlewares = filterMiddlewares(
+          operation,
+          this.globalOptions?.middlewares,
+          resolverMiddlewares,
+          field2["~meta"].middlewares
+        );
+        return (root, args, context, info) => {
+          const payload = { root, args, context, info, field: field2 };
+          const parseInput = createInputParser(field2["~meta"].input, args);
+          return applyMiddlewares(
+            {
+              operation,
+              outputSilk: field2["~meta"].output,
+              parent: void 0,
+              parseInput,
+              payload
+            },
+            async () => field2["~meta"].resolve(await parseInput.getResult(), payload),
+            middlewares
+          );
+        };
+      }
+      case "field": {
+        const middlewares = filterMiddlewares(
+          "field",
+          this.globalOptions?.middlewares,
+          resolverMiddlewares,
+          field2["~meta"].middlewares
+        );
+        return (root, args, context, info) => {
+          const payload = { root, args, context, info, field: field2 };
+          const parseInput = createInputParser(field2["~meta"].input, args);
+          return applyMiddlewares(
+            {
+              operation: "field",
+              outputSilk: field2["~meta"].output,
+              parent: root,
+              parseInput,
+              payload
+            },
+            async () => field2["~meta"].resolve(
+              root,
+              await parseInput.getResult(),
+              payload
+            ),
+            middlewares
+          );
+        };
+      }
+      case "subscription": {
+        const middlewares = filterMiddlewares(
+          "subscription.resolve",
+          this.globalOptions?.middlewares,
+          resolverMiddlewares,
+          field2["~meta"].middlewares
+        );
+        return (root, args, context, info) => {
+          const payload = { root, args, context, info, field: field2 };
+          const parseInput = createInputParser(field2["~meta"].input, args);
+          return applyMiddlewares(
+            {
+              operation: "subscription.resolve",
+              outputSilk: field2["~meta"].output,
+              parent: root,
+              parseInput,
+              payload
+            },
+            async () => field2["~meta"].resolve(
+              root,
+              await parseInput.getResult(),
+              payload
+            ),
+            middlewares
+          );
+        };
+      }
+    }
   }
-  provideForSubscribe(field2) {
+  provideForSubscribe(field2, fieldName) {
     if (field2?.["~meta"]?.subscribe == null)
       return;
-    return {
-      subscribe: (root, args, context, info) => resolverPayloadStorage.run(
-        { root, args, context, info, field: field2 },
-        async () => {
-          const generator = await field2["~meta"].subscribe?.(args, this.resolverOptions);
-          return bindAsyncIterator(resolverPayloadStorage, generator);
-        }
-      )
+    const resolverMiddlewares = this.resolvers.get(fieldName)?.["~meta"].options?.middlewares;
+    const middlewares = filterMiddlewares(
+      "subscription.subscribe",
+      this.globalOptions?.middlewares,
+      resolverMiddlewares,
+      field2["~meta"].middlewares
+    );
+    return (source, args, context, info) => {
+      const payload = { root: source, args, context, info, field: field2 };
+      const parseInput = createInputParser(field2["~meta"].input, args);
+      return applyMiddlewares(
+        {
+          operation: "subscription.subscribe",
+          outputSilk: field2["~meta"].output,
+          parent: void 0,
+          parseInput,
+          payload
+        },
+        async () => field2["~meta"].subscribe(
+          await parseInput.getResult(),
+          payload
+        ),
+        middlewares
+      );
     };
   }
   getCacheType(gqlType, fieldName) {
     return getCacheType(gqlType, { ...this.options, fieldName, parent: this });
   }
   get options() {
-    const { resolverOptions, weaverContext: weaverContext2 } = this;
+    const { globalOptions: resolverOptions, weaverContext: weaverContext2 } = this;
     return { resolverOptions, weaverContext: weaverContext2 };
   }
 };
@@ -1402,11 +1702,11 @@ function extract(field2) {
   };
 }
 function defineFieldMap(fields) {
-  const fieldMap = (0, import_graphql5.resolveObjMapThunk)(fields);
+  const fieldMap = (0, import_graphql8.resolveObjMapThunk)(fields);
   return mapValue(fieldMap, (fieldConfig, fieldName) => {
     const argsConfig = fieldConfig.args ?? {};
     return {
-      name: (0, import_graphql5.assertName)(fieldName),
+      name: (0, import_graphql8.assertName)(fieldName),
       description: fieldConfig.description,
       type: fieldConfig.type,
       args: defineArguments(argsConfig),
@@ -1420,7 +1720,7 @@ function defineFieldMap(fields) {
 }
 function defineArguments(args) {
   return Object.entries(args).map(([argName, argConfig]) => ({
-    name: (0, import_graphql5.assertName)(argName),
+    name: (0, import_graphql8.assertName)(argName),
     description: argConfig.description,
     type: argConfig.type,
     defaultValue: argConfig.defaultValue,
@@ -1437,7 +1737,7 @@ var OPERATION_OBJECT_NAMES = /* @__PURE__ */ new Set([
 function getCacheType(gqlType, options = {}) {
   const context = options.weaverContext ?? weaverContext;
   if (gqlType instanceof LoomObjectType) return gqlType;
-  if ((0, import_graphql5.isObjectType)(gqlType)) {
+  if ((0, import_graphql8.isObjectType)(gqlType)) {
     const gqlObject = context.loomObjectMap?.get(gqlType);
     if (gqlObject != null) return gqlObject;
     const loomObject = new LoomObjectType(gqlType, options);
@@ -1448,15 +1748,15 @@ function getCacheType(gqlType, options = {}) {
       );
     }
     return loomObject;
-  } else if ((0, import_graphql5.isListType)(gqlType)) {
-    return new import_graphql5.GraphQLList(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql5.isNonNullType)(gqlType)) {
-    return new import_graphql5.GraphQLNonNull(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql5.isUnionType)(gqlType)) {
+  } else if ((0, import_graphql8.isListType)(gqlType)) {
+    return new import_graphql8.GraphQLList(getCacheType(gqlType.ofType, options));
+  } else if ((0, import_graphql8.isNonNullType)(gqlType)) {
+    return new import_graphql8.GraphQLNonNull(getCacheType(gqlType.ofType, options));
+  } else if ((0, import_graphql8.isUnionType)(gqlType)) {
     const existing = context.loomUnionMap?.get(gqlType);
     if (existing != null) return existing;
     const config = gqlType.toConfig();
-    const unionType = new import_graphql5.GraphQLUnionType({
+    const unionType = new import_graphql8.GraphQLUnionType({
       ...config,
       types: config.types.map(
         (type) => getCacheType(type, options)
@@ -1483,7 +1783,7 @@ function isSchemaVendorWeaver(some) {
 }
 
 // src/schema/schema-loom.ts
-var import_graphql6 = require("graphql");
+var import_graphql9 = require("graphql");
 var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
   query;
   mutation;
@@ -1515,8 +1815,11 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     this.resolverOptions.middlewares.push(...middlewares);
     return this;
   }
-  add(resolver2) {
-    provideWeaverContext(() => this.addResolver(resolver2), this.context);
+  add(resolver2, modifyParent) {
+    provideWeaverContext(
+      () => this.addResolver(resolver2, modifyParent),
+      this.context
+    );
     return this;
   }
   addVendor(weaver) {
@@ -1526,14 +1829,14 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
   addType(silk2) {
     const gqlType = provideWeaverContext(() => {
       let gqlType2 = getGraphQLType(silk2);
-      if ((0, import_graphql6.isNonNullType)(gqlType2)) gqlType2 = gqlType2.ofType;
-      if ((0, import_graphql6.isObjectType)(gqlType2)) {
+      if ((0, import_graphql9.isNonNullType)(gqlType2)) gqlType2 = gqlType2.ofType;
+      if ((0, import_graphql9.isObjectType)(gqlType2)) {
         const existing = this.context.loomObjectMap.get(gqlType2);
         if (existing != null) return existing;
         const extraObject = new LoomObjectType(gqlType2, this.fieldOptions);
         this.context.loomObjectMap.set(gqlType2, extraObject);
         return extraObject;
-      } else if ((0, import_graphql6.isUnionType)(gqlType2) || (0, import_graphql6.isEnumType)(gqlType2)) {
+      } else if ((0, import_graphql9.isUnionType)(gqlType2) || (0, import_graphql9.isEnumType)(gqlType2)) {
         return gqlType2;
       }
       throw new Error(
@@ -1550,7 +1853,7 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
   weaveGraphQLSchema() {
     const { query: query2, mutation: mutation2, subscription: subscription2, types } = this;
     const config = this.context.getConfig("gqloom.core.schema");
-    const schema = new import_graphql6.GraphQLSchema({
+    const schema = new import_graphql9.GraphQLSchema({
       query: query2,
       mutation: mutation2,
       subscription: subscription2,
@@ -1559,14 +1862,14 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     });
     return schema;
   }
-  addResolver(resolver2) {
+  addResolver(resolver2, modifyParent) {
     const resolverOptions = resolver2["~meta"].options;
     const parent = resolver2["~meta"].parent;
-    const parentObject = (() => {
+    let parentObject = (() => {
       if (parent == null) return void 0;
       let gqlType = getGraphQLType(parent);
-      if ((0, import_graphql6.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
-      if (!(0, import_graphql6.isObjectType)(gqlType)) {
+      if ((0, import_graphql9.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
+      if (!(0, import_graphql9.isObjectType)(gqlType)) {
         throw new Error(
           `${gqlType?.name ?? gqlType.toString()} is not an object type`
         );
@@ -1580,18 +1883,20 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     })();
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
+    if (modifyParent != null && parentObject)
+      parentObject = modifyParent(parentObject);
     Object.entries(resolver2["~meta"].fields).forEach(([name, field2]) => {
       if (field2 === FIELD_HIDDEN) {
         if (parentObject == null) return;
         parentObject.hideField(name);
       } else if (field2["~meta"].operation === "field") {
         if (parentObject == null) return;
-        parentObject.addField(name, field2);
+        parentObject.addField(name, field2, resolver2);
       } else {
         const operationObject = this.getOperationObject(
           field2["~meta"].operation
         );
-        operationObject.addField(name, field2);
+        operationObject.addField(name, field2, resolver2);
       }
     });
     return this;
@@ -1623,7 +1928,7 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
   }
   get fieldOptions() {
     const { resolverOptions, context } = this;
-    return { resolverOptions, weaverContext: context };
+    return { globalOptions: resolverOptions, weaverContext: context };
   }
   static optionsFrom(...inputs) {
     const configs = /* @__PURE__ */ new Set();
@@ -1633,6 +1938,7 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
     const weavers = /* @__PURE__ */ new Set();
     let context;
     for (const item of inputs) {
+      if (item == null) continue;
       if (isSchemaVendorWeaver(item)) {
         weavers.add(item);
       } else if (typeof item === "function") {
@@ -1670,10 +1976,10 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
 var weave = GraphQLSchemaLoom.weave;
 
 // src/schema/interface.ts
-var import_graphql7 = require("graphql");
+var import_graphql10 = require("graphql");
 function ensureInterfaceType(gqlType, interfaceConfig) {
-  if ((0, import_graphql7.isInterfaceType)(gqlType)) return gqlType;
-  if (!(0, import_graphql7.isObjectType)(gqlType))
+  if ((0, import_graphql10.isInterfaceType)(gqlType)) return gqlType;
+  if (!(0, import_graphql10.isObjectType)(gqlType))
     throw new Error(`${gqlType.toString()} is not an object`);
   const key = gqlType;
   const existing = weaverContext.interfaceMap?.get(key);
@@ -1684,7 +1990,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
     fields,
     ...config
   } = gqlType.toConfig();
-  const interfaceType = new import_graphql7.GraphQLInterfaceType({
+  const interfaceType = new import_graphql10.GraphQLInterfaceType({
     ...config,
     ...interfaceConfig,
     fields: mapValue(fields, (field2) => {
@@ -1698,7 +2004,6 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 0 && (module.exports = {
   BaseChainFactory,
   ChainResolver,
-  ContextMemoization,
   EasyDataLoader,
   FieldChainFactory,
   FieldFactoryWithResolve,
@@ -1713,13 +2018,12 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   SYMBOLS,
   SubscriptionChainFactory,
   applyMiddlewares,
+  assignContextMap,
   capitalize,
   collectName,
   collectNames,
-  compose,
   createField,
   createInputParser,
-  createMemoization,
   createMutation,
   createQuery,
   createSubscription,
@@ -1729,10 +2033,13 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   ensureInputType,
   ensureInterfaceType,
   field,
+  filterMiddlewares,
   getCacheType,
   getFieldOptions,
   getGraphQLType,
+  getMemoizationMap,
   getOperationOptions,
+  getResolvingFields,
   getStandardValue,
   getSubscriptionOptions,
   initWeaverContext,
@@ -1752,20 +2059,17 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   nullableSilk,
   onlyMemoization,
   parseInputValue,
+  parseResolvingFields,
   parseSilk,
   pascalCase,
   provideWeaverContext,
   query,
   resolver,
-  resolverPayloadStorage,
   screamingSnakeCase,
   silk,
   subscription,
   toObjMap,
   tryIn,
-  useContext,
-  useMemoizationMap,
-  useResolverPayload,
   weave,
   weaverContext
 });