@mochabug/adapt-web 0.0.41 → 0.0.42

package/dist/esm/index.js

@@ -2,8 +2,26 @@ import { fromBinary, toJson } from "@bufbuild/protobuf";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import { connect, createInbox, credsAuthenticator, JSONCodec, } from "nats.ws";
 import { OutputSchema, SessionSchema, UrlSchema, } from "./genproto/mochabugapis/adapt/automations/v1/automations_pb.js";
+// Constants for JetStream protocol
+const CONSUMER_MSG_NEXT_PREFIX = "$JS.API.CONSUMER.MSG.NEXT.";
+const ACK_POSITIVE = new TextEncoder().encode("+ACK");
+const ACK_NEGATIVE = new TextEncoder().encode("-NAK");
+//const ACK_PREFIX = "$JS.ACK.";
+//const ACK_IN_PROGRESS = new TextEncoder().encode("+WPI");
+//const ACK_TERMINATE = new TextEncoder().encode("+TERM");
+// JetStream Status Codes
+const STATUS_NO_MESSAGES = "404";
+const STATUS_REQUEST_TIMEOUT = "408";
+const STATUS_MAX_ACK_PENDING = "409";
+const STATUS_FLOW_CONTROL = "100";
+// Default configuration
+const DEFAULT_MAX_MESSAGES = 100;
+const DEFAULT_EXPIRES_MS = 30000;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_THRESHOLD_RATIO = 0.5;
 const natsUrl = "wss://adapt-dev.mochabugapis.com:443/pubsub";
 const baseUrl = "https://adapt-dev.mochabugapis.com/v1/automations";
