@open-norantec/herbal 1.0.2-alpha.3 → 1.0.2-alpha.31

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

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+import { Constructor } from 'type-fest';
+import { OpenAPIObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
+export interface CreateClientOptions {
+    Module: Constructor<any>;
+}
+export declare abstract class Client {
+    readonly options: CreateClientOptions;
+    protected document: OpenAPIObject;
+    constructor(options: CreateClientOptions);
+    abstract generateClientSourceFile(): Promise<string>;
+    createSchema(group?: string): void;
+}

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

@@ -0,0 +1,39 @@
+"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 Client = (function () {
+    function Client(options) {
+        this.options = options;
+        this.document = {
+            openapi: '3.1.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+            },
+            paths: {},
+        };
+    }
+    Client.prototype.createSchema = function (group) {
+        var _this = this;
+        if (string_util_class_1.StringUtil.isFalsyString(group) && typeof group !== 'undefined')
+            return;
+        nest_util_class_1.NestUtil.getControllerClasses(this.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 = controller_util_class_1.ControllerUtil.getPool(Class.prototype);
+            if (string_util_class_1.StringUtil.isFalsyString(controllerName) || pool === null)
+                return;
+            Object.entries(pool.getOpenAPIPathsObject(group)).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

@@ -1,18 +1,75 @@
 #!/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");
+var _ = require("lodash");
+var fs = require("fs-extra");
+var path = require("node:path");
+var requireFromString = require("require-from-string");
 var command = new commander_1.Command('herbal');
-var getEntryFileContent = function (_a) {
-    var entryFilePath = _a.entryFilePath;
+var log = function (level) {
+    var _a, _b;
+    var messages = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        messages[_i - 1] = arguments[_i];
+    }
+    console.log("[".concat(new Date().toISOString(), "] -").concat(level, "- ").concat((_b = (_a = messages === null || messages === void 0 ? void 0 : messages.join) === null || _a === void 0 ? void 0 : _a.call(messages, ' ')) !== null && _b !== void 0 ? _b : ''));
+    switch (level) {
+        case 'error':
+            process.exit(1);
+        default:
+            break;
+    }
+};
+var handleGetVirtualEntryFileContent = function (buildEntryFilePath) {
     return [
         "import 'reflect-metadata';",
-        "import { ModelUtil, NestFactory } from '@open-norantec/herbal';",
+        "import { ModelUtil, NestFactory, isApplication } from '@open-norantec/herbal';",
         "import { LoggerService } from '@open-norantec/herbal/dist/modules/logger/logger.service';",
         "import { Worker, isMainThread, workerData } from 'node:worker_threads';",
-        "import ENTRY from '".concat(entryFilePath, "';"),
+        "import ENTRY from '".concat(buildEntryFilePath, "';"),
         '\nasync function bootstrap() {',
+        '  if (!isApplication(ENTRY)) {',
+        '    console.log(`The entry file must export an application or a function that returns an application.`);',
+        '    process.exit(1);',
+        '  }',
         '  const entryOptions = ENTRY?.options;',
         '  await entryOptions?.onBeforeBootstrap?.();',
         "\n  if (!!workerData?.['__herbal_worker']) {",
@@ -67,74 +124,113 @@ var getEntryFileContent = function (_a) {
         '\nbootstrap();',
     ].join('\n');
 };
-var getGenerateClientEntryFileContent = function (_a) {
-    var entryFilePath = _a.entryFilePath, outputPath = _a.outputPath, options = _a.options;
-    return [
-        "import 'reflect-metadata';",
-        "import ENTRY from '".concat(entryFilePath, "';"),
-        "import * as fs from 'node:fs';",
-        "import * as path from 'node:path';",
-        '\nasync function bootstrap() {',
-        "  const outputDirPath = '".concat(outputPath, "';"),
-        "  const outputFilePath = path.resolve(outputDirPath, '".concat(options.outputName, ".ts');"),
-        '  await ENTRY?.options?.onBeforeBootstrap?.();',
-        '  try {',
-        '    fs.rmSync(outputFilePath, {',
-        '      recursive: true,',
-        '      force: true,',
-        '    });',
-        '  } catch {}',
-        '  try {',
-        '    if (!fs.statSync(path.dirname(outputDirPath)).isDirectory()) {',
-        '      fs.rmSync(path.dirname(outputDirPath), {',
-        '        recursive: true,',
-        '        force: true,',
-        '      });',
-        '    }',
-        '  } catch {}',
-        '  try {',
-        '    fs.mkdirSync(outputDirPath, { recursive: true });',
-        '  } catch {}',
-        '  fs.writeFileSync(',
-        '    outputFilePath,',
-        '    ENTRY?.generateClientSourceFile?.(),',
-        '  );',
-        '}',
-        '\nbootstrap();',
-    ].join('\n');
-};
-var handleLog = function (level, message) {
-    console.log("[".concat(new Date().toISOString(), "] [").concat(level, "] ").concat(message));
-    switch (level) {
-        case 'error':
-            process.exit(1);
-        default:
-            break;
+var handleGetFileContent = function (filePath) {
+    var content = _.attempt(function () { return fs.readFileSync(filePath, 'utf-8'); });
+    if (content instanceof Error) {
+        log('error', "Failed to read file content for ".concat(filePath, ":"), content.message);
+        return '';
     }
+    return content;
+};
+var handleGetWatcher = function (callback) {
+    var watcher = fs.watch(process.cwd(), { recursive: true }, function (eventType, filename) {
+        callback(path.resolve(filename));
+    });
+    return { close: watcher.close.bind(watcher) };
 };
+var createHandleOutputFile = function (disableWriteFile) { return function (filePath, content) {
+    if (!disableWriteFile) {
+        var dir_1 = path.dirname(filePath);
+        if (!fs.existsSync(dir_1) || !fs.statSync(dir_1).isDirectory()) {
+            _.attempt(function () { return fs.removeSync(dir_1); });
+            _.attempt(function () { return fs.mkdirpSync(dir_1); });
+        }
+        _.attempt(function () { return fs.writeFileSync(filePath, content, 'utf-8'); });
+        log('info', "Generated file: ".concat(filePath));
+    }
+}; };
 command
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler', '--mode'],
-    mode: 'production',
-    afterEmitAction: 'none',
-}).name('build'))
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler'],
-    mode: 'development',
-    afterEmitAction: 'watch',
-}).name('watch'))
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getGenerateClientEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler', '--mode'],
-    mode: 'production',
-    afterEmitAction: 'run-once',
-    tsCompiler: require.resolve('ts-patch/compiler', {
-        paths: [__dirname, process.cwd()],
-    }),
-}).name('generate-client'));
+    .addCommand((0, forge_1.createCommand)('build', {
+    hiddenOptions: ['--watch', '--execute-after-build'],
+    onLog: log,
+    defaultOptions: function (source, output, options) { return ({
+        getWatcher: handleGetWatcher,
+        getVirtualEntryFileContent: handleGetVirtualEntryFileContent,
+        onGetFileContent: handleGetFileContent,
+        onOutputFile: createHandleOutputFile(!!(options === null || options === void 0 ? void 0 : options.disableWriteFile)),
+    }); },
+}))
+    .addCommand((0, forge_1.createCommand)('watch', {
+    hiddenOptions: [
+        '--watch',
+        '--execute-after-build',
+        '--obfuscate',
+        '--obfuscator-config-file <string>',
+        '--disable-write-file',
+    ],
+    onLog: log,
+    defaultOptions: function () { return ({
+        watch: true,
+        executeAfterBuild: true,
+        obfuscate: false,
+        getWatcher: handleGetWatcher,
+        getVirtualEntryFileContent: handleGetVirtualEntryFileContent,
+        onGetFileContent: handleGetFileContent,
+        onOutputFile: createHandleOutputFile(true),
+    }); },
+}))
+    .addCommand((0, forge_1.createCommand)('generate-client', function (_a) {
+    var addOption = _a.addOption;
+    addOption('--group <name>', '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,
+            getWatcher: handleGetWatcher,
+            onGetFileContent: handleGetFileContent,
+            onOutputFile: createHandleOutputFile(false),
+            getVirtualEntryFileContent: function (buildEntryFilePath) {
+                return [
+                    "const entry = require('".concat(buildEntryFilePath, "')"),
+                    "const { isClient } = require(\'@open-norantec/herbal\')",
+                    'module.exports = (context) => {',
+                    '  let client = entry;',
+                    '  if (!isClient(client)) { client = entry?.default; }',
+                    "  if (!isClient(client)) return '';",
+                    '  client.instance.createSchema(context?.group);',
+                    '  return client.instance.generateClientSourceFile();',
+                    '};',
+                ].join('\n');
+            },
+            rewriteOutputFile: function (code) { return __awaiter(void 0, void 0, void 0, function () {
+                var generateCodeMethod, error_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.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, _a.sent()];
+                        case 2:
+                            error_1 = _a.sent();
+                            log('error', "Failed to generate client code:", error_1 instanceof Error ? error_1.message : String(error_1));
+                            return [2, ''];
+                        case 3: return [2];
+                    }
+                });
+            }); },
+        }); },
+    };
+}));
 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,7 @@
