npm - @nestia/sdk - Versions diffs - 2.0.0-dev.20230991 → 2.0.0 - Mend

@nestia/sdk 2.0.0-dev.20230991 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (93) hide show

package/lib/executable/internal/NestiaConfigLoader.js ADDED Viewed

@@ -0,0 +1,582 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestiaConfigLoader = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const WorkerConnector_1 = require("tgrid/protocols/workers/WorkerConnector");
+const ts_node_1 = require("ts-node");
+const tsconfck_1 = require("tsconfck");
+const typescript_1 = __importDefault(require("typescript"));
+const typia_1 = __importDefault(require("typia"));
+var NestiaConfigLoader;
+(function (NestiaConfigLoader) {
+    NestiaConfigLoader.compilerOptions = (project) => __awaiter(this, void 0, void 0, function* () {
+        const configFileName = typescript_1.default.findConfigFile(process.cwd(), typescript_1.default.sys.fileExists, project);
+        if (!configFileName)
+            throw new Error(`unable to find "tsconfig.json" file.`);
+        const { tsconfig } = yield (0, tsconfck_1.parseNative)(configFileName);
+        const configFileText = JSON.stringify(tsconfig);
+        const { config } = typescript_1.default.parseConfigFileTextToJson(configFileName, configFileText);
+        const configParseResult = typescript_1.default.parseJsonConfigFileContent(config, typescript_1.default.sys, path_1.default.dirname(configFileName));
+        const _a = configParseResult.raw.compilerOptions, { moduleResolution } = _a, result = __rest(_a, ["moduleResolution"]);
+        return result;
+    });
+    NestiaConfigLoader.config = (options) => __awaiter(this, void 0, void 0, function* () {
+        if (fs_1.default.existsSync(path_1.default.resolve("nestia.config.ts")) === false)
+            throw new Error(`unable to find "nestia.config.ts" file.`);
+        (0, ts_node_1.register)({
+            emit: false,
+            compilerOptions: options,
+            require: options.baseUrl ? ["tsconfig-paths/register"] : undefined,
+        });
+        const loaded = yield Promise.resolve(`${path_1.default.resolve("nestia.config.ts")}`).then(s => __importStar(require(s)));
+        const config = typeof (loaded === null || loaded === void 0 ? void 0 : loaded.default) === "object" && loaded.default !== null
+            ? loaded.default
+            : loaded;
+        try {
+            return (input => {
+                const __is = input => {
+                    const $io0 = input => (undefined === input.swagger || "object" === typeof input.swagger && null !== input.swagger && $io1(input.swagger)) && (null !== input.input && undefined !== input.input && ("string" === typeof input.input || (Array.isArray(input.input) && input.input.every(elem => "string" === typeof elem) || "object" === typeof input.input && null !== input.input && $io17(input.input)))) && (undefined === input.output || "string" === typeof input.output) && (undefined === input.distribute || "string" === typeof input.distribute) && (undefined === input.simulate || "boolean" === typeof input.simulate) && (undefined === input.e2e || "string" === typeof input.e2e) && (undefined === input.propagate || "boolean" === typeof input.propagate) && (undefined === input.clone || "boolean" === typeof input.clone) && (undefined === input.primitive || "boolean" === typeof input.primitive) && (undefined === input.project || "string" === typeof input.project) && (undefined === input.assert || "boolean" === typeof input.assert) && (undefined === input.json || "boolean" === typeof input.json);
+                    const $io1 = input => "string" === typeof input.output && (undefined === input.info || "object" === typeof input.info && null !== input.info && false === Array.isArray(input.info) && $io2(input.info)) && (undefined === input.servers || Array.isArray(input.servers) && input.servers.every(elem => "object" === typeof elem && null !== elem && $io5(elem))) && (undefined === input.security || "object" === typeof input.security && null !== input.security && false === Array.isArray(input.security) && $io6(input.security)) && (undefined === input.decompose || "boolean" === typeof input.decompose);
+                    const $io2 = input => (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.termsOfService || "string" === typeof input.termsOfService && /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.termsOfService)) && (undefined === input.contact || "object" === typeof input.contact && null !== input.contact && false === Array.isArray(input.contact) && $io3(input.contact)) && (undefined === input.license || "object" === typeof input.license && null !== input.license && $io4(input.license)) && (undefined === input.version || "string" === typeof input.version);
+                    const $io3 = input => (undefined === input.name || "string" === typeof input.name) && (undefined === input.url || "string" === typeof input.url && /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url)) && (undefined === input.email || "string" === typeof input.email && /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test(input.email));
+                    const $io4 = input => "string" === typeof input.name && (undefined === input.url || "string" === typeof input.url && /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url));
+                    const $io5 = input => "string" === typeof input.url && /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url) && (undefined === input.description || "string" === typeof input.description);
+                    const $io6 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        if (RegExp(/(.*)/).test(key))
+                            return "object" === typeof value && null !== value && $iu0(value);
+                        return true;
+                    });
+                    const $io7 = input => "http" === input.type && "basic" === input.scheme;
+                    const $io8 = input => "http" === input.type && "bearer" === input.scheme && (undefined === input.bearerFormat || "string" === typeof input.bearerFormat);
+                    const $io9 = input => "apiKey" === input.type && (undefined === input["in"] || "header" === input["in"] || "query" === input["in"] || "cookie" === input["in"]) && (undefined === input.name || "string" === typeof input.name);
+                    const $io10 = input => "openIdConnect" === input.type && "string" === typeof input.openIdConnectUrl;
+                    const $io11 = input => "oauth2" === input.type && ("object" === typeof input.flows && null !== input.flows && false === Array.isArray(input.flows) && $io12(input.flows)) && (undefined === input.description || "string" === typeof input.description);
+                    const $io12 = input => (undefined === input.authorizationCode || "object" === typeof input.authorizationCode && null !== input.authorizationCode && $io13(input.authorizationCode)) && (undefined === input.implicit || "object" === typeof input.implicit && null !== input.implicit && $io15(input.implicit)) && (undefined === input.password || "object" === typeof input.password && null !== input.password && $io16(input.password)) && (undefined === input.clientCredentials || "object" === typeof input.clientCredentials && null !== input.clientCredentials && $io16(input.clientCredentials));
+                    const $io13 = input => "string" === typeof input.authorizationUrl && "string" === typeof input.tokenUrl && "string" === typeof input.refreshUrl && (undefined === input.scopes || "object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) && $io14(input.scopes));
+                    const $io14 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        if (RegExp(/(.*)/).test(key))
+                            return "string" === typeof value;
+                        return true;
+                    });
+                    const $io15 = input => "string" === typeof input.authorizationUrl && "string" === typeof input.refreshUrl && (undefined === input.scopes || "object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) && $io14(input.scopes));
+                    const $io16 = input => "string" === typeof input.tokenUrl && "string" === typeof input.refreshUrl && (undefined === input.scopes || "object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) && $io14(input.scopes));
+                    const $io17 = input => Array.isArray(input.include) && input.include.every(elem => "string" === typeof elem) && (undefined === input.exclude || Array.isArray(input.exclude) && input.exclude.every(elem => "string" === typeof elem));
+                    const $iu0 = input => (() => {
+                        if ("basic" === input.scheme)
+                            return $io7(input);
+                        else if ("bearer" === input.scheme)
+                            return $io8(input);
+                        else if ("apiKey" === input.type)
+                            return $io9(input);
+                        else if ("openIdConnect" === input.type)
+                            return $io10(input);
+                        else if ("oauth2" === input.type)
+                            return $io11(input);
+                        else
+                            return false;
+                    })();
+                    return "object" === typeof input && null !== input && $io0(input);
+                };
+                if (false === __is(input))
+                    ((input, _path, _exceptionable = true) => {
+                        const $guard = typia_1.default.assert.guard;
+                        const $join = typia_1.default.assert.join;
+                        const $ao0 = (input, _path, _exceptionable = true) => (undefined === input.swagger || ("object" === typeof input.swagger && null !== input.swagger || $guard(_exceptionable, {
+                            path: _path + ".swagger",
+                            expected: "(INestiaConfig.ISwaggerConfig | undefined)",
+                            value: input.swagger
+                        })) && $ao1(input.swagger, _path + ".swagger", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".swagger",
+                            expected: "(INestiaConfig.ISwaggerConfig | undefined)",
+                            value: input.swagger
+                        })) && ((null !== input.input || $guard(_exceptionable, {
+                            path: _path + ".input",
+                            expected: "(Array<string> | INestiaConfig.IInput | string)",
+                            value: input.input
+                        })) && (undefined !== input.input || $guard(_exceptionable, {
+                            path: _path + ".input",
+                            expected: "(Array<string> | INestiaConfig.IInput | string)",
+                            value: input.input
+                        })) && ("string" === typeof input.input || (Array.isArray(input.input) && input.input.every((elem, _index1) => "string" === typeof elem || $guard(_exceptionable, {
+                            path: _path + ".input[" + _index1 + "]",
+                            expected: "string",
+                            value: elem
+                        })) || "object" === typeof input.input && null !== input.input && $ao17(input.input, _path + ".input", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".input",
+                            expected: "(Array<string> | INestiaConfig.IInput | string)",
+                            value: input.input
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".input",
+                            expected: "(Array<string> | INestiaConfig.IInput | string)",
+                            value: input.input
+                        }))) && (undefined === input.output || "string" === typeof input.output || $guard(_exceptionable, {
+                            path: _path + ".output",
+                            expected: "(string | undefined)",
+                            value: input.output
+                        })) && (undefined === input.distribute || "string" === typeof input.distribute || $guard(_exceptionable, {
+                            path: _path + ".distribute",
+                            expected: "(string | undefined)",
+                            value: input.distribute
+                        })) && (undefined === input.simulate || "boolean" === typeof input.simulate || $guard(_exceptionable, {
+                            path: _path + ".simulate",
+                            expected: "(boolean | undefined)",
+                            value: input.simulate
+                        })) && (undefined === input.e2e || "string" === typeof input.e2e || $guard(_exceptionable, {
+                            path: _path + ".e2e",
+                            expected: "(string | undefined)",
+                            value: input.e2e
+                        })) && (undefined === input.propagate || "boolean" === typeof input.propagate || $guard(_exceptionable, {
+                            path: _path + ".propagate",
+                            expected: "(boolean | undefined)",
+                            value: input.propagate
+                        })) && (undefined === input.clone || "boolean" === typeof input.clone || $guard(_exceptionable, {
+                            path: _path + ".clone",
+                            expected: "(boolean | undefined)",
+                            value: input.clone
+                        })) && (undefined === input.primitive || "boolean" === typeof input.primitive || $guard(_exceptionable, {
+                            path: _path + ".primitive",
+                            expected: "(boolean | undefined)",
+                            value: input.primitive
+                        })) && (undefined === input.project || "string" === typeof input.project || $guard(_exceptionable, {
+                            path: _path + ".project",
+                            expected: "(string | undefined)",
+                            value: input.project
+                        })) && (undefined === input.assert || "boolean" === typeof input.assert || $guard(_exceptionable, {
+                            path: _path + ".assert",
+                            expected: "(boolean | undefined)",
+                            value: input.assert
+                        })) && (undefined === input.json || "boolean" === typeof input.json || $guard(_exceptionable, {
+                            path: _path + ".json",
+                            expected: "(boolean | undefined)",
+                            value: input.json
+                        }));
+                        const $ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.output || $guard(_exceptionable, {
+                            path: _path + ".output",
+                            expected: "string",
+                            value: input.output
+                        })) && (undefined === input.info || ("object" === typeof input.info && null !== input.info && false === Array.isArray(input.info) || $guard(_exceptionable, {
+                            path: _path + ".info",
+                            expected: "(Partial<ISwaggerInfo> | undefined)",
+                            value: input.info
+                        })) && $ao2(input.info, _path + ".info", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".info",
+                            expected: "(Partial<ISwaggerInfo> | undefined)",
+                            value: input.info
+                        })) && (undefined === input.servers || (Array.isArray(input.servers) || $guard(_exceptionable, {
+                            path: _path + ".servers",
+                            expected: "(Array<ISwagger.IServer> | undefined)",
+                            value: input.servers
+                        })) && input.servers.every((elem, _index2) => ("object" === typeof elem && null !== elem || $guard(_exceptionable, {
+                            path: _path + ".servers[" + _index2 + "]",
+                            expected: "ISwagger.IServer",
+                            value: elem
+                        })) && $ao5(elem, _path + ".servers[" + _index2 + "]", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".servers[" + _index2 + "]",
+                            expected: "ISwagger.IServer",
+                            value: elem
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".servers",
+                            expected: "(Array<ISwagger.IServer> | undefined)",
+                            value: input.servers
+                        })) && (undefined === input.security || ("object" === typeof input.security && null !== input.security && false === Array.isArray(input.security) || $guard(_exceptionable, {
+                            path: _path + ".security",
+                            expected: "(Record<string, ISwaggerSecurityScheme> | undefined)",
+                            value: input.security
+                        })) && $ao6(input.security, _path + ".security", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".security",
+                            expected: "(Record<string, ISwaggerSecurityScheme> | undefined)",
+                            value: input.security
+                        })) && (undefined === input.decompose || "boolean" === typeof input.decompose || $guard(_exceptionable, {
+                            path: _path + ".decompose",
+                            expected: "(boolean | undefined)",
+                            value: input.decompose
+                        }));
+                        const $ao2 = (input, _path, _exceptionable = true) => (undefined === input.title || "string" === typeof input.title || $guard(_exceptionable, {
+                            path: _path + ".title",
+                            expected: "(string | undefined)",
+                            value: input.title
+                        })) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                            path: _path + ".description",
+                            expected: "(string | undefined)",
+                            value: input.description
+                        })) && (undefined === input.termsOfService || "string" === typeof input.termsOfService && (/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.termsOfService) || $guard(_exceptionable, {
+                            path: _path + ".termsOfService",
+                            expected: "string & Format<url>",
+                            value: input.termsOfService
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".termsOfService",
+                            expected: "((string & Format<url>) | undefined)",
+                            value: input.termsOfService
+                        })) && (undefined === input.contact || ("object" === typeof input.contact && null !== input.contact && false === Array.isArray(input.contact) || $guard(_exceptionable, {
+                            path: _path + ".contact",
+                            expected: "(ISwaggerInfo.IContact | undefined)",
+                            value: input.contact
+                        })) && $ao3(input.contact, _path + ".contact", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".contact",
+                            expected: "(ISwaggerInfo.IContact | undefined)",
+                            value: input.contact
+                        })) && (undefined === input.license || ("object" === typeof input.license && null !== input.license || $guard(_exceptionable, {
+                            path: _path + ".license",
+                            expected: "(ISwaggerInfo.ILicense | undefined)",
+                            value: input.license
+                        })) && $ao4(input.license, _path + ".license", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".license",
+                            expected: "(ISwaggerInfo.ILicense | undefined)",
+                            value: input.license
+                        })) && (undefined === input.version || "string" === typeof input.version || $guard(_exceptionable, {
+                            path: _path + ".version",
+                            expected: "(string | undefined)",
+                            value: input.version
+                        }));
+                        const $ao3 = (input, _path, _exceptionable = true) => (undefined === input.name || "string" === typeof input.name || $guard(_exceptionable, {
+                            path: _path + ".name",
+                            expected: "(string | undefined)",
+                            value: input.name
+                        })) && (undefined === input.url || "string" === typeof input.url && (/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "string & Format<url>",
+                            value: input.url
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "((string & Format<url>) | undefined)",
+                            value: input.url
+                        })) && (undefined === input.email || "string" === typeof input.email && (/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test(input.email) || $guard(_exceptionable, {
+                            path: _path + ".email",
+                            expected: "string & Format<email>",
+                            value: input.email
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".email",
+                            expected: "((string & Format<email>) | undefined)",
+                            value: input.email
+                        }));
+                        const $ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || $guard(_exceptionable, {
+                            path: _path + ".name",
+                            expected: "string",
+                            value: input.name
+                        })) && (undefined === input.url || "string" === typeof input.url && (/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "string & Format<url>",
+                            value: input.url
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "((string & Format<url>) | undefined)",
+                            value: input.url
+                        }));
+                        const $ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.url && (/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test(input.url) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "string & Format<url>",
+                            value: input.url
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".url",
+                            expected: "(string & Format<url>)",
+                            value: input.url
+                        })) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                            path: _path + ".description",
+                            expected: "(string | undefined)",
+                            value: input.description
+                        }));
+                        const $ao6 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                            const value = input[key];
+                            if (undefined === value)
+                                return true;
+                            if (RegExp(/(.*)/).test(key))
+                                return ("object" === typeof value && null !== value || $guard(_exceptionable, {
+                                    path: _path + $join(key),
+                                    expected: "(ISwaggerSecurityScheme.IApiKey | ISwaggerSecurityScheme.IHttpBasic | ISwaggerSecurityScheme.IHttpBearer | ISwaggerSecurityScheme.IOAuth2 | ISwaggerSecurityScheme.IOpenId)",
+                                    value: value
+                                })) && $au0(value, _path + $join(key), true && _exceptionable) || $guard(_exceptionable, {
+                                    path: _path + $join(key),
+                                    expected: "(ISwaggerSecurityScheme.IApiKey | ISwaggerSecurityScheme.IHttpBasic | ISwaggerSecurityScheme.IHttpBearer | ISwaggerSecurityScheme.IOAuth2 | ISwaggerSecurityScheme.IOpenId)",
+                                    value: value
+                                });
+                            return true;
+                        });
+                        const $ao7 = (input, _path, _exceptionable = true) => ("http" === input.type || $guard(_exceptionable, {
+                            path: _path + ".type",
+                            expected: "\"http\"",
+                            value: input.type
+                        })) && ("basic" === input.scheme || $guard(_exceptionable, {
+                            path: _path + ".scheme",
+                            expected: "\"basic\"",
+                            value: input.scheme
+                        }));
+                        const $ao8 = (input, _path, _exceptionable = true) => ("http" === input.type || $guard(_exceptionable, {
+                            path: _path + ".type",
+                            expected: "\"http\"",
+                            value: input.type
+                        })) && ("bearer" === input.scheme || $guard(_exceptionable, {
+                            path: _path + ".scheme",
+                            expected: "\"bearer\"",
+                            value: input.scheme
+                        })) && (undefined === input.bearerFormat || "string" === typeof input.bearerFormat || $guard(_exceptionable, {
+                            path: _path + ".bearerFormat",
+                            expected: "(string | undefined)",
+                            value: input.bearerFormat
+                        }));
+                        const $ao9 = (input, _path, _exceptionable = true) => ("apiKey" === input.type || $guard(_exceptionable, {
+                            path: _path + ".type",
+                            expected: "\"apiKey\"",
+                            value: input.type
+                        })) && (undefined === input["in"] || "header" === input["in"] || "query" === input["in"] || "cookie" === input["in"] || $guard(_exceptionable, {
+                            path: _path + "[\"in\"]",
+                            expected: "(\"cookie\" | \"header\" | \"query\" | undefined)",
+                            value: input["in"]
+                        })) && (undefined === input.name || "string" === typeof input.name || $guard(_exceptionable, {
+                            path: _path + ".name",
+                            expected: "(string | undefined)",
+                            value: input.name
+                        }));
+                        const $ao10 = (input, _path, _exceptionable = true) => ("openIdConnect" === input.type || $guard(_exceptionable, {
+                            path: _path + ".type",
+                            expected: "\"openIdConnect\"",
+                            value: input.type
+                        })) && ("string" === typeof input.openIdConnectUrl || $guard(_exceptionable, {
+                            path: _path + ".openIdConnectUrl",
+                            expected: "string",
+                            value: input.openIdConnectUrl
+                        }));
+                        const $ao11 = (input, _path, _exceptionable = true) => ("oauth2" === input.type || $guard(_exceptionable, {
+                            path: _path + ".type",
+                            expected: "\"oauth2\"",
+                            value: input.type
+                        })) && (("object" === typeof input.flows && null !== input.flows && false === Array.isArray(input.flows) || $guard(_exceptionable, {
+                            path: _path + ".flows",
+                            expected: "ISwaggerSecurityScheme.IOAuth2.IFlowSet",
+                            value: input.flows
+                        })) && $ao12(input.flows, _path + ".flows", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".flows",
+                            expected: "ISwaggerSecurityScheme.IOAuth2.IFlowSet",
+                            value: input.flows
+                        })) && (undefined === input.description || "string" === typeof input.description || $guard(_exceptionable, {
+                            path: _path + ".description",
+                            expected: "(string | undefined)",
+                            value: input.description
+                        }));
+                        const $ao12 = (input, _path, _exceptionable = true) => (undefined === input.authorizationCode || ("object" === typeof input.authorizationCode && null !== input.authorizationCode || $guard(_exceptionable, {
+                            path: _path + ".authorizationCode",
+                            expected: "(ISwaggerSecurityScheme.IOAuth2.IFlow | undefined)",
+                            value: input.authorizationCode
+                        })) && $ao13(input.authorizationCode, _path + ".authorizationCode", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".authorizationCode",
+                            expected: "(ISwaggerSecurityScheme.IOAuth2.IFlow | undefined)",
+                            value: input.authorizationCode
+                        })) && (undefined === input.implicit || ("object" === typeof input.implicit && null !== input.implicit || $guard(_exceptionable, {
+                            path: _path + ".implicit",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"tokenUrl\"> | undefined)",
+                            value: input.implicit
+                        })) && $ao15(input.implicit, _path + ".implicit", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".implicit",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"tokenUrl\"> | undefined)",
+                            value: input.implicit
+                        })) && (undefined === input.password || ("object" === typeof input.password && null !== input.password || $guard(_exceptionable, {
+                            path: _path + ".password",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
+                            value: input.password
+                        })) && $ao16(input.password, _path + ".password", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".password",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
+                            value: input.password
+                        })) && (undefined === input.clientCredentials || ("object" === typeof input.clientCredentials && null !== input.clientCredentials || $guard(_exceptionable, {
+                            path: _path + ".clientCredentials",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
+                            value: input.clientCredentials
+                        })) && $ao16(input.clientCredentials, _path + ".clientCredentials", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".clientCredentials",
+                            expected: "(Omit<ISwaggerSecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
+                            value: input.clientCredentials
+                        }));
+                        const $ao13 = (input, _path, _exceptionable = true) => ("string" === typeof input.authorizationUrl || $guard(_exceptionable, {
+                            path: _path + ".authorizationUrl",
+                            expected: "string",
+                            value: input.authorizationUrl
+                        })) && ("string" === typeof input.tokenUrl || $guard(_exceptionable, {
+                            path: _path + ".tokenUrl",
+                            expected: "string",
+                            value: input.tokenUrl
+                        })) && ("string" === typeof input.refreshUrl || $guard(_exceptionable, {
+                            path: _path + ".refreshUrl",
+                            expected: "string",
+                            value: input.refreshUrl
+                        })) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        })) && $ao14(input.scopes, _path + ".scopes", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        }));
+                        const $ao14 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                            const value = input[key];
+                            if (undefined === value)
+                                return true;
+                            if (RegExp(/(.*)/).test(key))
+                                return "string" === typeof value || $guard(_exceptionable, {
+                                    path: _path + $join(key),
+                                    expected: "string",
+                                    value: value
+                                });
+                            return true;
+                        });
+                        const $ao15 = (input, _path, _exceptionable = true) => ("string" === typeof input.authorizationUrl || $guard(_exceptionable, {
+                            path: _path + ".authorizationUrl",
+                            expected: "string",
+                            value: input.authorizationUrl
+                        })) && ("string" === typeof input.refreshUrl || $guard(_exceptionable, {
+                            path: _path + ".refreshUrl",
+                            expected: "string",
+                            value: input.refreshUrl
+                        })) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        })) && $ao14(input.scopes, _path + ".scopes", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        }));
+                        const $ao16 = (input, _path, _exceptionable = true) => ("string" === typeof input.tokenUrl || $guard(_exceptionable, {
+                            path: _path + ".tokenUrl",
+                            expected: "string",
+                            value: input.tokenUrl
+                        })) && ("string" === typeof input.refreshUrl || $guard(_exceptionable, {
+                            path: _path + ".refreshUrl",
+                            expected: "string",
+                            value: input.refreshUrl
+                        })) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        })) && $ao14(input.scopes, _path + ".scopes", true && _exceptionable) || $guard(_exceptionable, {
+                            path: _path + ".scopes",
+                            expected: "(Record<string, string> | undefined)",
+                            value: input.scopes
+                        }));
+                        const $ao17 = (input, _path, _exceptionable = true) => ((Array.isArray(input.include) || $guard(_exceptionable, {
+                            path: _path + ".include",
+                            expected: "Array<string>",
+                            value: input.include
+                        })) && input.include.every((elem, _index3) => "string" === typeof elem || $guard(_exceptionable, {
+                            path: _path + ".include[" + _index3 + "]",
+                            expected: "string",
+                            value: elem
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".include",
+                            expected: "Array<string>",
+                            value: input.include
+                        })) && (undefined === input.exclude || (Array.isArray(input.exclude) || $guard(_exceptionable, {
+                            path: _path + ".exclude",
+                            expected: "(Array<string> | undefined)",
+                            value: input.exclude
+                        })) && input.exclude.every((elem, _index4) => "string" === typeof elem || $guard(_exceptionable, {
+                            path: _path + ".exclude[" + _index4 + "]",
+                            expected: "string",
+                            value: elem
+                        })) || $guard(_exceptionable, {
+                            path: _path + ".exclude",
+                            expected: "(Array<string> | undefined)",
+                            value: input.exclude
+                        }));
+                        const $au0 = (input, _path, _exceptionable = true) => (() => {
+                            if ("basic" === input.scheme)
+                                return $ao7(input, _path, true && _exceptionable);
+                            else if ("bearer" === input.scheme)
+                                return $ao8(input, _path, true && _exceptionable);
+                            else if ("apiKey" === input.type)
+                                return $ao9(input, _path, true && _exceptionable);
+                            else if ("openIdConnect" === input.type)
+                                return $ao10(input, _path, true && _exceptionable);
+                            else if ("oauth2" === input.type)
+                                return $ao11(input, _path, true && _exceptionable);
+                            else
+                                return $guard(_exceptionable, {
+                                    path: _path,
+                                    expected: "(ISwaggerSecurityScheme.IHttpBasic | ISwaggerSecurityScheme.IHttpBearer | ISwaggerSecurityScheme.IApiKey | ISwaggerSecurityScheme.IOpenId | ISwaggerSecurityScheme.IOAuth2)",
+                                    value: input
+                                });
+                        })();
+                        return ("object" === typeof input && null !== input || $guard(true, {
+                            path: _path + "",
+                            expected: "INestiaConfig",
+                            value: input
+                        })) && $ao0(input, _path + "", true) || $guard(true, {
+                            path: _path + "",
+                            expected: "INestiaConfig",
+                            value: input
+                        });
+                    })(input, "$input", true);
+                return input;
+            })(config);
+        }
+        catch (exp) {
+            if ((input => {
+                const $io0 = input => "string" === typeof input.method && (undefined === input.path || "string" === typeof input.path) && "string" === typeof input.expected && true && "string" === typeof input.name && "string" === typeof input.message && (undefined === input.stack || "string" === typeof input.stack);
+                return "object" === typeof input && null !== input && $io0(input);
+            })(exp))
+                exp.message = `invalid "nestia.config.ts" data.`;
+            throw exp;
+        }
+    });
+    NestiaConfigLoader.project = () => __awaiter(this, void 0, void 0, function* () {
+        const connector = new WorkerConnector_1.WorkerConnector(null, null, "process");
+        yield connector.connect(`${__dirname}/nestia.project.getter.${__filename.substr(-2)}`);
+        const driver = yield connector.getDriver();
+        const project = yield driver.get();
+        yield connector.close();
+        return project;
+    });
+})(NestiaConfigLoader || (exports.NestiaConfigLoader = NestiaConfigLoader = {}));
+//# sourceMappingURL=NestiaConfigLoader.js.map

package/lib/executable/internal/NestiaConfigLoader.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"NestiaConfigLoader.js","sourceRoot":"","sources":["../../../src/executable/internal/NestiaConfigLoader.ts"],"names":[],"mappings":"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"}

package/lib/executable/internal/NestiaProjectGetter.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare namespace NestiaProjectGetter {
+    function get(): Promise<string>;
+}

package/lib/executable/internal/NestiaProjectGetter.js ADDED Viewed

@@ -0,0 +1,28 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestiaProjectGetter = void 0;
+const NestiaConfigLoader_1 = require("./NestiaConfigLoader");
+var NestiaProjectGetter;
+(function (NestiaProjectGetter) {
+    function get() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield NestiaConfigLoader_1.NestiaConfigLoader.config({
+                module: "CommonJS",
+                noEmit: true,
+            });
+            return (_a = config.project) !== null && _a !== void 0 ? _a : "tsconfig.json";
+        });
+    }
+    NestiaProjectGetter.get = get;
+})(NestiaProjectGetter || (exports.NestiaProjectGetter = NestiaProjectGetter = {}));
+//# sourceMappingURL=NestiaProjectGetter.js.map