@horizon-republic/nestjs-jetstream 2.12.0 → 2.12.1

package/dist/index.cjs

@@ -598,7 +598,7 @@ var extractContext = (ctx, carrier, getter) => import_api.propagation.extract(ct
 
 // src/otel/tracer.ts
 var import_api2 = require("@opentelemetry/api");
-var PACKAGE_VERSION = true ? "2.12.0" : "0.0.0";
+var PACKAGE_VERSION = true ? "2.12.1" : "0.0.0";
 var getTracer = () => import_api2.trace.getTracer(TRACER_NAME, PACKAGE_VERSION);
 
 // src/otel/carrier.ts
@@ -3880,11 +3880,8 @@ var StreamMigration = class {
     );
   }
   /**
-   * Detect and finish a migration that a previous process left unfinished.
-   * Safe against concurrent instances: a backup fresh enough to belong to a
-   * live migration is left alone.
-   *
-   * @returns true when recovery work was performed.
+   * Finish a migration a previous process left unfinished; a backup fresh
+   * enough to belong to a live peer migration is left alone.
    */
   async recoverInterrupted(jsm, streamName2, desiredConfig) {
     const backupName = `${streamName2}${MIGRATION_BACKUP_SUFFIX}`;
@@ -3938,11 +3935,9 @@ var StreamMigration = class {
     await jsm.streams.update(streamName2, { ...streamConfig, sources: [] });
   }
   /**
-   * Wait until `sourceName` is fully drained into `streamName`. Lag-based, so
-   * concurrent live publishes to the target cannot fake completion the way a
-   * bare message-count comparison could. A freshly attached source reports
-   * `lag: 0, active: -1` before its first sync — `active >= 0` filters that
-   * false positive out (verified against NATS 2.12.6).
+   * Lag-based drain check — live publishes cannot fake completion. A fresh
+   * source reports lag 0 / active -1 before its first sync (NATS 2.12.6),
+   * hence the active guard.
    */
   async waitForSourceDrained(jsm, streamName2, sourceName, minimumMessages) {
     const deadline = Date.now() + this.sourcingTimeoutMs;
@@ -3959,12 +3954,8 @@ var StreamMigration = class {
     );
   }
   /**
-   * A backup already present when migrate() begins belongs to another
-   * instance migrating right now (rolling deploy) — wait for it to finish.
-   * Stale leftovers are handled by recoverInterrupted() before migrate() runs,
-   * so a timeout here means something is genuinely stuck.
-   *
-   * @returns true when a peer's backup was observed and cleared.
+   * A backup present at migrate() start is a live peer migration — wait it
+   * out. Stale leftovers were already handled by recoverInterrupted().
    */
   async waitOutPeerMigration(jsm, backupName) {
     if (await this.tryInfo(jsm, backupName) === null) return false;
@@ -4015,6 +4006,17 @@ var StreamMigration = class {
 };
 
 // src/server/infrastructure/stream.provider.ts
+var subjectCovers = (broad, narrow) => {
+  if (broad === narrow) return false;
+  const broadTokens = broad.split(".");
+  const narrowTokens = narrow.split(".");
+  for (let i = 0; i < broadTokens.length; i += 1) {
+    if (broadTokens[i] === ">") return i < narrowTokens.length;
+    if (i >= narrowTokens.length || narrowTokens[i] === ">") return false;
+    if (broadTokens[i] !== "*" && broadTokens[i] !== narrowTokens[i]) return false;
+  }
+  return broadTokens.length === narrowTokens.length;
+};
 var StreamProvider = class {
   constructor(options, connection) {
     this.options = options;
@@ -4069,13 +4071,8 @@ ${formatProvisioningSummary(this.options.name, reservations)}`);
       }
       case "cmd" /* Command */:
         return [`${name}.${"cmd" /* Command */}.>`];
-      case "broadcast" /* Broadcast */: {
-        const subjects = ["broadcast.>"];
-        if (this.isSchedulingEnabled(kind)) {
-          subjects.push("broadcast._sch.>");
-        }
-        return subjects;
-      }
+      case "broadcast" /* Broadcast */:
+        return ["broadcast.>"];
       case "ordered" /* Ordered */:
         return [`${name}.${"ordered" /* Ordered */}.>`];
     }
@@ -4145,7 +4142,8 @@ ${formatProvisioningSummary(this.options.name, reservations)}`);
   }
   async handleExistingStream(jsm, currentInfo, config, ctx) {
     if (this.isSharedStream(config.name)) {
-      config.subjects = [.../* @__PURE__ */ new Set([...config.subjects, ...currentInfo.config.subjects])];
+      const merged = [.../* @__PURE__ */ new Set([...config.subjects, ...currentInfo.config.subjects])];
+      config.subjects = merged.filter((s) => !merged.some((other) => subjectCovers(other, s)));
     }
     const diff = compareStreamConfig(currentInfo.config, config);
     if (!diff.hasChanges) {
@@ -5353,11 +5351,8 @@ var EventRouter = class {
     return void 0;
   }
   /**
-   * Last-resort path for a dead letter: invoke `onDeadLetter`, then `term` on
-   * success. On failure the message is nak'd to release it, but the server
-   * never redelivers past `max_deliver` — it stays in the stream for manual
-   * recovery. Used when the DLQ stream isn't configured, or when publishing
-   * to it failed and we still have to surface the message somewhere.
+   * Last resort: invoke onDeadLetter, then term on success. On failure the
+   * message is nak'd — never redelivered past max_deliver, but preserved.
    */
   async fallbackToOnDeadLetterCallback(info, msg) {
     const onDeadLetter = this.deadLetterConfig?.onDeadLetter;
@@ -5386,10 +5381,8 @@ var EventRouter = class {
     }
   }
   /**
-   * Copy the original message headers for the DLQ republish, dropping NATS
-   * server control headers: a copied Nats-TTL expires the DLQ entry (or gets
-   * the publish rejected when the DLQ stream has no allow_msg_ttl), a copied
-   * Nats-Msg-Id collides with the DLQ dedup window.
+   * Copy headers for the DLQ republish, dropping NATS control headers — a
+   * copied Nats-TTL would expire the DLQ entry, Nats-Msg-Id trips dedup.
    */
   buildDlqHeaders(msg) {
     const hdrs = (0, import_transport_node4.headers)();
@@ -5403,12 +5396,9 @@ var EventRouter = class {
     return hdrs;
   }
   /**
-   * Attempt the DLQ publish up to {@link DLQ_PUBLISH_ATTEMPTS} times.
-   *
-   * Past `max_deliver` the server never redelivers, so an in-process retry is
-   * the only second chance a dead letter gets. There is no artificial delay
-   * between attempts: when the broker is unreachable each publish already
-   * spends its own request timeout, which spaces the attempts naturally.
+   * Past max_deliver the server never redelivers, so these in-process attempts
+   * are the only second chance a dead letter gets. No artificial delay — an
+   * unreachable broker already spaces attempts via its own request timeout.
    */
   async publishToDlqWithRetry(connection, subject, data, headers2) {
     let lastErr;

package/dist/index.d.cts

@@ -1532,27 +1532,19 @@ declare class EventRouter {
     private getConcurrency;
     private getAckExtensionConfig;
     /**
-     * Last-resort path for a dead letter: invoke `onDeadLetter`, then `term` on
-     * success. On failure the message is nak'd to release it, but the server
-     * never redelivers past `max_deliver` — it stays in the stream for manual
-     * recovery. Used when the DLQ stream isn't configured, or when publishing
-     * to it failed and we still have to surface the message somewhere.
+     * Last resort: invoke onDeadLetter, then term on success. On failure the
+     * message is nak'd — never redelivered past max_deliver, but preserved.
      */
     private fallbackToOnDeadLetterCallback;
     /**
-     * Copy the original message headers for the DLQ republish, dropping NATS
-     * server control headers: a copied Nats-TTL expires the DLQ entry (or gets
-     * the publish rejected when the DLQ stream has no allow_msg_ttl), a copied
-     * Nats-Msg-Id collides with the DLQ dedup window.
+     * Copy headers for the DLQ republish, dropping NATS control headers — a
+     * copied Nats-TTL would expire the DLQ entry, Nats-Msg-Id trips dedup.
      */
     private buildDlqHeaders;
     /**
-     * Attempt the DLQ publish up to {@link DLQ_PUBLISH_ATTEMPTS} times.
-     *
-     * Past `max_deliver` the server never redelivers, so an in-process retry is
-     * the only second chance a dead letter gets. There is no artificial delay
-     * between attempts: when the broker is unreachable each publish already
-     * spends its own request timeout, which spaces the attempts naturally.
+     * Past max_deliver the server never redelivers, so these in-process attempts
+     * are the only second chance a dead letter gets. No artificial delay — an
+     * unreachable broker already spaces attempts via its own request timeout.
      */
     private publishToDlqWithRetry;
     /**

package/dist/index.d.ts

@@ -1532,27 +1532,19 @@ declare class EventRouter {
     private getConcurrency;
     private getAckExtensionConfig;
     /**
-     * Last-resort path for a dead letter: invoke `onDeadLetter`, then `term` on
-     * success. On failure the message is nak'd to release it, but the server
-     * never redelivers past `max_deliver` — it stays in the stream for manual
-     * recovery. Used when the DLQ stream isn't configured, or when publishing
-     * to it failed and we still have to surface the message somewhere.
+     * Last resort: invoke onDeadLetter, then term on success. On failure the
+     * message is nak'd — never redelivered past max_deliver, but preserved.
      */
     private fallbackToOnDeadLetterCallback;
     /**
-     * Copy the original message headers for the DLQ republish, dropping NATS
-     * server control headers: a copied Nats-TTL expires the DLQ entry (or gets
-     * the publish rejected when the DLQ stream has no allow_msg_ttl), a copied
-     * Nats-Msg-Id collides with the DLQ dedup window.
+     * Copy headers for the DLQ republish, dropping NATS control headers — a
+     * copied Nats-TTL would expire the DLQ entry, Nats-Msg-Id trips dedup.
      */
     private buildDlqHeaders;
     /**
-     * Attempt the DLQ publish up to {@link DLQ_PUBLISH_ATTEMPTS} times.
-     *
-     * Past `max_deliver` the server never redelivers, so an in-process retry is
-     * the only second chance a dead letter gets. There is no artificial delay
-     * between attempts: when the broker is unreachable each publish already
-     * spends its own request timeout, which spaces the attempts naturally.
+     * Past max_deliver the server never redelivers, so these in-process attempts
+     * are the only second chance a dead letter gets. No artificial delay — an
+     * unreachable broker already spaces attempts via its own request timeout.
      */
     private publishToDlqWithRetry;
     /**

package/dist/index.js

@@ -533,7 +533,7 @@ var extractContext = (ctx, carrier, getter) => propagation.extract(ctx, carrier,
 
 // src/otel/tracer.ts
 import { trace } from "@opentelemetry/api";
-var PACKAGE_VERSION = true ? "2.12.0" : "0.0.0";
+var PACKAGE_VERSION = true ? "2.12.1" : "0.0.0";
 var getTracer = () => trace.getTracer(TRACER_NAME, PACKAGE_VERSION);
 
 // src/otel/carrier.ts
@@ -3842,11 +3842,8 @@ var StreamMigration = class {
     );
   }
   /**
-   * Detect and finish a migration that a previous process left unfinished.
-   * Safe against concurrent instances: a backup fresh enough to belong to a
-   * live migration is left alone.
-   *
-   * @returns true when recovery work was performed.
+   * Finish a migration a previous process left unfinished; a backup fresh
+   * enough to belong to a live peer migration is left alone.
    */
   async recoverInterrupted(jsm, streamName2, desiredConfig) {
     const backupName = `${streamName2}${MIGRATION_BACKUP_SUFFIX}`;
@@ -3900,11 +3897,9 @@ var StreamMigration = class {
     await jsm.streams.update(streamName2, { ...streamConfig, sources: [] });
   }
   /**
-   * Wait until `sourceName` is fully drained into `streamName`. Lag-based, so
-   * concurrent live publishes to the target cannot fake completion the way a
-   * bare message-count comparison could. A freshly attached source reports
-   * `lag: 0, active: -1` before its first sync — `active >= 0` filters that
-   * false positive out (verified against NATS 2.12.6).
+   * Lag-based drain check — live publishes cannot fake completion. A fresh
+   * source reports lag 0 / active -1 before its first sync (NATS 2.12.6),
+   * hence the active guard.
    */
   async waitForSourceDrained(jsm, streamName2, sourceName, minimumMessages) {
     const deadline = Date.now() + this.sourcingTimeoutMs;
@@ -3921,12 +3916,8 @@ var StreamMigration = class {
     );
   }
   /**
-   * A backup already present when migrate() begins belongs to another
-   * instance migrating right now (rolling deploy) — wait for it to finish.
-   * Stale leftovers are handled by recoverInterrupted() before migrate() runs,
-   * so a timeout here means something is genuinely stuck.
-   *
-   * @returns true when a peer's backup was observed and cleared.
+   * A backup present at migrate() start is a live peer migration — wait it
+   * out. Stale leftovers were already handled by recoverInterrupted().
    */
   async waitOutPeerMigration(jsm, backupName) {
     if (await this.tryInfo(jsm, backupName) === null) return false;
@@ -3977,6 +3968,17 @@ var StreamMigration = class {
 };
 
 // src/server/infrastructure/stream.provider.ts
+var subjectCovers = (broad, narrow) => {
+  if (broad === narrow) return false;
+  const broadTokens = broad.split(".");
+  const narrowTokens = narrow.split(".");
+  for (let i = 0; i < broadTokens.length; i += 1) {
+    if (broadTokens[i] === ">") return i < narrowTokens.length;
+    if (i >= narrowTokens.length || narrowTokens[i] === ">") return false;
+    if (broadTokens[i] !== "*" && broadTokens[i] !== narrowTokens[i]) return false;
+  }
+  return broadTokens.length === narrowTokens.length;
+};
 var StreamProvider = class {
   constructor(options, connection) {
     this.options = options;
@@ -4031,13 +4033,8 @@ ${formatProvisioningSummary(this.options.name, reservations)}`);
       }
       case "cmd" /* Command */:
         return [`${name}.${"cmd" /* Command */}.>`];
-      case "broadcast" /* Broadcast */: {
-        const subjects = ["broadcast.>"];
-        if (this.isSchedulingEnabled(kind)) {
-          subjects.push("broadcast._sch.>");
-        }
-        return subjects;
-      }
+      case "broadcast" /* Broadcast */:
+        return ["broadcast.>"];
       case "ordered" /* Ordered */:
         return [`${name}.${"ordered" /* Ordered */}.>`];
     }
@@ -4107,7 +4104,8 @@ ${formatProvisioningSummary(this.options.name, reservations)}`);
   }
   async handleExistingStream(jsm, currentInfo, config, ctx) {
     if (this.isSharedStream(config.name)) {
-      config.subjects = [.../* @__PURE__ */ new Set([...config.subjects, ...currentInfo.config.subjects])];
+      const merged = [.../* @__PURE__ */ new Set([...config.subjects, ...currentInfo.config.subjects])];
+      config.subjects = merged.filter((s) => !merged.some((other) => subjectCovers(other, s)));
     }
     const diff = compareStreamConfig(currentInfo.config, config);
     if (!diff.hasChanges) {
@@ -5324,11 +5322,8 @@ var EventRouter = class {
     return void 0;
   }
   /**
-   * Last-resort path for a dead letter: invoke `onDeadLetter`, then `term` on
-   * success. On failure the message is nak'd to release it, but the server
-   * never redelivers past `max_deliver` — it stays in the stream for manual
-   * recovery. Used when the DLQ stream isn't configured, or when publishing
-   * to it failed and we still have to surface the message somewhere.
+   * Last resort: invoke onDeadLetter, then term on success. On failure the
+   * message is nak'd — never redelivered past max_deliver, but preserved.
    */
   async fallbackToOnDeadLetterCallback(info, msg) {
     const onDeadLetter = this.deadLetterConfig?.onDeadLetter;
@@ -5357,10 +5352,8 @@ var EventRouter = class {
     }
   }
   /**
-   * Copy the original message headers for the DLQ republish, dropping NATS
-   * server control headers: a copied Nats-TTL expires the DLQ entry (or gets
-   * the publish rejected when the DLQ stream has no allow_msg_ttl), a copied
-   * Nats-Msg-Id collides with the DLQ dedup window.
+   * Copy headers for the DLQ republish, dropping NATS control headers — a
+   * copied Nats-TTL would expire the DLQ entry, Nats-Msg-Id trips dedup.
    */
   buildDlqHeaders(msg) {
     const hdrs = natsHeaders3();
@@ -5374,12 +5367,9 @@ var EventRouter = class {
     return hdrs;
   }
   /**
-   * Attempt the DLQ publish up to {@link DLQ_PUBLISH_ATTEMPTS} times.
-   *
-   * Past `max_deliver` the server never redelivers, so an in-process retry is
-   * the only second chance a dead letter gets. There is no artificial delay
-   * between attempts: when the broker is unreachable each publish already
-   * spends its own request timeout, which spaces the attempts naturally.
+   * Past max_deliver the server never redelivers, so these in-process attempts
+   * are the only second chance a dead letter gets. No artificial delay — an
+   * unreachable broker already spaces attempts via its own request timeout.
    */
   async publishToDlqWithRetry(connection, subject, data, headers2) {
     let lastErr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@horizon-republic/nestjs-jetstream",
-  "version": "2.12.0",
+  "version": "2.12.1",
   "description": "A NestJS transport for NATS with JetStream events, broadcast fan-out, and Core/JetStream RPC.",
   "repository": {
     "type": "git",