@open-norantec/herbal 1.0.2-alpha.17 → 1.0.2-alpha.19

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

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+import { Constructor } from 'type-fest';
+import { GroupsFactory } from '../decorators/client-groups.decorator';
+import { OpenAPIObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
+export interface CreateClientOptions {
+    Module: Constructor<any>;
+    allowedClientGroupsFactory?: GroupsFactory;
+}
+export declare abstract class Client {
+    readonly options: CreateClientOptions;
+    protected document: OpenAPIObject;
+    constructor(options: CreateClientOptions);
+    abstract generateClientSourceFile(currentGroup?: string): string;
+}

package/dist/abstracts/client.abstract.class.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+require("reflect-metadata");
+var nest_util_class_1 = require("../utilities/nest-util.class");
+var string_util_class_1 = require("@open-norantec/utilities/dist/string-util.class");
+var controller_util_class_1 = require("../utilities/controller-util.class");
+var method_decorator_1 = require("../decorators/method.decorator");
+var Client = (function () {
+    function Client(options) {
+        var _this = this;
+        this.options = options;
+        this.document = {
+            openapi: '3.1.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+            },
+            paths: {},
+        };
+        nest_util_class_1.NestUtil.getControllerClasses(options.Module).forEach(function (Class) {
+            if (string_util_class_1.StringUtil.isFalsyString(Class === null || Class === void 0 ? void 0 : Class.name) || !(0, controller_util_class_1.isHerbalController)(Class))
+                return;
+            var controllerName = (0, controller_util_class_1.getControllerName)(Class);
+            var pool = method_decorator_1.Method.getPool(Class.prototype);
+            if (string_util_class_1.StringUtil.isFalsyString(controllerName) || pool === null)
+                return;
+            Object.entries(pool.getOpenAPIPathsObject()).forEach(function (_a) {
+                var pathname = _a[0], schemas = _a[1];
+                _this.document.paths[["/".concat(controllerName), pathname].join('')] = schemas;
+            });
+        });
+    }
+    return Client;
+}());
+exports.Client = Client;

package/dist/abstracts/index.d.ts

@@ -1 +1,2 @@
 export * from './auth-adapter.abstract.class';
+export * from './client.abstract.class';

package/dist/abstracts/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-adapter.abstract.class"), exports);
+__exportStar(require("./client.abstract.class"), exports);

package/dist/cli/herbal.js

@@ -115,8 +115,7 @@ var createHandleOutputFile = function (disableWriteFile) { return function (file
     }
 }; };
 command
