@fluojs/graphql 1.0.4 → 2.0.0

package/dist/module.js

@@ -1,18 +1,37 @@
+import { isForwardRef, isOptionalToken } from '@fluojs/di';
 import { defineModule } from '@fluojs/runtime';
+import { RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
 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];
+function createGraphqlProviders(optionsProvider) {
+  return [optionsProvider, GraphqlLifecycleService];
+}
+function assertGraphqlAsyncModuleOptions(options) {
+  if (options === null || typeof options !== 'object') {
+    throw new TypeError('GraphqlModule.forRootAsync requires an options object.');
+  }
+  const unsupportedKey = Object.keys(options).find(key => key !== 'inject' && key !== 'useFactory');
+  if (unsupportedKey !== undefined) {
+    throw new TypeError(`GraphqlModule.forRootAsync does not support "${unsupportedKey}"; use only inject and useFactory.`);
+  }
+  if (typeof options.useFactory !== 'function') {
+    throw new TypeError('GraphqlModule.forRootAsync requires a useFactory function.');
+  }
+  if (options.inject !== undefined && !Array.isArray(options.inject)) {
+    throw new TypeError('GraphqlModule.forRootAsync inject must be an array of application tokens.');
+  }
+}
+function isContainer(value) {
+  return value !== null && typeof value === 'object' && 'has' in value && 'resolve' in value;
+}
+async function resolveAsyncDependency(container, token) {
+  if (isForwardRef(token)) {
+    return await container.resolve(token.forwardRef());
+  }
+  if (isOptionalToken(token)) {
+    return container.has(token.token) ? await container.resolve(token.token) : undefined;
+  }
+  return await container.resolve(token);
 }
 
 /**
@@ -30,8 +49,44 @@ export class GraphqlModule {
     class GraphqlRootModule extends GraphqlModule {}
     return defineModule(GraphqlRootModule, {
       controllers: [GraphqlEndpointController],
-      middleware: [],
-      providers: createGraphqlProviders(options)
+      middleware: [GraphqlLifecycleService],
+      providers: createGraphqlProviders({
+        provide: GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN,
+        useValue: options
+      })
+    });
+  }
+
+  /**
+   * Registers GraphQL from options resolved by explicitly injected application dependencies.
+   *
+   * The factory runs once in each application context. Only `inject` and `useFactory` are
+   * supported; NestJS-style `imports`, `useClass`, `useExisting`, and implicit discovery are rejected.
+   *
+   * @param options Injected dependency tokens and the factory that resolves GraphQL options.
+   * @returns A module definition that resolves GraphQL configuration before endpoint lifecycle wiring begins.
+   *
+   * @throws {TypeError} When the options shape requests unsupported registration behavior.
+   */
+  static forRootAsync(options) {
+    assertGraphqlAsyncModuleOptions(options);
+    class GraphqlAsyncRootModule extends GraphqlModule {}
+    return defineModule(GraphqlAsyncRootModule, {
+      controllers: [GraphqlEndpointController],
+      middleware: [GraphqlLifecycleService],
+      providers: createGraphqlProviders({
+        inject: [RUNTIME_CONTAINER],
+        provide: GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN,
+        scope: 'singleton',
+        useFactory: async (...dependencies) => {
+          const [runtimeContainer] = dependencies;
+          if (!isContainer(runtimeContainer)) {
+            throw new TypeError('GraphqlModule.forRootAsync could not resolve the application container.');
+          }
+          const injectedDependencies = await Promise.all((options.inject ?? []).map(async token => await resolveAsyncDependency(runtimeContainer, token)));
+          return Reflect.apply(options.useFactory, options, injectedDependencies);
+        }
+      })
     });
   }
 }

package/dist/node/graphql-websocket-transport.d.ts

