@gqloom/core 0.8.3 → 0.9.0

package/dist/index.js

@@ -1,8 +1,17 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  DERIVED_DEPENDENCIES,
+  FIELD_HIDDEN,
+  GET_GRAPHQL_TYPE,
+  IS_RESOLVER,
+  WEAVER_CONFIG,
+  assignContextMap,
+  getMemoizationMap,
+  getResolvingFields,
+  isOnlyMemoryPayload,
+  onlyMemoization,
+  parseResolvingFields,
+  symbols_exports
+} from "./chunk-BQAPYNA7.js";
 
 // src/utils/args.ts
 function getOperationOptions(resolveOrOptions) {
@@ -17,20 +26,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();
@@ -44,122 +55,20 @@ 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
-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 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;
+  }, []);
 }
-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
-  });
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
 }
 
 // src/utils/object.ts
@@ -224,6 +133,9 @@ function pascalCase(str) {
 function capitalize(str) {
   return str.slice(0, 1).toUpperCase() + str.slice(1);
 }
+function screamingSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[\s-_]+/).map((word) => word.toUpperCase()).join("_");
+}
 
 // src/utils/error.ts
 function markErrorLocation(error, ...locations) {
@@ -593,9 +505,16 @@ function getStandardValue(result) {
 
 // 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,
@@ -603,15 +522,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]
@@ -619,6 +554,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(),
@@ -628,15 +566,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, {
@@ -644,40 +609,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(),
@@ -687,15 +659,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, {
@@ -705,6 +700,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(),
@@ -714,15 +713,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, {
@@ -732,6 +754,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(),
@@ -741,15 +767,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;
@@ -839,20 +889,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(
@@ -864,20 +907,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(
@@ -889,20 +925,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(
@@ -916,72 +948,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),
   {
@@ -1001,6 +981,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,
@@ -1008,38 +993,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 = {
@@ -1049,9 +1079,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 ??= {};
@@ -1077,17 +1114,6 @@ import {
   resolveObjMapThunk
 } from "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;
-}
-
 // src/schema/input.ts
 import {
   GraphQLInputObjectType,
@@ -1192,7 +1218,11 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
   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 = (() => {
@@ -1205,8 +1235,9 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
       }
     })();
     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;
     }
@@ -1233,12 +1264,13 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
   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);
@@ -1273,58 +1305,140 @@ var LoomObjectType = class _LoomObjectType extends GraphQLObjectType {
     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 };
   }
 };
@@ -1527,12 +1641,12 @@ var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
         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;
@@ -1564,7 +1678,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();
@@ -1574,6 +1688,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") {
@@ -1642,7 +1757,6 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 export {
   BaseChainFactory,
   ChainResolver,
-  ContextMemoization,
   EasyDataLoader,
   FieldChainFactory,
   FieldFactoryWithResolve,
@@ -1657,13 +1771,12 @@ export {
   symbols_exports as SYMBOLS,
   SubscriptionChainFactory,
   applyMiddlewares,
+  assignContextMap,
   capitalize,
   collectName,
   collectNames,
-  compose,
   createField,
   createInputParser,
-  createMemoization,
   createMutation,
   createQuery,
   createSubscription,
@@ -1673,10 +1786,13 @@ export {
   ensureInputType,
   ensureInterfaceType,
   field,
+  filterMiddlewares,
   getCacheType,
   getFieldOptions,
   getGraphQLType,
+  getMemoizationMap,
   getOperationOptions,
+  getResolvingFields,
   getStandardValue,
   getSubscriptionOptions,
   initWeaverContext,
@@ -1696,19 +1812,17 @@ export {
   nullableSilk,
   onlyMemoization,
   parseInputValue,
+  parseResolvingFields,
   parseSilk,
   pascalCase,
   provideWeaverContext,
   query,
   resolver,
-  resolverPayloadStorage,
+  screamingSnakeCase,
   silk,
   subscription,
   toObjMap,
   tryIn,
-  useContext,
-  useMemoizationMap,
-  useResolverPayload,
   weave,
   weaverContext
 };