feat: added includeTags

README.md

@@ -76,6 +76,7 @@ yarn openapi-codegen generate --config my-config.ts
   --splitByTags                       Organize output into separate folders based on OpenAPI operation tags (default: true)
   --defaultTag                        (Requires `--splitByTags`) Default tag for shared code across multiple tags (default: 'Common')
 
+  --includeTags                       Comma-separated list of tags to include in generation
   --excludeTags                       Comma-separated list of tags to exclude from generation
   --excludePathRegex                  Exclude operations whose paths match the given regular expression
   --excludeRedundantZodSchemas        Exclude any redundant Zod schemas (default: true)
@@ -115,6 +116,7 @@ yarn openapi-codegen generate --config my-config.ts
   --splitByTags                       Organize output into separate folders based on OpenAPI operation tags (default: true)
   --defaultTag                        (Requires `--splitByTags`) Default tag for shared code across multiple tags (default: 'Common')
 
+  --includeTags                       Comma-separated list of tags to include in generation
   --excludeTags                       Comma-separated list of tags to exclude from generation
   --excludePathRegex                  Exclude operations whose paths match the given regular expression
   --excludeRedundantZodSchemas        Exclude any redundant Zod schemas (default: true)

openapi-codegen.config.mjs

@@ -2,7 +2,7 @@
 const config = {
   input: "http://127.0.0.1:4000/docs-json",
   output: "./test/generated/next",
-  excludeTags: ["auth"],
+  includeTags: ["auth"],
   replaceOptionalWithNullish: true,
   builderConfigs: true,
   infiniteQueries: true,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "2.0.8-rc.26",
+  "version": "2.0.8-rc.33",
   "keywords": [
     "codegen",
     "openapi",
@@ -107,7 +107,7 @@
     "@tanstack/react-query": "^5.90.21",
     "axios": "^1.13.1",
     "react": "^19.1.0",
-    "vite": "^6.0.0 || ^7.0.0",
+    "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
     "zod": "^4.1.12"
   },
   "peerDependenciesMeta": {

src/commands/check.command.ts

@@ -19,6 +19,9 @@ class CheckOptions implements CheckParams {
   @YargOption({ envAlias: "defaultTag" })
   defaultTag?: string;
 
+  @YargOption({ envAlias: "includeTags" })
+  includeTags?: string;
+
   @YargOption({ envAlias: "excludeTags" })
   excludeTags?: string;
 

src/commands/check.ts

@@ -9,11 +9,18 @@ import SwaggerParser from "@apidevtools/swagger-parser";
 
 export type CheckParams = {
   config?: string;
+  includeTags?: string;
   excludeTags?: string;
   verbose?: boolean;
 } & Partial<Pick<GenerateOptions, "input" | "splitByTags" | "defaultTag">>;
 
-export async function check({ verbose, config: configParam, excludeTags: _excludeTagsParam, ...params }: CheckParams) {
+export async function check({
+  verbose,
+  config: configParam,
+  includeTags: _includeTagsParam,
+  excludeTags: _excludeTagsParam,
+  ...params
+}: CheckParams) {
   const start = Date.now();
 
   if (verbose) {

src/commands/generate.command.ts

@@ -16,6 +16,9 @@ class GenerateOptions implements GenerateParams {
   @YargOption({ envAlias: "output" })
   output?: string;
 
+  @YargOption({ envAlias: "clearOutput", type: "boolean" })
+  clearOutput?: boolean;
+
   @YargOption({ envAlias: "incremental", type: "boolean" })
   incremental?: boolean;
 
@@ -31,6 +34,9 @@ class GenerateOptions implements GenerateParams {
   @YargOption({ envAlias: "defaultTag" })
   defaultTag?: string;
 
+  @YargOption({ envAlias: "includeTags" })
+  includeTags?: string;
+
   @YargOption({ envAlias: "excludeTags" })
   excludeTags?: string;
 

src/commands/generate.ts

@@ -7,6 +7,7 @@ import { Profiler } from "@/helpers/profile.helper";
 
 export type GenerateParams = {
   config?: string;
+  includeTags?: string;
   excludeTags?: string;
   inlineEndpointsExcludeModules?: string;
   prettier?: boolean;
@@ -16,6 +17,7 @@ export type GenerateParams = {
     GenerateOptions,
     | "input"
     | "output"
+    | "clearOutput"
     | "incremental"
     | "tsNamespaces"
     | "tsPath"

src/generators/const/options.const.ts

@@ -8,9 +8,11 @@ export const DEFAULT_GENERATE_OPTIONS: GenerateOptions = {
   // Base options
   input: "http://localhost:4000/docs-json/",
   output: "output",
+  clearOutput: false,
   incremental: true,
   splitByTags: true,
   defaultTag: "Common",
+  includeTags: [],
   excludeTags: [],
   excludePathRegex: "",
   excludeRedundantZodSchemas: true,

src/generators/core/SchemaResolver.class.ts

@@ -179,6 +179,10 @@ export class SchemaResolver {
       return this.options.defaultTag;
     }
 
+    if (this.options.modelsInCommon) {
+      return formatTag(this.options.defaultTag);
+    }
+
     const extractedEnumZodSchema = this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === zodSchemaName);
     if (extractedEnumZodSchema) {
       return formatTag(extractedEnumZodSchema.tag ?? this.options.defaultTag);

src/generators/core/getMetadataFromOpenAPIDoc.test.ts

@@ -428,4 +428,23 @@ describe("getMetadataFromOpenAPIDoc", () => {
     expect(metadata.models).toEqual(models(extractEnums));
     expect(metadata.queries).toEqual(queries);
   });
+
+  test("uses common model namespace and import path when modelsInCommon is enabled with includeTags", async () => {
+    const openApiDoc = (await SwaggerParser.bundle("./test/petstore.yaml")) as OpenAPIV3.Document;
+
+    const metadata = await getMetadataFromOpenAPIDoc(openApiDoc, {
+      ...DEFAULT_GENERATE_OPTIONS,
+      includeTags: ["pet"],
+      modelsInCommon: true,
+      excludeRedundantZodSchemas: false,
+    });
+
+    expect(metadata.models.length).toBeGreaterThan(0);
+    expect(metadata.models.every((model) => model.namespace === "CommonModels")).toBe(true);
+    expect(metadata.models.every((model) => model.importPath === "common/common.models")).toBe(true);
+
+    const petQuery = metadata.queries.find((query) => query.name === "useGetById");
+    expect(petQuery?.response.namespace).toBe("CommonModels");
+    expect(petQuery?.response.importPath).toBe("common/common.models");
+  });
 });

src/generators/core/resolveConfig.ts

@@ -4,18 +4,20 @@ import { deepMerge } from "@/generators/utils/object.utils";
 
 export function resolveConfig({
   fileConfig = {},
-  params: { excludeTags, inlineEndpointsExcludeModules, ...options },
+  params: { includeTags, excludeTags, inlineEndpointsExcludeModules, ...options },
 }: {
   fileConfig?: Partial<GenerateOptions> | null;
   params: Partial<
-    Omit<GenerateOptions, "excludeTags" | "inlineEndpointsExcludeModules"> & {
+    Omit<GenerateOptions, "includeTags" | "excludeTags" | "inlineEndpointsExcludeModules"> & {
+      includeTags: string;
       excludeTags: string;
       inlineEndpointsExcludeModules: string;
     }
   >;
 }) {
   const resolvedConfig = deepMerge(DEFAULT_GENERATE_OPTIONS, fileConfig ?? {}, {
     ...options,
+    includeTags: includeTags?.split(","),
     excludeTags: excludeTags?.split(","),
     inlineEndpointsExcludeModules: inlineEndpointsExcludeModules?.split(","),
   });

src/generators/run/generate.runner.ts

@@ -1,23 +1,14 @@
-import fs from "fs";
 import path from "path";
-
 import SwaggerParser from "@apidevtools/swagger-parser";
 import { OpenAPIV3 } from "openapi-types";
 
 import { resolveConfig } from "@/generators/core/resolveConfig";
 import { generateCodeFromOpenAPIDoc } from "@/generators/generateCodeFromOpenAPIDoc";
 import { GenerateFileFormatter } from "@/generators/types/generate";
 import { GenerateOptions } from "@/generators/types/options";
-import { writeGenerateFileData } from "@/generators/utils/file.utils";
+import { removeStaleGeneratedFiles, writeGenerateFileData } from "@/generators/utils/file.utils";
 import { Profiler } from "@/helpers/profile.helper";
 
-const CACHE_FILE_NAME = ".openapi-codegen-cache.json";
-
-type CacheData = {
-  openApiHash: string;
-  optionsHash: string;
-};
-
 type GenerateStats = {
   generatedFilesCount: number;
   generatedModulesCount: number;
@@ -31,7 +22,8 @@ export async function runGenerate({
 }: {
   fileConfig?: Partial<GenerateOptions> | null;
   params?: Partial<
-    Omit<GenerateOptions, "excludeTags" | "inlineEndpointsExcludeModules"> & {
+    Omit<GenerateOptions, "includeTags" | "excludeTags" | "inlineEndpointsExcludeModules"> & {
+      includeTags: string;
       excludeTags: string;
       inlineEndpointsExcludeModules: string;
     }
@@ -42,27 +34,17 @@ export async function runGenerate({
   const config = profiler.runSync("config.resolve", () => resolveConfig({ fileConfig, params: params ?? {} }));
   const openApiDoc = await getOpenApiDoc(config.input, profiler);
 
-  const openApiHash = hashString(stableStringify(openApiDoc));
-  const optionsHash = hashString(stableStringify(getCacheableConfig(config)));
-  const cacheFilePath = path.resolve(config.output, CACHE_FILE_NAME);
-
-  if (config.incremental) {
-    const cached = readCache(cacheFilePath);
-    if (cached && cached.openApiHash === openApiHash && cached.optionsHash === optionsHash) {
-      return { skipped: true, config, stats: { generatedFilesCount: 0, generatedModulesCount: 0 } };
-    }
-  }
-
   const filesData = profiler.runSync("generate.total", () => generateCodeFromOpenAPIDoc(openApiDoc, config, profiler));
+  if (config.clearOutput) {
+    profiler.runSync("files.removeStaleGenerated", () => {
+      removeStaleGeneratedFiles({ output: config.output, filesData, options: config });
+    });
+  }
   await profiler.runAsync("files.write", async () => {
     await writeGenerateFileData(filesData, { formatGeneratedFile });
   });
   const stats = getGenerateStats(filesData, config);
 
-  if (config.incremental) {
-    await writeCache(cacheFilePath, { openApiHash, optionsHash }, formatGeneratedFile);
-  }
-
   return { skipped: false, config, stats };
 }
 
@@ -115,53 +97,6 @@ function hasExternalRef(value: unknown): boolean {
   return false;
 }
 
-function getCacheableConfig(config: GenerateOptions) {
-  const { output, incremental, ...cacheableConfig } = config;
-  void output;
-  void incremental;
-  return cacheableConfig;
-}
-
-function readCache(filePath: string): CacheData | null {
-  if (!fs.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8")) as CacheData;
-  } catch {
-    return null;
-  }
-}
-
-async function writeCache(filePath: string, data: CacheData, formatGeneratedFile?: GenerateFileFormatter) {
-  await writeGenerateFileData([{ fileName: filePath, content: JSON.stringify(data) }], {
-    formatGeneratedFile,
-  });
-}
-
-function hashString(input: string) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i += 1) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16);
-}
-
-function stableStringify(input: unknown): string {
-  if (input === null || typeof input !== "object") {
-    return JSON.stringify(input);
-  }
-
-  if (Array.isArray(input)) {
-    return `[${input.map((item) => stableStringify(item)).join(",")}]`;
-  }
-
-  const obj = input as Record<string, unknown>;
-  const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
-}
-
 function getGenerateStats(filesData: { fileName: string }[], config: GenerateOptions): GenerateStats {
   const generatedFilesCount = filesData.length;
   if (generatedFilesCount === 0) {

src/generators/types/options.ts

@@ -65,9 +65,11 @@ interface GenerateConfig {
 interface BaseGenerateOptions {
   input: string;
   output: string;
+  clearOutput?: boolean;
   incremental?: boolean;
   splitByTags: boolean;
   defaultTag: string;
+  includeTags: string[];
   excludeTags: string[];
   excludePathRegex: string;
   excludeRedundantZodSchemas: boolean;