@fluojs/graphql 1.0.0-beta.1

package/dist/module.js

@@ -0,0 +1,33 @@
+import { defineModule } from '@fluojs/runtime';
+import { GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN } from './internal-tokens.js';
+import { GraphqlEndpointController, GraphqlLifecycleService } from './service.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 function createGraphqlProviders(options) {
+  return [{
+    provide: GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN,
+    useValue: options
+  }, GraphqlLifecycleService];
+}
+export 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 = {}) {
+    class GraphqlRootModule extends GraphqlModule {}
+    return defineModule(GraphqlRootModule, {
+      controllers: [GraphqlEndpointController],
+      middleware: [],
+      providers: createGraphqlProviders(options)
+    });
+  }
+}

package/dist/pipeline/input-pipeline.d.ts

@@ -0,0 +1,34 @@
+import type { GraphqlArgType, GraphqlRootOutputType, GraphqlScalarTypeName, ResolverHandlerDescriptor } from '../types.js';
+/**
+ * Infers the scalar GraphQL type for one resolver argument from explicit metadata or DTO validation rules.
+ *
+ * @param handler Resolver descriptor that carries explicit arg metadata and DTO bindings.
+ * @param argName GraphQL argument name to inspect.
+ * @returns The inferred scalar type name used by the schema builder.
+ */
+export declare function resolveArgScalarType(handler: ResolverHandlerDescriptor, argName: string): GraphqlScalarTypeName;
+/**
+ * Resolves the scalar GraphQL argument type for one resolver argument.
+ *
+ * @param handler Resolver descriptor that carries explicit arg metadata and DTO bindings.
+ * @param argName GraphQL argument name to inspect.
+ * @returns The inferred scalar type name used by the schema builder.
+ */
+export declare function resolveArgType(handler: ResolverHandlerDescriptor, argName: string): GraphqlArgType;
+/**
+ * Resolves the GraphQL output type for one resolver handler.
+ *
+ * @param handler Resolver descriptor that may define an explicit output type.
+ * @returns The configured output type, or the default `string` scalar fallback.
+ */
+export declare function resolveOutputType(handler: ResolverHandlerDescriptor): GraphqlRootOutputType;
+/**
+ * Materializes and validates one resolver input object from GraphQL arguments.
+ *
+ * @param inputClass Optional DTO constructor used for instantiation and validation.
+ * @param args GraphQL argument payload received for the resolver call.
+ * @param argFieldDescriptors Mapping between GraphQL argument names and DTO field names.
+ * @returns The validated DTO instance, raw argument record, or `undefined` when no input was provided.
+ */
+export declare function createGraphqlInput(inputClass: Function | undefined, args: Record<string, unknown>, argFieldDescriptors: ResolverHandlerDescriptor['argFields']): Promise<unknown>;
+//# sourceMappingURL=input-pipeline.d.ts.map

package/dist/pipeline/input-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/input-pipeline.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAqD3H;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAiC/G;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAOlG;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,GAAG,qBAAqB,CAE3F;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,QAAQ,GAAG,SAAS,EAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,mBAAmB,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC1D,OAAO,CAAC,OAAO,CAAC,CA0BlB"}

package/dist/pipeline/input-pipeline.js

