@tsplc/server 0.0.0-stage → 0.1.0

package/src/serve.ts

@@ -0,0 +1,170 @@
+import { timingSafeEqual } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import type { AnyRouter, inferRouterContext } from "@trpc/server";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+import type { ClientSession, PlcLog } from "@tsplc/opcua";
+import type { TLSOptions } from "bun";
+import { z } from "zod";
+import type { Hmi, HmiPlc } from "./hmi";
+import { hmiPage } from "./hmi-page";
+import { createServiceHandler } from "./index";
+import { runOpcUaServices, type ServiceChannel } from "./opcua";
+
+type RouteHandler = (request: Request) => Response | Promise<Response>;
+
+export interface ServeOptions<Router extends AnyRouter> {
+  hostname: string;
+  port: number;
+  tls?: TLSOptions;
+  /** Required on every route except `/health`. Browser requests also need an allowed origin. */
+  auth: { bearerToken: string; allowedOrigins: readonly string[] };
+  plc: {
+    run: (signal: AbortSignal) => Promise<void>;
+    snapshot: () => { connected: boolean };
+    session: () => ClientSession;
+  };
+  /** Served at `/trpc/*`; its `plc` procedures also serve the PLC at `/tsplc/services/*`. */
+  router: Router;
+  /** Context for every call, after authentication. */
+  createContext: () => inferRouterContext<Router> | Promise<inferRouterContext<Router>>;
+  /** The generated OPC UA service channels; empty when the PLC calls over HTTP. */
+  channels: readonly ServiceChannel[];
+  /** Work repeated until shutdown. A failed run is logged and retried after its interval. */
+  jobs?: ReadonlyArray<{ name: string; intervalMs: number; run: () => Promise<void> }>;
+  /**
+   * An operator page at `/`, with `/hmi/state` and `/hmi/control`. These don't need the bearer
+   * token: only use it on a closed network. Controls still reject other sites' origins.
+   */
+  hmi?: { hmi: Hmi; plc: HmiPlc };
+  log: PlcLog;
+}
+
+const hmiControlRequest = z.strictObject({
+  index: z.number().int().nonnegative(),
+  value: z.number().optional(),
+});
+
+const json = (body: unknown, status = 200) =>
+  Response.json(body, { status, headers: { "Cache-Control": "no-store" } });
+
+const sleep = (ms: number, signal: AbortSignal) =>
+  delay(ms, undefined, { signal }).catch(() => undefined);
+
+/**
+ * The PLC's host process: serves one tRPC router to applications and its PLC
+ * procedures to the PLC, keeps the PLC session and background jobs running, and
+ * stops all of them on SIGINT/SIGTERM or `stop()`.
+ */
+export const serve = <Router extends AnyRouter>(options: ServeOptions<Router>) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const expected = Buffer.from(`Bearer ${options.auth.bearerToken}`);
+  const protect =
+    (handler: RouteHandler): RouteHandler =>
+    async (request) => {
+      const actual = Buffer.from(request.headers.get("authorization") ?? "");
+      if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
+        return json({ message: "Unauthorized" }, 401);
+      const origin = request.headers.get("origin");
+      if (origin !== null && !options.auth.allowedOrigins.includes(origin))
+        return json({ message: "Origin is not allowed" }, 403);
+      try {
+        return await handler(request);
+      } catch (error) {
+        options.log.warn(`Request failed: ${new URL(request.url).pathname}`, error);
+        return json({ message: "Internal server error" }, 500);
+      }
+    };
+  const routes: Record<string, RouteHandler> = {
+    "/health": () => json({ plcConnected: options.plc.snapshot().connected, running: true }),
+    "/trpc/*": protect((request) =>
+      fetchRequestHandler({
+        createContext: options.createContext,
+        endpoint: "/trpc",
+        req: request,
+        router: options.router,
+      }),
+    ),
+    "/tsplc/services/*": protect(
+      createServiceHandler({
+        router: options.router,
+        createContext: options.createContext,
+        onError: (error) => options.log.warn("PLC service call failed", error),
+      }),
+    ),
+  };
+  if (options.hmi) {
+    const { hmi, plc } = options.hmi;
+    routes["/"] = () =>
+      new Response(hmiPage(hmi.title), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+    routes["/hmi/state"] = () => json(hmi.state(plc));
+    routes["/hmi/control"] = async (request) => {
+      const origin = request.headers.get("origin");
+      if (
+        request.method !== "POST" ||
+        (origin !== null &&
+          origin !== new URL(request.url).origin &&
+          !options.auth.allowedOrigins.includes(origin))
+      )
+        return json({ message: "Control request not allowed" }, 403);
+      const parsed = hmiControlRequest.safeParse(await request.json().catch(() => null));
+      if (!parsed.success) return json({ message: "Invalid control request" }, 400);
+      try {
+        await hmi.control(plc, parsed.data);
+        return json({ ok: true });
+      } catch (error) {
+        if (error instanceof RangeError) return json({ message: error.message }, 400);
+        options.log.warn("HMI control failed", error);
+        return json({ message: "The PLC did not accept this command" }, 503);
+      }
+    };
+  }
+  const server = Bun.serve({
+    ...(options.tls ? { tls: options.tls } : {}),
+    hostname: options.hostname,
+    port: options.port,
+    routes,
+    fetch: () => json({ message: "Not found" }, 404),
+  });
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  options.log.info(`Listening on ${server.url}`);
+
+  const closed = Promise.all([
+    options.plc.run(signal),
+    runOpcUaServices({
+      router: options.router,
+      createContext: options.createContext,
+      channels: options.channels,
+      getSession: options.plc.session,
+      onError: (error) => options.log.warn("PLC service gateway unavailable", error),
+      onReady: () => options.log.info("PLC service gateway ready"),
+      signal,
+    }),
+    ...(options.jobs ?? []).map(async (job) => {
+      while (!signal.aborted) {
+        try {
+          await job.run();
+        } catch (error) {
+          options.log.warn(`${job.name} failed`, error);
+        }
+        await sleep(job.intervalMs, signal);
+      }
+    }),
+  ]).finally(async () => {
+    controller.abort();
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+    await server.stop(true);
+  });
+
+  return {
+    url: server.url,
+    closed: closed.then(() => undefined),
+    stop: async () => {
+      stop();
+      await closed;
+    },
+  };
+};