+import 'reflect-metadata';
+import { Client, CreateClientOptions } from '../abstracts/client.abstract.class';
+export declare class TypeScriptClient extends Client implements Client {
+    constructor(options: CreateClientOptions);
+    generateClientSourceFile(): Promise<string>;
+    private schemaToTypeScriptLiteral;
+}

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

@@ -0,0 +1,239 @@
+"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 __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 });
+exports.TypeScriptClient = void 0;
+require("reflect-metadata");
+var client_abstract_class_1 = require("../abstracts/client.abstract.class");
+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, _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,
+                                unknownAny: 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('')
+                                    .replace(/^export\s+interface\s+Interface[a-zA-Z0-9-_]+\s+\{/, '{');
+                            })];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    return TypeScriptClient;
+}(client_abstract_class_1.Client));
+exports.TypeScriptClient = TypeScriptClient;

package/dist/core.d.ts

@@ -3,16 +3,11 @@ import { HeaderUtil } from '@open-norantec/utilities/dist/header-util.class';
 import { z } from 'zod';
 import { Request } from './types/request.type';
 export * from '@nestjs/core';
-export interface MethodContext<IS extends z.Schema<any>> {
-    headers: ReturnType<typeof HeaderUtil.parse>;
-    input: z.infer<IS>;
-    request: Request;
-}
 export type MethodHandler<IS extends z.Schema<any>, OS extends z.Schema<any>> = (request: Request, input: unknown, headers: ReturnType<typeof HeaderUtil.parse>) => Promise<{
     request: z.infer<IS>;
     response: z.infer<OS>;
 }>;
 export declare class HerbalController {
-    protected registerMethod: <IS extends z.ZodType<any, z.ZodTypeDef, any>, OS extends z.ZodType<any, z.ZodTypeDef, any>>(inputSchema: IS, outputSchema: OS, callback: (context: MethodContext<IS>) => Promise<z.TypeOf<OS>>) => MethodHandler<IS, OS>;
-    private handler;
+    private $handleRequest;
+    private $call;
 }