@fluojs/graphql 1.0.0-beta.1

package/dist/decorators.js

@@ -0,0 +1,111 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { argMetadataSymbol, handlerMetadataSymbol, resolverMetadataSymbol } from './metadata.js';
+function getStandardMetadataBag(metadata) {
+  void metadataSymbol;
+  return metadata;
+}
+function normalizeResolverTypeName(typeName, fallbackName) {
+  const trimmed = typeName?.trim();
+  if (trimmed) {
+    return trimmed;
+  }
+  return fallbackName;
+}
+function normalizeMethodMetadata(type, fieldNameOrOptions) {
+  if (typeof fieldNameOrOptions === 'string') {
+    return {
+      fieldName: fieldNameOrOptions.trim() || undefined,
+      type
+    };
+  }
+  if (!fieldNameOrOptions) {
+    return {
+      type
+    };
+  }
+  return {
+    argTypes: fieldNameOrOptions.argTypes,
+    fieldName: fieldNameOrOptions.fieldName?.trim() || undefined,
+    inputClass: fieldNameOrOptions.input,
+    outputType: fieldNameOrOptions.outputType,
+    topics: fieldNameOrOptions.topics,
+    type
+  };
+}
+function defineStandardResolverMetadata(metadata, resolverMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  bag[resolverMetadataSymbol] = {
+    typeName: resolverMetadata.typeName
+  };
+}
+function defineStandardHandlerMetadata(metadata, propertyKey, handlerMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[handlerMetadataSymbol];
+  const map = current ?? new Map();
+  map.set(propertyKey, {
+    argTypes: handlerMetadata.argTypes,
+    fieldName: handlerMetadata.fieldName,
+    inputClass: handlerMetadata.inputClass,
+    outputType: handlerMetadata.outputType,
+    topics: handlerMetadata.topics,
+    type: handlerMetadata.type
+  });
+  bag[handlerMetadataSymbol] = map;
+}
+function defineStandardArgFieldMetadata(metadata, propertyKey, argFieldMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[argMetadataSymbol];
+  const map = current ?? new Map();
+  map.set(propertyKey, {
+    argName: argFieldMetadata.argName,
+    fieldName: argFieldMetadata.fieldName
+  });
+  bag[argMetadataSymbol] = map;
+}
+function createMethodDecorator(type, fieldNameOrOptions) {
+  const metadata = normalizeMethodMetadata(type, fieldNameOrOptions);
+  const decorator = (_value, context) => {
+    const name = type === 'query' ? 'Query' : type === 'mutation' ? 'Mutation' : 'Subscription';
+    if (context.private) {
+      throw new Error(`@${name}() cannot be used on private methods.`);
+    }
+    if (context.static) {
+      throw new Error(`@${name}() cannot be used on static methods.`);
+    }
+    defineStandardHandlerMetadata(context.metadata, context.name, metadata);
+  };
+  return decorator;
+}
+export function Resolver(typeName) {
+  const decorator = (value, context) => {
+    defineStandardResolverMetadata(context.metadata, {
+      typeName: normalizeResolverTypeName(typeName, value.name || 'Resolver')
+    });
+  };
+  return decorator;
+}
+export function Query(fieldNameOrOptions) {
+  return createMethodDecorator('query', fieldNameOrOptions);
+}
+export function Mutation(fieldNameOrOptions) {
+  return createMethodDecorator('mutation', fieldNameOrOptions);
+}
+export function Subscription(fieldNameOrOptions) {
+  return createMethodDecorator('subscription', fieldNameOrOptions);
+}
+export function Arg(argName) {
+  const decorator = (_value, context) => {
+    if (context.private) {
+      throw new Error('@Arg() cannot be used on private fields.');
+    }
+    if (context.static) {
+      throw new Error('@Arg() cannot be used on static fields.');
+    }
+    const fieldName = typeof context.name === 'symbol' ? context.name.toString() : context.name;
+    defineStandardArgFieldMetadata(context.metadata, context.name, {
+      argName: argName?.trim() || fieldName,
+      fieldName
+    });
+  };
+  return decorator;
+}

