vona 1.0.0 → 5.0.7

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

@@ -0,0 +1,16 @@
+import { VonaApplication } from '../../../types/application/app.js';
+import { BeanSimple } from '../../bean/beanSimple.js';
+export declare class AppReload extends BeanSimple {
+    _freezeCounter: number;
+    _needReload: boolean;
+    _reloadDebounceInAgent: any;
+    now(): void;
+    freeze(): void;
+    unfreeze(): void;
+    initialize(): void;
+    _reloadInApp({ action }: any): void;
+    _reloadInAgent({ action }: any): void;
+    _reloadImmediateInAgent(): void;
+}
+export default function (app: VonaApplication): void;
+//# sourceMappingURL=reload.d.ts.map

package/dist/lib/module/reload/reload.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppReload = void 0;
+const debounce_1 = __importDefault(require("debounce"));
+const cast_js_1 = require("../../../types/utils/cast.js");
+const beanSimple_js_1 = require("../../bean/beanSimple.js");
+class AppReload extends beanSimple_js_1.BeanSimple {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "_freezeCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_needReload", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_reloadDebounceInAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    now() {
+        if (this.app.meta.inApp) {
+            this._reloadInApp({ action: 'now' });
+        }
+        else {
+            this._reloadInAgent({ action: 'now' });
+        }
+    }
+    freeze() {
+        if (this.app.meta.inApp) {
+            this._reloadInApp({ action: 'freeze' });
+        }
+        else {
+            this._reloadInAgent({ action: 'freeze' });
+        }
+    }
+    unfreeze() {
+        if (this.app.meta.inApp) {
+            this._reloadInApp({ action: 'unfreeze' });
+        }
+        else {
+            this._reloadInAgent({ action: 'unfreeze' });
+        }
+    }
+    initialize() {
+        if (this.app.meta.inAgent) {
+            //
+            this._freezeCounter = 0;
+            this._needReload = false;
+            this._reloadDebounceInAgent = (0, debounce_1.default)(() => {
+                if (this._freezeCounter === 0 && this._needReload) {
+                    this._needReload = false;
+                    this._reloadImmediateInAgent();
+                }
+            }, 1000);
+            //
+            this.app.meta.messenger.addProvider({
+                name: 'core:reload',
+                handler: info => {
+                    this._reloadInAgent(info);
+                },
+            });
+        }
+    }
+    // invoked in app
+    _reloadInApp({ action }) {
+        this.app.meta.messenger.callAgent({ name: 'core:reload', data: { action } });
+    }
+    // invoked in agent
+    _reloadInAgent({ action }) {
+        if (action === 'now') {
+            if (this._freezeCounter > 0) {
+                this._needReload = true;
+            }
+            else {
+                this._reloadImmediateInAgent();
+            }
+        }
+        else if (action === 'freeze') {
+            this._freezeCounter++;
+        }
+        else if (action === 'unfreeze') {
+            this._freezeCounter--;
+            if (this._freezeCounter === 0 && this._needReload) {
+                this._reloadDebounceInAgent();
+            }
+        }
+    }
+    // invoked in agent
+    _reloadImmediateInAgent() {
+        (0, cast_js_1.Cast)(process).send({
+            to: 'master',
+            action: 'reload-worker',
+        });
+    }
+}
+exports.AppReload = AppReload;
+function default_1(app) {
+    app.meta.reload.initialize();
+}
+exports.default = default_1;
+//# sourceMappingURL=reload.js.map

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

@@ -0,0 +1,7 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class AppReload extends BeanSimple {
+    now(): void;
+    freeze(): void;
+    unfreeze(): void;
+}
+//# sourceMappingURL=reload.d.ts.map

package/dist/lib/module/reload.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppReload = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class AppReload extends beanSimple_js_1.BeanSimple {
+    now() {
+        this.app.meta['a-cms:watcher'].reload({ action: 'now' });
+    }
+    freeze() {
+        this.app.meta['a-cms:watcher'].reload({ action: 'freeze' });
+    }
+    unfreeze() {
+        this.app.meta['a-cms:watcher'].reload({ action: 'unfreeze' });
+    }
+}
+exports.AppReload = AppReload;
+//# sourceMappingURL=reload.js.map

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

@@ -0,0 +1,10 @@
+import { VonaApplication, IModule } from '../../types/index.js';
+import { BeanSimple } from '../bean/beanSimple.js';
+import { IModuleRoute } from '../bean/index.js';
+export declare class AppRouter extends BeanSimple {
+    register(info: any, route: IModuleRoute): void;
+    unRegister(name: any): void;
+    findByPath(moduleName: any, arg: any): any;
+}
+export default function (app: VonaApplication, modules: Record<string, IModule>): void;
+//# sourceMappingURL=route.d.ts.map

