massimo-cli 0.3.0 → 0.5.0

package/help/help.txt

@@ -55,7 +55,7 @@ You can generate only the types with the --types-only flag.
 $ massimo http://exmaple.com/to/schema/file --name myclient --types-only
 ```
 
-Will create the single myclient.d.ts file.
+Will create the single myclient.d.ts file (or .d.mts/.d.cts depending on module format and --type-extension option).
 
 Options:
 
@@ -77,3 +77,4 @@ Options:
 * `--props-optional` - If `true`, properties will be defined as optional unless they're part of the `required` array. By default this option is `true`.
 * `--skip-config-update` - If `true`, it will not update the `platformatic|watt` config found in your repo. By default this option is `true`.
 * `--retry-timeout-ms` - If passed, the HTTP request to get an Open API schema will be retried (reference: https://undici.nodejs.org/#/docs/api/RetryHandler.md)
+* `--type-extension` - Force the use of module-specific type extensions (.d.mts for ESM, .d.cts for CJS) instead of the default logic.

package/index.js

@@ -4,7 +4,7 @@ import { access, mkdir, readFile, rm, writeFile } from 'fs/promises'
 import graphql from 'graphql'
 import helpMe from 'help-me'
 import parseArgs from 'minimist'
-import { join } from 'path'
+import { join, dirname } from 'path'
 import pino from 'pino'
 import pinoPretty from 'pino-pretty'
 import { getGlobalDispatcher, interceptors, request } from 'undici'
@@ -43,6 +43,71 @@ export async function createDirectory (path, empty = false) {
   return mkdir(path, { recursive: true, maxRetries: 10, retryDelay: 1000 })
 }
 
+export async function detectModuleFormat (folder, explicitFormat) {
+  if (explicitFormat) {
+    if (explicitFormat === 'esm' || explicitFormat === 'cjs') {
+      return explicitFormat
+    }
+    throw new Error(
+      `Invalid module format: ${explicitFormat}. Valid values are 'esm' or 'cjs'`
+    )
+  }
+  let currentDir = folder
+  while (currentDir !== dirname(currentDir)) {
+    const packageJsonPath = join(currentDir, 'package.json')
+    if (await isFileAccessible(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'))
+        if (packageJson.type === 'module') return 'esm'
+        return 'cjs'
+      } catch (err) {
+      }
+    }
+    currentDir = dirname(currentDir)
+  }
+
+  return 'esm'
+}
+
+export async function determineTypeExtension (folder, moduleFormat, typeExtension, explicitModuleFormat, generateImplementation = true) {
+  if (typeExtension) {
+    return moduleFormat === 'esm' ? 'd.mts' : 'd.cts'
+  }
+
+  if (!explicitModuleFormat && !generateImplementation) {
+    return 'd.ts'
+  }
+
+  if (!explicitModuleFormat && generateImplementation) {
+    return 'd.ts'
+  }
+
+  let currentDir = folder
+  while (currentDir !== dirname(currentDir)) {
+    const packageJsonPath = join(currentDir, 'package.json')
+    if (await isFileAccessible(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'))
+        const parentType = packageJson.type === 'module' ? 'esm' : 'cjs'
+
+        if (moduleFormat === parentType) {
+          return 'd.ts'
+        }
+
+        return moduleFormat === 'esm' ? 'd.mts' : 'd.cts'
+      } catch (err) {
+      }
+    }
+    currentDir = dirname(currentDir)
+  }
+
+  if (explicitModuleFormat) {
+    return moduleFormat === 'esm' ? 'd.mts' : 'd.cts'
+  }
+
+  return 'd.ts'
+}
+
 async function writeOpenAPIClient (
   folder,
   name,
@@ -58,20 +123,29 @@ async function writeOpenAPIClient (
   typesComment,
   logger,
   withCredentials,
-  propsOptional
+  propsOptional,
+  moduleFormat,
+  typeExtension,
+  explicitModuleFormat
 ) {
   await createDirectory(folder)
 
   // TODO deal with yaml
   const schema = parseFile(text)
   if (!schema) {
-    throw new Error('Cannot parse OpenAPI file. Please make sure is a JSON or a YAML file.')
+    throw new Error(
+      'Cannot parse OpenAPI file. Please make sure is a JSON or a YAML file.'
+    )
   }
   if (!typesOnly) {
-    await writeFile(join(folder, `${name}.openapi.json`), JSON.stringify(schema, null, 2))
+    await writeFile(
+      join(folder, `${name}.openapi.json`),
+      JSON.stringify(schema, null, 2)
+    )
   }
 
   if (isFrontend) {
+    const typeExt = await determineTypeExtension(folder, moduleFormat, typeExtension, explicitModuleFormat, generateImplementation)
     const { types, implementation } = processFrontendOpenAPI({
       schema,
       name,
@@ -80,9 +154,10 @@ async function writeOpenAPIClient (
       language,
       logger,
       withCredentials,
-      propsOptional
+      propsOptional,
+      typeExt
     })
-    await writeFile(join(folder, `${name}-types.d.mts`), types)
+    await writeFile(join(folder, `${name}-types.${typeExt}`), types)
     if (generateImplementation) {
       const extension = language === 'js' ? 'mjs' : 'mts'
       await writeFile(join(folder, `${name}.${extension}`), implementation)
@@ -96,30 +171,56 @@ async function writeOpenAPIClient (
       optionalHeaders,
       validateResponse,
       typesComment,
-      propsOptional
+      propsOptional,
+      moduleFormat,
     })
-    await writeFile(join(folder, `${name}.d.mts`), types)
+    const typeExt = await determineTypeExtension(folder, moduleFormat, typeExtension, explicitModuleFormat, generateImplementation)
+    const implExt = moduleFormat === 'esm' ? 'mjs' : 'cjs'
+    await writeFile(join(folder, `${name}.${typeExt}`), types)
     if (generateImplementation) {
-      await writeFile(join(folder, `${name}.mjs`), implementation)
+      await writeFile(join(folder, `${name}.${implExt}`), implementation)
     }
 
     if (!typesOnly) {
-      await writeFile(join(folder, 'package.json'), getPackageJSON({ name, generateImplementation }))
+      await writeFile(
+        join(folder, 'package.json'),
+        await getPackageJSON({ name, generateImplementation, moduleFormat, folder, typeExtension, explicitModuleFormat })
+      )
     }
   }
 }
 
-async function writeGraphQLClient (folder, name, schema, url, generateImplementation) {
+async function writeGraphQLClient (
+  folder,
+  name,
+  schema,
+  url,
+  generateImplementation,
+  moduleFormat,
+  typeExtension,
+  explicitModuleFormat
+) {
   await createDirectory(folder, { recursive: true })
-  const { types, implementation } = processGraphQL({ schema, name, folder, url })
+  const { types, implementation } = processGraphQL({
+    schema,
+    name,
+    folder,
+    url,
+    moduleFormat,
+  })
   const clientSchema = graphql.buildClientSchema(schema)
   const sdl = graphql.printSchema(clientSchema)
+  const typeExt = await determineTypeExtension(folder, moduleFormat, typeExtension, explicitModuleFormat, generateImplementation)
+  const implExt = moduleFormat === 'esm' ? 'mjs' : 'cjs'
   await writeFile(join(folder, `${name}.schema.graphql`), sdl)
-  await writeFile(join(folder, `${name}.d.mts`), types)
+  await writeFile(join(folder, `${name}.${typeExt}`), types)
   if (generateImplementation) {
-    await writeFile(join(folder, `${name}.mjs`), implementation)
+    await writeFile(join(folder, `${name}.${implExt}`), implementation)
   }
-  await writeFile(join(folder, 'package.json'), getPackageJSON({ name, generateImplementation }))
+  await writeFile(
+    join(folder, 'package.json'),
+    await getPackageJSON({ name, generateImplementation, moduleFormat, folder, typeExtension, explicitModuleFormat })
+  )
 }
 
 async function downloadAndWriteOpenAPI (
@@ -139,7 +240,10 @@ async function downloadAndWriteOpenAPI (
   typesComment,
   withCredentials,
   propsOptional,
-  retryTimeoutMs
+  retryTimeoutMs,
+  moduleFormat,
+  typeExtension,
+  explicitModuleFormat
 ) {
   logger.debug(`Trying to download OpenAPI schema from ${url}`)
   let requestOptions
@@ -152,7 +256,9 @@ async function downloadAndWriteOpenAPI (
   }
 
   const dispatcher = retryTimeoutMs
-    ? getGlobalDispatcher().compose([interceptors.retry({ minTimeout: retryTimeoutMs })])
+    ? getGlobalDispatcher().compose([
+      interceptors.retry({ minTimeout: retryTimeoutMs })
+    ])
     : undefined
   const res = await request(url, { ...requestOptions, dispatcher })
   if (res.statusCode === 200) {
@@ -174,7 +280,10 @@ async function downloadAndWriteOpenAPI (
         typesComment,
         logger,
         withCredentials,
-        propsOptional
+        propsOptional,
+        moduleFormat,
+        typeExtension,
+        explicitModuleFormat
       )
       /* c8 ignore next 3 */
     } catch (err) {
@@ -188,7 +297,16 @@ async function downloadAndWriteOpenAPI (
   return false
 }
 
-async function downloadAndWriteGraphQL (logger, url, folder, name, generateImplementation) {
+async function downloadAndWriteGraphQL (
+  logger,
+  url,
+  folder,
+  name,
+  generateImplementation,
+  moduleFormat,
+  typeExtension,
+  explicitModuleFormat
+) {
   logger.debug(`Trying to download GraphQL schema from ${url}`)
   const query = graphql.getIntrospectionQuery()
   const res = await request(url, {
@@ -198,7 +316,7 @@ async function downloadAndWriteGraphQL (logger, url, folder, name, generateImple
     },
     body: JSON.stringify({
       query
-    })
+    }),
   })
 
   const text = await res.body.text()
@@ -208,7 +326,16 @@ async function downloadAndWriteGraphQL (logger, url, folder, name, generateImple
   }
 
   const { data: schema } = JSON.parse(text)
-  await writeGraphQLClient(folder, name, schema, url, generateImplementation)
+  await writeGraphQLClient(
+    folder,
+    name,
+    schema,
+    url,
+    generateImplementation,
+    moduleFormat,
+    typeExtension,
+    explicitModuleFormat
+  )
   return 'graphql'
 }
 
@@ -227,7 +354,10 @@ async function readFromFileAndWrite (
   language,
   typesComment,
   withCredentials,
-  propsOptional
+  propsOptional,
+  moduleFormat,
+  typeExtension,
+  explicitModuleFormat
 ) {
   logger.info(`Trying to read schema from file ${file}`)
   const text = await readFile(file, 'utf8')
@@ -248,17 +378,32 @@ async function readFromFileAndWrite (
       typesComment,
       logger,
       withCredentials,
-      propsOptional
+      propsOptional,
+      moduleFormat,
+      typeExtension,
+      explicitModuleFormat
     )
     return 'openapi'
   } catch (err) {
-    logger.error(err, `Error parsing OpenAPI definition: "${err.message}". Trying with GraphQL`)
+    logger.error(
+      err,
+      `Error parsing OpenAPI definition: "${err.message}". Trying with GraphQL`
+    )
     // try GraphQL
     const schema = graphql.buildSchema(text)
     const introspectionResult = graphql.introspectionFromSchema(schema)
 
     // dummy URL
-    await writeGraphQLClient(folder, name, introspectionResult, 'http://localhost:3042/graphql', generateImplementation)
+    await writeGraphQLClient(
+      folder,
+      name,
+      introspectionResult,
+      'http://localhost:3042/graphql',
+      generateImplementation,
+      moduleFormat,
+      typeExtension,
+      explicitModuleFormat
+    )
     return 'graphql'
   }
 }
@@ -280,7 +425,10 @@ async function downloadAndProcess (options) {
     typesComment,
     withCredentials,
     propsOptional,
-    retryTimeoutMs
+    retryTimeoutMs,
+    moduleFormat,
+    typeExtension,
+    explicitModuleFormat
   } = options
 
   const generateImplementation = options.generateImplementation
@@ -308,7 +456,10 @@ async function downloadAndProcess (options) {
           typesComment,
           withCredentials,
           propsOptional,
-          retryTimeoutMs
+          retryTimeoutMs,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
         )
       )
       toTry.push(
@@ -330,14 +481,39 @@ async function downloadAndProcess (options) {
           typesComment,
           withCredentials,
           propsOptional,
-          retryTimeoutMs
+          retryTimeoutMs,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
         )
       )
     } else if (options.type === 'graphql') {
       toTry.push(
-        downloadAndWriteGraphQL.bind(null, logger, url + '/graphql', folder, name, generateImplementation, typesOnly)
+        downloadAndWriteGraphQL.bind(
+          null,
+          logger,
+          url + '/graphql',
+          folder,
+          name,
+          generateImplementation,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
+        )
+      )
+      toTry.push(
+        downloadAndWriteGraphQL.bind(
+          null,
+          logger,
+          url,
+          folder,
+          name,
+          generateImplementation,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
+        )
       )
-      toTry.push(downloadAndWriteGraphQL.bind(null, logger, url, folder, name, generateImplementation, typesOnly))
     } else {
       // add download functions only if it's an URL
       toTry.push(
@@ -359,11 +535,24 @@ async function downloadAndProcess (options) {
           typesComment,
           withCredentials,
           propsOptional,
-          retryTimeoutMs
+          retryTimeoutMs,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
         )
       )
       toTry.push(
-        downloadAndWriteGraphQL.bind(null, logger, url + '/graphql', folder, name, generateImplementation, typesOnly)
+        downloadAndWriteGraphQL.bind(
+          null,
+          logger,
+          url + '/graphql',
+          folder,
+          name,
+          generateImplementation,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
+        )
       )
       toTry.push(
         downloadAndWriteOpenAPI.bind(
@@ -384,10 +573,25 @@ async function downloadAndProcess (options) {
           typesComment,
           withCredentials,
           propsOptional,
-          retryTimeoutMs
+          retryTimeoutMs,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
+        )
+      )
+      toTry.push(
+        downloadAndWriteGraphQL.bind(
+          null,
+          logger,
+          url,
+          folder,
+          name,
+          generateImplementation,
+          moduleFormat,
+          typeExtension,
+          explicitModuleFormat
         )
       )
-      toTry.push(downloadAndWriteGraphQL.bind(null, logger, url, folder, name, generateImplementation, typesOnly))
     }
   } else {
     // add readFromFileAndWrite to the functions only if it's not an URL
@@ -408,7 +612,10 @@ async function downloadAndProcess (options) {
         language,
         typesComment,
         withCredentials,
-        propsOptional
+        propsOptional,
+        moduleFormat,
+        typeExtension,
+        explicitModuleFormat
       )
     )
   }
@@ -420,18 +627,26 @@ async function downloadAndProcess (options) {
   }
   /* c8 ignore next 3 */
   if (!found) {
-    throw new Error(`Could not find a valid OpenAPI or GraphQL schema at ${url}`)
+    throw new Error(
+      `Could not find a valid OpenAPI or GraphQL schema at ${url}`
+    )
   }
 }
 
-function getPackageJSON ({ name, generateImplementation }) {
+async function getPackageJSON ({ name, generateImplementation, moduleFormat, folder, typeExtension, explicitModuleFormat }) {
+  const isESM = moduleFormat === 'esm'
+  const typeExt = await determineTypeExtension(folder, moduleFormat, typeExtension, explicitModuleFormat, generateImplementation)
   const obj = {
     name,
-    types: `./${name}.d.mts`
+    types: `./${name}.${typeExt}`
+  }
+
+  if (isESM) {
+    obj.type = 'module'
   }
 
   if (generateImplementation) {
-    obj.main = `./${name}.mjs`
+    obj.main = `./${name}.${isESM ? 'mjs' : 'cjs'}`
   }
 
   return JSON.stringify(obj, null, 2)
@@ -447,7 +662,16 @@ export async function command (argv) {
     _: [url],
     ...options
   } = parseArgs(argv, {
-    string: ['name', 'folder', 'optional-headers', 'language', 'type', 'url-auth-headers', 'types-comment'],
+    string: [
+      'name',
+      'folder',
+      'optional-headers',
+      'language',
+      'type',
+      'url-auth-headers',
+      'types-comment',
+      'module'
+    ],
     boolean: [
       'typescript',
       'full-response',
@@ -457,7 +681,8 @@ export async function command (argv) {
       'frontend',
       'validate-response',
       'props-optional',
-      'skip-config-update'
+      'skip-config-update',
+      'type-extension'
     ],
     default: {
       typescript: false,
@@ -507,7 +732,7 @@ export async function command (argv) {
     options.propsOptional = options['props-optional'] ?? true
 
     options.optionalHeaders = options['optional-headers']
-      ? options['optional-headers'].split(',').map(h => h.trim())
+      ? options['optional-headers'].split(',').map((h) => h.trim())
       : []
 
     options.validateResponse = options['validate-response']
@@ -516,11 +741,17 @@ export async function command (argv) {
       options.name = options.isFrontend ? 'api' : 'client'
     }
     options.folder = options.folder || join(process.cwd(), options.name)
+    options.moduleFormat = await detectModuleFormat(options.folder, options.module)
+    if (!options.module) {
+      logger.info(`Module format detected: ${options.moduleFormat}`)
+    }
     options.urlAuthHeaders = options['url-auth-headers']
     options.typesComment = options['types-comment']
     options.withCredentials = options['with-credentials']
     options.skipConfigUpdate = options['skip-config-update'] ?? true
     options.retryTimeoutMs = options['retry-timeout-ms']
+    options.typeExtension = options['type-extension']
+    options.explicitModuleFormat = !!options.module
     await downloadAndProcess({ url, ...options, logger })
     logger.info(`Client generated successfully into ${options.folder}`)
     logger.info('Check out the docs to know more: https://docs.platformatic.dev/docs/service/overview')

package/lib/frontend-openapi-generator.js

@@ -18,7 +18,8 @@ export function processFrontendOpenAPI ({
   fullRequest,
   logger,
   withCredentials,
-  propsOptional
+  propsOptional,
+  typeExt = 'd.mts'
 }) {
   return {
     types: generateTypesFromOpenAPI({ schema, name, fullResponse, fullRequest, propsOptional }),
@@ -29,7 +30,8 @@ export function processFrontendOpenAPI ({
       fullResponse,
       fullRequest,
       logger,
-      withCredentials
+      withCredentials,
+      typeExt
     })
   }
 }
@@ -41,7 +43,8 @@ function generateFrontendImplementationFromOpenAPI ({
   fullResponse,
   fullRequest,
   logger,
-  withCredentials
+  withCredentials,
+  typeExt = 'd.mts'
 }) {
   const camelCaseName = capitalize(camelcase(name))
   const { paths } = schema
@@ -111,13 +114,13 @@ function generateFrontendImplementationFromOpenAPI ({
     writer.write('function sanitizeUrl(url)').block(() => {
       writer.writeLine("if (url.endsWith('/')) { return url.slice(0, -1) } else { return url }")
     })
-    writer.writeLine(`/**  @type {import('./${name}-types.d.mts').${camelCaseName}['setBaseUrl']} */`)
+    writer.writeLine(`/**  @type {import('./${name}-types.${typeExt}').${camelCaseName}['setBaseUrl']} */`)
     writer.writeLine('export const setBaseUrl = (newUrl) => { baseUrl = sanitizeUrl(newUrl) }')
     writer.newLine()
-    writer.writeLine(`/**  @type {import('./${name}-types.d.mts').${camelCaseName}['setDefaultHeaders']} */`)
+    writer.writeLine(`/**  @type {import('./${name}-types.${typeExt}').${camelCaseName}['setDefaultHeaders']} */`)
     writer.writeLine('export const setDefaultHeaders = (headers) => { defaultHeaders = headers }')
     writer.newLine()
-    writer.writeLine(`/**  @type {import('./${name}-types.d.mts').${camelCaseName}['setDefaultFetchParams']} */`)
+    writer.writeLine(`/**  @type {import('./${name}-types.${typeExt}').${camelCaseName}['setDefaultFetchParams']} */`)
     writer.writeLine('export const setDefaultFetchParams = (fetchParams) => { defaultFetchParams = fetchParams }')
     writer.newLine()
     writer.write('function headersToJSON(headers) ').block(() => {
@@ -354,7 +357,7 @@ function generateFrontendImplementationFromOpenAPI ({
       // ```
       //
       writer