package/dist/discovery.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledModule } from '@fluojs/runtime';
+import type { GraphqlModuleOptions, ResolverDescriptor } from './types.js';
+export declare function discoverResolverDescriptors(compiledModules: readonly CompiledModule[], options: GraphqlModuleOptions): ResolverDescriptor[];
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAkI3E,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,OAAO,EAAE,oBAAoB,GAC5B,kBAAkB,EAAE,CA+CtB"}

package/dist/discovery.js

@@ -0,0 +1,142 @@
+import { getClassDiMetadata } from '@fluojs/core/internal';
+import { getArgFieldMetadataEntries, getResolverHandlerMetadataEntries, getResolverMetadata } from './metadata.js';
+function scopeFromProvider(provider, factoryResolverClass) {
+  if (typeof provider === 'function') {
+    return getClassDiMetadata(provider)?.scope ?? 'singleton';
+  }
+  if ('useClass' in provider) {
+    return provider.scope ?? getClassDiMetadata(provider.useClass)?.scope ?? 'singleton';
+  }
+  if ('useFactory' in provider) {
+    return provider.scope ?? (factoryResolverClass ? getClassDiMetadata(factoryResolverClass)?.scope : undefined) ?? 'singleton';
+  }
+  return 'singleton';
+}
+function isClassProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useClass' in provider;
+}
+function isValueProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useValue' in provider;
+}
+function isFactoryProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useFactory' in provider;
+}
+function methodKeyToName(methodKey) {
+  return typeof methodKey === 'symbol' ? methodKey.toString() : methodKey;
+}
+function normalizeAllowedResolverSet(resolvers) {
+  if (!resolvers || resolvers.length === 0) {
+    return undefined;
+  }
+  return new Set(resolvers);
+}
+function discoveryCandidates(compiledModules) {
+  const candidates = [];
+  for (const compiledModule of compiledModules) {
+    for (const provider of compiledModule.definition.providers ?? []) {
+      if (typeof provider === 'function') {
+        candidates.push({
+          moduleName: compiledModule.type.name,
+          scope: scopeFromProvider(provider),
+          targetType: provider,
+          token: provider
+        });
+        continue;
+      }
+      if (isClassProvider(provider)) {
+        candidates.push({
+          moduleName: compiledModule.type.name,
+          scope: scopeFromProvider(provider),
+          targetType: provider.useClass,
+          token: provider.provide
+        });
+        continue;
+      }
+      if (isValueProvider(provider)) {
+        const value = provider.useValue;
+        if (typeof value === 'function') {
+          candidates.push({
+            moduleName: compiledModule.type.name,
+            scope: 'singleton',
+            targetType: value,
+            token: provider.provide
+          });
+          continue;
+        }
+        if (typeof value === 'object' && value !== null) {
+          const constructor = value.constructor;
+          if (constructor && constructor !== Object) {
+            candidates.push({
+              moduleName: compiledModule.type.name,
+              scope: 'singleton',
+              targetType: constructor,
+              token: provider.provide
+            });
+          }
+        }
+        continue;
+      }
+      if (isFactoryProvider(provider)) {
+        const resolverClass = provider.resolverClass;
+        if (resolverClass) {
+          candidates.push({
+            moduleName: compiledModule.type.name,
+            scope: scopeFromProvider(provider, resolverClass),
+            targetType: resolverClass,
+            token: provider.provide
+          });
+        }
+      }
+    }
+    for (const controller of compiledModule.definition.controllers ?? []) {
+      candidates.push({
+        moduleName: compiledModule.type.name,
+        scope: scopeFromProvider(controller),
+        targetType: controller,
+        token: controller
+      });
+    }
+  }
+  return candidates;
+}
+export function discoverResolverDescriptors(compiledModules, options) {
+  const allowedResolvers = normalizeAllowedResolverSet(options.resolvers);
+  const seenTargets = new Set();
+  const descriptors = [];
+  for (const candidate of discoveryCandidates(compiledModules)) {
+    if (allowedResolvers && !allowedResolvers.has(candidate.targetType)) {
+      continue;
+    }
+    const resolverMetadata = getResolverMetadata(candidate.targetType);
+    if (!resolverMetadata) {
+      continue;
+    }
+    if (seenTargets.has(candidate.targetType)) {
+      continue;
+    }
+    seenTargets.add(candidate.targetType);
+    descriptors.push({
+      handlers: getResolverHandlerMetadataEntries(candidate.targetType.prototype).map(entry => {
+        const inputClass = entry.metadata.inputClass;
+        const argFields = inputClass !== undefined ? getArgFieldMetadataEntries(inputClass.prototype).map(argField => argField.metadata) : [];
+        return {
+          argFields,
+          argTypes: entry.metadata.argTypes,
+          fieldName: entry.metadata.fieldName ?? methodKeyToName(entry.propertyKey),
+          inputClass,
+          methodKey: entry.propertyKey,
+          methodName: methodKeyToName(entry.propertyKey),
+          outputType: entry.metadata.outputType,
+          topics: entry.metadata.topics,
+          type: entry.metadata.type
+        };
+      }),
+      moduleName: candidate.moduleName,
+      scope: candidate.scope,
+      targetName: candidate.targetType.name,
+      token: candidate.token,
+      typeName: resolverMetadata.typeName
+    });
+  }
+  return descriptors;
+}

