@gqloom/core 0.8.4 → 0.9.1

package/dist/context.cjs

@@ -0,0 +1,453 @@
+"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";
+
+// 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");
+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/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;
+}
+function isAsyncIterator(value) {
+  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();
+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;
+  return getMemoizationMap(payload);
+}
+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];
+  }
+};
+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];
+  }
+};
+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
+  });
+}
+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()
+  });
+}
+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);
+  };
+};
+var asyncContextProvider = Object.assign(
+  createProvider(),
+  {
+    operations: [
+      "query",
+      "mutation",
+      "field",
+      "subscription.resolve",
+      "subscription.subscribe",
+      "resolveReference"
+    ],
+    with: (...keyValues) => {
+      return createProvider(...keyValues);
+    }
+  }
+);
+
+// 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
+});

package/dist/context.d.cts

@@ -0,0 +1,137 @@
+import { P as OnlyMemoizationPayload, R as ResolverPayload, B as BaseField, v as Middleware, K as ResolvingFields } from './context-DsvT0-C6.cjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import 'graphql';
+
+/**
+ * the AsyncLocalStorage instance to store the resolver payload
+ */
+declare const resolverPayloadStorage: AsyncLocalStorage<OnlyMemoizationPayload | ResolverPayload<object, BaseField>>;
+/**
+ * use detailed payload of the current resolver
+ * @returns the resolver payload
+ */
+declare function useResolverPayload(): ResolverPayload | undefined;
+/**
+ * use context of the current resolver
+ * @returns the context of the current resolver
+ */
+declare function useContext<TContextType = object>(): TContextType;
+/**
+ * use the MemoizationMap of the current context
+ */
+declare function useMemoizationMap(): WeakMap<WeakKey, any> | undefined;
+interface ContextOptions {
+    getContextMap: () => WeakMap<WeakKey, any> | undefined;
+    key: WeakKey;
+}
+/**
+ * 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
+ *
+ */
+declare class InjectableContext<T> implements ContextOptions {
+    readonly getter: () => T;
+    /**
+     * 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: () => T, options?: Partial<ContextOptions>);
+    /**
+     * A function that returns the WeakMap used to store context values.
+     * This can be customized to use different storage mechanisms.
+     */
+    getContextMap: () => WeakMap<WeakKey, any> | undefined;
+    /**
+     * A unique key used to identify this context in the WeakMap.
+     * This is used to store and retrieve values from the context map.
+     */
+    readonly key: WeakKey;
+    /**
+     * 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(): T;
+    /**
+     * 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: () => T): [WeakKey, () => T];
+}
+/**
+ * Create a memoization in context to store the result of a getter function
+ */
+declare class ContextMemoization<T> implements ContextOptions {
+    readonly getter: () => T;
+    constructor(getter: () => T, options?: Partial<ContextOptions>);
+    getContextMap: () => WeakMap<WeakKey, any> | undefined;
+    readonly key: WeakKey;
+    /**
+     * Get the value in memoization or call the getter function
+     * @returns the value of the getter function
+     */
+    get(): T;
+    /**
+     * Clear the memoization
+     * @returns true if the memoization is cleared, undefined if the context is not found
+     */
+    clear(): boolean | undefined;
+    /**
+     * Check if the memoization exists
+     * @returns true if the memoization exists, undefined if the context is not found
+     */
+    exists(): boolean | undefined;
+    /**
+     * 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: T): WeakMap<WeakKey, any> | undefined;
+    provide(value: T): [WeakKey, T];
+}
+interface CallableContext<T> extends InjectableContext<T> {
+    (): T;
+}
+/**
+ * Create a callable context
+ * @param args - The arguments to pass to the InjectableContext constructor
+ * @returns A callable context
+ */
+declare function createContext<T>(...args: ConstructorParameters<typeof InjectableContext<T>>): CallableContext<T>;
+/**
+ * Async Memoization with a callable function
+ */
+interface CallableContextMemoization<T> extends ContextMemoization<T> {
+    (): T;
+}
+/**
+ * Create a memoization in context to store the result of a getter function
+ */
+declare function createMemoization<T>(...args: ConstructorParameters<typeof ContextMemoization<T>>): CallableContextMemoization<T>;
+interface AsyncContextProvider extends Middleware {
+    with: (...keyValues: [WeakKey, any][]) => Middleware;
+}
+declare const asyncContextProvider: AsyncContextProvider;
+
+/**
+ * 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
+ */
+declare const useResolvingFields: CallableContext<ResolvingFields | undefined>;
+
+declare function bindAsyncIterator<TAsyncLocalStorage extends AsyncLocalStorage<unknown>, TAsyncIterator extends AsyncIterator<unknown, unknown, unknown>>(storage: TAsyncLocalStorage, generator: TAsyncIterator): TAsyncIterator;
+declare function isAsyncIterator(value: unknown): value is AsyncIterator<unknown, unknown, unknown>;
+
+export { type AsyncContextProvider, type CallableContext, type CallableContextMemoization, ContextMemoization, InjectableContext, asyncContextProvider, bindAsyncIterator, createContext, createMemoization, isAsyncIterator, resolverPayloadStorage, useContext, useMemoizationMap, useResolverPayload, useResolvingFields };