@@ -0,0 +1,129 @@
+import { getDtoValidationSchema } from '@fluojs/core/internal';
+import { DefaultValidator } from '@fluojs/validation';
+import { isGraphqlListTypeRef } from '../types.js';
+const defaultValidator = new DefaultValidator();
+const blockedGraphqlInputKeys = new Set(['__proto__', 'constructor', 'prototype']);
+function isSafeGraphqlInputKey(fieldName) {
+  return !blockedGraphqlInputKeys.has(fieldName);
+}
+function hasRule(rules, kind) {
+  return rules.some(rule => rule.kind === kind);
+}
+function inferScalarFromValidationRules(rules) {
+  if (hasRule(rules, 'int')) {
+    return 'int';
+  }
+  if (hasRule(rules, 'number') || hasRule(rules, 'min') || hasRule(rules, 'max') || hasRule(rules, 'divisibleBy')) {
+    return 'float';
+  }
+  if (hasRule(rules, 'boolean')) {
+    return 'boolean';
+  }
+  if (hasRule(rules, 'string') || hasRule(rules, 'validatorjs')) {
+    return 'string';
+  }
+  return undefined;
+}
+function inferScalarFromDefaultValue(value) {
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? 'int' : 'float';
+  }
+  if (typeof value === 'string') {
+    return 'string';
+  }
+  return undefined;
+}
+function toPropertyKey(fieldName) {
+  return fieldName;
+}
+
+/**
+ * Infers the scalar GraphQL type for one resolver argument from explicit metadata or DTO validation rules.
+ *
+ * @param handler Resolver descriptor that carries explicit arg metadata and DTO bindings.
+ * @param argName GraphQL argument name to inspect.
+ * @returns The inferred scalar type name used by the schema builder.
+ */
+export function resolveArgScalarType(handler, argName) {
+  const explicit = handler.argTypes?.[argName];
+  if (explicit && !isGraphqlListTypeRef(explicit)) {
+    return explicit;
+  }
+  if (!handler.inputClass) {
+    return 'string';
+  }
+  const mappedFieldName = handler.argFields.find(field => field.argName === argName)?.fieldName;
+  if (!mappedFieldName) {
+    return 'string';
+  }
+  const validationEntry = getDtoValidationSchema(handler.inputClass).find(entry => entry.propertyKey === toPropertyKey(mappedFieldName));
+  const inferredFromRules = validationEntry ? inferScalarFromValidationRules(validationEntry.rules) : undefined;
+  if (inferredFromRules) {
+    return inferredFromRules;
+  }
+  try {
+    const seed = new handler.inputClass();
+    return inferScalarFromDefaultValue(seed[mappedFieldName]) ?? 'string';
+  } catch {
+    return 'string';
+  }
+}
+
+/**
+ * Resolves the scalar GraphQL argument type for one resolver argument.
+ *
+ * @param handler Resolver descriptor that carries explicit arg metadata and DTO bindings.
+ * @param argName GraphQL argument name to inspect.
+ * @returns The inferred scalar type name used by the schema builder.
+ */
+export function resolveArgType(handler, argName) {
+  const explicit = handler.argTypes?.[argName];
+  if (explicit) {
+    return explicit;
+  }
+  return resolveArgScalarType(handler, argName);
+}
+
+/**
+ * Resolves the GraphQL output type for one resolver handler.
+ *
+ * @param handler Resolver descriptor that may define an explicit output type.
+ * @returns The configured output type, or the default `string` scalar fallback.
+ */
+export function resolveOutputType(handler) {
+  return handler.outputType ?? 'string';
+}
+
+/**
+ * Materializes and validates one resolver input object from GraphQL arguments.
+ *
+ * @param inputClass Optional DTO constructor used for instantiation and validation.
+ * @param args GraphQL argument payload received for the resolver call.
+ * @param argFieldDescriptors Mapping between GraphQL argument names and DTO field names.
+ * @returns The validated DTO instance, raw argument record, or `undefined` when no input was provided.
+ */
+export async function createGraphqlInput(inputClass, args, argFieldDescriptors) {
+  if (!inputClass) {
+    return Object.keys(args).length === 0 ? undefined : args;
+  }
+  const instance = new inputClass();
+  if (argFieldDescriptors.length === 0) {
+    for (const [fieldName, value] of Object.entries(args)) {
+      if (!isSafeGraphqlInputKey(fieldName)) {
+        continue;
+      }
+      instance[fieldName] = value;
+    }
+  } else {
+    for (const descriptor of argFieldDescriptors) {
+      if (isSafeGraphqlInputKey(descriptor.fieldName) && Object.hasOwn(args, descriptor.argName)) {
+        instance[descriptor.fieldName] = args[descriptor.argName];
+      }
+    }
+  }
+  await defaultValidator.validate(instance, inputClass);
+  return instance;
+}

