vona 1.0.0 → 5.0.4

package/dist/lib/module/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extend_1 = require("@cabloy/extend");
+const errorClass_js_1 = require("../bean/resource/error/errorClass.js");
+const ERROR = Symbol('Context#__error');
+function default_1(app, modules) {
+    // all errors
+    const ebErrors = {};
+    // load errors
+    loadErrors();
+    // patch service
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // maybe /favicon.ico
+            if (context.module) {
+                // error
+                context[ERROR] = context.bean._newBean(errorClass_js_1.ErrorClass, ebErrors);
+                // methods
+                ['success', 'fail', 'throw', 'parseFail', 'parseSuccess', 'parseCode'].forEach(key => {
+                    context[key] = function (...args) {
+                        return context[ERROR][key](context.module.info.relativeName, ...args);
+                    };
+                    context[key].module = function (module, ...args) {
+                        return context[ERROR][key](module, ...args);
+                    };
+                });
+            }
+            // createError
+            context.createError = function (data) {
+                return app.meta.util.createError(data);
+            };
+            return context;
+        };
+    }
+    function loadErrors() {
+        for (const key in modules) {
+            const module = modules[key];
+            const ebError = (ebErrors[module.info.relativeName] = {});
+            // module errors
+            if (module.resource.Errors)
+                (0, extend_1.extend)(true, ebError, module.resource.Errors);
+        }
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/module/index.js

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

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

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

package/dist/lib/module/loader.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoader = void 0;
+const meta_js_1 = require("../core/meta.js");
+const module_js_1 = require("./module.js");
+const route_js_1 = __importDefault(require("./route.js"));
+const config_js_1 = __importDefault(require("./config.js"));
+const moduleMeta_js_1 = __importDefault(require("./moduleMeta.js"));
+const locales_js_1 = __importDefault(require("./locales.js"));
+const errors_js_1 = __importDefault(require("./errors.js"));
+const constant_js_1 = __importDefault(require("./constant.js"));
+const messenger_js_1 = __importDefault(require("./messenger.js"));
+const redis_js_1 = __importDefault(require("./redis.js"));
+const queue_js_1 = __importDefault(require("./queue/queue.js"));
+const broadcast_js_1 = __importDefault(require("./broadcast/broadcast.js"));
+const startup_js_1 = __importDefault(require("./startup.js"));
+const schedule_js_1 = __importDefault(require("./schedule.js"));
+const app_js_1 = __importDefault(require("./cluster/app.js"));
+const agent_js_1 = __importDefault(require("./cluster/agent.js"));
+const reload_js_1 = __importDefault(require("./reload/reload.js"));
+const development_js_1 = __importDefault(require("./reload/development.js"));
+const contextPatch_js_1 = __importDefault(require("./contextPatch.js"));
+const index_js_1 = require("./bean/index.js");
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class ModuleLoader extends beanSimple_js_1.BeanSimple {
+    async execute() {
+        const app = this.app;
+        // meta
+        const meta = app.bean._newBean(meta_js_1.AppMeta);
+        app.meta = meta;
+        // messenger
+        (0, messenger_js_1.default)(app);
+        // modules
+        const moduleTools = app.bean._newBean(module_js_1.ModuleTools);
+        // prepare
+        const modules = await moduleTools.prepare();
+        // load modules
+        await moduleTools.load();
+        // monkey modules
+        await moduleTools.monkey('moduleLoading');
+        if (meta.inApp) {
+            await (0, config_js_1.default)(app, modules);
+            await (0, moduleMeta_js_1.default)(app, modules);
+            (0, index_js_1.loadBeans)(app);
+            (0, locales_js_1.default)(app, modules);
+            (0, errors_js_1.default)(app, modules);
+            (0, constant_js_1.default)(app, modules);
+            (0, route_js_1.default)(app, modules);
+            (0, contextPatch_js_1.default)(app);
+            (0, redis_js_1.default)(app);
+            (0, queue_js_1.default)(app, modules);
+            (0, broadcast_js_1.default)(app, modules);
+            (0, startup_js_1.default)(app);
+            (0, schedule_js_1.default)(app);
+            (0, app_js_1.default)(app);
+            (0, reload_js_1.default)(app);
+        }
+        else {
+            await (0, config_js_1.default)(app, modules);
+            await (0, moduleMeta_js_1.default)(app, modules);
+            (0, agent_js_1.default)(app);
+            (0, reload_js_1.default)(app);
+            (0, development_js_1.default)(app);
+        }
+        // monkey modules
+        await moduleTools.monkey('moduleLoaded');
+    }
+}
+exports.ModuleLoader = ModuleLoader;
+//# sourceMappingURL=loader.js.map

package/dist/lib/module/locales.d.ts

@@ -0,0 +1,3 @@
+import { VonaApplication, IModule } from '../../types/index.js';
+export default function (app: VonaApplication, modules: Record<string, IModule>): void;
+//# sourceMappingURL=locales.d.ts.map

package/dist/lib/module/locales.js

@@ -0,0 +1,132 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const localeutil = __importStar(require("@cabloy/localeutil"));
+function default_1(app, modules) {
+    // all locales
+    app.meta.locales = {};
+    app.meta.localeModules = {};
+    // load locales
+    loadLocales();
+    // patch service
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // maybe /favicon.ico
+            if (context.module) {
+                context.text = function (text, ...args) {
+                    return context.meta.locale.getText(undefined, undefined, text, ...args);
+                };
+                context.text.locale = function (locale, text, ...args) {
+                    return context.meta.locale.getText(undefined, locale, text, ...args);
+                };
+            }
+            const __getLocale = context.__getLocale;
+            context.__getLocale = function () {
+                if (context.__locale) {
+                    return context.__locale;
+                }
+                let locale = __getLocale.call(context);
+                const locale2 = context.bean.util.parseTokenSafe(locale);
+                if (locale !== locale2) {
+                    locale = locale2;
+                    context.__setLocale(locale);
+                }
+                return locale;
+            };
+            return context;
+        };
+    }
+    function loadLocales() {
+        /**
+         * based on egg-i18n
+         *
+         * https://github.com/eggjs/egg-i18n/blob/master/app.js
+         *
+         */
+        // project locales
+        const localeDirs = app.config.i18n.dirs;
+        for (let i = 0; i < localeDirs.length; i++) {
+            const dir = localeDirs[i];
+            if (!fs_1.default.existsSync(dir)) {
+                continue;
+            }
+            const names = fs_1.default.readdirSync(dir);
+            for (let j = 0; j < names.length; j++) {
+                const name = names[j];
+                if (path_1.default.extname(name) !== '.js')
+                    continue;
+                const filepath = path_1.default.join(dir, name);
+                // support en_US.js => en-US.js
+                const locale = localeutil.formatLocale(name.split('.')[0]);
+                const resource = require(filepath);
+                _initLocales(locale, resource.default ? resource.default : resource);
+            }
+        }
+        // module locales
+        for (const moduleName in modules) {
+            const module = modules[moduleName];
+            _registerLocales(moduleName, module.resource.locales);
+        }
+    }
+    function _initLocales(locale, locales) {
+        if (!locales)
+            return;
+        if (!locales.modules) {
+            // override
+            app.meta.locales[locale] = Object.assign({}, app.meta.locales[locale], locales);
+        }
+        else {
+            const moduleMap = locales.modules;
+            for (const moduleName in moduleMap) {
+                _registerLocale(moduleName, locale, moduleMap[moduleName]);
+            }
+        }
+    }
+    function _registerLocales(moduleName, locales) {
+        if (!locales)
+            return;
+        for (const locale in locales) {
+            _registerLocale(moduleName, locale, locales[locale]);
+        }
+    }
+    function _registerLocale(moduleName, locale, moduleLocales) {
+        // locales: not override
+        app.meta.locales[locale] = Object.assign({}, moduleLocales, app.meta.locales[locale]);
+        // localeModules
+        if (!app.meta.localeModules[moduleName])
+            app.meta.localeModules[moduleName] = {};
+        app.meta.localeModules[moduleName][locale] = Object.assign({}, moduleLocales, app.meta.localeModules[moduleName][locale]);
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=locales.js.map

package/dist/lib/module/messenger.d.ts

@@ -0,0 +1,25 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+import { VonaApplication } from '../../types/index.js';
+interface IMessengerCallbackContext {
+    name: string;
+    data: any;
+}
+type IMessengerCallback = (info: IMessengerCallbackContext) => void;
+export declare class AppMessenger extends BeanSimple {
+    _providers: object;
+    _pids: any;
+    protected __init__(): void;
+    callAgent(info: any, cb?: IMessengerCallback): void;
+    callRandom(info: any, cb?: IMessengerCallback): void;
+    callTo(pid: any, info: any, cb?: IMessengerCallback): void;
+    callAll(info: any): void;
+    _call(pid: any, info: any, cb?: IMessengerCallback): void;
+    sendToApp(eventName: any, info: any): void;
+    sendTo(pid: any, eventName: any, info: any): void;
+    sendRandom(eventName: any, info: any): void;
+    sendAgent(eventName: any, info: any): void;
+    addProvider(provider: any): void;
+}
+export default function (app: VonaApplication): void;
+export {};
+//# sourceMappingURL=messenger.d.ts.map

package/dist/lib/module/messenger.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppMessenger = void 0;
+const uuid_1 = __importDefault(require("uuid"));
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+const eventMessengerCall = 'eb:event:messengerCall';
+class AppMessenger extends beanSimple_js_1.BeanSimple {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "_providers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "_pids", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    __init__() {
+        const app = this.app;
+        // wait for call
+        app.messenger.on(eventMessengerCall, async (info) => {
+            const provider = this._providers[info.name];
+            let data;
+            let err;
+            try {
+                data = await provider.handler(info.data);
+            }
+            catch (error) {
+                err = app.meta.util.createError(error, true);
+            }
+            if (info.echo) {
+                if (app.meta.inApp) {
+                    this.sendAgent(info.echo, { err, data });
+                }
+                else {
+                    this.sendTo(info.pid, info.echo, { err, data });
+                }
+            }
+        });
+        // in agent
+        if (app.meta.inAgent) {
+            // get pids
+            app.messenger.on('egg-pids', data => {
+                this._pids = data;
+            });
+        }
+    }
+    callAgent(info, cb) {
+        info.pid = process.pid;
+        this._call(null, info, cb);
+    }
+    callRandom(info, cb) {
+        this._call(null, info, cb);
+    }
+    callTo(pid, info, cb) {
+        this._call(pid, info, cb);
+    }
+    callAll(info) {
+        this.sendToApp(eventMessengerCall, info);
+    }
+    // info: { name, data }
+    _call(pid, info, cb) {
+        const app = this.app;
+        if (cb) {
+            info.echo = uuid_1.default.v4();
+            app.messenger.once(info.echo, info => {
+                return cb(info);
+            });
+        }
+        if (app.meta.inApp) {
+            this.sendAgent(eventMessengerCall, info);
+        }
+        else {
+            if (pid) {
+                this.sendTo(pid, eventMessengerCall, info);
+            }
+            else {
+                this.sendRandom(eventMessengerCall, info);
+            }
+        }
+    }
+    sendToApp(eventName, info) {
+        const app = this.app;
+        app.messenger.sendToApp(eventName, info);
+    }
+    sendTo(pid, eventName, info) {
+        const app = this.app;
+        if (app.meta.isTest || !this._pids) {
+            // support init:backend
+            app.messenger.sendToApp(eventName, info);
+        }
+        else {
+            app.messenger.sendTo(pid, eventName, info);
+        }
+    }
+    sendRandom(eventName, info) {
+        const app = this.app;
+        if (app.meta.isTest || !this._pids) {
+            // support init:backend
+            app.messenger.sendToApp(eventName, info);
+        }
+        else {
+            app.messenger.sendRandom(eventName, info);
+        }
+    }
+    sendAgent(eventName, info) {
+        const app = this.app;
+        app.messenger.sendToAgent(eventName, info);
+    }
+    addProvider(provider) {
+        this._providers[provider.name] = provider;
+    }
+}
+exports.AppMessenger = AppMessenger;
+function default_1(app) {
+    // messenger
+    app.meta.messenger = app.bean._newBean(AppMessenger);
+}
+exports.default = default_1;
+//# sourceMappingURL=messenger.js.map

