vona 1.0.0 → 5.0.4

package/dist/lib/framework/metaClass.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_js_1 = require("../base/model.js");
+const beanModuleScopeBase_js_1 = require("../bean/beanModuleScopeBase.js");
+function default_1() {
+    const __classes = {};
+    const classes = new Proxy(__classes, {
+        get(target, prop) {
+            return target[prop];
+        },
+        set(target, prop, value) {
+            // only once
+            if (!target[prop]) {
+                target[prop] = value;
+            }
+            return true;
+        },
+    });
+    // model
+    classes.Model = model_js_1.Model;
+    // BeanModuleScopeBase
+    classes.BeanModuleScopeBase = beanModuleScopeBase_js_1.BeanModuleScopeBase;
+    return classes;
+}
+exports.default = default_1;
+//# sourceMappingURL=metaClass.js.map

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

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

package/dist/lib/framework/moduleInfo.js

@@ -0,0 +1,67 @@
+"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 module_1 = __importDefault(require("module"));
+const ModuleInfo = __importStar(require("@cabloy/module-info"));
+const meta_js_1 = __importDefault(require("./meta.js"));
+let __patched = false;
+function default_1(app) {
+    // only once
+    if (__patched)
+        return;
+    __patched = true;
+    // meta
+    const meta = (0, meta_js_1.default)(app);
+    // compile
+    const Module2 = module_1.default;
+    const originalCompile = Module2.prototype._compile;
+    Module2.prototype._compile = function (...args) {
+        const _module = this;
+        let _moduleInfo;
+        // meta
+        Object.defineProperty(_module, 'meta', {
+            enumerable: false,
+            get() {
+                return meta;
+            },
+        });
+        // info
+        Object.defineProperty(_module, 'info', {
+            enumerable: false,
+            get() {
+                if (!_moduleInfo) {
+                    _moduleInfo = ModuleInfo.parseInfoFromPackage(_module.path);
+                }
+                return _moduleInfo;
+            },
+        });
+        return originalCompile.apply(_module, args);
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=moduleInfo.js.map

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

@@ -0,0 +1,4 @@
+export default function (): {
+    mixinClasses(classMain: any, classesMore: any, ...args: any[]): any;
+};
+//# sourceMappingURL=util.d.ts.map

package/dist/lib/framework/util.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mixin_classes_1 = __importDefault(require("mixin-classes"));
+function default_1() {
+    return {
+        mixinClasses(classMain, classesMore, ...args) {
+            return (0, mixin_classes_1.default)(classMain, classesMore, ...args);
+        },
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=util.js.map

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

@@ -0,0 +1,68 @@
+declare const _default: {
+    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;
+};
+export default _default;
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/module/asset/errors.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    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=errors.js.map

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

@@ -0,0 +1,4 @@
+import { VonaApplication } from '../../../types/index.js';
+export declare function loadBeanContainer(app: VonaApplication): void;
+export declare function loadBeans(app: VonaApplication): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/module/bean/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBeans = exports.loadBeanContainer = void 0;
+const beanContainer_js_1 = require("../../bean/beanContainer.js");
+function loadBeanContainer(app) {
+    app.bean = beanContainer_js_1.BeanContainer.create(app, null);
+}
+exports.loadBeanContainer = loadBeanContainer;
+function loadBeans(app) {
+    // patch context
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // not check context.module
+            // bean
+            context.bean = beanContainer_js_1.BeanContainer.create(app, context);
+            return context;
+        };
+    }
+}
+exports.loadBeans = loadBeans;
+//# sourceMappingURL=index.js.map

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

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

package/dist/lib/module/broadcast/broadcast.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const broadcastClient_js_1 = require("./broadcastClient.js");
+function default_1(app, modules) {
+    // broadcast
+    app.meta.broadcast = app.bean._newBean(broadcastClient_js_1.BroadcastClient);
+    // all broadcasts
+    const ebBroadcasts = (app.meta.broadcasts = {});
+    // load broadcasts
+    loadBroadcasts();
+    function loadBroadcasts() {
+        for (const key in modules) {
+            const module = modules[key];
+            const config = app.meta.configs[module.info.relativeName];
+            if (!config.broadcasts)
+                continue;
+            for (const broadcastKey in config.broadcasts) {
+                const broadcastConfig = config.broadcasts[broadcastKey];
+                const fullKey = `${broadcastConfig.module || module.info.relativeName}:${broadcastKey}`;
+                if (!ebBroadcasts[fullKey])
+                    ebBroadcasts[fullKey] = [];
+                // bean
+                const implementationName = broadcastConfig.bean;
+                if (!implementationName) {
+                    throw new Error(`bean not set for broadcast: ${module.info.relativeName}.${broadcastKey}`);
+                }
+                let bean;
+                if (typeof implementationName === 'string') {
+                    bean = {
+                        module: module.info.relativeName,
+                        name: implementationName,
+                    };
+                }
+                else {
+                    bean = {
+                        module: implementationName.module || module.info.relativeName,
+                        name: implementationName.name,
+                    };
+                }
+                ebBroadcasts[fullKey].push({
+                    bean,
+                    config: broadcastConfig,
+                });
+            }
+        }
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=broadcast.js.map

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

@@ -0,0 +1,24 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+export declare class BroadcastClient extends BeanSimple {
+    __callerId: string;
+    channelName: string | null;
+    sub: any;
+    pub: any;
+    protected __init__(): void;
+    emit(info: any): void;
+    _performTasks({ __callerId, locale, subdomain, module, broadcastName, data }: {
+        __callerId: any;
+        locale: any;
+        subdomain: any;
+        module: any;
+        broadcastName: any;
+        data: any;
+    }): Promise<void>;
+    _performTask({ broadcast, context, locale, subdomain }: {
+        broadcast: any;
+        context: any;
+        locale: any;
+        subdomain: any;
+    }): Promise<any>;
+}
+//# sourceMappingURL=broadcastClient.d.ts.map

package/dist/lib/module/broadcast/broadcastClient.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastClient = void 0;
+const beanSimple_js_1 = require("../../bean/beanSimple.js");
+class BroadcastClient extends beanSimple_js_1.BeanSimple {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "__callerId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "channelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "sub", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pub", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    __init__() {
+        const app = this.app;
+        this.__callerId = app.meta.workerId;
+        this.channelName = `broadcast_${this.app.name}:`;
+        this.pub = app.redis.get('broadcast').duplicate();
+        this.sub = app.redis.get('broadcast').duplicate();
+        this.sub.subscribe(this.channelName, function () { });
+        this.sub.on('message', (_channel, info) => {
+            this._performTasks(JSON.parse(info))
+                .then(() => {
+                // do nothing
+            })
+                .catch(err => {
+                app.logger.error(err);
+            });
+        });
+    }
+    // { locale, subdomain, module, broadcastName, data }
+    emit(info) {
+        info.__callerId = this.__callerId;
+        this.pub.publish(this.channelName, JSON.stringify(info));
+    }
+    async _performTasks({ __callerId, locale, subdomain, module, broadcastName, data }) {
+        const app = this.app;
+        // context
+        const context = { data };
+        if (__callerId === this.__callerId) {
+            context.sameAsCaller = true;
+        }
+        // broadcasts
+        const broadcastArray = app.meta.broadcasts[`${module}:${broadcastName}`];
+        if (!broadcastArray)
+            return;
+        // loop
+        for (const broadcast of broadcastArray) {
+            await this._performTask({ broadcast, context, locale, subdomain });
+        }
+    }
+    async _performTask({ broadcast, context, locale, subdomain }) {
+        const app = this.app;
+        const bean = broadcast.bean;
+        // execute as global when broadcast.config.instance === false
+        // ignore when instance not started
+        const instanceStarted = app.meta.util.instanceStarted(subdomain);
+        if (!instanceStarted && broadcast.config.instance !== false)
+            return;
+        // execute
+        return await app.meta.util.executeBean({
+            locale,
+            subdomain,
+            context,
+            beanModule: bean.module,
+            beanFullName: `${bean.module}.broadcast.${bean.name}`,
+            transaction: broadcast.config.transaction,
+        });
+    }
+}
+exports.BroadcastClient = BroadcastClient;
+//# sourceMappingURL=broadcastClient.js.map

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

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

package/dist/lib/module/cluster/agent.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../../types/index.js");
+function default_1(app) {
+    // ready
+    let _ready = false;
+    const pids = {};
+    // messenger
+    app.meta.messenger.addProvider({
+        name: 'appReady',
+        handler: data => {
+            pids[data.pid] = true;
+            if (!_ready) {
+                _ready = true;
+                // for agent: event: appReady
+                app.emit(index_js_1.EnumAppEvent.AppReady);
+            }
+        },
+    });
+}
+exports.default = default_1;
+//# sourceMappingURL=agent.js.map

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

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

package/dist/lib/module/cluster/app.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ready_js_1 = require("../version/ready.js");
+function default_1(app) {
+    const versionReady = app.bean._newBean(ready_js_1.VersionReady);
+    // initialize
+    versionReady.initialize();
+    // eb_clear
+    app.messenger.once('eb_clear', async (data) => {
+        await app.meta.queue._clearWorkers();
+        process.send({ to: 'master', action: 'eb_clear_done', data: { id: data.id } });
+    });
+}
+exports.default = default_1;
+// maybe cause some resources initialized more times
+// async function __versionReady(app) {
+//   try {
+//     await versionReady(app);
+//   } catch (err) {
+//     console.error(err);
+//     setTimeout(async () => {
+//       await __versionReady(app);
+//     }, app.config.versionReady.retry.timeout);
+//   }
+// }
+//# sourceMappingURL=app.js.map

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

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

package/dist/lib/module/config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extend_1 = require("@cabloy/extend");
+const CTXCONFIG = Symbol.for('Context#__config');
+async function default_1(app, modules) {
+    // all configs
+    app.meta.configs = {};
+    // load configs
+    await loadConfigs();
+    // patch service
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // maybe /favicon.ico
+            if (context.module) {
+                Object.defineProperty(context, 'config', {
+                    enumerable: false,
+                    get() {
+                        // check cache
+                        if (context[CTXCONFIG])
+                            return context[CTXCONFIG];
+                        // get
+                        let useCache;
+                        let _configs = context.bean.instance.getInstanceConfigs();
+                        if (!_configs) {
+                            _configs = app.meta.configs;
+                            useCache = false;
+                        }
+                        else {
+                            useCache = true;
+                        }
+                        const _config = _configs[context.module.info.relativeName];
+                        _config.module = function (moduleName) {
+                            return _configs[moduleName];
+                        };
+                        if (useCache) {
+                            context[CTXCONFIG] = _config;
+                        }
+                        return _config;
+                    },
+                });
+            }
+            return context;
+        };
+    }
+    async function loadConfigs() {
+        for (const key in modules) {
+            const module = modules[key];
+            const ebConfig = (app.meta.configs[module.info.relativeName] = {});
+            // module config
+            if (module.resource.config) {
+                const config = await module.resource.config(app);
+                // configNew is not used by now
+                await app.meta.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'configLoaded', module, config);
+                (0, extend_1.extend)(true, ebConfig, config);
+            }
+            // application config
+            if (app.config.modules && app.config.modules[module.info.relativeName]) {
+                (0, extend_1.extend)(true, ebConfig, app.config.modules[module.info.relativeName]);
+            }
+        }
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=config.js.map

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

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

package/dist/lib/module/constant.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extend_1 = require("@cabloy/extend");
+function default_1(app, modules) {
+    // all constants
+    const ebConstants = (app.meta.constants = {});
+    // load constants
+    loadConstants();
+    // patch service
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            // maybe /favicon.ico
+            if (context.module) {
+                // constant
+                context.constant = ebConstants[context.module.info.relativeName];
+            }
+            return context;
+        };
+    }
+    function loadConstants() {
+        for (const key in modules) {
+            const module = modules[key];
+            const ebConstant = (ebConstants[module.info.relativeName] = {});
+            // module constants
+            if (module.resource.constants)
+                (0, extend_1.extend)(true, ebConstant, module.resource.constants);
+            // patchConstant
+            patchConstant(ebConstant);
+        }
+    }
+    function patchConstant(ebConstant) {
+        Object.defineProperty(ebConstant, 'module', {
+            enumerable: false,
+            get() {
+                return function (moduleName) {
+                    return ebConstants[moduleName];
+                };
+            },
+        });
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=constant.js.map

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

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

package/dist/lib/module/contextPatch.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(app) {
+    // patch context
+    patchCreateContext();
+    function patchCreateContext() {
+        const createContext = app.createContext;
+        app.createContext = (...args) => {
+            const context = createContext.call(app, ...args);
+            app.meta.util.monkeyModule(app.meta.appMonkey, app.meta.modulesArray, 'createContext', undefined, context);
+            return context;
+        };
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=contextPatch.js.map

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

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