alemonjs 2.1.81 → 2.1.83-alpha.1

package/lib/app/event-error.d.ts

@@ -0,0 +1,2 @@
+import type { EventErrorContext } from '../types';
+export declare const dispatchEventError: (context: EventErrorContext) => Promise<boolean>;

package/lib/app/event-error.js

@@ -0,0 +1,20 @@
+import { getChildrenApp } from './store.js';
+import { showErrorModule } from '../core/utils.js';
+
+const dispatchEventError = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const onEventError = app?.cycle?.onEventError;
+    if (!onEventError) {
+        return false;
+    }
+    try {
+        const result = await onEventError(context);
+        return result === 'continue';
+    }
+    catch (error) {
+        showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'onEventError failed'));
+        return false;
+    }
+};
+
+export { dispatchEventError };

package/lib/app/event-processor-callHandler.d.ts

@@ -1 +1,5 @@
-export declare const createCallHandler: (valueEvent: any) => (currents: any, nextEvent: any) => void;
+import type { EventErrorPhase } from '../types';
+export declare const createCallHandler: (valueEvent: any) => (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: EventErrorPhase;
+}) => void;

package/lib/app/event-processor-callHandler.js

@@ -3,9 +3,10 @@ import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
+import { dispatchEventError } from './event-error.js';
 
 const createCallHandler = valueEvent => {
-    const callHandler = (currents, nextEvent) => {
+    const callHandler = (currents, nextEvent, meta) => {
         let index = 0;
         let isClose = false;
         let isNext = false;
@@ -24,7 +25,10 @@ const createCallHandler = valueEvent => {
                     isNext = true;
                     nextEvent(...cns);
                 };
-                const res = await withEventContext(valueEvent, nextFn, () => currents[index](valueEvent, nextFn));
+                const res = await withEventContext(valueEvent, nextFn, () => currents[index](valueEvent, nextFn), {
+                    appName: meta?.appName,
+                    phase: meta?.phase
+                });
                 if (res !== true) {
                     if (!isNext) {
                         finishCurrentTrace('consumed');
@@ -35,7 +39,19 @@ const createCallHandler = valueEvent => {
             }
             catch (err) {
                 finishCurrentTrace('error');
+                const shouldContinue = meta?.appName && meta?.phase
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error: err,
+                        appName: meta.appName,
+                        phase: meta.phase
+                    })
+                    : false;
                 showErrorModule(err);
+                if (shouldContinue) {
+                    nextEvent();
+                    return;
+                }
                 return;
             }
             ++index;

package/lib/app/event-processor-cycleFiles.d.ts

@@ -1,4 +1,7 @@
 import { Next, Events, EventKeys, FileTreeNode, StoreResponseItem } from '../types';
 export declare const clearModuleCache: (path?: string) => void;
 export declare const createNextStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, files: StoreResponseItem[], callHandler: (currents: any, nextEvent: any) => void) => Next;
-export declare const createFileTreeStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, root: FileTreeNode, callHandler: (currents: any, nextEvent: any) => void) => Next;
+export declare const createFileTreeStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, root: FileTreeNode, callHandler: (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: "middleware" | "response";
+}) => void, phase: "middleware" | "response") => Next;

package/lib/app/event-processor-cycleFiles.js

@@ -1,5 +1,6 @@
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
 import { EventMessageText } from '../core/variable.js';
+import { dispatchEventError } from './event-error.js';
 
 const moduleCache = new Map();
 const shouldSkipFile = (file, select, valueEvent) => {
@@ -37,7 +38,7 @@ const loadModule = async (filePath) => {
     moduleCache.set(filePath, mod);
     return mod;
 };
-const callHandlerFile = async (valueEvent, select, file, nextStep, callback) => {
+const callHandlerFile = async (valueEvent, select, file, nextStep, callback, phase) => {
     try {
         const app = await loadModule(file.path);
         if (!app?.default?.current || !app?.default?.select) {
@@ -60,8 +61,16 @@ const callHandlerFile = async (valueEvent, select, file, nextStep, callback) =>
         callback(app);
     }
     catch (err) {
+        const shouldContinue = await dispatchEventError({
+            event: valueEvent,
+            error: err,
+            appName: file.appName,
+            phase
+        });
         showErrorModule(err);
-        nextStep();
+        if (shouldContinue) {
+            nextStep();
+        }
     }
 };
 const createNextStep = (valueEvent, select, next, files, callHandler) => {
@@ -94,14 +103,14 @@ const createNextStep = (valueEvent, select, next, files, callHandler) => {
         }, app => {
             const currentsItem = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             currents.push(...currentsItem);
-        });
+        }, 'response');
         if (currents.length > 0) {
             callHandler(currents, nextStep);
         }
     };
     return nextStep;
 };
