@gqloom/core 0.10.0 → 0.11.0

package/dist/context.cjs

@@ -1,460 +1,259 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/context/index.ts
-var context_exports = {};
-__export(context_exports, {
-  ContextMemoization: () => ContextMemoization,
-  InjectableContext: () => InjectableContext,
-  asyncContextProvider: () => asyncContextProvider,
-  bindAsyncIterator: () => bindAsyncIterator,
-  createContext: () => createContext,
-  createMemoization: () => createMemoization,
-  isAsyncIterator: () => isAsyncIterator,
-  resolverPayloadStorage: () => resolverPayloadStorage,
-  useContext: () => useContext,
-  useMemoizationMap: () => useMemoizationMap,
-  useResolverPayload: () => useResolverPayload,
-  useResolvingFields: () => useResolvingFields
-});
-module.exports = __toCommonJS(context_exports);
-
-// src/utils/parse-resolving-fields.ts
-var import_graphql3 = require("graphql");
-
-// src/utils/constants.ts
-var DERIVED_DEPENDENCIES = "loom.derived-from-dependencies";
+const require_context = require('./context-3UlS1xGQ.cjs');
+let node_async_hooks = require("node:async_hooks");
+node_async_hooks = require_context.__toESM(node_async_hooks);
 
-// 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 field = objectFields[requestedFieldName];
-      if (field) {
-        const deps = field.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/context/context.ts
-var import_node_async_hooks = require("async_hooks");
-
-// src/utils/symbols.ts
-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");
-
-// 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/context/async-iterator.ts
+//#region src/context/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;
+	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;
 }
 function isAsyncIterator(value) {
-  return value !== null && typeof value === "object" && "next" in value && typeof value.next === "function";
+	return value !== null && typeof value === "object" && "next" in value && typeof value.next === "function";
 }
 
-// src/context/context.ts
-var resolverPayloadStorage = new import_node_async_hooks.AsyncLocalStorage();
+//#endregion
+//#region src/context/context.ts
+/**
+* the AsyncLocalStorage instance to store the resolver payload
+*/
+const resolverPayloadStorage = new node_async_hooks.AsyncLocalStorage();
+/**
+* use detailed payload of the current resolver
+* @returns the resolver payload
+*/
 function useResolverPayload() {
-  const payload = resolverPayloadStorage.getStore();
-  if (payload === void 0 || isOnlyMemoryPayload(payload)) return;
-  return payload;
+	const payload = resolverPayloadStorage.getStore();
+	if (payload === void 0 || require_context.isOnlyMemoryPayload(payload)) return;
+	return payload;
 }
+/**
+* use context of the current resolver
+* @returns the context of the current resolver
+*/
 function useContext() {
-  return useResolverPayload()?.context;
+	return useResolverPayload()?.context;
 }
+/**
+* use the MemoizationMap of the current context
+*/
 function useMemoizationMap() {
-  const payload = resolverPayloadStorage.getStore();
-  if (payload == null) return;
-  return getMemoizationMap(payload);
+	const payload = resolverPayloadStorage.getStore();
+	if (payload == null) return;
+	return require_context.getMemoizationMap(payload);
 }
