akanjs 3.0.0-alpha.44 → 3.0.0-alpha.46

package/base/primitiveRegistry.ts

@@ -209,12 +209,12 @@ declare global {
     [DEFAULT_VALUE]: boolean;
     [PURIFIED_VALUE]: boolean;
     [EXAMPLE_VALUE]: boolean;
-    validate(value: boolean | number): boolean;
-    parseValue(input: boolean | number): boolean | number;
-    serializeValue(value: boolean | number): boolean | number;
-    _parse(input: boolean | number): boolean;
-    _serialize(value: boolean | number): boolean;
-    _checkValue(value: boolean | number): void;
+    validate(value: boolean | number | string): boolean;
+    parseValue(input: boolean | number | string): boolean | number | string;
+    serializeValue(value: boolean | number | string): boolean | number | string;
+    _parse(input: boolean | number | string): boolean;
+    _serialize(value: boolean | number | string): boolean;
+    _checkValue(value: boolean | number | string): void;
   }
   interface DateConstructor {
     refName: "Date";
@@ -305,10 +305,14 @@ Object.assign(String, scalarPrimitiveStatics, {
 });
 PrimitiveRegistry.register(String);
 
-const normalizeBooleanPrimitiveValue = (value: boolean | number): boolean | null => {
+const normalizeBooleanPrimitiveValue = (value: boolean | number | string): boolean | null => {
   if (typeof value === "boolean") return value;
   if (value === 1) return true;
   if (value === 0) return false;
+  if (typeof value !== "string") return null;
+  const text = value.trim().toLowerCase();
+  if (text === "true" || text === "1") return true;
+  if (text === "false" || text === "0") return false;
   return null;
 };
 
@@ -317,13 +321,13 @@ Object.assign(Boolean, {
   refName: "Boolean",
   [DEFAULT_VALUE]: false,
   [EXAMPLE_VALUE]: true,
-  validate(value: boolean | number) {
+  validate(value: boolean | number | string) {
     return normalizeBooleanPrimitiveValue(value) !== null;
   },
-  parseValue(input: boolean | number) {
+  parseValue(input: boolean | number | string) {
     return normalizeBooleanPrimitiveValue(input) ?? input;
   },
-  serializeValue(value: boolean | number) {
+  serializeValue(value: boolean | number | string) {
     return normalizeBooleanPrimitiveValue(value) ?? value;
   },
 });

package/common/index.ts

@@ -45,6 +45,7 @@ export { randomPicks } from "./randomPicks";
 export {
   assertUniqueRoutePatterns,
   compareRouteSpecificity,
+  getPageSourceFileViolation,
   getRouteExports,
   isRouteSourceFile,
   isSpecialRouteLeaf,

package/common/routeConvention.ts

@@ -67,27 +67,37 @@ export function isRouteSourceFile(filePath: string): boolean {
   return tryParseRouteModuleKey(key) !== null;
 }
 
-export function validatePageSourceFile(filePath: string, options: ValidatePageSourceFileOptions = {}): boolean {
-  if (!SOURCE_EXT_RE.test(filePath)) return false;
+/**
+ * Why a `page/` file breaks the route convention, or null when it is fine. Null also covers a non-source
+ * asset, which `page/` tolerates. `akan sync <lib>` reports these alongside its other layout violations,
+ * so the rule stays in one place instead of being restated where it cannot afford to throw.
+ */
+export function getPageSourceFileViolation(filePath: string): string | null {
+  if (!SOURCE_EXT_RE.test(filePath)) return null;
 
   const key = filePath.startsWith("./") ? filePath : `./${filePath.split(/[\\/]/).join("/")}`;
   const match = ROUTE_SOURCE_RE.exec(key);
-  const displayPath = options.filePath ?? key;
-  if (!match) throw new Error(`[route-convention] invalid page source file: ${displayPath}`);
+  if (!match) return "invalid page source file";
 
   const file = match[1] as string;
   const ext = match[2] as string;
   const leaf = file.split("/").filter(Boolean).at(-1);
-  if (!leaf) throw new Error(`[route-convention] invalid page source file: ${displayPath}`);
+  if (!leaf) return "invalid page source file";
 
-  if (ext !== "tsx") throw new Error(`[route-convention] route source files under page/ must use .tsx: ${displayPath}`);
+  if (ext !== "tsx") return "route source files under page/ must use .tsx";
   if (leaf.startsWith("_") && !RESERVED_ROUTE_FILES.has(leaf) && leaf !== INTERNAL_ROOT_LAYOUT_LEAF)
-    throw new Error(
-      `[route-convention] only _index.tsx, _layout.tsx and _overrides.tsx are allowed as reserved route files under page/: ${displayPath}`,
-    );
-  if (/^[A-Z]/.test(leaf))
-    throw new Error(`[route-convention] route page filenames must not start with an uppercase letter: ${displayPath}`);
-  return true;
+    return "only _index.tsx, _layout.tsx and _overrides.tsx are allowed as reserved route files under page/";
+  if (/^[A-Z]/.test(leaf)) return "route page filenames must not start with an uppercase letter";
+  return null;
+}
+
+export function validatePageSourceFile(filePath: string, options: ValidatePageSourceFileOptions = {}): boolean {
+  if (!SOURCE_EXT_RE.test(filePath)) return false;
+
+  const violation = getPageSourceFileViolation(filePath);
+  if (!violation) return true;
+  const key = filePath.startsWith("./") ? filePath : `./${filePath.split(/[\\/]/).join("/")}`;
+  throw new Error(`[route-convention] ${violation}: ${options.filePath ?? key}`);
 }
 
 export function validateSubRoutePageKey(

package/fetch/client/fetchClient.ts

@@ -81,6 +81,7 @@ export class FetchClient {
   readonly handler: Record<string, FetchHandler>;
   readonly slice: Record<string, SliceMeta> = {};
   readonly sortKeyMap = new Map<string, string[]>();
+  readonly #originWs = new Map<string, WsClient>();
   readonly #handlerStore: Record<string, FetchHandler> = {};
   readonly #handlerFactory = new Map<string, FetchHandlerFactory>();
   #sharedRegistryAppliedVersion = 0;
@@ -95,8 +96,7 @@ export class FetchClient {
   ) {
     this.origin = origin;
     this.http = new HttpClient(origin, ErrorCls);
-    const wsUri = `${origin.replace("http://", "ws://").replace("https://", "wss://")}/ws`;
-    this.ws = new WsClient(wsUri, ErrorCls);
+    this.ws = new WsClient(FetchClient.#makeWsUri(origin), ErrorCls);
     Object.assign(this.#handlerStore, handler);
     this.handler = this.#makeHandlerProxy();
     this.applySignal(serializedSignal);
@@ -158,6 +158,7 @@ export class FetchClient {
     this.ErrorCls = ErrorCls;
     this.http.setErrorConstructor(ErrorCls);
     this.ws.setErrorConstructor(ErrorCls);
+    for (const ws of this.#originWs.values()) ws.setErrorConstructor(ErrorCls);
   }
   applySignal(serializedSignal: { [key: string]: SerializedSignal }, { share = true }: { share?: boolean } = {}) {
     if (share && Object.keys(serializedSignal).length > 0) {
@@ -232,6 +233,8 @@ export class FetchClient {
   }
   disconnect() {
     this.ws.destroy();
+    for (const ws of this.#originWs.values()) ws.destroy();
+    this.#originWs.clear();
   }
   clone({ origin, connect = true, jwt }: { origin?: string; connect?: boolean; jwt?: string } = {}) {
     const instance = new FetchClient(origin ?? this.origin, {}, this.serializedSignal, this.ErrorCls);
@@ -245,6 +248,20 @@ export class FetchClient {
   setJwt(jwt: string | null) {
     this.jwt = jwt;
     this.ws.setJwt(jwt);
+    for (const ws of this.#originWs.values()) ws.setJwt(jwt);
+  }
+
+  #resolveWs(origin?: string) {
+    if (!origin) return this.ws;
+    const target = origin.replace(/\/+$/, "");
+    if (target === this.origin.replace(/\/+$/, "")) return this.ws;
+    const cached = this.#originWs.get(target);
+    if (cached) return cached;
+    const ws = new WsClient(FetchClient.#makeWsUri(target), this.ErrorCls);
+    this.#originWs.set(target, ws);
+    ws.setJwt(this.jwt);
+    ws.connect();
+    return ws;
   }
   #makeAuthHeaders(option?: FetchPolicy): Record<string, string> {
     if (option?.token) return { Authorization: `Bearer ${option.token}` };
@@ -338,13 +355,13 @@ export class FetchClient {
               handleEvent(parsedReturn);
             };
             wrappedListeners.set(handleEvent, wrapped);
-            this.ws.subscribe({
+            const ws = this.#resolveWs(fetchPolicy?.origin);
+            ws.subscribe({
               key,
               data,
               handleEvent: wrapped,
             });
-            return () =>
-              this.ws.unsubscribe({ key, data, handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent });
+            return () => ws.unsubscribe({ key, data, handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent });
           };
         });
         return;
@@ -356,8 +373,9 @@ export class FetchClient {
           const serializerMap = this.#makeArgSerializer(endpoint.args);
           return (...argData: unknown[]) => {
             const args = argData.slice(0, msgArgLength);
+            const fetchPolicy = argData[msgArgLength] as FetchPolicy | undefined;
             const data = msgArgs.map((arg, idx) => serializerMap.get(arg.name)?.(args[idx]) ?? null);
-            this.ws.emit(key, data);
+            this.#resolveWs(fetchPolicy?.origin).emit(key, data);
           };
         });
         this.#setHandlerFactory(`listen${capitalize(key)}`, () => {
@@ -369,8 +387,9 @@ export class FetchClient {
               handleEvent(parsedReturn);
             };
             wrappedListeners.set(handleEvent, wrapped);
-            this.ws.on(key, wrapped);
-            return () => this.ws.off(key, wrappedListeners.get(handleEvent) ?? handleEvent);
+            const ws = this.#resolveWs(fetchPolicy.origin);
+            ws.on(key, wrapped);
+            return () => ws.off(key, wrappedListeners.get(handleEvent) ?? handleEvent);
           }) as FetchHandler;
         });
         return;
@@ -380,6 +399,10 @@ export class FetchClient {
         break;
     }
   }
+  static #makeWsUri(origin: string) {
+    return `${origin.replace("http://", "ws://").replace("https://", "wss://")}/ws`;
+  }
+
   static paginationArgs: SerializedArg[] = [
     { type: "search", name: "skip", refName: "Int" },
     { type: "search", name: "limit", refName: "Int" },

package/fetch/client/wsClient.ts

@@ -41,6 +41,7 @@ export class WsClient {
   #listenerMap = new Map<string, Set<Listener>>();
   #destroyed = false;
   #connectRequested = false;
+  #outbox: string[] = [];
   #unconnectedWarnTimers = new Map<string, ReturnType<typeof setTimeout>>();
   #jwt: string | null = null;
   connected = false;
@@ -94,6 +95,9 @@ export class WsClient {
         const data: WebsocketReqData = { key: option.key, data: option.data, subscribe: true };
         this.#ws?.send(JSON.stringify(data));
       });
+      const queued = this.#outbox;
+      this.#outbox = [];
+      for (const frame of queued) this.#ws?.send(frame);
     };
     this.#ws.onmessage = (e) => {
       try {
@@ -197,6 +201,7 @@ export class WsClient {
     }
     for (const timer of this.#unconnectedWarnTimers.values()) clearTimeout(timer);
     this.#unconnectedWarnTimers.clear();
+    this.#outbox = [];
     this.#ws?.close();
     this.#ws = null;
   }
@@ -240,28 +245,31 @@ export class WsClient {
       `[akanjs] WebSocket is not connected. Call fetch.instance.connect(), or drop the root layout "wsConnect = false", before ${action} "${key}".`,
     );
   }
-  #warnUnconnectedSubscribe(key: string) {
-    if (this.#connectRequested || this.#unconnectedWarnTimers.has(key)) return;
+  #warnUnconnected(action: "emit" | "subscribe", key: string) {
+    const timerKey = `${action}:${key}`;
+    if (this.#connectRequested || this.#unconnectedWarnTimers.has(timerKey)) return;
     const timer = setTimeout(() => {
-      this.#unconnectedWarnTimers.delete(key);
+      this.#unconnectedWarnTimers.delete(timerKey);
       if (this.#connectRequested || this.#destroyed) return;
-      this.#warnNotConnected("subscribe", key);
+      this.#warnNotConnected(action, key);
     }, 0);
-    this.#unconnectedWarnTimers.set(key, timer);
+    this.#unconnectedWarnTimers.set(timerKey, timer);
   }
   emit(key: string, data: WsRequestPayload) {
+    const payload: WebsocketReqData = { key, data: Array.isArray(data) ? data : [data] };
+    const frame = JSON.stringify(payload);
+
     if (this.#ws?.readyState !== WebSocket.OPEN) {
-      this.logger.warn("WebSocket not connected");
-      this.#warnNotConnected("emit", key);
+      this.#outbox.push(frame);
+      this.#warnUnconnected("emit", key);
       return this;
     }
-    const payload: WebsocketReqData = { key, data: Array.isArray(data) ? data : [data] };
-    this.#ws.send(JSON.stringify(payload));
+    this.#ws.send(frame);
     return this;
   }
   subscribe(option: { key: string; data: unknown[]; handleEvent: (data: unknown) => void }) {
     const roomId = WsClient.makeRoomId(option.key, option.data);
-    if (!this.#ws) this.#warnUnconnectedSubscribe(option.key);
+    if (!this.#ws) this.#warnUnconnected("subscribe", option.key);
     if (!this.#roomSubscribeMap.has(roomId)) {
       this.#roomSubscribeMap.set(roomId, { key: option.key, data: option.data, listener: new Set() });
       if (this.#ws?.readyState === WebSocket.OPEN) {

package/fetch/fetchType/endpointFetch.type.ts

@@ -44,7 +44,7 @@ type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
 /** Typed off `PromptResult` rather than the endpoint's return ref, which is the `Any` carrier a prompt rides on. */
 type PromptFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<PromptMessage[]>;
 
-type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => void;
+type MessageEmitFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => void;
 
 type MessageListenFn<E, SlceCls extends SliceCls | never> = (
   handleEvent: (data: EndpInfoReturns<E, SlceCls>) => PromiseOrObject<void>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.44",
+  "version": "3.0.0-alpha.46",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/service/adapt.ts

@@ -4,8 +4,8 @@ import { type ExtractInjectInfoObject, type InjectBuilder, type InjectInfo, inje
 
 export interface Adaptor {
   readonly logger: Logger;
-  onInit(): Promise<void>;
-  onDestroy(): Promise<void>;
+  onInit(): Promise<void> | void;
+  onDestroy(): Promise<void> | void;
 }
 
 export type AdaptorCls<
@@ -30,9 +30,9 @@ export function adapt(name: string, injectBuilder?: InjectBuilder) {
     readonly logger = new Logger(name);
     static readonly [INJECT_META] = injectInfoMap;
     static readonly refName = name;
-    async onInit() {
+    onInit(): Promise<void> | void {
     }
-    async onDestroy() {
+    onDestroy(): Promise<void> | void {
     }
   }
   return Adaptor;

package/service/predefinedAdaptor/database.adaptor.ts

@@ -18,6 +18,7 @@ import {
   type DocumentUpdateOptions,
   documentQueryHelper,
   encodeDocumentValue,
+  isDocumentId,
   isDocumentUpdateNode,
   NoDocumentError,
   resolveDocumentUpdate,
@@ -1033,6 +1034,7 @@ export class SqlDocumentStore {
   async create(data: DocumentRecord, { runSaveHooks = true }: WriteHookOptions = {}) {
     const now = Date.now();
     const id = data.id ?? createDocumentId(now);
+    if (!isDocumentId(id)) throw new Error(`Invalid ID value: ${id}`);
     const doc = this.hydrate(
       this.prepareDocument({
         ...data,

package/service/serve.ts

@@ -43,9 +43,9 @@ const avoidKeys = new Set([
 export interface Service {
   readonly logger: Logger;
   
-  onInit(): Promise<void>;
+  onInit(): Promise<void> | void;
   _libsOnInit(): Promise<void>;
-  onDestroy(): Promise<void>;
+  onDestroy(): Promise<void> | void;
   _libsOnDestroy(): Promise<void>;
 }
 
@@ -121,9 +121,9 @@ export function serve(
     }
     static [INJECT_META] = {};
     readonly logger = new Logger(this.constructor.name);
-    async onInit() {
+    onInit(): Promise<void> | void {
     }
-    async onDestroy() {
+    onDestroy(): Promise<void> | void {
     }
   };
   applyMixins(srvRef, extSrvs, avoidKeys);
@@ -132,10 +132,11 @@ export function serve(
   const onDestroyFns = extSrvs.map((srv) => srv.prototype.onDestroy);
   Object.assign(srvRef.prototype, {
     async _libsOnInit(this: Service) {
-      await Promise.all([...onInitFns.map((onInit) => onInit?.call(this)), this.onInit()]);
+      
+      await Promise.all([...onInitFns, this.onInit].map(async (onInit) => await onInit?.call(this)));
     },
     async _libsOnDestroy(this: Service) {
-      await Promise.all([...onDestroyFns.map((onDestroy) => onDestroy?.call(this)), this.onDestroy()]);
+      await Promise.all([...onDestroyFns, this.onDestroy].map(async (onDestroy) => await onDestroy?.call(this)));
     },
   });
 

package/signal/intercept.ts

@@ -7,8 +7,8 @@ export type InterceptorCls<Methods = {}, InjectMap extends { [key: string]: Inje
   Methods &
     ExtractInjectInfoObject<InjectMap> & {
       readonly logger: Logger;
-      onInit(): Promise<void>;
-      onDestroy(): Promise<void>;
+      onInit(): Promise<void> | void;
+      onDestroy(): Promise<void> | void;
       intercept(context: SignalContext): AsyncGenerator<unknown> | Promise<unknown>;
     },
   { readonly [INJECT_META]: InjectMap; readonly refName: string }
@@ -31,9 +31,9 @@ export function intercept(refName: string, injectBuilder?: InjectBuilder) {
     intercept(context: SignalContext): AsyncGenerator | Promise<(res: Response) => Promise<Response>> {
       return Promise.resolve((res: Response) => Promise.resolve(res));
     }
-    async onInit() {
+    onInit(): Promise<void> | void {
     }
-    async onDestroy() {
+    onDestroy(): Promise<void> | void {
     }
   };
 }

package/types/base/primitiveRegistry.d.ts

@@ -114,12 +114,12 @@ declare global {
         [DEFAULT_VALUE]: boolean;
         [PURIFIED_VALUE]: boolean;
         [EXAMPLE_VALUE]: boolean;
-        validate(value: boolean | number): boolean;
-        parseValue(input: boolean | number): boolean | number;
-        serializeValue(value: boolean | number): boolean | number;
-        _parse(input: boolean | number): boolean;
-        _serialize(value: boolean | number): boolean;
-        _checkValue(value: boolean | number): void;
+        validate(value: boolean | number | string): boolean;
+        parseValue(input: boolean | number | string): boolean | number | string;
+        serializeValue(value: boolean | number | string): boolean | number | string;
+        _parse(input: boolean | number | string): boolean;
+        _serialize(value: boolean | number | string): boolean;
+        _checkValue(value: boolean | number | string): void;
     }
     interface DateConstructor {
         refName: "Date";

package/types/common/index.d.ts

@@ -24,7 +24,7 @@ export { pathGet } from "./pathGet.d.ts";
 export { pathSet } from "./pathSet.d.ts";
 export { randomPick } from "./randomPick.d.ts";
 export { randomPicks } from "./randomPicks.d.ts";
-export { assertUniqueRoutePatterns, compareRouteSpecificity, getRouteExports, isRouteSourceFile, isSpecialRouteLeaf, LAYOUT_ROUTE_EXPORTS, matchRoutePattern, normalizeRoutePattern, PAGE_ROUTE_EXPORTS, type ParsedRouteModuleKey, parseRouteModuleKey, RESERVED_ROUTE_CONFIG_EXPORTS, ROOT_LAYOUT_ROUTE_EXPORTS, type RouteModuleKind, routeSegmentToPatternPart, routeSegmentToTreePath, tryParseRouteModuleKey, type ValidatePageSourceFileOptions, type ValidateSubRoutePageKeyOptions, validatePageSourceFile, validateSubRoutePageKey, } from "./routeConvention.d.ts";
+export { assertUniqueRoutePatterns, compareRouteSpecificity, getPageSourceFileViolation, getRouteExports, isRouteSourceFile, isSpecialRouteLeaf, LAYOUT_ROUTE_EXPORTS, matchRoutePattern, normalizeRoutePattern, PAGE_ROUTE_EXPORTS, type ParsedRouteModuleKey, parseRouteModuleKey, RESERVED_ROUTE_CONFIG_EXPORTS, ROOT_LAYOUT_ROUTE_EXPORTS, type RouteModuleKind, routeSegmentToPatternPart, routeSegmentToTreePath, tryParseRouteModuleKey, type ValidatePageSourceFileOptions, type ValidateSubRoutePageKeyOptions, validatePageSourceFile, validateSubRoutePageKey, } from "./routeConvention.d.ts";
 export { sleep } from "./sleep.d.ts";
 export { splitVersion } from "./splitVersion.d.ts";
 export { getBasePathFromPathname, parseBasePaths, parseSubRouteHosts, resolveSubRouteHosts } from "./subRoute.d.ts";

package/types/common/routeConvention.d.ts

@@ -27,6 +27,12 @@ export interface ValidatePageSourceFileOptions {
     filePath?: string;
 }
 export declare function isRouteSourceFile(filePath: string): boolean;
+/**
+ * Why a `page/` file breaks the route convention, or null when it is fine. Null also covers a non-source
+ * asset, which `page/` tolerates. `akan sync <lib>` reports these alongside its other layout violations,
+ * so the rule stays in one place instead of being restated where it cannot afford to throw.
+ */
+export declare function getPageSourceFileViolation(filePath: string): string | null;
 export declare function validatePageSourceFile(filePath: string, options?: ValidatePageSourceFileOptions): boolean;
 export declare function validateSubRoutePageKey(key: string, basePaths: Iterable<string>, options?: ValidateSubRoutePageKeyOptions): void;
 export declare function parseRouteModuleKey(key: string): ParsedRouteModuleKey;

package/types/fetch/fetchType/endpointFetch.type.d.ts

@@ -7,7 +7,7 @@ type EndpInfoReturns<E, SlceCls extends SliceCls | never> = EndpointClientReturn
 type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<EndpInfoReturns<E, SlceCls>>;
 /** Typed off `PromptResult` rather than the endpoint's return ref, which is the `Any` carrier a prompt rides on. */
 type PromptFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<PromptMessage[]>;
-type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => void;
+type MessageEmitFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => void;
 type MessageListenFn<E, SlceCls extends SliceCls | never> = (handleEvent: (data: EndpInfoReturns<E, SlceCls>) => PromiseOrObject<void>, options?: FetchPolicy) => () => void;
 type PubsubSubscribeFn<E, SlceCls extends SliceCls | never> = (...args: [
     ...EndpInfoArgs<E>,

package/types/service/adapt.d.ts

@@ -3,8 +3,8 @@ import { Logger } from "akanjs/common";
 import { type ExtractInjectInfoObject, type InjectBuilder, type InjectInfo } from "./injectInfo.d.ts";
 export interface Adaptor {
     readonly logger: Logger;
-    onInit(): Promise<void>;
-    onDestroy(): Promise<void>;
+    onInit(): Promise<void> | void;
+    onDestroy(): Promise<void> | void;
 }
 export type AdaptorCls<Methods = any, InjectMap extends Record<string, InjectInfo> = {}> = Cls<Methods & ExtractInjectInfoObject<InjectMap> & Adaptor, {
     readonly [INJECT_META]: InjectMap;

package/types/service/serve.d.ts

@@ -10,9 +10,9 @@ interface ServiceOptions {
 export type ServiceType = "database" | "plain";
 export interface Service {
     readonly logger: Logger;
-    onInit(): Promise<void>;
+    onInit(): Promise<void> | void;
     _libsOnInit(): Promise<void>;
-    onDestroy(): Promise<void>;
+    onDestroy(): Promise<void> | void;
     _libsOnDestroy(): Promise<void>;
 }
 export type ServiceCls<RefName extends string = string, Methods = {}, InjectMap extends {

package/types/signal/intercept.d.ts

@@ -6,8 +6,8 @@ export type InterceptorCls<Methods = {}, InjectMap extends {
     [key: string]: InjectInfo;
 } = {}> = Cls<Methods & ExtractInjectInfoObject<InjectMap> & {
     readonly logger: Logger;
-    onInit(): Promise<void>;
-    onDestroy(): Promise<void>;
+    onInit(): Promise<void> | void;
+    onDestroy(): Promise<void> | void;
     intercept(context: SignalContext): AsyncGenerator<unknown> | Promise<unknown>;
 }, {
     readonly [INJECT_META]: InjectMap;