Revert "feat: implement --include-tag"

Author: vladkens

src/config.ts

@@ -1,7 +1,7 @@
-import { Oas3Operation, Oas3Schema, Referenced } from "@redocly/openapi-core/lib/typings/openapi"
+import { Oas3Definition } from "@redocly/openapi-core"
+import { Oas3Operation } from "@redocly/openapi-core/lib/typings/openapi"
 import { cli } from "cleye"
 import { name, version } from "../package.json"
-import { PathItem } from "./schema"
 
 export type OpConfig = Oas3Operation & { method: string; path: string }
 export type OpName = [string, string]
@@ -10,28 +10,20 @@ export type Config = {
   source: string
   output: string | null
   name: string
-  includeTags: string[] | null
   parseDates: boolean
   inlineEnums: boolean
   resolveName?: (ctx: Context, op: OpConfig, proposal: OpName) => OpName | undefined
   headers: Record<string, string>
 }
 
-export type Context = Config & {
-  paths: Record<string, PathItem>
-  schemas: Record<string, Referenced<Oas3Schema>>
-  logTag: string
-  usedNames: Set<string>
-}
+export type Context = Config & { doc: Oas3Definition; logTag: string; usedNames: Set<string> }
 
 export const initCtx = (config?: Partial<Context>): Context => {
   return {
     source: "",
     output: "",
     name: "ApiClient",
-    paths: {},
-    schemas: {},
-    includeTags: null,
+    doc: { openapi: "3.1.0" },
     parseDates: false,
     inlineEnums: false,
     headers: {},
@@ -62,11 +54,6 @@ export const getCliConfig = () => {
         description: "API class name to export",
         default: "ApiClient",
       },
-      includeTag: {
-        type: [String],
-        description: "Only include operations with the given tags.",
-        default: null,
-      },
       parseDates: {
         type: Boolean,
         description: "Parse dates as Date objects",
@@ -91,7 +78,6 @@ export const getCliConfig = () => {
     source: argv._.source,
     output: argv._.output ?? null,
     name: argv.flags.name,
-    includeTags: argv.flags.includeTag,
     parseDates: argv.flags.parseDates,
     inlineEnums: argv.flags.inlineEnums,
     headers: parseHeaders(argv.flags.header),

src/generator.ts

@@ -1,13 +1,14 @@
 import redocly, { BaseResolver, Oas3Definition } from "@redocly/openapi-core"
 import { filterEmpty, filterNullable } from "array-utils-ts"
-import { lowerFirst, sortBy, uniqBy, upperFirst } from "lodash-es"
+import { isObject, lowerFirst, sortBy, uniqBy, upperFirst } from "lodash-es"
 import { convertObj } from "swagger2openapi"
 import ts from "typescript"
 import { Context, OpConfig, OpName } from "./config"
 import { getRepSchema, getReqSchema, unref } from "./schema"
 import { makeType, makeTypeAlias, normalizeIdentifier } from "./type-gen"
 
 const f = ts.factory
+const HttpMethods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"] as const
 
 const normalizeOpName = (val: string) => {
   const articles = new Set(["a", "an", "the"])
@@ -163,10 +164,21 @@ const prepareNs = (ctx: Context, name: string, handlers: ts.PropertyAssignment[]
 const prepareRoutes = async (ctx: Context) => {
   const routes: Record<string, ts.PropertyAssignment[]> = {}
 
-  for (const [path, pathConfig] of Object.entries(ctx.paths)) {
-    for (const [method, config] of Object.entries(pathConfig.ops)) {
+  for (const [path, pathConfig] of Object.entries(ctx.doc.paths ?? {})) {
+    ctx.logTag = `${"[ALL]".toUpperCase().padEnd(6, " ")} ${path}`
+    if (!isObject(pathConfig)) continue
+
+    if ("$ref" in pathConfig) {
+      console.warn(`${ctx.logTag} $ref should be resolved before (skipping)`)
+      continue
+    }
+
+    for (const method of HttpMethods) {
       ctx.logTag = `${method.toUpperCase().padEnd(6, " ")} ${path}`
 
+      const config = pathConfig[method]
+      if (!config) continue
+
       if (pathConfig.parameters) {
         config.parameters = [...(config.parameters ?? []), ...pathConfig.parameters]
       }
@@ -196,7 +208,7 @@ const prepareRoutes = async (ctx: Context) => {
 
 const prepareTypes = async (ctx: Context) => {
   const types: ts.DeclarationStatement[] = []
-  const typesConfig = sortBy(Object.entries(ctx.schemas), ([k]) => k)
+  const typesConfig = sortBy(Object.entries(ctx.doc.components?.schemas ?? {}), ([k]) => k)
   for (const [name, config] of typesConfig) {
     try {
       types.push(makeTypeAlias(ctx, name, config))

src/main.ts

@@ -5,12 +5,10 @@ import { fileURLToPath } from "url"
 import { Config, initCtx } from "./config"
 import { generateAst, loadSchema } from "./generator"
 import { formatCode, printCode } from "./printer"
-import { filterSchema } from "./schema"
 
 export const apigen = async (config: Partial<Config> & Pick<Config, "source" | "output">) => {
   const doc = await loadSchema({ url: config.source, headers: config.headers })
-  const { paths, schemas } = filterSchema(doc, config)
-  const ctx = initCtx({ ...config, paths, schemas })
+  const ctx = initCtx({ ...config, doc })
   const { modules, types } = await generateAst(ctx)
 
   const filepath = join(dirname(fileURLToPath(import.meta.url)), "_template.ts")

src/schema.ts

@@ -1,77 +1,16 @@
 import {
   Oas3_1Schema,
-  Oas3Definition,
   Oas3Operation,
   Oas3Parameter,
   Oas3RequestBody,
   Oas3Schema,
   Referenced,
 } from "@redocly/openapi-core/lib/typings/openapi"
-import { get, isObject } from "lodash-es"
-import { Config, Context } from "./config"
+import { get } from "lodash-es"
+import { Context } from "./config"
 
 export type OAS3 = Oas3Schema | Oas3_1Schema
 
-const HttpMethods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"] as const
-
-// Oas3PathItem defines each method operation as a property.
-// We want to be able to iterate over methods so we introduce this type.
-export interface PathItem {
-  ops: Record<string, Oas3Operation>
-  summary?: string
-  description?: string
-  parameters?: Array<Referenced<Oas3Parameter>>
-}
-
-export function filterSchema(doc: Oas3Definition, config: Partial<Config>) {
-  const paths: Record<string, PathItem> = {}
-  let usedSchemaRefs = new Set<string>()
-  for (const [path, pathConfig] of Object.entries(doc.paths ?? {})) {
-    const logTag = `${"[ALL]".toUpperCase().padEnd(6, " ")} ${path}`
-    if (!isObject(pathConfig)) continue
-
-    if ("$ref" in pathConfig) {
-      console.warn(`${logTag} $ref should be resolved before (skipping)`)
-      continue
-    }
-
-    paths[path] = {
-      ops: {},
-      summary: pathConfig.summary,
-      description: pathConfig.description,
-      parameters: pathConfig.parameters,
-    }
-
-    for (const method of HttpMethods) {
-      const op = pathConfig[method]
-      if (!op) continue
-
-      if (config.includeTags && !op.tags?.some((tag) => config.includeTags!.includes(tag))) {
-        continue
-      }
-
-      paths[path].ops[method] = op
-      extractSchemaReferences(op, usedSchemaRefs)
-    }
-  }
-  const schemas = doc.components?.schemas ?? {}
-
-  // When we filter out operations we also want to filter out schemas that are no longer used.
-  let schemaRefsToCheck = usedSchemaRefs
-  while (schemaRefsToCheck.size > 0) {
-    const newSchemaRefs = new Set<string>()
-    for (const ref of schemaRefsToCheck) {
-      extractSchemaReferences(schemas[ref], newSchemaRefs)
-    }
-    schemaRefsToCheck = newSchemaRefs.difference(usedSchemaRefs)
-    usedSchemaRefs = usedSchemaRefs.union(newSchemaRefs)
-  }
-  for (const unusedSchema of new Set(Object.keys(schemas)).difference(usedSchemaRefs)) {
-    delete schemas[unusedSchema]
-  }
-  return { paths, schemas }
-}
-
 // todo: wrong <T> typing
 export const unref = <T extends Oas3RequestBody | Oas3Parameter | OAS3>(
   ctx: Context,
@@ -84,7 +23,7 @@ export const unref = <T extends Oas3RequestBody | Oas3Parameter | OAS3>(
     const obj = parts.reduce(
       // openapi encodes "/" in key as "~1"
       (acc, x) => get(acc, x, get(acc, decodeURIComponent(x).replaceAll("~1", "/"))),
-      { components: { schemas: ctx.schemas } },
+      ctx.doc,
     )
 
     if (obj) return obj as unknown as T
@@ -147,23 +86,3 @@ export const getRepSchema = (ctx: Context, config: Oas3Operation): OAS3 | undefi
 
   return undefined
 }
-
-function extractSchemaReferences(obj: any, schemaRefs: Set<string>): void {
-  if (obj === null || obj === undefined) {
-    return
-  }
-
-  if (typeof obj === "object" && !Array.isArray(obj) && obj.$ref) {
-    const ref = obj.$ref
-    if (typeof ref === "string" && ref.startsWith("#/components/schemas/")) {
-      const schemaName = ref.replace("#/components/schemas/", "")
-      schemaRefs.add(schemaName)
-    }
-  }
-
-  if (Array.isArray(obj)) {
-    obj.forEach((item) => extractSchemaReferences(item, schemaRefs))
-  } else if (typeof obj === "object") {
-    Object.values(obj).forEach((prop) => extractSchemaReferences(prop, schemaRefs))
-  }
-}