@open-norantec/herbal 1.0.2-alpha.24 → 1.0.2-alpha.25

package/dist/abstracts/client.abstract.class.d.ts

@@ -8,6 +8,6 @@ export declare abstract class Client {
     readonly options: CreateClientOptions;
     protected document: OpenAPIObject;
     constructor(options: CreateClientOptions);
-    abstract generateClientSourceFile(): string;
+    abstract generateClientSourceFile(): Promise<string>;
     createSchema(group?: string): void;
 }

package/dist/cli/herbal.js

@@ -1,5 +1,41 @@
 #!/usr/bin/env node
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
 var forge_1 = require("@open-norantec/forge");
@@ -177,21 +213,28 @@ command
                     '  if (!isClient(client)) { client = entry?.default; }',
                     "  if (!isClient(client)) return '';",
                     '  client.instance.createSchema(context?.group);',
-                    "  return client.instance.generateClientSourceFile() ?? '';",
+                    '  return client.instance.generateClientSourceFile();',
                     '};',
                 ].join('\n');
             },
-            rewriteOutputFile: function (code) {
-                try {
-                    var generateCodeMethod = requireFromString(code);
-                    if (typeof generateCodeMethod !== 'function')
-                        return '';
-                    return generateCodeMethod({ group: options === null || options === void 0 ? void 0 : options.group });
-                }
-                catch (_a) {
-                    return '';
-                }
-            },
+            rewriteOutputFile: function (code) { return __awaiter(void 0, void 0, void 0, function () {
+                var generateCodeMethod, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, , 3]);
+                            generateCodeMethod = requireFromString(code);
+                            if (typeof generateCodeMethod !== 'function')
+                                return [2, ''];
+                            return [4, Promise.resolve(generateCodeMethod({ group: options === null || options === void 0 ? void 0 : options.group })).then(function (generatedCode) { return generatedCode !== null && generatedCode !== void 0 ? generatedCode : ''; })];
+                        case 1: return [2, _b.sent()];
+                        case 2:
+                            _a = _b.sent();
+                            return [2, ''];
+                        case 3: return [2];
+                    }
+                });
+            }); },
         }); },
     };
 }));

package/dist/clients/typescript-client.class.d.ts

@@ -1,22 +1,7 @@
 import 'reflect-metadata';
