@newhomestar/sdk 0.7.9 → 0.7.11

package/dist/events.js

@@ -54,7 +54,7 @@ async function _relayRow(db, row, eventsUrl, serviceToken) {
             ...row.payload,
             idempotency_key: row.idempotencyKey,
         };
-        const res = await fetch(`${eventsUrl}/events/queue`, {
+        const res = await fetch(`${eventsUrl}/queue`, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${serviceToken}`,
@@ -317,7 +317,7 @@ export async function logEvent(payload) {
     const eventsUrl = _getEnvOrThrow('NOVA_EVENTS_SERVICE_URL', 'logEvent');
     const serviceToken = _getEnvOrThrow('NOVA_SERVICE_TOKEN', 'logEvent');
     const serviceSlug = process.env.NOVA_SERVICE_SLUG;
-    const res = await fetch(`${eventsUrl}/events`, {
+    const res = await fetch(`${eventsUrl}`, {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${serviceToken}`,
@@ -349,7 +349,7 @@ export async function queueEvent(payload) {
     const eventsUrl = _getEnvOrThrow('NOVA_EVENTS_SERVICE_URL', 'queueEvent');
     const serviceToken = _getEnvOrThrow('NOVA_SERVICE_TOKEN', 'queueEvent');
     const serviceSlug = process.env.NOVA_SERVICE_SLUG;
-    const res = await fetch(`${eventsUrl}/events/queue`, {
+    const res = await fetch(`${eventsUrl}/queue`, {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${serviceToken}`,
@@ -565,7 +565,7 @@ export async function withInboundEvent(db, msg, handler) {
     // Safe because: if ACK fails, PGMQ re-delivers, UNIQUE(msg_id) blocks
     // re-processing, and we just ACK again on the duplicate delivery.
     try {
-        const ackRes = await fetch(`${eventsUrl}/events/queue/ack`, {
+        const ackRes = await fetch(`${eventsUrl}/queue/ack`, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${serviceToken}`,
@@ -656,6 +656,14 @@ export function startInboundConsumer(db, options) {
     }
     const abort = new AbortController();
     let reconnectAttempt = 0;
+    /** Log nested error causes for rich diagnostics (undici stores ECONNREFUSED etc. in err.cause) */
+    function _logErrorCause(err, depth = 0) {
+        if (!err?.cause || depth > 3)
+            return;
+        const indent = '   ' + ' └─'.repeat(depth + 1) + ' ';
+        console.error(`[nova/events] ${indent}cause: ${String(err.cause).slice(0, 500)}`);
+        _logErrorCause(err.cause, depth + 1);
+    }
     /** Derive the event topic from a raw PGMQ message payload */
     function _deriveEventType(payload) {
         if (typeof payload.topic === 'string')
@@ -668,7 +676,7 @@ export function startInboundConsumer(db, options) {
     /** Send a NACK to extend the visibility timeout with exponential backoff */
     async function _nack(msgId, readCt) {
         try {
-            await fetch(`${eventsUrl}/events/queue/nack`, {
+            await fetch(`${eventsUrl}/queue/nack`, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${serviceToken}`,
@@ -702,7 +710,7 @@ export function startInboundConsumer(db, options) {
             // No handler registered and no default — skip + ACK to unblock queue
             console.log(`[nova/events] No handler for event type "${eventType}" (msg_id=${msgId}) — ACK and skip`);
             try {
-                await fetch(`${eventsUrl}/events/queue/ack`, {
+                await fetch(`${eventsUrl}/queue/ack`, {
                     method: 'POST',
                     headers: { 'Authorization': `Bearer ${serviceToken}`, 'Content-Type': 'application/json' },
                     body: JSON.stringify({ queue_name: queueName, msg_id: msgId }),
@@ -779,20 +787,25 @@ export function startInboundConsumer(db, options) {
     // Node.js's built-in fetch (undici) has a default bodyTimeout of 300s (5 minutes)
     // which kills long-lived SSE streams as if the response body "stalled".
     // Setting bodyTimeout: 0 disables this limit for the stream connection.
-    // headersTimeout: 30_000 still guards against slow initial connection.
+    // headersTimeout: 120_000 guards against slow initial connections (was 30s — too short
+    // for containers that may take time to establish TCP to the Events Service).
     const sseAgent = new UndiciAgent({
         bodyTimeout: 0,
-        headersTimeout: 30_000,
+        headersTimeout: 120_000,
         keepAliveTimeout: 120_000,
         keepAliveMaxTimeout: 600_000,
     });
     /** Main loop: connect, consume, reconnect */
     async function _connect() {
+        // Log config once on startup so container logs show what we're connecting to
+        const tokenSuffix = serviceToken ? `***${serviceToken.slice(-4)}` : 'MISSING';
+        console.log(`[nova/events] SSE consumer starting — url=${eventsUrl} ` +
+            `token=${tokenSuffix} queue=${queueName} vt=${vt}s headersTimeout=120s`);
         while (!abort.signal.aborted) {
-            const streamUrl = `${eventsUrl}/events/queue/stream?queue=${encodeURIComponent(queueName)}&vt=${vt}`;
+            const streamUrl = `${eventsUrl}/queue/stream?queue=${encodeURIComponent(queueName)}&vt=${vt}`;
+            const connectStart = Date.now();
             try {
-                console.log(`[nova/events] Connecting to SSE queue "${queueName}" ` +
-                    `(attempt ${reconnectAttempt + 1})…`);
+                console.log(`[nova/events] Connecting to SSE stream (attempt ${reconnectAttempt + 1}): ${streamUrl}`);
                 const response = await fetch(streamUrl, {
                     headers: { 'Authorization': `Bearer ${serviceToken}`, 'Accept': 'text/event-stream' },
                     signal: abort.signal,
@@ -806,8 +819,9 @@ export function startInboundConsumer(db, options) {
                     throw new Error(`SSE connect failed: HTTP ${response.status} — ${text.slice(0, 200)}`);
                 }
                 // Successfully connected — reset reconnect counter
+                const ttfb = Date.now() - connectStart;
                 reconnectAttempt = 0;
-                console.log(`[nova/events] SSE consumer connected to queue "${queueName}"`);
+                console.log(`[nova/events] SSE consumer connected to queue "${queueName}" (TTFB: ${ttfb}ms)`);
                 // Consume the stream; catch stream-level errors separately from
                 // connection-level errors so they don't trigger exponential backoff.
                 // A stream dying mid-flight (e.g. proxy timeout) is a normal lifecycle
@@ -821,7 +835,9 @@ export function startInboundConsumer(db, options) {
                     const isAbortError = streamErr?.name === 'AbortError' || streamErr?.code === 20;
                     if (isAbortError)
                         return;
-                    console.error(`[nova/events] SSE stream error for queue "${queueName}":`, String(streamErr).slice(0, 300));
+                    const elapsed = Date.now() - connectStart;
+                    console.error(`[nova/events] SSE stream error for queue "${queueName}" (after ${elapsed}ms):`, String(streamErr).slice(0, 500));
+                    _logErrorCause(streamErr);
                 }
                 if (abort.signal.aborted) {
                     console.log(`[nova/events] SSE consumer for queue "${queueName}" shut down gracefully`);
@@ -829,7 +845,9 @@ export function startInboundConsumer(db, options) {
                 }
                 // Stream ended (normal close OR proxy timeout). The connection WAS
                 // established, so no exponential backoff — reconnect in a fixed 1s.
-                console.log(`[nova/events] SSE stream for queue "${queueName}" closed — reconnecting in 1000ms…`);
+                const totalDuration = Date.now() - connectStart;
+                console.log(`[nova/events] SSE stream for queue "${queueName}" closed after ${totalDuration}ms — ` +
+                    `reconnecting in 1000ms…`);
                 await new Promise((resolve) => {
                     const t = setTimeout(resolve, 1_000);
                     abort.signal.addEventListener('abort', () => { clearTimeout(t); resolve(); }, { once: true });
@@ -844,7 +862,9 @@ export function startInboundConsumer(db, options) {
                 const isAbortError = err?.name === 'AbortError' || err?.code === 20;
                 if (isAbortError)
                     return;
-                console.error(`[nova/events] SSE connection error for queue "${queueName}":`, String(err).slice(0, 300));
+                const elapsed = Date.now() - connectStart;
+                console.error(`[nova/events] SSE connection error for queue "${queueName}" (failed after ${elapsed}ms):`, String(err).slice(0, 500));
+                _logErrorCause(err);
             }
             // Exponential backoff only for connection-level failures (fetch threw or
             // server returned non-200). Stream-level drops use the fixed 1s above.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newhomestar/sdk",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {