vona 1.0.0 → 5.0.7

package/dist/lib/decorator/interface/useOptions.d.ts

@@ -0,0 +1,14 @@
+import { IBeanRecord, InjectionScope, MetadataKey } from '../../../index.js';
+export interface IDecoratorUseOptionsBase {
+    prop: MetadataKey;
+    beanFullName: string;
+    /** such as: moduleScope */
+    selector?: string;
+    injectionScope?: InjectionScope;
+}
+export interface IDecoratorUseOptions {
+    beanFullName?: keyof IBeanRecord;
+    selector?: string;
+    injectionScope?: InjectionScope;
+}
+//# sourceMappingURL=useOptions.d.ts.map

package/dist/lib/decorator/interface/useOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=useOptions.js.map

package/dist/lib/decorator/type/constructable.d.ts

@@ -0,0 +1,2 @@
+export type Constructable<T = unknown> = new (...args: any[]) => T;
+//# sourceMappingURL=constructable.d.ts.map

package/dist/lib/decorator/type/constructable.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=constructable.js.map

package/dist/lib/decorator/type/containerScope.d.ts

@@ -0,0 +1,2 @@
+export type ContainerScope = 'app' | 'ctx' | 'new';
+//# sourceMappingURL=containerScope.d.ts.map

package/dist/lib/decorator/type/containerScope.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=containerScope.js.map

package/dist/lib/decorator/type/injectionScope.d.ts

@@ -0,0 +1,2 @@
+export type InjectionScope = 'app' | 'ctx' | 'new';
+//# sourceMappingURL=injectionScope.d.ts.map

package/dist/lib/decorator/type/injectionScope.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=injectionScope.js.map

package/dist/lib/error/error.d.ts

@@ -0,0 +1,18 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class ErrorClass extends BeanSimple {
+    ebErrors: any;
+    constructor(ebErrors: any);
+    success(module: any, data: any, code: any, ...args: any[]): void;
+    fail(module: any, code: any, ...args: any[]): void;
+    throw(module: any, code: any, ...args: any[]): void;
+    parseFail(module: any, code: any, ...args: any[]): any;
+    parseSuccess(module: any, code: any, ...args: any[]): {
+        code: any;
+        message: null;
+    };
+    parseCode(module: any, codeDefault: any, code: any, ...args: any[]): {
+        code: any;
+        message: null;
+    };
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/lib/error/error.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorClass = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class ErrorClass extends beanSimple_js_1.BeanSimple {
+    constructor(ebErrors) {
+        super();
+        this.ebErrors = ebErrors;
+    }
+    // data,code/message,args
+    success(module, data, code, ...args) {
+        const body = this.parseSuccess(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: 0, message: body.message, data };
+    }
+    // code/message,args
+    fail(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: body.code, message: body.message }; // body maybe Error
+    }
+    // code/message,args
+    throw(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        const err = new Error();
+        err.code = body.code;
+        err.message = body.message;
+        if (body.code < 500)
+            err.status = body.code;
+        throw err;
+    }
+    // code/message,args
+    parseFail(module, code, ...args) {
+        if (typeof code === 'object')
+            return code;
+        return this.parseCode(module, 1, code, ...args);
+    }
+    // code/message,args
+    parseSuccess(module, code, ...args) {
+        return this.parseCode(module, 0, code, ...args);
+    }
+    // parseCode
+    parseCode(module, codeDefault, code, ...args) {
+        const ebError = this.ebErrors[module];
+        let message = null;
+        if (code === undefined || code === null || code === '') {
+            code = codeDefault;
+        }
+        else if (typeof code === 'string') {
+            message = this.ctx.text(code, ...args);
+            code = codeDefault;
+        }
+        else {
+            message = this.ctx.text(ebError[code], ...args);
+        }
+        if (!message) {
+            message = this.ctx.text(ebError[codeDefault]);
+        }
+        code = __combineErrorCode(module, code);
+        return { code, message };
+    }
+}
+exports.ErrorClass = ErrorClass;
+function __combineErrorCode(module, code) {
+    if (typeof code !== 'number' || code <= 1000)
+        return code;
+    return module ? `${module}:${code}` : code;
+}
+//# sourceMappingURL=error.js.map

package/dist/lib/error/errorClass.d.ts