-import { SchemaObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
 import { Client, CreateClientOptions } from '../abstracts/client.abstract.class';
-declare namespace OpenApiToTypescript {
-    interface Options {
-        useInterface?: boolean;
-        export?: boolean;
-        generateJSDoc?: boolean;
-        preferUnknown?: boolean;
-        singleLine?: boolean;
-    }
-    interface TypeResult {
-        code: string;
-        name?: string;
-    }
-}
-export declare function convertOpenApiToTypescript(schema: SchemaObject, name?: string, options?: OpenApiToTypescript.Options): OpenApiToTypescript.TypeResult;
 export declare class TypeScriptClient extends Client implements Client {
     constructor(options: CreateClientOptions);
-    generateClientSourceFile(): string;
+    generateClientSourceFile(): Promise<string>;
+    private schemaToTypeScriptLiteral;
 }
-export {};

package/dist/clients/typescript-client.class.js

@@ -14,346 +14,224 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeScriptClient = exports.convertOpenApiToTypescript = void 0;
+exports.TypeScriptClient = void 0;
 require("reflect-metadata");
 var client_abstract_class_1 = require("../abstracts/client.abstract.class");
-var OpenApiToTypescriptConverter = (function () {
-    function OpenApiToTypescriptConverter(options) {
-        if (options === void 0) { options = {}; }
-        this.options = __assign({ useInterface: false, export: true, generateJSDoc: true, preferUnknown: true, singleLine: true }, options);
-    }
-    OpenApiToTypescriptConverter.prototype.convert = function (schema, name) {
-        var typeString = this.parseSchema(schema, 0, name);
-        if (name) {
-            var exportKeyword = this.options.export ? 'export ' : '';
-            if (this.options.useInterface && schema.type === 'object' && schema.properties) {
-                var code_1 = "".concat(exportKeyword).concat(typeString);
-                return { code: code_1, name: name };
-            }
-            var code = "".concat(exportKeyword, "type ").concat(name, " = ").concat(typeString, ";");
-            return { code: code, name: name };
-        }
-        return { code: typeString };
-    };
-    OpenApiToTypescriptConverter.prototype.generateTypes = function (schemas) {
-        var _this = this;
-        if (!schemas)
-            return '';
-        var lines = [];
-        Object.entries(schemas).forEach(function (_a) {
-            var name = _a[0], schema = _a[1];
-            var result = _this.convert(schema, name);
-            lines.push(result.code);
-        });
-        return lines.join('\n');
-    };
-    OpenApiToTypescriptConverter.fromZodResult = function (result, name, options) {
-        var converter = new OpenApiToTypescriptConverter(options);
-        return converter.convert(result.schema, name);
-    };
-    OpenApiToTypescriptConverter.prototype.parseSchema = function (schema, depth, name) {
-        if (depth === void 0) { depth = 0; }
-        if ('$ref' in schema && typeof schema.$ref === 'string') {
-            return this.refToTypeName(schema.$ref);
-        }
-        var s = schema;
-        if (s.oneOf) {
-            return this.parseOneOf(s.oneOf, depth);
-        }
-        if (s.anyOf) {
-            return this.parseAnyOf(s.anyOf, depth);
-        }
-        if (s.allOf) {
-            return this.parseAllOf(s.allOf, depth);
-        }
-        switch (s.type) {
-            case 'object':
-                return this.parseObject(s, depth, name);
-            case 'array':
-                return this.parseArray(s, depth);
-            case 'string':
-                return this.parseString(s);
-            case 'integer':
-            case 'number':
-                return 'number';
-            case 'boolean':
-                return 'boolean';
-            default:
-                if (s.enum) {
-                    return this.parseEnum(s.enum);
-                }
-                if (Array.isArray(s.type)) {
-                    return s.type.join(' | ');
-                }
-                if (Object.keys(s).length === 0 || (s.type === undefined && !s.enum)) {
-                    return this.options.preferUnknown ? 'unknown' : 'any';
-                }
-                return this.options.preferUnknown ? 'unknown' : 'any';
-        }
-    };
-    OpenApiToTypescriptConverter.prototype.parseObject = function (schema, depth, name) {
-        var _this = this;
-        if (schema.additionalProperties && !schema.properties) {
-            if (typeof schema.additionalProperties === 'boolean') {
-                return 'Record<string, unknown>';
-            }
-            var valueType = this.parseSchema(schema.additionalProperties, depth);
-            return "Record<string, ".concat(valueType, ">");
-        }
-        var properties = schema.properties || {};
-        var required = schema.required || [];
-        if (Object.keys(properties).length === 0) {
-            if (schema.additionalProperties) {
-                if (typeof schema.additionalProperties === 'boolean') {
-                    return 'Record<string, unknown>';
-                }
-                var valueType = this.parseSchema(schema.additionalProperties, depth);
-                return "Record<string, ".concat(valueType, ">");
-            }
-            return 'Record<string, never>';
-        }
-        if (this.options.useInterface && name && depth === 0) {
-            var props_1 = [];
-            Object.entries(properties).forEach(function (_a) {
-                var key = _a[0], propSchema = _a[1];
-                var isRequired = required.includes(key);
-                var tsType = _this.parseSchema(propSchema, depth + 1);
-                var optional = isRequired ? '' : '?';
-                props_1.push("".concat(key).concat(optional, ": ").concat(tsType));
-            });
-            return "interface ".concat(name, " { ").concat(props_1.join('; '), " }");
-        }
-        var props = [];
-        Object.entries(properties).forEach(function (_a) {
-            var key = _a[0], propSchema = _a[1];
-            var isRequired = required.includes(key);
-            var tsType = _this.parseSchema(propSchema, depth + 1);
-            var optional = isRequired ? '' : '?';
-            props.push("".concat(key).concat(optional, ": ").concat(tsType));
-        });
-        return "{ ".concat(props.join('; '), " }");
-    };
-    OpenApiToTypescriptConverter.prototype.parseArray = function (schema, depth) {
-        var _this = this;
-        var items = schema.items;
-        if (!items) {
-            return 'unknown[]';
-        }
-        if (Array.isArray(items)) {
-            var types = items.map(function (item) { return _this.parseSchema(item, depth); });
-            return "[".concat(types.join(', '), "]");
-        }
-        var itemType = this.parseSchema(items, depth);
-        if (itemType.includes('|') || itemType.includes('&')) {
-            return "(".concat(itemType, ")[]");
-        }
-        return "".concat(itemType, "[]");
-    };
-    OpenApiToTypescriptConverter.prototype.parseString = function (schema) {
-        if (schema.enum) {
-            return this.parseEnum(schema.enum);
-        }
-        return 'string';
-    };
-    OpenApiToTypescriptConverter.prototype.parseEnum = function (values) {
-        var literals = values.map(function (v) {
-            if (v === null)
-                return 'null';
-            if (typeof v === 'string') {
-                return "'".concat(v.replace(/'/g, "\\'"), "'");
-            }
-            return String(v);
-        });
-        return literals.join(' | ');
-    };
-    OpenApiToTypescriptConverter.prototype.parseOneOf = function (schemas, depth) {
-        var _this = this;
-        var types = schemas.map(function (s) { return _this.parseSchema(s, depth); });
-        return types.join(' | ');
-    };
-    OpenApiToTypescriptConverter.prototype.parseAnyOf = function (schemas, depth) {
-        var _this = this;
-        var types = schemas.map(function (s) { return _this.parseSchema(s, depth); });
-        return types.join(' | ');
-    };
-    OpenApiToTypescriptConverter.prototype.parseAllOf = function (schemas, depth) {
-        var _this = this;
-        var types = schemas.map(function (s) {
-            var parsed = _this.parseSchema(s, depth);
-            return parsed;
-        });
-        var uniqueTypes = __spreadArray([], Array.from(new Set(types)), true);
-        if (uniqueTypes.length === 1) {
-            return uniqueTypes[0];
-        }
-        return uniqueTypes.join(' & ');
-    };
-    OpenApiToTypescriptConverter.prototype.refToTypeName = function (ref) {
-        var parts = ref.split('/');
-        return parts[parts.length - 1] || 'unknown';
-    };
-    return OpenApiToTypescriptConverter;
-}());
-function convertOpenApiToTypescript(schema, name, options) {
-    var converter = new OpenApiToTypescriptConverter(options);
-    return converter.convert(schema, name);
-}
-exports.convertOpenApiToTypescript = convertOpenApiToTypescript;
+var json_schema_to_typescript_1 = require("json-schema-to-typescript");
 var TypeScriptClient = (function (_super) {
     __extends(TypeScriptClient, _super);
     function TypeScriptClient(options) {
         return _super.call(this, options) || this;
     }
     TypeScriptClient.prototype.generateClientSourceFile = function () {
-        var _a;
-        var options = this.options;
-        if (!(options === null || options === void 0 ? void 0 : options.Module))
-            throw new Error("Parameter 'Module' must be specified");
-        var METHOD_TYPE_MAP_NAME = 'MethodTypeMap';
-        var METHOD_TYPE_MAP_KEYS_NAME = 'MethodTypeMapKeys';
-        var RESPONSE_CALLBACK_DATA_NAME = 'ResponseCallbackData';
-        var REQUEST_OPTIONS_NAME = 'RequestOptions';
-        var RESULT_TYPE_NAME = 'Result';
-        var REQUEST_METHOD_MAP_NAME = 'REQUEST_METHOD_MAP';
-        var RESPONSE_CACHE_MAP_NAME = 'RESPONSE_CACHE_MAP';
-        var REQUEST_BODY_TYPE_ANNOTATION = "".concat(METHOD_TYPE_MAP_NAME, "[T]['request']");
-        var RESULT_TYPE_ANNOTATION = "".concat(RESULT_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[T]['response']>");
-        var methodTypeMapCodeLines = Object.entries((_a = this.document.paths) !== null && _a !== void 0 ? _a : {})
-            .map(function (_a) {
-            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-            var pathname = _a[0], schema = _a[1];
-            var requestSchema = (_e = (_d = (_c = (_b = schema === null || schema === void 0 ? void 0 : schema.post) === null || _b === void 0 ? void 0 : _b.requestBody) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d['application/json']) === null || _e === void 0 ? void 0 : _e.schema;
-            var responseSchema = (_k = (_j = (_h = (_g = (_f = schema === null || schema === void 0 ? void 0 : schema.post) === null || _f === void 0 ? void 0 : _f.responses) === null || _g === void 0 ? void 0 : _g['200']) === null || _h === void 0 ? void 0 : _h.content) === null || _j === void 0 ? void 0 : _j['application/json']) === null || _k === void 0 ? void 0 : _k.schema;
-            if (!requestSchema && !responseSchema)
-                return null;
-            return [
-                "'".concat(pathname, "': {"),
-                " request: ".concat(((_l = convertOpenApiToTypescript(requestSchema)) === null || _l === void 0 ? void 0 : _l.code) || 'any', ";"),
-                " response: ".concat(((_m = convertOpenApiToTypescript(responseSchema)) === null || _m === void 0 ? void 0 : _m.code) || 'any', ";"),
-                ' };',
-            ].join('');
-        })
-            .filter(function (value) { return value !== null; }).map(function (line) { return "  ".concat(line); });
-        methodTypeMapCodeLines.unshift("export interface ".concat(METHOD_TYPE_MAP_NAME, " {"));
-        methodTypeMapCodeLines.push('}');
-        return [
-            "import * as hash from 'object-hash';",
-            "import * as _ from 'lodash';",
-            "\n".concat(methodTypeMapCodeLines.join('\n')),
-            "\ntype ".concat(METHOD_TYPE_MAP_KEYS_NAME, " = keyof ").concat(METHOD_TYPE_MAP_NAME, ";"),
-            "\ntype ".concat(RESPONSE_CALLBACK_DATA_NAME, "<K extends ").concat(METHOD_TYPE_MAP_KEYS_NAME, "> = {"),
-            '  url: K;',
-            "  result: ".concat(RESULT_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[K]['response']>;"),
-            '};',
-            "\nexport interface ".concat(REQUEST_OPTIONS_NAME, " extends RequestInit {"),
-            '  headers?: Record<string, any>;',
-            '  ignoreCache?: boolean;',
-            '  prefix?: string;',
-            '  timeout?: number;',
-            '  getAuthorizationCredential?: () => string;',
-            "  onRequest?: (context: { cached: boolean; id: string; options: Omit<".concat(REQUEST_OPTIONS_NAME, ", 'getAuthorizationCredential' | 'onRequest' | 'onResponse'>; prefix: string | undefined; requestBody: string; url: string; }) => void | Promise<void>;"),
-            "  onResponse?: <K extends ".concat(METHOD_TYPE_MAP_KEYS_NAME, ">(response: ").concat(RESPONSE_CALLBACK_DATA_NAME, "<K>, id: string) => void | Promise<void>;"),
-            '}',
-            "\nexport interface ".concat(RESULT_TYPE_NAME, "<T> {"),
-            '  error: Error | null;',
-            "  response: T | null;",
-            '  status: number;',
-            '  statusText: string;',
-            '  headers?: Record<string, any>;',
-            '}',
-            '\nexport class Client {',
-            "  public constructor(private readonly options: ".concat(REQUEST_OPTIONS_NAME, " = {}) {}"),
-            "\n  protected readonly ".concat(REQUEST_METHOD_MAP_NAME, " = new Map<keyof ").concat(METHOD_TYPE_MAP_NAME, ", (...params: any[]) => Promise<unknown>>();"),
-            "\n  protected readonly ".concat(RESPONSE_CACHE_MAP_NAME, " = new Map<string, ").concat(RESULT_TYPE_NAME, "<unknown>>();"),
-            "\n  public createRequest<T extends keyof ".concat(METHOD_TYPE_MAP_NAME, ">(url: T): (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => Promise<").concat(RESULT_TYPE_ANNOTATION, "> {"),
-            "    if (typeof this.".concat(REQUEST_METHOD_MAP_NAME, ".get(url) !== 'function') {"),
-            "      this.".concat(REQUEST_METHOD_MAP_NAME, ".set(url, (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => this.request.call(this, url, requestBody, options));"),
-            '    }',
-            "    return this.".concat(REQUEST_METHOD_MAP_NAME, ".get(url) as (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => Promise<").concat(RESULT_TYPE_ANNOTATION, ">;"),
-            '  }',
-            "\n  public async request<T extends keyof ".concat(METHOD_TYPE_MAP_NAME, ">(url: T, requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: Omit<").concat(REQUEST_OPTIONS_NAME, ", 'getAuthorizationCredential' | 'onRequest' | 'onResponse'>): Promise<").concat(RESULT_TYPE_ANNOTATION, "> {"),
-            '    const id = `${Math.random().toString(32).slice(2)}${Date.now().toString(16)}`;',
-            '    const requestHash = hash(requestBody ?? null);',
-            '    const requestBodyString = JSON.stringify(requestBody);',
-            "    const finalOptions = _.merge({}, this?.options, _.omit(options, ['getAuthorizationCredential', 'onRequest', 'onResponse']));",
-            "    const onRequestOptions = _.omit(finalOptions, ['getAuthorizationCredential', 'onRequest', 'onResponse']);",
-            '    const { getAuthorizationCredential, onResponse, onRequest, ignoreCache, timeout, prefix, ...requestOptions } = finalOptions;',
-            "    if (this.".concat(RESPONSE_CACHE_MAP_NAME, ".has(requestHash) && !ignoreCache) {"),
-            '      onRequest?.({',
-            '        prefix,',
-            '        url,',
-            '        requestBody: requestBodyString,',
-            '        cached: true,',
-            '        options: onRequestOptions,',
-            '        id,',
-            '      });',
-            "      return this.".concat(RESPONSE_CACHE_MAP_NAME, ".get(requestHash) as ").concat(RESULT_TYPE_ANNOTATION, ";"),
-            '    }',
-            '    onRequest?.({',
-            '      prefix,',
-            '      url,',
-            '      id,',
-            '      requestBody: requestBodyString,',
-            '      cached: false,',
-            '      options: onRequestOptions,',
-            '    });',
-            '    const credential = getAuthorizationCredential?.();',
-            '    const abortController = new AbortController();',
-            '    if (timeout! > 0) {',
-            '      setTimeout(() => {',
-            '        abortController.abort();',
-            '      }, timeout);',
-            '    }',
-            "    const result: ".concat(RESULT_TYPE_ANNOTATION, " = await fetch((prefix ?? '') + url, {"),
-            '      ...requestOptions,',
-            '      body: JSON.stringify(requestBody),',
-            "      method: 'POST',",
-            '      signal: abortController.signal,',
-            '      headers: {',
-            '        ...requestOptions?.headers,',
-            "        'Content-Type': 'application/json',",
-            "        Authorization: (typeof credential === 'string' && credential.length > 0) ? credential : finalOptions?.headers?.Authorization,",
-            '      },',
-            '    }).then((response) => {',
-            '      const status = response?.status;',
-            '      const statusText = response?.statusText;',
-            '      const headers = Array.from(response?.headers?.entries?.() ?? []).reduce((result, [key, value]) => {',
-            "        if (typeof key !== 'string' || key.length === 0) return result;",
-            '        result[key] = value;',
-            '        return result;',
-            '      }, {});',
-            '      if (!response?.ok) {',
-            '        return response.text().then((errorText) => ({ error: new Error(errorText), response: null, headers, status, statusText }));',
-            '      }',
-            "      return response.json().then((response) => ({ error: null, response, headers, status, statusText } as ".concat(RESULT_TYPE_ANNOTATION, "));"),
-            "    }).catch((error) => Promise.resolve({ error, response: null, headers: {}, status: 0, statusText: '' }));",
-            "    onResponse?.({ url, result }, id);",
-            "    this.".concat(RESPONSE_CACHE_MAP_NAME, ".set(requestHash, result);"),
-            '    return result;',
-            '  }',
-            '}\n',
-        ].join('\n');
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return __awaiter(this, void 0, void 0, function () {
+            var options, METHOD_TYPE_MAP_NAME, METHOD_TYPE_MAP_KEYS_NAME, RESPONSE_CALLBACK_DATA_NAME, REQUEST_OPTIONS_NAME, RESULT_TYPE_NAME, REQUEST_METHOD_MAP_NAME, RESPONSE_CACHE_MAP_NAME, REQUEST_BODY_TYPE_ANNOTATION, RESULT_TYPE_ANNOTATION, methodTypeMapCodeLines, _i, _l, _m, pathname, schema, requestSchema, responseSchema, requestTypeLiteral, responseTypeLiteral;
+            return __generator(this, function (_o) {
+                switch (_o.label) {
+                    case 0:
+                        options = this.options;
+                        if (!(options === null || options === void 0 ? void 0 : options.Module))
+                            throw new Error("Parameter 'Module' must be specified");
+                        METHOD_TYPE_MAP_NAME = 'MethodTypeMap';
+                        METHOD_TYPE_MAP_KEYS_NAME = 'MethodTypeMapKeys';
+                        RESPONSE_CALLBACK_DATA_NAME = 'ResponseCallbackData';
+                        REQUEST_OPTIONS_NAME = 'RequestOptions';
+                        RESULT_TYPE_NAME = 'Result';
+                        REQUEST_METHOD_MAP_NAME = 'REQUEST_METHOD_MAP';
+                        RESPONSE_CACHE_MAP_NAME = 'RESPONSE_CACHE_MAP';
+                        REQUEST_BODY_TYPE_ANNOTATION = "".concat(METHOD_TYPE_MAP_NAME, "[T]['request']");
+                        RESULT_TYPE_ANNOTATION = "".concat(RESULT_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[T]['response']>");
+                        methodTypeMapCodeLines = [];
+                        _i = 0, _l = Object.entries((_a = this.document.paths) !== null && _a !== void 0 ? _a : {});
+                        _o.label = 1;
+                    case 1:
+                        if (!(_i < _l.length)) return [3, 5];
+                        _m = _l[_i], pathname = _m[0], schema = _m[1];
+                        requestSchema = (_e = (_d = (_c = (_b = schema === null || schema === void 0 ? void 0 : schema.post) === null || _b === void 0 ? void 0 : _b.requestBody) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d['application/json']) === null || _e === void 0 ? void 0 : _e.schema;
+                        responseSchema = (_k = (_j = (_h = (_g = (_f = schema === null || schema === void 0 ? void 0 : schema.post) === null || _f === void 0 ? void 0 : _f.responses) === null || _g === void 0 ? void 0 : _g['200']) === null || _h === void 0 ? void 0 : _h.content) === null || _j === void 0 ? void 0 : _j['application/json']) === null || _k === void 0 ? void 0 : _k.schema;
+                        if (!requestSchema && !responseSchema)
+                            return [3, 4];
+                        return [4, this.schemaToTypeScriptLiteral(requestSchema)];
+                    case 2:
+                        requestTypeLiteral = _o.sent();
+                        return [4, this.schemaToTypeScriptLiteral(responseSchema)];
+                    case 3:
+                        responseTypeLiteral = _o.sent();
+                        methodTypeMapCodeLines.push(["'".concat(pathname, "': {"), " request: ".concat(requestTypeLiteral, ";"), " response: ".concat(responseTypeLiteral, ";"), ' };'].join(''));
+                        _o.label = 4;
+                    case 4:
+                        _i++;
+                        return [3, 1];
+                    case 5:
+                        methodTypeMapCodeLines.unshift("export interface ".concat(METHOD_TYPE_MAP_NAME, " {"));
+                        methodTypeMapCodeLines.push('}');
+                        return [2, [
+                                "import * as hash from 'object-hash';",
+                                "import * as _ from 'lodash';",
+                                "\n".concat(methodTypeMapCodeLines.join('\n')),
+                                "\ntype ".concat(METHOD_TYPE_MAP_KEYS_NAME, " = keyof ").concat(METHOD_TYPE_MAP_NAME, ";"),
+                                "\ntype ".concat(RESPONSE_CALLBACK_DATA_NAME, "<K extends ").concat(METHOD_TYPE_MAP_KEYS_NAME, "> = {"),
+                                '  url: K;',
+                                "  result: ".concat(RESULT_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[K]['response']>;"),
+                                '};',
+                                "\nexport interface ".concat(REQUEST_OPTIONS_NAME, " extends RequestInit {"),
+                                '  headers?: Record<string, any>;',
+                                '  ignoreCache?: boolean;',
+                                '  prefix?: string;',
+                                '  timeout?: number;',
+                                '  getAuthorizationCredential?: () => string;',
+                                "  onRequest?: (context: { cached: boolean; id: string; options: Omit<".concat(REQUEST_OPTIONS_NAME, ", 'getAuthorizationCredential' | 'onRequest' | 'onResponse'>; prefix: string | undefined; requestBody: string; url: string; }) => void | Promise<void>;"),
+                                "  onResponse?: <K extends ".concat(METHOD_TYPE_MAP_KEYS_NAME, ">(response: ").concat(RESPONSE_CALLBACK_DATA_NAME, "<K>, id: string) => void | Promise<void>;"),
+                                '}',
+                                "\nexport interface ".concat(RESULT_TYPE_NAME, "<T> {"),
+                                '  error: Error | null;',
+                                "  response: T | null;",
+                                '  status: number;',
+                                '  statusText: string;',
+                                '  headers?: Record<string, any>;',
+                                '}',
+                                '\nexport class Client {',
+                                "  public constructor(private readonly options: ".concat(REQUEST_OPTIONS_NAME, " = {}) {}"),
+                                "\n  protected readonly ".concat(REQUEST_METHOD_MAP_NAME, " = new Map<keyof ").concat(METHOD_TYPE_MAP_NAME, ", (...params: any[]) => Promise<unknown>>();"),
+                                "\n  protected readonly ".concat(RESPONSE_CACHE_MAP_NAME, " = new Map<string, ").concat(RESULT_TYPE_NAME, "<unknown>>();"),
+                                "\n  public createRequest<T extends keyof ".concat(METHOD_TYPE_MAP_NAME, ">(url: T): (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => Promise<").concat(RESULT_TYPE_ANNOTATION, "> {"),
+                                "    if (typeof this.".concat(REQUEST_METHOD_MAP_NAME, ".get(url) !== 'function') {"),
+                                "      this.".concat(REQUEST_METHOD_MAP_NAME, ".set(url, (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => this.request.call(this, url, requestBody, options));"),
+                                '    }',
+                                "    return this.".concat(REQUEST_METHOD_MAP_NAME, ".get(url) as (requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: ").concat(REQUEST_OPTIONS_NAME, ") => Promise<").concat(RESULT_TYPE_ANNOTATION, ">;"),
+                                '  }',
+                                "\n  public async request<T extends keyof ".concat(METHOD_TYPE_MAP_NAME, ">(url: T, requestBody?: ").concat(REQUEST_BODY_TYPE_ANNOTATION, ", options?: Omit<").concat(REQUEST_OPTIONS_NAME, ", 'getAuthorizationCredential' | 'onRequest' | 'onResponse'>): Promise<").concat(RESULT_TYPE_ANNOTATION, "> {"),
+                                '    const id = `${Math.random().toString(32).slice(2)}${Date.now().toString(16)}`;',
+                                '    const requestHash = hash(requestBody ?? null);',
+                                '    const requestBodyString = JSON.stringify(requestBody);',
+                                "    const finalOptions = _.merge({}, this?.options, _.omit(options, ['getAuthorizationCredential', 'onRequest', 'onResponse']));",
+                                "    const onRequestOptions = _.omit(finalOptions, ['getAuthorizationCredential', 'onRequest', 'onResponse']);",
+                                '    const { getAuthorizationCredential, onResponse, onRequest, ignoreCache, timeout, prefix, ...requestOptions } = finalOptions;',
+                                "    if (this.".concat(RESPONSE_CACHE_MAP_NAME, ".has(requestHash) && !ignoreCache) {"),
+                                '      onRequest?.({',
+                                '        prefix,',
+                                '        url,',
+                                '        requestBody: requestBodyString,',
+                                '        cached: true,',
+                                '        options: onRequestOptions,',
+                                '        id,',
+                                '      });',
+                                "      return this.".concat(RESPONSE_CACHE_MAP_NAME, ".get(requestHash) as ").concat(RESULT_TYPE_ANNOTATION, ";"),
+                                '    }',
+                                '    onRequest?.({',
+                                '      prefix,',
+                                '      url,',
+                                '      id,',
+                                '      requestBody: requestBodyString,',
+                                '      cached: false,',
+                                '      options: onRequestOptions,',
+                                '    });',
+                                '    const credential = getAuthorizationCredential?.();',
+                                '    const abortController = new AbortController();',
+                                '    if (timeout! > 0) {',
+                                '      setTimeout(() => {',
+                                '        abortController.abort();',
+                                '      }, timeout);',
+                                '    }',
+                                "    const result: ".concat(RESULT_TYPE_ANNOTATION, " = await fetch((prefix ?? '') + url, {"),
+                                '      ...requestOptions,',
+                                '      body: JSON.stringify(requestBody),',
+                                "      method: 'POST',",
+                                '      signal: abortController.signal,',
+                                '      headers: {',
+                                '        ...requestOptions?.headers,',
+                                "        'Content-Type': 'application/json',",
+                                "        Authorization: (typeof credential === 'string' && credential.length > 0) ? credential : finalOptions?.headers?.Authorization,",
+                                '      },',
+                                '    }).then((response) => {',
+                                '      const status = response?.status;',
+                                '      const statusText = response?.statusText;',
+                                '      const headers = Array.from(response?.headers?.entries?.() ?? []).reduce((result, [key, value]) => {',
+                                "        if (typeof key !== 'string' || key.length === 0) return result;",
+                                '        result[key] = value;',
+                                '        return result;',
+                                '      }, {});',
+                                '      if (!response?.ok) {',
+                                '        return response.text().then((errorText) => ({ error: new Error(errorText), response: null, headers, status, statusText }));',
+                                '      }',
+                                "      return response.json().then((response) => ({ error: null, response, headers, status, statusText } as ".concat(RESULT_TYPE_ANNOTATION, "));"),
+                                "    }).catch((error) => Promise.resolve({ error, response: null, headers: {}, status: 0, statusText: '' }));",
+                                "    onResponse?.({ url, result }, id);",
+                                "    this.".concat(RESPONSE_CACHE_MAP_NAME, ".set(requestHash, result);"),
+                                '    return result;',
+                                '  }',
+                                '}\n',
+                            ].join('\n')];
+                }
+            });
+        });
+    };
+    TypeScriptClient.prototype.schemaToTypeScriptLiteral = function (schema) {
+        return __awaiter(this, void 0, void 0, function () {
+            var interfaceName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        interfaceName = "Interface_".concat(Math.random().toString(36).slice(2));
+                        return [4, (0, json_schema_to_typescript_1.compile)(schema, interfaceName, {
+                                format: true,
+                                bannerComment: '',
+                                additionalProperties: false,
+                                style: {
+                                    singleQuote: true,
+                                    semi: true,
+                                    trailingComma: 'none',
+                                },
+                            }).then(function (code) {
+                                return code
+                                    .trim()
+                                    .split('\n')
+                                    .map(function (line, index) { return "".concat(index === 0 ? '' : ' ').concat(line.trim()); })
+                                    .join('')
+                                    .slice("export interface ".concat(interfaceName, " ").length);
+                            })];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
     };
     return TypeScriptClient;
 }(client_abstract_class_1.Client));

package/dist/core.js

@@ -122,7 +122,6 @@ var HerbalController = exports.HerbalController = (function () {
                                 traceId: request.traceId,
                                 transaction: request.transaction,
                                 url: request.originalUrl,
-                                controller: this,
                             })];
                     case 1:
                         result = (_e.data = _f.sent(),
@@ -165,7 +164,7 @@ var HerbalController = exports.HerbalController = (function () {
                         callFn = (_b = (_a = controller_util_class_1.ControllerUtil.getPool(this)) === null || _a === void 0 ? void 0 : _a.getCallFn) === null || _b === void 0 ? void 0 : _b.call(_a, name);
                         if (typeof callFn !== 'function')
                             throw new common_1.NotFoundException("Method ".concat(name, " not found"));
-                        return [4, callFn(context)];
+                        return [4, callFn(this, context)];
                     case 1: return [2, _c.sent()];
                 }
             });

package/dist/utilities/controller-util.class.d.ts

@@ -16,25 +16,24 @@ export interface MethodRegisterOptions<IS extends z.Schema<any>, OS extends z.Sc
     disableTransaction?: boolean;
 }
 export type MethodRegisterFn<C> = <IS extends z.Schema<any>, OS extends z.Schema<any>>(name: string, options: MethodRegisterOptions<IS, OS>, callback: MethodCallback<IS, OS, C>) => void;
-export interface MethodContext<IS extends z.Schema<any>, C> extends RequestContext {
-    controller: C;
+export interface MethodContext<IS extends z.Schema<any>> extends RequestContext {
     headers: ReturnType<typeof HeaderUtil.parse>;
     input: z.infer<IS>;
     url: string;
 }
-export type MethodCallContext<IS extends z.Schema<any>, C> = Omit<MethodContext<IS, C>, 'input'>;
-export type MethodCallback<IS extends z.Schema<any>, OS extends z.Schema<any>, C> = (context: MethodContext<IS, C>) => Promise<z.infer<OS>>;
+export type MethodCallContext<IS extends z.Schema<any>> = Omit<MethodContext<IS>, 'input'>;
+export type MethodCallback<IS extends z.Schema<any>, OS extends z.Schema<any>, C> = (this: C, context: MethodContext<IS>) => Promise<z.infer<OS>>;
 declare class MethodConfig<IS extends z.Schema<any>, OS extends z.Schema<any>, C> {
     readonly name: string;
     readonly options: MethodRegisterOptions<IS, OS>;
     protected readonly callback: MethodCallback<IS, OS, C>;
     constructor(name: string, options: MethodRegisterOptions<IS, OS>, callback: MethodCallback<IS, OS, C>);
-    call(callContext: MethodCallContext<IS, C>): Promise<z.TypeOf<OS>>;
+    call(controller: C, callContext: MethodCallContext<IS>): Promise<z.TypeOf<OS>>;
 }
 declare class MethodPool {
     protected readonly methods: Map<string, MethodConfig<any, any, any>>;
     registerMethod<IS extends z.Schema<any>, OS extends z.Schema<any>, C>(name: string, options: MethodRegisterOptions<IS, OS>, callback: MethodCallback<IS, OS, C>): void;
-    getCallFn(name: string): ((callContext: MethodCallContext<any, any>) => Promise<any>) | null;
+    getCallFn(name: string): ((controller: any, callContext: MethodCallContext<any>) => Promise<any>) | null;
     getAuthAdapters(name: string): Constructor<AuthAdapter>[] | null | undefined;
     getOpenAPIPathsObject(group?: string): PathsObject;
 }
@@ -54,7 +53,7 @@ export interface ControllerUtilCreateOptions {
 export declare class ControllerUtil {
     static getPool(targetPrototype: object): MethodPool | null;
     static create(createOptions?: ControllerUtilCreateOptions): {
-        <C>(options: HerbalControllerOptions<C>): ClassDecorator;
+        <C>(options?: HerbalControllerOptions<C> | undefined): ClassDecorator;
         isHerbalController: typeof isHerbalController;
         getControllerName: typeof getControllerName;
     };

package/dist/utilities/controller-util.class.js

@@ -96,7 +96,7 @@ var MethodConfig = (function () {
         this.options = options;
         this.callback = callback;
     }
-    MethodConfig.prototype.call = function (callContext) {
+    MethodConfig.prototype.call = function (controller, callContext) {
         var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function () {
             var inputSchema, outputSchema, parsedBody_1, input, rawResponse_1, response, error_1;
@@ -118,7 +118,7 @@ var MethodConfig = (function () {
                         }
                         else if (input instanceof Error)
                             throw input;
-                        return [4, this.callback(__assign(__assign({}, callContext), { input: input }))];
+                        return [4, this.callback.call(controller, __assign(__assign({}, callContext), { input: input }))];
                     case 2:
                         rawResponse_1 = _g.sent();
                         response = _.attempt(function () { return outputSchema.parse(rawResponse_1); });
@@ -174,6 +174,8 @@ var MethodPool = (function () {
             var clientGroups = typeof config.options.clientGroups === 'function'
                 ? config.options.clientGroups(defaultGroupName)
                 : (_b = config === null || config === void 0 ? void 0 : config.options) === null || _b === void 0 ? void 0 : _b.clientGroups;
+            if (!Array.isArray(clientGroups) && !string_util_class_1.StringUtil.isFalsyString(group) && defaultGroupName !== group)
+                return;
             if (Array.isArray(clientGroups) && !clientGroups.includes(currentGroupName))
                 return;
             result["/".concat(name)] = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@open-norantec/herbal",
-    "version": "1.0.2-alpha.24",
+    "version": "1.0.2-alpha.25",
     "description": "Herbal is a builder and toolchain for Nest.js applications",
     "main": "dist/index.js",
     "scripts": {
@@ -42,6 +42,7 @@
         "@open-norantec/utilities": "latest",
         "commander": "^12.1.0",
         "fs-extra": "^11.3.4",
+        "json-schema-to-typescript": "^15.0.4",
         "lodash": "^4.17.21",
         "nest-winston": "^1.10.2",
         "nj-request-scope": "^1.0.10",