fix(parser): prevent broken output by tracking dependencies when using filters

Author: mrlubos

packages/openapi-ts-tests/test/openapi-ts.config.ts

@@ -25,8 +25,8 @@ export default defineConfig(() => {
       //     'x-foo': 'bar',
       //   },
       // },
-      // include:
-      //   '^(#/components/schemas/import|#/paths/api/v{api-version}/simple/options)$',
+      include: '^(#/components/schemas/Foo)$',
+      // '^(#/components/schemas/Foo|#/paths/api/v{api-version}/simple/options)$',
       // organization: 'hey-api',
       // path: {
       //   components: {},
@@ -36,7 +36,12 @@ export default defineConfig(() => {
       //   openapi: '3.1.0',
       //   paths: {},
       // },
-      path: path.resolve(__dirname, 'spec', '3.1.x', 'full.json'),
+      path: path.resolve(
+        __dirname,
+        'spec',
+        '3.1.x',
+        'validators-circular-ref-2.yaml',
+      ),
       // path: 'http://localhost:4000/',
       // path: 'https://get.heyapi.dev/',
       // path: 'https://get.heyapi.dev/hey-api/backend?branch=main&version=1.0.0',
@@ -115,7 +120,7 @@ export default defineConfig(() => {
       },
       {
         exportFromIndex: true,
-        name: '@tanstack/react-query',
+        // name: '@tanstack/react-query',
       },
       {
         // exportFromIndex: true,

packages/openapi-ts/src/openApi/3.1.x/parser/dependencyGraph.ts

@@ -0,0 +1,110 @@
+import type { OpenApiV3_1_X, SchemaObject } from '../types/spec';
+
+const collectSchemaDependencies = (
+  schema: SchemaObject,
+  dependencies: Set<string>,
+) => {
+  // TODO: add more keywords, e.g. prefixItems
+
+  if (schema.$ref) {
+    const refName = schema.$ref.split('/').pop();
+    if (refName) {
+      dependencies.add(refName);
+    }
+  }
+
+  if (schema.items) {
+    collectSchemaDependencies(schema.items, dependencies);
+  }
+
+  if (schema.properties) {
+    for (const property of Object.values(schema.properties)) {
+      if (typeof property !== 'boolean') {
+        collectSchemaDependencies(property, dependencies);
+      }
+    }
+  }
+
+  if (schema.allOf) {
+    for (const item of schema.allOf) {
+      collectSchemaDependencies(item, dependencies);
+    }
+  }
+
+  if (schema.anyOf) {
+    for (const item of schema.anyOf) {
+      collectSchemaDependencies(item, dependencies);
+    }
+  }
+
+  if (schema.oneOf) {
+    for (const item of schema.oneOf) {
+      collectSchemaDependencies(item, dependencies);
+    }
+  }
+};
+
+// TODO: make generic to work with other categories
+type DependencyGraph = Map<string, Set<string>>;
+
+export const createDependencyGraph = (spec: OpenApiV3_1_X): DependencyGraph => {
+  // TODO: add paths, other components
+  const dependencyGraph: DependencyGraph = new Map();
+
+  if (spec.components) {
+    if (spec.components.schemas) {
+      for (const [schemaName, schema] of Object.entries(
+        spec.components.schemas,
+      )) {
+        const dependencies = new Set<string>();
+        collectSchemaDependencies(schema, dependencies);
+        dependencyGraph.set(schemaName, dependencies);
+      }
+    }
+  }
+
+  return dependencyGraph;
+};
+
+// TODO: make generic to work with any spec version
+// TODO: support exclude
+export const filterSpec = ({
+  dependencyGraph,
+  includedSchemas,
+  spec,
+}: {
+  dependencyGraph: DependencyGraph;
+  includedSchemas: Set<string>;
+  spec: OpenApiV3_1_X;
+}): OpenApiV3_1_X => {
+  const allIncludedSchemas = new Set<string>(includedSchemas);
+
+  const stack = [...includedSchemas];
+  while (stack.length) {
+    const schemaName = stack.pop()!;
+    const dependencies = dependencyGraph.get(schemaName);
+    if (dependencies) {
+      for (const dependency of dependencies) {
+        if (!allIncludedSchemas.has(dependency)) {
+          allIncludedSchemas.add(dependency);
+          stack.push(dependency);
+        }
+      }
+    }
+  }
+
+  if (spec.components) {
+    if (spec.components.schemas) {
+      const schemasFiltered: typeof spec.components.schemas = {};
+      for (const schemaName of allIncludedSchemas) {
+        const schemaSource = spec.components.schemas[schemaName];
+        if (schemaSource) {
+          schemasFiltered[schemaName] = schemaSource;
+        }
+      }
+      spec.components.schemas = schemasFiltered;
+    }
+  }
+
+  return spec;
+};

packages/openapi-ts/src/openApi/3.1.x/parser/index.ts

@@ -10,12 +10,25 @@ import type {
   RequestBodyObject,
   SecuritySchemeObject,
 } from '../types/spec';
+import { createDependencyGraph, filterSpec } from './dependencyGraph';
 import { parseOperation } from './operation';
 import { parametersArrayToObject, parseParameter } from './parameter';
 import { parseRequestBody } from './requestBody';
 import { parseSchema } from './schema';
 import { parseServers } from './server';
+
 export const parseV3_1_X = (context: IR.Context<OpenApiV3_1_X>) => {
+  // TODO: construct includedSchemas from config
+  const includedSchemas = new Set<string>();
+  includedSchemas.add('Bar');
+
+  // TODO: skip filtering if no filters are defined
+  const dependencyGraph = createDependencyGraph(context.spec);
+  context.spec = filterSpec({
+    dependencyGraph,
+    includedSchemas,
+    spec: context.spec,
+  });
   const state: State = {
     ids: new Map(),
     operationIds: new Map(),
@@ -25,13 +38,14 @@ export const parseV3_1_X = (context: IR.Context<OpenApiV3_1_X>) => {
   const excludeFilters = createFilters(context.config.input.exclude);
   const includeFilters = createFilters(context.config.input.include);
 
+  // TODO: remove shouldProcessRef
   const shouldProcessRef = ($ref: string, schema: Record<string, any>) =>
     canProcessRef({
       $ref,
       excludeFilters,
       includeFilters,
       schema,
-    });
+    }) || true;
 
   // TODO: parser - handle more component types, old parser handles only parameters and schemas
   if (context.spec.components) {