vona 1.0.0 → 5.0.4

package/dist/lib/module/module.js

@@ -0,0 +1,134 @@
+"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.ModuleTools = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const module_glob_1 = require("@cabloy/module-glob");
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+const node_url_1 = require("node:url");
+const Path = __importStar(require("node:path"));
+// const __import_type_serialization = true;
+const __import_type_serialization = false;
+class ModuleTools extends beanSimple_js_1.BeanSimple {
+    async prepare() {
+        const app = this.app;
+        // all modules
+        const { suites, modules, modulesArray } = await (0, module_glob_1.glob)({
+            projectMode: 'vona',
+            projectPath: path_1.default.join(app.options.baseDir, '../..'),
+            disabledModules: process.env.Project_Disabled_Modules,
+            disabledSuites: process.env.Project_Disabled_Suites,
+            log: !!app.meta.inAgent,
+        });
+        app.meta.suites = suites;
+        app.meta.modules = modules;
+        app.meta.modulesArray = modulesArray;
+        app.meta.modulesMonkey = {};
+        // app monkey
+        let pathAppMonkey;
+        if (app.meta.isTest || app.meta.isLocal) {
+            pathAppMonkey = _pathToHref(path_1.default.resolve(process.cwd(), 'src/backend/config/monkey.mts'));
+        }
+        else {
+            pathAppMonkey = _pathToHref(path_1.default.resolve(app.options.baseDir, 'config/monkey.mjs'));
+        }
+        if (fs_extra_1.default.existsSync(pathAppMonkey)) {
+            const AppMonkey = await import(pathAppMonkey);
+            app.meta.appMonkey = app.bean._newBean(AppMonkey.AppMonkey);
+        }
+        return modules;
+    }
+    async load() {
+        const app = this.app;
+        // 1. import
+        const modulesResource = await this._importModules();
+        // 2. resource
+        for (let i = 0; i < modulesResource.length; i++) {
+            const module = app.meta.modulesArray[i];
+            module.resource = modulesResource[i];
+        }
+        // 3. main / monkey
+        for (const module of app.meta.modulesArray) {
+            if (module.resource.Main) {
+                module.mainInstance = app.bean._newBean(module.resource.Main, module);
+            }
+            if (module.resource.Monkey) {
+                module.monkeyInstance = app.bean._newBean(module.resource.Monkey, module);
+                app.meta.modulesMonkey[module.info.relativeName] = module;
+            }
+        }
+    }
+    async monkey(monkeyName) {
+        const app = this.app;
+        for (const module of app.meta.modulesArray) {
+            await app.meta.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, monkeyName, module);
+        }
+    }
+    _getModuleIndexPath(module) {
+        const app = this.app;
+        const pathSrc = `${module.root}/src/index.ts`;
+        if ((app.meta.isTest || app.meta.isLocal) && fs_extra_1.default.existsSync(pathSrc)) {
+            return _pathToHref(pathSrc);
+        }
+        return _pathToHref(`${module.root}/dist/index.js`);
+    }
+    async _importModules_serialization() {
+        const modulesResource = [];
+        for (const module of this.app.meta.modulesArray) {
+            modulesResource.push(await import(this._getModuleIndexPath(module)));
+        }
+        return modulesResource;
+    }
+    async _importModules_parallelization() {
+        const promises = [];
+        for (const module of this.app.meta.modulesArray) {
+            promises.push(import(this._getModuleIndexPath(module)));
+        }
+        return await Promise.all(promises);
+    }
+    async _importModules() {
+        const timeBegin = new Date();
+        console.log(`import modules begin, pid: ${process.pid}`);
+        let modulesResource;
+        if (__import_type_serialization) {
+            modulesResource = await this._importModules_serialization();
+        }
+        else {
+            modulesResource = await this._importModules_parallelization();
+        }
+        const timeEnd = new Date();
+        console.log(`import modules end, pid: ${process.pid}: ${(timeEnd.valueOf() - timeBegin.valueOf()) / 1000}s`);
+        return modulesResource;
+    }
+}
+exports.ModuleTools = ModuleTools;
+function _pathToHref(fileName) {
+    return Path.sep === '\\' ? (0, node_url_1.pathToFileURL)(fileName).href : fileName;
+}
+//# sourceMappingURL=module.js.map

