@navios/openapi 0.7.0

package/lib/index.d.mts

@@ -0,0 +1,594 @@
+import * as _navios_core0 from "@navios/core";
+import { ControllerMetadata, HandlerMetadata, ModuleMetadata } from "@navios/core";
+import { ZodType, z } from "zod/v4";
+import { oas31 } from "zod-openapi";
+import { BaseEndpointConfig } from "@navios/builder";
+
+//#region src/decorators/api-tag.decorator.d.mts
+declare const ApiTagSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiTag decorator, inferred from the schema */
+type ApiTagOptions = z.infer<typeof ApiTagSchema>;
+/**
+ * Groups endpoints under a specific tag/folder in the documentation.
+ *
+ * Can be applied to controllers (affects all endpoints) or individual methods.
+ * When applied to both, the method-level tag takes precedence.
+ *
+ * @param name - The tag name
+ * @param description - Optional tag description
+ *
+ * @example
+ * ```typescript
+ * // Apply to entire controller
+ * @Controller()
+ * @ApiTag('Users', 'User management operations')
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   async getUser() {}
+ * }
+ *
+ * // Apply to individual endpoint
+ * @Controller()
+ * export class MixedController {
+ *   @Endpoint(getUser)
+ *   @ApiTag('Users')
+ *   async getUser() {}
+ *
+ *   @Endpoint(getOrder)
+ *   @ApiTag('Orders')
+ *   async getOrder() {}
+ * }
+ * ```
+ */
+declare function ApiTag(name: string, description?: string): <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T;
+//#endregion
+//#region src/decorators/api-operation.decorator.d.mts
+declare const ApiOperationSchema: z.ZodObject<{
+  summary: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  operationId: z.ZodOptional<z.ZodString>;
+  deprecated: z.ZodOptional<z.ZodBoolean>;
+  externalDocs: z.ZodOptional<z.ZodObject<{
+    url: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Options for the @ApiOperation decorator, inferred from the schema */
+type ApiOperationOptions = z.infer<typeof ApiOperationSchema>;
+/**
+ * Provides detailed operation metadata for an endpoint.
+ *
+ * Use this decorator when you need to specify multiple operation properties.
+ * For simple cases, consider using @ApiSummary instead.
+ *
+ * @param options - Operation configuration options
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   @ApiOperation({
+ *     summary: 'Get user by ID',
+ *     description: 'Retrieves a user by their unique identifier. Returns 404 if not found.',
+ *     operationId: 'getUserById',
+ *   })
+ *   async getUser(params: EndpointParams<typeof getUser>) {}
+ *
+ *   @Endpoint(legacyGetUser)
+ *   @ApiOperation({
+ *     summary: 'Get user (legacy)',
+ *     deprecated: true,
+ *     externalDocs: {
+ *       url: 'https://docs.example.com/migration',
+ *       description: 'Migration guide'
+ *     }
+ *   })
+ *   async getLegacyUser() {}
+ * }
+ * ```
+ */
+declare const ApiOperation: _navios_core0.ClassSchemaAttribute<z.ZodObject<{
+  summary: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  operationId: z.ZodOptional<z.ZodString>;
+  deprecated: z.ZodOptional<z.ZodBoolean>;
+  externalDocs: z.ZodOptional<z.ZodObject<{
+    url: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+//#endregion
+//#region src/decorators/api-summary.decorator.d.mts
+/**
+ * Shorthand decorator for adding just a summary to an endpoint.
+ *
+ * This is equivalent to `@ApiOperation({ summary: '...' })` but more concise.
+ *
+ * @param summary - Short summary text for the endpoint
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   @ApiSummary('Get user by ID')
+ *   async getUser() {}
+ *
+ *   @Endpoint(createUser)
+ *   @ApiSummary('Create a new user')
+ *   async createUser() {}
+ * }
+ * ```
+ */
+declare const ApiSummary: _navios_core0.ClassSchemaAttribute<z.ZodString>;
+//#endregion
+//#region src/decorators/api-deprecated.decorator.d.mts
+declare const ApiDeprecatedSchema: z.ZodObject<{
+  message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiDeprecated decorator, inferred from the schema */
+type ApiDeprecatedOptions = z.infer<typeof ApiDeprecatedSchema>;
+/**
+ * Marks an endpoint as deprecated.
+ *
+ * Deprecated endpoints are shown with a visual indicator in documentation
+ * and may include a migration message.
+ *
+ * @param message - Optional deprecation message
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   // Simple deprecation
+ *   @Endpoint(legacyGetUser)
+ *   @ApiDeprecated()
+ *   async getLegacyUser() {}
+ *
+ *   // With migration message
+ *   @Endpoint(oldCreateUser)
+ *   @ApiDeprecated('Use POST /v2/users instead')
+ *   async oldCreateUser() {}
+ * }
+ * ```
+ */
+declare function ApiDeprecated(message?: string): <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T;
+//#endregion
+//#region src/decorators/api-security.decorator.d.mts
+declare const ApiSecuritySchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+/** Security requirement for an endpoint, inferred from the schema */
+type ApiSecurityRequirement = z.infer<typeof ApiSecuritySchema>;
+/**
+ * Specifies security requirements for an endpoint.
+ *
+ * The security requirement object maps security scheme names to their scopes.
+ * For schemes that don't use scopes (like API keys), use an empty array.
+ *
+ * @param requirements - Security requirements object
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   // Require bearer token authentication
+ *   @Endpoint(getUser)
+ *   @ApiSecurity({ bearerAuth: [] })
+ *   async getUser() {}
+ *
+ *   // Require multiple authentication methods
+ *   @Endpoint(adminEndpoint)
+ *   @ApiSecurity({ bearerAuth: [], apiKey: [] })
+ *   async adminAction() {}
+ *
+ *   // OAuth2 with specific scopes
+ *   @Endpoint(writeUser)
+ *   @ApiSecurity({ oauth2: ['users:write', 'users:read'] })
+ *   async writeUser() {}
+ * }
+ * ```
+ */
+declare const ApiSecurity: _navios_core0.ClassSchemaAttribute<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+//#endregion
+//#region src/decorators/api-exclude.decorator.d.mts
+/**
+ * Excludes an endpoint from OpenAPI documentation.
+ *
+ * Use this decorator for internal endpoints that should not be visible
+ * in the public API documentation.
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class HealthController {
+ *   @Endpoint(healthCheck)
+ *   @ApiExclude()
+ *   async healthCheck() {
+ *     return { status: 'ok' }
+ *   }
+ *
+ *   @Endpoint(internalMetrics)
+ *   @ApiExclude()
+ *   async internalMetrics() {
+ *     return { ... }
+ *   }
+ * }
+ * ```
+ */
+declare const ApiExclude: _navios_core0.ClassAttribute;
+//#endregion
+//#region src/decorators/api-stream.decorator.d.mts
+declare const ApiStreamSchema: z.ZodObject<{
+  contentType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiStream decorator, inferred from the schema */
+type ApiStreamOptions = z.infer<typeof ApiStreamSchema>;
+/**
+ * Specifies content type and description for stream endpoints.
+ *
+ * Stream endpoints don't have a responseSchema, so this decorator provides
+ * the necessary metadata for OpenAPI documentation.
+ *
+ * @param options - Stream response options
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class FileController {
+ *   // Binary file download
+ *   @Stream(downloadFile)
+ *   @ApiStream({
+ *     contentType: 'application/octet-stream',
+ *     description: 'Download file as binary stream'
+ *   })
+ *   async download(params: StreamParams<typeof downloadFile>, reply: Reply) {
+ *     // Stream implementation
+ *   }
+ * }
+ *
+ * @Controller()
+ * export class EventController {
+ *   // Server-Sent Events
+ *   @Stream(streamEvents)
+ *   @ApiStream({
+ *     contentType: 'text/event-stream',
+ *     description: 'Real-time event stream'
+ *   })
+ *   async stream(params: StreamParams<typeof streamEvents>, reply: Reply) {
+ *     // SSE implementation
+ *   }
+ * }
+ * ```
+ */
+declare const ApiStream: _navios_core0.ClassSchemaAttribute<z.ZodObject<{
+  contentType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+//#endregion
+//#region src/metadata/openapi.metadata.d.mts
+/**
+ * Extracted OpenAPI metadata for an endpoint
+ */
+interface OpenApiEndpointMetadata {
+  /** Tags for grouping endpoints */
+  tags: string[];
+  /** Short summary */
+  summary?: string;
+  /** Detailed description */
+  description?: string;
+  /** Unique operation identifier */
+  operationId?: string;
+  /** Whether the endpoint is deprecated */
+  deprecated: boolean;
+  /** Deprecation message */
+  deprecationMessage?: string;
+  /** Security requirements */
+  security?: ApiSecurityRequirement[];
+  /** External documentation link */
+  externalDocs?: {
+    url: string;
+    description?: string;
+  };
+  /** Stream content type (for stream endpoints) */
+  stream?: ApiStreamOptions;
+  /** Whether to exclude from documentation */
+  excluded: boolean;
+}
+//#endregion
+//#region src/services/endpoint-scanner.service.d.mts
+/**
+ * Represents a discovered endpoint with all its metadata
+ */
+interface DiscoveredEndpoint {
+  /** Module metadata */
+  module: ModuleMetadata;
+  /** Controller class */
+  controllerClass: any;
+  /** Controller metadata */
+  controller: ControllerMetadata;
+  /** Handler (endpoint) metadata */
+  handler: HandlerMetadata<any>;
+  /** Endpoint configuration from @navios/builder */
+  config: BaseEndpointConfig;
+  /** Extracted OpenAPI metadata */
+  openApiMetadata: OpenApiEndpointMetadata;
+}
+/**
+ * Service responsible for scanning modules and discovering endpoints.
+ *
+ * Iterates through all modules, controllers, and endpoints,
+ * extracting OpenAPI metadata from decorators.
+ */
+declare class EndpointScannerService {
+  private readonly logger;
+  private readonly metadataExtractor;
+  /**
+   * Scans all loaded modules and discovers endpoints.
+   *
+   * @param modules - Map of loaded modules from NaviosApplication
+   * @returns Array of discovered endpoints
+   */
+  scan(modules: Map<string, ModuleMetadata>): DiscoveredEndpoint[];
+  /**
+   * Scans a controller and returns its endpoints
+   */
+  private scanController;
+}
+//#endregion
+//#region src/services/metadata-extractor.service.d.mts
+/**
+ * Service responsible for extracting OpenAPI metadata from decorators.
+ *
+ * Merges controller-level and handler-level metadata to produce
+ * a complete OpenAPI metadata object for each endpoint.
+ */
+declare class MetadataExtractorService {
+  /**
+   * Extracts and merges OpenAPI metadata from controller and handler.
+   *
+   * @param controller - Controller metadata
+   * @param handler - Handler metadata
+   * @returns Merged OpenAPI metadata
+   */
+  extract(controller: ControllerMetadata, handler: HandlerMetadata<any>): OpenApiEndpointMetadata;
+}
+//#endregion
+//#region src/services/schema-converter.service.d.mts
+type SchemaObject = oas31.SchemaObject;
+type ReferenceObject = oas31.ReferenceObject;
+/**
+ * Result of schema conversion
+ */
+interface SchemaConversionResult {
+  schema: SchemaObject | ReferenceObject;
+  components: Record<string, SchemaObject>;
+}
+/**
+ * Service responsible for converting Zod schemas to OpenAPI schemas.
+ *
+ * Uses zod-openapi library which supports Zod 4's native `.meta()` method
+ * for OpenAPI-specific metadata.
+ */
+declare class SchemaConverterService {
+  /**
+   * Converts a Zod schema to an OpenAPI schema object.
+   *
+   * @param schema - Zod schema to convert
+   * @returns OpenAPI schema object with any component schemas
+   *
+   * @example
+   * ```typescript
+   * const userSchema = z.object({
+   *   id: z.string().meta({ openapi: { example: 'usr_123' } }),
+   *   name: z.string(),
+   * })
+   *
+   * const result = schemaConverter.convert(userSchema)
+   * // { schema: { type: 'object', properties: { ... } }, components: {} }
+   * ```
+   */
+  convert(schema: ZodType): SchemaConversionResult;
+  /**
+   * Checks if a schema property represents a File type.
+   *
+   * Used for multipart form handling to convert File types to binary format.
+   *
+   * @param schema - Schema object to check
+   * @returns true if the schema represents a file
+   */
+  isFileSchema(schema: SchemaObject): boolean;
+  /**
+   * Transforms schema properties to handle File/Blob types for multipart.
+   *
+   * Converts File types to OpenAPI binary format and handles arrays of files.
+   *
+   * @param properties - Schema properties object
+   * @returns Transformed properties with file types as binary
+   */
+  transformFileProperties(properties: Record<string, SchemaObject>): Record<string, SchemaObject>;
+}
+//#endregion
+//#region src/services/path-builder.service.d.mts
+type PathItemObject = oas31.PathItemObject;
+/**
+ * Result of path item generation
+ */
+interface PathItemResult {
+  path: string;
+  pathItem: PathItemObject;
+}
+/**
+ * Service responsible for building OpenAPI path items from endpoints.
+ *
+ * Handles URL parameter conversion, request body generation,
+ * and response schema generation for different endpoint types.
+ */
+declare class PathBuilderService {
+  private readonly schemaConverter;
+  /**
+   * Generates an OpenAPI path item for a discovered endpoint.
+   *
+   * @param endpoint - Discovered endpoint with metadata
+   * @returns Path string and path item object
+   */
+  build(endpoint: DiscoveredEndpoint): PathItemResult;
+  /**
+   * Converts Navios URL param format ($param) to OpenAPI format ({param})
+   */
+  convertUrlParams(url: string): string;
+  /**
+   * Extracts URL parameter names from a URL pattern
+   */
+  extractUrlParamNames(url: string): string[];
+  /**
+   * Gets the endpoint type based on the adapter token
+   */
+  getEndpointType(handler: HandlerMetadata<any>): 'endpoint' | 'multipart' | 'stream';
+  /**
+   * Builds OpenAPI parameters from endpoint config
+   */
+  private buildParameters;
+  /**
+   * Builds request body based on endpoint type
+   */
+  private buildRequestBody;
+  /**
+   * Builds request body for JSON endpoints
+   */
+  private buildJsonRequestBody;
+  /**
+   * Builds request body for multipart endpoints
+   */
+  private buildMultipartRequestBody;
+  /**
+   * Builds responses based on endpoint type
+   */
+  private buildResponses;
+  /**
+   * Builds responses for JSON endpoints
+   */
+  private buildJsonResponses;
+  /**
+   * Builds responses for stream endpoints
+   */
+  private buildStreamResponses;
+  /**
+   * Gets content object for different stream types
+   */
+  private getStreamContent;
+}
+//#endregion
+//#region src/services/openapi-generator.service.d.mts
+type OpenAPIObject = oas31.OpenAPIObject;
+type SecuritySchemeObject = oas31.SecuritySchemeObject;
+type TagObject = oas31.TagObject;
+/**
+ * Options for generating the OpenAPI document
+ */
+interface OpenApiGeneratorOptions {
+  /**
+   * OpenAPI document info
+   */
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: {
+      name?: string;
+      url?: string;
+      email?: string;
+    };
+    license?: {
+      name: string;
+      url?: string;
+    };
+  };
+  /**
+   * External documentation
+   */
+  externalDocs?: {
+    url: string;
+    description?: string;
+  };
+  /**
+   * Server definitions
+   */
+  servers?: Array<{
+    url: string;
+    description?: string;
+    variables?: Record<string, {
+      default: string;
+      enum?: string[];
+      description?: string;
+    }>;
+  }>;
+  /**
+   * Security scheme definitions
+   */
+  securitySchemes?: Record<string, SecuritySchemeObject>;
+  /**
+   * Global security requirements
+   */
+  security?: Array<Record<string, string[]>>;
+  /**
+   * Tag definitions with descriptions
+   */
+  tags?: TagObject[];
+}
+/**
+ * Service responsible for generating the complete OpenAPI document.
+ *
+ * Orchestrates endpoint discovery, path generation, and document assembly.
+ */
+declare class OpenApiGeneratorService {
+  private readonly logger;
+  private readonly scanner;
+  private readonly pathBuilder;
+  /**
+   * Generates an OpenAPI document from loaded modules.
+   *
+   * @param modules - Map of loaded modules
+   * @param options - OpenAPI generation options
+   * @returns Complete OpenAPI document
+   */
+  generate(modules: Map<string, ModuleMetadata>, options: OpenApiGeneratorOptions): OpenAPIObject;
+  /**
+   * Builds paths object from discovered endpoints
+   */
+  private buildPaths;
+  /**
+   * Collects unique tags from endpoints
+   */
+  private collectTags;
+  /**
+   * Merges discovered tags with configured tags
+   */
+  private mergeTags;
+}
+//#endregion
+//#region src/tokens/index.d.mts
+/**
+ * Tokens for OpenAPI metadata attributes
+ */
+/** Token for @ApiTag decorator */
+declare const ApiTagToken: unique symbol;
+/** Token for @ApiOperation decorator */
+declare const ApiOperationToken: unique symbol;
+/** Token for @ApiSummary decorator */
+declare const ApiSummaryToken: unique symbol;
+/** Token for @ApiDeprecated decorator */
+declare const ApiDeprecatedToken: unique symbol;
+/** Token for @ApiSecurity decorator */
+declare const ApiSecurityToken: unique symbol;
+/** Token for @ApiExclude decorator */
+declare const ApiExcludeToken: unique symbol;
+/** Token for @ApiStream decorator */
+declare const ApiStreamToken: unique symbol;
+//#endregion
+export { ApiDeprecated, type ApiDeprecatedOptions, ApiDeprecatedToken, ApiExclude, ApiExcludeToken, ApiOperation, type ApiOperationOptions, ApiOperationToken, ApiSecurity, type ApiSecurityRequirement, ApiSecurityToken, ApiStream, type ApiStreamOptions, ApiStreamToken, ApiSummary, ApiSummaryToken, ApiTag, type ApiTagOptions, ApiTagToken, type DiscoveredEndpoint, EndpointScannerService, MetadataExtractorService, type OpenApiEndpointMetadata, type OpenApiGeneratorOptions, OpenApiGeneratorService, PathBuilderService, type PathItemResult, type SchemaConversionResult, SchemaConverterService };
+//# sourceMappingURL=index.d.mts.map

package/lib/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/decorators/api-tag.decorator.mts","../src/decorators/api-operation.decorator.mts","../src/decorators/api-summary.decorator.mts","../src/decorators/api-deprecated.decorator.mts","../src/decorators/api-security.decorator.mts","../src/decorators/api-exclude.decorator.mts","../src/decorators/api-stream.decorator.mts","../src/metadata/openapi.metadata.mts","../src/services/endpoint-scanner.service.mts","../src/services/metadata-extractor.service.mts","../src/services/schema-converter.service.mts","../src/services/path-builder.service.mts","../src/services/openapi-generator.service.mts","../src/tokens/index.mts"],"sourcesContent":[],"mappings":"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"}