package/dist/lib/module/route.js

@@ -0,0 +1,239 @@
+"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 });
+exports.AppRouter = void 0;
+const is_type_of_1 = __importDefault(require("is-type-of"));
+const egg_path_matching_1 = __importDefault(require("egg-path-matching"));
+const ModuleInfo = __importStar(require("@cabloy/module-info"));
+const middleware_js_1 = __importDefault(require("./middleware.js"));
+const index_js_1 = require("../../types/index.js");
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+const MWSTATUS = Symbol('Context#__wmstatus');
+class AppRouter extends beanSimple_js_1.BeanSimple {
+    register(info, route) {
+        // info
+        if (typeof info === 'string') {
+            info = ModuleInfo.parseInfo(info);
+        }
+        // app
+        const app = this.app;
+        // args
+        const args = [];
+        // name:
+        const routeName = route.name;
+        // path
+        const routePath = typeof route.path === 'string' ? app.meta.util.combineFetchPath(info, route.path) : route.path;
+        // route
+        const _route = {
+            pid: info.pid,
+            module: info.name,
+            controller: route.controller,
+            controllerBeanFullName: '',
+            action: '',
+            route,
+        };
+        // constroller
+        if (route.controller) {
+            if (is_type_of_1.default.function(route.controller)) {
+                throw new Error(`Controller should be bean: ${info.relativeName}.${(0, index_js_1.Cast)(route.controller)(app).name}`);
+            }
+            let controllerBeanFullName;
+            if (typeof route.controller === 'string') {
+                controllerBeanFullName = `${info.relativeName}.controller.${route.controller}`;
+            }
+            else {
+                controllerBeanFullName = `${route.controller.module || info.relativeName}.controller.${route.controller.name}`;
+            }
+            _route.controllerBeanFullName = controllerBeanFullName;
+        }
+        // action
+        let action = route.action;
+        if (!action && typeof route.path === 'string') {
+            action = route.path.substring(route.path.lastIndexOf('/') + 1);
+        }
+        _route.action = action || '';
+        // middlewares: start
+        const fnStart = async (ctx, next) => {
+            // status
+            ctx[MWSTATUS] = {};
+            // route
+            ctx.route = _route;
+            // dynamic options
+            ctx.meta.middlewares = {};
+            // next
+            await next();
+            // invoke callbackes: handle secondly
+            await ctx.tailDone();
+        };
+        fnStart._name = 'start';
+        args.push(fnStart);
+        // middlewares: globals
+        app.meta.middlewaresGlobal.forEach(item => {
+            args.push(wrapMiddleware(item));
+        });
+        // middlewares: tailDone
+        const fnTailDone = async (ctx, next) => {
+            // next
+            await next();
+            // invoke callbackes: handle firstly
+            await ctx.tailDone();
+        };
+        fnStart._name = 'tailDone';
+        args.push(fnTailDone);
+        // middlewares: route
+        if (route.middlewares) {
+            let middlewares = route.middlewares;
+            if (typeof middlewares === 'string')
+                middlewares = middlewares.split(',');
+            middlewares.forEach(key => {
+                if (is_type_of_1.default.string(key)) {
+                    const item = app.meta.middlewaresNormal[key];
+                    if (item) {
+                        args.push(wrapMiddleware(item));
+                    }
+                    else {
+                        args.push(wrapMiddlewareApp(key, route, app));
+                    }
+                }
+                else {
+                    args.push(key);
+                }
+            });
+        }
+        // controller
+        if (route.controller) {
+            // middleware controller
+            args.push(methodToMiddleware(_route.controllerBeanFullName, _route));
+        }
+        // load
+        if (routeName) {
+            app.router[route.method](routeName, routePath, ...args);
+        }
+        else {
+            app.router[route.method](routePath, ...args);
+        }
+    }
+    unRegister(name) {
+        const app = this.app;
+        const index = app.router.stack.findIndex(layer => layer.name && layer.name === name);
+        if (index > -1)
+            app.router.stack.splice(index, 1);
+    }
+    findByPath(moduleName, arg) {
+        const app = this.app;
+        const path = app.meta.util.combineFetchPath(moduleName, arg);
+        return app.router.stack.find(layer => layer.path === path);
+    }
+}
+exports.AppRouter = AppRouter;
+function default_1(app, modules) {
+    // load middlewares
+    (0, middleware_js_1.default)(app);
+    // patch router
+    patchRouter();
+    // load routes
+    loadRoutes();
+    function patchRouter() {
+        app.meta.router = app.bean._newBean(AppRouter);
+    }
+    function loadRoutes() {
+        // load routes
+        for (const key in modules) {
+            const module = modules[key];
+            // routes and controllers
+            const routes = module.resource.routes;
+            if (routes) {
+                for (const route of routes) {
+                    app.meta.router.register(module.info, route);
+                }
+            }
+        }
+    }
+}
+exports.default = default_1;
+function wrapMiddlewareApp(key, route, app) {
+    try {
+        const middleware = app.middlewares[key];
+        const optionsRoute = route.meta ? route.meta[key] : null;
+        const mw = middleware(optionsRoute, app);
+        mw._name = key;
+        return mw;
+    }
+    catch (err) {
+        console.log(`\nmiddleware error: ${key}\n`);
+        throw err;
+    }
+}
+function wrapMiddleware(item) {
+    const fn = (ctx, next) => {
+        // options
+        const options = ctx.meta.getMiddlewareOptions(item.name);
+        // enable match ignore dependencies
+        if (options.enable === false || !middlewareMatch(ctx, options) || !middlewareDeps(ctx, options)) {
+            ctx[MWSTATUS][item.name] = false;
+            return next();
+        }
+        // bean
+        const bean = item.bean;
+        // execute
+        const beanFullName = `${bean.module}.middleware.${bean.name}`;
+        const beanInstance = ctx.bean._getBean(beanFullName);
+        if (!beanInstance) {
+            throw new Error(`middleware bean not found: ${beanFullName}`);
+        }
+        return beanInstance.execute(options, next);
+    };
+    fn._name = item.name;
+    return fn;
+}
+function middlewareMatch(ctx, options) {
+    if (!options.match && !options.ignore) {
+        return true;
+    }
+    const match = (0, egg_path_matching_1.default)(options);
+    return match(ctx);
+}
+function middlewareDeps(ctx, options) {
+    let deps = options.dependencies || [];
+    if (typeof deps === 'string')
+        deps = deps.split(',');
+    return deps.every(key => ctx[MWSTATUS][key] !== false);
+}
+function methodToMiddleware(controllerBeanFullName, _route) {
+    return function classControllerMiddleware(...args) {
+        const controller = this.bean._getBean(controllerBeanFullName);
+        if (!controller) {
+            throw new Error(`controller not found: ${controllerBeanFullName}`);
+        }
+        if (!controller[_route.action]) {
+            throw new Error(`controller action not found: ${controllerBeanFullName}.${_route.action}`);
+        }
+        return controller[_route.action](...args);
+    };
+}
+//# sourceMappingURL=route.js.map

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

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

