@iworkflow/temporal 0.2.0 → 0.3.0

package/README.md

@@ -2,9 +2,10 @@
 
 Temporal для `@iworkflow/core`. Peer: `@temporalio/{client,worker,workflow,activity}` ^1.24.
 
-- `temporalRuntime(workflowsPath).start(def)` — воркер на task queue `def.app`.
-- `temporalClient()` — старт, сигнал, query по id.
+- `temporalRuntime(workflowsPath, opts?).start(def)` — воркер на task queue `def.app`; `opts.workflowBundlePath` — готовый бандл прод-сборки.
+- `temporalClient(opts?)` — старт, сигнал, query по id.
 - `@iworkflow/temporal/workflow` — только для входа песочницы модуля:
   `export const outreach = temporalFlow(flows.outreach, ["send-twice"])`.
 
-Переменные: `TEMPORAL_URL` (по умолчанию `127.0.0.1:17233`), `TEMPORAL_NAMESPACE`.
+`opts` (`TemporalOptions`): `address`, `namespace`, `tls`, `apiKey` — источник токена, меняется каждые `apiKeyRenewMs`.
+Без них — переменные `TEMPORAL_URL` (по умолчанию `127.0.0.1:17233`), `TEMPORAL_NAMESPACE`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iworkflow/temporal",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Temporal adapter for @iworkflow/core",
   "keywords": [
     "workflow",
@@ -29,7 +29,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@iworkflow/core": "^0.2.0"
+    "@iworkflow/core": "^0.3.0"
   },
   "peerDependencies": {
     "@temporalio/activity": "^1.24.0",

package/src/connection.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { connectOptions, renewApiKey } from "./connection";
+
+test("токен берётся при подключении и меняется по таймеру", async () => {
+  let n = 0;
+  const apiKey = async () => `t${++n}`;
+  expect(await connectOptions({ address: "a:1", tls: true, apiKey })).toEqual({ address: "a:1", tls: true, apiKey: "t1" });
+  const got: string[] = [];
+  const stop = renewApiKey({ apiKey, apiKeyRenewMs: 10 }, (t) => got.push(t));
+  while (got.length < 2) await Bun.sleep(5);
+  stop();
+  const seen = got.length;
+  await Bun.sleep(25);
+  expect(seen).toBeGreaterThanOrEqual(2);
+  expect(got.length).toBe(seen);
+});
+
+test("без токена и TLS — только адрес", async () => {
+  expect(await connectOptions({ address: "a:1" })).toEqual({ address: "a:1" });
+});
+
+test("медленный запрос не затирает свежий токен, после остановки токен не ставится", async () => {
+  let release!: (t: string) => void;
+  let calls = 0;
+  const apiKey = () => (++calls === 1 ? new Promise<string>((r) => (release = r)) : Promise.resolve(`t${calls}`));
+  const got: string[] = [];
+  const stop = renewApiKey({ apiKey, apiKeyRenewMs: 5 }, (t) => got.push(t));
+  await Bun.sleep(40);
+  expect(calls).toBe(1);
+  stop();
+  release("old");
+  await Bun.sleep(5);
+  expect(got).toEqual([]);
+});

package/src/connection.ts

@@ -0,0 +1,45 @@
+// Подключение к Temporal: адрес, TLS, токен с заменой на месте — общее для воркера и клиента.
+import type { TLSConfig } from "@temporalio/client";
+
+/** Подключение к Temporal; не задано — TEMPORAL_URL и TEMPORAL_NAMESPACE из окружения. */
+export interface TemporalOptions {
+  address?: string;
+  namespace?: string;
+  /** TLSConfig SDK (serverNameOverride, свой CA, mTLS). С apiKey SDK включает TLS сам — без TLS только `false`. */
+  tls?: boolean | TLSConfig;
+  /** Источник токена; соединение берёт свежий каждые apiKeyRenewMs (по умолчанию 60 с). */
+  apiKey?: () => Promise<string>;
+  apiKeyRenewMs?: number;
+}
+
+export const address = (o: TemporalOptions) => o.address ?? process.env.TEMPORAL_URL ?? "127.0.0.1:17233";
+export const namespace = (o: TemporalOptions) => o.namespace ?? process.env.TEMPORAL_NAMESPACE ?? "default";
+
+/** Токен меняется на месте: иначе воркер однажды молча перестанет брать задачи. */
+export function renewApiKey(o: TemporalOptions, set: (token: string) => unknown): () => void {
+  if (!o.apiKey) return () => {};
+  const apiKey = o.apiKey;
+  // По одному запросу за раз: поздний ответ не затрёт свежий токен, после остановки токен не ставится.
+  let busy = false;
+  let stopped = false;
+  const timer = setInterval(() => {
+    if (busy) return;
+    busy = true;
+    apiKey()
+      .then((t) => (stopped ? undefined : set(t)))
+      .catch((e: unknown) => stopped || console.error("токен Temporal не обновлён:", e))
+      .finally(() => (busy = false));
+  }, o.apiKeyRenewMs ?? 60_000);
+  timer.unref?.();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
+export const connectOptions = async (o: TemporalOptions) => ({
+  address: address(o),
+  ...(o.tls !== undefined ? { tls: o.tls } : {}),
+  ...(o.apiKey ? { apiKey: await o.apiKey() } : {}),
+});
+

package/src/index.ts

@@ -12,8 +12,11 @@ import {
   type FlowHandle,
   type FlowStatus,
 } from "@iworkflow/core";
+import { address, connectOptions, namespace, renewApiKey, type TemporalOptions } from "./connection";
 import { cause, toTemporal } from "./failure";
 
+export type { TemporalOptions };
+
 // Те же имена, что в workflow.ts: его нельзя импортировать вне песочницы.
 const SIGNAL = "iwf.signal";
 const QUERY = "iwf.query";
@@ -49,9 +52,6 @@ const wrap = <T>(h: WorkflowHandle): FlowHandle<T> => ({
   terminate: async (reason) => void (await h.terminate(reason).catch(notFound(h.workflowId))),
 });
 
-const address = () => process.env.TEMPORAL_URL ?? "127.0.0.1:17233";
-const namespace = () => process.env.TEMPORAL_NAMESPACE ?? "default";
-
 /** Шаги отдают Failure как ApplicationFailure: тип, детали и nonRetryable доезжают до процесса. */
 const withFailures = (activities: Record<string, Activity>) =>
   Object.fromEntries(
@@ -67,44 +67,90 @@ const withFailures = (activities: Record<string, Activity>) =>
     ]),
   );
 
