@navios/openapi 0.9.1 → 1.0.0-alpha.3

package/lib/{services-MFCyRMd8.mjs → services-B7UR1D1X.mjs}

@@ -1,4 +1,4 @@
-import { Injectable, Logger, MultipartAdapterToken, StreamAdapterToken, extractControllerMetadata, inject } from "@navios/core";
+import { EndpointAdapterToken, Injectable, Logger, MultipartAdapterToken, StreamAdapterToken, extractControllerMetadata, inject } from "@navios/core";
 import { createSchema } from "zod-openapi";
 
 //#region src/tokens/index.mts
@@ -1340,9 +1340,10 @@ var PathBuilderService = class {
 	/**
 	* Gets the endpoint type based on the adapter token
 	*/ getEndpointType(handler) {
+		if (handler.adapterToken === EndpointAdapterToken) return "endpoint";
 		if (handler.adapterToken === MultipartAdapterToken) return "multipart";
 		if (handler.adapterToken === StreamAdapterToken) return "stream";
-		return "endpoint";
+		return "unknown";
 	}
 	/**
 	* Builds OpenAPI parameters from endpoint config
@@ -1413,33 +1414,64 @@ var PathBuilderService = class {
 		switch (this.getEndpointType(handler)) {
 			case "stream": return this.buildStreamResponses(endpoint);
 			case "multipart":
-			case "endpoint":
-			default: return this.buildJsonResponses(config, handler);
+			case "endpoint": return this.buildJsonResponses(config, handler);
+			case "unknown": return this.buildUnknownResponses(config);
+			default: return this.buildUnknownResponses(config);
 		}
 	}
 	/**
+	* Builds error responses from errorSchema
+	*
+	* @param errorSchema - Optional record mapping status codes to Zod schemas
+	* @returns ResponsesObject with error responses, or empty object if no errorSchema
+	*/ buildErrorResponses(errorSchema) {
+		if (!errorSchema) return {};
+		const errorResponses = {};
+		for (const [statusCode, schema] of Object.entries(errorSchema)) {
+			const { schema: convertedSchema } = this.schemaConverter.convert(schema);
+			errorResponses[statusCode] = {
+				description: `Error response (${statusCode})`,
+				content: { "application/json": { schema: convertedSchema } }
+			};
+		}
+		return errorResponses;
+	}
+	/**
 	* Builds responses for JSON endpoints
 	*/ buildJsonResponses(config, handler) {
 		const successCode = handler.successStatusCode?.toString() ?? "200";
-		if (!config.responseSchema) return { [successCode]: { description: "Successful response" } };
-		const { schema } = this.schemaConverter.convert(config.responseSchema);
-		return { [successCode]: {
-			description: "Successful response",
-			content: { "application/json": { schema } }
-		} };
+		const responses = {};
+		if (!config.responseSchema) responses[successCode] = { description: "Successful response" };
+		else {
+			const { schema } = this.schemaConverter.convert(config.responseSchema);
+			responses[successCode] = {
+				description: "Successful response",
+				content: { "application/json": { schema } }
+			};
+		}
+		Object.assign(responses, this.buildErrorResponses(config.errorSchema));
+		return responses;
 	}
 	/**
 	* Builds responses for stream endpoints
 	*/ buildStreamResponses(endpoint) {
-		const { openApiMetadata, handler } = endpoint;
+		const { config, openApiMetadata, handler } = endpoint;
 		const successCode = handler.successStatusCode?.toString() ?? "200";
 		const contentType = openApiMetadata.stream?.contentType ?? "application/octet-stream";
 		const description = openApiMetadata.stream?.description ?? "Stream response";
 		const content = this.getStreamContent(contentType);
-		return { [successCode]: {
+		const responses = { [successCode]: {
 			description,
 			content
 		} };
+		Object.assign(responses, this.buildErrorResponses(config.errorSchema));
+		return responses;
+	}
+	/**
+	* Builds responses for unknown endpoint types.
+	* Unknown types have no success response but can have error responses.
+	*/ buildUnknownResponses(config) {
+		return this.buildErrorResponses(config.errorSchema);
 	}
 	/**
 	* Gets content object for different stream types
@@ -1822,4 +1854,4 @@ var OpenApiGeneratorService = class {
 
 //#endregion
 export { _MetadataExtractorService as a, ApiOperationToken as c, ApiSummaryToken as d, ApiTagToken as f, _EndpointScannerService as i, ApiSecurityToken as l, _PathBuilderService as n, ApiDeprecatedToken as o, _SchemaConverterService as r, ApiExcludeToken as s, _OpenApiGeneratorService as t, ApiStreamToken as u };
-//# sourceMappingURL=services-MFCyRMd8.mjs.map
+//# sourceMappingURL=services-B7UR1D1X.mjs.map

package/lib/services-B7UR1D1X.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"services-B7UR1D1X.mjs","names":["ApiTagToken","Symbol","for","ApiOperationToken","ApiSummaryToken","ApiDeprecatedToken","ApiSecurityToken","ApiExcludeToken","ApiStreamToken","Injectable","ApiDeprecatedToken","ApiExcludeToken","ApiOperationToken","ApiSecurityToken","ApiStreamToken","ApiSummaryToken","ApiTagToken","MetadataExtractorService","extract","controller","handler","controllerTag","customAttributes","get","handlerTag","operation","summary","deprecated","security","excluded","stream","tags","name","push","description","operationId","undefined","externalDocs","extractControllerMetadata","inject","Injectable","Logger","MetadataExtractorService","EndpointScannerService","logger","context","name","metadataExtractor","scan","modules","endpoints","moduleName","moduleMetadata","controllers","size","debug","controllerClass","controllerMeta","controllerEndpoints","scanController","push","length","module","handler","config","openApiMetadata","extract","excluded","classMethod","controller","Injectable","createSchema","SchemaConverterService","convert","schema","isFileSchema","type","format","transformFileProperties","properties","result","key","prop","Object","entries","description","items","EndpointAdapterToken","inject","Injectable","MultipartAdapterToken","StreamAdapterToken","SchemaConverterService","PathBuilderService","schemaConverter","build","endpoint","config","handler","openApiMetadata","path","convertUrlParams","url","operation","tags","length","undefined","summary","description","operationId","deprecated","externalDocs","security","parameters","buildParameters","requestBody","buildRequestBody","responses","buildResponses","cleanOperation","Object","fromEntries","entries","filter","v","pathItem","method","toLowerCase","replace","extractUrlParamNames","matches","matchAll","Array","from","m","getEndpointType","adapterToken","params","urlParams","param","push","name","in","required","schema","type","querySchema","convert","schemaObj","properties","includes","buildMultipartRequestBody","buildJsonRequestBody","requestSchema","content","transformFileProperties","buildStreamResponses","buildJsonResponses","buildUnknownResponses","buildErrorResponses","errorSchema","errorResponses","statusCode","convertedSchema","successCode","successStatusCode","toString","responseSchema","assign","contentType","stream","getStreamContent","format","inject","Injectable","Logger","EndpointScannerService","PathBuilderService","OpenApiGeneratorService","logger","context","name","scanner","pathBuilder","generate","modules","options","debug","endpoints","scan","paths","buildPaths","discoveredTags","collectTags","tags","mergeTags","document","openapi","info","servers","length","externalDocs","security","securitySchemes","components","Object","keys","endpoint","path","pathItem","build","Set","tag","openApiMetadata","add","configuredTags","tagMap","Map","set","tagName","has","Array","from","values"],"sources":["../src/tokens/index.mts","../src/services/metadata-extractor.service.mts","../src/services/endpoint-scanner.service.mts","../src/services/schema-converter.service.mts","../src/services/path-builder.service.mts","../src/services/openapi-generator.service.mts"],"sourcesContent":["/**\n * Tokens for OpenAPI metadata attributes\n */\n\n/** Token for @ApiTag decorator */\nexport const ApiTagToken = Symbol.for('navios:openapi:tag')\n\n/** Token for @ApiOperation decorator */\nexport const ApiOperationToken = Symbol.for('navios:openapi:operation')\n\n/** Token for @ApiSummary decorator */\nexport const ApiSummaryToken = Symbol.for('navios:openapi:summary')\n\n/** Token for @ApiDeprecated decorator */\nexport const ApiDeprecatedToken = Symbol.for('navios:openapi:deprecated')\n\n/** Token for @ApiSecurity decorator */\nexport const ApiSecurityToken = Symbol.for('navios:openapi:security')\n\n/** Token for @ApiExclude decorator */\nexport const ApiExcludeToken = Symbol.for('navios:openapi:exclude')\n\n/** Token for @ApiStream decorator */\nexport const ApiStreamToken = Symbol.for('navios:openapi:stream')\n","import type { ControllerMetadata, HandlerMetadata } from '@navios/core'\n\nimport { Injectable } from '@navios/core'\n\nimport type { OpenApiEndpointMetadata } from '../metadata/openapi.metadata.mjs'\n\nimport {\n  ApiDeprecatedToken,\n  ApiExcludeToken,\n  ApiOperationToken,\n  ApiSecurityToken,\n  ApiStreamToken,\n  ApiSummaryToken,\n  ApiTagToken,\n} from '../tokens/index.mjs'\n\n/**\n * Service responsible for extracting OpenAPI metadata from decorators.\n *\n * Merges controller-level and handler-level metadata to produce\n * a complete OpenAPI metadata object for each endpoint.\n */\n@Injectable()\nexport class MetadataExtractorService {\n  /**\n   * Extracts and merges OpenAPI metadata from controller and handler.\n   *\n   * @param controller - Controller metadata\n   * @param handler - Handler metadata\n   * @returns Merged OpenAPI metadata\n   */\n  extract(\n    controller: ControllerMetadata,\n    handler: HandlerMetadata<any>,\n  ): OpenApiEndpointMetadata {\n    // Extract controller-level metadata\n    const controllerTag = controller.customAttributes.get(ApiTagToken) as\n      | { name: string; description?: string }\n      | undefined\n\n    // Extract handler-level metadata\n    const handlerTag = handler.customAttributes.get(ApiTagToken) as\n      | { name: string; description?: string }\n      | undefined\n    const operation = handler.customAttributes.get(ApiOperationToken) as\n      | {\n          summary?: string\n          description?: string\n          operationId?: string\n          deprecated?: boolean\n          externalDocs?: { url: string; description?: string }\n        }\n      | undefined\n    const summary = handler.customAttributes.get(ApiSummaryToken) as\n      | string\n      | undefined\n    const deprecated = handler.customAttributes.get(ApiDeprecatedToken) as\n      | { message?: string }\n      | undefined\n    const security = handler.customAttributes.get(ApiSecurityToken) as\n      | Record<string, string[]>\n      | undefined\n    const excluded = handler.customAttributes.get(ApiExcludeToken) as\n      | boolean\n      | undefined\n    const stream = handler.customAttributes.get(ApiStreamToken) as\n      | { contentType: string; description?: string }\n      | undefined\n\n    // Build tags array (handler tag takes precedence but both are included)\n    const tags: string[] = []\n    if (controllerTag?.name) {\n      tags.push(controllerTag.name)\n    }\n    if (handlerTag?.name && handlerTag.name !== controllerTag?.name) {\n      tags.push(handlerTag.name)\n    }\n\n    return {\n      tags,\n      summary: operation?.summary ?? summary,\n      description: operation?.description,\n      operationId: operation?.operationId,\n      deprecated: deprecated !== undefined || operation?.deprecated === true,\n      externalDocs: operation?.externalDocs,\n      security: security ? [security] : undefined,\n      excluded: excluded === true,\n      stream,\n    }\n  }\n}\n","import type { BaseEndpointOptions, EndpointOptions } from '@navios/builder'\nimport type {\n  ControllerMetadata,\n  HandlerMetadata,\n  ModuleMetadata,\n} from '@navios/core'\n\nimport {\n  extractControllerMetadata,\n  inject,\n  Injectable,\n  Logger,\n} from '@navios/core'\n\nimport type { OpenApiEndpointMetadata } from '../metadata/openapi.metadata.mjs'\n\nimport { MetadataExtractorService } from './metadata-extractor.service.mjs'\n\n/**\n * Represents a discovered endpoint with all its metadata\n */\nexport interface DiscoveredEndpoint {\n  /** Module metadata */\n  module: ModuleMetadata\n  /** Controller class */\n  controllerClass: any\n  /** Controller metadata */\n  controller: ControllerMetadata\n  /** Handler (endpoint) metadata */\n  handler: HandlerMetadata<any>\n  /** Endpoint configuration from @navios/builder */\n  config: EndpointOptions | BaseEndpointOptions\n  /** Extracted OpenAPI metadata */\n  openApiMetadata: OpenApiEndpointMetadata\n}\n\n/**\n * Service responsible for scanning modules and discovering endpoints.\n *\n * Iterates through all modules, controllers, and endpoints,\n * extracting OpenAPI metadata from decorators.\n */\n@Injectable()\nexport class EndpointScannerService {\n  private readonly logger = inject(Logger, {\n    context: EndpointScannerService.name,\n  })\n\n  private readonly metadataExtractor = inject(MetadataExtractorService)\n\n  /**\n   * Scans all loaded modules and discovers endpoints.\n   *\n   * @param modules - Map of loaded modules from NaviosApplication\n   * @returns Array of discovered endpoints\n   */\n  scan(modules: Map<string, ModuleMetadata>): DiscoveredEndpoint[] {\n    const endpoints: DiscoveredEndpoint[] = []\n\n    for (const [moduleName, moduleMetadata] of modules) {\n      if (\n        !moduleMetadata.controllers ||\n        moduleMetadata.controllers.size === 0\n      ) {\n        continue\n      }\n\n      this.logger.debug(`Scanning module: ${moduleName}`)\n\n      for (const controllerClass of moduleMetadata.controllers) {\n        const controllerMeta = extractControllerMetadata(controllerClass)\n        const controllerEndpoints = this.scanController(\n          moduleMetadata,\n          controllerClass,\n          controllerMeta,\n        )\n        endpoints.push(...controllerEndpoints)\n      }\n    }\n\n    this.logger.debug(`Discovered ${endpoints.length} endpoints`)\n    return endpoints\n  }\n\n  /**\n   * Scans a controller and returns its endpoints\n   */\n  private scanController(\n    module: ModuleMetadata,\n    controllerClass: any,\n    controllerMeta: ControllerMetadata,\n  ): DiscoveredEndpoint[] {\n    const endpoints: DiscoveredEndpoint[] = []\n\n    for (const handler of controllerMeta.endpoints) {\n      // Skip endpoints without config (non-builder endpoints)\n      if (!handler.config) {\n        continue\n      }\n\n      const openApiMetadata = this.metadataExtractor.extract(\n        controllerMeta,\n        handler,\n      )\n\n      // Skip excluded endpoints\n      if (openApiMetadata.excluded) {\n        this.logger.debug(`Skipping excluded endpoint: ${handler.classMethod}`)\n        continue\n      }\n\n      endpoints.push({\n        module,\n        controllerClass,\n        controller: controllerMeta,\n        handler,\n        config: handler.config as EndpointOptions | BaseEndpointOptions,\n        openApiMetadata,\n      })\n    }\n\n    return endpoints\n  }\n}\n","import type { ZodType } from 'zod/v4'\nimport type { oas31 } from 'zod-openapi'\n\nimport { Injectable } from '@navios/core'\nimport { createSchema } from 'zod-openapi'\n\ntype SchemaObject = oas31.SchemaObject\ntype ReferenceObject = oas31.ReferenceObject\n\n/**\n * Result of schema conversion\n */\nexport interface SchemaConversionResult {\n  schema: SchemaObject | ReferenceObject\n  components: Record<string, SchemaObject>\n}\n\n/**\n * Service responsible for converting Zod schemas to OpenAPI schemas.\n *\n * Uses zod-openapi library which supports Zod 4's native `.meta()` method\n * for OpenAPI-specific metadata.\n */\n@Injectable()\nexport class SchemaConverterService {\n  /**\n   * Converts a Zod schema to an OpenAPI schema object.\n   *\n   * @param schema - Zod schema to convert\n   * @returns OpenAPI schema object with any component schemas\n   *\n   * @example\n   * ```typescript\n   * const userSchema = z.object({\n   *   id: z.string().meta({ openapi: { example: 'usr_123' } }),\n   *   name: z.string(),\n   * })\n   *\n   * const result = schemaConverter.convert(userSchema)\n   * // { schema: { type: 'object', properties: { ... } }, components: {} }\n   * ```\n   */\n  convert(schema: ZodType): SchemaConversionResult {\n    return createSchema(schema)\n  }\n\n  /**\n   * Checks if a schema property represents a File type.\n   *\n   * Used for multipart form handling to convert File types to binary format.\n   *\n   * @param schema - Schema object to check\n   * @returns true if the schema represents a file\n   */\n  isFileSchema(schema: SchemaObject): boolean {\n    return schema.type === 'string' && schema.format === 'binary'\n  }\n\n  /**\n   * Transforms schema properties to handle File/Blob types for multipart.\n   *\n   * Converts File types to OpenAPI binary format and handles arrays of files.\n   *\n   * @param properties - Schema properties object\n   * @returns Transformed properties with file types as binary\n   */\n  transformFileProperties(\n    properties: Record<string, SchemaObject>,\n  ): Record<string, SchemaObject> {\n    const result: Record<string, SchemaObject> = {}\n\n    for (const [key, prop] of Object.entries(properties)) {\n      if (this.isFileSchema(prop)) {\n        result[key] = {\n          type: 'string',\n          format: 'binary',\n          description: prop.description,\n        }\n      } else if (\n        prop.type === 'array' &&\n        prop.items &&\n        this.isFileSchema(prop.items as SchemaObject)\n      ) {\n        result[key] = {\n          type: 'array',\n          items: { type: 'string', format: 'binary' },\n          description: prop.description,\n        }\n      } else {\n        result[key] = prop\n      }\n    }\n\n    return result\n  }\n}\n","import type {\n  BaseEndpointOptions,\n  EndpointOptions,\n  ErrorSchemaRecord,\n} from '@navios/builder'\nimport type { HandlerMetadata } from '@navios/core'\nimport type { oas31 } from 'zod-openapi'\n\nimport {\n  EndpointAdapterToken,\n  inject,\n  Injectable,\n  MultipartAdapterToken,\n  StreamAdapterToken,\n} from '@navios/core'\n\nimport type { DiscoveredEndpoint } from './endpoint-scanner.service.mjs'\n\nimport { SchemaConverterService } from './schema-converter.service.mjs'\n\ntype ContentObject = oas31.ContentObject\ntype OperationObject = oas31.OperationObject\ntype ParameterObject = oas31.ParameterObject\ntype PathItemObject = oas31.PathItemObject\ntype RequestBodyObject = oas31.RequestBodyObject\ntype ResponsesObject = oas31.ResponsesObject\ntype SchemaObject = oas31.SchemaObject\n\n/**\n * Result of path item generation\n */\nexport interface PathItemResult {\n  path: string\n  pathItem: PathItemObject\n}\n\n/**\n * Service responsible for building OpenAPI path items from endpoints.\n *\n * Handles URL parameter conversion, request body generation,\n * and response schema generation for different endpoint types.\n */\n@Injectable()\nexport class PathBuilderService {\n  private readonly schemaConverter = inject(SchemaConverterService)\n\n  /**\n   * Generates an OpenAPI path item for a discovered endpoint.\n   *\n   * @param endpoint - Discovered endpoint with metadata\n   * @returns Path string and path item object\n   */\n  build(endpoint: DiscoveredEndpoint): PathItemResult {\n    const { config, handler, openApiMetadata } = endpoint\n\n    // Convert $param to {param} format for OpenAPI\n    const path = this.convertUrlParams(config.url)\n\n    const operation: OperationObject = {\n      tags: openApiMetadata.tags.length > 0 ? openApiMetadata.tags : undefined,\n      summary: openApiMetadata.summary,\n      description: openApiMetadata.description,\n      operationId: openApiMetadata.operationId,\n      deprecated: openApiMetadata.deprecated || undefined,\n      externalDocs: openApiMetadata.externalDocs,\n      security: openApiMetadata.security,\n      parameters: this.buildParameters(config as EndpointOptions),\n      requestBody: this.buildRequestBody(config as EndpointOptions, handler),\n      responses: this.buildResponses(endpoint),\n    }\n\n    // Remove undefined properties\n    const cleanOperation = Object.fromEntries(\n      Object.entries(operation).filter(([, v]) => v !== undefined),\n    ) as OperationObject\n\n    return {\n      path,\n      pathItem: {\n        [config.method.toLowerCase()]: cleanOperation,\n      },\n    }\n  }\n\n  /**\n   * Converts Navios URL param format ($param) to OpenAPI format ({param})\n   */\n  convertUrlParams(url: string): string {\n    return url.replace(/\\$(\\w+)/g, '{$1}')\n  }\n\n  /**\n   * Extracts URL parameter names from a URL pattern\n   */\n  extractUrlParamNames(url: string): string[] {\n    const matches = url.matchAll(/\\$(\\w+)/g)\n    return Array.from(matches, (m) => m[1])\n  }\n\n  /**\n   * Gets the endpoint type based on the adapter token\n   */\n  getEndpointType(\n    handler: HandlerMetadata<any>,\n  ): 'endpoint' | 'multipart' | 'stream' | 'unknown' {\n    if (handler.adapterToken === EndpointAdapterToken) {\n      return 'endpoint'\n    }\n    if (handler.adapterToken === MultipartAdapterToken) {\n      return 'multipart'\n    }\n    if (handler.adapterToken === StreamAdapterToken) {\n      return 'stream'\n    }\n    return 'unknown'\n  }\n\n  /**\n   * Builds OpenAPI parameters from endpoint config\n   */\n  private buildParameters(config: EndpointOptions): ParameterObject[] {\n    const params: ParameterObject[] = []\n\n    // URL parameters (from $paramName in URL)\n    const urlParams = this.extractUrlParamNames(config.url)\n    for (const param of urlParams) {\n      params.push({\n        name: param,\n        in: 'path',\n        required: true,\n        schema: { type: 'string' },\n      })\n    }\n\n    // Query parameters (from querySchema)\n    if (config.querySchema) {\n      const { schema: querySchema } = this.schemaConverter.convert(\n        config.querySchema,\n      )\n      const schemaObj = querySchema as SchemaObject\n      if (schemaObj.properties) {\n        for (const [name, schema] of Object.entries(schemaObj.properties)) {\n          params.push({\n            name,\n            in: 'query',\n            required: schemaObj.required?.includes(name) ?? false,\n            schema: schema as SchemaObject,\n            description: (schema as SchemaObject).description,\n          })\n        }\n      }\n    }\n\n    return params\n  }\n\n  /**\n   * Builds request body based on endpoint type\n   */\n  private buildRequestBody(\n    config: EndpointOptions,\n    handler: HandlerMetadata<any>,\n  ): RequestBodyObject | undefined {\n    const type = this.getEndpointType(handler)\n\n    switch (type) {\n      case 'multipart':\n        return this.buildMultipartRequestBody(config)\n      case 'stream':\n        return undefined // Streams typically don't have request bodies\n      case 'endpoint':\n      default:\n        return this.buildJsonRequestBody(config)\n    }\n  }\n\n  /**\n   * Builds request body for JSON endpoints\n   */\n  private buildJsonRequestBody(\n    config: EndpointOptions,\n  ): RequestBodyObject | undefined {\n    if (!config.requestSchema) {\n      return undefined\n    }\n\n    const { schema } = this.schemaConverter.convert(config.requestSchema)\n\n    return {\n      required: true,\n      content: {\n        'application/json': {\n          schema,\n        },\n      },\n    }\n  }\n\n  /**\n   * Builds request body for multipart endpoints\n   */\n  private buildMultipartRequestBody(\n    config: EndpointOptions,\n  ): RequestBodyObject {\n    if (!config.requestSchema) {\n      return {\n        required: true,\n        content: {\n          'multipart/form-data': {\n            schema: { type: 'object' },\n          },\n        },\n      }\n    }\n\n    const schema = this.schemaConverter.convert(config.requestSchema)\n      .schema as SchemaObject\n\n    // Transform schema properties to handle File types\n    const properties = this.schemaConverter.transformFileProperties(\n      (schema.properties as Record<string, SchemaObject>) || {},\n    )\n\n    return {\n      required: true,\n      content: {\n        'multipart/form-data': {\n          schema: {\n            type: 'object',\n            properties,\n            required: schema.required,\n          },\n        },\n      },\n    }\n  }\n\n  /**\n   * Builds responses based on endpoint type\n   */\n  private buildResponses(endpoint: DiscoveredEndpoint): ResponsesObject {\n    const { config, handler } = endpoint\n    const type = this.getEndpointType(handler)\n\n    switch (type) {\n      case 'stream':\n        return this.buildStreamResponses(endpoint)\n      case 'multipart':\n      case 'endpoint':\n        return this.buildJsonResponses(config as EndpointOptions, handler)\n      case 'unknown':\n        return this.buildUnknownResponses(config)\n      default:\n        return this.buildUnknownResponses(config)\n    }\n  }\n\n  /**\n   * Builds error responses from errorSchema\n   *\n   * @param errorSchema - Optional record mapping status codes to Zod schemas\n   * @returns ResponsesObject with error responses, or empty object if no errorSchema\n   */\n  private buildErrorResponses(\n    errorSchema?: ErrorSchemaRecord,\n  ): ResponsesObject {\n    if (!errorSchema) {\n      return {}\n    }\n\n    const errorResponses: ResponsesObject = {}\n\n    for (const [statusCode, schema] of Object.entries(errorSchema)) {\n      const { schema: convertedSchema } = this.schemaConverter.convert(schema)\n      errorResponses[statusCode] = {\n        description: `Error response (${statusCode})`,\n        content: {\n          'application/json': {\n            schema: convertedSchema,\n          },\n        },\n      }\n    }\n\n    return errorResponses\n  }\n\n  /**\n   * Builds responses for JSON endpoints\n   */\n  private buildJsonResponses(\n    config: EndpointOptions,\n    handler: HandlerMetadata<any>,\n  ): ResponsesObject {\n    const successCode = handler.successStatusCode?.toString() ?? '200'\n    const responses: ResponsesObject = {}\n\n    // Build success response\n    if (!config.responseSchema) {\n      responses[successCode] = {\n        description: 'Successful response',\n      }\n    } else {\n      const { schema } = this.schemaConverter.convert(config.responseSchema)\n      responses[successCode] = {\n        description: 'Successful response',\n        content: {\n          'application/json': {\n            schema,\n          },\n        },\n      }\n    }\n\n    // Add error responses from errorSchema\n    Object.assign(responses, this.buildErrorResponses(config.errorSchema))\n\n    return responses\n  }\n\n  /**\n   * Builds responses for stream endpoints\n   */\n  private buildStreamResponses(endpoint: DiscoveredEndpoint): ResponsesObject {\n    const { config, openApiMetadata, handler } = endpoint\n    const successCode = handler.successStatusCode?.toString() ?? '200'\n\n    const contentType =\n      openApiMetadata.stream?.contentType ?? 'application/octet-stream'\n    const description = openApiMetadata.stream?.description ?? 'Stream response'\n\n    const content: ContentObject = this.getStreamContent(contentType)\n\n    const responses: ResponsesObject = {\n      [successCode]: {\n        description,\n        content,\n      },\n    }\n\n    // Add error responses from errorSchema\n    Object.assign(responses, this.buildErrorResponses(config.errorSchema))\n\n    return responses\n  }\n\n  /**\n   * Builds responses for unknown endpoint types.\n   * Unknown types have no success response but can have error responses.\n   */\n  private buildUnknownResponses(\n    config: EndpointOptions | BaseEndpointOptions,\n  ): ResponsesObject {\n    // Only include error responses, no success response\n    return this.buildErrorResponses(config.errorSchema)\n  }\n\n  /**\n   * Gets content object for different stream types\n   */\n  private getStreamContent(contentType: string): ContentObject {\n    switch (contentType) {\n      case 'text/event-stream':\n        return {\n          'text/event-stream': {\n            schema: {\n              type: 'string',\n              description: 'Server-Sent Events stream',\n            },\n          },\n        }\n\n      case 'application/octet-stream':\n        return {\n          'application/octet-stream': {\n            schema: {\n              type: 'string',\n              format: 'binary',\n              description: 'Binary file download',\n            },\n          },\n        }\n\n      case 'application/json':\n        return {\n          'application/json': {\n            schema: {\n              type: 'string',\n              description: 'Newline-delimited JSON stream',\n            },\n          },\n        }\n\n      default:\n        return {\n          [contentType]: {\n            schema: { type: 'string', format: 'binary' },\n          },\n        }\n    }\n  }\n}\n","import type { ModuleMetadata } from '@navios/core'\nimport type { oas31 } from 'zod-openapi'\n\nimport { inject, Injectable, Logger } from '@navios/core'\n\nimport type { DiscoveredEndpoint } from './endpoint-scanner.service.mjs'\n\nimport { EndpointScannerService } from './endpoint-scanner.service.mjs'\nimport { PathBuilderService } from './path-builder.service.mjs'\n\ntype OpenAPIObject = oas31.OpenAPIObject\ntype PathsObject = oas31.PathsObject\ntype SecuritySchemeObject = oas31.SecuritySchemeObject\ntype TagObject = oas31.TagObject\n\n/**\n * Options for generating the OpenAPI document\n */\nexport interface OpenApiGeneratorOptions {\n  /**\n   * OpenAPI document info\n   */\n  info: {\n    title: string\n    version: string\n    description?: string\n    termsOfService?: string\n    contact?: {\n      name?: string\n      url?: string\n      email?: string\n    }\n    license?: {\n      name: string\n      url?: string\n    }\n  }\n\n  /**\n   * External documentation\n   */\n  externalDocs?: {\n    url: string\n    description?: string\n  }\n\n  /**\n   * Server definitions\n   */\n  servers?: Array<{\n    url: string\n    description?: string\n    variables?: Record<\n      string,\n      {\n        default: string\n        enum?: string[]\n        description?: string\n      }\n    >\n  }>\n\n  /**\n   * Security scheme definitions\n   */\n  securitySchemes?: Record<string, SecuritySchemeObject>\n\n  /**\n   * Global security requirements\n   */\n  security?: Array<Record<string, string[]>>\n\n  /**\n   * Tag definitions with descriptions\n   */\n  tags?: TagObject[]\n}\n\n/**\n * Service responsible for generating the complete OpenAPI document.\n *\n * Orchestrates endpoint discovery, path generation, and document assembly.\n */\n@Injectable()\nexport class OpenApiGeneratorService {\n  private readonly logger = inject(Logger, {\n    context: OpenApiGeneratorService.name,\n  })\n\n  private readonly scanner = inject(EndpointScannerService)\n  private readonly pathBuilder = inject(PathBuilderService)\n\n  /**\n   * Generates an OpenAPI document from loaded modules.\n   *\n   * @param modules - Map of loaded modules\n   * @param options - OpenAPI generation options\n   * @returns Complete OpenAPI document\n   */\n  generate(\n    modules: Map<string, ModuleMetadata>,\n    options: OpenApiGeneratorOptions,\n  ): OpenAPIObject {\n    this.logger.debug('Generating OpenAPI document')\n\n    // Discover all endpoints\n    const endpoints = this.scanner.scan(modules)\n\n    // Generate paths\n    const paths = this.buildPaths(endpoints)\n\n    // Collect unique tags from endpoints\n    const discoveredTags = this.collectTags(endpoints)\n\n    // Merge discovered tags with configured tags\n    const tags = this.mergeTags(discoveredTags, options.tags)\n\n    // Build the OpenAPI document\n    const document: OpenAPIObject = {\n      openapi: '3.1.0',\n      info: options.info,\n      paths,\n    }\n\n    // Add optional fields\n    if (options.servers && options.servers.length > 0) {\n      document.servers = options.servers\n    }\n\n    if (options.externalDocs) {\n      document.externalDocs = options.externalDocs\n    }\n\n    if (tags.length > 0) {\n      document.tags = tags\n    }\n\n    if (options.security) {\n      document.security = options.security\n    }\n\n    if (options.securitySchemes) {\n      document.components = {\n        ...document.components,\n        securitySchemes: options.securitySchemes,\n      }\n    }\n\n    this.logger.debug(\n      `Generated OpenAPI document with ${Object.keys(paths).length} paths`,\n    )\n\n    return document\n  }\n\n  /**\n   * Builds paths object from discovered endpoints\n   */\n  private buildPaths(endpoints: DiscoveredEndpoint[]): PathsObject {\n    const paths: PathsObject = {}\n\n    for (const endpoint of endpoints) {\n      const { path, pathItem } = this.pathBuilder.build(endpoint)\n\n      // Merge with existing path if methods differ\n      if (paths[path]) {\n        paths[path] = {\n          ...paths[path],\n          ...pathItem,\n        }\n      } else {\n        paths[path] = pathItem\n      }\n    }\n\n    return paths\n  }\n\n  /**\n   * Collects unique tags from endpoints\n   */\n  private collectTags(endpoints: DiscoveredEndpoint[]): Set<string> {\n    const tags = new Set<string>()\n\n    for (const endpoint of endpoints) {\n      for (const tag of endpoint.openApiMetadata.tags) {\n        tags.add(tag)\n      }\n    }\n\n    return tags\n  }\n\n  /**\n   * Merges discovered tags with configured tags\n   */\n  private mergeTags(\n    discoveredTags: Set<string>,\n    configuredTags?: TagObject[],\n  ): TagObject[] {\n    const tagMap = new Map<string, TagObject>()\n\n    // Add configured tags first (they have descriptions)\n    if (configuredTags) {\n      for (const tag of configuredTags) {\n        tagMap.set(tag.name, tag)\n      }\n    }\n\n    // Add discovered tags that aren't already configured\n    for (const tagName of discoveredTags) {\n      if (!tagMap.has(tagName)) {\n        tagMap.set(tagName, { name: tagName })\n      }\n    }\n\n    return Array.from(tagMap.values())\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/openapi",
-  "version": "0.9.1",
+  "version": "1.0.0-alpha.3",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -12,7 +12,7 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@navios/core": "^0.9.3",
+    "@navios/core": "^1.0.0-alpha.3",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "typings": "./lib/index.d.mts",
@@ -41,13 +41,12 @@
     }
   },
   "devDependencies": {
-    "@navios/builder": "^0.5.3",
-    "@navios/core": "^0.9.3",
+    "@navios/builder": "^1.0.0-alpha.2",
+    "@navios/core": "^1.0.0-alpha.3",
     "typescript": "^5.9.3",
     "zod": "^4.2.1"
   },
   "dependencies": {
-    "@navios/di": "^0.9.2",
     "yaml": "^2.8.2",
     "zod-openapi": "^5.4.5"
   }

package/src/__tests__/endpoint-scanner.service.spec.mts

@@ -0,0 +1,362 @@
+import type { BaseEndpointOptions } from '@navios/builder'
+import type {
+  ControllerMetadata,
+  HandlerMetadata,
+  ModuleMetadata,
+} from '@navios/core'
+
+import { Logger } from '@navios/core'
+import { TestContainer } from '@navios/di/testing'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { EndpointScannerService } from '../services/endpoint-scanner.service.mjs'
+import { MetadataExtractorService } from '../services/metadata-extractor.service.mjs'
+
+// Mock metadata extractor
+const mockMetadataExtractor = {
+  extract: vi.fn().mockReturnValue({
+    tags: ['default'],
+    summary: '',
+    description: '',
+    operationId: '',
+    deprecated: false,
+    excluded: false,
+    security: [],
+  }),
+}
+
+// Mock logger
+const mockLogger = {
+  debug: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+}
+
+// Mock extractControllerMetadata
+vi.mock('@navios/core', async () => {
+  const actual = await vi.importActual('@navios/core')
+  return {
+    ...actual,
+    extractControllerMetadata: vi.fn((controller) => controller.__metadata),
+  }
+})
+
+const createHandlerMetadata = (
+  config: Partial<BaseEndpointOptions> | undefined,
+  classMethod = 'test',
+): HandlerMetadata<any> => ({
+  classMethod,
+  url: config?.url ?? '',
+  successStatusCode: 200,
+  adapterToken: null,
+  headers: {},
+  httpMethod: config?.method ?? 'GET',
+  config: config as BaseEndpointOptions,
+  guards: new Set(),
+  customAttributes: new Map(),
+})
+
+describe('EndpointScannerService', () => {
+  let container: TestContainer
+
+  beforeEach(() => {
+    container = new TestContainer()
+    // Bind required dependencies
+    container.bind(Logger).toValue(mockLogger as any)
+    container
+      .bind(MetadataExtractorService)
+      .toValue(mockMetadataExtractor as any)
+    vi.clearAllMocks()
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('scan', () => {
+    it('should discover endpoints from modules', async () => {
+      const scanner = await container.get(EndpointScannerService)
+
+      // Create mock handler metadata
+      const handler = createHandlerMetadata(
+        {
+          method: 'GET',
+          url: '/users',
+        },
+        'getUsers',
+      )
+
+      // Create mock controller metadata
+      const controllerMeta: ControllerMetadata = {
+        endpoints: new Set([handler]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      // Create mock controller class with attached metadata
+      class TestController {
+        static __metadata = controllerMeta
+      }
+
+      // Create mock module metadata
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set([TestController as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['TestModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(1)
+      expect(endpoints[0].handler).toBe(handler)
+      expect(endpoints[0].module).toBe(moduleMetadata)
+      expect(mockLogger.debug).toHaveBeenCalled()
+    })
+
+    it('should skip modules without controllers', async () => {
+      const scanner = await container.get(EndpointScannerService)
+
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set(),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['EmptyModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(0)
+    })
+
+    it('should skip modules with undefined controllers', async () => {
+      const scanner = await container.get(EndpointScannerService)
+
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set(),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['NoControllerModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(0)
+    })
+
+    it('should skip endpoints without config', async () => {
+      const scanner = await container.get(EndpointScannerService)
+
+      // Handler without config
+      const handler = createHandlerMetadata(undefined, 'noConfigMethod')
+
+      const controllerMeta: ControllerMetadata = {
+        endpoints: new Set([handler]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class TestController {
+        static __metadata = controllerMeta
+      }
+
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set([TestController as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['TestModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(0)
+    })
+
+    it('should skip excluded endpoints', async () => {
+      const excludedExtractor = {
+        extract: vi.fn().mockReturnValue({
+          tags: [],
+          excluded: true, // Excluded
+        }),
+      }
+      await container.invalidate(mockMetadataExtractor as any)
+      container.bind(MetadataExtractorService).toValue(excludedExtractor as any)
+
+      const scanner = await container.get(EndpointScannerService)
+
+      const handler = createHandlerMetadata(
+        {
+          method: 'GET',
+          url: '/excluded',
+        },
+        'excludedMethod',
+      )
+
+      const controllerMeta: ControllerMetadata = {
+        endpoints: new Set([handler]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class TestController {
+        static __metadata = controllerMeta
+      }
+
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set([TestController as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['TestModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(0)
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('Skipping excluded'),
+      )
+    })
+
+    it('should scan multiple modules and controllers', async () => {
+      const scanner = await container.get(EndpointScannerService)
+
+      // Module 1, Controller 1
+      const handler1 = createHandlerMetadata(
+        { method: 'GET', url: '/users' },
+        'getUsers',
+      )
+
+      const controllerMeta1: ControllerMetadata = {
+        endpoints: new Set([handler1]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class Controller1 {
+        static __metadata = controllerMeta1
+      }
+
+      // Module 1, Controller 2
+      const handler2 = createHandlerMetadata(
+        { method: 'POST', url: '/posts' },
+        'createPost',
+      )
+
+      const controllerMeta2: ControllerMetadata = {
+        endpoints: new Set([handler2]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class Controller2 {
+        static __metadata = controllerMeta2
+      }
+
+      const module1: ModuleMetadata = {
+        controllers: new Set([Controller1 as any, Controller2 as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      // Module 2
+      const handler3 = createHandlerMetadata(
+        { method: 'GET', url: '/orders' },
+        'getOrders',
+      )
+
+      const controllerMeta3: ControllerMetadata = {
+        endpoints: new Set([handler3]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class Controller3 {
+        static __metadata = controllerMeta3
+      }
+
+      const module2: ModuleMetadata = {
+        controllers: new Set([Controller3 as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([
+        ['Module1', module1],
+        ['Module2', module2],
+      ])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints).toHaveLength(3)
+    })
+
+    it('should extract openApiMetadata for each endpoint', async () => {
+      const customMetadata = {
+        tags: ['users', 'api'],
+        summary: 'Get all users',
+        description: 'Returns a list of users',
+        operationId: 'getUsers',
+        deprecated: false,
+        excluded: false,
+        security: [{ bearer: [] }],
+      }
+
+      const customExtractor = {
+        extract: vi.fn().mockReturnValue(customMetadata),
+      }
+      await container.invalidate(mockMetadataExtractor as any)
+      container.bind(MetadataExtractorService).toValue(customExtractor as any)
+
+      const scanner = await container.get(EndpointScannerService)
+
+      const handler = createHandlerMetadata(
+        { method: 'GET', url: '/users' },
+        'getUsers',
+      )
+
+      const controllerMeta: ControllerMetadata = {
+        endpoints: new Set([handler]),
+        guards: new Set(),
+        customAttributes: new Map(),
+      }
+
+      class TestController {
+        static __metadata = controllerMeta
+      }
+
+      const moduleMetadata: ModuleMetadata = {
+        controllers: new Set([TestController as any]),
+        imports: new Set(),
+        guards: new Set(),
+        overrides: new Set(),
+        customAttributes: new Map(),
+      }
+
+      const modules = new Map([['TestModule', moduleMetadata]])
+
+      const endpoints = scanner.scan(modules)
+
+      expect(endpoints[0].openApiMetadata).toEqual(customMetadata)
+    })
+  })
+})

package/src/__tests__/metadata.spec.mts

@@ -1,7 +1,7 @@
 import type { HandlerMetadata } from '@navios/core'
 
 import { Controller, extractControllerMetadata } from '@navios/core'
-import { TestContainer } from '@navios/di/testing'
+import { TestContainer } from '@navios/core/testing'
 
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'