package/dist/guardrails.d.ts

@@ -0,0 +1,35 @@
+import { GraphQLError, type ExecutionArgs, type ValidationRule } from 'graphql';
+import type { GraphqlRequestLimitsOptions } from './types.js';
+interface GraphqlValidationPluginContext {
+    addValidationRule(rule: ValidationRule): void;
+}
+interface GraphqlValidationPlugin {
+    onExecute?(payload: GraphqlOperationHookPayload): void;
+    onSubscribe?(payload: GraphqlOperationHookPayload): void;
+    onValidate?(context: GraphqlValidationPluginContext): void;
+}
+interface GraphqlOperationHookPayload {
+    args: Pick<ExecutionArgs, 'document' | 'operationName'>;
+    setResultAndStopExecution(result: {
+        errors: GraphQLError[];
+    }): void;
+}
+/**
+ * Resolve the effective GraphQL request budget configuration for one module instance.
+ *
+ * @param limits User-provided request limit overrides, or `false` to disable built-in budgets.
+ * @returns The normalized request limits, or `undefined` when guardrails are explicitly disabled.
+ */
+export declare function resolveGraphqlRequestLimits(limits: GraphqlRequestLimitsOptions | false | undefined): Required<GraphqlRequestLimitsOptions> | undefined;
+/**
+ * Create the GraphQL plugin that enforces introspection and request-budget guardrails.
+ *
+ * @param options Effective guardrail settings for introspection and per-request limits.
+ * @returns An Envelop-compatible plugin when at least one guardrail is enabled.
+ */
+export declare function createGraphqlValidationPlugin(options: {
+    introspection: boolean;
+    limits: Required<GraphqlRequestLimitsOptions> | undefined;
+}): GraphqlValidationPlugin | undefined;
+export {};
+//# sourceMappingURL=guardrails.d.ts.map

package/dist/guardrails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrails.d.ts","sourceRoot":"","sources":["../src/guardrails.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAUlB,KAAK,cAAc,EACpB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAQ9D,UAAU,8BAA8B;IACtC,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;CAC/C;AAED,UAAU,uBAAuB;IAC/B,SAAS,CAAC,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CAAC;IACvD,WAAW,CAAC,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CAAC;IACzD,UAAU,CAAC,CAAC,OAAO,EAAE,8BAA8B,GAAG,IAAI,CAAC;CAC5D;AAED,UAAU,2BAA2B;IACnC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,GAAG,eAAe,CAAC,CAAC;IACxD,yBAAyB,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;CACrE;AAcD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,2BAA2B,GAAG,KAAK,GAAG,SAAS,GACtD,QAAQ,CAAC,2BAA2B,CAAC,GAAG,SAAS,CAUnD;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE;IACrD,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,SAAS,CAAC;CAC3D,GAAG,uBAAuB,GAAG,SAAS,CAkCtC"}

