feat: add cli option, thread through to import-builder

Author: mnahkies

packages/documentation/src/lib/playground.tsx

@@ -57,6 +57,7 @@ const defaultConfig = {
   tsCompilerOptions: {exactOptionalPropertyTypes: false},
   enableTypedBasePaths: true,
   filenameConvention: "kebab-case",
+  tsIsEsmProject: false,
   tsServerImplementationMethod: "type",
   enumExtensibility: "",
 } satisfies Config

packages/documentation/src/lib/playground/config-form.tsx

@@ -17,6 +17,7 @@ const schema = configSchema.pick({
   groupingStrategy: true,
   tsAllowAny: true,
   tsServerImplementationMethod: true,
+  tsIsEsmProject: true,
   enumExtensibility: true,
 })
 
@@ -37,6 +38,7 @@ export const ConfigForm: React.FC<{
       groupingStrategy: config.groupingStrategy,
       tsAllowAny: config.tsAllowAny,
       tsServerImplementationMethod: config.tsServerImplementationMethod,
+      tsIsEsmProject: config.tsIsEsmProject,
       enumExtensibility: config.enumExtensibility,
     } as const,
   })
@@ -83,6 +85,11 @@ export const ConfigForm: React.FC<{
         name={"tsAllowAny"}
         control={control}
       />
+      <ControlledCheckbox
+        label={"--ts-is-esm-project"}
+        name={"tsIsEsmProject"}
+        control={control}
+      />
       <ControlledSelect
         name={"tsServerImplementationMethod"}
         control={control}

packages/openapi-code-generator/src/cli.ts

@@ -17,6 +17,7 @@ import {z} from "zod/v4"
 import {promptContinue} from "./core/cli-utils"
 import {NodeFsAdaptor} from "./core/file-system/node-fs-adaptor"
 import type {OperationGroupStrategy} from "./core/input"
+import {loadPackageJson} from "./core/loaders/package.json.loader"
 import {loadTsConfigCompilerOptions} from "./core/loaders/tsconfig.loader"
 import {
   loadTypescriptFormatterConfig,
@@ -30,7 +31,7 @@ import {configSchema, generate} from "./index"
 import {templateNames} from "./templates"
 import type {ServerImplementationMethod} from "./templates.types"
 
-export const boolParser = (arg: string): boolean => {
+const optionalBoolParser = (arg: string): boolean | undefined => {
   const TRUTHY_VALUES = ["true", "1", "on"]
   const FALSY_VALUES = ["false", "0", "off", ""]
 
@@ -41,6 +42,10 @@ export const boolParser = (arg: string): boolean => {
     return false
   }
 
+  if (!arg) {
+    return undefined
+  }
+
   throw new InvalidArgumentError(
     `'${arg}' is not a valid boolean parameter. Valid truthy values are: ${TRUTHY_VALUES.map(
       (it) => JSON.stringify(it),
@@ -50,6 +55,16 @@ export const boolParser = (arg: string): boolean => {
   )
 }
 
+export const boolParser = (arg: string): boolean => {
+  const result = optionalBoolParser(arg)
+
+  if (result === undefined) {
+    throw new InvalidArgumentError(`'${arg}' is not a valid boolean parameter.`)
+  }
+
+  return result
+}
+
 export const remoteSpecRequestHeadersParser = (arg: string) => {
   return z
     .preprocess(
@@ -123,6 +138,14 @@ const program = new Command()
       .argParser(boolParser)
       .default(false),
   )
+  .addOption(
+    new Option(
+      "--ts-is-esm-project [bool]",
+      `(typescript) whether the target project uss esm or commonjs. auto-detected from package.json when omitted.`,
+    )
+      .env("OPENAPI_TS_IS_ESM_PROJECT")
+      .argParser(optionalBoolParser),
+  )
   .addOption(
     new Option(
       "--ts-server-implementation-method <value>",
@@ -285,19 +308,25 @@ async function main() {
   )
 
   const outputPath = path.join(process.cwd(), config.output)
+
   const formatterOptions = await loadTypescriptFormatterConfig(
     outputPath,
     fsAdaptor,
   )
+
   const formatter = await formatterFactory(formatterOptions)
 
+  const projectPackageJson = await loadPackageJson(outputPath, fsAdaptor)
+
   const compilerOptions = await loadTsConfigCompilerOptions(
     outputPath,
     fsAdaptor,
   )
 
   await generate(
     configSchema.parse({
+      // can be overridden by config spread
+      tsIsEsmProject: projectPackageJson.type === "module",
       ...config,
       tsCompilerOptions: compilerOptions,
     }),

packages/openapi-code-generator/src/config.ts

@@ -27,6 +27,7 @@ export type Config = {
   enumExtensibility: "" | "open" | "closed"
   tsAllowAny: boolean
   tsServerImplementationMethod: ServerImplementationMethod
+  tsIsEsmProject: boolean
   tsCompilerOptions: CompilerOptions
   remoteSpecRequestHeaders?: GenericLoaderRequestHeaders | undefined
 }
@@ -64,6 +65,7 @@ export const configSchema = z.object({
   enumExtensibility: z.enum(["", "open", "closed"]),
   tsAllowAny: z.boolean(),
   tsServerImplementationMethod: tsServerImplementationSchema,
+  tsIsEsmProject: z.boolean(),
   tsCompilerOptions: tsconfigSchema.shape.compilerOptions,
   remoteSpecRequestHeaders: z
     .record(

packages/openapi-code-generator/src/core/file-system/node-fs-adaptor.ts

@@ -13,8 +13,15 @@ export class NodeFsAdaptor implements IFsAdaptor {
   }
 
   async exists(path: string) {
-    const stat = await fs.stat(path)
-    return stat.isFile()
+    try {
+      const stat = await fs.stat(path)
+      return stat.isFile()
+    } catch (err) {
+      if (err instanceof Error && Reflect.get(err, "code") === "ENOENT") {
+        return false
+      }
+      throw err
+    }
   }
 
   existsSync(path: string) {

packages/openapi-code-generator/src/core/loaders/package.json.loader.ts

@@ -0,0 +1,19 @@
+import json5 from "json5"
+import {z} from "zod/v4"
+import type {IFsAdaptor} from "../file-system/fs-adaptor"
+import {loadFileUp} from "./utils"
+
+const schema = z.object({
+  type: z.enum(["module", "commonjs"]).optional().default("commonjs"),
+})
+
+export async function loadPackageJson(
+  outputPath: string,
+  fsAdaptor: IFsAdaptor,
+) {
+  const packageJson = json5.parse(
+    (await loadFileUp("package.json", outputPath, fsAdaptor)) ?? "{}",
+  )
+
+  return schema.parse(packageJson)
+}

packages/openapi-code-generator/src/core/loaders/utils.ts

@@ -1,3 +1,25 @@
+import path from "node:path"
+import type {IFsAdaptor} from "../file-system/fs-adaptor"
+
 export function isRemote(location: string): boolean {
   return location.startsWith("http://") || location.startsWith("https://")
 }
+
+export async function loadFileUp(
+  filename: string,
+  directory: string,
+  fsAdaptor: IFsAdaptor,
+): Promise<string | undefined> {
+  while (directory !== "/") {
+    const filePath = path.join(directory, filename)
+
+    if (await fsAdaptor.exists(filePath)) {
+      return fsAdaptor.readFile(filePath)
+    }
+
+    // biome-ignore lint/style/noParameterAssign: walk
+    directory = path.dirname(directory)
+  }
+
+  return undefined
+}

packages/openapi-code-generator/src/index.ts

@@ -85,6 +85,7 @@ export async function generate(
     compilerOptions: config.tsCompilerOptions,
     groupingStrategy: config.groupingStrategy,
     filenameConvention: config.filenameConvention,
+    isEsmProject: config.tsIsEsmProject,
     allowAny: config.tsAllowAny,
     serverImplementationMethod: config.tsServerImplementationMethod,
   })

packages/openapi-code-generator/src/templates.types.ts

@@ -27,6 +27,10 @@ export interface OpenapiTypescriptGeneratorConfig
    * Which runtime schema parsing library to use
    */
   schemaBuilder: SchemaBuilderType
+  /**
+   * Whether the project is using ESM, or CommonJS
+   */
+  isEsmProject: boolean
   /**
    * Sub-set of typescript compiler options relevant to codegen
    */

packages/openapi-code-generator/src/typescript/client/client-servers-builder.spec.ts

@@ -19,7 +19,7 @@ async function runTest(
     "unit-test.ts",
     "UnitTest",
     servers,
-    new ImportBuilder(),
+    new ImportBuilder({includeFileExtensions: false}),
   )
 
   for (const it of operations) {