vona 1.0.0 → 5.0.4

package/dist/lib/module/startup.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../index.js");
+function default_1(app) {
+    // use modulesArray
+    const ebModulesArray = app.meta.modulesArray;
+    // all startups
+    const ebStartups = (app.meta.startups = {});
+    const ebStartupsArray = (app.meta.startupsArray = []);
+    // load startups
+    loadStartups();
+    function loadStartups() {
+        for (const module of ebModulesArray) {
+            const config = app.meta.configs[module.info.relativeName];
+            if (!config.startups)
+                continue;
+            for (const startupKey in config.startups) {
+                const startupConfig = config.startups[startupKey];
+                const fullKey = `${module.info.relativeName}:${startupKey}`;
+                // bean
+                const beanName = startupConfig.bean;
+                if (!beanName)
+                    throw new Error(`bean not set for startup: ${fullKey}`);
+                let bean;
+                if (typeof beanName === 'string') {
+                    bean = {
+                        module: module.info.relativeName,
+                        name: beanName,
+                    };
+                }
+                else {
+                    bean = {
+                        module: beanName.module || module.info.relativeName,
+                        name: beanName.name,
+                    };
+                }
+                ebStartups[fullKey] = {
+                    key: fullKey,
+                    module: module.info.relativeName,
+                    name: startupKey,
+                    config: startupConfig,
+                    bean,
+                };
+                ebStartupsArray.push(ebStartups[fullKey]);
+            }
+        }
+    }
+    app.meta._runStartup = async ({ module, name, instanceStartup }) => {
+        const fullKey = `${module}:${name}`;
+        const startup = ebStartups[fullKey];
+        // normal
+        if (!startup.config.debounce) {
+            return await _runStartupInner({ startup, instanceStartup });
+        }
+        // debounce: lock
+        const subdomain = instanceStartup ? instanceStartup.subdomain : undefined;
+        return await app.meta.util.lock({
+            subdomain,
+            resource: `${instanceStartup ? 'instanceStartup' : 'startup'}.${fullKey}`,
+            fn: async () => {
+                return await app.meta.util.executeBean({
+                    subdomain,
+                    beanModule: 'a-base',
+                    fn: async ({ ctx }) => {
+                        await _runStartupLock({ ctx, startup, instanceStartup });
+                    },
+                });
+            },
+        });
+    };
+    app.meta._runStartupInstance = async ({ subdomain, options }) => {
+        // run startups: not after
+        for (const startup of app.meta.startupsArray) {
+            if (!startup.config.disable && startup.config.instance && startup.config.after !== true) {
+                console.log(`---- instance startup: ${startup.key}, pid: ${process.pid}`);
+                await app.meta._runStartup({
+                    module: startup.module,
+                    name: startup.name,
+                    instanceStartup: { subdomain, options },
+                });
+            }
+        }
+        // set flag
+        app.meta.appReadyInstances[subdomain] = true;
+        // run startups: after
+        for (const startup of app.meta.startupsArray) {
+            if (!startup.config.disable && startup.config.instance && startup.config.after === true) {
+                console.log(`---- instance startup: ${startup.key}, pid: ${process.pid}`);
+                await app.meta._runStartup({
+                    module: startup.module,
+                    name: startup.name,
+                    instanceStartup: { subdomain, options },
+                });
+            }
+        }
+        // load queue workers
+        if (!app.meta.isTest) {
+            app.meta._loadQueueWorkers({ subdomain });
+        }
+    };
+    async function _runStartupLock({ ctx, startup, instanceStartup }) {
+        // ignore debounce for test
+        const force = instanceStartup && instanceStartup.options && instanceStartup.options.force;
+        if (!force && !ctx.app.meta.isTest) {
+            const fullKey = `${startup.module}:${startup.name}`;
+            const cacheKey = `startupDebounce:${fullKey}${instanceStartup ? `:${ctx.instance.id}` : ''}`;
+            const debounce = typeof startup.config.debounce === 'number' ? startup.config.debounce : ctx.app.config.queue.startup.debounce;
+            const cache = (0, index_js_1.Cast)(ctx.bean).cacheRedis.module('a-base');
+            const flag = await cache.getset(cacheKey, true, debounce);
+            if (flag)
+                return;
+        }
+        // perform
+        await _runStartupInner({ startup, instanceStartup });
+    }
+    async function _runStartupInner({ startup, instanceStartup }) {
+        // context
+        const context = {
+            options: instanceStartup ? instanceStartup.options : undefined,
+        };
+        // bean
+        const bean = startup.bean;
+        // execute
+        return await app.meta.util.executeBean({
+            subdomain: instanceStartup ? instanceStartup.subdomain : undefined,
+            context,
+            beanModule: bean.module,
+            beanFullName: `${bean.module}.startup.${bean.name}`,
+            transaction: startup.config.transaction,
+        });
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=startup.js.map

package/dist/lib/module/version/clear.d.ts

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

package/dist/lib/module/version/clear.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function default_1(app) {
+    if (!app.meta.isTest)
+        return;
+    // clear keys
+    await _clearRedisKeys(app.redis.get('limiter'), `b_${app.name}:*`);
+    await _clearRedisKeys(app.redis.get('queue'), `bull_${app.name}:*`);
+    // broadcast channel has subscribed
+    // await _clearRedisKeys(app.redis.get('broadcast'), `broadcast_${app.name}:*`);
+    await _clearRedisKeys(app.redis.get('cache'), `cache_${app.name}:*`);
+    await _clearRedisKeys(app.redis.get('io'), `io_${app.name}:*`);
+    await _clearRedisKeys(app.redis.get('auth'), `auth_${app.name}:*`);
+    await _clearRedisKeys(app.redis.get('summer'), `summer_${app.name}:*`);
+    // redlock
+    for (const clientName of app.config.queue.redlock.clients) {
+        await _clearRedisKeys(app.redis.get(clientName), `redlock_${app.name}:*`);
+    }
+    // src/backend/app/public
+    await fs_extra_1.default.remove(path_1.default.join(app.options.baseDir, 'app/public/1'));
+}
+exports.default = default_1;
+async function _clearRedisKeys(redis, pattern) {
+    if (!redis)
+        return;
+    const keyPrefix = redis.options.keyPrefix;
+    const keys = await redis.keys(pattern);
+    const keysDel = [];
+    for (const fullKey of keys) {
+        const key = keyPrefix ? fullKey.substr(keyPrefix.length) : fullKey;
+        keysDel.push(key);
+    }
+    if (keysDel.length > 0) {
+        await redis.del(keysDel);
+    }
+}
+//# sourceMappingURL=clear.js.map

package/dist/lib/module/version/ready.d.ts

@@ -0,0 +1,6 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+export declare class VersionReady extends BeanSimple {
+    initialize(): void;
+    execute(): Promise<void>;
+}
+//# sourceMappingURL=ready.d.ts.map

package/dist/lib/module/version/ready.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionReady = void 0;
+const index_js_1 = require("../../../types/index.js");
+const beanSimple_js_1 = require("../../bean/beanSimple.js");
+const clear_js_1 = __importDefault(require("./clear.js"));
+class VersionReady extends beanSimple_js_1.BeanSimple {
+    initialize() {
+        const app = this.app;
+        // checkAppReady
+        app.meta.checkAppReady = async function () {
+            return new Promise((resolve, reject) => {
+                // check once
+                if (app.meta.__versionReady) {
+                    resolve(true);
+                }
+                if (app.meta.__versionReadyError) {
+                    reject(app.meta.__versionReadyError);
+                }
+                // listen
+                app.on(index_js_1.EnumAppEvent.AppReady, () => {
+                    resolve(true);
+                });
+                app.on(index_js_1.EnumAppEvent.AppReadyError, err => {
+                    reject(err);
+                });
+            });
+        };
+    }
+    async execute() {
+        const app = this.app;
+        try {
+            // version ready
+            await _versionReady(app);
+            // record
+            app.meta.__versionReady = true;
+            // event: appReady
+            app.emit(index_js_1.EnumAppEvent.AppReady);
+            // event to agent
+            app.meta.messenger.callAgent({
+                name: 'appReady',
+                data: { pid: process.pid },
+            });
+        }
+        catch (err) {
+            // record
+            app.meta.__versionReadyError = err;
+            // event: appReadyError
+            app.emit(index_js_1.EnumAppEvent.AppReadyError, err);
+            // throw exception
+            throw err;
+        }
+    }
+}
+exports.VersionReady = VersionReady;
+async function _versionReady(app) {
+    // clear keys
+    await (0, clear_js_1.default)(app);
+    // run startups: not after
+    for (const startup of app.meta.startupsArray) {
+        if (!startup.config.disable && !startup.config.instance && startup.config.after !== true) {
+            console.log(`---- startup: ${startup.key}, pid: ${process.pid}`);
+            await app.meta._runStartup({ module: startup.module, name: startup.name });
+        }
+    }
+    // appReady
+    app.meta.appReady = true;
+    app.meta.appReadyInstances = {};
+    // run startups: after
+    for (const startup of app.meta.startupsArray) {
+        if (!startup.config.disable && !startup.config.instance && startup.config.after === true) {
+            console.log(`---- startup: ${startup.key}, pid: ${process.pid}`);
+            await app.meta._runStartup({ module: startup.module, name: startup.name });
+        }
+    }
+    // version init
+    if (app.meta.isTest || app.meta.isLocal) {
+        // subdomain
+        const subdomain = '';
+        // init
+        await app.meta.util.executeBean({
+            subdomain,
+            beanModule: 'a-instance',
+            beanFullName: 'instance',
+            context: { subdomain },
+            fn: 'instanceStartup',
+        });
+    }
+    // version test
+    if (app.meta.isTest) {
+        // subdomain
+        const subdomain = '';
+        // test
+        await app.meta.util.executeBean({
+            subdomain,
+            beanModule: 'a-version',
+            beanFullName: 'a-version.service.version',
+            context: subdomain,
+            fn: '__instanceTest',
+        });
+    }
+}
+//# sourceMappingURL=ready.js.map

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

@@ -0,0 +1,18 @@
+import { BeanSimple } from '../../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/resource/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/resource/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/resource/error/errorContext.js

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

package/dist/lib/resource/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/resource/error/errorGlobal.js

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

package/dist/lib/resource/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/resource/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/resource/error/errorObject.d.ts

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

package/dist/lib/resource/error/errorObject.js

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

package/dist/lib/resource/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/resource/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/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isClass.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/index.js

@@ -0,0 +1,18 @@
+"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("./isClass.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/utils/isClass.d.ts

@@ -0,0 +1,2 @@
+export declare function isClass(fn: any): boolean;
+//# sourceMappingURL=isClass.d.ts.map

package/dist/lib/utils/isClass.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClass = void 0;
+function isClass(fn) {
+    // just check if is function
+    return typeof fn === 'function';
+}
+exports.isClass = isClass;
+// function fnBody(fn) {
+//   return toString
+//     .call(fn)
+//     .replace(/^[^{]*{\s*/, '')
+//     .replace(/\s*}[^}]*$/, '');
+// }
+// export function isClass(fn) {
+//   return (
+//     typeof fn === 'function' && (/^class(?:\s|{)/.test(toString.call(fn)) || /^.*classCallCheck\(/.test(fnBody(fn))) // babel.js
+//   );
+// }
+//# sourceMappingURL=isClass.js.map