@ps-aux/api-client-gen 0.0.7-rc2 → 0.1.1-rc1

package/dist/bin.esm.js

@@ -1,5 +1,5 @@
 #!/bin/env node
-import { g as generateApiClient } from './generateApiClient-DUCQclNI.js';
+import { g as generateApiClient } from './generateApiClient-PeRLjZk9.js';
 import { cosmiconfigSync } from 'cosmiconfig';
 import 'path';
 import 'fs';

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/bin/env node
 'use strict';
 
-var generateApiClient = require('./generateApiClient-BHDOH9mh.js');
+var generateApiClient = require('./generateApiClient-d_X--WFl.js');
 var cosmiconfig = require('cosmiconfig');
 require('path');
 require('fs');

package/dist/generateApiClient-PeRLjZk9.js

@@ -0,0 +1,168 @@
+import Path from 'path';
+import * as fs from 'fs';
+import fs__default from 'fs';
+import axios from 'axios';
+import fs$1 from 'fs/promises';
+import { generateApi } from 'swagger-typescript-api';
+import { generate } from 'ts-to-zod';
+
+const downloadSpec = async (path, url) => {
+    const res = await axios({
+        url,
+        method: 'GET',
+        responseType: 'arraybuffer',
+    }).catch(err => {
+        throw err.toString();
+    });
+    const content = res.data.toString();
+    await fs$1.writeFile(path, format(content));
+};
+const format = (content) => JSON.stringify(JSON.parse(content), null, 4);
+
+const generateOpenApiModel = async ({ input, isNode, responseWrapper, name, outputDir }, log) => {
+    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 = [];
+    const replaces = [];
+    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>', ''])
+    // replaces.push(['request: <Data, A = any>', 'request: <Data>'])
+    log(`Will modify the outputs ${JSON.stringify({
+        addImports,
+        replaces,
+    })}`);
+    await modifyOutput(dstFile, {
+        addImports,
+        replaces,
+    });
+    return dstFile;
+};
+const modifyOutput = async (path, cmd) => {
+    let content = await fs$1.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$1.writeFile(path, content);
+};
+const getThisScriptDirname = () => {
+    // Might be problem in ESM mode
+    return __dirname;
+};
+const capitalize = (str) => {
+    return str[0].toUpperCase() + str.substring(1);
+};
+
+// TODO needed?
+const removeGenericTypes = (code) => {
+    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');
+};
+const generateSchemas = (inputFile, outputFile, opts = {}) => {
+    const code = fs__default.readFileSync(inputFile).toString();
+    const { getZodSchemasFile } = generate({
+        sourceText: removeGenericTypes(code),
+        // inputOutputMappings: {
+        //
+        // },
+        customJSDocFormatTypes: {
+        // Custom mapping
+        // 'date-time': 'blablaj' - regex
+        }
+    });
+    const fileName = Path.basename(inputFile);
+    let f = getZodSchemasFile(`./${fileName.replace('.ts', '')}`);
+    // Add import from the api model - TODO find a way how to define on generate
+    f = f.replaceAll('"./index";', '"./client"');
+    // 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__default.writeFileSync(outputFile, f);
+};
+
+const generateApiClient = async ({ dstDir, apiName, env, srcSpec, responseWrapper, zodSchemas }, log = console.log) => {
+    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, dir, log) => {
+    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;
+};
+
+export { generateApiClient as g };

package/dist/generateApiClient-d_X--WFl.js

