@gqloom/core 0.8.4 → 0.9.1

package/dist/context.d.ts

@@ -0,0 +1,137 @@
+import { P as OnlyMemoizationPayload, R as ResolverPayload, B as BaseField, v as Middleware, K as ResolvingFields } from './context-DsvT0-C6.js';
+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 };

package/dist/context.js

@@ -0,0 +1,234 @@
+import {
+  getMemoizationMap,
+  getResolvingFields,
+  isOnlyMemoryPayload,
+  onlyMemoization
+} from "./chunk-BQAPYNA7.js";
+
+// src/context/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// 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 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);
+  }
+);
+export {
+  ContextMemoization,
+  InjectableContext,
+  asyncContextProvider,
+  bindAsyncIterator,
+  createContext,
+  createMemoization,
+  isAsyncIterator,
+  resolverPayloadStorage,
+  useContext,
+  useMemoizationMap,
+  useResolverPayload,
+  useResolvingFields
+};