@jep182/n8n-nodes-whatsthat 0.2.0

package/dist/nodes/WhatsThatTargets/WhatsThatTargets.node.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsThatTargets = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const access_1 = require("../../shared/access");
+const runtime_1 = require("../../shared/runtime");
+class WhatsThatTargets {
+    constructor() {
+        this.description = {
+            displayName: 'WhatsThat Targets',
+            name: 'whatsThatTargets',
+            icon: 'file:../WhatsThatSession/whatsthat.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Discover, link, and manage chats and groups for WhatsThat',
+            defaults: { name: 'WhatsThat Targets' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'whatsThatRuntime', required: true }],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    default: 'listDiscovered',
+                    options: [
+                        { name: 'List Discovered Targets', value: 'listDiscovered' },
+                        { name: 'List Linked Targets', value: 'listLinked' },
+                        { name: 'Link Target', value: 'link' },
+                        { name: 'Unlink Target', value: 'unlink' },
+                    ],
+                },
+                {
+                    displayName: 'Session ID',
+                    name: 'sessionId',
+                    type: 'string',
+                    default: '',
+                },
+                {
+                    displayName: 'Target JID',
+                    name: 'jid',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: { operation: ['link'] },
+                    },
+                },
+                {
+                    displayName: 'Alias',
+                    name: 'alias',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: { operation: ['link', 'unlink'] },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const access = await (0, access_1.buildAccess)(this);
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const operation = this.getNodeParameter('operation', itemIndex);
+                const sessionId = this.getNodeParameter('sessionId', itemIndex);
+                let json;
+                switch (operation) {
+                    case 'listDiscovered':
+                        json = await runtime_1.registry.listTargets(access, sessionId);
+                        break;
+                    case 'listLinked':
+                        json = await runtime_1.registry.listLinkedTargets(access, sessionId);
+                        break;
+                    case 'link':
+                        json = await runtime_1.registry.connectTarget(access, sessionId, this.getNodeParameter('alias', itemIndex), this.getNodeParameter('jid', itemIndex));
+                        break;
+                    case 'unlink':
+                        json = {
+                            removed: await runtime_1.registry.unlinkTarget(access, sessionId, this.getNodeParameter('alias', itemIndex)),
+                        };
+                        break;
+                    default:
+                        throw new Error(`Unsupported operation ${operation}`);
+                }
+                returnData.push({ json: json, pairedItem: itemIndex });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: itemIndex });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.WhatsThatTargets = WhatsThatTargets;

package/dist/nodes/WhatsThatTrigger/WhatsThatTrigger.node.d.ts

@@ -0,0 +1,5 @@
+import type { INodeType, INodeTypeDescription, ITriggerFunctions, ITriggerResponse } from 'n8n-workflow';
+export declare class WhatsThatTrigger implements INodeType {
+    description: INodeTypeDescription;
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
+}

package/dist/nodes/WhatsThatTrigger/WhatsThatTrigger.node.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsThatTrigger = void 0;
+const runtime_1 = require("../../shared/runtime");
+class WhatsThatTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'WhatsThat Trigger',
+            name: 'whatsThatTrigger',
+            icon: 'file:../WhatsThatSession/whatsthat.svg',
+            group: ['trigger'],
+            version: 1,
+            description: 'Listen to session, message, and group events from WhatsThat',
+            defaults: { name: 'WhatsThat Trigger' },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [{ name: 'whatsThatRuntime', required: true }],
+            properties: [
+                { displayName: 'Session ID', name: 'sessionId', type: 'string', default: '' },
+                {
+                    displayName: 'Event',
+                    name: 'eventName',
+                    type: 'options',
+                    default: 'message.received',
+                    options: [
+                        { name: 'Message Received', value: 'message.received' },
+                        { name: 'Message From Me', value: 'message.from_me' },
+                        { name: 'Message Sent', value: 'message.sent' },
+                        { name: 'Session Pairing', value: 'session.pairing' },
+                        { name: 'Session Connected', value: 'session.connected' },
+                        { name: 'Session Disconnected', value: 'session.disconnected' },
+                        { name: 'Group Updated', value: 'group.updated' },
+                        { name: 'Group Participants', value: 'group.participants' },
+                        { name: 'Any Event', value: '*' }
+                    ],
+                }
+            ],
+        };
+    }
+    async trigger() {
+        const sessionId = this.getNodeParameter('sessionId');
+        const eventName = this.getNodeParameter('eventName');
+        const handler = (event) => {
+            if (event.sessionId !== sessionId)
+                return;
+            if (eventName !== '*' && event.event !== eventName)
+                return;
+            this.emit([[{ json: event }]]);
+        };
+        runtime_1.registry.on('event', handler);
+        return {
+            closeFunction: async () => {
+                runtime_1.registry.off('event', handler);
+            },
+        };
+    }
+}
+exports.WhatsThatTrigger = WhatsThatTrigger;