package/dist/schema/schema.d.ts

@@ -0,0 +1,20 @@
+import type { Container } from '@fluojs/di';
+import type { GraphQLError as GraphQLErrorType, GraphQLList as GraphQLListType, GraphQLObjectType as GraphQLObjectTypeType, GraphQLSchema as GraphQLSchemaType, GraphQLScalarType, GraphQLUnionType as GraphQLUnionTypeType } from 'graphql';
+import { type ResolverDescriptor } from '../types.js';
+type YogaGraphqlDeps = {
+    GraphQLError: typeof GraphQLErrorType;
+    GraphQLBoolean: GraphQLScalarType;
+    GraphQLFloat: GraphQLScalarType;
+    GraphQLID: GraphQLScalarType;
+    GraphQLInt: GraphQLScalarType;
+    GraphQLList: typeof GraphQLListType;
+    GraphQLObjectType: typeof GraphQLObjectTypeType;
+    GraphQLSchema: typeof GraphQLSchemaType;
+    GraphQLString: GraphQLScalarType;
+    GraphQLUnionType: typeof GraphQLUnionTypeType;
+    buildSchema: (source: string) => GraphQLSchemaType;
+};
+export declare function resolveSchema(deps: YogaGraphqlDeps, optionsSchema: GraphQLSchemaType | string | undefined, createCodeFirstSchema: () => GraphQLSchemaType, markAllowedCrossRealmGraphqlObjects: (value: unknown) => void): GraphQLSchemaType;
+export declare function createCodeFirstSchema(deps: YogaGraphqlDeps, runtimeContainer: Container, resolverDescriptors: ResolverDescriptor[], markAllowedCrossRealmGraphqlObjects?: (value: unknown) => void): GraphQLSchemaType;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EAGV,YAAY,IAAI,gBAAgB,EAGhC,WAAW,IAAI,eAAe,EAC9B,iBAAiB,IAAI,qBAAqB,EAE1C,aAAa,IAAI,iBAAiB,EAClC,iBAAiB,EACjB,gBAAgB,IAAI,oBAAoB,EACzC,MAAM,SAAS,CAAC;AAIjB,OAAO,EAOL,KAAK,kBAAkB,EAGxB,MAAM,aAAa,CAAC;AAErB,KAAK,eAAe,GAAG;IACrB,YAAY,EAAE,OAAO,gBAAgB,CAAC;IACtC,cAAc,EAAE,iBAAiB,CAAC;IAClC,YAAY,EAAE,iBAAiB,CAAC;IAChC,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,EAAE,OAAO,eAAe,CAAC;IACpC,iBAAiB,EAAE,OAAO,qBAAqB,CAAC;IAChD,aAAa,EAAE,OAAO,iBAAiB,CAAC;IACxC,aAAa,EAAE,iBAAiB,CAAC;IACjC,gBAAgB,EAAE,OAAO,oBAAoB,CAAC;IAC9C,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,iBAAiB,CAAC;CACpD,CAAC;AAiaF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS,EACrD,qBAAqB,EAAE,MAAM,iBAAiB,EAC9C,mCAAmC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAC5D,iBAAiB,CAWnB;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,EACrB,gBAAgB,EAAE,SAAS,EAC3B,mBAAmB,EAAE,kBAAkB,EAAE,EACzC,mCAAmC,GAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAe,GACvE,iBAAiB,CA0CnB"}

package/dist/schema/schema.js