package/dist/lib/module/middleware.d.ts

@@ -0,0 +1,3 @@
+import { VonaApplication } from '../../types/index.js';
+export default function (app: VonaApplication): [object, any[]];
+//# sourceMappingURL=middleware.d.ts.map

package/dist/lib/module/middleware.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deps_1 = require("@cabloy/deps");
+function default_1(app) {
+    // use modulesArray
+    const ebModulesArray = app.meta.modulesArray;
+    // all middlewares
+    app.meta.middlewares = [];
+    const ebMiddlewaresAll = app.meta.middlewares;
+    app.meta.middlewaresNormal = {};
+    const ebMiddlewaresNormal = app.meta.middlewaresNormal;
+    app.meta.middlewaresGlobal = [];
+    const ebMiddlewaresGlobal = app.meta.middlewaresGlobal;
+    app.meta.middlewaresSocketIoConnection = [];
+    const ebMiddlewaresSocketIoConnection = app.meta.middlewaresSocketIoConnection;
+    app.meta.middlewaresSocketIoPacket = [];
+    const ebMiddlewaresSocketIoPacket = app.meta.middlewaresSocketIoPacket;
+    // load middlewares all
+    loadMiddlewaresAll(ebMiddlewaresAll, ebModulesArray, app);
+    // handle dependents
+    handleDependents(ebMiddlewaresAll);
+    // load middlewares
+    loadMiddlewares(ebMiddlewaresAll, ebMiddlewaresNormal, ebMiddlewaresGlobal, ebMiddlewaresSocketIoConnection, ebMiddlewaresSocketIoPacket);
+    return [ebMiddlewaresNormal, ebMiddlewaresGlobal];
+}
+exports.default = default_1;
+function loadMiddlewares(ebMiddlewaresAll, ebMiddlewaresNormal, ebMiddlewaresGlobal, ebMiddlewaresSocketIoConnection, ebMiddlewaresSocketIoPacket) {
+    // load
+    for (const item of ebMiddlewaresAll) {
+        // ignore other types, such as: socketio.connection/socketio.packet
+        const type = item.options.type;
+        if (!type) {
+            // normal
+            ebMiddlewaresNormal[item.name] = item;
+            if (item.options.global) {
+                ebMiddlewaresGlobal.push(item);
+            }
+        }
+        else if (type === 'socketio.connection') {
+            ebMiddlewaresSocketIoConnection.push(item);
+        }
+        else if (type === 'socketio.packet') {
+            ebMiddlewaresSocketIoPacket.push(item);
+        }
+    }
+    // global order
+    swap(ebMiddlewaresGlobal);
+    swap(ebMiddlewaresSocketIoConnection);
+    swap(ebMiddlewaresSocketIoPacket);
+}
+function loadMiddlewaresAll(ebMiddlewaresAll, ebModulesArray, app) {
+    for (const module of ebModulesArray) {
+        const config = app.meta.configs[module.info.relativeName];
+        if (!config.middlewares)
+            continue;
+        for (const middlewareKey in config.middlewares) {
+            const middlewareConfig = config.middlewares[middlewareKey];
+            // bean
+            const beanName = middlewareConfig.bean;
+            if (!beanName)
+                throw new Error(`bean not set for middleware: ${module.info.relativeName}.${middlewareKey}`);
+            let bean;
+            if (typeof beanName === 'string') {
+                bean = {
+                    module: module.info.relativeName,
+                    name: beanName,
+                };
+            }
+            else {
+                bean = {
+                    module: beanName.module || module.info.relativeName,
+                    name: beanName.name,
+                };
+            }
+            // push
+            ebMiddlewaresAll.push({
+                module: module.info.relativeName,
+                name: middlewareKey,
+                options: middlewareConfig,
+                bean,
+            });
+        }
+    }
+}
+function handleDependents(ebMiddlewaresAll) {
+    for (const middleware of ebMiddlewaresAll) {
+        let dependents = middleware.options.dependents;
+        if (!dependents)
+            continue;
+        if (!Array.isArray(dependents)) {
+            dependents = dependents.split(',');
+        }
+        for (const dep of dependents) {
+            const middleware2 = ebMiddlewaresAll.find(item => item.name === dep);
+            if (!middleware2) {
+                throw new Error(`middleware ${dep} not found for dependents of ${middleware.name}`);
+            }
+            const options = middleware2.options;
+            if (!options.dependencies)
+                options.dependencies = [];
+            if (!Array.isArray(options.dependencies)) {
+                options.dependencies = options.dependencies.split(',');
+            }
+            if (options.dependencies.findIndex(item => item === middleware.name) === -1) {
+                options.dependencies.push(middleware.name);
+            }
+        }
+    }
+}
+function swap(middlewares) {
+    (0, deps_1.swapDeps)(middlewares, { name: 'name', dependencies: 'options.dependencies' });
+}
+//# sourceMappingURL=middleware.js.map

