@ps-aux/api-client-gen 0.0.6-rc1 → 0.0.6-rc3

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@ps-aux/api-client-gen",
-  "version": "0.0.6-rc1",
+  "version": "0.0.6-rc3",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
-  "type": "module",
   "types": "dist/index.d.ts",
   "bin": {
     "gen-api-client": "dist/bin.js"

package/src/downloadSpec.ts

@@ -1,22 +0,0 @@
-import axios from 'axios'
-import fs from 'fs/promises'
-
-export const downloadSpec = async (path: string, url: string) => {
-    const res = await axios({
-        url,
-        method: 'GET',
-        responseType: 'arraybuffer',
-    }).catch(err => {
-        throw err.toString()
-    })
-
-    const content = res.data.toString()
-
-    await fs.writeFile(path, format(content))
-}
-
-const format = (content: string): string =>
-    JSON.stringify(
-        JSON.parse(content), null, 4,
-    )
-

package/src/generateApiClient.ts

@@ -1,76 +0,0 @@
-import Path from 'path'
-import * as fs from 'fs'
-import { downloadSpec } from './downloadSpec'
-import { generateOpenApiModel } from './generateOpenApiModel'
-import { generateSchemas, GenerateSchemasOptions } from './generateSchemas'
-
-export type Params = {
-    srcSpec: string, // path or http(s) URL
-    dstDir: string
-    apiName: string
-    env: 'browser' | 'node'
-    responseWrapper?: {
-        symbol: string
-        import?: string
-    },
-    zodSchemas?: GenerateSchemasOptions & {
-        enabled?: boolean
-    }
-}
-
-export const generateApiClient = async ({
-                                            dstDir,
-                                            apiName,
-                                            env,
-                                            srcSpec,
-                                            responseWrapper,
-                                            zodSchemas,
-                                        }: Params, log: (msg: string) => void = console.log): Promise<void> => {
-    if (!srcSpec) throw new Error(`Url or path ('srcSpec' not specified`)
-    if (!apiName) throw new Error('apiName not specified')
-    if (!dstDir) throw new Error('dstDir not specified')
-    if (!env) throw new Error('env not specified')
-
-    const dir = Path.resolve(dstDir, apiName)
-    if (!fs.existsSync(dir)) {
-        log(`Creating dir ${dir}`)
-        fs.mkdirSync(dir, {
-            recursive: true,
-        })
-    }
-    const clientDir = Path.resolve(dir, 'client')
-
-    const specPath = await getSpecPath(srcSpec, dir, log)
-
-    const clientFile = await generateOpenApiModel(
-        {
-            name: apiName,
-            input: specPath,
-            outputDir: clientDir,
-            isNode: env === 'node',
-            responseWrapper,
-        },
-        log,
-    )
-
-    if (zodSchemas?.enabled === false)
-        return
-
-
-    log('Generating Zod schemas')
-    generateSchemas(Path.resolve(dir, clientFile), Path.resolve(dir, './zod.ts'), zodSchemas)
-}
-
-const getSpecPath = async (urlOrPath: string, dir: string, log: (str: string) => void): Promise<string> => {
-    if (!urlOrPath.startsWith('http')) {
-        if (!fs.existsSync(urlOrPath))
-            throw new Error(`Spec file ${urlOrPath} does not exists`)
-        return urlOrPath
-    }
-    const specPath = Path.resolve(dir, `spec.json`)
-
-    log(`Will download the API spec from ${urlOrPath} to ${specPath}`)
-    await downloadSpec(specPath, urlOrPath)
-
-    return specPath
-}

package/src/generateOpenApiModel.ts

@@ -1,114 +0,0 @@
-import { generateApi } from 'swagger-typescript-api'
-import Path from 'path'
-import fs from 'fs/promises'
-
-export type GenerateOpenApiModelCmd = {
-    name: string,
-    input: string,
-    outputDir: string,
-    isNode?: boolean
-    responseWrapper?: {
-        symbol: string
-        import?: string
-    },
-}
-
-export const generateOpenApiModel = async ({ input, isNode, responseWrapper, name, outputDir }: GenerateOpenApiModelCmd,
-                                           log: (msg: string) => void,
-): Promise<string> => {
-
-    log(`Will generate API client name=${name} to ${outputDir}, node=${isNode}`)
-    const specialMapping = isNode
-        ? {
-            File: '{file: Buffer | stream.Readable, name: string}',
-        }
-        : {}
-
-    const fileName = 'index'
-    const dstFile = Path.join(outputDir,  `${fileName}.ts`)
-
-    await generateApi({
-        name: 'index',
-        output: outputDir,
-        input: input,
-        // modular: true,
-        httpClientType: 'axios',
-        templates: Path.resolve(getThisScriptDirname(), '../templates'),
-        defaultResponseAsSuccess: true,
-        // generateRouteTypes: true,
-        singleHttpClient: true,
-        // extractRequestBody: true,
-        cleanOutput: true,
-        moduleNameFirstTag: true,
-        apiClassName: capitalize(name) + 'Api',
-        // @ts-ignore
-        codeGenConstructs: (struct) => ({
-            // @ts-ignore
-            Keyword: specialMapping,
-        }),
-        // extractRequestParams: true,
-    })
-
-    const addImports: string[] = []
-    const replaces: [string, string][] = []
-
-    if (isNode) {
-        addImports.push('import stream from \'node:stream\'')
-    }
-
-
-    if (responseWrapper) {
-        log(`Will use response wrapper '${JSON.stringify(responseWrapper)}'`)
-        if (responseWrapper.import)
-            addImports.push(responseWrapper.import)
-
-        replaces.push(['Promise', responseWrapper.symbol])
-    }
-
-
-    // Remove unnecessary generics
-    replaces.push(['<SecurityDataType extends unknown>', ''])
-    replaces.push(['<SecurityDataType>', ''])
-
-
-    log(`Will modify the outputs ${JSON.stringify({
-        addImports,
-        replaces,
-    })}`)
-    await modifyOutput(dstFile, {
-        addImports,
-        replaces,
-    })
-
-    return dstFile
-}
-
-const modifyOutput = async (path: string, cmd: {
-    addImports: string[]
-    replaces: [string, string][]
-}) => {
-
-
-    let content = await fs.readFile(path).then((r) => r.toString())
-
-    if (cmd.addImports.length) {
-        content = cmd.addImports.join('\n') + '\n' + content
-    }
-
-    cmd.replaces.forEach(([from, to]) => {
-        content = content.replaceAll(from, to)
-    })
-
-
-    await fs.writeFile(path, content)
-}
-
-const getThisScriptDirname = (): string => {
-    // Might be problem in ESM mode
-    return __dirname
-}
-
-
-const capitalize = (str: string): string => {
-    return str[0].toUpperCase() + str.substring(1)
-}

package/src/generateSchemas.ts

@@ -1,40 +0,0 @@
-import fs from 'fs'
-import { generate } from 'ts-to-zod'
-import Path from 'path'
-
-// TODO needed?
-const removeGenericTypes = (code: string): string => {
-    const regex = /export (interface|enum|type) [^<]* \{\n(.*\n)*?}/mg
-    const matches = code.matchAll(regex)
-    const types = Array.from(matches).map(m => m[0])
-
-    return types.join('\n')
-}
-
-export type GenerateSchemasOptions = {
-    localDateTimes?: boolean
-}
-
-export const generateSchemas = (inputFile: string, outputFile: string, opts: GenerateSchemasOptions = {}) => {
-    const code = fs.readFileSync(inputFile).toString()
-
-    const { getZodSchemasFile } = generate({
-        sourceText: removeGenericTypes(code),
-        customJSDocFormatTypes: {
-            // Custom mapping
-            // 'date-time': 'blablaj' - regex
-        },
-    })
-
-    const fileName = Path.basename(inputFile)
-
-    let f = getZodSchemasFile(`./${fileName.replace('.ts', '')}`)
-
-    // Backend sends nulls not undefined - should be properly set in the OpenAPI TS types generation!
-    f = f.replaceAll('.optional()', '.nullable()')
-    if (opts.localDateTimes) {
-        f = f.replaceAll('z.string().datetime()', 'z.string().datetime({local: true})')
-    }
-    fs.writeFileSync(outputFile, f)
-
-}

package/src/go.ts

@@ -1,23 +0,0 @@
-#!/bin/env node
-import { generateApiClient } from './generateApiClient'
-import { cosmiconfigSync } from 'cosmiconfig'
-
-const profile = process.argv[2]
-
-if (!profile)
-    throw new Error(`No profile specified`)
-
-const conf = cosmiconfigSync('api-client-gen')
-    .search()
-
-// TODO validate config
-if (!conf)
-    throw new Error(`No config provided`)
-
-
-const profileConf = conf.config[profile]
-
-if (!profile)
-    throw new Error(`Profile ${profile} not present in the configuration`)
-
-generateApiClient(profileConf).catch(console.error)

package/src/index.ts

@@ -1,3 +0,0 @@
-export { generateApiClient } from "./generateApiClient";
-
-

package/test/go.spec.ts

@@ -1,16 +0,0 @@
-import { generateApiClient } from '../src'
-import * as Path from 'path'
-import { test } from 'vitest'
-
-
-test('generate', async () => {
-    await generateApiClient({
-        srcSpec: Path.resolve(__dirname, 'schema.json'),
-        dstDir: Path.resolve(__dirname, 'out'),
-        env: 'browser',
-        apiName: 'test',
-        zodSchemas: {
-            localDateTimes: true,
-        },
-    })
-})

package/test/schema.json

@@ -1,118 +0,0 @@
-{
-  "openapi": "3.0.0",
-  "info": {
-    "title": "Simple API",
-    "description": "A basic API example",
-    "version": "1.0.0"
-  },
-  "servers": [
-    {
-      "url": "https://api.example.com/v1",
-      "description": "Main production server"
-    }
-  ],
-  "paths": {
-    "/users": {
-      "get": {
-        "summary": "Get list of users",
-        "responses": {
-          "200": {
-            "description": "Successful response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/User"
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      "post": {
-        "summary": "Create a new user",
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/User"
-              }
-            }
-          }
-        },
-        "responses": {
-          "201": {
-            "description": "User created successfully",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/User"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/users/{id}": {
-      "get": {
-        "summary": "Get user by ID",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/User"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "schemas": {
-      "User": {
-        "type": "object",
-        "required": [
-          "id",
-          "name"
-        ],
-        "properties": {
-          "id": {
-            "type": "string",
-            "example": "123"
-          },
-          "name": {
-            "type": "string",
-            "example": "John Doe"
-          },
-          "email": {
-            "type": "string",
-            "format": "email",
-            "example": "john@example.com"
-          },
-          "createdAt": {
-            "type": "string",
-            "format": "date-time"
-          }
-        }
-      }
-    }
-  }
-}