@codemation/host 0.0.1

package/src/presentation/server/WorkflowDiscoveryPathSegmentsComputer.ts

@@ -0,0 +1,53 @@
+import path from "node:path";
+
+import { WorkflowModulePathFinder } from "./WorkflowModulePathFinder";
+
+export class WorkflowDiscoveryPathSegmentsComputer {
+  compute(
+    args: Readonly<{
+      consumerRoot: string;
+      workflowDiscoveryDirectories: ReadonlyArray<string>;
+      absoluteWorkflowModulePath: string;
+    }>,
+  ): readonly string[] | undefined {
+    const normalizedConsumer = path.resolve(args.consumerRoot);
+    const normalizedWorkflowPath = path.resolve(args.absoluteWorkflowModulePath);
+    const directories =
+      args.workflowDiscoveryDirectories.length > 0
+        ? args.workflowDiscoveryDirectories
+        : [...WorkflowModulePathFinder.defaultWorkflowDirectories];
+
+    let bestRoot: string | null = null;
+    for (const directory of directories) {
+      const absoluteDirectory = path.resolve(normalizedConsumer, directory);
+      const isPrefix =
+        normalizedWorkflowPath === absoluteDirectory ||
+        normalizedWorkflowPath.startsWith(`${absoluteDirectory}${path.sep}`);
+      if (!isPrefix) {
+        continue;
+      }
+      if (!bestRoot || absoluteDirectory.length > bestRoot.length) {
+        bestRoot = absoluteDirectory;
+      }
+    }
+    if (!bestRoot) {
+      return undefined;
+    }
+    const relative = path.relative(bestRoot, normalizedWorkflowPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+      return undefined;
+    }
+    if (relative.length === 0) {
+      return undefined;
+    }
+    const parts = relative.split(path.sep).filter((segment) => segment.length > 0);
+    if (parts.length === 0) {
+      return undefined;
+    }
+    const lastIndex = parts.length - 1;
+    const last = parts[lastIndex] ?? "";
+    const ext = path.extname(last);
+    parts[lastIndex] = ext ? last.slice(0, -ext.length) : last;
+    return parts;
+  }
+}

package/src/presentation/server/WorkflowModulePathFinder.ts

@@ -0,0 +1,47 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+
+export class WorkflowModulePathFinder {
+  static readonly defaultWorkflowDirectories = ["src/workflows", "workflows"] as const;
+  private readonly workflowExtensions = new Set([".ts", ".js", ".mts", ".mjs"]);
+
+  async discoverModulePaths(
+    args: Readonly<{
+      consumerRoot: string;
+      workflowDirectories: ReadonlyArray<string> | undefined;
+      exists: (absolutePath: string) => Promise<boolean>;
+    }>,
+  ): Promise<ReadonlyArray<string>> {
+    const directories = args.workflowDirectories ?? WorkflowModulePathFinder.defaultWorkflowDirectories;
+    const workflowModulePaths: string[] = [];
+    for (const directory of directories) {
+      const absoluteDirectory = path.resolve(args.consumerRoot, directory);
+      if (!(await args.exists(absoluteDirectory))) {
+        continue;
+      }
+      workflowModulePaths.push(...(await this.collectWorkflowModulePaths(absoluteDirectory)));
+    }
+    return workflowModulePaths;
+  }
+
+  private async collectWorkflowModulePaths(directoryPath: string): Promise<ReadonlyArray<string>> {
+    const entries = await readdir(directoryPath, { withFileTypes: true });
+    const workflowModulePaths: string[] = [];
+    for (const entry of entries) {
+      const entryPath = path.resolve(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        workflowModulePaths.push(...(await this.collectWorkflowModulePaths(entryPath)));
+        continue;
+      }
+      if (this.isWorkflowModulePath(entryPath)) {
+        workflowModulePaths.push(entryPath);
+      }
+    }
+    return workflowModulePaths;
+  }
+
+  private isWorkflowModulePath(modulePath: string): boolean {
+    const extension = path.extname(modulePath);
+    return this.workflowExtensions.has(extension) && !modulePath.endsWith(".d.ts");
+  }
+}

package/src/presentation/websocket/WorkflowWebsocketServer.ts