package/dist/lib/module/model.d.ts

@@ -0,0 +1,3 @@
+import { CabloyApplication } from '../../types/index.js';
+export default function (app: CabloyApplication): void;
+//# sourceMappingURL=model.d.ts.map

package/dist/lib/module/model.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const beanModelBase_js_1 = require("../bean/resource/model/beanModelBase.js");
+function default_1(app) {
+    // patch model
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // maybe /favicon.ico
+            if (context.module) {
+                context.model = createModelContainer(context, context.module.info.relativeName);
+            }
+            return context;
+        };
+    }
+    function createModelContainer(context, relativeName) {
+        // base
+        const modelContainer = context.bean._newBean(beanModelBase_js_1.BeanModelBase);
+        // module
+        modelContainer.__ebCacheModule = new Map();
+        modelContainer.module = function (moduleName) {
+            let _modelContainer = modelContainer.__ebCacheModule.get(moduleName);
+            if (!_modelContainer) {
+                _modelContainer = createModelContainer(context, moduleName);
+                modelContainer.__ebCacheModule.set(moduleName, _modelContainer);
+            }
+            return _modelContainer;
+        };
+        // proxy
+        return new Proxy(modelContainer, {
+            get(obj, prop) {
+                if (typeof prop === 'symbol')
+                    return obj[prop];
+                // base
+                if (obj[prop])
+                    return obj[prop];
+                const beanFullName = `${relativeName}.model.${prop}`;
+                // model
+                return context.bean._getBean(beanFullName);
+            },
+        });
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,12 @@
+import { IModule } from '../../types/index.js';
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class ModuleTools extends BeanSimple {
+    prepare(): Promise<Record<string, IModule>>;
+    load(): Promise<void>;
+    monkey(monkeyName: any): Promise<void>;
+    private _getModuleIndexPath;
+    private _importModules_serialization;
+    private _importModules_parallelization;
+    private _importModules;
+}
+//# sourceMappingURL=module.d.ts.map