@open-norantec/herbal 1.0.2-alpha.0 → 1.0.2-alpha.10

package/dist/cli/herbal.js

@@ -1,18 +1,63 @@
 #!/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 utilities_1 = require("../utilities");
+var _ = require("lodash");
+var fs = require("fs-extra");
+var path = require("node:path");
+var attempt_util_class_1 = require("@open-norantec/utilities/dist/attempt-util.class");
 var command = new commander_1.Command('herbal');
 var getEntryFileContent = function (_a) {
     var entryFilePath = _a.entryFilePath;
     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, "';"),
         '\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,42 +112,6 @@ 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) {
@@ -127,14 +136,45 @@ command
     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((function () {
+    var subCommand = new commander_1.Command('generate-client');
+    subCommand
+        .requiredOption('--entry <entry>', 'The entry file path of the application. It must export an instance generated with `createClient` to default.')
+        .requiredOption('--output-file <path>', 'The output file path of the generated client source file.')
+        .option('--group <group>', 'The group name of the generated client. It is used to distinguish different clients when there are multiple clients in the same application.')
+        .action(function (options) { return __awaiter(void 0, void 0, void 0, function () {
+        var clientUtil;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    clientUtil = _.attempt(function () {
+                        return new utilities_1.ClientUtil(options, function (absoluteOutputFile, content) {
+                            var absoluteOutputDir = path.dirname(absoluteOutputFile);
+                            if (!fs.existsSync(absoluteOutputDir) || !fs.statSync(absoluteOutputDir).isDirectory()) {
+                                _.attempt(function () { return fs.removeSync(absoluteOutputDir); });
+                                _.attempt(function () { return fs.mkdirpSync(absoluteOutputDir); });
+                            }
+                            var writeResult = attempt_util_class_1.AttemptUtil.exec(function () {
+                                return fs.writeFileSync(absoluteOutputFile, content, { encoding: 'utf-8' });
+                            });
+                            if (writeResult instanceof Error) {
+                                handleLog === null || handleLog === void 0 ? void 0 : handleLog('error', "Failed to write client code: ".concat(writeResult.message));
+                                return;
+                            }
+                            handleLog === null || handleLog === void 0 ? void 0 : handleLog('info', "Client code generated successfully at ".concat(absoluteOutputFile));
+                        }, handleLog);
+                    });
+                    if (clientUtil instanceof Error) {
+                        handleLog('error', "Failed to initialize the client utility: ".concat(clientUtil.message));
+                        return [2];
+                    }
+                    return [4, clientUtil.generateClientCode()];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+    return subCommand;
+})());
 command.parse(process.argv);

package/dist/create.d.ts

@@ -1,11 +1,10 @@
 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 CreateOptions {
+export interface CreateApplicationOptions {
     Module: Constructor<any>;
     cors?: CorsOptions | CorsOptionsDelegate<any> | false;
     factoryOptions?: NestApplicationOptions;
@@ -16,12 +15,30 @@ export interface CreateOptions {
     uses?: any[];
     websocketAdapter?: WebSocketAdapter;
     getListenPort: (resolver: Resolver) => number | Promise<number>;
-    allowedClientGroupsFactory?: GroupsFactory;
     callback?: (listenPort: number, app: INestApplication<any>) => void | Promise<void>;
     onBeforeBootstrap?: () => void | Promise<void>;
     worker?: (resolver: Resolver, listenPort: number) => any;
 }
-export declare function create(options: CreateOptions): {
-    options: CreateOptions;
-    generateClientSourceFile: () => string;
-};
+export interface CreateClientOptions {
+    Module: Constructor<any>;
+    allowedClientGroupsFactory?: (currentGroup: string | undefined, defaultGroupName: string) => string[] | null | undefined;
+}
+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(currentGroup?: string): string;
+}
+export declare function isClient(input: any): boolean;
+export declare function createTypeScriptClient(options: CreateClientOptions): TypeScriptClient;
+export {};

package/dist/create.js

@@ -1,6 +1,21 @@
 "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.create = void 0;
+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");
@@ -8,147 +23,183 @@ var string_util_class_1 = require("@open-norantec/utilities/dist/string-util.cla
 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");
-function create(options) {
-    return {
-        options: options,
-        generateClientSourceFile: function () {
-            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)) {
+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 (currentGroup) {
+        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, currentGroup, defaultGroupName);
+                    })) {
                     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, options === null || options === void 0 ? void 0 : options.allowedClientGroupsFactory)) {
-                        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');
-        },
+                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.create = create;
+exports.createTypeScriptClient = createTypeScriptClient;

package/dist/decorators/index.d.ts

@@ -1,2 +1,3 @@
 export * from './auth-adapter.decorator';
 export * from './client-groups.decorator';
+export * from './no-transaction.decorator';

package/dist/decorators/index.js

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

package/dist/decorators/no-transaction.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export declare function NoTransaction(): PropertyDecorator;
+export declare namespace NoTransaction {
+    var isDisabled: (target: object, propertyKey: string) => boolean;
+}

package/dist/decorators/no-transaction.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoTransaction = void 0;
+require("reflect-metadata");
+var _ = require("lodash");
+var TRANSACTION_DISABLED = Symbol();
+function NoTransaction() {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(TRANSACTION_DISABLED, true, target, propertyKey);
+    };
+}
+exports.NoTransaction = NoTransaction;
+NoTransaction.isDisabled = function (target, propertyKey) {
+    var result = _.attempt(function () { return Reflect.getMetadata(TRANSACTION_DISABLED, target, propertyKey); });
+    return result === true;
+};