@nice-code/action 0.5.1 → 0.5.2

package/build/devtools/server/index.js

@@ -0,0 +1,246 @@
+// src/devtools/server/NiceActionServerDevtools.ts
+class ActionServerDevtools {
+  _options;
+  _inFlight = new Map;
+  constructor(options = {}) {
+    const defaultEnabled = typeof process !== "undefined" ? true : true;
+    this._options = {
+      logger: options.logger ?? defaultConsoleLogger,
+      format: options.format ?? "pretty",
+      logPayloads: options.logPayloads ?? true,
+      enabled: options.enabled ?? defaultEnabled
+    };
+  }
+  attachToDomain(domain) {
+    if (!this._options.enabled) {
+      return () => {};
+    }
+    return domain.addActionListener((update) => {
+      const { runningAction, type, time } = update;
+      const actionPath = [...runningAction.allDomains, runningAction.id].join(".");
+      if (type === "started" /* started */) {
+        this._inFlight.set(runningAction.cuid, { startTime: time });
+        this._log("started", actionPath, runningAction.cuid, {
+          ...this._options.logPayloads ? { input: runningAction.state?.request?.input } : {}
+        });
+      } else if (type === "progress" /* progress */) {
+        this._log("progress", actionPath, runningAction.cuid, { progress: update.progress });
+      } else if (type === "finished" /* finished */) {
+        const timing = this._inFlight.get(runningAction.cuid);
+        const duration = timing != null ? time - timing.startTime : undefined;
+        this._inFlight.delete(runningAction.cuid);
+        const finishType = update.finishType;
+        if (finishType === "success" /* success */) {
+          const result = update.response?.result;
+          if (result != null && !result.ok) {
+            this._log("action-error", actionPath, runningAction.cuid, {
+              ...duration != null ? { duration: `${duration}ms` } : {},
+              error: serializeError(result.error)
+            });
+          } else {
+            this._log("success", actionPath, runningAction.cuid, {
+              ...duration != null ? { duration: `${duration}ms` } : {},
+              ...this._options.logPayloads ? { output: result?.output } : {}
+            });
+          }
+        } else if (finishType === "failed" /* failed */) {
+          this._log("failed", actionPath, runningAction.cuid, {
+            ...duration != null ? { duration: `${duration}ms` } : {},
+            error: serializeError(update.error)
+          });
+        } else {
+          this._log("aborted", actionPath, runningAction.cuid, {
+            ...duration != null ? { duration: `${duration}ms` } : {},
+            ...update.reason != null ? { reason: String(update.reason) } : {}
+          });
+        }
+      }
+    });
+  }
+  _log(event, actionPath, cuid, data) {
+    const { logger, format } = this._options;
+    if (format === "json") {
+      logger(JSON.stringify({ time: new Date().toISOString(), event, action: actionPath, cuid, ...data }));
+      return;
+    }
+    const prefix = PRETTY_PREFIX[event] ?? `[${event}]`;
+    const suffix = Object.keys(data).length > 0 ? `  ${formatPrettyData(data)}` : "";
+    logger(`${prefix} ${actionPath}  cuid=${cuid}${suffix}`);
+  }
+}
+var PRETTY_PREFIX = {
+  started: "[nice-action] ►",
+  progress: "[nice-action]  ",
+  success: "[nice-action] ✓",
+  failed: "[nice-action] ✗",
+  aborted: "[nice-action] ○"
+};
+function formatPrettyData(data) {
+  return Object.entries(data).map(([k, v]) => `${k}=${safeStringify(v)}`).join(" ");
+}
+function safeStringify(value) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return `"${value}"`;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function serializeError(err) {
+  if (err == null)
+    return err;
+  if (err instanceof Error)
+    return { message: err.message, name: err.name, stack: err.stack };
+  if (typeof err === "object") {
+    try {
+      return JSON.parse(JSON.stringify(err));
+    } catch {
+      return String(err);
+    }
+  }
+  return err;
+}
+function defaultConsoleLogger(message) {
+  console.log(message);
+}
+// src/devtools/core/ActionDevtoolsCore.ts
+function serializeErrorForDisplay(error) {
+  if (error != null && typeof error === "object" && error.name === "NiceError" && typeof error.toJsonObject === "function") {
+    return error.toJsonObject();
+  }
+  return error;
+}
+function extractRouting(context) {
+  return (context?.routing ?? []).map((item) => {
+    const handler = item.handler;
+    const isExternal = handler?.type === "external";
+    return {
+      runtime: {
+        envId: item.runtime?.envId ?? "unknown",
+        perId: item.runtime?.perId,
+        insId: item.runtime?.insId
+      },
+      handlerType: isExternal ? "external" : "local",
+      handlerClient: isExternal && handler.client != null ? {
+        envId: handler.client.envId ?? "unknown",
+        perId: handler.client.perId,
+        insId: handler.client.insId
+      } : undefined,
+      transport: isExternal ? handler.transType : undefined,
+      transportSummary: isExternal ? handler.transInfo?.summary : undefined,
+      transportUrl: isExternal ? handler.transInfo?.url : undefined,
+      time: item.time
+    };
+  });
+}
+function extractMeta(context) {
+  return {
+    timeCreated: context?.timeCreated ?? Date.now(),
+    originClient: {
+      envId: context?.originClient?.envId ?? "unknown",
+      perId: context?.originClient?.perId,
+      insId: context?.originClient?.insId
+    },
+    routing: extractRouting(context)
+  };
+}
+
+class ActionDevtoolsCore {
+  _entries = [];
+  _listeners = new Set;
+  constructor(_options = {}) {}
+  attachToDomain(domain) {
+    return domain.addActionListener((update) => {
+      const { runningAction, type, time } = update;
+      if (type === "started" /* started */) {
+        const entry = {
+          cuid: runningAction.cuid,
+          actionId: runningAction.id,
+          domain: runningAction.domain,
+          allDomains: [...runningAction.allDomains],
+          status: "running",
+          startTime: time,
+          input: runningAction.state?.request?.input,
+          inputHash: runningAction.state?.request?.inputHash,
+          progressUpdates: [],
+          meta: extractMeta(runningAction.context),
+          parentCuid: runningAction.parentCuid,
+          callSite: runningAction.callSite
+        };
+        this._entries = [entry, ...this._entries];
+        this._notify();
+      } else if (type === "progress" /* progress */) {
+        this._updateEntry(runningAction.cuid, (e) => ({
+          ...e,
+          progressUpdates: [...e.progressUpdates, update.progress]
+        }));
+      } else if (type === "finished" /* finished */) {
+        this._updateEntry(runningAction.cuid, (e) => {
+          const finishedRoutingContext = update.response?.context ?? runningAction.context;
+          const base = {
+            ...e,
+            endTime: time,
+            meta: { ...e.meta, routing: extractRouting(finishedRoutingContext) }
+          };
+          const finishType = update.finishType;
+          if (finishType === "success" /* success */) {
+            const result = update.response?.result;
+            const outputHash = update.response?.outputHash;
+            if (result != null && !result.ok) {
+              const rawError = result.error;
+              const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
+              return {
+                ...base,
+                status: "action-error",
+                outputHash,
+                error: serializeErrorForDisplay(rawError),
+                errorStack: errorStack2
+              };
+            }
+            return { ...base, status: "success", output: result?.output, outputHash };
+          }
+          if (finishType === "failed" /* failed */) {
+            const rawError = update.error;
+            const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
+            return { ...base, status: "failed", error: serializeErrorForDisplay(rawError), errorStack: errorStack2 };
+          }
+          const abortReason = update.reason;
+          const errorStack = abortReason instanceof Error ? abortReason.stack : undefined;
+          return { ...base, status: "aborted", abortReason: serializeErrorForDisplay(abortReason), errorStack };
+        });
+      }
+    });
+  }
+  getEntries() {
+    return this._entries;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    listener(this._entries);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  clear() {
+    this._entries = [];
+    this._notify();
+  }
+  _updateEntry(cuid, updater) {
+    this._entries = this._entries.map((e) => e.cuid === cuid ? updater(e) : e);
+    this._notify();
+  }
+  _notify() {
+    const snapshot = this._entries;
+    for (const listener of this._listeners)
+      listener(snapshot);
+  }
+}
+export {
+  ActionServerDevtools,
+  ActionDevtoolsCore
+};