-        .writeLine(`/**  @type {import('./${name}-types.d.mts').${camelCaseName}['${operationId}']} */`)
+        .writeLine(`/**  @type {import('./${name}-types.${typeExt}').${camelCaseName}['${operationId}']} */`)
         .write(`export const ${operationId} = async (request) =>`)
         .block(() => {
           writer.write(`return await ${underscoredOperationId}(baseUrl, request)`)

package/lib/graphql-generator.js

@@ -2,11 +2,11 @@ import CodeBlockWriter from 'code-block-writer'
 import { UnknownTypeError } from './errors.js'
 import { capitalize, toJavaScriptName } from './utils.js'
 
-export function processGraphQL ({ schema, name, folder, url }) {
+export function processGraphQL ({ schema, name, folder, url, moduleFormat }) {
   schema = schema.__schema
   return {
     types: generateTypesFromGraphQL({ schema, name }),
-    implementation: generateImplementationFromGraqhQL({ schema, name, url })
+    implementation: generateImplementationFromGraqhQL({ schema, name, url, moduleFormat })
   }
 }
 
@@ -60,8 +60,9 @@ function generateTypesFromGraphQL ({ schema, name }) {
   return writer.toString()
 }
 
-function generateImplementationFromGraqhQL ({ name, url }) {
+function generateImplementationFromGraqhQL ({ name, url, moduleFormat }) {
   const camelcasedName = toJavaScriptName(name)
+  const isESM = moduleFormat === 'esm'
 
   const writer = new CodeBlockWriter({
     indentNumberOfSpaces: 2,
@@ -69,27 +70,40 @@ function generateImplementationFromGraqhQL ({ name, url }) {
     useSingleQuote: true
   })
 
-  writer.writeLine("import { buildGraphQLClient } from 'massimo'")
-  writer.writeLine("import { join } from 'node:path'")
+  if (isESM) {
+    writer.writeLine("import { buildGraphQLClient } from 'massimo'")
+    writer.writeLine("import { join } from 'node:path'")
+  } else {
+    writer.writeLine("const { buildGraphQLClient } = require('massimo')")
+    writer.writeLine("const { join } = require('node:path')")
+  }
   writer.blankLine()
 
   url = new URL(url)
 
   const functionName = `generate${capitalize(camelcasedName)}Client`
-  writer.write(`export async function ${functionName} (opts)`).block(() => {
+  const funcDecl = isESM ? `export async function ${functionName} (opts)` : `async function ${functionName} (opts)`
+  writer.write(funcDecl).block(() => {
     writer.writeLine('const url = new URL(opts.url)')
     writer.writeLine(`url.pathname = '${url.pathname}'`)
     writer.write('return buildGraphQLClient(').inlineBlock(() => {
       writer.writeLine("type: 'graphql',")
       writer.writeLine(`name: '${camelcasedName}',`)
-      writer.writeLine(`path: join(import.meta.dirname, '${name}.schema.graphql'),`)
+      const pathExpr = isESM ? `join(import.meta.dirname, '${name}.schema.graphql')` : `join(__dirname, '${name}.schema.graphql')`
+      writer.writeLine(`path: ${pathExpr},`)
       writer.writeLine('serviceId: opts.serviceId,')
       writer.writeLine('url: url.toString()')
     })
     writer.write(')')
   })
   writer.blankLine()
-  writer.writeLine(`export default ${functionName}`)
+  if (isESM) {
+    writer.writeLine(`export default ${functionName}`)
+  } else {
+    writer.writeLine(`module.exports = ${functionName}`)
+    writer.writeLine(`module.exports.default = ${functionName}`)
+    writer.writeLine(`module.exports.${functionName} = ${functionName}`)
+  }
   return writer.toString()
 }
 

package/lib/openapi-generator.js

@@ -11,7 +11,8 @@ export function processOpenAPI ({
   optionalHeaders,
   validateResponse,
   typesComment,
-  propsOptional
+  propsOptional,
+  moduleFormat
 }) {
   return {
     types: generateTypesFromOpenAPI({
@@ -23,12 +24,13 @@ export function processOpenAPI ({
       typesComment,
       propsOptional
     }),
-    implementation: generateImplementationFromOpenAPI({ name, fullResponse, fullRequest, validateResponse })
+    implementation: generateImplementationFromOpenAPI({ name, fullResponse, fullRequest, validateResponse, moduleFormat })
   }
 }
 
-function generateImplementationFromOpenAPI ({ name, fullResponse, fullRequest, validateResponse }) {
+function generateImplementationFromOpenAPI ({ name, fullResponse, fullRequest, validateResponse, moduleFormat }) {
   const camelcasedName = toJavaScriptName(name)
+  const isESM = moduleFormat === 'esm'
 
   const writer = new CodeBlockWriter({
     indentNumberOfSpaces: 2,
@@ -36,16 +38,23 @@ function generateImplementationFromOpenAPI ({ name, fullResponse, fullRequest, v
     useSingleQuote: true
   })
 
-  writer.writeLine("import { buildOpenAPIClient } from 'massimo'")
-  writer.writeLine("import { join } from 'node:path'")
+  if (isESM) {
+    writer.writeLine("import { buildOpenAPIClient } from 'massimo'")
+    writer.writeLine("import { join } from 'node:path'")
+  } else {
+    writer.writeLine("const { buildOpenAPIClient } = require('massimo')")
+    writer.writeLine("const { join } = require('node:path')")
+  }
   writer.blankLine()
 
   const functionName = `generate${capitalize(camelcasedName)}Client`
-  writer.write(`export async function ${functionName} (opts)`).block(() => {
+  const funcDecl = isESM ? `export async function ${functionName} (opts)` : `async function ${functionName} (opts)`
+  writer.write(funcDecl).block(() => {
     writer.write('return buildOpenAPIClient(').inlineBlock(() => {
       writer.writeLine("type: 'openapi',")
       writer.writeLine(`name: '${camelcasedName}',`)
-      writer.writeLine(`path: join(import.meta.dirname, '${name}.openapi.json'),`)
+      const pathExpr = isESM ? `join(import.meta.dirname, '${name}.openapi.json')` : `join(__dirname, '${name}.openapi.json')`
+      writer.writeLine(`path: ${pathExpr},`)
       writer.writeLine('url: opts.url,')
       writer.writeLine('serviceId: opts.serviceId,')
       writer.writeLine('throwOnError: opts.throwOnError,')
@@ -57,7 +66,13 @@ function generateImplementationFromOpenAPI ({ name, fullResponse, fullRequest, v
     writer.write(')')
   })
   writer.blankLine()
-  writer.writeLine(`export default ${functionName}`)
+  if (isESM) {
+    writer.writeLine(`export default ${functionName}`)
+  } else {
+    writer.writeLine(`module.exports = ${functionName}`)
+    writer.writeLine(`module.exports.default = ${functionName}`)
+    writer.writeLine(`module.exports.${functionName} = ${functionName}`)
+  }
   return writer.toString()
 }
 
@@ -68,7 +83,7 @@ function generateTypesFromOpenAPI ({
   fullRequest,
   optionalHeaders,
   typesComment,
-  propsOptional
+  propsOptional,
 }) {
   const camelcasedName = toJavaScriptName(name)
   const capitalizedName = capitalize(camelcasedName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "massimo-cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A client for HTTP services.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,7 +30,7 @@
     "pino-pretty": "^13.0.0",
     "undici": "^7.0.0",
     "yaml": "^2.4.1",
-    "massimo": "0.3.0"
+    "massimo": "0.5.0"
   },
   "devDependencies": {
     "@platformatic/composer": "3.0.0-alpha.6",