@@ -0,0 +1,53 @@
+import type { FrameworkRequest, HttpApplicationAdapter } from '@fluojs/http';
+import type { ExecutionArgs, execute as executeGraphql, GraphQLError as GraphQLErrorType, subscribe as subscribeGraphql } from 'graphql';
+interface GraphqlNodeWebSocketLimits {
+    maxConnections: number;
+    maxOperationsPerConnection: number;
+    maxPayloadBytes: number;
+}
+interface GraphqlSubscribePayload {
+    operationName?: string | null;
+    query: string;
+    variables?: Record<string, unknown> | null;
+}
+/**
+ * Describes a GraphQL-over-WebSocket subscription forwarded to application hooks.
+ */
+export interface GraphqlNodeWebSocketSubscribeRequest {
+    connectionParams?: Record<string, unknown>;
+    operationId: string;
+    payload: GraphqlSubscribePayload;
+    request: FrameworkRequest;
+    socket: object;
+}
+/**
+ * Represents a registered Node GraphQL WebSocket transport.
+ */
+export interface GraphqlNodeWebSocketTransport {
+    /**
+     * Releases websocket listeners, clients, and GraphQL protocol resources.
+     *
+     * @returns A promise that resolves when cleanup completes or rejects with all current cleanup failures.
+     */
+    dispose(): Promise<void>;
+}
+interface GraphqlNodeWebSocketTransportOptions {
+    adapter: HttpApplicationAdapter;
+    connectionInitWaitTimeoutMs?: number;
+    execute: typeof executeGraphql;
+    keepAliveMs?: number;
+    limits?: GraphqlNodeWebSocketLimits;
+    onComplete: (socketKey: object, operationId: string) => Promise<void> | void;
+    onDisconnect: (socketKey: object) => Promise<void> | void;
+    onSubscribe: (request: GraphqlNodeWebSocketSubscribeRequest) => Promise<ExecutionArgs | readonly GraphQLErrorType[]>;
+    subscribe: typeof subscribeGraphql;
+}
+/**
+ * Registers GraphQL-over-WebSocket upgrade handling for a Node HTTP/S adapter.
+ *
+ * @param options Transport dependencies and WebSocket lifecycle hooks.
+ * @returns A transport that unregisters upgrade handling and disposes WebSocket clients.
+ */
+export declare function createNodeGraphqlWebSocketTransport(options: GraphqlNodeWebSocketTransportOptions): Promise<GraphqlNodeWebSocketTransport>;
+export {};
+//# sourceMappingURL=graphql-websocket-transport.d.ts.map

package/dist/node/graphql-websocket-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-websocket-transport.d.ts","sourceRoot":"","sources":["../../src/node/graphql-websocket-transport.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,KAAK,EACV,aAAa,EACb,OAAO,IAAI,cAAc,EACzB,YAAY,IAAI,gBAAgB,EAChC,SAAS,IAAI,gBAAgB,EAC9B,MAAM,SAAS,CAAC;AAgBjB,UAAU,0BAA0B;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,0BAA0B,EAAE,MAAM,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,uBAAuB;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,oCAAoC;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,uBAAuB,CAAC;IACjC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,UAAU,oCAAoC;IAC5C,OAAO,EAAE,sBAAsB,CAAC;IAChC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,OAAO,EAAE,OAAO,cAAc,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,0BAA0B,CAAC;IACpC,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7E,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,WAAW,EAAE,CAAC,OAAO,EAAE,oCAAoC,KAAK,OAAO,CAAC,aAAa,GAAG,SAAS,gBAAgB,EAAE,CAAC,CAAC;IACrH,SAAS,EAAE,OAAO,gBAAgB,CAAC;CACpC;AA2ID;;;;;GAKG;AACH,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,oCAAoC,GAC5C,OAAO,CAAC,6BAA6B,CAAC,CAkIxC"}

package/dist/node/graphql-websocket-transport.js