package/dist/lib/module/schedule.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(app) {
+    // all schedules
+    const ebSchedules = (app.meta.schedules = {});
+    // load schedules
+    loadSchedules();
+    function loadSchedules() {
+        for (const module of app.meta.modulesArray) {
+            const config = app.meta.configs[module.info.relativeName];
+            if (!config.schedules)
+                continue;
+            for (const scheduleKey in config.schedules) {
+                const fullKey = `${module.info.relativeName}.${scheduleKey}`;
+                const scheduleConfig = config.schedules[scheduleKey];
+                // bean
+                const beanName = scheduleConfig.bean;
+                if (!beanName)
+                    throw new Error(`bean not set for schedule: ${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,
+                    };
+                }
+                ebSchedules[fullKey] = {
+                    module: module.info.relativeName,
+                    name: scheduleKey,
+                    config: scheduleConfig,
+                    bean,
+                };
+            }
+        }
+    }
+    function __installSchedules({ subdomain }) {
+        for (const fullKey in ebSchedules) {
+            const schedule = ebSchedules[fullKey];
+            if (!schedule.config.disable && schedule.config.repeat) {
+                // push
+                const jobName = __getJobName(subdomain, schedule.module, schedule.name); // not use :
+                app.meta.queue.push({
+                    subdomain,
+                    module: 'a-base',
+                    queueName: 'schedule',
+                    queueNameSub: fullKey,
+                    jobName,
+                    jobOptions: {
+                        // jobId,
+                        repeat: schedule.config.repeat,
+                    },
+                    data: {
+                        subdomain,
+                        module: schedule.module,
+                        name: schedule.name,
+                    },
+                });
+            }
+        }
+    }
+    app.meta._loadSchedules = async ({ ctx }) => {
+        const instances = await ctx.bean.instance.list({ where: {} });
+        for (const instance of instances) {
+            __installSchedules({ subdomain: instance.name });
+        }
+    };
+    app.meta._runSchedule = async (context) => {
+        const { subdomain, module, name } = context.data;
+        // ignore on test
+        if (app.meta.isTest)
+            return;
+        // check if valid
+        if (!__checkJobValid(context)) {
+            await __deleteSchedule(context);
+            return;
+        }
+        // schedule
+        const fullKey = `${module}.${name}`;
+        const schedule = ebSchedules[fullKey];
+        // bean
+        const bean = schedule.bean;
+        // execute
+        return await app.meta.util.executeBean({
+            subdomain,
+            beanModule: bean.module,
+            beanFullName: `${bean.module}.schedule.${bean.name}`,
+            transaction: schedule.config.transaction,
+            context,
+            instance: true,
+        });
+    };
+    async function __deleteSchedule(context) {
+        const job = context.job;
+        const jobKeyActive = app.meta.queue._getRepeatKey(job.data.jobName, job.data.jobOptions.repeat);
+        const repeat = await job.queue.repeat;
+        await repeat.removeRepeatableByKey(jobKeyActive);
+    }
+    function __checkJobValid(context) {
+        const job = context.job;
+        const { subdomain, module, name } = context.data;
+        // schedule
+        const fullKey = `${module}.${name}`;
+        const schedule = ebSchedules[fullKey];
+        if (!schedule)
+            return false;
+        // check disable
+        if (schedule.config.disable)
+            return false;
+        // check if changed
+        const jobKeyActive = app.meta.queue._getRepeatKey(job.data.jobName, job.data.jobOptions.repeat);
+        const jobNameConfig = __getJobName(subdomain, module, name);
+        const jobKeyConfig = app.meta.queue._getRepeatKey(jobNameConfig, schedule.config.repeat);
+        if (jobKeyActive !== jobKeyConfig)
+            return false;
+        // ok
+        return true;
+    }
+    function __getJobName(subdomain, module, name) {
+        return `${subdomain}.${module}.${name}`;
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=schedule.js.map

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

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

package/dist/lib/module/service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SERVICEPROXY = Symbol('CTX#__SERVICEPROXY');
+function default_1(app) {
+    // 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, 'service', {
+                    get() {
+                        let service = context[SERVICEPROXY];
+                        if (!service) {
+                            service = context[SERVICEPROXY] = new Proxy({}, {
+                                get(obj, prop) {
+                                    if (typeof prop === 'symbol')
+                                        return obj[prop];
+                                    const beanFullName = `${context.module.info.relativeName}.service.${prop}`;
+                                    return context.bean._getBean(beanFullName);
+                                },
+                            });
+                        }
+                        return service;
+                    },
+                });
+            }
+            return context;
+        };
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=service.js.map

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

@@ -0,0 +1,5 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class SocketioReady extends BeanSimple {
+    initialize(): void;
+}
+//# sourceMappingURL=socketio.d.ts.map

package/dist/lib/module/socketio.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketioReady = void 0;
+const url_1 = require("url");
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class SocketioReady extends beanSimple_js_1.BeanSimple {
+    initialize() {
+        const app = this.app;
+        // checkRequest
+        app.io.checkRequest = function (req, fn) {
+            // not cors (safari not send sec-fetch-mode)
+            // if (req.headers['sec-fetch-mode'] !== 'cors') return fn(null, true);
+            // origin
+            let origin = req.headers.origin || req.headers.referer;
+            // file:// URLs produce a null Origin which can't be authorized via echo-back
+            if (origin === 'null' || origin === null)
+                origin = '*';
+            if (!origin || origin === '*')
+                return fn(null, true);
+            const host = req.headers['x-forwarded-host'] || req.headers.host;
+            if (new url_1.URL(origin).host === host) {
+                return fn(null, true);
+            }
+            // check
+            const reqNew = Object.assign({}, req, {
+                method: 'SOCKETIO',
+                url: '/api/a/base/',
+            });
+            const ctx = app.createAnonymousContext(reqNew);
+            ctx.bean.instance
+                .checkAppReadyInstance({ startup: true })
+                .then(res => {
+                if (!res)
+                    return fn(null, false);
+                if (app.meta.util.isSafeDomain(ctx, origin)) {
+                    return fn(null, true);
+                }
+                return fn(null, false);
+            })
+                .catch(() => {
+                return fn(null, false);
+            });
+        };
+    }
+}
+exports.SocketioReady = SocketioReady;
+//# sourceMappingURL=socketio.js.map

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

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