@@ -0,0 +1,18 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+export declare class ErrorClass extends BeanSimple {
+    ebErrors: any;
+    constructor(ebErrors: any);
+    success(module: any, data: any, code: any, ...args: any[]): void;
+    fail(module: any, code: any, ...args: any[]): void;
+    throw(module: any, code: any, ...args: any[]): never;
+    parseFail(module: any, code: any, ...args: any[]): any;
+    parseSuccess(module: any, code: any, ...args: any[]): {
+        code: any;
+        message: string;
+    };
+    parseCode(module: any, codeDefault: any, code: any, ...args: any[]): {
+        code: any;
+        message: string;
+    };
+}
+//# sourceMappingURL=errorClass.d.ts.map

package/dist/lib/error/errorClass.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorClass = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+const errorInternal_js_1 = require("./errorInternal.js");
+class ErrorClass extends beanSimple_js_1.BeanSimple {
+    constructor(ebErrors) {
+        super();
+        this.ebErrors = ebErrors;
+    }
+    // data,code/message,args
+    success(module, data, code, ...args) {
+        const body = this.parseSuccess(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: 0, message: body.message, data };
+    }
+    // code/message,args
+    fail(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: body.code, message: body.message }; // body maybe Error
+    }
+    // code/message,args
+    throw(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        const err = new Error();
+        err.code = body.code;
+        err.message = body.message;
+        if (body.code < 500)
+            err.status = body.code;
+        throw err;
+    }
+    // code/message,args
+    parseFail(module, code, ...args) {
+        if (typeof code === 'object')
+            return code;
+        return this.parseCode(module, 1, code, ...args);
+    }
+    // code/message,args
+    parseSuccess(module, code, ...args) {
+        return this.parseCode(module, 0, code, ...args);
+    }
+    // parseCode
+    parseCode(module, codeDefault, code, ...args) {
+        const ebError = this.ebErrors[module];
+        // convert from enum
+        if (code && typeof code === 'string') {
+            code = ebError[code];
+        }
+        if (code === undefined || code === null || code === '') {
+            code = codeDefault;
+        }
+        let message;
+        if (code <= 1000) {
+            message = this.ctx.text(errorInternal_js_1.errorsInternal[code], ...args);
+        }
+        else {
+            message = this.ctx.text(ebError[code], ...args);
+        }
+        code = __combineErrorCode(module, code);
+        return { code, message };
+    }
+}
+exports.ErrorClass = ErrorClass;
+function __combineErrorCode(module, code) {
+    if (typeof code !== 'number' || code <= 1000)
+        return code;
+    return module ? `${module}:${code}` : code;
+}
+//# sourceMappingURL=errorClass.js.map

package/dist/lib/error/errorContext.d.ts

@@ -0,0 +1,38 @@
+import { IErrorObject } from './errorObject.js';
+type TypeErrorMethodNames = 'parseFail' | 'parseSuccess';
+type TypeErrorMethodCommon = {
+    (code: number | string, ...args: any[]): IErrorObject;
+    module: (moduleName: string, code: number | string, ...args: any[]) => IErrorObject;
+};
+type TypeErrorMethodFail = {
+    (code: number | string, ...args: any[]): void;
+    module: (moduleName: string, code: number | string, ...args: any[]) => void;
+};
+type TypeErrorMethodThrow = {
+    (code: number | string, ...args: any[]): never;
+    module: (moduleName: string, code: number | string, ...args: any[]) => never;
+};
+type TypeErrorMethodSuccess = {
+    (data?: any, ...args: any[]): void;
+    module: (moduleName: string, data: any, ...args: any[]) => void;
+};
+type TypeErrorMethodParseCode = {
+    (codeDefault: number, code: number | string, ...args: any[]): IErrorObject;
+    module: (moduleName: string, codeDefault: number, code: number | string, ...args: any[]) => IErrorObject;
+};
+type TypeErrorMethods = {
+    success: TypeErrorMethodSuccess;
+} & {
+    throw: TypeErrorMethodThrow;
+} & {
+    fail: TypeErrorMethodFail;
+} & {
+    [property in TypeErrorMethodNames]: TypeErrorMethodCommon;
+} & {
+    parseCode: TypeErrorMethodParseCode;
+};
+export interface ContextError extends TypeErrorMethods {
+    createError: (data: object | Error) => Error;
+}
+export {};
+//# sourceMappingURL=errorContext.d.ts.map