-const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
+const createFileTreeStep = (valueEvent, select, next, root, callHandler, phase) => {
     const processNode = (node, done) => {
         if (node.middleware?.path) {
             void checkMiddleware(node, done);
@@ -123,7 +132,7 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
             matched = true;
             const items = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             mwCurrents.push(...items);
-        });
+        }, 'middleware');
         if (matched) {
             if (mwCurrents.length === 0) {
                 void processContent(node, done);
@@ -141,6 +150,9 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
                     return;
                 }
                 void processContent(node, done);
+            }, {
+                appName: node.middleware?.appName,
+                phase
             });
         }
     };
@@ -174,8 +186,11 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
                 else {
                     processFiles(node, idx + 1, filesDone, treeDone);
                 }
+            }, {
+                appName: file.appName,
+                phase
             });
-        });
+        }, phase);
     };
     const processChildNodes = (node, done) => {
         const childKeys = Array.from(node.children.keys());

package/lib/app/event-processor-cycleRoute.d.ts

@@ -1,2 +1,5 @@
 import { Next, Events, EventKeys, ResponseRoute } from '../types';
-export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any) => void) => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;
+export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: "route";
+}) => void, phase: "route") => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;

package/lib/app/event-processor-cycleRoute.js

@@ -3,6 +3,7 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
+import { dispatchEventError } from './event-error.js';
 
 const AsyncFunction = (async () => { }).constructor;
 function isAsyncFunction(fn) {
@@ -11,7 +12,7 @@ function isAsyncFunction(fn) {
 function isFunction(value) {
     return isAsyncFunction(value) || typeof value === 'function' || value instanceof Function;
 }
-const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
+const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler, phase) => {
     const handlerResultCache = new Map();
     const collectHandlers = (tail) => {
         const result = [];
@@ -126,11 +127,24 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                         return;
                     }
                     void nextNode();
+                }, {
+                    appName: node.appName,
+                    phase
                 });
             }
             catch (err) {
+                const shouldContinue = typeof node.appName === 'string'
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error: err,
+                        appName: node.appName,
+                        phase
+                    })
+                    : false;
                 showErrorModule(err);
-                void nextNode();
+                if (shouldContinue) {
+                    void nextNode();
+                }
             }
         };
         void nextNode();

package/lib/app/event-processor-event.js

@@ -8,10 +8,10 @@ const responseRouterSingleton = new ResponseRouter();
 const expendEvent = (valueEvent, select, next) => {
     const root = responseTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextEvent = createFileTreeStep(valueEvent, select, next, root, callHandler);
+    const nextEvent = createFileTreeStep(valueEvent, select, next, root, callHandler, 'response');
     const routes = responseRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
-    const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler);
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler, 'route');
     void processChildren(routes, [], nextEvent);
 };
 

package/lib/app/event-processor-middleware.js

@@ -8,10 +8,10 @@ const middlewareRouterSingleton = new MiddlewareRouter();
 const expendMiddleware = (valueEvent, select, next) => {
     const root = middlewareTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextMiddleware = createFileTreeStep(valueEvent, select, next, root, callHandler);
+    const nextMiddleware = createFileTreeStep(valueEvent, select, next, root, callHandler, 'middleware');
     const routes = middlewareRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
-    const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler);
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler, 'route');
     void processChildren(routes, [], nextMiddleware);
 };
 

package/lib/app/event-processor-subscribe.js

@@ -5,6 +5,7 @@ import { showErrorModule } from '../core/utils.js';
 import { getSubscribeList } from './store.js';
 import { SubscribeStatus } from './config.js';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
+import { dispatchEventError } from './event-error.js';
 
 const expendSubscribe = (valueEvent, select, next, choose) => {
     const subListValue = getSubscribeList(choose, select);
@@ -64,15 +65,29 @@ const expendSubscribe = (valueEvent, select, next, choose) => {
             }
         };
         try {
-            const result = withEventContext(valueEvent, Continue, () => item.data.current(valueEvent, Continue));
+            const result = withEventContext(valueEvent, Continue, () => item.data.current(valueEvent, Continue), {
+                appName: item.data.appName,
+                phase: 'subscribe'
+            });
             if (result && typeof result.then === 'function') {
                 void result.then(() => {
                     if (!isContinue) {
                         finishCurrentTrace('consumed');
                     }
-                }, error => {
+                }, async (error) => {
                     finishCurrentTrace('error');
+                    const shouldContinue = typeof item.data.appName === 'string'
+                        ? await dispatchEventError({
+                            event: valueEvent,
+                            error,
+                            appName: item.data.appName,
+                            phase: 'subscribe'
+                        })
+                        : false;
                     showErrorModule(error);
+                    if (shouldContinue) {
+                        nextObserver(true);
+                    }
                 });
                 return;
             }
@@ -82,7 +97,20 @@ const expendSubscribe = (valueEvent, select, next, choose) => {
         }
         catch (error) {
             finishCurrentTrace('error');
-            showErrorModule(error);
+            void (async () => {
+                const shouldContinue = typeof item.data.appName === 'string'
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error,
+                        appName: item.data.appName,
+                        phase: 'subscribe'
+                    })
+                    : false;
+                showErrorModule(error);
+                if (shouldContinue) {
+                    nextObserver(true);
+                }
+            })();
         }
     };
     nextObserver();

