@jep182/n8n-nodes-whatsthat 0.3.0 → 0.4.3

package/README.md

@@ -17,8 +17,8 @@ It lets you:
 
 Use this node to:
 
-- create a session
 - connect a session
+- wait for a session to become connected
 - list sessions
 - inspect session status
 - disconnect a session
@@ -27,6 +27,7 @@ Use this node to:
 When pairing is available, the node returns:
 
 - `pairingCode`
+- `qrCodeUrl`
 - `qr`
 - `qrDataUrl`
 
@@ -85,14 +86,19 @@ WhatsThat embeds Baileys directly in n8n.
 ```
 
 3. Add `WhatsThat Session`.
-4. Choose `Create Session`, then provide:
+4. Choose `Connect Session`, then provide:
    - `Session ID (Internal)`: a stable unique ID such as `main-phone`
    - `Label (Visible Name)`: a human-readable name such as `Luca personal phone`
    - optional `Phone Number For Pairing`: full number with country code, digits only, without `00` or `+`
-5. Run `Connect Session`.
-6. Use the returned `pairingCode` or `qrDataUrl` to connect the device.
-7. Use `WhatsThat Targets` to discover and link chats/groups.
-8. Use `WhatsThat Message` to send messages by alias or raw JID.
+5. Run the node and use the returned `pairingCode`, `qrCodeUrl`, or `qrDataUrl` to connect the device.
+6. Add another `WhatsThat Session` node with `Ensure Session`.
+7. Set `Return When` to `Connected` so the workflow waits until the already-started session finishes pairing.
+8. Use `WhatsThat Targets` to discover and link chats/groups.
+9. Use `WhatsThat Message` to send messages by alias or raw JID.
+
+Example workflow:
+
+- [`examples/register-number.workflow.json`](./examples/register-number.workflow.json)
 
 ## Media Delivery
 

package/dist/nodes/WhatsThatSession/WhatsThatSession.node.js

@@ -13,7 +13,7 @@ class WhatsThatSession {
             icon: 'file:whatsthat.svg',
             group: ['transform'],
             version: 1,
-            description: 'Manage embedded Baileys sessions for WhatsThat',
+            description: 'Create, connect, and manage embedded Baileys sessions for WhatsThat',
             defaults: { name: 'WhatsThat Session' },
             inputs: ['main'],
             outputs: ['main'],
@@ -23,10 +23,10 @@ class WhatsThatSession {
                     displayName: 'Operation',
                     name: 'operation',
                     type: 'options',
-                    default: 'create',
+                    default: 'connect',
                     options: [
-                        { name: 'Create Session', value: 'create' },
                         { name: 'Connect Session', value: 'connect' },
+                        { name: 'Ensure Session', value: 'ensure' },
                         { name: 'List Sessions', value: 'list' },
                         { name: 'Get Session Status', value: 'status' },
                         { name: 'Disconnect Session', value: 'disconnect' },
@@ -51,7 +51,7 @@ class WhatsThatSession {
                     default: '',
                     description: 'Human-readable name shown in results. Example: "Luca personal phone" or "Support number".',
                     displayOptions: {
-                        show: { operation: ['create'] },
+                        show: { operation: ['connect', 'ensure'] },
                     },
                 },
                 {
@@ -61,7 +61,34 @@ class WhatsThatSession {
                     default: '',
                     description: 'Optional. Full phone number with country code, digits only, without 00 or +. Example: 393331234567.',
                     displayOptions: {
-                        show: { operation: ['create'] },
+                        show: { operation: ['connect', 'ensure'] },
+                    },
+                },
+                {
+                    displayName: 'Return When',
+                    name: 'waitFor',
+                    type: 'options',
+                    default: 'pairing_or_connected',
+                    options: [
+                        { name: 'Pairing Is Ready Or Connected', value: 'pairing_or_connected' },
+                        { name: 'Connected', value: 'connected' },
+                    ],
+                    description: 'Return as soon as pairing data is ready, or wait until the session is fully connected.',
+                    displayOptions: {
+                        show: { operation: ['ensure'] },
+                    },
+                },
+                {
+                    displayName: 'Timeout Seconds',
+                    name: 'timeoutSeconds',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                    },
+                    default: 20,
+                    description: 'Maximum time to wait before returning the latest known session status.',
+                    displayOptions: {
+                        show: { operation: ['ensure'] },
                     },
                 },
             ],
@@ -77,19 +104,33 @@ class WhatsThatSession {
                 const rawSessionId = this.getNodeParameter('sessionId', itemIndex, '');
                 const sessionId = operation === 'list' ? (0, validation_1.normalizeSessionId)(rawSessionId) : (0, validation_1.requireSessionId)(rawSessionId);
                 let json;
-                const label = this.getNodeParameter('label', itemIndex, '').trim();
-                const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
                 switch (operation) {
-                    case 'create':
-                        json = await runtime_1.registry.ensureSession(access.paths.root, access, {
+                    case 'connect': {
+                        const label = this.getNodeParameter('label', itemIndex, '').trim();
+                        const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
+                        await runtime_1.registry.ensureSession(access.paths.root, access, {
                             sessionId,
                             label: label || sessionId,
                             phoneNumberForPairing,
                         });
-                        break;
-                    case 'connect':
                         json = await runtime_1.registry.connectSession(access.paths.root, access, sessionId);
                         break;
+                    }
+                    case 'ensure': {
+                        const label = this.getNodeParameter('label', itemIndex, '').trim();
+                        const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
+                        const waitFor = this.getNodeParameter('waitFor', itemIndex);
+                        const timeoutSeconds = this.getNodeParameter('timeoutSeconds', itemIndex, 20);
+                        json = await runtime_1.registry.ensureConnectedSession(access.paths.root, access, {
+                            sessionId,
+                            label: label || sessionId,
+                            phoneNumberForPairing,
+                        }, {
+                            waitFor,
+                            timeoutMs: timeoutSeconds * 1000,
+                        });
+                        break;
+                    }
                     case 'list':
                         json = await runtime_1.registry.listSessions(access);
                         break;

package/dist/shared/runtime.d.ts

@@ -46,6 +46,14 @@ declare class WhatsThatRegistry extends EventEmitter {
         phoneNumberForPairing?: string;
     }): Promise<SessionRecord>;
     connectSession(storageRoot: string, access: DataAccess, sessionId: string): Promise<SessionRecord>;
+    ensureConnectedSession(_storageRoot: string, access: DataAccess, input: {
+        sessionId: string;
+        label: string;
+        phoneNumberForPairing?: string;
+    }, options?: {
+        waitFor?: 'pairing_or_connected' | 'connected';
+        timeoutMs?: number;
+    }): Promise<SessionRecord>;
     listSessions(access: DataAccess): Promise<SessionRecord[]>;
     getSession(access: DataAccess, sessionId: string): Promise<SessionRecord | undefined>;
     disconnectSession(access: DataAccess, sessionId: string): Promise<SessionRecord | undefined>;
@@ -61,7 +69,11 @@ declare class WhatsThatRegistry extends EventEmitter {
     private upsertSession;
     private upsertDiscoveredTarget;
     private emitRuntime;
+    private waitForSessionState;
+    private matchesWaitTarget;
+    waitForConnectedSession(access: DataAccess, sessionId: string, timeoutMs: number): Promise<SessionRecord>;
     private required;
+    private buildQrCodeUrl;
 }
 export declare const registry: WhatsThatRegistry;
 export declare function extractMessageText(message: proto.IMessage | null | undefined): string | undefined;

package/dist/shared/runtime.js

@@ -98,10 +98,12 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
             if (update.qr) {
                 qrcode_terminal_1.default.generate(update.qr, { small: true });
                 const qrDataUrl = await qrcode_1.default.toDataURL(update.qr);
+                const qrCodeUrl = this.buildQrCodeUrl(update.qr);
                 const pairingRecord = {
                     ...current,
                     status: 'pairing',
                     qr: update.qr,
+                    qrCodeUrl,
                     qrDataUrl,
                     updatedAt: new Date().toISOString(),
                     lastSeenAt: new Date().toISOString(),
@@ -128,6 +130,7 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
                     status: 'connected',
                     phone: socket.user?.id,
                     qr: undefined,
+                    qrCodeUrl: undefined,
                     qrDataUrl: undefined,
                     pairingCode: undefined,
                     updatedAt: new Date().toISOString(),
@@ -216,6 +219,17 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
         this.sockets.set(sessionId, socket);
         return (await this.getSession(access, sessionId)) ?? starting;
     }
+    async ensureConnectedSession(_storageRoot, access, input, options) {
+        await this.ensureSession(_storageRoot, access, input);
+        const current = await this.getSession(access, input.sessionId);
+        if (!current) {
+            throw new Error(`Unknown session ${input.sessionId}`);
+        }
+        if (!this.sockets.has(input.sessionId) && current.status !== 'connected') {
+            throw new Error(`Session ${input.sessionId} is not active. Run Connect Session first and keep the n8n runtime alive until pairing completes.`);
+        }
+        return this.waitForSessionState(access, input.sessionId, options?.waitFor ?? 'pairing_or_connected', options?.timeoutMs ?? 20000);
+    }
     async listSessions(access) {
         const sessions = await access.listSessions();
         return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
@@ -448,12 +462,71 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
     emitRuntime(event) {
         this.emit('event', event);
     }
+    async waitForSessionState(access, sessionId, waitFor, timeoutMs) {
+        const current = await this.getSession(access, sessionId);
+        if (!current) {
+            throw new Error(`Unknown session ${sessionId}`);
+        }
+        if (this.matchesWaitTarget(current, waitFor)) {
+            return current;
+        }
+        return new Promise((resolve) => {
+            let settled = false;
+            let timeout;
+            const cleanup = () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                this.off('event', handler);
+            };
+            const settle = async () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve((await this.getSession(access, sessionId)) ?? current);
+            };
+            const handler = async (event) => {
+                if (event.sessionId !== sessionId)
+                    return;
+                const latest = await this.getSession(access, sessionId);
+                if (latest && this.matchesWaitTarget(latest, waitFor)) {
+                    await settle();
+                }
+            };
+            this.on('event', handler);
+            timeout = setTimeout(() => {
+                void settle();
+            }, timeoutMs);
+        });
+    }
+    matchesWaitTarget(record, waitFor) {
+        if (record.status === 'connected') {
+            return true;
+        }
+        if (waitFor === 'pairing_or_connected' && record.status === 'pairing') {
+            return true;
+        }
+        return false;
+    }
+    async waitForConnectedSession(access, sessionId, timeoutMs) {
+        const current = await this.getSession(access, sessionId);
+        if (!current) {
+            throw new Error(`Unknown session ${sessionId}`);
+        }
+        if (!this.sockets.has(sessionId) && current.status !== 'connected') {
+            throw new Error(`Session ${sessionId} is not active. Run Connect Session first and keep the n8n runtime alive until pairing completes.`);
+        }
+        return this.waitForSessionState(access, sessionId, 'connected', timeoutMs);
+    }
     required(value, field) {
         if (value === undefined || value === null || value === '') {
             throw new Error(`Missing required field ${field}`);
         }
         return value;
     }
+    buildQrCodeUrl(qr) {
+        return `https://quickchart.io/qr?text=${encodeURIComponent(qr)}`;
+    }
 }
 exports.registry = new WhatsThatRegistry();
 function extractMessageText(message) {

package/dist/shared/types.d.ts

@@ -7,6 +7,7 @@ export interface SessionRecord {
     phone?: string;
     pairingCode?: string;
     qr?: string;
+    qrCodeUrl?: string;
     qrDataUrl?: string;
     phoneNumberForPairing?: string;
     lastSeenAt: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jep182/n8n-nodes-whatsthat",
-  "version": "0.3.0",
+  "version": "0.4.3",
   "description": "n8n community nodes with embedded Baileys runtime for multi-session chat automation",
   "license": "MIT",
   "main": "dist/index.js",