@goast/core 0.5.2 → 0.6.0-beta.1

package/src/src/codegen/generator.ts

@@ -1,192 +0,0 @@
-import { resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import { OpenApiParser } from '../parse/parser.js';
-import type { ApiData } from '../transform/api-types.js';
-import { ActionProvider } from '../utils/action-provider.js';
-import { type DirectoryScanOptions, getFiles } from '../utils/file-system.utils.js';
-import type { EmptyConstructor, Merge } from '../utils/type.utils.js';
-import { defaultOpenApiGeneratorConfig, type OpenApiGeneratorConfig } from './config.js';
-import type {
-  AnyConfig,
-  OpenApiGenerationProvider,
-  OpenApiGenerationProviderContext,
-  OpenApiGenerationProviderFn,
-  OpenApiGeneratorContext,
-  OpenApiGeneratorInput,
-  OpenApiGeneratorOutput,
-} from './types.js';
-
-type OpenApiGenerationProviders = {
-  provider: ActionProvider<OpenApiGenerationProviderFn>;
-  config: AnyConfig | undefined;
-}[];
-
-type VInput<TActual, TExpected> = TExpected extends TActual ? TActual
-  : { __error: 'The current output of the generator does not satisfy the input of this generator.' };
-
-class _OpenApiGenerator<TOutput extends OpenApiGeneratorInput> {
-  private readonly _providers: OpenApiGenerationProviders;
-  private readonly _config: OpenApiGeneratorConfig;
-  private readonly _parser: OpenApiParser;
-
-  constructor(config: OpenApiGeneratorConfig, providers: OpenApiGenerationProviders, parser: OpenApiParser) {
-    this._providers = providers;
-    this._config = config;
-    this._parser = parser;
-  }
-
-  public use<PInput extends OpenApiGeneratorInput, POutput extends OpenApiGeneratorOutput, PConfig extends AnyConfig>(
-    provider: ActionProvider<OpenApiGenerationProviderFn<VInput<PInput, TOutput>, POutput, PConfig>>,
-    config?: Partial<PConfig>,
-  ): _OpenApiGenerator<Merge<[TOutput, POutput]>> {
-    // deno-lint-ignore no-explicit-any
-    this._providers.push({ provider: provider as any, config });
-    return new _OpenApiGenerator<Merge<[TOutput, POutput]>>(this._config, [...this._providers], this._parser);
-  }
-
-  public useType<
-    PInput extends OpenApiGeneratorInput,
-    POutput extends OpenApiGeneratorOutput,
-    PConfig extends AnyConfig,
-  >(
-    type: EmptyConstructor<OpenApiGenerationProvider<VInput<PInput, TOutput>, POutput, PConfig>>,
-    config?: Partial<PConfig>,
-  ): _OpenApiGenerator<Merge<[TOutput, POutput]>> {
-    return this.use(ActionProvider.fromType(type, 'generate'), config);
-  }
-
-  public useFn<PInput extends TOutput, POutput extends OpenApiGeneratorOutput, PConfig extends AnyConfig>(
-    fn: OpenApiGenerationProviderFn<VInput<PInput, TOutput>, POutput, PConfig>,
-    config?: Partial<PConfig>,
-  ): _OpenApiGenerator<Merge<[TOutput, POutput]>> {
-    return this.use(ActionProvider.fromFn(fn), config);
-  }
-
-  public useValue<PInput extends TOutput, POutput extends OpenApiGeneratorOutput, PConfig extends AnyConfig>(
-    value: OpenApiGenerationProvider<VInput<PInput, TOutput>, POutput, PConfig>,
-    config?: Partial<PConfig>,
-  ): _OpenApiGenerator<Merge<[TOutput, POutput]>> {
-    return this.use(ActionProvider.fromValue(value, 'generate'), config);
-  }
-
-  public async generate<T extends ApiData>(data: T): Promise<TOutput> {
-    const absOutputPath = resolve(this._config.outputDir);
-    if (this._config.clearOutputDir) {
-      await fs.emptyDir(absOutputPath);
-    } else {
-      await fs.ensureDir(absOutputPath);
-    }
-
-    this._providers.forEach(({ config }) => {
-      if (config && 'outputDir' in config && config.outputDir && typeof config.outputDir === 'string') {
-        const providerOutputDir = resolve(config.outputDir);
-        if (this._config.clearOutputDir) {
-          fs.emptyDirSync(providerOutputDir);
-        } else {
-          fs.ensureDirSync(providerOutputDir);
-        }
-      }
-    });
-
-    let input = {} as TOutput;
-    for (const generator of this._providers) {
-      const context = {
-        data,
-        input,
-        config: this._config,
-      };
-
-      const result = await generator.provider.run(context, generator.config);
-      if (result) {
-        input = mergeDeep(input, result);
-      }
-    }
-
-    return input;
-  }
-
-  public async parseAndGenerate(...fileNames: (string | string[])[]): Promise<TOutput> {
-    const data = await this._parser.parseApisAndTransform(...fileNames);
-    return await this.generate(data);
-  }
-
-  public async parseAndGenerateFromDir(dir: string, options?: Partial<DirectoryScanOptions>): Promise<TOutput> {
-    const filter = (file: string) =>
-      (file.endsWith('.yml') || file.endsWith('.yaml') || file.endsWith('.json')) && (options?.filter?.(file) ?? true);
-    return this.parseAndGenerate(...(await getFiles(dir, { ...options, filter })));
-  }
-}
-
-// deno-lint-ignore ban-types
-export class OpenApiGenerator extends _OpenApiGenerator<{}> {
-  constructor(config?: Partial<OpenApiGeneratorConfig>) {
-    super(
-      { ...defaultOpenApiGeneratorConfig, ...config },
-      [],
-      new OpenApiParser({ ...defaultOpenApiGeneratorConfig, ...config }),
-    );
-  }
-}
-
-function mergeDeep<T extends Record<string, unknown>, U extends Record<string, unknown>[]>(
-  target: T,
-  ...sources: U
-): T & U[number] {
-  if (!sources.length) return target;
-  const source = sources.shift();
-
-  for (const key in source) {
-    const value = source[key];
-    if (value && typeof value === 'object') {
-      if (!target[key]) Object.assign(target, { [key]: value });
-      else mergeDeep(target[key] as Record<string, unknown>, value as Record<string, unknown>);
-    } else if (Array.isArray(value)) {
-      if (!target[key]) Object.assign(target, { [key]: value });
-      else Object.assign(target, { [key]: [...(target[key] as Iterable<unknown>), ...value] });
-    } else {
-      Object.assign(target, { [key]: value });
-    }
-  }
-
-  return mergeDeep(target, ...sources);
-}
-
-export type DefaultGenerationProviderConfig<T extends AnyConfig> =
-  & Omit<T, keyof OpenApiGeneratorConfig>
-  & Partial<Pick<T, keyof OpenApiGeneratorConfig>>;
-
-export abstract class OpenApiGenerationProviderBase<
-  TInput extends OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput,
-  TConfig extends AnyConfig,
-  TContext extends OpenApiGenerationProviderContext<TInput, TConfig>,
-> implements OpenApiGenerationProvider<TInput, TOutput, TConfig> {
-  public async generate(
-    context: OpenApiGeneratorContext<TInput>,
-    config?: Partial<TConfig> | undefined,
-  ): Promise<TOutput> {
-    const ctx = await this.buildContext(context, config);
-    return await this.onGenerate(ctx);
-  }
-
-  protected getProviderContext(
-    context: OpenApiGeneratorContext<TInput>,
-    config: Partial<TConfig> | undefined,
-    defaultConfig: DefaultGenerationProviderConfig<TConfig>,
-  ): OpenApiGenerationProviderContext<TInput, TConfig> {
-    const c = { ...context.config, ...defaultConfig, ...config } as unknown as OpenApiGeneratorConfig & TConfig;
-    return Object.assign(context, {
-      config: c,
-    });
-  }
-
-  protected abstract buildContext(
-    context: OpenApiGeneratorContext<TInput>,
-    config?: Partial<TConfig> | undefined,
-  ): TContext | Promise<TContext>;
-
-  protected abstract onGenerate(ctx: TContext): TOutput | Promise<TOutput>;
-}

package/src/src/codegen/internal-utils.ts

@@ -1,6 +0,0 @@
-// deno-lint-ignore no-explicit-any
-export function addSourceIfTest(config: any, result: any, sourceFn: () => any) {
-  if (config.__test__ && !result.__source__) {
-    result.__source__ = sourceFn();
-  }
-}

package/src/src/codegen/schemas-generator.ts

@@ -1,87 +0,0 @@
-import type { ApiSchema } from '../transform/api-types.js';
-import { getSchemaReference } from '../utils/schema.utils.js';
-import type { MaybePromise } from '../utils/type.utils.js';
-import { type DefaultGenerationProviderConfig, OpenApiGenerationProviderBase } from './generator.js';
-import { addSourceIfTest } from './internal-utils.js';
-import type {
-  AnyConfig,
-  OpenApiGenerationProviderContext,
-  OpenApiGeneratorContext,
-  OpenApiGeneratorInput,
-  OpenApiGeneratorOutput,
-} from './types.js';
-
-export type OpenApiSchemasGenerationProviderContext<
-  TInput extends OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput,
-  TConfig extends AnyConfig,
-  TSchemaOutput extends OpenApiGeneratorOutput,
-> = OpenApiGenerationProviderContext<TInput, TConfig> & {
-  existingSchemaResults: Map<string, TSchemaOutput>;
-  output: TOutput;
-};
-
-export abstract class OpenApiSchemasGenerationProviderBase<
-  TInput extends OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput,
-  TConfig extends AnyConfig,
-  TSchemaOutput extends OpenApiGeneratorOutput,
-  TContext extends OpenApiSchemasGenerationProviderContext<TInput, TOutput, TConfig, TSchemaOutput>,
-> extends OpenApiGenerationProviderBase<TInput, TOutput, TConfig, TContext> {
-  protected override getProviderContext(
-    context: OpenApiGeneratorContext<TInput>,
-    config: Partial<TConfig> | undefined,
-    defaultConfig: DefaultGenerationProviderConfig<TConfig>,
-  ): OpenApiSchemasGenerationProviderContext<TInput, TOutput, TConfig, TSchemaOutput> {
-    const ctx = super.getProviderContext(context, config, defaultConfig);
-    return Object.assign(ctx, {
-      existingSchemaResults: new Map<string, TSchemaOutput>(),
-      output: this.initResult(ctx),
-    });
-  }
-
-  protected override async onGenerate(ctx: TContext): Promise<TOutput> {
-    for (const schema of ctx.data.schemas) {
-      await this.getSchemaResult(ctx, schema);
-    }
-
-    await this.generateAdditionalFiles(ctx);
-
-    return ctx.output;
-  }
-
-  public async getSchemaResult(ctx: TContext, schema: ApiSchema): Promise<TSchemaOutput> {
-    const existingResult = ctx.existingSchemaResults.get(schema.id);
-    if (existingResult) return existingResult;
-
-    let result: TSchemaOutput;
-    const reference = this.getSchemaReference(ctx, schema);
-    if (reference) {
-      result = await this.getSchemaResult(ctx, reference);
-    } else {
-      result = await this.generateSchema(ctx, schema);
-    }
-
-    addSourceIfTest(ctx.config, result, () => `${schema.$src.file}#${schema.$src.path}`);
-    ctx.existingSchemaResults.set(schema.id, result);
-    this.addSchemaResult(ctx, schema, result);
-    return result;
-  }
-
-  // deno-lint-ignore no-unused-vars
-  protected getSchemaReference(ctx: TContext, schema: ApiSchema): ApiSchema | undefined {
-    const ref = getSchemaReference(schema, ['description']);
-    return ref.id !== schema.id ? ref : undefined;
-  }
-
-  protected abstract initResult(ctx: OpenApiGenerationProviderContext<TInput, TConfig>): TOutput;
-
-  protected abstract generateSchema(ctx: TContext, schema: ApiSchema): MaybePromise<TSchemaOutput>;
-
-  protected abstract addSchemaResult(ctx: TContext, schema: ApiSchema, result: TSchemaOutput): void;
-
-  // deno-lint-ignore no-unused-vars
-  protected generateAdditionalFiles(ctx: TContext): MaybePromise<void> {
-    // Override if needed
-  }
-}

package/src/src/codegen/services-generator.ts

@@ -1,77 +0,0 @@
-import type { ApiService } from '../transform/api-types.js';
-import type { MaybePromise } from '../utils/type.utils.js';
-import { type DefaultGenerationProviderConfig, OpenApiGenerationProviderBase } from './generator.js';
-import { addSourceIfTest } from './internal-utils.js';
-import type {
-  AnyConfig,
-  OpenApiGenerationProviderContext,
-  OpenApiGeneratorContext,
-  OpenApiGeneratorInput,
-  OpenApiGeneratorOutput,
-} from './types.js';
-
-export type OpenApiServicesGenerationProviderContext<
-  TInput extends OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput,
-  TConfig extends AnyConfig,
-  TServiceOutput extends OpenApiGeneratorOutput,
-> = OpenApiGenerationProviderContext<TInput, TConfig> & {
-  existingServiceResults: Map<string, TServiceOutput>;
-  output: TOutput;
-};
-
-export abstract class OpenApiServicesGenerationProviderBase<
-  TInput extends OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput,
-  TConfig extends AnyConfig,
-  TServiceOutput extends OpenApiGeneratorOutput,
-  TContext extends OpenApiServicesGenerationProviderContext<TInput, TOutput, TConfig, TServiceOutput>,
-> extends OpenApiGenerationProviderBase<TInput, TOutput, TConfig, TContext> {
-  protected override getProviderContext(
-    context: OpenApiGeneratorContext<TInput>,
-    config: Partial<TConfig> | undefined,
-    defaultConfig: DefaultGenerationProviderConfig<TConfig>,
-  ): OpenApiServicesGenerationProviderContext<TInput, TOutput, TConfig, TServiceOutput> {
-    const ctx = super.getProviderContext(context, config, defaultConfig);
-    return Object.assign(ctx, {
-      existingServiceResults: new Map<string, TServiceOutput>(),
-      output: this.initResult(ctx),
-    });
-  }
-
-  protected override async onGenerate(ctx: TContext): Promise<TOutput> {
-    for (const service of ctx.data.services) {
-      await this.getServiceResult(ctx, service);
-    }
-
-    await this.generateAdditionalFiles(ctx);
-
-    return ctx.output;
-  }
-
-  protected async getServiceResult(ctx: TContext, service: ApiService): Promise<TServiceOutput> {
-    const existingResult = ctx.existingServiceResults.get(service.id);
-    if (existingResult) return existingResult;
-
-    const result = await this.generateService(ctx, service);
-
-    addSourceIfTest(
-      ctx.config,
-      result,
-      () => service.$src ? `${service.$src.file}#${service.$src.path}` : `tag:${service.name}`,
-    );
-    this.addServiceResult(ctx, service, result);
-    return result;
-  }
-
-  protected abstract initResult(ctx: OpenApiGenerationProviderContext<TInput, TConfig>): TOutput;
-
-  protected abstract generateService(ctx: TContext, service: ApiService): MaybePromise<TServiceOutput>;
-
-  protected abstract addServiceResult(ctx: TContext, service: ApiService, result: TServiceOutput): void;
-
-  // deno-lint-ignore no-unused-vars
-  protected generateAdditionalFiles(ctx: TContext): MaybePromise<void> {
-    // Override if needed
-  }
-}

package/src/src/codegen/types.ts

@@ -1,37 +0,0 @@
-import type { ApiData } from '../transform/api-types.js';
-import type { MaybePromise } from '../utils/type.utils.js';
-import type { OpenApiGeneratorConfig } from './config.js';
-
-export type AnyConfig = Readonly<Record<string, unknown>>;
-export type OpenApiGeneratorInput = Record<string, unknown>;
-export type OpenApiGeneratorOutput = Record<string, unknown> | undefined;
-export type OpenApiGeneratorContext<TInput extends OpenApiGeneratorInput = OpenApiGeneratorInput> = {
-  data: ApiData;
-  input: TInput;
-  config: OpenApiGeneratorConfig;
-};
-
-export type OpenApiGenerationProviderContext<TInput extends OpenApiGeneratorInput, TConfig extends AnyConfig> =
-  & Omit<
-    OpenApiGeneratorContext<TInput>,
-    'config'
-  >
-  & {
-    config: OpenApiGeneratorConfig & TConfig;
-  };
-
-export interface OpenApiGenerationProvider<
-  TInput extends OpenApiGeneratorInput = OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput = OpenApiGeneratorOutput,
-  TConfig extends AnyConfig = AnyConfig,
-> {
-  generate(
-    ...args: Parameters<OpenApiGenerationProviderFn<TInput, TOutput, TConfig>>
-  ): ReturnType<OpenApiGenerationProviderFn<TInput, TOutput, TConfig>>;
-}
-
-export type OpenApiGenerationProviderFn<
-  TInput extends OpenApiGeneratorInput = OpenApiGeneratorInput,
-  TOutput extends OpenApiGeneratorOutput = OpenApiGeneratorOutput,
-  TConfig extends AnyConfig = AnyConfig,
-> = (context: OpenApiGeneratorContext<TInput>, config?: Partial<TConfig>) => MaybePromise<TOutput>;

package/src/src/collect/collector.ts

@@ -1,142 +0,0 @@
-import type {
-  OpenApiDocument,
-  OpenApiHeader,
-  OpenApiMediaType,
-  OpenApiParameter,
-  OpenApiPathItem,
-  OpenApiRequestBody,
-  OpenApiResponse,
-  OpenApiSchema,
-} from '../parse/openapi-types.js';
-import type { Deref } from '../parse/types.js';
-import { collect, collectRecord } from './helpers.js';
-import type { OpenApiCollectorData } from './types.js';
-
-type Collect<T> = Deref<T> | Deref<T>[] | undefined;
-
-export function collectOpenApi(apis: Deref<OpenApiDocument>[]): OpenApiCollectorData {
-  const data: OpenApiCollectorData = {
-    documents: [],
-    schemas: new Map(),
-    endpoints: new Map(),
-  };
-
-  collectDocument(data, apis);
-
-  return data;
-}
-
-const jsonSchemaProperties = ['$id', 'allOf', 'anyOf', 'oneOf', 'enum', 'not', 'properties', 'title', 'type'];
-
-function collectDocument(data: OpenApiCollectorData, documents: Collect<OpenApiDocument>) {
-  collect(data, documents, (data, document) => {
-    data.documents.push(document);
-    collectPaths(data, document.paths);
-    collectRecord<Deref<OpenApiSchema>>(data, document.components?.schemas, collectSchema);
-    collectRecord<Deref<OpenApiSchema>>(data, document.definitions, collectSchema);
-    collectRecord<Deref<OpenApiParameter>>(data, document.components?.parameters, collectParameter);
-    collectRecord<Deref<OpenApiParameter>>(data, document.parameters, collectParameter);
-    collectRecord<Deref<OpenApiRequestBody>>(data, document.components?.requestBodies, collectRequestBody);
-    collectRecord<Deref<OpenApiResponse>>(data, document.components?.responses, collectResponse);
-    collectRecord<Deref<OpenApiResponse>>(data, document.responses, collectResponse);
-    collectRecord<Deref<OpenApiHeader>>(data, document.components?.headers, collectHeader);
-
-    if (Object.keys(document).some((key) => jsonSchemaProperties.includes(key))) {
-      collectSchema(data, document as Deref<OpenApiSchema>);
-    }
-  });
-}
-
-function collectPaths(data: OpenApiCollectorData, paths: Collect<Record<string, OpenApiPathItem>>) {
-  collect(data, paths, (data, path) => {
-    collectRecord<Deref<OpenApiPathItem>>(data, path, collectPathItem);
-  });
-}
-
-function collectPathItem(data: OpenApiCollectorData, pathItems: Collect<OpenApiPathItem>, path: string) {
-  collect(data, pathItems, (data, pathItem) => {
-    collectParameter(data, pathItem.parameters);
-    for (const m of ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'] as const) {
-      const operation = pathItem[m];
-      if (!operation) continue;
-      const key = `${operation.$src.file}#${operation.$src.path}`;
-      if (data.endpoints.has(key)) continue;
-      data.endpoints.set(key, {
-        path,
-        method: m,
-        pathItem,
-        operation,
-      });
-      collectParameter(data, operation.parameters);
-      collectRequestBody(data, operation.requestBody);
-      collectRecord<Deref<OpenApiResponse>>(data, operation.responses, collectResponse);
-    }
-  });
-}
-
-function collectSchema(data: OpenApiCollectorData, schemas: Collect<OpenApiSchema>) {
-  collect(data, schemas, (data, schema) => {
-    const key = `${schema.$src.file}#${schema.$src.path}`;
-    if (data.schemas.has(key)) return;
-    data.schemas.set(key, schema);
-    collectSchema(data, schema.allOf);
-    collectSchema(data, schema.anyOf);
-    collectSchema(data, schema.oneOf);
-    collectSchema(data, schema.items);
-    collectSchema(data, schema.not);
-    collectRecord<Deref<OpenApiSchema>>(data, schema.properties, collectSchema);
-    collectRecord<Deref<OpenApiSchema>>(data, schema.patternProperties, collectSchema);
-    collectRecord<Deref<OpenApiSchema>>(data, schema.dependencies, collectSchema);
-    collectRecord<Deref<OpenApiSchema>>(data, schema.definitions, collectSchema);
-    if (typeof schema.additionalProperties === 'object') {
-      collectSchema(data, schema.additionalProperties);
-    }
-    if (typeof schema.additionalItems === 'object') {
-      collectSchema(data, schema.additionalItems);
-    }
-    if (typeof schema.discriminator === 'object') {
-      collectRecord<Deref<OpenApiSchema>>(data, schema.discriminator?.mapping, collectSchema);
-    }
-  });
-}
-
-function collectParameter(data: OpenApiCollectorData, parameters: Collect<OpenApiParameter>) {
-  collect(data, parameters, (data, parameter) => {
-    collectSchema(data, parameter.schema);
-  });
-}
-
-function collectMediaType(data: OpenApiCollectorData, mediaTypes: Collect<OpenApiMediaType>) {
-  collect(data, mediaTypes, (data, mediaType) => {
-    collectSchema(data, mediaType.schema);
-  });
-}
-
-function collectRequestBody(data: OpenApiCollectorData, requestBody: Collect<OpenApiRequestBody>) {
-  collect(data, requestBody, (data, requestBody) => {
-    collectRecord<Deref<OpenApiMediaType>>(data, requestBody.content, collectMediaType);
-  });
-}
-
-function isSchema(obj: Record<string, unknown>): obj is Deref<OpenApiSchema> {
-  return obj && typeof obj === 'object' && obj['type'] !== undefined;
-}
-
-function collectResponse(data: OpenApiCollectorData, responses: Collect<OpenApiResponse>) {
-  collect(data, responses, (data, responses) => {
-    collectRecord<Deref<OpenApiMediaType>>(data, responses.content, collectMediaType);
-    collect(data, responses.headers, (data, header) => {
-      if (isSchema(header)) {
-        collectSchema(data, header);
-      } else {
-        collectHeader(data, header);
-      }
-    });
-  });
-}
-
-function collectHeader(data: OpenApiCollectorData, headers: Collect<OpenApiHeader>) {
-  collect(data, headers, (data, headers) => {
-    collectSchema(data, headers.schema);
-  });
-}

package/src/src/collect/helpers.ts

@@ -1,36 +0,0 @@
-import { isOpenApiObjectProperty } from '../internal-utils.js';
-import type { Nullable } from '../utils/type.utils.js';
-import type { OpenApiCollectorData } from './types.js';
-
-export function collect<T extends Record<`x-${string}`, unknown>>(
-  data: OpenApiCollectorData,
-  obj: Nullable<T | Nullable<T>[]>,
-  func: (data: OpenApiCollectorData, obj: NonNullable<T>) => void,
-) {
-  if (!obj) return;
-  if (Array.isArray(obj)) {
-    for (const o of obj) {
-      if (!o) continue;
-      if (o['x-ignore']) continue;
-      func(data, o);
-    }
-  } else {
-    if (obj['x-ignore']) return;
-    func(data, obj);
-  }
-}
-
-export function collectRecord<T extends Record<`x-${string}`, unknown>>(
-  data: OpenApiCollectorData,
-  obj: Nullable<Record<string, Nullable<T>>>,
-  func: (data: OpenApiCollectorData, obj: NonNullable<T>, key: string) => void,
-) {
-  if (!obj) return;
-  for (const key in obj) {
-    if (!isOpenApiObjectProperty(key)) continue;
-    const value = obj[key];
-    if (!value) continue;
-    if (value['x-ignore']) continue;
-    func(data, value, key);
-  }
-}

package/src/src/collect/types.ts

@@ -1,21 +0,0 @@
-import type {
-  OpenApiDocument,
-  OpenApiHttpMethod,
-  OpenApiOperation,
-  OpenApiPathItem,
-  OpenApiSchema,
-} from '../parse/openapi-types.js';
-import type { Deref } from '../parse/types.js';
-
-export type OpenApiCollectorEndpointInfo = {
-  path: string;
-  method: OpenApiHttpMethod;
-  pathItem: Deref<OpenApiPathItem>;
-  operation: Deref<OpenApiOperation>;
-};
-
-export type OpenApiCollectorData = {
-  documents: Deref<OpenApiDocument>[];
-  schemas: Map<string, Deref<OpenApiSchema>>;
-  endpoints: Map<string, OpenApiCollectorEndpointInfo>;
-};

package/src/src/internal-utils.ts

@@ -1,5 +0,0 @@
-export function isOpenApiObjectProperty<T extends string>(
-  propertyName: T,
-): propertyName is Exclude<T, `$${string}` | `x-${string}`> {
-  return !propertyName.startsWith('$') && !propertyName.startsWith('x-');
-}

package/src/src/parse/deref-proxy.ts

@@ -1,70 +0,0 @@
-import { isNullish } from '../utils/common.utils.js';
-import type { OpenApiObject } from './openapi-types.js';
-import type { Deref, DerefSource } from './types.js';
-
-export function createDerefProxy<T extends OpenApiObject<string>>(
-  obj: T,
-  source: DerefSource<T>,
-  ref?: Deref<T>,
-): Deref<T> {
-  return new Proxy(obj, new DerefProxyHandler(source, ref)) as Deref<T>;
-}
-
-const propertiesNotDerivedFromRef: PropertyKey[] = ['title'];
-
-class DerefProxyHandler<T extends OpenApiObject<string>> implements ProxyHandler<T> {
-  private readonly _overwrittenValues: Record<PropertyKey, unknown> = {};
-
-  constructor(
-    private readonly _source: DerefSource<T>,
-    private _ref?: Deref<T>,
-  ) {}
-
-  public get(target: T, prop: PropertyKey): unknown {
-    if (prop === '$ref') {
-      return this._ref;
-    } else if (prop === '$src') {
-      return this._source;
-    }
-
-    if (this._overwrittenValues[prop] !== undefined) {
-      return this._overwrittenValues[prop];
-    }
-    if ((target as Record<PropertyKey, unknown>)[prop] !== undefined) {
-      return (target as Record<PropertyKey, unknown>)[prop];
-    }
-
-    return propertiesNotDerivedFromRef.includes(prop)
-      ? undefined
-      : (this._ref as Record<PropertyKey, unknown> | undefined)?.[prop];
-  }
-
-  public set(_target: T, prop: PropertyKey, value: unknown): boolean {
-    if (prop === '$ref' && (typeof value === 'object' || typeof value === 'undefined')) {
-      this._ref = !value ? undefined : (value as Deref<T>);
-      return true;
-    }
-    if (prop === '$src') {
-      return false;
-    }
-
-    this._overwrittenValues[prop] = value;
-    return true;
-  }
-
-  public has(target: T, prop: PropertyKey): boolean {
-    return prop in target || (!isNullish(this._ref) && prop in this._ref);
-  }
-
-  public ownKeys(target: T): ArrayLike<string | symbol> {
-    return Array.from(
-      new Set([
-        ...Object.getOwnPropertyNames(target),
-        ...Object.getOwnPropertySymbols(target),
-        ...(!isNullish(this._ref) ? Object.keys(this._ref) : []),
-        '$ref',
-        '$src',
-      ]),
-    );
-  }
-}