Update task link service to new typed event emitter

Author: charlesvien

apps/array/src/main/di/container.ts

@@ -10,9 +10,9 @@ import { FsService } from "../services/fs/service.js";
 import { GitService } from "../services/git/service.js";
 import { OAuthService } from "../services/oauth/service.js";
 import { ShellService } from "../services/shell/service.js";
+import { TaskLinkService } from "../services/task-link/service.js";
 import { UpdatesService } from "../services/updates/service.js";
 import { MAIN_TOKENS } from "./tokens.js";
-import { TaskLinkService } from "../services/task-link/service.js";
 
 export const container = new Container({
   defaultScope: "Singleton",
@@ -29,4 +29,4 @@ container.bind(MAIN_TOKENS.GitService).to(GitService);
 container.bind(MAIN_TOKENS.OAuthService).to(OAuthService);
 container.bind(MAIN_TOKENS.ShellService).to(ShellService);
 container.bind(MAIN_TOKENS.UpdatesService).to(UpdatesService);
-container.bind(MAIN_TOKENS.TaskLinkService).to(TaskLinkService);
+container.bind(MAIN_TOKENS.TaskLinkService).to(TaskLinkService);

apps/array/src/main/index.ts

@@ -43,9 +43,9 @@ import {
   shutdownPostHog,
   trackAppEvent,
 } from "./services/posthog-analytics.js";
+import type { TaskLinkService } from "./services/task-link/service";
 import type { UpdatesService } from "./services/updates/service.js";
 import { registerWorkspaceIpc } from "./services/workspace/index.js";
-import { TaskLinkService } from "./services/task-link/service";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

apps/array/src/main/services/deep-link/service.ts

@@ -52,7 +52,7 @@ export class DeepLinkService {
 
   /**
    * Handle an incoming deep link URL
-   * 
+   *
    * NOTE: Strips the protocol and main key, passing only dynamic segments to handlers.
    */
   public handleUrl(url: string): boolean {
@@ -83,7 +83,9 @@ export class DeepLinkService {
       // Extract path segments after the main key (strip leading slash)
       const pathSegments = parsedUrl.pathname.slice(1);
 
-      log.info(`Routing deep link to '${mainKey}' handler with path: ${pathSegments || "(empty)"}`);
+      log.info(
+        `Routing deep link to '${mainKey}' handler with path: ${pathSegments || "(empty)"}`,
+      );
       return handler(pathSegments, parsedUrl.searchParams);
     } catch (error) {
       log.error("Failed to parse deep link URL:", error);

apps/array/src/main/services/oauth/service.ts

@@ -52,8 +52,8 @@ export class OAuthService {
     private readonly deepLinkService: DeepLinkService,
   ) {
     // Register OAuth callback handler for deep links
-    this.deepLinkService.registerHandler("callback", (url) =>
-      this.handleOAuthCallback(url),
+    this.deepLinkService.registerHandler("callback", (_path, searchParams) =>
+      this.handleOAuthCallback(searchParams),
     );
     log.info("Registered OAuth callback handler for deep links");
   }

apps/array/src/main/services/task-link/service.ts

@@ -1,30 +1,32 @@
-import { EventEmitter } from "node:events";
-import { injectable } from "inversify";
+import { inject, injectable } from "inversify";
+import { MAIN_TOKENS } from "../../di/tokens.js";
 import { logger } from "../../lib/logger.js";
+import { TypedEventEmitter } from "../../lib/typed-event-emitter.js";
 import { getMainWindow } from "../../trpc/context.js";
-import type { DeepLinkHandler } from "../deep-link/service.js";
+import type { DeepLinkService } from "../deep-link/service.js";
 
 const log = logger.scope("task-link-service");
 
-@injectable()
-export class TaskLinkService {
-  private emitter = new EventEmitter();
-
-  /**
-   * Get the deep link handler for task links.
-   * Register this with DeepLinkService for the "task" key.
-   * Expects URLs like: array://task/{taskId}
-   */
-  public getDeepLinkHandler(): DeepLinkHandler {
-    return (path) => this.handleTaskLink(path);
-  }
+export const TaskLinkEvent = {
+  OpenTask: "openTask",
+} as const;
 
-  /**
-   * Subscribe to task link events.
-   */
-  public onTaskLink(callback: (taskId: string) => void): () => void {
-    this.emitter.on("task", callback);
-    return () => this.emitter.off("task", callback);
+export interface TaskLinkEvents {
+  [TaskLinkEvent.OpenTask]: { taskId: string };
+}
+
+@injectable()
+export class TaskLinkService extends TypedEventEmitter<TaskLinkEvents> {
+  constructor(
+    @inject(MAIN_TOKENS.DeepLinkService)
+    private readonly deepLinkService: DeepLinkService,
+  ) {
+    super();
+    // Register task link handler for deep links
+    this.deepLinkService.registerHandler("task", (path) =>
+      this.handleTaskLink(path),
+    );
+    log.info("Registered task link handler for deep links");
   }
 
   private handleTaskLink(path: string): boolean {
@@ -37,7 +39,7 @@ export class TaskLinkService {
     }
 
     log.info(`Emitting task link event: ${taskId}`);
-    this.emitter.emit("task", taskId);
+    this.emit(TaskLinkEvent.OpenTask, { taskId });
 
     // Focus the window
     const mainWindow = getMainWindow();

apps/array/src/main/trpc/router.ts

@@ -1,5 +1,5 @@
-import { deepLinkRouter } from "./routers/deep-link.js";
 import { contextMenuRouter } from "./routers/context-menu.js";
+import { deepLinkRouter } from "./routers/deep-link.js";
 import { dockBadgeRouter } from "./routers/dock-badge.js";
 import { encryptionRouter } from "./routers/encryption.js";
 import { externalAppsRouter } from "./routers/external-apps.js";

apps/array/src/main/trpc/routers/deep-link.ts

@@ -1,39 +1,26 @@
-import { get } from "../../di/container.js";
+import { on } from "node:events";
+import { container } from "../../di/container.js";
 import { MAIN_TOKENS } from "../../di/tokens.js";
-import type { TaskLinkService } from "../../services/task-link/service.js";
+import {
+  TaskLinkEvent,
+  type TaskLinkEvents,
+  type TaskLinkService,
+} from "../../services/task-link/service.js";
 import { publicProcedure, router } from "../trpc.js";
 
+const getService = () =>
+  container.get<TaskLinkService>(MAIN_TOKENS.TaskLinkService);
+
 export const deepLinkRouter = router({
   /**
    * Subscribe to task link deep link events.
    * Emits task ID when array://task/{taskId} is opened.
    */
-  onOpenTask: publicProcedure.subscription(async function* () {
-    const taskLinkService = get<TaskLinkService>(MAIN_TOKENS.TaskLinkService);
-
-    // Create a queue to buffer events
-    const queue: string[] = [];
-    let resolve: (() => void) | null = null;
-
-    const unsubscribe = taskLinkService.onTaskLink((taskId) => {
-      queue.push(taskId);
-      resolve?.();
-    });
-
-    try {
-      while (true) {
-        if (queue.length === 0) {
-          await new Promise<void>((r) => {
-            resolve = r;
-          });
-        }
-        const taskId = queue.shift();
-        if (taskId) {
-          yield taskId;
-        }
-      }
-    } finally {
-      unsubscribe();
+  onOpenTask: publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    const options = opts.signal ? { signal: opts.signal } : undefined;
+    for await (const [payload] of on(service, TaskLinkEvent.OpenTask, options)) {
+      yield payload as TaskLinkEvents[typeof TaskLinkEvent.OpenTask];
     }
   }),
 });