package/dist/shared/access.d.ts

@@ -0,0 +1,18 @@
+import type { NodeContext } from './context';
+import type { DedupRecord, DiscoveredTarget, LinkedTarget, SessionRecord } from './types';
+export declare function buildAccess(context: NodeContext): Promise<{
+    config: import("./context").RuntimeConfig;
+    paths: {
+        root: string;
+        authRoot: string;
+        tablesFallback: string;
+    };
+    listSessions: () => Promise<SessionRecord[]>;
+    saveSessions: (data: SessionRecord[]) => Promise<void>;
+    listLinkedTargets: () => Promise<LinkedTarget[]>;
+    saveLinkedTargets: (data: LinkedTarget[]) => Promise<void>;
+    listDiscoveredTargets: () => Promise<DiscoveredTarget[]>;
+    saveDiscoveredTargets: (data: DiscoveredTarget[]) => Promise<void>;
+    listDedup: () => Promise<DedupRecord[]>;
+    saveDedup: (data: DedupRecord[]) => Promise<void>;
+}>;

package/dist/shared/access.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAccess = buildAccess;
+const context_1 = require("./context");
+const fs_1 = require("./fs");
+const store_1 = require("./store");
+async function buildAccess(context) {
+    const config = await (0, context_1.getRuntimeConfig)(context);
+    const paths = (0, context_1.runtimePaths)(config);
+    await (0, fs_1.ensureDir)(paths.root);
+    await (0, fs_1.ensureDir)(paths.authRoot);
+    return {
+        config,
+        paths,
+        listSessions: () => (0, store_1.listRecords)(context, config, 'sessions'),
+        saveSessions: (data) => (0, store_1.saveRecords)(context, config, 'sessions', data),
+        listLinkedTargets: () => (0, store_1.listRecords)(context, config, 'linked_targets'),
+        saveLinkedTargets: (data) => (0, store_1.saveRecords)(context, config, 'linked_targets', data),
+        listDiscoveredTargets: () => (0, store_1.listRecords)(context, config, 'discovered_targets'),
+        saveDiscoveredTargets: (data) => (0, store_1.saveRecords)(context, config, 'discovered_targets', data),
+        listDedup: () => (0, store_1.listRecords)(context, config, 'dedup'),
+        saveDedup: (data) => (0, store_1.saveRecords)(context, config, 'dedup', data),
+    };
+}

package/dist/shared/context.d.ts

@@ -0,0 +1,15 @@
+import type { IDataObject, IExecuteFunctions, ILoadOptionsFunctions, IDataTableProjectAggregateService, IDataTableProjectService } from 'n8n-workflow';
+export type NodeContext = IExecuteFunctions | ILoadOptionsFunctions;
+export interface RuntimeConfig {
+    storagePath: string;
+    useDataTables: boolean;
+}
+export declare function getRuntimeConfig(context: NodeContext): Promise<RuntimeConfig>;
+export declare function runtimePaths(config: RuntimeConfig): {
+    root: string;
+    authRoot: string;
+    tablesFallback: string;
+};
+export declare function getAggregateProxy(context: NodeContext): Promise<IDataTableProjectAggregateService | null>;
+export declare function getTableProxy(context: NodeContext, tableId: string): Promise<IDataTableProjectService | null>;
+export declare function asDataObject(value: unknown): IDataObject;

package/dist/shared/context.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = getRuntimeConfig;
+exports.runtimePaths = runtimePaths;
+exports.getAggregateProxy = getAggregateProxy;
+exports.getTableProxy = getTableProxy;
+exports.asDataObject = asDataObject;
+const node_path_1 = __importDefault(require("node:path"));
+async function getRuntimeConfig(context) {
+    const credentials = await context.getCredentials('whatsThatRuntime');
+    const storagePath = String(credentials.storagePath || '/home/node/.n8n/whatsthat');
+    return {
+        storagePath,
+        useDataTables: Boolean(credentials.useDataTables ?? true),
+    };
+}
+function runtimePaths(config) {
+    return {
+        root: config.storagePath,
+        authRoot: node_path_1.default.join(config.storagePath, 'auth'),
+        tablesFallback: node_path_1.default.join(config.storagePath, 'tables'),
+    };
+}
+async function getAggregateProxy(context) {
+    if (!context.helpers.getDataTableAggregateProxy) {
+        return null;
+    }
+    return context.helpers.getDataTableAggregateProxy();
+}
+async function getTableProxy(context, tableId) {
+    if (!context.helpers.getDataTableProxy) {
+        return null;
+    }
+    return context.helpers.getDataTableProxy(tableId);
+}
+function asDataObject(value) {
+    return value;
+}