package/dist/guardrails.js

@@ -0,0 +1,162 @@
+import { GraphQLError, Kind } from 'graphql';
+const DEFAULT_GRAPHQL_REQUEST_LIMITS = {
+  maxComplexity: 250,
+  maxCost: 500,
+  maxDepth: 12
+};
+/**
+ * Resolve the effective GraphQL request budget configuration for one module instance.
+ *
+ * @param limits User-provided request limit overrides, or `false` to disable built-in budgets.
+ * @returns The normalized request limits, or `undefined` when guardrails are explicitly disabled.
+ */
+export function resolveGraphqlRequestLimits(limits) {
+  if (limits === false) {
+    return undefined;
+  }
+  return {
+    maxComplexity: limits?.maxComplexity ?? DEFAULT_GRAPHQL_REQUEST_LIMITS.maxComplexity,
+    maxCost: limits?.maxCost ?? DEFAULT_GRAPHQL_REQUEST_LIMITS.maxCost,
+    maxDepth: limits?.maxDepth ?? DEFAULT_GRAPHQL_REQUEST_LIMITS.maxDepth
+  };
+}
+
+/**
+ * Create the GraphQL plugin that enforces introspection and request-budget guardrails.
+ *
+ * @param options Effective guardrail settings for introspection and per-request limits.
+ * @returns An Envelop-compatible plugin when at least one guardrail is enabled.
+ */
+export function createGraphqlValidationPlugin(options) {
+  const validationRules = [];
+  if (!options.introspection) {
+    validationRules.push(createDisableIntrospectionRule());
+  }
+  if (validationRules.length === 0 && !options.limits) {
+    return undefined;
+  }
+  const enforceRequestLimits = options.limits ? payload => {
+    const errors = evaluateGraphqlRequestLimits(payload.args.document, payload.args.operationName, options.limits);
+    if (errors.length > 0) {
+      payload.setResultAndStopExecution({
+        errors
+      });
+    }
+  } : undefined;
+  return {
+    ...(enforceRequestLimits ? {
+      onExecute: enforceRequestLimits,
+      onSubscribe: enforceRequestLimits
+    } : {}),
+    onValidate({
+      addValidationRule
+    }) {
+      for (const rule of validationRules) {
+        addValidationRule(rule);
+      }
+    }
+  };
+}
+function createDisableIntrospectionRule() {
+  return context => ({
+    Field(node) {
+      const fieldName = node.name.value;
+      if (fieldName === '__schema' || fieldName === '__type') {
+        context.reportError(new GraphQLError(`GraphQL introspection is disabled, but the query requested "${fieldName}".`));
+      }
+    }
+  });
+}
+function evaluateGraphqlRequestLimits(document, operationName, limits) {
+  const metrics = analyzeGraphqlOperation(document, operationName);
+  if (!metrics) {
+    return [];
+  }
+  const checks = [{
+    actual: metrics.maxDepth,
+    label: 'depth',
+    limit: limits.maxDepth
+  }, {
+    actual: metrics.complexity,
+    label: 'complexity',
+    limit: limits.maxComplexity
+  }, {
+    actual: metrics.cost,
+    label: 'cost',
+    limit: limits.maxCost
+  }];
+  return checks.flatMap(check => {
+    if (check.actual <= check.limit) {
+      return [];
+    }
+    return [new GraphQLError(`GraphQL query ${check.label} ${String(check.actual)} exceeds the configured limit of ${String(check.limit)}.`)];
+  });
+}
+function analyzeGraphqlOperation(document, operationName) {
+  const fragments = new Map();
+  const operations = [];
+  for (const definition of document.definitions) {
+    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+      fragments.set(definition.name.value, definition);
+      continue;
+    }
+    if (definition.kind === Kind.OPERATION_DEFINITION) {
+      operations.push(definition);
+    }
+  }
+  const operation = resolveOperationDefinition(operations, operationName);
+  if (!operation) {
+    return undefined;
+  }
+  const metrics = {
+    complexity: 0,
+    cost: 0,
+    maxDepth: 0
+  };
+  const walkSelectionSet = (selectionSet, depth, activeFragments) => {
+    for (const selection of selectionSet.selections) {
+      if (selection.kind === Kind.FIELD) {
+        const nextDepth = depth + 1;
+        metrics.maxDepth = Math.max(metrics.maxDepth, nextDepth);
+        metrics.complexity += 1;
+        metrics.cost += nextDepth;
+        if (selection.selectionSet) {
+          walkSelectionSet(selection.selectionSet, nextDepth, activeFragments);
+        }
+        continue;
+      }
+      if (selection.kind === Kind.INLINE_FRAGMENT) {
+        walkInlineFragment(selection, depth, activeFragments);
+        continue;
+      }
+      if (selection.kind !== Kind.FRAGMENT_SPREAD) {
+        continue;
+      }
+      walkFragmentSpread(selection, depth, activeFragments);
+    }
+  };
+  const walkInlineFragment = (fragment, depth, activeFragments) => {
+    walkSelectionSet(fragment.selectionSet, depth, activeFragments);
+  };
+  const walkFragmentSpread = (fragmentSpread, depth, activeFragments) => {
+    const fragmentName = fragmentSpread.name.value;
+    if (activeFragments.has(fragmentName)) {
+      return;
+    }
+    const fragment = fragments.get(fragmentName);
+    if (!fragment) {
+      return;
+    }
+    activeFragments.add(fragmentName);
+    walkSelectionSet(fragment.selectionSet, depth, activeFragments);
+    activeFragments.delete(fragmentName);
+  };
+  walkSelectionSet(operation.selectionSet, 0, new Set());
+  return metrics;
+}
+function resolveOperationDefinition(operations, operationName) {
+  if (operationName) {
+    return operations.find(operation => operation.name?.value === operationName);
+  }
+  return operations.length === 1 ? operations[0] : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './dataloader.js';
+export * from './decorators.js';
+export { GraphqlModule } from './module.js';
+export { isGraphqlListTypeRef, listOf, } from './types.js';
+export type { ArgFieldMetadata, GraphQLContext, GraphqlArgType, GraphqlListTypeRef, GraphqlModuleOptions, GraphqlRequestLimitsOptions, GraphqlRequestContext, GraphqlRootOutputNamedType, GraphqlRootOutputType, GraphqlScalarTypeName, GraphqlSubscriptionsOptions, GraphqlWebSocketSubscriptionsOptions, ResolverHandlerMetadata, ResolverHandlerType, ResolverMetadata, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EACL,oBAAoB,EACpB,MAAM,GACP,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACrB,2BAA2B,EAC3B,oCAAoC,EACpC,uBAAuB,EACvB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './dataloader.js';
+export * from './decorators.js';
+export { GraphqlModule } from './module.js';
+export { isGraphqlListTypeRef, listOf } from './types.js';

package/dist/internal-tokens.d.ts

@@ -0,0 +1,7 @@
+import type { Token } from '@fluojs/core';
+import type { GraphqlModuleOptions } from './types.js';
+/**
+ * DI token for providing GraphQL module configuration options.
+ */
+export declare const GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN: Token<GraphqlModuleOptions>;
+//# sourceMappingURL=internal-tokens.d.ts.map

package/dist/internal-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-tokens.d.ts","sourceRoot":"","sources":["../src/internal-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,qCAAqC,EAAE,KAAK,CAAC,oBAAoB,CAE7E,CAAC"}

package/dist/internal-tokens.js

@@ -0,0 +1,4 @@
+/**
+ * DI token for providing GraphQL module configuration options.
+ */
+export const GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN = Symbol.for('fluo.graphql.module-options');

package/dist/metadata.d.ts

@@ -0,0 +1,20 @@
+import type { MetadataPropertyKey } from '@fluojs/core';
+import type { ArgFieldMetadata, ResolverHandlerMetadata, ResolverMetadata } from './types.js';
+export declare function defineResolverMetadata(target: object, metadata: ResolverMetadata): void;
+export declare function getResolverMetadata(target: object): ResolverMetadata | undefined;
+export declare function defineResolverHandlerMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: ResolverHandlerMetadata): void;
+export declare function getResolverHandlerMetadata(target: object, propertyKey: MetadataPropertyKey): ResolverHandlerMetadata | undefined;
+export declare function getResolverHandlerMetadataEntries(target: object): Array<{
+    metadata: ResolverHandlerMetadata;
+    propertyKey: MetadataPropertyKey;
+}>;
+export declare function defineArgFieldMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: ArgFieldMetadata): void;
+export declare function getArgFieldMetadata(target: object, propertyKey: MetadataPropertyKey): ArgFieldMetadata | undefined;
+export declare function getArgFieldMetadataEntries(target: object): Array<{
+    metadata: ArgFieldMetadata;
+    propertyKey: MetadataPropertyKey;
+}>;
+export declare const resolverMetadataSymbol: symbol;
+export declare const handlerMetadataSymbol: symbol;
+export declare const argMetadataSymbol: symbol;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAyH9F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAEvF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAShF;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,uBAAuB,GAChC,IAAI,CAEN;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,GAC/B,uBAAuB,GAAG,SAAS,CASrC;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,GACb,KAAK,CAAC;IAAE,QAAQ,EAAE,uBAAuB,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAOhF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAEzH;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,CASlH;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,GACb,KAAK,CAAC;IAAE,QAAQ,EAAE,gBAAgB,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAEzE;AAED,eAAO,MAAM,sBAAsB,QAA8B,CAAC;AAClE,eAAO,MAAM,qBAAqB,QAA6B,CAAC;AAChE,eAAO,MAAM,iBAAiB,QAA8B,CAAC"}