@@ -0,0 +1,169 @@
+import { WebSocket, WebSocketServer } from "ws";
+import type { WorkflowWebsocketMessage } from "../../application/contracts/WorkflowWebsocketMessage";
+import type { Logger } from "../../application/logging/Logger";
+import type { WorkflowWebsocketPublisher } from "../../application/websocket/WorkflowWebsocketPublisher";
+import { ApiPaths } from "../http/ApiPaths";
+
+type WorkflowWebsocketClientMessage =
+  | Readonly<{ kind: "subscribe"; roomId: string }>
+  | Readonly<{ kind: "unsubscribe"; roomId: string }>;
+
+type WorkflowWebsocketControlMessage =
+  | Readonly<{ kind: "ready" }>
+  | Readonly<{ kind: "subscribed"; roomId: string }>
+  | Readonly<{ kind: "unsubscribed"; roomId: string }>
+  | Readonly<{ kind: "error"; message: string }>;
+
+type WorkflowWebsocketServerMessage = WorkflowWebsocketControlMessage | WorkflowWebsocketMessage;
+
+export class WorkflowWebsocketServer implements WorkflowWebsocketPublisher {
+  private websocketServer: WebSocketServer | null = null;
+  private readonly sockets = new Set<WebSocket>();
+  private readonly roomIdsBySocket = new Map<WebSocket, Set<string>>();
+  private started = false;
+
+  constructor(
+    private readonly port: number,
+    private readonly bindHost: string,
+    private readonly logger: Logger,
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+    const websocketServer = new WebSocketServer({
+      host: this.bindHost,
+      port: this.port,
+      path: ApiPaths.workflowWebsocket(),
+    });
+    this.websocketServer = websocketServer;
+    websocketServer.on("connection", (socket) => {
+      void this.connect(socket);
+    });
+    try {
+      await this.awaitListening(websocketServer);
+    } catch (error) {
+      this.websocketServer = null;
+      await this.closeAfterFailedStart(websocketServer);
+      throw error;
+    }
+    this.logger.debug(`listening on ws://${this.bindHost}:${this.port}${ApiPaths.workflowWebsocket()}`);
+    this.started = true;
+  }
+
+  async stop(): Promise<void> {
+    if (!this.websocketServer) {
+      return;
+    }
+    this.started = false;
+    for (const socket of this.sockets) {
+      socket.removeAllListeners();
+      socket.terminate();
+    }
+    this.sockets.clear();
+    this.roomIdsBySocket.clear();
+    const websocketServer = this.websocketServer;
+    this.websocketServer = null;
+    await new Promise<void>((resolve, reject) => {
+      websocketServer.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  async publishToRoom(roomId: string, message: WorkflowWebsocketMessage): Promise<void> {
+    let deliveredSocketCount = 0;
+    for (const [socket, roomIds] of this.roomIdsBySocket) {
+      if (socket.readyState !== WebSocket.OPEN || !roomIds.has(roomId)) {
+        continue;
+      }
+      socket.send(JSON.stringify(message satisfies WorkflowWebsocketServerMessage));
+      deliveredSocketCount += 1;
+    }
+    if (message.kind === "event") {
+      const event = message.event;
+      const eventLabel =
+        "snapshot" in event && event.snapshot
+          ? `${event.kind}:${event.runId}:${event.snapshot.nodeId}:${event.snapshot.status}`
+          : `${event.kind}:${event.runId}`;
+      this.logger.debug(`published room=${roomId} sockets=${deliveredSocketCount} event=${eventLabel}`);
+      return;
+    }
+    this.logger.debug(`published room=${roomId} sockets=${deliveredSocketCount} kind=${message.kind}`);
+  }
+
+  private async connect(socket: WebSocket): Promise<void> {
+    this.sockets.add(socket);
+    this.roomIdsBySocket.set(socket, new Set());
+    this.logger.debug(`client connected activeSockets=${this.sockets.size}`);
+    socket.send(JSON.stringify({ kind: "ready" } satisfies WorkflowWebsocketServerMessage));
+    socket.on("message", (rawData) => {
+      void this.handleMessage(socket, rawData);
+    });
+    socket.on("close", () => {
+      this.sockets.delete(socket);
+      this.roomIdsBySocket.delete(socket);
+      this.logger.debug(`client disconnected activeSockets=${this.sockets.size}`);
+    });
+    socket.on("error", () => {
+      this.sockets.delete(socket);
+      this.roomIdsBySocket.delete(socket);
+      this.logger.warn(`client socket error activeSockets=${this.sockets.size}`);
+    });
+  }
+
+  private async handleMessage(socket: WebSocket, rawData: unknown): Promise<void> {
+    try {
+      const message = this.parseClientMessage(rawData);
+      if (message.kind === "subscribe") {
+        this.roomIdsBySocket.get(socket)?.add(message.roomId);
+        this.logger.debug(`subscribed room=${message.roomId}`);
+        socket.send(
+          JSON.stringify({ kind: "subscribed", roomId: message.roomId } satisfies WorkflowWebsocketServerMessage),
+        );
+        return;
+      }
+      this.roomIdsBySocket.get(socket)?.delete(message.roomId);
+      this.logger.debug(`unsubscribed room=${message.roomId}`);
+      socket.send(
+        JSON.stringify({ kind: "unsubscribed", roomId: message.roomId } satisfies WorkflowWebsocketServerMessage),
+      );
+    } catch (error) {
+      const exception = error instanceof Error ? error : new Error(String(error));
+      this.logger.warn(`failed to handle client message: ${exception.message}`);
+      socket.send(
+        JSON.stringify({ kind: "error", message: exception.message } satisfies WorkflowWebsocketServerMessage),
+      );
+    }
+  }
+
+  private async awaitListening(websocketServer: WebSocketServer): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      websocketServer.once("listening", () => resolve());
+      websocketServer.once("error", reject);
+    });
+  }
+
+  private async closeAfterFailedStart(websocketServer: WebSocketServer): Promise<void> {
+    await new Promise<void>((resolve) => {
+      websocketServer.close(() => resolve());
+    });
+  }
+
+  private parseClientMessage(rawData: unknown): WorkflowWebsocketClientMessage {
+    const value = typeof rawData === "string" ? rawData : Buffer.isBuffer(rawData) ? rawData.toString("utf8") : "";
+    const message = JSON.parse(value) as Readonly<{ kind?: unknown; roomId?: unknown }>;
+    if (message.kind === "subscribe" && typeof message.roomId === "string") {
+      return { kind: "subscribe", roomId: message.roomId };
+    }
+    if (message.kind === "unsubscribe" && typeof message.roomId === "string") {
+      return { kind: "unsubscribe", roomId: message.roomId };
+    }
+    throw new Error("Unsupported websocket client message.");
+  }
+}

