@dudousxd/nestjs-durable 0.39.1 → 0.40.0

package/dist/index.js

@@ -13,9 +13,120 @@ import { readSearchAttributes } from "@dudousxd/nestjs-durable-core";
 // src/decorators.ts
 import { DURABLE_STEP_CONFIG, DURABLE_STEP_NAME, WORKFLOW_NAME_KEY } from "@dudousxd/nestjs-durable-core";
 import "reflect-metadata";
+
+// src/origin.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var declaringFileByClass = /* @__PURE__ */ new WeakMap();
+var packageNameByDir = /* @__PURE__ */ new Map();
+function declaringFile(boundary) {
+  const capture = Error.captureStackTrace;
+  if (typeof capture !== "function") return void 0;
+  const holder = {};
+  capture(holder, boundary);
+  return topFrameFile(holder.stack);
+}
+__name(declaringFile, "declaringFile");
+function rememberDeclaringFile(target, file) {
+  if (file) declaringFileByClass.set(target, file);
+}
+__name(rememberDeclaringFile, "rememberDeclaringFile");
+function originOfClass(target) {
+  for (let ctor = target; typeof ctor === "function" || typeof ctor === "object" && ctor !== null; ctor = Object.getPrototypeOf(ctor)) {
+    const file = declaringFileByClass.get(ctor);
+    if (file) return packageNameFor(file);
+  }
+  return void 0;
+}
+__name(originOfClass, "originOfClass");
+function originOfProvider(wrapper) {
+  const fromMetatype = originOfClass(wrapper.metatype);
+  if (fromMetatype) return fromMetatype;
+  const instance = wrapper.instance;
+  if (typeof instance !== "object" || instance === null) return void 0;
+  return originOfClass(instance.constructor);
+}
+__name(originOfProvider, "originOfProvider");
+function packageNameFor(file) {
+  const start = dirname(file);
+  const visited = [];
+  let dir = start;
+  for (; ; ) {
+    if (packageNameByDir.has(dir)) {
+      const cached = packageNameByDir.get(dir);
+      for (const seen of visited) packageNameByDir.set(seen, cached);
+      return cached;
+    }
+    visited.push(dir);
+    const name = readPackageName(join(dir, "package.json"));
+    if (name !== void 0) {
+      for (const seen of visited) packageNameByDir.set(seen, name);
+      return name;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      for (const seen of visited) packageNameByDir.set(seen, void 0);
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+__name(packageNameFor, "packageNameFor");
+function readPackageName(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const name = parsed.name;
+  return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+__name(readPackageName, "readPackageName");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord, "isRecord");
+function topFrameFile(stack) {
+  if (typeof stack !== "string") return void 0;
+  for (const line of stack.split("\n")) {
+    const frame = line.trim();
+    if (!frame.startsWith("at ")) continue;
+    return fileOfFrame(frame.slice(3));
+  }
+  return void 0;
+}
+__name(topFrameFile, "topFrameFile");
+function fileOfFrame(frame) {
+  const match = /\((.+):\d+:\d+\)$/.exec(frame) ?? /^(.+):\d+:\d+$/.exec(frame);
+  const location = match?.[1];
+  if (location === void 0) return void 0;
+  if (location.startsWith("file://")) {
+    try {
+      return fileURLToPath(location);
+    } catch {
+      return void 0;
+    }
+  }
+  const absolute = location.startsWith("/") || /^[A-Za-z]:[\\/]/.test(location);
+  return absolute ? location : void 0;
+}
+__name(fileOfFrame, "fileOfFrame");
+
+// src/decorators.ts
 var WORKFLOW_METADATA = Symbol("nestjs-durable:workflow");
 function Workflow(options) {
+  const declaredIn = declaringFile(Workflow);
   return (target) => {
+    rememberDeclaringFile(target, declaredIn);
     const meta = {
       name: options.name,
       version: options.version ?? "1",
@@ -244,7 +355,7 @@ function scanWorkflows(discovery, register) {
     if (typeof workflow.run !== "function") {
       throw new Error(`@Workflow ${meta.name} must define a run(ctx, input) method`);
     }
-    register(meta, workflow);
+    register(meta, workflow, originOfProvider(wrapper));
   }
 }
 __name(scanWorkflows, "scanWorkflows");
@@ -1541,7 +1652,9 @@ var WorkflowRegistrar = class {
         this.engine.registerEntity(entityMeta.name, entityConfigFor(instance.constructor));
       }
     }
-    scanWorkflows(this.discovery, (meta, workflow) => {
+    const unattributed = [];
+    scanWorkflows(this.discovery, (meta, workflow, origin) => {
+      if (origin === void 0) unattributed.push(meta.name);
       const validateInput = meta.validateInput ?? (meta.inputSchema ? classValidatorInput(meta.inputSchema) : void 0);
       const eventBatch = meta.debounce ? {
         mode: "debounce",
@@ -1553,6 +1666,10 @@ var WorkflowRegistrar = class {
       } : void 0;
       const workflowCtor = workflow.constructor;
       this.engine.register(meta.name, meta.version, (ctx, input) => workflow.run(ctx, input), {
+        // Stamped onto every run this workflow starts (see `WorkflowRun.origin`). Derived from the
+        // class's declaring file, so a lib gets attributed without opting in; `undefined` when it
+        // could not be derived, which the engine records as unknown rather than defaulting.
+        origin,
         tags: meta.tags,
         singleton: meta.singleton,
         executionTimeout: meta.executionTimeout,
@@ -1585,14 +1702,27 @@ var WorkflowRegistrar = class {
       }
       if (inline) {
         const dlqName = `${meta.name}.dlq`;
-        this.engine.register(dlqName, meta.version, inline);
+        this.engine.register(dlqName, meta.version, inline, {
+          origin
+        });
         deadLetterByWorkflow.set(meta.name, dlqName);
       } else if (meta.deadLetterWorkflow) {
         deadLetterByWorkflow.set(meta.name, workflowName2(meta.deadLetterWorkflow));
       }
     });
+    this.reportUnattributed(unattributed);
     this.installDeadLetterRouting(deadLetterByWorkflow);
   }
+  /**
+  * Says, once at boot, which workflows could not be attributed to a package — their runs are stamped
+  * with no `origin` at all, so an operator filtering the dashboard by origin will not see them. That
+  * is the deliberate trade (an absent origin over an invented one), but it has to be visible: a
+  * silently-dropped run is indistinguishable from a run that never happened.
+  */
+  reportUnattributed(names) {
+    if (names.length === 0) return;
+    console.warn(`[nestjs-durable] could not derive an origin (declaring package) for ${names.length} workflow(s): ${names.join(", ")}. Their runs carry no origin and will not match an origin filter.`);
+  }
   /** Returns the instance's `@DeadLetter()` method bound to the instance, or undefined if none. */
   findDeadLetterHandler(instance) {
     const prototype = Object.getPrototypeOf(instance);