package/dist/metadata.js

@@ -0,0 +1,120 @@
+const symbolWithMetadata = Symbol;
+const metadataSymbol = symbolWithMetadata.metadata ?? Symbol.for('fluo.symbol.metadata');
+if (!symbolWithMetadata.metadata) {
+  Object.defineProperty(Symbol, 'metadata', {
+    configurable: true,
+    value: metadataSymbol
+  });
+}
+const standardResolverMetadataKey = Symbol.for('fluo.graphql.standard.resolver');
+const standardHandlerMetadataKey = Symbol.for('fluo.graphql.standard.handler');
+const standardArgFieldMetadataKey = Symbol.for('fluo.graphql.standard.arg-field');
+const resolverMetadataStore = new WeakMap();
+const handlerMetadataStore = new WeakMap();
+const argFieldMetadataStore = new WeakMap();
+function cloneResolverMetadata(metadata) {
+  return {
+    typeName: metadata.typeName
+  };
+}
+function cloneHandlerMetadata(metadata) {
+  return {
+    argTypes: metadata.argTypes,
+    fieldName: metadata.fieldName,
+    inputClass: metadata.inputClass,
+    outputType: metadata.outputType,
+    topics: metadata.topics,
+    type: metadata.type
+  };
+}
+function cloneArgFieldMetadata(metadata) {
+  return {
+    argName: metadata.argName,
+    fieldName: metadata.fieldName
+  };
+}
+function getStandardMetadataBag(target) {
+  return target[metadataSymbol];
+}
+function getStandardResolverMetadata(target) {
+  const metadata = getStandardMetadataBag(target)?.[standardResolverMetadataKey];
+  if (!metadata) {
+    return undefined;
+  }
+  return cloneResolverMetadata(metadata);
+}
+function getStandardHandlerMap(target) {
+  const constructor = target.constructor;
+  return constructor ? getStandardMetadataBag(constructor)?.[standardHandlerMetadataKey] : undefined;
+}
+function getStandardArgFieldMap(target) {
+  const constructor = target.constructor;
+  return constructor ? getStandardMetadataBag(constructor)?.[standardArgFieldMetadataKey] : undefined;
+}
+function getOrCreateHandlerMetadataMap(target) {
+  let map = handlerMetadataStore.get(target);
+  if (!map) {
+    map = new Map();
+    handlerMetadataStore.set(target, map);
+  }
+  return map;
+}
+function getOrCreateArgFieldMetadataMap(target) {
+  let map = argFieldMetadataStore.get(target);
+  if (!map) {
+    map = new Map();
+    argFieldMetadataStore.set(target, map);
+  }
+  return map;
+}
+function getMergedMetadataEntries(target, stored, standard, resolve) {
+  const storedMap = stored ?? new Map();
+  const standardMap = standard ?? new Map();
+  const keys = new Set([...storedMap.keys(), ...standardMap.keys()]);
+  return Array.from(keys).map(propertyKey => ({
+    metadata: resolve(target, propertyKey),
+    propertyKey
+  })).filter(entry => entry.metadata !== undefined);
+}
+export function defineResolverMetadata(target, metadata) {
+  resolverMetadataStore.set(target, cloneResolverMetadata(metadata));
+}
+export function getResolverMetadata(target) {
+  const stored = resolverMetadataStore.get(target);
+  const standard = getStandardResolverMetadata(target);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  return cloneResolverMetadata(stored ?? standard);
+}
+export function defineResolverHandlerMetadata(target, propertyKey, metadata) {
+  getOrCreateHandlerMetadataMap(target).set(propertyKey, cloneHandlerMetadata(metadata));
+}
+export function getResolverHandlerMetadata(target, propertyKey) {
+  const stored = handlerMetadataStore.get(target)?.get(propertyKey);
+  const standard = getStandardHandlerMap(target)?.get(propertyKey);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  return cloneHandlerMetadata(stored ?? standard);
+}
+export function getResolverHandlerMetadataEntries(target) {
+  return getMergedMetadataEntries(target, handlerMetadataStore.get(target), getStandardHandlerMap(target), getResolverHandlerMetadata);
+}
+export function defineArgFieldMetadata(target, propertyKey, metadata) {
+  getOrCreateArgFieldMetadataMap(target).set(propertyKey, cloneArgFieldMetadata(metadata));
+}
+export function getArgFieldMetadata(target, propertyKey) {
+  const stored = argFieldMetadataStore.get(target)?.get(propertyKey);
+  const standard = getStandardArgFieldMap(target)?.get(propertyKey);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  return cloneArgFieldMetadata(stored ?? standard);
+}
+export function getArgFieldMetadataEntries(target) {
+  return getMergedMetadataEntries(target, argFieldMetadataStore.get(target), getStandardArgFieldMap(target), getArgFieldMetadata);
+}
+export const resolverMetadataSymbol = standardResolverMetadataKey;
+export const handlerMetadataSymbol = standardHandlerMetadataKey;
+export const argMetadataSymbol = standardArgFieldMetadataKey;