package/dist/lib/error/errorContext.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=errorContext.js.map

package/dist/lib/error/errorGlobal.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    export interface Error {
+        code: number | string;
+        status: number | string;
+    }
+}
+export {};
+//# sourceMappingURL=errorGlobal.d.ts.map

package/dist/lib/error/errorGlobal.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=errorGlobal.js.map

package/dist/lib/error/errorInternal.d.ts

@@ -0,0 +1,67 @@
+export declare const errorsInternal: {
+    0: string;
+    1: string;
+    100: string;
+    101: string;
+    102: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    305: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    509: string;
+    510: string;
+    511: string;
+};
+//# sourceMappingURL=errorInternal.d.ts.map

package/dist/lib/error/errorInternal.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorsInternal = void 0;
+exports.errorsInternal = {
+    0: 'Success',
+    1: 'Unknown Error',
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Unordered Collection',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    509: 'Bandwidth Limit Exceeded',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+};
+//# sourceMappingURL=errorInternal.js.map

package/dist/lib/error/errorObject.d.ts

@@ -0,0 +1,5 @@
+export interface IErrorObject {
+    code: number | string;
+    message: string;
+}
+//# sourceMappingURL=errorObject.d.ts.map

package/dist/lib/error/errorObject.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=errorObject.js.map

package/dist/lib/error/index.d.ts

@@ -0,0 +1,5 @@
+export * from './errorClass.js';
+export * from './errorContext.js';
+export * from './errorGlobal.js';
+export * from './errorObject.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/error/index.js

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

package/dist/lib/framework/bootstrap.d.ts

@@ -0,0 +1,9 @@
+import { VonaApplication } from '../../types/index.js';
+export declare class Bootstrap {
+    app: VonaApplication;
+    constructor(app: VonaApplication);
+    loadModules(): Promise<void>;
+    versionReady(): Promise<void>;
+    socketioReady(): Promise<void>;
+}
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/lib/framework/bootstrap.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bootstrap = void 0;
+const index_js_1 = require("../module/bean/index.js");
+const loader_js_1 = require("../module/loader.js");
+const socketio_js_1 = require("../module/socketio.js");
+const ready_js_1 = require("../module/version/ready.js");
+class Bootstrap {
+    constructor(app) {
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.app = app;
+    }
+    async loadModules() {
+        // bean container
+        (0, index_js_1.loadBeanContainer)(this.app);
+        // module loader
+        const moduleLoader = this.app.bean._newBean(loader_js_1.ModuleLoader);
+        await moduleLoader.execute();
+    }
+    async versionReady() {
+        const versionReady = this.app.bean._newBean(ready_js_1.VersionReady);
+        await versionReady.execute();
+    }
+    async socketioReady() {
+        const socketioReady = this.app.bean._newBean(socketio_js_1.SocketioReady);
+        socketioReady.initialize();
+    }
+}
+exports.Bootstrap = Bootstrap;
+//# sourceMappingURL=bootstrap.js.map

package/dist/lib/framework/framework.d.ts

@@ -0,0 +1,11 @@
+import egg from 'egg';
+export { Bootstrap } from './bootstrap.js';
+export { CustomAppWorkerLoader as AppWorkerLoader, CustomAgentWorkerLoader as AgentWorkerLoader } from './loader.js';
+declare const EGG_PATH: unique symbol;
+export declare class Application extends egg.Application {
+    get [EGG_PATH](): string;
+}
+export declare class Agent extends egg.Agent {
+    get [EGG_PATH](): string;
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/lib/framework/framework.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = exports.Application = exports.AgentWorkerLoader = exports.AppWorkerLoader = exports.Bootstrap = void 0;
+const path_1 = __importDefault(require("path"));
+const egg_1 = __importDefault(require("egg"));
+var bootstrap_js_1 = require("./bootstrap.js");
+Object.defineProperty(exports, "Bootstrap", { enumerable: true, get: function () { return bootstrap_js_1.Bootstrap; } });
+var loader_js_1 = require("./loader.js");
+Object.defineProperty(exports, "AppWorkerLoader", { enumerable: true, get: function () { return loader_js_1.CustomAppWorkerLoader; } });
+Object.defineProperty(exports, "AgentWorkerLoader", { enumerable: true, get: function () { return loader_js_1.CustomAgentWorkerLoader; } });
+const EGG_PATH = Symbol.for('egg#eggPath');
+const eggPath = path_1.default.resolve(__dirname, '../..');
+class Application extends egg_1.default.Application {
+    get [EGG_PATH]() {
+        return eggPath;
+    }
+}
+exports.Application = Application;
+class Agent extends egg_1.default.Agent {
+    get [EGG_PATH]() {
+        return eggPath;
+    }
+}
+exports.Agent = Agent;
+//# sourceMappingURL=framework.js.map

package/dist/lib/framework/loader.d.ts

@@ -0,0 +1,24 @@
+import { VonaConfigMeta } from 'vona-shared';
+export declare const CustomAppWorkerLoader: {
+    new (): {
+        [x: string]: any;
+        pkgVona: any;
+        loadConfig(): void;
+        getAppname(): any;
+        _loadAppEnvs(meta: VonaConfigMeta): void;
+        _loadAppConfig(meta: VonaConfigMeta): void;
+    };
+    [x: string]: any;
+};
+export declare const CustomAgentWorkerLoader: {
+    new (): {
+        [x: string]: any;
+        pkgVona: any;
+        loadConfig(): void;
+        getAppname(): any;
+        _loadAppEnvs(meta: VonaConfigMeta): void;
+        _loadAppConfig(meta: VonaConfigMeta): void;
+    };
+    [x: string]: any;
+};
+//# sourceMappingURL=loader.d.ts.map

package/dist/lib/framework/loader.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomAgentWorkerLoader = exports.CustomAppWorkerLoader = void 0;
+const path_1 = __importDefault(require("path"));
+const egg_1 = require("egg");
+const dotenv_1 = require("@cabloy/dotenv");
+const extend_1 = require("@cabloy/extend");
+function createLoaderClass(Base) {
+    return class LoaderClass extends Base {
+        constructor() {
+            super(...arguments);
+            Object.defineProperty(this, "pkgVona", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: null
+            });
+        }
+        loadConfig() {
+            // meta
+            const mode = this.serverEnv;
+            // use process.env.META_FLAVOR for test
+            const meta = {
+                flavor: this.app.options.flavor || process.env.META_FLAVOR || 'normal',
+                mode,
+                mine: 'mine',
+            };
+            // load envs
+            this._loadAppEnvs(meta);
+            // load super config
+            super.loadConfig();
+            // load app config
+            this._loadAppConfig(meta);
+            // subdomainOffset
+            this.app.subdomainOffset = typeof this.config.subdomainOffset === 'undefined' ? 2 : this.config.subdomainOffset;
+        }
+        getAppname() {
+            if (!this.pkgVona) {
+                this.pkgVona = require(path_1.default.join(process.cwd(), 'package.json'));
+                this.pkg.name = this.pkgVona.name;
+            }
+            return this.pkgVona.name;
+        }
+        _loadAppEnvs(meta) {
+            const projectPath = path_1.default.join(this.options.baseDir, '../..');
+            const envDir = path_1.default.join(projectPath, 'env');
+            (0, dotenv_1.loadEnvs)(meta, envDir, '.env');
+        }
+        _loadAppConfig(meta) {
+            const configDir = path_1.default.join(this.options.baseDir, 'config/config');
+            const files = (0, dotenv_1.getEnvFiles)(meta, configDir, 'config', '.js');
+            if (!files)
+                return;
+            const target = this.config;
+            for (const file of files) {
+                const config = this.loadFile(file, this.appInfo);
+                if (config) {
+                    (0, extend_1.extend)(true, target, config);
+                }
+            }
+        }
+    };
+}
+exports.CustomAppWorkerLoader = createLoaderClass(egg_1.AppWorkerLoader);
+exports.CustomAgentWorkerLoader = createLoaderClass(egg_1.AgentWorkerLoader);
+//# sourceMappingURL=loader.js.map

package/dist/lib/framework/meta.d.ts

@@ -0,0 +1,2 @@
+export default function (app: any): any;
+//# sourceMappingURL=meta.d.ts.map