@@ -0,0 +1,188 @@
+'use strict';
+
+var Path = require('path');
+var fs$1 = require('fs');
+var axios = require('axios');
+var fs = require('fs/promises');
+var swaggerTypescriptApi = require('swagger-typescript-api');
+var tsToZod = require('ts-to-zod');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs$1);
+
+const downloadSpec = async (path, url) => {
+    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) => JSON.stringify(JSON.parse(content), null, 4);
+
+const generateOpenApiModel = async ({ input, isNode, responseWrapper, name, outputDir }, log) => {
+    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 swaggerTypescriptApi.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 = [];
+    const replaces = [];
+    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>', ''])
+    // replaces.push(['request: <Data, A = any>', 'request: <Data>'])
+    log(`Will modify the outputs ${JSON.stringify({
+        addImports,
+        replaces,
+    })}`);
+    await modifyOutput(dstFile, {
+        addImports,
+        replaces,
+    });
+    return dstFile;
+};
+const modifyOutput = async (path, cmd) => {
+    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 = () => {
+    // Might be problem in ESM mode
+    return __dirname;
+};
+const capitalize = (str) => {
+    return str[0].toUpperCase() + str.substring(1);
+};
+
+// TODO needed?
+const removeGenericTypes = (code) => {
+    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');
+};
+const generateSchemas = (inputFile, outputFile, opts = {}) => {
+    const code = fs$1.readFileSync(inputFile).toString();
+    const { getZodSchemasFile } = tsToZod.generate({
+        sourceText: removeGenericTypes(code),
+        // inputOutputMappings: {
+        //
+        // },
+        customJSDocFormatTypes: {
+        // Custom mapping
+        // 'date-time': 'blablaj' - regex
+        }
+    });
+    const fileName = Path.basename(inputFile);
+    let f = getZodSchemasFile(`./${fileName.replace('.ts', '')}`);
+    // Add import from the api model - TODO find a way how to define on generate
+    f = f.replaceAll('"./index";', '"./client"');
+    // 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$1.writeFileSync(outputFile, f);
+};
+
+const generateApiClient = async ({ dstDir, apiName, env, srcSpec, responseWrapper, zodSchemas }, log = console.log) => {
+    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__namespace.existsSync(dir)) {
+        log(`Creating dir ${dir}`);
+        fs__namespace.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, dir, log) => {
+    if (!urlOrPath.startsWith('http')) {
+        if (!fs__namespace.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;
+};
+
+exports.generateApiClient = generateApiClient;

package/dist/generateApiClient.d.ts

@@ -12,4 +12,4 @@ export type Params = {
         enabled?: boolean;
     };
 };
-export declare const generateApiClient: ({ dstDir, apiName, env, srcSpec, responseWrapper, zodSchemas, }: Params, log?: (msg: string) => void) => Promise<void>;
+export declare const generateApiClient: ({ dstDir, apiName, env, srcSpec, responseWrapper, zodSchemas }: Params, log?: (msg: string) => void) => Promise<void>;

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-export { g as generateApiClient } from './generateApiClient-DUCQclNI.js';
+export { g as generateApiClient } from './generateApiClient-PeRLjZk9.js';
 import 'path';
 import 'fs';
 import 'axios';

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var generateApiClient = require('./generateApiClient-BHDOH9mh.js');
+var generateApiClient = require('./generateApiClient-d_X--WFl.js');
 require('path');
 require('fs');
 require('axios');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ps-aux/api-client-gen",
-  "version": "0.0.7-rc2",
+  "version": "0.1.1-rc1",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
@@ -12,8 +12,7 @@
     "dev": "rollup -c --watch",
     "pub": "npm test && npm run build && npm publish",
     "test": "vitest",
-    "tc": "tsc",
-    "eh": "foo"
+    "tc": "tsc"
   },
   "author": "",
   "license": "ISC",

package/templates/api.ejs

@@ -0,0 +1,56 @@
+<%
+const { apiConfig, routes, utils, config } = it;
+const { info, servers, externalDocs } = apiConfig;
+const { _, require, formatDescription } = utils;
+
+const server = (servers && servers[0]) || { url: "" };
+
+const descriptionLines = _.compact([
+  `@title ${info.title || "No title"}`,
+  info.version && `@version ${info.version}`,
+  info.license && `@license ${_.compact([
+    info.license.name,
+    info.license.url && `(${info.license.url})`,
+  ]).join(" ")}`,
+  info.termsOfService && `@termsOfService ${info.termsOfService}`,
+  server.url && `@baseUrl ${server.url}`,
+  externalDocs.url && `@externalDocs ${externalDocs.url}`,
+  info.contact && `@contact ${_.compact([
+    info.contact.name,
+    info.contact.email && `<${info.contact.email}>`,
+    info.contact.url && `(${info.contact.url})`,
+  ]).join(" ")}`,
+  info.description && " ",
+  info.description && _.replace(formatDescription(info.description), /\n/g, "\n * "),
+]);
+
+%>
+
+<% if (config.httpClientType === config.constants.HTTP_CLIENT.AXIOS) { %> import type { AxiosRequestConfig, AxiosResponse } from "axios"; <% } %>
+
+<% if (descriptionLines.length) { %>
+/**
+<% descriptionLines.forEach((descriptionLine) => { %>
+* <%~ descriptionLine %>
+
+<% }) %>
+*/
+<% } %>
+export class <%~ config.apiClassName %><RequestParams>{
+
+  http: HttpClient<RequestParams>;
+
+  constructor (http: HttpClient<RequestParams>) {
+    this.http = http;
+  }
+
+  <% for (const { routes: combinedRoutes = [], moduleName } of routes.combined) { %>
+  <%~ moduleName %> = {
+  <% for (const route of combinedRoutes) { %>
+
+  <%~ includeFile('./procedure-call.ejs', { ...it, route }) %>
+
+  <% } %>
+  }
+  <% } %>
+}

package/templates/http-client.eta

@@ -1,8 +1,5 @@
 export type ContentType = {}
 
-export type RequestParams = {
-}
-
 export const ContentType = {
     Json: 'application/json',
     FormData: 'multipart/form-data',
@@ -18,6 +15,6 @@ export type Request = {
     secure?: boolean
 }
 
-export type HttpClient = {
-    request: <Data, A = any>(req: Request) => Promise<Data>
+export type HttpClient<RequestParams> = {
+    request: <Data>(req: Request, params?: RequestParams) => Promise<Data>
 }

package/templates/procedure-call.ejs

@@ -0,0 +1,98 @@
+<%
+const { utils, route, config } = it;
+const { requestBodyInfo, responseBodyInfo, specificArgNameResolver } = route;
+const { _, getInlineParseContent, getParseContent, parseSchema, getComponentByRef, require } = utils;
+const { parameters, path, method, payload, query, formData, security, requestParams } = route.request;
+const { type, errorType, contentTypes } = route.response;
+const { HTTP_CLIENT, RESERVED_REQ_PARAMS_ARG_NAMES } = config.constants;
+const routeDocs = includeFile("@base/route-docs", { config, route, utils });
+const queryName = (query && query.name) || "query";
+const pathParams = _.values(parameters);
+const pathParamsNames = _.map(pathParams, "name");
+
+const isFetchTemplate = config.httpClientType === HTTP_CLIENT.FETCH;
+
+const requestConfigParam = {
+    name: specificArgNameResolver.resolve(RESERVED_REQ_PARAMS_ARG_NAMES),
+    optional: true,
+    type: "RequestParams"
+}
+
+const argToTmpl = ({ name, optional, type, defaultValue }) => `${name}${!defaultValue && optional ? '?' : ''}: ${type}${defaultValue ? ` = ${defaultValue}` : ''}`;
+
+const rawWrapperArgs = config.extractRequestParams ?
+    _.compact([
+        requestParams && {
+          name: pathParams.length ? `{ ${_.join(pathParamsNames, ", ")}, ...${queryName} }` : queryName,
+          optional: false,
+          type: getInlineParseContent(requestParams),
+        },
+        ...(!requestParams ? pathParams : []),
+        payload,
+        requestConfigParam,
+    ]) :
+    _.compact([
+        ...pathParams,
+        query,
+        payload,
+        requestConfigParam,
+    ])
+
+const wrapperArgs = _
+    // Sort by optionality
+    .sortBy(rawWrapperArgs, [o => o.optional])
+    .map(argToTmpl)
+    .join(', ')
+
+// RequestParams["type"]
+const requestContentKind = {
+    "JSON": "ContentType.Json",
+    "URL_ENCODED": "ContentType.UrlEncoded",
+    "FORM_DATA": "ContentType.FormData",
+    "TEXT": "ContentType.Text",
+}
+// RequestParams["format"]
+const responseContentKind = {
+    "JSON": '"json"',
+    "IMAGE": '"blob"',
+    "FORM_DATA": isFetchTemplate ? '"formData"' : '"document"'
+}
+
+const bodyTmpl = _.get(payload, "name") || null;
+const queryTmpl = (query != null && queryName) || null;
+const bodyContentKindTmpl = requestContentKind[requestBodyInfo.contentKind] || null;
+const responseFormatTmpl = responseContentKind[responseBodyInfo.success && responseBodyInfo.success.schema && responseBodyInfo.success.schema.contentKind] || null;
+const securityTmpl = security ? 'true' : null;
+
+const describeReturnType = () => {
+    if (!config.toJS) return "";
+
+    switch(config.httpClientType) {
+        case HTTP_CLIENT.AXIOS: {
+          return `Promise<AxiosResponse<${type}>>`
+        }
+        default: {
+          return `Promise<HttpResponse<${type}, ${errorType}>`
+        }
+    }
+}
+
+%>
+/**
+<%~ routeDocs.description %>
+
+ *<% /* Here you can add some other JSDoc tags */ %>
+
+<%~ routeDocs.lines %>
+
+ */
+<%~ route.routeName.usage %><%~ route.namespace ? ': ' : ' = ' %>(<%~ wrapperArgs %>)<%~ config.toJS ? `: ${describeReturnType()}` : "" %> =>
+    <%~ config.singleHttpClient ? 'this.http.request' : 'this.request' %><<%~ type %>>({
+        path: `<%~ path %>`,
+        method: '<%~ _.upperCase(method) %>',
+        <%~ queryTmpl ? `query: ${queryTmpl},` : '' %>
+        <%~ bodyTmpl ? `body: ${bodyTmpl},` : '' %>
+        <%~ securityTmpl ? `secure: ${securityTmpl},` : '' %>
+        <%~ bodyContentKindTmpl ? `type: ${bodyContentKindTmpl},` : '' %>
+        <%~ responseFormatTmpl ? `format: ${responseFormatTmpl},` : '' %>
+    }, params)<%~ route.namespace ? ',' : '' %>