Class DefaultSpecProcessor

src/core/SpecProcessor.ts:20–214

type SchemaOrRef = SchemaObject | ReferenceObject;

export class DefaultSpecProcessor implements ISpecProcessor {
  async process(spec: OpenAPIV3.Document): Promise<OpenAPIV3.Document> {
    // First dereference all $refs
    const dereferencedSpec = (await $RefParser.dereference(spec, {
      continueOnError: true,
    })) as OpenAPIV3.Document;

    // Then merge all allOf schemas
    return this.mergeAllOfSchemas(dereferencedSpec);
  }

  /**
   * Recursively traverses the OpenAPI spec and merges any allOf schemas found
   * @param spec The OpenAPI specification to process
   * @returns The processed specification with merged allOf schemas
   */
  private mergeAllOfSchemas(spec: OpenAPIV3.Document): OpenAPIV3.Document {
    // Deep clone the spec to avoid modifying the input
    const processedSpec = structuredClone(spec);

    // Process components schemas if they exist
    if (processedSpec.components?.schemas) {
      for (const [key, schema] of Object.entries(
        processedSpec.components.schemas
      )) {
        processedSpec.components.schemas[key] = this.processSchema(
          schema as SchemaOrRef
        );
      }
    }

    // Process schemas in paths
    for (const path of Object.values(processedSpec.paths || {})) {
      this.processPathItem(path as OpenAPIV3.PathItemObject);
    }

    return processedSpec;
  }

  /**
   * Processes a path item object, handling all nested schemas
   * @param pathItem The path item to process
   */
  private processPathItem(pathItem: OpenAPIV3.PathItemObject): void {
    const operations = [
      "get",
      "put",
      "post",
      "delete",
      "options",
      "head",
      "patch",
      "trace",
    ];

    for (const op of operations) {
      const operation = pathItem[
        op as keyof OpenAPIV3.PathItemObject