package/dist/lib/module/moduleMeta.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=moduleMeta.d.ts.map

package/dist/lib/module/moduleMeta.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1(app, modules) {
+    // all metas
+    app.meta.metas = {};
+    // load metas
+    await loadMetas();
+    async function loadMetas() {
+        for (const key in modules) {
+            const module = modules[key];
+            // module meta
+            if (typeof module.resource.meta === 'function') {
+                module.meta = module.resource.meta(app);
+            }
+            else {
+                module.meta = module.resource.meta;
+            }
+            if (module.meta) {
+                await app.meta.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'metaLoaded', module, module.meta);
+            }
+            app.meta.metas[module.info.relativeName] = module.meta;
+        }
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=moduleMeta.js.map

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

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

package/dist/lib/module/queue/queue.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queueClient_js_1 = require("./queueClient.js");
+function default_1(app, modules) {
+    // queue
+    app.meta.queue = app.bean._newBean(queueClient_js_1.QueueClient);
+    // all queues
+    const ebQueues = (app.meta.queues = {});
+    // load queues
+    loadQueues();
+    function loadQueues() {
+        for (const key in modules) {
+            const module = modules[key];
+            const config = app.meta.configs[module.info.relativeName];
+            if (!config.queues)
+                continue;
+            for (const queueName in config.queues) {
+                const queueConfig = config.queues[queueName];
+                const fullKey = `${module.info.relativeName}:${queueName}`;
+                // bean
+                const beanName = queueConfig.bean;
+                if (!beanName)
+                    throw new Error(`bean not set for queue: ${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,
+                    };
+                }
+                ebQueues[fullKey] = {
+                    module: module.info.relativeName,
+                    name: queueName,
+                    config: queueConfig,
+                    bean,
+                };
+            }
+        }
+    }
+    app.meta._loadQueueWorkers = ({ subdomain }) => {
+        for (const fullKey in ebQueues) {
+            const queue = ebQueues[fullKey];
+            const info = {
+                subdomain,
+                module: queue.module,
+                queueName: queue.name,
+            };
+            app.meta.queue._ensureWorker(info);
+        }
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=queue.js.map

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

@@ -0,0 +1,26 @@
+import * as bull from 'bullmq';
+import { IQueueCallbacks, IQueueQueue, IQueueQueues, IQueueWork, IQueueWorks } from '../../../types/index.js';
+import { BeanSimple } from '../../bean/beanSimple.js';
+export declare class QueueClient extends BeanSimple {
+    _workers: IQueueWorks;
+    _queues: IQueueQueues;
+    _queueCallbacks: IQueueCallbacks;
+    push(info: any): void;
+    pushAsync(info: any): Promise<unknown>;
+    _clearWorkers(): Promise<void>;
+    _createWorker(info: any, queueKey: any): IQueueWork;
+    _createQueue(info: any, queueKey: any): IQueueQueue;
+    _ensureWorker(info: any): void;
+    _ensureQueue(info: any): IQueueQueue;
+    _getQueue(info: any): bull.Queue<any, any, string>;
+    _callCallback(jobId: any, failedReason: any, data: any): void;
+    _queuePush(info: any, isAsync: any): Promise<unknown>;
+    _combineQueueKey({ subdomain, module, queueName }: {
+        subdomain: any;
+        module?: string | undefined;
+        queueName?: string | undefined;
+    }): string;
+    _performTask(job: any): Promise<any>;
+    _getRepeatKey(name: any, repeat: any): string;
+}
+//# sourceMappingURL=queueClient.d.ts.map

package/dist/lib/module/queue/queueClient.js

@@ -0,0 +1,262 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueClient = void 0;
+const bull = __importStar(require("bullmq"));
+const uuid = __importStar(require("uuid"));
+const beanSimple_js_1 = require("../../bean/beanSimple.js");
+class QueueClient extends beanSimple_js_1.BeanSimple {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "_workers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "_queues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "_queueCallbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    push(info) {
+        if (!info.dbLevel)
+            info.dbLevel = 1;
+        this._queuePush(info, false);
+    }
+    // { locale, subdomain, module, queueName,queueNameSub,data }
+    pushAsync(info) {
+        if (!info.dbLevel)
+            throw new Error('should specify the info.dbLevel');
+        return this._queuePush(info, true);
+    }
+    async _clearWorkers() {
+        for (const queueKey in this._workers) {
+            const _worker = this._workers[queueKey];
+            await _worker.worker.close();
+        }
+        this._workers = {};
+    }
+    _createWorker(info, queueKey) {
+        const app = this.app;
+        // worker
+        const _worker = {};
+        // prefix
+        const prefix = `bull_${app.name}:queue`;
+        // queue config
+        const queueConfig = app.meta.queues[`${info.module}:${info.queueName}`].config;
+        // queueConfig.options: queue/worker/job/redlock
+        const workerOptions = (queueConfig.options && queueConfig.options.worker) || null;
+        const redlockOptions = (queueConfig.options && queueConfig.options.redlock) || null;
+        const _redlockOptions = Object.assign({}, app.config.queue.redlock.options, redlockOptions);
+        // redlock
+        if (!queueConfig.concurrency) {
+            _worker.redlock = app.meta.redlock.create(_redlockOptions);
+        }
+        // create work
+        const connectionWorker = app.redis.get('queue').duplicate();
+        const _workerOptions = Object.assign({}, app.config.queue.worker, workerOptions, {
+            prefix,
+            connection: connectionWorker,
+        });
+        _worker.worker = new bull.Worker(queueKey, async (job) => {
+            // concurrency
+            if (queueConfig.concurrency) {
+                return await this._performTask(job);
+            }
+            // redlock
+            const _lockResource = `queue:${queueKey}${job.data.queueNameSub ? '#' + job.data.queueNameSub : ''}`;
+            return await app.meta.util.lock({
+                // subdomain: job.data.subdomain, // need not
+                resource: _lockResource,
+                options: _redlockOptions,
+                redlock: _worker.redlock,
+                fn: async () => {
+                    return await this._performTask(job);
+                },
+            });
+        }, _workerOptions);
+        _worker.worker.on('failed', (_job, err) => {
+            app.logger.error(err);
+        });
+        _worker.worker.on('error', err => {
+            if (err.message && err.message.indexOf('Missing lock for job') > -1) {
+                const workerInner = _worker.worker;
+                if (!workerInner.running) {
+                    _worker.worker.run().catch(error => {
+                        console.error(error);
+                    });
+                }
+            }
+        });
+        // ok
+        return _worker;
+    }
+    _createQueue(info, queueKey) {
+        const app = this.app;
+        // queue
+        const _queue = {};
+        // prefix
+        const prefix = `bull_${app.name}:queue`;
+        // queue config
+        const queueConfig = app.meta.queues[`${info.module}:${info.queueName}`].config;
+        // queueConfig.options: queue/worker/job/limiter
+        const queueOptions = (queueConfig.options && queueConfig.options.queue) || null;
+        // create queue
+        const connectionQueue = app.redis.get('queue').duplicate();
+        const _queueOptions = Object.assign({}, queueOptions, { prefix, connection: connectionQueue });
+        _queue.queue = new bull.Queue(queueKey, _queueOptions);
+        // create events
+        const connectionEvents = app.redis.get('queue').duplicate();
+        _queue.queueEvents = new bull.QueueEvents(queueKey, { prefix, connection: connectionEvents });
+        _queue.queueEvents.on('completed', ({ jobId, returnvalue }) => {
+            this._callCallback(jobId, null, returnvalue);
+        });
+        _queue.queueEvents.on('failed', ({ jobId, failedReason }) => {
+            this._callCallback(jobId, failedReason, null);
+        });
+        // ok
+        return _queue;
+    }
+    _ensureWorker(info) {
+        // queueKey
+        const queueKey = this._combineQueueKey(info);
+        // worker
+        if (!this._workers[queueKey]) {
+            this._workers[queueKey] = this._createWorker(info, queueKey);
+        }
+    }
+    _ensureQueue(info) {
+        // worker
+        this._ensureWorker(info);
+        // queueKey
+        const queueKey = this._combineQueueKey(info);
+        // queue
+        if (!this._queues[queueKey]) {
+            this._queues[queueKey] = this._createQueue(info, queueKey);
+        }
+        // ok
+        return this._queues[queueKey];
+    }
+    _getQueue(info) {
+        return this._ensureQueue(info).queue;
+    }
+    _callCallback(jobId, failedReason, data) {
+        const _callback = this._queueCallbacks[jobId];
+        if (_callback) {
+            delete this._queueCallbacks[jobId];
+            _callback.callback(failedReason ? new Error(failedReason) : null, data);
+        }
+    }
+    _queuePush(info, isAsync) {
+        const app = this.app;
+        // queue config
+        const fullKey = `${info.module}:${info.queueName}`;
+        const queueBase = app.meta.queues[fullKey];
+        if (!queueBase)
+            throw new Error(`queue config not found: ${fullKey}`);
+        const queueConfig = queueBase.config;
+        // queueConfig.options: queue/worker/job/limiter
+        const jobOptions = (queueConfig.options && queueConfig.options.job) || null;
+        // queue
+        const queue = this._getQueue(info);
+        // job
+        const jobId = (info.jobOptions && info.jobOptions.jobId) || uuid.v4();
+        const jobName = info.jobName || jobId;
+        const _jobOptions = Object.assign({}, jobOptions, info.jobOptions);
+        // not async
+        if (!isAsync) {
+            // add job
+            return queue.add(jobName, info, _jobOptions);
+        }
+        // async
+        return new Promise((resolve, reject) => {
+            // jobId
+            if (!_jobOptions.jobId) {
+                _jobOptions.jobId = jobId;
+            }
+            // callback
+            this._queueCallbacks[jobId] = {
+                info,
+                callback: (err, data) => {
+                    if (err)
+                        return reject(err);
+                    resolve(data);
+                },
+            };
+            // add job
+            return queue.add(jobName, info, _jobOptions);
+        });
+    }
+    _combineQueueKey({ subdomain, module = '', queueName = '' }) {
+        const app = this.app;
+        subdomain = app.meta.util.subdomainDesp(subdomain);
+        return `${subdomain}||${module}||${queueName}`;
+    }
+    async _performTask(job) {
+        const app = this.app;
+        let { locale, subdomain, module, queueName, queueNameSub, data, ctxParent, dbLevel } = job.data;
+        // ctxParent
+        if (!ctxParent)
+            ctxParent = {};
+        ctxParent.dbLevel = dbLevel - 1;
+        // context
+        const context = { job, data };
+        if (queueNameSub) {
+            context.queueNameSub = queueNameSub;
+        }
+        // queue config
+        const queue = app.meta.queues[`${module}:${queueName}`];
+        // bean
+        const bean = queue.bean;
+        // execute
+        return await app.meta.util.executeBean({
+            locale,
+            subdomain,
+            context,
+            beanModule: bean.module,
+            beanFullName: `${bean.module}.queue.${bean.name}`,
+            transaction: queue.config.transaction,
+            ctxParent,
+        });
+    }
+    _getRepeatKey(name, repeat) {
+        const endDate = repeat.endDate ? new Date(repeat.endDate).getTime() : '';
+        const tz = repeat.tz || '';
+        const suffix = (repeat.cron ? repeat.cron : String(repeat.every)) || '';
+        const jobId = repeat.jobId ? repeat.jobId : '';
+        return `${name}:${jobId}:${endDate}:${tz}:${suffix}`;
+    }
+}
+exports.QueueClient = QueueClient;
+//# sourceMappingURL=queueClient.js.map

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

@@ -0,0 +1,11 @@
+import Bottleneck from 'bottleneck';
+import { VonaApplication } from '../../types/index.js';
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class AppLimiter extends BeanSimple {
+    create(options: any): Bottleneck;
+}
+export declare class AppRedlock extends BeanSimple {
+    create(options: any): any;
+}
+export default function (app: VonaApplication): void;
+//# sourceMappingURL=redis.d.ts.map

package/dist/lib/module/redis.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppRedlock = exports.AppLimiter = void 0;
+const bottleneck_1 = __importDefault(require("bottleneck"));
+const redlock_1 = __importDefault(require("redlock"));
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class AppLimiter extends beanSimple_js_1.BeanSimple {
+    // https://github.com/SGrondin/bottleneck#clustering
+    create(options) {
+        options = options || {};
+        // datastore
+        options.datastore = 'ioredis';
+        // connection
+        if (options.connection === undefined) {
+            options.connection = new bottleneck_1.default.IORedisConnection({
+                client: this.app.redis.get('limiter'),
+            });
+        }
+        return new bottleneck_1.default(options);
+    }
+}
+exports.AppLimiter = AppLimiter;
+class AppRedlock extends beanSimple_js_1.BeanSimple {
+    // https://github.com/mike-marcacci/node-redlock#configuration
+    create(options) {
+        // clients
+        const clients = [];
+        for (const clientName of this.app.config.queue.redlock.clients) {
+            const client = this.app.redis.get(clientName) || this.app.redis.get('limiter');
+            clients.push(client);
+        }
+        return new redlock_1.default(clients, options);
+    }
+}
+exports.AppRedlock = AppRedlock;
+function default_1(app) {
+    // limiter
+    app.meta.limiter = app.bean._newBean(AppLimiter);
+    // redlock
+    app.meta.redlock = app.bean._newBean(AppRedlock);
+}
+exports.default = default_1;
+//# sourceMappingURL=redis.js.map

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

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

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

@@ -0,0 +1,98 @@
+"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"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const debounce_1 = __importDefault(require("debounce"));
+const process_helper_1 = require("@cabloy/process-helper");
+const cast_js_1 = require("../../../types/utils/cast.js");
+function default_1(app) {
+    let watcherDevelopment = null;
+    // only in development
+    if (app.meta.inAgent && app.meta.isLocal) {
+        _register();
+    }
+    // invoked in agent
+    function _register() {
+        // watchDirs
+        const watchDirs = _collectDevelopmentWatchDirs();
+        // close
+        if (watcherDevelopment) {
+            const _watcher = (0, cast_js_1.Cast)(watcherDevelopment);
+            if (!_watcher.__eb_closed) {
+                if (_watcher.__eb_ready) {
+                    _watcher.close();
+                }
+                else {
+                    _watcher.__eb_closing = true;
+                }
+            }
+            watcherDevelopment = null;
+        }
+        // watcher
+        const _watcher = chokidar_1.default.watch(watchDirs).on('change', (0, debounce_1.default)(info => {
+            _developmentChange(info);
+        }, app.config.development.debounce));
+        // on ready
+        const _watcher2 = (0, cast_js_1.Cast)(_watcher);
+        _watcher.once('ready', function () {
+            _watcher2.__eb_ready = true;
+            if (_watcher2.__eb_closing) {
+                _watcher.close();
+                _watcher2.__eb_closed = true;
+            }
+        });
+        // ok
+        watcherDevelopment = _watcher;
+    }
+    // invoked in agent
+    function _collectDevelopmentWatchDirs() {
+        const __pathes = [
+            'src/backend/config',
+            'src/backend/demo',
+            'src/module',
+            'src/module-vendor',
+            'src/suite',
+            'src/suite-vendor',
+            'packages-vona/vona',
+        ];
+        const cwd = process.cwd();
+        const watchDirs = [];
+        for (const __path of __pathes) {
+            const pathDir = path_1.default.join(cwd, __path);
+            if (fs_extra_1.default.existsSync(pathDir)) {
+                watchDirs.push(pathDir);
+            }
+        }
+        return watchDirs;
+        // const pathSrc = path.resolve(this.app.config.baseDir, '..');
+        // let watchDirs = eggBornUtils.tools.globbySync(`${pathSrc}/**/backend/src`, { onlyDirectories: true });
+        // watchDirs = [path.join(pathSrc, 'backend/config')].concat(watchDirs);
+        // return watchDirs;
+    }
+    // invoked in agent
+    async function _developmentChange(info) {
+        info = info.replace(/\\/g, '/');
+        // extname
+        const extname = path_1.default.extname(info);
+        if (!['.ts', '.mts'].includes(extname))
+            return;
+        // log
+        app.logger.warn(`[agent:development] reload worker because ${info} changed`);
+        // tsc
+        if (extname !== '.mts') {
+            const __pathes = ['src/backend/config', 'src/backend/demo', 'packages-vona/vona'];
+            if (__pathes.some(item => info.indexOf(item) > -1)) {
+                const processHelper = new process_helper_1.ProcessHelper();
+                await processHelper.tsc();
+            }
+        }
+        // reload
+        app.meta.reload.now();
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=development.js.map