package/dist/shared/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function ensureDirFor(filePath: string): Promise<void>;
+export declare function readJson<T>(filePath: string, fallback: T): Promise<T>;
+export declare function writeJson<T>(filePath: string, payload: T): Promise<void>;

package/dist/shared/fs.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.ensureDirFor = ensureDirFor;
+exports.readJson = readJson;
+exports.writeJson = writeJson;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+async function ensureDir(dirPath) {
+    await promises_1.default.mkdir(dirPath, { recursive: true });
+}
+async function ensureDirFor(filePath) {
+    await ensureDir(node_path_1.default.dirname(filePath));
+}
+async function readJson(filePath, fallback) {
+    try {
+        const raw = await promises_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        await ensureDirFor(filePath);
+        await promises_1.default.writeFile(filePath, JSON.stringify(fallback, null, 2), 'utf8');
+        return fallback;
+    }
+}
+async function writeJson(filePath, payload) {
+    await ensureDirFor(filePath);
+    await promises_1.default.writeFile(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}

package/dist/shared/runtime.d.ts

@@ -0,0 +1,68 @@
+import { EventEmitter } from 'node:events';
+import { proto } from '@whiskeysockets/baileys';
+import type { DiscoveredTarget, LinkedTarget, SessionRecord } from './types';
+type DataAccess = {
+    listSessions(): Promise<SessionRecord[]>;
+    saveSessions(data: SessionRecord[]): Promise<void>;
+    listLinkedTargets(): Promise<LinkedTarget[]>;
+    saveLinkedTargets(data: LinkedTarget[]): Promise<void>;
+    listDiscoveredTargets(): Promise<DiscoveredTarget[]>;
+    saveDiscoveredTargets(data: DiscoveredTarget[]): Promise<void>;
+};
+type SendRequest = {
+    sessionId: string;
+    channelAlias?: string;
+    jid?: string;
+    type: 'text' | 'image' | 'video' | 'audio' | 'document' | 'reaction' | 'location' | 'contact' | 'poll';
+    sendAsDocument?: boolean;
+    message?: string;
+    mediaUrl?: string;
+    mimetype?: string;
+    fileName?: string;
+    caption?: string;
+    replyToMessageId?: string;
+    reactionText?: string;
+    location?: {
+        degreesLatitude: number;
+        degreesLongitude: number;
+        name?: string;
+        address?: string;
+    };
+    contact?: {
+        displayName: string;
+        vcard: string;
+    };
+    poll?: {
+        name: string;
+        values: string[];
+        selectableCount?: number;
+    };
+};
+declare class WhatsThatRegistry extends EventEmitter {
+    private sockets;
+    ensureSession(storageRoot: string, access: DataAccess, input: {
+        sessionId: string;
+        label: string;
+        phoneNumberForPairing?: string;
+    }): Promise<SessionRecord>;
+    connectSession(storageRoot: string, access: DataAccess, sessionId: string): Promise<SessionRecord>;
+    listSessions(access: DataAccess): Promise<SessionRecord[]>;
+    getSession(access: DataAccess, sessionId: string): Promise<SessionRecord | undefined>;
+    disconnectSession(access: DataAccess, sessionId: string): Promise<SessionRecord | undefined>;
+    removeSession(access: DataAccess, sessionId: string): Promise<boolean>;
+    listTargets(access: DataAccess, sessionId: string): Promise<DiscoveredTarget[]>;
+    listLinkedTargets(access: DataAccess, sessionId: string): Promise<LinkedTarget[]>;
+    connectTarget(access: DataAccess, sessionId: string, alias: string, jid: string): Promise<LinkedTarget>;
+    unlinkTarget(access: DataAccess, sessionId: string, alias: string): Promise<boolean>;
+    sendMessage(access: DataAccess, request: SendRequest): Promise<Record<string, unknown>>;
+    private buildContent;
+    private syncGroups;
+    private rememberTarget;
+    private upsertSession;
+    private upsertDiscoveredTarget;
+    private emitRuntime;
+    private required;
+}
+export declare const registry: WhatsThatRegistry;
+export declare function extractMessageText(message: proto.IMessage | null | undefined): string | undefined;
+export {};