-    .addCommand((0, forge_1.createCommand)({
-    name: 'build',
+    .addCommand((0, forge_1.createCommand)('build', {
     hiddenOptions: ['--watch', '--execute-after-build'],
     onLog: log,
     defaultOptions: function (source, output, options) { return ({
@@ -126,8 +125,7 @@ command
         onOutputFile: createHandleOutputFile(!!(options === null || options === void 0 ? void 0 : options.disableWriteFile)),
     }); },
 }))
-    .addCommand((0, forge_1.createCommand)({
-    name: 'watch',
+    .addCommand((0, forge_1.createCommand)('watch', {
     hiddenOptions: [
         '--watch',
         '--execute-after-build',
@@ -146,51 +144,54 @@ command
         onOutputFile: createHandleOutputFile(true),
     }); },
 }))
-    .addCommand((0, forge_1.createCommand)({
-    name: 'generate-client',
-    onLog: log,
-    hiddenOptions: [
-        '--watch',
-        '--execute-after-build',
-        '--obfuscate',
-        '--obfuscator-config-file <string>',
-        '--disable-write-file',
-    ],
-    defaultOptions: function () { return ({
-        watch: false,
-        executeAfterBuild: false,
-        obfuscate: false,
-        customTransformers: function (program) {
-            return {
-                before: [(0, reflect_declaration_1.transformer)(program)],
-            };
-        },
-        getWatcher: handleGetWatcher,
-        onGetFileContent: handleGetFileContent,
-        onOutputFile: createHandleOutputFile(false),
-        getVirtualEntryFileContent: function (buildEntryFilePath) {
-            return [
-                "const entry = require('".concat(buildEntryFilePath, "')"),
-                "const { Client } = require(\'@open-norantec/herbal\')",
-                'module.exports = () => {',
-                '  let client = entry;',
-                '  if (!(client instanceof Client)) { client = entry?.default; }',
-                "  if (!(client instanceof Client)) return '';",
-                "  try { return client?.generateClientSourceFile?.() ?? ''; } catch { return ''; }",
-                '};',
-            ].join('\n');
-        },
-        rewriteOutputFile: function (code) {
-            try {
-                var generateCodeMethod = requireFromString(code);
-                if (typeof generateCodeMethod !== 'function')
+    .addCommand((0, forge_1.createCommand)('generate-client', function (_a) {
+    var addOption = _a.addOption;
+    addOption('--group', 'Client group name to generate');
+    return {
+        onLog: log,
+        hiddenOptions: [
+            '--watch',
+            '--execute-after-build',
+            '--obfuscate',
+            '--obfuscator-config-file <string>',
+            '--disable-write-file',
+        ],
+        defaultOptions: function (source, output, options) { return ({
+            watch: false,
+            executeAfterBuild: false,
+            obfuscate: false,
+            customTransformers: function (program) {
+                return {
+                    before: [(0, reflect_declaration_1.transformer)(program)],
+                };
+            },
+            getWatcher: handleGetWatcher,
+            onGetFileContent: handleGetFileContent,
+            onOutputFile: createHandleOutputFile(false),
+            getVirtualEntryFileContent: function (buildEntryFilePath) {
+                return [
+                    "const entry = require('".concat(buildEntryFilePath, "')"),
+                    "const { isClient } = require(\'@open-norantec/herbal\')",
+                    'module.exports = () => {',
+                    '  let client = entry;',
+                    '  if (!isClient(client)) { client = entry?.default; }',
+                    "  if (!isClient(client)) return '';",
+                    "  try { return client.instance.generateClientSourceFile() ?? ''; } catch (error) { throw error; }",
+                    '};',
+                ].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 '';
-                return generateCodeMethod();
-            }
-            catch (_a) {
-                return '';
-            }
-        },
-    }); },
+                }
+            },
+        }); },
+    };
 }));
 command.parse(process.argv);

package/dist/clients/index.d.ts

@@ -0,0 +1 @@
+export * from './typescript-client.class';

package/dist/clients/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./typescript-client.class"), exports);

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

@@ -0,0 +1,23 @@
+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 {
+    readonly options: CreateClientOptions;
+    constructor(options: CreateClientOptions);
+    generateClientSourceFile(): string;
+}
+export {};

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

@@ -0,0 +1,375 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        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 __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];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptClient = exports.convertOpenApiToTypescript = void 0;
+require("reflect-metadata");
+var client_abstract_class_1 = require("../abstracts/client.abstract.class");
+var nest_util_class_1 = require("../utilities/nest-util.class");
+var string_util_class_1 = require("@open-norantec/utilities/dist/string-util.class");
+var controller_util_class_1 = require("../utilities/controller-util.class");
+var method_decorator_1 = require("../decorators/method.decorator");
+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 TypeScriptClient = (function (_super) {
+    __extends(TypeScriptClient, _super);
+    function TypeScriptClient(options) {
+        var _this = _super.call(this, options) || this;
+        _this.options = options;
+        return _this;
+    }
+    TypeScriptClient.prototype.generateClientSourceFile = function () {
+        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 = nest_util_class_1.NestUtil.getControllerClasses(options.Module)
+            .reduce(function (result, Class) {
+            if (string_util_class_1.StringUtil.isFalsyString(Class === null || Class === void 0 ? void 0 : Class.name) || !(0, controller_util_class_1.isHerbalController)(Class))
+                return result;
+            var controllerName = (0, controller_util_class_1.getControllerName)(Class);
+            var pool = method_decorator_1.Method.getPool(Class.prototype);
+            if (string_util_class_1.StringUtil.isFalsyString(controllerName) || pool === null)
+                return result;
+            return result.concat(Object.entries(pool.getOpenAPIPathsObject())
+                .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(controllerName).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');
+    };
+    return TypeScriptClient;
+}(client_abstract_class_1.Client));
+exports.TypeScriptClient = TypeScriptClient;

package/dist/core.js

@@ -158,15 +158,14 @@ var HerbalController = exports.HerbalController = (function () {
     HerbalController.prototype.$call = function (name, context) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var methodConfig;
+            var callFn;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        methodConfig = (_b = (_a = decorators_1.Method.getPool(this)) === null || _a === void 0 ? void 0 : _a.getConfig) === null || _b === void 0 ? void 0 : _b.call(_a, name);
-                        if (methodConfig === null || typeof methodConfig === 'undefined') {
+                        callFn = (_b = (_a = decorators_1.Method.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, methodConfig.call(context)];
+                        return [4, callFn(context)];
                     case 1: return [2, _c.sent()];
                 }
             });

package/dist/{create.d.ts → create/create-application.d.ts}

@@ -1,10 +1,8 @@
 import 'reflect-metadata';
 import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
 import { Constructor } from 'type-fest';
-import { GroupsFactory } from './decorators/client-groups.decorator';
 import { CanActivate, ExceptionFilter, INestApplication, NestApplicationOptions, NestInterceptor, PipeTransform, WebSocketAdapter } from '@nestjs/common';
 export type Resolver = <T>(Class: Constructor<T>) => Promise<T>;
-export type TypeCustomizerFn = (dataTypeMapName: string, name: string, genericName: string) => string[];
 export interface CreateApplicationOptions {
     Module: Constructor<any>;
     cors?: CorsOptions | CorsOptionsDelegate<any> | false;
@@ -20,26 +18,10 @@ export interface CreateApplicationOptions {
     onBeforeBootstrap?: () => void | Promise<void>;
     worker?: (resolver: Resolver, listenPort: number) => any;
 }
-export interface CreateClientOptions {
-    Module: Constructor<any>;
-    allowedClientGroupsFactory?: GroupsFactory;
-}
 declare class Application {
     readonly options: CreateApplicationOptions;
     constructor(options: CreateApplicationOptions);
 }
 export declare function isApplication(input: any): boolean;
 export declare function createApplication(options: CreateApplicationOptions): Application;
-export declare abstract class Client {
-    readonly options: CreateClientOptions;
-    constructor(options: CreateClientOptions);
-    abstract generateClientSourceFile(currentGroup?: string): string;
-}
-declare class TypeScriptClient extends Client implements Client {
-    readonly options: CreateClientOptions;
-    constructor(options: CreateClientOptions);
-    generateClientSourceFile(): string;
-}
-export declare function isClient(input: any): boolean;
-export declare function createTypeScriptClient(options: CreateClientOptions): TypeScriptClient;
 export {};

package/dist/create/create-application.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApplication = exports.isApplication = void 0;
+require("reflect-metadata");
+var Application = (function () {
+    function Application(options) {
+        this.options = options;
+    }
+    return Application;
+}());
+function isApplication(input) {
+    return input instanceof Application;
+}
+exports.isApplication = isApplication;
+function createApplication(options) {
+    return new Application(options);
+}
+exports.createApplication = createApplication;

package/dist/create/create-client.d.ts

@@ -0,0 +1,9 @@
+import { Constructor } from 'type-fest';
+import { Client as ClientFactory, CreateClientOptions } from '../abstracts/client.abstract.class';
+declare class Client {
+    readonly instance: ClientFactory;
+    constructor(instance: ClientFactory);
+}
+export declare function isClient(input: any): boolean;
+export declare function createClient(Class: Constructor<ClientFactory>, options: CreateClientOptions): Client;
+export {};

package/dist/create/create-client.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = exports.isClient = void 0;
+var Client = (function () {
+    function Client(instance) {
+        this.instance = instance;
+    }
+    return Client;
+}());
+function isClient(input) {
+    return input instanceof Client;
+}
+exports.isClient = isClient;
+function createClient(Class, options) {
+    return new Client(new Class(options));
+}
+exports.createClient = createClient;

package/dist/create/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-application';
+export * from './create-client';

package/dist/create/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-application"), exports);
+__exportStar(require("./create-client"), exports);

package/dist/decorators/method.decorator.d.ts

@@ -6,6 +6,7 @@ import { HeaderUtil } from '@open-norantec/utilities/dist/header-util.class';
 import { Constructor } from 'type-fest';
 import { Type } from '@nestjs/common';
 import { RequestContext } from '../types';
+import { PathsObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
 export interface MethodOptions<IS extends z.Schema<any>, OS extends z.Schema<any>> {
     inputSchema: IS;
     outputSchema: OS;
@@ -24,7 +25,7 @@ export type MethodCallContext<IS extends z.Schema<any>> = Omit<MethodContext<IS>
 export type MethodCallback<IS extends z.Schema<any>, OS extends z.Schema<any>> = (context: MethodContext<IS>) => Promise<z.infer<OS>>;
 declare class MethodConfig<IS extends z.Schema<any>, OS extends z.Schema<any>> {
     readonly name: string;
-    protected readonly options: MethodOptions<IS, OS>;
+    readonly options: MethodOptions<IS, OS>;
     protected readonly callback: MethodCallback<IS, OS>;
     constructor(name: string, options: MethodOptions<IS, OS>, callback: MethodCallback<IS, OS>);
     call(callContext: MethodCallContext<IS>): Promise<z.TypeOf<OS>>;
@@ -32,7 +33,8 @@ declare class MethodConfig<IS extends z.Schema<any>, OS extends z.Schema<any>> {
 declare class MethodPool {
     protected readonly methods: Map<string, MethodConfig<any, any>>;
     registerMethod<IS extends z.Schema<any>, OS extends z.Schema<any>>(name: string, options: MethodOptions<IS, OS>, callback: MethodCallback<IS, OS>): void;
-    getConfig(name: string): MethodConfig<any, any> | null;
+    getCallFn(name: string): any;
+    getOpenAPIPathsObject(): PathsObject;
 }
 export declare function Method<IS extends z.Schema<any>, OS extends z.Schema<any>>(...parameters: Parameters<typeof MethodPool.prototype.registerMethod<IS, OS>>): ClassDecorator;
 export declare namespace Method {

package/dist/decorators/method.decorator.js

@@ -53,6 +53,7 @@ var zod_1 = require("zod");
 var utilities_1 = require("@open-norantec/utilities");
 var common_1 = require("@nestjs/common");
 var _ = require("lodash");
+var zod_openapi_1 = require("zod-openapi");
 var METHOD_POOL = Symbol();
 var MethodConfig = (function () {
     function MethodConfig(name, options, callback) {
@@ -115,9 +116,41 @@ var MethodPool = (function () {
             throw new Error("Method name cannot contain slashes: ".concat(name));
         this.methods.set(name, new MethodConfig(name, options, callback));
     };
-    MethodPool.prototype.getConfig = function (name) {
-        var config = this.methods.get(name);
-        return config instanceof MethodConfig ? config : null;
+    MethodPool.prototype.getCallFn = function (name) {
+        var _a;
+        var callFn = (_a = this.methods.get(name)) === null || _a === void 0 ? void 0 : _a.call;
+        return typeof callFn === 'function' ? callFn.bind(this) : null;
+    };
+    MethodPool.prototype.getOpenAPIPathsObject = function () {
+        var result = {};
+        Array.from(this.methods.entries()).forEach(function (_a) {
+            var name = _a[0], config = _a[1];
+            result["/".concat(name)] = {
+                post: {
+                    requestBody: {
+                        description: 'Request body for method ' + name,
+                        required: true,
+                        content: {
+                            'application/json': {
+                                schema: (0, zod_openapi_1.createSchema)(config.options.inputSchema).schema,
+                            },
+                        },
+                    },
+                    responses: {
+                        '200': {
+                            description: 'Response for method ' + name,
+                            content: {
+                                'application/json': (0, zod_openapi_1.createSchema)(zod_1.z.object({
+                                    data: config.options.outputSchema,
+                                    token: zod_1.z.string().nullable(),
+                                })),
+                            },
+                        },
+                    },
+                },
+            };
+        });
+        return result;
     };
     return MethodPool;
 }());

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './constants';
 export * from './decorators';
 export * from './utilities';
 export * from '@nestjs/sequelize';
+export * from './clients';
 export { Response } from 'express';
 export { Request } from './types';
 export { LoggerService } from './modules';

package/dist/index.js

@@ -25,5 +25,6 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./utilities"), exports);
 __exportStar(require("@nestjs/sequelize"), exports);
+__exportStar(require("./clients"), exports);
 var modules_1 = require("./modules");
 Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return modules_1.LoggerService; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@open-norantec/herbal",
-    "version": "1.0.2-alpha.17",
+    "version": "1.0.2-alpha.19",
     "description": "Herbal is a builder and toolchain for Nest.js applications",
     "main": "dist/index.js",
     "scripts": {
@@ -38,14 +38,13 @@
         "@nestjs/common": "^10.0.0",
         "@nestjs/core": "^10.4.19",
         "@nestjs/sequelize": "^10.0.1",
-        "@open-norantec/forge": "^2.0.0-alpha.5",
+        "@open-norantec/forge": "^2.0.0-alpha.9",
         "@open-norantec/utilities": "latest",
         "commander": "^12.1.0",
         "fs-extra": "^11.3.4",
         "lodash": "^4.17.21",
         "nest-winston": "^1.10.2",
         "nj-request-scope": "^1.0.10",
-        "openapi-types": "^12.1.3",
         "patch-package": "^8.0.1",
         "reflect-metadata": "^0.2.2",
         "rxjs": "^7.8.2",
@@ -54,7 +53,8 @@
         "type-fest": "^4.41.0",
         "typescript": ">=5.1.0 <5.2.0",
         "uuid": "^11.1.0",
-        "zod": "^3.25.67"
+        "zod": "^3.25.67",
+        "zod-openapi": "4.2.4"
     },
     "devDependencies": {
         "@types/express": "^5.0.3",

package/dist/create.js

@@ -1,205 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypeScriptClient = exports.isClient = exports.Client = exports.createApplication = exports.isApplication = void 0;
-require("reflect-metadata");
-var _ = require("lodash");
-var nest_util_class_1 = require("./utilities/nest-util.class");
-var string_util_class_1 = require("@open-norantec/utilities/dist/string-util.class");
-var reflect_declaration_1 = require("./transformers/reflect-declaration");
-var client_groups_decorator_1 = require("./decorators/client-groups.decorator");
-var controller_util_class_1 = require("./utilities/controller-util.class");
-var Application = (function () {
-    function Application(options) {
-        this.options = options;
-    }
-    return Application;
-}());
-function isApplication(input) {
-    return input instanceof Application;
-}
-exports.isApplication = isApplication;
-function createApplication(options) {
-    return new Application(options);
-}
-exports.createApplication = createApplication;
-var Client = (function () {
-    function Client(options) {
-        this.options = options;
-    }
-    return Client;
-}());
-exports.Client = Client;
-var TypeScriptClient = (function (_super) {
-    __extends(TypeScriptClient, _super);
-    function TypeScriptClient(options) {
-        var _this = _super.call(this, options) || this;
-        _this.options = options;
-        return _this;
-    }
-    TypeScriptClient.prototype.generateClientSourceFile = function () {
-        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 HTTP_RESPONSE_BODY_TYPE_NAME = 'HttpResponseBody';
-        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(HTTP_RESPONSE_BODY_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[T]['response']>>");
-        var methodTypeMapCodeLines = nest_util_class_1.NestUtil.getControllerClasses(options.Module)
-            .reduce(function (result, Class) {
-            if (string_util_class_1.StringUtil.isFalsyString(Class === null || Class === void 0 ? void 0 : Class.name))
-                return result;
-            var controllerName = _.camelCase(Class.name.replace(/Controller$/g, ''));
-            if (string_util_class_1.StringUtil.isFalsyString(controllerName) || !(0, controller_util_class_1.isHerbalController)(Class)) {
-                return result;
-            }
-            var metadataNames = Reflect.getMetadataKeys(Class.prototype).filter(function (metadataName) { return !string_util_class_1.StringUtil.isFalsyString(metadataName); });
-            return result.concat(metadataNames.reduce(function (result, metadataName) {
-                var methodName = metadataName.slice(reflect_declaration_1.DECORATOR_NAME_PREFIX.length);
-                if (string_util_class_1.StringUtil.isFalsyString(metadataName) ||
-                    !metadataName.startsWith(reflect_declaration_1.DECORATOR_NAME_PREFIX) ||
-                    !client_groups_decorator_1.ClientGroups.shouldShowInClient(Class, methodName, function (defaultGroupName) {
-                        var _a;
-                        return (_a = options.allowedClientGroupsFactory) === null || _a === void 0 ? void 0 : _a.call(options, defaultGroupName);
-                    })) {
-                    return result;
-                }
-                var scopeIdentifier = "/".concat(controllerName, "/").concat(methodName);
-                return result.concat(["'".concat(scopeIdentifier, "'"), "".concat(Reflect.getMetadata(metadataName, Class.prototype), ";")].join(': '));
-            }, []));
-        }, [])
-            .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(HTTP_RESPONSE_BODY_TYPE_NAME, "<").concat(METHOD_TYPE_MAP_NAME, "[K]['response']>>;"),
-            '};',
-            "\nexport type ".concat(HTTP_RESPONSE_BODY_TYPE_NAME, "<T> = {"),
-            '  data: T;',
-            '  token: string | null;',
-            '};',
-            "\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');
-    };
-    return TypeScriptClient;
-}(Client));
-function isClient(input) {
-    return input instanceof Client;
-}
-exports.isClient = isClient;
-function createTypeScriptClient(options) {
-    return new TypeScriptClient(options);
-}
-exports.createTypeScriptClient = createTypeScriptClient;