@@ -0,0 +1,278 @@
+import { DtoValidationError } from '@fluojs/validation';
+import { createGraphqlInput, resolveArgType, resolveOutputType } from '../pipeline/input-pipeline.js';
+import { GRAPHQL_OPERATION_CONTAINER, isGraphqlListTypeRef } from '../types.js';
+function isAsyncIterable(value) {
+  return typeof value === 'object' && value !== null && Symbol.asyncIterator in value;
+}
+function scalarByName(deps, scalar) {
+  switch (scalar) {
+    case 'int':
+      return deps.GraphQLInt;
+    case 'float':
+      return deps.GraphQLFloat;
+    case 'boolean':
+      return deps.GraphQLBoolean;
+    case 'id':
+      return deps.GraphQLID;
+    case 'string':
+    default:
+      return deps.GraphQLString;
+  }
+}
+function builtinScalarByGraphqlName(deps, scalarName) {
+  switch (scalarName) {
+    case 'String':
+      return deps.GraphQLString;
+    case 'Int':
+      return deps.GraphQLInt;
+    case 'Float':
+      return deps.GraphQLFloat;
+    case 'Boolean':
+      return deps.GraphQLBoolean;
+    case 'ID':
+      return deps.GraphQLID;
+    default:
+      return undefined;
+  }
+}
+function normalizeFieldOutputType(deps, type) {
+  const maybeScalarName = type.name;
+  if (typeof maybeScalarName === 'string') {
+    return builtinScalarByGraphqlName(deps, maybeScalarName) ?? type;
+  }
+  return type;
+}
+function normalizeObjectOutputType(deps, outputTypeCache, outputType) {
+  const outputTypeName = outputType.name;
+  const cached = outputTypeCache.get(outputTypeName);
+  if (cached) {
+    return cached;
+  }
+  const config = outputType.toConfig();
+  const clonedFields = Object.fromEntries(Object.entries(config.fields).map(([fieldName, fieldConfig]) => {
+    const field = fieldConfig;
+    return [fieldName, {
+      ...field,
+      type: normalizeFieldOutputType(deps, field.type)
+    }];
+  }));
+  const normalized = new deps.GraphQLObjectType({
+    ...config,
+    fields: clonedFields
+  });
+  outputTypeCache.set(outputTypeName, normalized);
+  return normalized;
+}
+function normalizeUnionOutputType(deps, outputTypeCache, outputType) {
+  const outputTypeName = outputType.name;
+  const cached = outputTypeCache.get(outputTypeName);
+  if (cached) {
+    return cached;
+  }
+  const config = outputType.toConfig();
+  const normalizedTypes = config.types.map(itemType => normalizeObjectOutputType(deps, outputTypeCache, itemType));
+  const normalizedTypeByName = new Set(normalizedTypes.map(itemType => itemType.name).filter(name => typeof name === 'string'));
+  const normalized = new deps.GraphQLUnionType({
+    ...config,
+    resolveType: async (...args) => {
+      if (!config.resolveType) {
+        return undefined;
+      }
+      const resolved = await config.resolveType(...args);
+      if (typeof resolved === 'string' || resolved === null || resolved === undefined) {
+        return typeof resolved === 'string' && normalizedTypeByName.has(resolved) ? resolved : resolved;
+      }
+      const resolvedName = resolved.name;
+      if (typeof resolvedName === 'string') {
+        return normalizedTypeByName.has(resolvedName) ? resolvedName : undefined;
+      }
+      return undefined;
+    },
+    types: normalizedTypes
+  });
+  outputTypeCache.set(outputTypeName, normalized);
+  return normalized;
+}
+function isUnionOutputType(value) {
+  return typeof value === 'object' && typeof value.getTypes === 'function';
+}
+function resolveArgGraphqlType(deps, argType) {
+  if (isGraphqlListTypeRef(argType)) {
+    return new deps.GraphQLList(scalarByName(deps, argType.ofType));
+  }
+  return scalarByName(deps, argType);
+}
+function resolveNamedRootOutputType(deps, outputTypeCache, markAllowedCrossRealmGraphqlObjects, outputRef) {
+  if (typeof outputRef === 'string') {
+    return scalarByName(deps, outputRef);
+  }
+  markAllowedCrossRealmGraphqlObjects(outputRef);
+  if (isUnionOutputType(outputRef)) {
+    return normalizeUnionOutputType(deps, outputTypeCache, outputRef);
+  }
+  return normalizeObjectOutputType(deps, outputTypeCache, outputRef);
+}
+function resolveRootOutputType(deps, outputTypeCache, markAllowedCrossRealmGraphqlObjects, outputRef) {
+  if (isGraphqlListTypeRef(outputRef)) {
+    const listItemType = resolveNamedRootOutputType(deps, outputTypeCache, markAllowedCrossRealmGraphqlObjects, outputRef.ofType);
+    return new deps.GraphQLList(listItemType);
+  }
+  return resolveNamedRootOutputType(deps, outputTypeCache, markAllowedCrossRealmGraphqlObjects, outputRef);
+}
+function createFieldArgs(deps, handler) {
+  return Object.fromEntries(handler.argFields.map(argField => [argField.argName, {
+    type: resolveArgGraphqlType(deps, resolveArgType(handler, argField.argName))
+  }]));
+}
+function createSubscriptionField(descriptor, handler, args, outputType, invokeResolver) {
+  return {
+    args,
+    resolve(payload) {
+      return payload;
+    },
+    subscribe: async (_source, rawArgs, contextValue) => {
+      const value = await invokeResolver(descriptor, handler, rawArgs, contextValue);
+      if (!isAsyncIterable(value)) {
+        throw new Error(`Subscription resolver ${descriptor.targetName}.${handler.methodName} must return AsyncIterable.`);
+      }
+      return value;
+    },
+    type: outputType
+  };
+}
+function createOperationField(descriptor, handler, args, outputType, invokeResolver) {
+  return {
+    args,
+    resolve: async (_source, rawArgs, contextValue) => invokeResolver(descriptor, handler, rawArgs, contextValue),
+    type: outputType
+  };
+}
+function pickFieldsByType(deps, descriptors, handlerType, markAllowedCrossRealmGraphqlObjects, outputTypeCache, invokeResolver) {
+  const fields = {};
+  for (const descriptor of descriptors) {
+    for (const handler of descriptor.handlers) {
+      if (handler.type !== handlerType) {
+        continue;
+      }
+      const args = createFieldArgs(deps, handler);
+      const outputRef = resolveOutputType(handler);
+      const outputType = resolveRootOutputType(deps, outputTypeCache, markAllowedCrossRealmGraphqlObjects, outputRef);
+      if (Object.hasOwn(fields, handler.fieldName)) {
+        throw new Error(`GraphQL schema conflict: field "${handler.fieldName}" on ${handlerType} type is registered more than once. ` + `Found duplicate in resolver "${descriptor.targetName}". Each field name must be unique across all resolvers.`);
+      }
+      if (handler.type === 'subscription') {
+        fields[handler.fieldName] = createSubscriptionField(descriptor, handler, args, outputType, invokeResolver);
+        continue;
+      }
+      fields[handler.fieldName] = createOperationField(descriptor, handler, args, outputType, invokeResolver);
+    }
+  }
+  return fields;
+}
+function isGraphQLSchemaLike(value) {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+  return typeof value.getQueryType === 'function' && typeof value.getTypeMap === 'function';
+}
+function toGraphqlValidationError(deps, error) {
+  return new deps.GraphQLError('Validation failed.', {
+    extensions: {
+      code: 'BAD_USER_INPUT',
+      issues: error.issues
+    }
+  });
+}
+async function createResolverInput(deps, handler, args) {
+  try {
+    return await createGraphqlInput(handler.inputClass, args, handler.argFields);
+  } catch (error) {
+    if (error instanceof DtoValidationError) {
+      throw toGraphqlValidationError(deps, error);
+    }
+    throw error;
+  }
+}
+function resolveResolverMethod(instance, descriptor, handler) {
+  const value = instance[handler.methodKey];
+  if (typeof value !== 'function') {
+    throw new Error(`Resolver handler ${descriptor.targetName}.${handler.methodName} is not callable.`);
+  }
+  return value;
+}
+function createResolverInvoker(deps, runtimeContainer) {
+  return async (descriptor, handler, args, contextValue) => {
+    if (descriptor.scope === 'singleton') {
+      const instance = await runtimeContainer.resolve(descriptor.token);
+      const resolverMethod = resolveResolverMethod(instance, descriptor, handler);
+      const input = await createResolverInput(deps, handler, args);
+      return resolverMethod.call(instance, input, contextValue);
+    }
+    const operationContainer = contextValue[GRAPHQL_OPERATION_CONTAINER] ?? runtimeContainer.createRequestScope();
+    const disposeOperationContainer = contextValue[GRAPHQL_OPERATION_CONTAINER] === undefined;
+    try {
+      const instance = await operationContainer.resolve(descriptor.token);
+      const resolverMethod = resolveResolverMethod(instance, descriptor, handler);
+      const input = await createResolverInput(deps, handler, args);
+      return await resolverMethod.call(instance, input, contextValue);
+    } finally {
+      if (disposeOperationContainer) {
+        await operationContainer.dispose();
+      }
+    }
+  };
+}
+function createQueryRootType(deps, queryFields) {
+  if (Object.keys(queryFields).length === 0) {
+    return new deps.GraphQLObjectType({
+      fields: {
+        _empty: {
+          resolve: () => 'ok',
+          type: deps.GraphQLString
+        }
+      },
+      name: 'Query'
+    });
+  }
+  return new deps.GraphQLObjectType({
+    fields: queryFields,
+    name: 'Query'
+  });
+}
+function createOptionalRootType(deps, name, fields) {
+  if (Object.keys(fields).length === 0) {
+    return undefined;
+  }
+  return new deps.GraphQLObjectType({
+    fields,
+    name
+  });
+}
+export function resolveSchema(deps, optionsSchema, createCodeFirstSchema, markAllowedCrossRealmGraphqlObjects) {
+  if (isGraphQLSchemaLike(optionsSchema)) {
+    markAllowedCrossRealmGraphqlObjects(optionsSchema);
+    return optionsSchema;
+  }
+  if (typeof optionsSchema === 'string') {
+    return deps.buildSchema(optionsSchema);
+  }
+  return createCodeFirstSchema();
+}
+export function createCodeFirstSchema(deps, runtimeContainer, resolverDescriptors, markAllowedCrossRealmGraphqlObjects = () => {}) {
+  if (resolverDescriptors.length === 0) {
+    throw new Error('GraphQL module requires either schema or at least one resolver decorated with @Resolver().');
+  }
+  const invokeResolver = createResolverInvoker(deps, runtimeContainer);
+  const outputTypeCache = new Map();
+  const queryFields = pickFieldsByType(deps, resolverDescriptors, 'query', markAllowedCrossRealmGraphqlObjects, outputTypeCache, invokeResolver);
+  const mutationFields = pickFieldsByType(deps, resolverDescriptors, 'mutation', markAllowedCrossRealmGraphqlObjects, outputTypeCache, invokeResolver);
+  const subscriptionFields = pickFieldsByType(deps, resolverDescriptors, 'subscription', markAllowedCrossRealmGraphqlObjects, outputTypeCache, invokeResolver);
+  const queryType = createQueryRootType(deps, queryFields);
+  const mutationType = createOptionalRootType(deps, 'Mutation', mutationFields);
+  const subscriptionType = createOptionalRootType(deps, 'Subscription', subscriptionFields);
+  return new deps.GraphQLSchema({
+    mutation: mutationType,
+    query: queryType,
+    subscription: subscriptionType
+  });
+}