@@ -0,0 +1,219 @@
+import { handleProtocols } from 'graphql-ws';
+import { useServer } from 'graphql-ws/lib/use/ws';
+import { WebSocketServer } from 'ws';
+import { isGraphqlPath } from '../transport/transport.js';
+
+/**
+ * Describes a GraphQL-over-WebSocket subscription forwarded to application hooks.
+ */
+
+/**
+ * Represents a registered Node GraphQL WebSocket transport.
+ */
+
+function hasNodeUpgradeServer(value) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  const server = value;
+  return typeof server.on === 'function' && typeof server.off === 'function';
+}
+function isConnectionParamsRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function buildFrameworkRequestFromIncomingMessage(request) {
+  const requestUrl = new URL(request.url ?? '/graphql', 'http://localhost');
+  return {
+    cookies: {},
+    headers: request.headers,
+    method: request.method ?? 'GET',
+    params: {},
+    path: requestUrl.pathname,
+    query: Object.fromEntries(requestUrl.searchParams.entries()),
+    raw: request,
+    url: requestUrl.pathname + requestUrl.search
+  };
+}
+function closeWebSocketServer(server) {
+  return new Promise((resolve, reject) => {
+    server.close(error => {
+      if (error?.message === 'The server is not running') {
+        resolve();
+        return;
+      }
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function collectCleanupError(errors, error) {
+  if (error instanceof AggregateError) {
+    for (const nested of error.errors) {
+      collectCleanupError(errors, nested);
+    }
+    return;
+  }
+  if (errors.includes(error)) {
+    return;
+  }
+  errors.push(error);
+}
+function resolveUpgradeServer(adapter) {
+  if (typeof adapter.getServer !== 'function') {
+    throw new Error('GraphQL websocket subscriptions require an HTTP adapter with getServer(). Use the Node HTTP adapter or provide a compatible adapter implementation.');
+  }
+  const server = adapter.getServer();
+  if (!hasNodeUpgradeServer(server)) {
+    throw new Error('GraphQL websocket subscriptions require adapter.getServer() to return a Node HTTP/S server that supports upgrade listeners.');
+  }
+  return server;
+}
+function rejectWebSocketUpgrade(socket, statusCode, message) {
+  if (!socket.writable) {
+    socket.destroy();
+    return;
+  }
+  const body = `${message}\n`;
+  socket.write([`HTTP/1.1 ${String(statusCode)} ${statusCode === 503 ? 'Service Unavailable' : 'Bad Request'}`, 'Connection: close', 'Content-Type: text/plain; charset=utf-8', `Content-Length: ${String(new TextEncoder().encode(body).byteLength)}`, '', body].join('\r\n'));
+  socket.destroy();
+}
+function createUpgradeListener(websocketServer, limits) {
+  return (request, socket, head) => {
+    const targetPath = new URL(request.url ?? '/', 'http://localhost').pathname;
+    if (!isGraphqlPath(targetPath)) {
+      return;
+    }
+    if (limits && websocketServer.clients.size >= limits.maxConnections) {
+      rejectWebSocketUpgrade(socket, 503, 'GraphQL websocket connection count exceeds the configured limit.');
+      return;
+    }
+    websocketServer.handleUpgrade(request, socket, head, websocket => {
+      websocketServer.emit('connection', websocket, request);
+    });
+  };
+}
+function createSubscribeRequest(context, message) {
+  return {
+    connectionParams: isConnectionParamsRecord(context.connectionParams) ? context.connectionParams : undefined,
+    operationId: message.id,
+    payload: message.payload,
+    request: buildFrameworkRequestFromIncomingMessage(context.extra.request),
+    socket: context.extra.socket
+  };
+}
+
+/**
+ * Registers GraphQL-over-WebSocket upgrade handling for a Node HTTP/S adapter.
+ *
+ * @param options Transport dependencies and WebSocket lifecycle hooks.
+ * @returns A transport that unregisters upgrade handling and disposes WebSocket clients.
+ */
+export async function createNodeGraphqlWebSocketTransport(options) {
+  const upgradeServer = resolveUpgradeServer(options.adapter);
+  const disconnectErrors = [];
+  const disconnectedSockets = new Set();
+  const pendingDisconnects = new Set();
+  let websocketDisposableDisposed = false;
+  let websocketServerClosed = false;
+  let inFlightDispose;
+  const websocketServer = new WebSocketServer({
+    handleProtocols: protocols => handleProtocols(protocols),
+    maxPayload: options.limits?.maxPayloadBytes ?? 0,
+    noServer: true
+  });
+  const upgradeListener = createUpgradeListener(websocketServer, options.limits);
+  const drainDisconnectErrors = cleanupErrors => {
+    for (const error of disconnectErrors.splice(0, disconnectErrors.length)) {
+      collectCleanupError(cleanupErrors, error);
+    }
+  };
+  const trackDisconnect = socketKey => {
+    if (disconnectedSockets.has(socketKey)) {
+      return;
+    }
+    disconnectedSockets.add(socketKey);
+    const pendingDisconnect = Promise.resolve(options.onDisconnect(socketKey)).catch(error => {
+      disconnectErrors.push(error);
+    }).finally(() => {
+      pendingDisconnects.delete(pendingDisconnect);
+    });
+    pendingDisconnects.add(pendingDisconnect);
+  };
+  const trackConnection = websocket => {
+    websocket.once('close', () => trackDisconnect(websocket));
+  };
+  const websocketDisposable = useServer({
+    connectionInitWaitTimeout: options.connectionInitWaitTimeoutMs,
+    execute: options.execute,
+    onComplete: async (context, message) => {
+      await options.onComplete(context.extra.socket, message.id);
+    },
+    onDisconnect: context => {
+      trackDisconnect(context.extra.socket);
+    },
+    onSubscribe: async (context, message) => options.onSubscribe(createSubscribeRequest(context, message)),
+    subscribe: options.subscribe
+  }, websocketServer, options.keepAliveMs);
+  websocketServer.on('connection', trackConnection);
+  upgradeServer.on('upgrade', upgradeListener);
+  const runDispose = async () => {
+    const cleanupErrors = [];
+    drainDisconnectErrors(cleanupErrors);
+    websocketServer.off('connection', trackConnection);
+    upgradeServer.off('upgrade', upgradeListener);
+    for (const client of websocketServer.clients) {
+      client.terminate();
+    }
+    while (pendingDisconnects.size > 0) {
+      const disconnectResults = await Promise.allSettled([...pendingDisconnects]);
+      for (const result of disconnectResults) {
+        if (result.status === 'rejected') {
+          collectCleanupError(cleanupErrors, result.reason);
+        }
+      }
+    }
+    drainDisconnectErrors(cleanupErrors);
+    if (!websocketDisposableDisposed) {
+      try {
+        await websocketDisposable.dispose();
+        websocketDisposableDisposed = true;
+      } catch (error) {
+        collectCleanupError(cleanupErrors, error);
+      }
+    }
+    if (!websocketServerClosed) {
+      try {
+        await closeWebSocketServer(websocketServer);
+        websocketServerClosed = true;
+      } catch (error) {
+        collectCleanupError(cleanupErrors, error);
+      }
+    }
+    while (pendingDisconnects.size > 0) {
+      const lateDisconnectResults = await Promise.allSettled([...pendingDisconnects]);
+      for (const result of lateDisconnectResults) {
+        if (result.status === 'rejected') {
+          collectCleanupError(cleanupErrors, result.reason);
+        }
+      }
+    }
+    drainDisconnectErrors(cleanupErrors);
+    if (cleanupErrors.length === 1) {
+      throw cleanupErrors[0];
+    }
+    if (cleanupErrors.length > 1) {
+      throw new AggregateError(cleanupErrors, 'Failed to dispose GraphQL websocket transport resources.');
+    }
+  };
+  return {
+    async dispose() {
+      inFlightDispose ??= runDispose().finally(() => {
+        inFlightDispose = undefined;
+      });
+      await inFlightDispose;
+    }
+  };
+}

package/dist/pipeline/input-pipeline.js

@@ -1,4 +1,4 @@
-import { getDtoValidationSchema } from '@fluojs/core/internal';
+import { getDtoValidationSchema } from '@fluojs/core/request-pipeline';
 import { DefaultValidator } from '@fluojs/validation';
 import { isGraphqlListTypeRef } from '../types.js';
 const defaultValidator = new DefaultValidator();

package/dist/schema/object-field-resolvers.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLFieldConfigArgumentMap, GraphQLFieldConfigMap, GraphQLOutputType } from 'graphql';
+import type { GraphQLContext as FluoGraphQLContext, GraphqlRootOutputType, ResolverDescriptor, ResolverHandlerDescriptor } from '../types.js';
+type ResolveOutputType = (outputType: GraphqlRootOutputType) => GraphQLOutputType;
+type ResolveInputArgs = (handler: ResolverHandlerDescriptor) => GraphQLFieldConfigArgumentMap;
+type InvokeObjectFieldResolver = (descriptor: ResolverDescriptor, handler: ResolverHandlerDescriptor, args: Record<string, unknown>, source: unknown, contextValue: FluoGraphQLContext) => Promise<unknown>;
+/**
+ * Indexes object field resolver descriptors and attaches them to matching code-first object types.
+ */
+export declare class ObjectFieldResolverRegistry {
+    private readonly attachedTypeNames;
+    private readonly entriesByTypeName;
+    constructor(descriptors: readonly ResolverDescriptor[]);
+    attach(typeName: string, fields: GraphQLFieldConfigMap<unknown, FluoGraphQLContext>, resolveOutputType: ResolveOutputType, resolveInputArgs: ResolveInputArgs, invokeResolver: InvokeObjectFieldResolver): GraphQLFieldConfigMap<unknown, FluoGraphQLContext>;
+    createMethodArguments(handler: ResolverHandlerDescriptor, input: unknown, parent: unknown, contextValue: FluoGraphQLContext): unknown[];
+    assertAllTargetsAttached(): void;
+}
+export {};
+//# sourceMappingURL=object-field-resolvers.d.ts.map

package/dist/schema/object-field-resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-field-resolvers.d.ts","sourceRoot":"","sources":["../../src/schema/object-field-resolvers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEvG,OAAO,KAAK,EACV,cAAc,IAAI,kBAAkB,EACpC,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAOrB,KAAK,iBAAiB,GAAG,CAAC,UAAU,EAAE,qBAAqB,KAAK,iBAAiB,CAAC;AAClF,KAAK,gBAAgB,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,6BAA6B,CAAC;AAE9F,KAAK,yBAAyB,GAAG,CAC/B,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,yBAAyB,EAClC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,kBAAkB,KAC7B,OAAO,CAAC,OAAO,CAAC,CAAC;AAMtB;;GAEG;AACH,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IACvD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA4D;gBAElF,WAAW,EAAE,SAAS,kBAAkB,EAAE;IAqBtD,MAAM,CACJ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,CAAC,EAC1D,iBAAiB,EAAE,iBAAiB,EACpC,gBAAgB,EAAE,gBAAgB,EAClC,cAAc,EAAE,yBAAyB,GACxC,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,CAAC;IAmCrD,qBAAqB,CACnB,OAAO,EAAE,yBAAyB,EAClC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,kBAAkB,GAC/B,OAAO,EAAE;IAuBZ,wBAAwB,IAAI,IAAI;CASjC"}

package/dist/schema/object-field-resolvers.js

@@ -0,0 +1,86 @@
+import { GraphQLNonNull } from 'graphql';
+function assertNever(value) {
+  throw new Error(`Unsupported GraphQL field resolver parameter binding: ${String(value)}`);
+}
+
+/**
+ * Indexes object field resolver descriptors and attaches them to matching code-first object types.
+ */
+export class ObjectFieldResolverRegistry {
+  attachedTypeNames = new Set();
+  entriesByTypeName = new Map();
+  constructor(descriptors) {
+    for (const descriptor of descriptors) {
+      for (const handler of descriptor.handlers) {
+        if (handler.type !== 'field') {
+          continue;
+        }
+        const fields = this.entriesByTypeName.get(descriptor.typeName) ?? new Map();
+        if (fields.has(handler.fieldName)) {
+          throw new Error(`GraphQL schema conflict: object field resolver "${descriptor.typeName}.${handler.fieldName}" is registered more than once.`);
+        }
+        fields.set(handler.fieldName, {
+          descriptor,
+          handler
+        });
+        this.entriesByTypeName.set(descriptor.typeName, fields);
+      }
+    }
+  }
+  attach(typeName, fields, resolveOutputType, resolveInputArgs, invokeResolver) {
+    const resolverFields = this.entriesByTypeName.get(typeName);
+    if (!resolverFields) {
+      return fields;
+    }
+    this.attachedTypeNames.add(typeName);
+    const attachedFields = {
+      ...fields
+    };
+    for (const [fieldName, entry] of resolverFields) {
+      const existingField = attachedFields[fieldName];
+      const outputType = entry.handler.outputType ? resolveOutputType(entry.handler.outputType) : existingField?.type;
+      if (!outputType) {
+        throw new Error(`GraphQL object field resolver "${typeName}.${fieldName}" must target an existing field or declare a type.`);
+      }
+      const hasExplicitNonNullableNewField = existingField === undefined && entry.handler.outputType !== undefined && entry.handler.nullable === false;
+      attachedFields[fieldName] = {
+        ...existingField,
+        ...(entry.handler.inputClass ? {
+          args: resolveInputArgs(entry.handler)
+        } : {}),
+        resolve: async (source, args, contextValue) => invokeResolver(entry.descriptor, entry.handler, args, source, contextValue),
+        type: hasExplicitNonNullableNewField ? new GraphQLNonNull(outputType) : outputType
+      };
+    }
+    return attachedFields;
+  }
+  createMethodArguments(handler, input, parent, contextValue) {
+    const lastBinding = handler.parameterBindings.at(-1);
+    const methodArguments = Array.from({
+      length: (lastBinding?.index ?? -1) + 1
+    });
+    for (const binding of handler.parameterBindings) {
+      switch (binding.kind) {
+        case 'input':
+          methodArguments[binding.index] = input;
+          break;
+        case 'parent':
+          methodArguments[binding.index] = parent;
+          break;
+        case 'context':
+          methodArguments[binding.index] = contextValue;
+          break;
+        default:
+          assertNever(binding.kind);
+      }
+    }
+    return methodArguments;
+  }
+  assertAllTargetsAttached() {
+    for (const typeName of this.entriesByTypeName.keys()) {
+      if (!this.attachedTypeNames.has(typeName)) {
+        throw new Error(`GraphQL object field resolver target type "${typeName}" is not reachable from a code-first root operation output type.`);
+      }
+    }
+  }
+}

package/dist/schema/schema.d.ts

@@ -1,5 +1,5 @@
 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 { GraphQLError as GraphQLErrorType, GraphQLList as GraphQLListType, GraphQLNonNull as GraphQLNonNullType, GraphQLObjectType as GraphQLObjectTypeType, GraphQLScalarType, GraphQLSchema as GraphQLSchemaType, GraphQLUnionType as GraphQLUnionTypeType } from 'graphql';
 import { type ResolverDescriptor } from '../types.js';
 type YogaGraphqlDeps = {
     GraphQLError: typeof GraphQLErrorType;
@@ -8,11 +8,15 @@ type YogaGraphqlDeps = {
     GraphQLID: GraphQLScalarType;
     GraphQLInt: GraphQLScalarType;
     GraphQLList: typeof GraphQLListType;
+    GraphQLNonNull: typeof GraphQLNonNullType;
     GraphQLObjectType: typeof GraphQLObjectTypeType;
     GraphQLSchema: typeof GraphQLSchemaType;
     GraphQLString: GraphQLScalarType;
     GraphQLUnionType: typeof GraphQLUnionTypeType;
     buildSchema: (source: string) => GraphQLSchemaType;
+    createGraphQLError: (message: string, options: {
+        extensions?: Record<string, unknown>;
+    }) => GraphQLErrorType;
 };
 /**
  * Resolve schema.

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

@@ -1 +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;;;;;;;;GAQG;AACH,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;;;;;;;;GAQG;AACH,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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EAEV,YAAY,IAAI,gBAAgB,EAMhC,WAAW,IAAI,eAAe,EAC9B,cAAc,IAAI,kBAAkB,EACpC,iBAAiB,IAAI,qBAAqB,EAE1C,iBAAiB,EACjB,aAAa,IAAI,iBAAiB,EAClC,gBAAgB,IAAI,oBAAoB,EACzC,MAAM,SAAS,CAAC;AAGjB,OAAO,EAOL,KAAK,kBAAkB,EAGxB,MAAM,aAAa,CAAC;AAGrB,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,cAAc,EAAE,OAAO,kBAAkB,CAAC;IAC1C,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;IACnD,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KAAK,gBAAgB,CAAC;CAC9G,CAAC;AA4fF;;;;;;;;GAQG;AACH,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;;;;;;;;GAQG;AACH,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,CA6EnB"}