package/src/server.ts

@@ -0,0 +1,14 @@
+export { CodemationPostgresPrismaClientFactory, PrismaClient } from "./persistenceServer";
+export { ApiPaths } from "./presentation/http/ApiPaths";
+export { CodemationServerGateway } from "./presentation/http/CodemationServerGatewayFactory";
+export { CodemationConsumerAppResolver } from "./presentation/server/CodemationConsumerAppResolver";
+export type { CodemationConsumerApp } from "./presentation/server/CodemationConsumerAppResolver";
+export { CodemationConsumerConfigLoader } from "./presentation/server/CodemationConsumerConfigLoader";
+export type { CodemationConsumerConfigResolution } from "./presentation/server/CodemationConsumerConfigLoader";
+export { CodemationPluginDiscovery } from "./presentation/server/CodemationPluginDiscovery";
+export type {
+  CodemationDiscoveredPluginPackage,
+  CodemationResolvedPluginPackage,
+} from "./presentation/server/CodemationPluginDiscovery";
+export { WorkflowModulePathFinder } from "./presentation/server/WorkflowModulePathFinder";
+export { WorkflowDiscoveryPathSegmentsComputer } from "./presentation/server/WorkflowDiscoveryPathSegmentsComputer";

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "jsx": "react-jsx",
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "test/**/*.tsx", "vitest*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.shared.ts

@@ -0,0 +1,45 @@
+import path from "node:path";
+
+const hostSrc = path.resolve(import.meta.dirname, "./src");
+const nextHostSrc = path.resolve(import.meta.dirname, "../next-host/src");
+
+export const hostVitestSharedConfig = {
+  esbuild: {
+    jsx: "automatic" as const,
+    jsxImportSource: "react",
+  },
+  resolve: {
+    alias: [
+      { find: "@codemation/core/browser", replacement: path.resolve(import.meta.dirname, "../core/src/browser.ts") },
+      { find: /^@codemation\/host-src\/(.+)$/, replacement: `${hostSrc}/$1` },
+      { find: /^@codemation\/next-host\/src\/(.+)$/, replacement: `${nextHostSrc}/$1` },
+      { find: "@codemation/host/client", replacement: path.resolve(import.meta.dirname, "./src/client.ts") },
+      { find: "@codemation/host/server", replacement: path.resolve(import.meta.dirname, "./src/server.ts") },
+      {
+        find: "@codemation/host/persistence",
+        replacement: path.resolve(import.meta.dirname, "./src/persistenceServer.ts"),
+      },
+      { find: "@codemation/host", replacement: path.resolve(import.meta.dirname, "./src/index.ts") },
+      { find: "@codemation/core-nodes", replacement: path.resolve(import.meta.dirname, "../core-nodes/src/index.ts") },
+      {
+        find: "@codemation/queue-bullmq",
+        replacement: path.resolve(import.meta.dirname, "../queue-bullmq/src/index.ts"),
+      },
+      {
+        find: "@codemation/eventbus-redis",
+        replacement: path.resolve(import.meta.dirname, "../eventbus-redis/src/index.ts"),
+      },
+      { find: "@codemation/core/testing", replacement: path.resolve(import.meta.dirname, "../core/src/testing.ts") },
+      {
+        find: "@codemation/core/bootstrap",
+        replacement: path.resolve(import.meta.dirname, "../core/src/bootstrap/index.ts"),
+      },
+      { find: "@codemation/core", replacement: path.resolve(import.meta.dirname, "../core/src/index.ts") },
+      {
+        find: "next/navigation",
+        replacement: path.resolve(import.meta.dirname, "./test/nextNavigationStub.ts"),
+      },
+      { find: /^@\//, replacement: `${nextHostSrc}/` },
+    ],
+  },
+};