package/dist/service.d.ts

@@ -0,0 +1,58 @@
+import { type HttpApplicationAdapter } from '@fluojs/http';
+import type { Container } from '@fluojs/di';
+import { type ApplicationLogger, type CompiledModule, type OnApplicationBootstrap, type OnApplicationShutdown } from '@fluojs/runtime';
+import type { GraphqlModuleOptions } from './types.js';
+/**
+ * Declares the HTTP endpoints that receive GraphQL GET and POST requests.
+ */
+export declare class GraphqlEndpointController {
+    handleGet(): undefined;
+    handlePost(): undefined;
+}
+/**
+ * Boots the GraphQL runtime, middleware, and subscription transports for the active adapter.
+ */
+export declare class GraphqlLifecycleService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly runtimeContainer;
+    private readonly compiledModules;
+    private readonly logger;
+    private readonly adapter;
+    private readonly options;
+    private graphQLErrorConstructor;
+    private middlewareRegistered;
+    private readonly operationContainers;
+    private readonly websocketOperationContainers;
+    private websocketDisposable;
+    private websocketServer;
+    private websocketUpgradeListener;
+    private websocketUpgradeServer;
+    private executeGraphqlOperation;
+    private subscribeGraphqlOperation;
+    private yoga;
+    private readonly middleware;
+    constructor(runtimeContainer: Container, compiledModules: readonly CompiledModule[], logger: ApplicationLogger, adapter: HttpApplicationAdapter, options: GraphqlModuleOptions);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    private resolveGraphiqlEnabled;
+    private resolveIntrospectionEnabled;
+    private resolveWebSocketLimits;
+    private resolveSchema;
+    private createCodeFirstSchema;
+    private discoverResolverDescriptors;
+    private registerMiddleware;
+    private unregisterMiddleware;
+    private buildGraphqlContext;
+    private registerWebSocketTransport;
+    private unregisterWebSocketTransport;
+    private isWebSocketTransportEnabled;
+    private resolveUpgradeServer;
+    private handleWebSocketSubscribe;
+    private createWebSocketOperationLimitError;
+    private rejectWebSocketUpgrade;
+    private getOrCreateWebSocketOperationContainer;
+    private disposeWebSocketOperationContainer;
+    private disposeAllWebSocketOperationContainers;
+    private getOrCreateOperationContainer;
+    private disposeOperationContainer;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgD,KAAK,sBAAsB,EAAsD,MAAM,cAAc,CAAC;AAE7J,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AA2BzB,OAAO,KAAK,EAEV,oBAAoB,EAGrB,MAAM,YAAY,CAAC;AAkIpB;;GAEG;AACH,qBACa,yBAAyB;IAEpC,SAAS,IAAI,SAAS;IAKtB,UAAU,IAAI,SAAS;CAGxB;AAoHD;;GAEG;AACH,qBACa,uBAAwB,YAAW,sBAAsB,EAAE,qBAAqB;IA4DzF,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IA/DxB,OAAO,CAAC,uBAAuB,CAAsC;IACrE,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqC;IACzE,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAA6C;IAC1F,OAAO,CAAC,mBAAmB,CAAkD;IAC7E,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,wBAAwB,CAAkC;IAClE,OAAO,CAAC,sBAAsB,CAAgC;IAC9D,OAAO,CAAC,uBAAuB,CAAyD;IACxF,OAAO,CAAC,yBAAyB,CAAyD;IAC1F,OAAO,CAAC,IAAI,CAAuB;IAEnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CA4CzB;gBAGiB,gBAAgB,EAAE,SAAS,EAC3B,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB;IAGxC,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAsCvC,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAU5C,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,mBAAmB;IAyB3B,OAAO,CAAC,0BAA0B;YAuEpB,4BAA4B;IAuC1C,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,oBAAoB;YAkBd,wBAAwB;IAwDtC,OAAO,CAAC,kCAAkC;IAwB1C,OAAO,CAAC,sBAAsB;IAoB9B,OAAO,CAAC,sCAAsC;YAchC,kCAAkC;YAqBlC,sCAAsC;IAkBpD,OAAO,CAAC,6BAA6B;YAYvB,yBAAyB;CAexC"}