Make timers integrated into kernel

Author: Wesley-Young

.changeset/quiet-timers-share.md

@@ -0,0 +1,6 @@
+---
+"@fraqjs/fraq": minor
+"@fraqjs/kernel": minor
+---
+
+将 `timeout` 和 `interval` 集成到 `@fraqjs/kernel`

packages/fraq/src/core/context/index.ts

@@ -12,7 +12,6 @@ import type { Filter } from '../filter';
 import type { LogHandler } from '../logging';
 import { ApiHookRegistry } from './api-hooks';
 import { EventSourceRegistry } from './event-sources';
-import { TimerRegistry } from './timers';
 
 export interface ContextOptions {
   reconnect?: {
@@ -42,7 +41,6 @@ interface Subsystems {
   readonly detachParentEvents: (() => void) | undefined;
   readonly apiHooks: ApiHookRegistry;
   readonly eventSources: EventSourceRegistry;
-  readonly timers: TimerRegistry;
 }
 
 interface Builtins {
@@ -55,8 +53,6 @@ interface Builtins {
     <E extends ApiEndpointName>(endpoint: E, hook: ApiHook<E>): () => void;
     (hook: AnyApiHook): () => void;
   };
-  timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
-  interval(intervalMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
   createSession(selfId: number, message: IncomingMessage): Session;
 }
 
@@ -134,11 +130,6 @@ const ContextRuntime = defineContext<RootOptions, Filter>()
       create: () => new ApiHookRegistry(baseClient, parent?.systems.apiHooks, name, getState),
       stop: (registry) => registry.clear(),
     });
-    const timers = subsystem({
-      name: 'timers',
-      create: () => new TimerRegistry(name, logger, getState),
-      suspend: (registry) => registry.clear(),
-    });
     const eventSources = subsystem({
       name: 'eventSources',
       create: () =>
@@ -155,7 +146,6 @@ const ContextRuntime = defineContext<RootOptions, Filter>()
       detachParentEvents,
       apiHooks,
       eventSources,
-      timers,
     };
   })
   .builtins<Builtins>(({ logger, rootOptions, parent, systems, getState }) => {
@@ -185,8 +175,6 @@ const ContextRuntime = defineContext<RootOptions, Filter>()
       installEventSource: (eventSource) => systems.eventSources.install(eventSource),
       hookApi: (endpointOrHook: ApiEndpointName | AnyApiHook, hook?: ApiHook<ApiEndpointName>) =>
         systems.apiHooks.register(endpointOrHook, hook),
-      timeout: (delayMs, callback) => systems.timers.timeout(delayMs, callback),
-      interval: (intervalMs, callback) => systems.timers.interval(intervalMs, callback),
       createSession: (selfId, message) => createSession(systems.apiHooks.client, selfId, message),
     };
   })

packages/kernel/src/context/index.ts

@@ -8,6 +8,7 @@ import { type ContextState, LifecycleManager } from './lifecycle';
 import { PluginRegistry, type PluginRegistryOptions } from './plugins';
 import { ServiceRegistry, type ServiceResolutionScope } from './services';
 import { type SubsystemDefinition, SubsystemRegistry } from './subsystems';
+import { TimerRegistry } from './timers';
 
 export type { ContextState } from './lifecycle';
 export type { SubsystemCleanupResult, SubsystemDefinition, SubsystemHooks } from './subsystems';
@@ -18,6 +19,8 @@ export interface KernelContext<C extends object, ForkOptions> {
   readonly state: ContextState;
   readonly logger: Logger;
   readonly logBus: LogEmitter;
+  timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
+  interval(intervalMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
 
   install<T extends ParameterList>(plugin: PluginDefinition<C, T>, ...args: T): void;
 
@@ -169,6 +172,7 @@ export class ContextBuilder<RootOptions, ForkOptions, Subsystems = never, Builti
       private readonly services: ServiceRegistry<Context>;
       private readonly serviceScope: ServiceResolutionScope<Context>;
       private readonly subsystems = new SubsystemRegistry();
+      private readonly timers: TimerRegistry;
       private readonly systems: Subsystems;
       private readonly plugins: PluginRegistry<Context>;
       private readonly lifecycle: LifecycleManager<Context>;
@@ -191,6 +195,11 @@ export class ContextBuilder<RootOptions, ForkOptions, Subsystems = never, Builti
         this.services = new ServiceRegistry(parent?.services);
 
         const getState = () => this.lifecycle.state;
+        this.timers = this.subsystems.register({
+          name: 'timers',
+          create: () => new TimerRegistry(name, this.logger, getState),
+          suspend: (timers) => timers.clear(),
+        });
         this.systems = createSubsystems({
           name,
           path: this.path,
@@ -248,6 +257,14 @@ export class ContextBuilder<RootOptions, ForkOptions, Subsystems = never, Builti
         return this.lifecycle.state;
       }
 
+      timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout {
+        return this.timers.timeout(delayMs, callback);
+      }
+
+      interval(intervalMs: number, callback: () => void | Promise<void>): NodeJS.Timeout {
+        return this.timers.interval(intervalMs, callback);
+      }
+
       install<T extends ParameterList>(plugin: PluginDefinition<Context, T>, ...args: T): void {
         this.plugins.install(plugin, ...args);
       }

packages/fraq/src/core/context/timers.ts packages/kernel/src/context/timers.tspackages/fraq/src/core/context/timers.ts renamed to packages/kernel/src/context/timers.ts

@@ -1,6 +1,5 @@
-import type { ContextState } from '@fraqjs/kernel';
-
 import type { Logger } from '../logging';
+import type { ContextState } from './lifecycle';
 
 export class TimerRegistry {
   private readonly timers = new Set<NodeJS.Timeout>();
@@ -11,10 +10,6 @@ export class TimerRegistry {
     private readonly getState: () => ContextState,
   ) {}
 
-  get hasTimers(): boolean {
-    return this.timers.size > 0;
-  }
-
   timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout {
     this.assertCanScheduleTimer();
     const timeout = setTimeout(() => {