+// REST API functions (unchanged from original)
 export async function startSession(req, token) {
     const headers = new Headers({
         "Content-Type": "application/json",
@@ -96,6 +114,7 @@ export class RestClientError extends Error {
         this.response = response;
     }
 }
+// Connection states
 var ConnectionState;
 (function (ConnectionState) {
     ConnectionState["DISCONNECTED"] = "disconnected";
@@ -115,15 +134,17 @@ export class PubsubClient {
         this.urlHandler = null;
         this.isReconnecting = false;
         this.connectionState = ConnectionState.DISCONNECTED;
+        // Pull consumer state
+        this.pending = 0;
+        this.pulling = false;
+        this.pullTimer = null;
+        this.maxMessages = DEFAULT_MAX_MESSAGES;
+        this.expiresMs = DEFAULT_EXPIRES_MS;
+        this.pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+        this.threshold = DEFAULT_MAX_MESSAGES * DEFAULT_THRESHOLD_RATIO;
+        this.inbox = null;
+        this.jc = JSONCodec();
         this.debug = debug;
-        this.subscribe = this.subscribe.bind(this);
-        this.unsubscribe = this.unsubscribe.bind(this);
-        this.createSubscriptions = this.createSubscriptions.bind(this);
-        this.clearSubscriptions = this.clearSubscriptions.bind(this);
-        this.resubscribe = this.resubscribe.bind(this);
-        this.setupStatusMonitoring = this.setupStatusMonitoring.bind(this);
-        this.isConnected = this.isConnected.bind(this);
-        this.getConnectionState = this.getConnectionState.bind(this);
     }
     log(level, message, data) {
         if (!this.debug && level === "debug")
@@ -152,7 +173,9 @@ export class PubsubClient {
         }
         // If we're already connected to the same subject, just update handlers
         if (this.connectionState === ConnectionState.CONNECTED &&
-            this.subject === opts.subject) {
+            this.subject === opts.subject &&
+            this.streamName === opts.stream &&
+            this.consumerName === opts.consumer) {
             this.log("debug", "Already connected to same subject, updating handlers only");
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
@@ -169,13 +192,18 @@ export class PubsubClient {
         }
         try {
             this.connectionState = ConnectionState.CONNECTING;
-            // Store the new configuration
+            // Store configuration
             this.subject = opts.subject;
             this.streamName = opts.stream;
             this.consumerName = opts.consumer;
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
             this.urlHandler = opts.onUrl || null;
+            this.maxMessages = opts.maxMessages || DEFAULT_MAX_MESSAGES;
+            this.expiresMs = opts.expiresMs || DEFAULT_EXPIRES_MS;
+            this.pollIntervalMs = opts.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+            this.threshold = Math.floor(this.maxMessages * DEFAULT_THRESHOLD_RATIO);
+            // Connect to NATS
             const inboxPrefix = `_INBOX_${opts.consumer}`;
             this.log("debug", `Connecting with inbox prefix: ${inboxPrefix}`);
             this.nc = await connect({
@@ -191,16 +219,11 @@ export class PubsubClient {
             this.connectionState = ConnectionState.CONNECTED;
             this.log("info", "Connected successfully");
             this.setupStatusMonitoring();
-            await this.createSubscriptions(this.streamName, this.consumerName);
+            await this.createPullSubscription();
         }
         catch (error) {
             this.connectionState = ConnectionState.DISCONNECTED;
-            this.subject = null;
-            this.streamName = null;
-            this.consumerName = null;
-            this.outputHandler = null;
-            this.sessionHandler = null;
-            this.urlHandler = null;
+            this.cleanupState();
             if (this.nc) {
                 try {
                     await this.nc.close();
@@ -215,6 +238,8 @@ export class PubsubClient {
         }
     }
     setupStatusMonitoring() {
+        if (!this.nc)
+            return;
         (async () => {
             try {
                 for await (const status of this.nc.status()) {
@@ -239,32 +264,24 @@ export class PubsubClient {
                             }
                             break;
                         case "error":
-                            // Usually permissions errors
                             this.log("error", "Connection error:", status.data);
                             break;
                         case "update":
-                            // Cluster configuration update
                             this.log("debug", "Cluster update received:", status.data);
                             break;
                         case "ldm":
-                            // Lame Duck Mode - server is requesting clients to reconnect
                             this.log("warn", "Server requesting reconnection (LDM)");
                             break;
-                        // Debug events - usually can be safely ignored but useful for debugging
                         case "reconnecting":
                             this.log("debug", "Attempting to reconnect...");
                             break;
-                        case "pingTimer":
-                            // Ping timer events - very verbose, only log if debug is enabled
-                            if (this.debug) {
-                                this.log("debug", "Ping timer event");
-                            }
-                            break;
                         case "staleConnection":
                             this.log("warn", "Connection is stale, may reconnect soon");
                             break;
                         default:
-                            this.log("debug", `Unknown status event: ${status.type}`, status.data);
+                            if (status.type !== "pingTimer" || this.debug) {
+                                this.log("debug", `Status event: ${status.type}`, status.data);
+                            }
                     }
                 }
             }
@@ -275,180 +292,251 @@ export class PubsubClient {
             }
         })();
     }
-    async createSubscriptions(streamName, consumerName) {
+    async createPullSubscription() {
+        if (!this.nc || !this.streamName || !this.consumerName) {
+            throw new Error("Not properly initialized");
+        }
         await this.clearSubscriptions();
         try {
-            this.log("info", `Creating pull subscription for consumer: ${consumerName} on stream: ${streamName}`);
-            const jc = JSONCodec();
-            const pullSubject = `$JS.API.CONSUMER.MSG.NEXT.${streamName}.${consumerName}`;
-            // Create inbox with proper prefix - let the system generate the unique part
-            const inbox = createInbox(`_INBOX_${consumerName}`);
-            const sub = this.nc.subscribe(inbox);
+            this.log("info", `Creating pull subscription for consumer: ${this.consumerName} on stream: ${this.streamName}`);
+            // Create inbox for receiving messages
+            this.inbox = createInbox(`_INBOX_${this.consumerName}`);
+            const sub = this.nc.subscribe(this.inbox);
             this.pullSubscription = sub;
-            // Track state
-            let pending = 0;
-            let pulling = false;
-            const maxMessages = 100;
-            const threshold = 50;
-            const pollInterval = 1000; // 1 second poll interval
-            // Pull messages with proper expiration
-            const pull = async (batch) => {
-                if (pulling)
-                    return;
-                pulling = true;
+            // Reset state
+            this.pending = 0;
+            this.pulling = false;
+            // Start message processing loop
+            this.processMessages(sub);
+            // Initial pull - use no_wait to check for immediate messages
+            this.log("debug", `Initial no_wait pull for ${this.maxMessages} messages`);
+            await this.pull(this.maxMessages, true);
+            // Schedule periodic pulls for long polling
+            this.schedulePull();
+            this.log("info", "Pull subscription created successfully");
+        }
+        catch (error) {
+            this.log("error", "Failed to create subscriptions:", error);
+            throw error;
+        }
+    }
+    async processMessages(sub) {
+        try {
+            for await (const msg of sub) {
+                if (this.connectionState === ConnectionState.CLOSING ||
+                    this.connectionState === ConnectionState.DISCONNECTED) {
+                    this.log("info", "Subscription closing");
+                    break;
+                }
                 try {
-                    // Set expires to slightly longer than poll interval to avoid accumulation
-                    const request = {
-                        batch,
-                        expires: (pollInterval + 500) * 1000000, // Poll interval + 500ms buffer, in nanoseconds
-                    };
-                    this.nc.publish(pullSubject, jc.encode(request), { reply: inbox });
-                    pending += batch;
-                    this.log("debug", `Pull request sent: batch=${batch}, pending=${pending}, expires=${request.expires}ns`);
+                    await this.handleMessage(msg);
                 }
-                finally {
-                    pulling = false;
+                catch (error) {
+                    this.log("error", "Error handling message:", error);
                 }
-            };
-            // Initial pull
-            this.log("debug", `Initial pull request for ${maxMessages} messages`);
-            pull(maxMessages);
-            // Set up periodic pulling
-            let pullTimer = null;
-            const schedulePull = () => {
-                if (pullTimer)
-                    clearTimeout(pullTimer);
-                pullTimer = setTimeout(() => {
-                    if (pending < threshold) {
-                        const pullCount = maxMessages - pending;
-                        this.log("debug", `Scheduled pull: pending=${pending} < threshold=${threshold}, pulling ${pullCount} more`);
-                        pull(pullCount);
-                    }
-                    else {
-                        this.log("debug", `Skipping scheduled pull: pending=${pending} >= threshold=${threshold}`);
+            }
+        }
+        catch (error) {
+            if (this.connectionState !== ConnectionState.CLOSING) {
+                this.log("error", "Message processing error:", error);
+            }
+        }
+    }
+    async handleMessage(msg) {
+        this.log("debug", "header", msg.headers);
+        const status = msg.headers?.get("Status");
+        const description = msg.headers?.get("Description");
+        if (status) {
+            this.log("debug", `Received status message: ${status} ${description || ""}`);
+            await this.handleStatusMessage(status, description, msg);
+            return;
+        }
+        // Check for flow control messages (also may have empty data)
+        const flowControl = msg.headers?.get("Nats-Msg-Size");
+        if (flowControl === "FlowControl") {
+            this.log("debug", "Received flow control request, responding");
+            msg.respond();
+            return;
+        }
+        // Alternative flow control check
+        if (msg.headers) {
+            const headers = Array.from(msg.headers.keys());
+            if (headers.some((h) => h.includes("FlowControl"))) {
+                this.log("debug", "Received flow control message, responding");
+                if (msg.reply) {
+                    msg.respond();
+                }
+                return;
+            }
+        }
+        // Now check if this is an actual data message
+        // Status and flow control messages will have already been handled above
+        if (!msg.data || msg.data.length === 0) {
+            // This should be rare now - log with more detail for debugging
+            this.log("debug", `Received empty message on ${msg.subject}, headers: ${msg.headers ? Array.from(msg.headers.keys()).join(", ") : "none"}`);
+            return;
+        }
+        // Get the actual stream subject from headers
+        const streamSubject = msg.headers?.get("Nats-Subject");
+        if (!streamSubject) {
+            this.log("debug", "Message without stream subject, skipping");
+            return;
+        }
+        // We got a real message
+        this.pending = Math.max(0, this.pending - 1);
+        this.log("debug", `Message received on subject ${streamSubject}, pending decreased to ${this.pending}`);
+        // Process the message
+        const parts = streamSubject.split(".");
+        const action = parts[parts.length - 1];
+        this.log("info", `↓ message: ${action} on ${streamSubject}`);
+        try {
+            switch (action) {
+                case "output": {
+                    if (this.outputHandler) {
+                        const output = fromBinary(OutputSchema, msg.data);
+                        this.outputHandler({
+                            vertex: output.vertex,
+                            fork: output.fork,
+                            data: parseOutputData(output.data),
+                            created: timestampDate(output.created),
+                        });
                     }
-                }, pollInterval);
-            };
-            // Process messages
-            (async () => {
-                try {
-                    for await (const msg of sub) {
-                        if (this.connectionState === ConnectionState.CLOSING ||
-                            this.connectionState === ConnectionState.DISCONNECTED) {
-                            this.log("info", "Subscription closing");
-                            if (pullTimer)
-                                clearTimeout(pullTimer);
-                            break;
-                        }
-                        // Check status header
-                        const status = msg.headers?.get("Status");
-                        if (status === "404") {
-                            // No messages available
-                            this.log("debug", "No messages available (404), resetting pending to 0");
-                            pending = 0;
-                            schedulePull();
-                            continue;
-                        }
-                        if (status === "408") {
-                            this.log("debug", "Pull request timed out (408), resetting pending and pulling immediately");
-                            pending = 0;
-                            pull(maxMessages); // Immediately pull again instead of scheduling
-                            continue;
-                        }
-                        if (status === "409") {
-                            this.log("warn", "Max ack pending reached (409), waiting 5 seconds before retry");
-                            pending = 0;
-                            setTimeout(() => pull(maxMessages), 5000);
-                            continue;
-                        }
-                        // Skip if not a real message
-                        if (!msg.data || msg.data.length === 0 || msg.subject === inbox) {
-                            this.log("debug", `Skipping non-message: data=${msg.data?.length || 0} bytes, subject=${msg.subject}`);
-                            continue;
-                        }
-                        // We got a real message
-                        pending = Math.max(0, pending - 1);
-                        this.log("debug", `Message received, pending decreased to ${pending}`);
-                        // Re-pull if below threshold
-                        if (pending < threshold && !pulling) {
-                            const pullCount = maxMessages - pending;
-                            this.log("debug", `Pending ${pending} < threshold ${threshold}, pulling ${pullCount} more messages`);
-                            pull(pullCount);
-                        }
-                        const parts = msg.subject.split(".");
-                        const action = parts[parts.length - 1];
-                        this.log("info", `↓ message: ${action} on ${msg.subject}`);
-                        try {
-                            switch (action) {
-                                case "output": {
-                                    if (this.outputHandler) {
-                                        const output = fromBinary(OutputSchema, msg.data);
-                                        this.outputHandler({
-                                            vertex: output.vertex,
-                                            fork: output.fork,
-                                            data: parseOutputData(output.data),
-                                            created: timestampDate(output.created),
-                                        });
-                                    }
-                                    break;
-                                }
-                                case "session": {
-                                    if (this.sessionHandler) {
-                                        const session = fromBinary(SessionSchema, msg.data);
-                                        this.sessionHandler(toJson(SessionSchema, session));
-                                    }
-                                    break;
-                                }
-                                case "url": {
-                                    if (this.urlHandler) {
-                                        const url = fromBinary(UrlSchema, msg.data);
-                                        this.urlHandler(toJson(UrlSchema, url));
-                                    }
-                                    break;
-                                }
-                                default:
-                                    this.log("warn", `Unknown message action: ${action}`);
-                            }
-                            // ACK the message
-                            const ackSuccess = msg.respond();
-                            if (!ackSuccess) {
-                                this.log("warn", "Failed to ACK message");
-                            }
-                            else {
-                                this.log("debug", `Message ACKed successfully for action: ${action}`);
-                            }
-                        }
-                        catch (error) {
-                            this.log("error", "Error handling message:", error);
-                            // NAK the message for redelivery
-                            const nakSuccess = msg.respond(new TextEncoder().encode("-NAK"));
-                            if (!nakSuccess) {
-                                this.log("warn", "Failed to NAK message");
-                            }
-                            else {
-                                this.log("debug", "Message NAKed for redelivery");
-                            }
-                        }
+                    break;
+                }
+                case "session": {
+                    if (this.sessionHandler) {
+                        const session = fromBinary(SessionSchema, msg.data);
+                        this.sessionHandler(toJson(SessionSchema, session));
                     }
+                    break;
                 }
-                catch (error) {
-                    if (this.connectionState !== ConnectionState.CLOSING) {
-                        this.log("error", "Handler error:", error);
+                case "url": {
+                    if (this.urlHandler) {
+                        const url = fromBinary(UrlSchema, msg.data);
+                        this.urlHandler(toJson(UrlSchema, url));
                     }
+                    break;
+                }
+                default:
+                    this.log("warn", `Unknown message action: ${action}`);
+            }
+            // ACK the message
+            if (msg.reply) {
+                msg.respond(ACK_POSITIVE);
+                this.log("debug", `Message ACKed successfully for action: ${action}`);
+            }
+        }
+        catch (error) {
+            this.log("error", "Error processing message:", error);
+            // NAK the message for redelivery
+            if (msg.reply) {
+                msg.respond(ACK_NEGATIVE);
+                this.log("debug", "Message NAKed for redelivery");
+            }
+            throw error;
+        }
+        // Pull more if below threshold
+        if (this.pending < this.threshold && !this.pulling) {
+            const pullCount = this.maxMessages - this.pending;
+            this.log("debug", `Pending ${this.pending} < threshold ${this.threshold}, pulling ${pullCount} more messages`);
+            this.pull(pullCount, false);
+        }
+    }
+    async handleStatusMessage(status, description, msg) {
+        switch (status) {
+            case STATUS_NO_MESSAGES:
+                this.log("debug", `No messages available (404): ${description || "No Messages"}`);
+                this.pending = 0;
+                // This is expected when using no_wait or when there are no messages
+                // Don't immediately pull again, let the scheduler handle it
+                break;
+            case STATUS_REQUEST_TIMEOUT:
+                this.log("debug", `Pull request expired (408): ${description || "Request Timeout"}`);
+                // This can happen for each unfilled slot in a batch
+                // Decrement pending for each 408 received
+                if (this.pending > 0) {
+                    this.pending--;
                 }
-                finally {
-                    if (pullTimer)
-                        clearTimeout(pullTimer);
+                // Don't immediately pull, let threshold logic handle it
+                if (this.pending < this.threshold && !this.pulling) {
+                    await this.pull(this.maxMessages - this.pending, false);
                 }
-            })();
-            this.log("info", "Pull subscription created successfully");
+                break;
+            case STATUS_MAX_ACK_PENDING:
+                this.log("warn", `Max ack pending reached (409): ${description || "Exceeded MaxAckPending"}`);
+                this.pending = 0;
+                // Wait before retry
+                setTimeout(() => this.pull(this.maxMessages, false), 5000);
+                break;
+            case STATUS_FLOW_CONTROL:
+                this.log("debug", `Received heartbeat/flow control (100): ${description || ""}`);
+                // Respond if needed
+                if (msg.reply) {
+                    msg.respond();
+                }
+                break;
+            default:
+                this.log("debug", `Received unknown status: ${status} - ${description || ""}`);
+        }
+    }
+    async pull(batch, noWait = false) {
+        if (this.pulling || !this.nc || !this.inbox || batch <= 0) {
+            this.log("debug", `Skipping pull: pulling=${this.pulling}, batch=${batch}`);
+            return;
+        }
+        this.pulling = true;
+        try {
+            const pullSubject = `${CONSUMER_MSG_NEXT_PREFIX}${this.streamName}.${this.consumerName}`;
+            const request = {
+                batch,
+            };
+            if (noWait) {
+                request.no_wait = true;
+            }
+            else if (this.expiresMs > 0) {
+                // Convert milliseconds to nanoseconds
+                request.expires = this.expiresMs * 1000000;
+            }
+            this.nc.publish(pullSubject, this.jc.encode(request), {
+                reply: this.inbox,
+            });
+            this.pending += batch;
+            this.log("debug", `Pull request sent: batch=${batch}, pending=${this.pending}, noWait=${noWait}, expires=${request.expires ? `${this.expiresMs}ms` : "none"}`);
         }
         catch (error) {
-            this.log("error", "Failed to create subscriptions:", error);
+            this.log("error", "Error sending pull request:", error);
             throw error;
         }
+        finally {
+            this.pulling = false;
+        }
+    }
+    schedulePull() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+        }
+        if (this.connectionState !== ConnectionState.CONNECTED) {
+            return;
+        }
+        this.pullTimer = setTimeout(() => {
+            if (this.pending < this.threshold && !this.pulling) {
+                const pullCount = this.maxMessages - this.pending;
+                this.log("debug", `Scheduled pull: pending=${this.pending} < threshold=${this.threshold}, pulling ${pullCount} more`);
+                // For scheduled pulls, use long polling (with expires)
+                this.pull(pullCount, false);
+            }
+            else {
+                this.log("debug", `Skipping scheduled pull: pending=${this.pending} >= threshold=${this.threshold} or pulling=${this.pulling}`);
+            }
+            // Reschedule
+            this.schedulePull();
+        }, this.pollIntervalMs);
     }
     async clearSubscriptions() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+            this.pullTimer = null;
+        }
         if (!this.pullSubscription)
             return;
         this.log("debug", "Clearing subscription");
@@ -462,10 +550,27 @@ export class PubsubClient {
         this.pullSubscription = null;
     }
     async resubscribe() {
-        // Only called when we have an active connection that needs resubscription
-        await this.createSubscriptions(this.streamName, this.consumerName);
+        if (!this.streamName || !this.consumerName)
+            return;
+        this.log("info", "Resubscribing after reconnection");
+        // Clear old state
+        this.pending = 0;
+        this.pulling = false;
+        // Recreate subscription
+        await this.createPullSubscription();
         this.log("info", "✓ Resubscribed successfully");
     }
+    cleanupState() {
+        this.subject = null;
+        this.streamName = null;
+        this.consumerName = null;
+        this.outputHandler = null;
+        this.sessionHandler = null;
+        this.urlHandler = null;
+        this.inbox = null;
+        this.pending = 0;
+        this.pulling = false;
+    }
     async unsubscribe() {
         if (this.connectionState === ConnectionState.DISCONNECTED ||
             this.connectionState === ConnectionState.CLOSING) {
@@ -474,12 +579,7 @@ export class PubsubClient {
         this.log("info", "Starting unsubscribe process");
         this.connectionState = ConnectionState.CLOSING;
         await this.clearSubscriptions();
-        this.outputHandler = null;
-        this.sessionHandler = null;
-        this.urlHandler = null;
-        this.subject = null;
-        this.streamName = null;
-        this.consumerName = null;
+        this.cleanupState();
         this.isReconnecting = false;
         if (this.nc && !this.nc.isClosed()) {
             try {
@@ -501,6 +601,7 @@ export class PubsubClient {
         return this.connectionState;
     }
 }
+// Helper functions
 function validateSubject(subject) {
     if (!subject || subject.includes(" ") || subject.includes("\t")) {
         return false;
@@ -518,7 +619,6 @@ function parseOutputData(data) {
             return [key, JSON.parse(new TextDecoder().decode(value))];
         }
         catch (error) {
-            // Note: We don't have access to the log method here, so we keep console.error
             console.error(`Failed to parse data for key ${key}:`, error);
             return [key, null];
         }
@@ -535,4 +635,19 @@ function createAuthenticator(val) {
         throw new Error("Invalid credentials format");
     }
 }
+// Usage example
+export async function createPubsubClient(credentials, automation, handlers, options) {
+    const client = new PubsubClient(options?.debug);
+    await client.subscribe({
+        credentials,
+        subject: `automations.${automation.organization}.${automation.group}.${automation.automation}.>`,
+        stream: "automations",
+        consumer: `${automation.automation}-consumer`,
+        onOutput: handlers.onOutput,
+        onSession: handlers.onSession,
+        onUrl: handlers.onUrl,
+        ...options,
+    });
+    return client;
+}
 //# sourceMappingURL=index.js.map