-/** workflowsPath — вход песочницы модуля: temporalFlow(...) на каждый процесс, имя экспорта = имя процесса. */
-export function temporalRuntime(workflowsPath: string): EngineRuntime {
+/**
+ * workflowsPath — вход песочницы модуля: temporalFlow(...) на каждый процесс, имя экспорта = имя процесса.
+ * workflowBundlePath — готовый бандл того же входа (прод-сборка); с ним воркер не собирает код сам.
+ */
+export function temporalRuntime(
+  workflowsPath: string,
+  opts: TemporalOptions & { workflowBundlePath?: string } = {},
+): EngineRuntime {
   let workers: Worker[] = [];
   let running: Promise<void>[] = [];
   let conn: NativeConnection | undefined;
+  let starting = false;
+  let stopRenew = () => {};
   return {
     async start(def: AppDefinition) {
+      if (starting) throw new Error("воркер уже запущен");
+      starting = true;
       bindStepRuntime({
         heartbeat: async (details) => Context.current().heartbeat(details),
         lastHeartbeat: async () => Context.current().info.heartbeatDetails,
       });
-      conn = await NativeConnection.connect({ address: address() });
-      const activities = withFailures(def.activities);
-      const base = { connection: conn, namespace: namespace() };
-      workers = [await Worker.create({ ...base, taskQueue: def.app, workflowsPath, activities })];
-      // Пул — своя очередь с пределом одновременных шагов в этом процессе.
-      for (const [pool, limit] of Object.entries(def.pools ?? {}))
-        workers.push(
-          await Worker.create({
-            ...base,
-            taskQueue: poolQueue(def.app, pool),
-            activities,
-            maxConcurrentActivityTaskExecutions: limit,
-          }),
-        );
+      let c: NativeConnection;
+      try {
+        c = conn = await NativeConnection.connect(await connectOptions(opts));
+      } catch (e) {
+        starting = false;
+        throw e;
+      }
+      stopRenew = renewApiKey(opts, (t) => c.setApiKey(t));
+      // Воркер не создался (нет бандла, namespace) — соединение и таймер токена закрываются.
+      try {
+        const activities = withFailures(def.activities);
+        const base = { connection: c, namespace: namespace(opts) };
+        const code = opts.workflowBundlePath ? { workflowBundle: { codePath: opts.workflowBundlePath } } : { workflowsPath };
+        workers = [await Worker.create({ ...base, taskQueue: def.app, ...code, activities })];
+        // Пул — своя очередь с пределом одновременных шагов в этом процессе.
+        for (const [pool, limit] of Object.entries(def.pools ?? {}))
+          workers.push(
+            await Worker.create({
+              ...base,
+              taskQueue: poolQueue(def.app, pool),
+              activities,
+              maxConcurrentActivityTaskExecutions: limit,
+            }),
+          );
+      } catch (e) {
+        // Созданный, но не запущенный воркер держит соединение: запустить и сразу погасить.
+        await Promise.allSettled(workers.map(async (w) => {
+          const r = w.run();
+          w.shutdown();
+          await r;
+        }));
+        stopRenew();
+        await c.close().catch(() => {});
+        conn = undefined;
+        workers = [];
+        starting = false;
+        throw e;
+      }
       running = workers.map((w) => w.run());
     },
     async stop() {
-      for (const w of workers) w.shutdown();
-      await Promise.all(running);
-      await conn?.close();
+      for (const w of workers) if (w.getState() === "RUNNING") w.shutdown();
+      // Упавший воркер не мешает закрыть соединение и таймер токена.
+      const done = await Promise.allSettled(running);
+      stopRenew();
+      try {
+        await conn?.close();
+      } finally {
+        conn = undefined;
+        workers = [];
+        running = [];
+        starting = false;
+      }
+      const failed = done.find((r) => r.status === "rejected");
+      if (failed) throw (failed as PromiseRejectedResult).reason;
     },
   };
 }
 
-export async function temporalClient(): Promise<EngineClient> {
-  const connection = await Connection.connect({ address: address() });
-  const client = new Client({ connection, namespace: namespace() });
+export async function temporalClient(opts: TemporalOptions = {}): Promise<EngineClient> {
+  const connection = await Connection.connect(await connectOptions(opts));
+  const stopRenew = renewApiKey(opts, (t) => connection.setApiKey(t));
+  const client = new Client({ connection, namespace: namespace(opts) });
   return {
     async start(target, args, opts) {
       const h = await client.workflow.start(target.flow, {
@@ -117,6 +163,6 @@ export async function temporalClient(): Promise<EngineClient> {
       return wrap(h);
     },
     handle: (id) => wrap(client.workflow.getHandle(id)),
-    close: () => connection.close(),
+    close: () => (stopRenew(), connection.close()),
   };
 }