package/dist/module.d.ts

@@ -0,0 +1,22 @@
+import type { Provider } from '@fluojs/di';
+import { type ModuleType } from '@fluojs/runtime';
+import type { GraphqlModuleOptions } from './types.js';
+/**
+ * Creates GraphQL runtime providers for module-level options and lifecycle wiring.
+ *
+ * @param options GraphQL module options used by the lifecycle service and endpoint controller.
+ * @returns Provider definitions that register only the internal options token and GraphQL lifecycle service; this helper
+ * does not register `GraphqlEndpointController` or mount the `/graphql` endpoint by itself.
+ */
+export declare function createGraphqlProviders(options: GraphqlModuleOptions): Provider[];
+export declare class GraphqlModule {
+    /**
+     * Registers the GraphQL endpoint controller together with lifecycle providers.
+     *
+     * @param options Optional GraphQL module options for schema, resolver discovery, context, and plugins.
+     * @returns A module definition that wires GraphQL runtime behavior and mounts the GraphQL endpoint controller; use this
+     * module path (not `createGraphqlProviders(...)` alone) when the application should expose `/graphql`.
+     */
+    static forRoot(options?: GraphqlModuleOptions): ModuleType;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,oBAAoB,GAAG,QAAQ,EAAE,CAQhF;AAED,qBAAa,aAAa;IACxB;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,oBAAyB,GAAG,UAAU;CAS/D"}