package/lib/app/event-processor.js

@@ -4,6 +4,7 @@ import { expendCycle } from './event-processor-cycle.js';
 import { withProcessorTrace, finishCurrentTrace } from './hook-event-context.js';
 import { ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap } from './store.js';
 import { getCachedRegExp, matchIn, fastHash } from '../core/utils.js';
+import { dispatchEventStart } from './lifecycle-callbacks.js';
 
 const filter = ({ Now, store, INTERVAL }, MessageId) => {
     if (store.has(MessageId)) {
@@ -59,8 +60,12 @@ const callback = () => {
 };
 setTimeout(callback, processorRepeatedClearTimeMin);
 const onProcessor = (name, event, data) => {
-    withProcessorTrace(name, event, () => {
+    void withProcessorTrace(name, event, async () => {
         try {
+            await dispatchEventStart({
+                event,
+                name
+            });
             const value = getConfigValue();
             const disabledTextRegular = value?.disabled_text_regular;
             if (disabledTextRegular && event['MessageText']) {

package/lib/app/hook-event-context.d.ts

@@ -1,10 +1,14 @@
 import { Result } from '../core';
-import { EventKeys, Events } from '../types';
-export type EventTraceReason = 'filtered' | 'completed' | 'consumed' | 'error';
-export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R) => R;
+import { EventErrorPhase, EventKeys, Events, EventTraceReason } from '../types';
+export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R, options?: {
+    appName?: string;
+    phase?: EventErrorPhase;
+}) => R;
 export declare const withProcessorTrace: <T extends EventKeys, R>(select: T, event: Events[T], runner: () => R) => R;
 export declare const getCurrentEvent: <T extends EventKeys>() => Events[T] | undefined;
 export declare const getCurrentNext: () => ((...args: boolean[]) => void) | undefined;
+export declare const getCurrentAppName: () => string | undefined;
+export declare const getCurrentPhase: () => EventErrorPhase | undefined;
 export declare const finishCurrentTrace: (reason: EventTraceReason) => void;
 export declare const markEventSendAttempt: <T extends EventKeys>(event?: Events[T]) => void;
 export declare const markEventSendSuccess: <T extends EventKeys>(event?: Events[T]) => void;

package/lib/app/hook-event-context.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { performance } from 'node:perf_hooks';
 import { getConfigValue } from '../core/config.js';
 import { ResultCode } from '../core/variable.js';
+import { dispatchEventFinished } from './lifecycle-callbacks.js';
 
 const eventStore = new AsyncLocalStorage();
 const shouldShowLog = (event) => {
@@ -61,19 +62,31 @@ const createEventTrace = (select) => {
                     message: 'event processor finished',
                     data: createLogData(event, trace.select, reason, duration)
                 });
-                return;
             }
-            logger.info(createLogText(event, trace.select, reason, duration));
+            else {
+                logger.info(createLogText(event, trace.select, reason, duration));
+            }
+            void dispatchEventFinished({
+                event,
+                name: trace.select,
+                reason,
+                duration,
+                hasSendAttempted: event._sendAttempted === true || event._has_send_attempt === true,
+                hasSendSucceeded: event._sendSucceeded === true || event._has_send_success === true,
+                lastSendError: event._lastSendError ?? event._last_send_error ?? null
+            });
         }
     };
     return trace;
 };
-const withEventContext = (event, next, runner) => {
+const withEventContext = (event, next, runner, options) => {
     const current = eventStore.getStore();
     return eventStore.run({
         event,
         next,
-        trace: current?.trace
+        trace: current?.trace,
+        appName: options?.appName ?? current?.appName,
+        phase: options?.phase ?? current?.phase
     }, runner);
 };
 const withProcessorTrace = (select, event, runner) => {
@@ -90,6 +103,12 @@ const getCurrentEvent = () => {
 const getCurrentNext = () => {
     return eventStore.getStore()?.next;
 };
+const getCurrentAppName = () => {
+    return eventStore.getStore()?.appName;
+};
+const getCurrentPhase = () => {
+    return eventStore.getStore()?.phase;
+};
 const finishCurrentTrace = (reason) => {
     eventStore.getStore()?.trace?.finish(reason);
 };
@@ -144,4 +163,4 @@ const recordEventSendResults = (results, event) => {
     }
 };
 
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace };
+export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace };

package/lib/app/hook-use/subscribe.js

@@ -1,12 +1,13 @@
 import { ResultCode } from '../../core/variable.js';
 import { SubscribeList } from '../store.js';
 import { SubscribeStatus } from '../config.js';
-import { getCurrentEvent } from '../hook-event-context.js';
+import { getCurrentEvent, getCurrentAppName } from '../hook-event-context.js';
 
 function useSubscribe(eventOrSelects, maybeSelects) {
     const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
     const event = (maybeSelects === undefined ? undefined : eventOrSelects);
     const valueEvent = event ?? getCurrentEvent();
+    const appName = getCurrentAppName();
     if (typeof valueEvent !== 'object' || valueEvent === null) {
         logger.error({
             code: ResultCode.FailParams,
@@ -50,6 +51,7 @@ function useSubscribe(eventOrSelects, maybeSelects) {
                 }
             }
             subList.value.append({
+                appName,
                 choose,
                 selects: curSelects,
                 keys: values,

package/lib/app/index.js

@@ -1,4 +1,4 @@
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getChildrenApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listChildrenApps, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './store.js';
 export { Expose, clearAllExpose, disposeExpose, registerExpose } from './expose.js';
 export { loadModels, run } from './load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './load_modules/loadChild.js';
@@ -35,7 +35,7 @@ export { useUser } from './hook-use/user.js';
 export { useObserver, useSubscribe } from './hook-use/subscribe.js';
 export { createEvent, useEvent } from './hook-use/event.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './api/schedule.js';
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './hook-event-context.js';
+export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './hook-event-context.js';
 export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';

package/lib/app/lifecycle-callbacks.d.ts

@@ -0,0 +1,14 @@
+import type { EventFinishedContext, EventStartContext, HttpErrorContext, RuntimeStatusChangeContext } from '../types';
+export declare const dispatchEventStart: (context: EventStartContext) => Promise<void>;
+export declare const dispatchEventFinished: (context: EventFinishedContext) => Promise<void>;
+export declare const dispatchHttpError: (context: HttpErrorContext) => Promise<boolean>;
+export declare const dispatchRuntimeStatusChange: (context: RuntimeStatusChangeContext) => Promise<void>;
+export declare const dispatchAppReady: (appName: string, store: {
+    response: any[];
+    responseMiddleware: {
+        [key: string]: any;
+    };
+    middleware: any[];
+}) => Promise<void>;
+export declare const dispatchAppDispose: (appName: string, error?: unknown) => Promise<void>;
+export declare const dispatchDisposeAllApps: (error?: unknown) => Promise<void>;

package/lib/app/lifecycle-callbacks.js

@@ -0,0 +1,99 @@
+import { showErrorModule } from '../core/utils.js';
+
+const swallowLifecycleError = (error) => {
+    showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown lifecycle error'));
+};
+const getChildrenApps = () => {
+    return Object.values(global.alemonjsCore?.storeChildrenApp ?? {});
+};
+const getChildrenApp = (name) => {
+    return global.alemonjsCore?.storeChildrenApp?.[name] ?? null;
+};
+const dispatchEventStart = async (context) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        try {
+            await app.cycle?.onEventStart?.(context);
+        }
+        catch (error) {
+            swallowLifecycleError(error);
+        }
+    }
+};
+const dispatchEventFinished = async (context) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        try {
+            await app.cycle?.onEventFinished?.(context);
+        }
+        catch (error) {
+            swallowLifecycleError(error);
+        }
+    }
+};
+const dispatchHttpError = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const handler = app?.cycle?.onHttpError;
+    if (!handler) {
+        return false;
+    }
+    try {
+        const result = await handler(context);
+        return result === 'handled';
+    }
+    catch (error) {
+        swallowLifecycleError(error);
+        return false;
+    }
+};
+const dispatchRuntimeStatusChange = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const handler = app?.cycle?.onRuntimeStatusChange;
+    if (!handler) {
+        return;
+    }
+    try {
+        await handler(context);
+    }
+    catch (error) {
+        swallowLifecycleError(error);
+    }
+};
+const dispatchAppReady = async (appName, store) => {
+    const app = getChildrenApp(appName);
+    const handler = app?.cycle?.onReady;
+    if (!handler) {
+        return;
+    }
+    try {
+        await handler(store);
+    }
+    catch (error) {
+        throw error;
+    }
+};
+const dispatchAppDispose = async (appName, error) => {
+    const app = getChildrenApp(appName);
+    if (!app?.cycle) {
+        return;
+    }
+    try {
+        if (app.cycle.onDispose) {
+            await app.cycle.onDispose(error);
+        }
+        if (app.cycle.unMounted) {
+            await app.cycle.unMounted(error);
+        }
+    }
+    catch (disposeError) {
+        swallowLifecycleError(disposeError);
+    }
+};
+const dispatchDisposeAllApps = async (error) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        await dispatchAppDispose(app.name, error);
+    }
+};
+
+export { dispatchAppDispose, dispatchAppReady, dispatchDisposeAllApps, dispatchEventFinished, dispatchEventStart, dispatchHttpError, dispatchRuntimeStatusChange };