+/**
+* A class that provides dependency injection and context sharing capabilities.
+* It allows you to create injectable dependencies that can be shared across different parts of your application.
+*
+* @template T The type of the value that will be injected
+*
+*/
 var InjectableContext = class {
-  /**
-   * Creates a new instance of InjectableContext.
-   *
-   * @param getter - A function that returns the default value when no custom implementation is provided
-   * @param options - Optional configuration for the context
-   * @param options.getContextMap - A function that returns the WeakMap used to store context values. Defaults to useMemoizationMap
-   * @param options.key - A unique key used to identify this context in the WeakMap. Defaults to the getter function
-   */
-  constructor(getter, options = {}) {
-    this.getter = getter;
-    this.getter = getter;
-    this.getContextMap = options.getContextMap ?? useMemoizationMap;
-    this.key = options.key ?? this.getter;
-  }
-  /**
-   * A function that returns the WeakMap used to store context values.
-   * This can be customized to use different storage mechanisms.
-   */
-  getContextMap;
-  /**
-   * A unique key used to identify this context in the WeakMap.
-   * This is used to store and retrieve values from the context map.
-   */
-  key;
-  /**
-   * Retrieves the value from the context.
-   * If a custom implementation is provided, it will be used.
-   * Otherwise, the default getter function will be called.
-   *
-   * @returns The value of type T
-   */
-  get() {
-    const getter = this.getContextMap()?.get(this.key) ?? this.getter;
-    if (typeof getter === "function") return getter();
-    return getter;
-  }
-  /**
-   * Provides a new implementation for this context.
-   *
-   * @param getter - A function that returns the new value
-   * @returns A tuple containing the key and the new getter function
-   */
-  provide(getter) {
-    return [this.key, getter];
-  }
+	/**
+	* Creates a new instance of InjectableContext.
+	*
+	* @param getter - A function that returns the default value when no custom implementation is provided
+	* @param options - Optional configuration for the context
+	* @param options.getContextMap - A function that returns the WeakMap used to store context values. Defaults to useMemoizationMap
+	* @param options.key - A unique key used to identify this context in the WeakMap. Defaults to the getter function
+	*/
+	constructor(getter, options = {}) {
+		this.getter = getter;
+		this.getter = getter;
+		this.getContextMap = options.getContextMap ?? useMemoizationMap;
+		this.key = options.key ?? this.getter;
+	}
+	/**
+	* A function that returns the WeakMap used to store context values.
+	* This can be customized to use different storage mechanisms.
+	*/
+	getContextMap;
+	/**
+	* A unique key used to identify this context in the WeakMap.
+	* This is used to store and retrieve values from the context map.
+	*/
+	key;
+	/**
+	* Retrieves the value from the context.
+	* If a custom implementation is provided, it will be used.
+	* Otherwise, the default getter function will be called.
+	*
+	* @returns The value of type T
+	*/
+	get() {
+		const getter = this.getContextMap()?.get(this.key) ?? this.getter;
+		if (typeof getter === "function") return getter();
+		return getter;
+	}
+	/**
+	* Provides a new implementation for this context.
+	*
+	* @param getter - A function that returns the new value
+	* @returns A tuple containing the key and the new getter function
+	*/
+	provide(getter) {
+		return [this.key, getter];
+	}
 };
+/**
+* Create a memoization in context to store the result of a getter function
+*/
 var ContextMemoization = class {
-  constructor(getter, options = {}) {
-    this.getter = getter;
-    this.getter = getter;
-    this.getContextMap = options.getContextMap ?? useMemoizationMap;
-    this.key = options.key ?? this.getter;
-  }
-  getContextMap;
-  key;
-  /**
-   * Get the value in memoization or call the getter function
-   * @returns the value of the getter function
-   */
-  get() {
-    const map = this.getContextMap();
-    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.getContextMap();
-    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.getContextMap();
-    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.getContextMap();
-    if (!map) return;
-    return map.set(this.key, value);
-  }
-  provide(value) {
-    return [this.key, value];
-  }
+	constructor(getter, options = {}) {
+		this.getter = getter;
+		this.getter = getter;
+		this.getContextMap = options.getContextMap ?? useMemoizationMap;
+		this.key = options.key ?? this.getter;
+	}
+	getContextMap;
+	key;
+	/**
+	* Get the value in memoization or call the getter function
+	* @returns the value of the getter function
+	*/
+	get() {
+		const map = this.getContextMap();
+		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.getContextMap();
+		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.getContextMap();
+		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.getContextMap();
+		if (!map) return;
+		return map.set(this.key, value);
+	}
+	provide(value) {
+		return [this.key, value];
+	}
 };
+/**
+* Create a callable context
+* @param args - The arguments to pass to the InjectableContext constructor
+* @returns A callable context
+*/
 function createContext(...args) {
-  const context = new InjectableContext(...args);
-  const callable = () => context.get();
-  Object.defineProperty(context, "key", {
-    value: callable,
-    writable: false,
-    configurable: false
-  });
-  return Object.assign(callable, {
-    key: context.key,
-    get: () => context.get(),
-    provide: (getter) => context.provide(getter),
-    getContextMap: () => context.getContextMap(),
-    getter: context.getter
-  });
+	const context = new InjectableContext(...args);
+	const callable = () => context.get();
+	Object.defineProperty(context, "key", {
+		value: callable,
+		writable: false,
+		configurable: false
+	});
+	return Object.assign(callable, {
+		key: context.key,
+		get: () => context.get(),
+		provide: (getter) => context.provide(getter),
+		getContextMap: () => context.getContextMap(),
+		getter: context.getter
+	});
 }
