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

package/dist/create.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = 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");
-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)) {
-                    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');
-        },
-    };
-}
-exports.create = create;

package/dist/transformers/reflect-declaration.d.ts

@@ -1,3 +0,0 @@
-import * as ts from 'typescript';
-export declare const DECORATOR_NAME_PREFIX = "\u03A6nt:method:";
-export default function transformer(program: ts.Program): ts.TransformerFactory<ts.SourceFile>;

package/dist/transformers/reflect-declaration.js

@@ -1,63 +0,0 @@
-"use strict";
-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.DECORATOR_NAME_PREFIX = void 0;
-var ts = require("typescript");
-exports.DECORATOR_NAME_PREFIX = 'Φnt:method:';
-function transformer(program) {
-    var checker = program.getTypeChecker();
-    return function () {
-        return function (sourceFile) {
-            var newStatements = [];
-            var visitNode = function (node) {
-                var _a;
-                if (ts.isClassDeclaration(node) && node.name) {
-                    var className = node.name.text;
-                    for (var _i = 0, _b = node.members; _i < _b.length; _i++) {
-                        var member = _b[_i];
-                        if (!ts.isPropertyDeclaration(member) || !member.name)
-                            continue;
-                        if (!ts.isIdentifier(member.name))
-                            continue;
-                        var propName = member.name.text;
-                        var symbol = checker.getSymbolAtLocation(member.name);
-                        if (!symbol)
-                            continue;
-                        var type = checker.getTypeOfSymbolAtLocation(symbol, member);
-                        var callSignatures = type.getCallSignatures();
-                        if (callSignatures.length === 0)
-                            continue;
-                        var returnType = callSignatures[0].getReturnType();
-                        var actualType = returnType;
-                        if (((_a = returnType.symbol) === null || _a === void 0 ? void 0 : _a.getName()) === 'Promise') {
-                            var typeArgs = returnType.typeArguments;
-                            if (typeArgs && typeArgs.length > 0) {
-                                actualType = typeArgs[0];
-                            }
-                        }
-                        var actualTypeStr = checker.typeToString(actualType, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType);
-                        if (!actualTypeStr || actualTypeStr === 'void' || actualTypeStr === 'any')
-                            continue;
-                        newStatements.push(ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier('Reflect.defineMetadata'), undefined, [
-                            ts.factory.createStringLiteral("".concat(exports.DECORATOR_NAME_PREFIX).concat(propName)),
-                            ts.factory.createStringLiteral(actualTypeStr),
-                            ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier('prototype')),
-                        ])));
-                    }
-                }
-                ts.forEachChild(node, visitNode);
-            };
-            ts.forEachChild(sourceFile, visitNode);
-            return ts.factory.updateSourceFile(sourceFile, __spreadArray(__spreadArray([], sourceFile.statements, true), newStatements, true));
-        };
-    };
-}
-exports.default = transformer;