package/lib/app/load_modules/loadChild.js

@@ -6,6 +6,7 @@ import { registerExpose } from '../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
 import { registerAppDir, scheduleCancelByApp, unregisterAppDir } from '../schedule-store.js';
 import module$1 from 'module';
+import { dispatchRuntimeStatusChange, dispatchAppDispose, dispatchAppReady } from '../lifecycle-callbacks.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -89,21 +90,19 @@ const loadChildren = async (mainPath, appName) => {
             app = await moduleApp.default.callback();
         }
         App.pushCycle(app);
+        await dispatchRuntimeStatusChange({
+            appName,
+            previousStatus: 'discovered',
+            status: 'loading'
+        });
         const unMounted = async (e) => {
             showErrorModule(e);
             clearRuntimeAppKoaRouters(appName);
             updateRuntimeAppStatus(appName, 'failed', e);
             scheduleCancelByApp(appName);
             unregisterAppDir(appName);
+            await dispatchAppDispose(appName, e);
             App.un();
-            try {
-                if (app?.unMounted) {
-                    await app.unMounted(e);
-                }
-            }
-            catch (e) {
-                showErrorModule(e);
-            }
         };
         try {
             if (app?.onCreated) {
@@ -133,10 +132,12 @@ const loadChildren = async (mainPath, appName) => {
                 expose: hasExposeCapability
             });
             App.on();
+            const emptyStore = { response: [], responseMiddleware: {}, middleware: [] };
             try {
                 if (app?.onMounted) {
-                    await app.onMounted({ response: [], responseMiddleware: {}, middleware: [] });
+                    await app.onMounted(emptyStore);
                 }
+                await dispatchAppReady(appName, emptyStore);
                 updateRuntimeAppStatus(appName, 'ready');
             }
             catch (e) {
@@ -202,10 +203,12 @@ const loadChildren = async (mainPath, appName) => {
                 event: resData.length > 0 || Object.keys(resAndMwData).length > 0 || mwData.length > 0
             });
             App.on();
+            const mountedStore = { response: resData, responseMiddleware: resAndMwData, middleware: mwData };
             try {
                 if (app?.onMounted) {
-                    await app.onMounted({ response: resData, responseMiddleware: resAndMwData, middleware: mwData });
+                    await app.onMounted(mountedStore);
                 }
+                await dispatchAppReady(appName, mountedStore);
                 updateRuntimeAppStatus(appName, 'ready');
             }
             catch (e) {

package/lib/app/router/dsl.js

@@ -690,10 +690,10 @@ class Router {
         const description = formatRouteDescription(routeEntry?.config.description);
         const schemaHints = buildSchemaHints(routeEntry?.config.schema);
         const replyLines = buildValidationReply({
-            error: validation && !validation.valid ? validation.error : '参数校验失败',
+            error: validation?.valid === false ? validation.error : '参数校验失败',
             commandKey: result.commandKey,
             description,
-            usage: validation && !validation.valid ? validation.usage : undefined,
+            usage: validation?.valid === false ? validation.usage : undefined,
             schemaHints
         });
         replyLines.forEach((line, index) => {

package/lib/app/store.d.ts

@@ -187,6 +187,8 @@ export declare class ChildrenApp {
     un(): void;
     get value(): import("../types").StoreChildrenApp;
 }
+export declare const getChildrenApp: (name: string) => import("../types").StoreChildrenApp;
+export declare const listChildrenApps: () => import("../types").StoreChildrenApp[];
 export declare const ProcessorEventAutoClearMap: Map<any, any>;
 export declare const ProcessorEventUserAutoClearMap: Map<any, any>;
 export declare const logger: any;