+/**
+* Create a memoization in context to store the result of a getter function
+*/
 function createMemoization(...args) {
-  const memoization = new ContextMemoization(...args);
-  const callable = () => memoization.get();
-  Object.defineProperty(memoization, "key", {
-    value: callable,
-    writable: false,
-    configurable: false
-  });
-  return Object.assign(callable, {
-    key: memoization.key,
-    get: () => memoization.get(),
-    set: (value) => memoization.set(value),
-    clear: () => memoization.clear(),
-    exists: () => memoization.exists(),
-    getter: memoization.getter,
-    provide: (value) => memoization.provide(value),
-    getContextMap: () => memoization.getContextMap()
-  });
+	const memoization = new ContextMemoization(...args);
+	const callable = () => memoization.get();
+	Object.defineProperty(memoization, "key", {
+		value: callable,
+		writable: false,
+		configurable: false
+	});
+	return Object.assign(callable, {
+		key: memoization.key,
+		get: () => memoization.get(),
+		set: (value) => memoization.set(value),
+		clear: () => memoization.clear(),
+		exists: () => memoization.exists(),
+		getter: memoization.getter,
+		provide: (value) => memoization.provide(value),
+		getContextMap: () => memoization.getContextMap()
+	});
 }
-var createProvider = (...keyValues) => {
-  return ({ next, payload, operation }) => {
-    const store = payload ?? onlyMemoization();
-    const map = getMemoizationMap(store);
-    if (map) {
-      for (const [key, value] of keyValues) {
-        map.set(key, value);
-      }
-    }
-    if (operation === "subscription.subscribe") {
-      return resolverPayloadStorage.run(store, async () => {
-        let result = await next();
-        if (isAsyncIterator(result)) {
-          result = bindAsyncIterator(resolverPayloadStorage, result);
-        }
-        return result;
-      });
-    }
-    return resolverPayloadStorage.run(store, next);
-  };
+const createProvider = (...keyValues) => {
+	return ({ next, payload, operation }) => {
+		const store = payload ?? require_context.onlyMemoization();
+		const map = require_context.getMemoizationMap(store);
+		if (map) for (const [key, value] of keyValues) map.set(key, value);
+		if (operation === "subscription.subscribe") return resolverPayloadStorage.run(store, async () => {
+			let result = await next();
+			if (isAsyncIterator(result)) result = bindAsyncIterator(resolverPayloadStorage, result);
+			return result;
+		});
+		return resolverPayloadStorage.run(store, next);
+	};
 };
-var asyncContextProvider = Object.assign(
-  createProvider(),
-  {
-    operations: [
-      "query",
-      "mutation",
-      "field",
-      "subscription.resolve",
-      "subscription.subscribe",
-      "resolveReference"
-    ],
-    with: (...keyValues) => {
-      return createProvider(...keyValues);
-    },
-    run: async (resolve, ...keyValues) => {
-      const store = onlyMemoization();
-      const map = getMemoizationMap(store);
-      for (const [key, value] of keyValues) {
-        map.set(key, value);
-      }
-      return resolverPayloadStorage.run(store, resolve);
-    }
-  }
-);
+const asyncContextProvider = Object.assign(createProvider(), {
+	operations: [
+		"query",
+		"mutation",
+		"field",
+		"subscription.resolve",
+		"subscription.subscribe",
+		"resolveReference"
+	],
+	with: (...keyValues) => {
+		return createProvider(...keyValues);
+	},
+	run: async (resolve, ...keyValues) => {
+		const store = require_context.onlyMemoization();
+		const map = require_context.getMemoizationMap(store);
+		for (const [key, value] of keyValues) map.set(key, value);
+		return resolverPayloadStorage.run(store, resolve);
+	}
+});
 
-// src/context/use-resolving-fields.ts
-var useResolvingFields = createContext(
-  () => {
-    const payload = useResolverPayload();
-    if (!payload) return;
-    return getResolvingFields(payload);
-  }
-);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ContextMemoization,
-  InjectableContext,
-  asyncContextProvider,
-  bindAsyncIterator,
-  createContext,
-  createMemoization,
-  isAsyncIterator,
-  resolverPayloadStorage,
-  useContext,
-  useMemoizationMap,
-  useResolverPayload,
-  useResolvingFields
+//#endregion
+//#region src/context/use-resolving-fields.ts
+/**
+* A hook that analyzes and processes field resolution in a GraphQL query.
+*
+* @returns An object containing sets of different field types,
+* or undefined if no resolver payload is available
+*/
+const useResolvingFields = createContext(() => {
+	const payload = useResolverPayload();
+	if (!payload) return;
+	return require_context.getResolvingFields(payload);
 });
+
+//#endregion
+exports.ContextMemoization = ContextMemoization;
+exports.InjectableContext = InjectableContext;
+exports.asyncContextProvider = asyncContextProvider;
+exports.bindAsyncIterator = bindAsyncIterator;
+exports.createContext = createContext;
+exports.createMemoization = createMemoization;
+exports.isAsyncIterator = isAsyncIterator;
+exports.resolverPayloadStorage = resolverPayloadStorage;
+exports.useContext = useContext;
+exports.useMemoizationMap = useMemoizationMap;
+exports.useResolverPayload = useResolverPayload;
+exports.useResolvingFields = useResolvingFields;