nodejs-insta-private-api-mqt 1.3.83 → 1.3.84

package/dist-ts/dist/realtime/mixins/realtime-sub.mixin.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * RealtimeSubMixin - ENHANCED VERSION
+ *
+ * This file has been modified to include all MQTT features from instagram_mqtt library.
+ *
+ * CHANGES MADE (from instagram_mqtt compatibility):
+ * 1. Added import for subscriptions (QueryIDs) - was MISSING
+ * 2. Added client.mqtt.listen() approach for REALTIME_SUB topic - was MISSING
+ * 3. Added 'realtimeSub' event emission - was MISSING (only had 'subscription')
+ * 4. Added 'direct' topic processing - was MISSING
+ * 5. Added emitDirectEvent() method - was MISSING
+ * 6. Added QueryIDs-based event emission (directTyping, appPresence, etc.) - was MISSING
+ *
+ * PRESERVED:
+ * - Original 'subscription' event emission (for backwards compatibility)
+ * - Original on('message') approach with topicMap (extended, not replaced)
+ * - All existing retry logic and error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeSubMixin = void 0;
+const mixin_1 = require("./mixin");
+const constants_1 = require("../../constants");
+const shared_1 = require("../../shared");
+// ADDED: Import subscriptions for QueryIDs (was MISSING in nodejs-insta-private-api-mqt)
+const subscriptions_1 = require("../subscriptions");
+const mqtts_1 = require("mqtts");
+class RealtimeSubMixin extends mixin_1.Mixin {
+    apply(client) {
+        (0, mixin_1.hook)(client, 'connect', {
+            post: async () => {
+                // Wait for MQTT client to be ready (PRESERVED from original)
+                let retries = 0;
+                while (!client.mqtt && retries < 50) {
+                    await new Promise(r => setTimeout(r, 100));
+                    retries++;
+                }
+                if (!client.mqtt) {
+                    throw new mqtts_1.IllegalStateError('No mqtt client created after retries');
+                }
+                // ADDED: Use client.mqtt.listen() for REALTIME_SUB topic (from instagram_mqtt)
+                // This is the approach used by instagram_mqtt for handling realtime subscriptions
+                if (client.mqtt.listen) {
+                    client.mqtt.listen({
+                        topic: constants_1.Topics.REALTIME_SUB.id,
+                        transformer: async ({ payload }) => {
+                            try {
+                                return constants_1.Topics.REALTIME_SUB.parser.parseMessage(constants_1.Topics.REALTIME_SUB, await (0, shared_1.tryUnzipAsync)(payload));
+                            }
+                            catch (err) {
+                                // If transformer fails, return null so handler can skip
+                                console.warn('[RealtimeSubMixin] transformer parse failed:', (err === null || err === void 0 ? void 0 : err.message) || err);
+                                return null;
+                            }
+                        },
+                    }, data => {
+                        if (data) {
+                            // ADDED: Call the instagram_mqtt compatible handler
+                            this.handleRealtimeSubFromListen(client, data);
+                        }
+                    });
+                }
+                // PRESERVED: Original on('message') approach with topicMap (for backwards compatibility)
+                client.mqtt.on('message', async (msg) => {
+                    var _a;
+                    const topicMap = (_a = client.mqtt) === null || _a === void 0 ? void 0 : _a.topicMap;
+                    const topic = topicMap === null || topicMap === void 0 ? void 0 : topicMap.get(msg.topic);
+                    if (topic && topic.parser && !topic.noParse) {
+                        try {
+                            const unzipped = await (0, shared_1.tryUnzipAsync)(msg.payload);
+                            const parsedMessages = topic.parser.parseMessage(topic, unzipped);
+                            if (Array.isArray(parsedMessages)) {
+                                parsedMessages.forEach(m => {
+                                    this.handleRealtimeSub(client, topic, m.data);
+                                });
+                            }
+                            else {
+                                this.handleRealtimeSub(client, topic, parsedMessages.data);
+                            }
+                        }
+                        catch (e) {
+                            console.error(`RealtimeSub parse error on ${topic.path}:`, e.message);
+                        }
+                    }
+                });
+            },
+        });
+    }
+    /**
+     * ADDED: Handler compatible with instagram_mqtt's listen() approach
+     * This method handles data from client.mqtt.listen() and emits instagram_mqtt compatible events
+     *
+     * @param {Object} client - The realtime client instance
+     * @param {Object} param1 - The parsed data object containing { data, topic }
+     */
+    handleRealtimeSubFromListen(client, { data, topic: messageTopic }) {
+        const { message } = data;
+        // ADDED: Emit 'realtimeSub' event (was MISSING - this is what instagram_mqtt does)
+        client.emit('realtimeSub', { data, topic: messageTopic });
+        // ADDED: Process message based on type (was MISSING)
+        if (typeof message === 'string') {
+            // If message is a string, parse it and emit direct event
+            this.emitDirectEvent(client, JSON.parse(message));
+        }
+        else if (message) {
+            const { topic, payload, json } = message;
+            switch (topic) {
+                case 'direct': {
+                    // ADDED: Handle 'direct' topic specifically (was MISSING)
+                    this.emitDirectEvent(client, json);
+                    break;
+                }
+                default: {
+                    // ADDED: Emit QueryID-based events (was MISSING)
+                    // This emits events like 'directTyping', 'appPresence', 'directStatus', etc.
+                    const entries = Object.entries(subscriptions_1.QueryIDs);
+                    const query = entries.find(e => e[1] === topic);
+                    if (query) {
+                        client.emit(query[0], json || payload);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * ADDED: Method to emit direct events (was MISSING from nodejs-insta-private-api-mqt)
+     * This method parses string values in parsed.data and emits 'direct' event for each
+     *
+     * @param {Object} client - The realtime client instance
+     * @param {Object} parsed - The parsed message object containing data array
+     */
+    emitDirectEvent(client, parsed) {
+        if (!parsed || !parsed.data || !Array.isArray(parsed.data)) {
+            return;
+        }
+        parsed.data = parsed.data.map((e) => {
+            if (typeof e.value === 'string') {
+                try {
+                    e.value = JSON.parse(e.value);
+                }
+                catch (parseErr) {
+                    // If parsing fails, keep original value
+                    console.warn('[RealtimeSubMixin] emitDirectEvent JSON parse failed:', parseErr === null || parseErr === void 0 ? void 0 : parseErr.message);
+                }
+            }
+            return e;
+        });
+        // Emit 'direct' event for each data item
+        parsed.data.forEach((data) => client.emit('direct', data));
+    }
+    /**
+     * PRESERVED: Original handler for on('message') approach (for backwards compatibility)
+     * This emits the 'subscription' event that existing code may depend on
+     *
+     * @param {Object} client - The realtime client instance
+     * @param {Object} topic - The topic object from topicMap
+     * @param {Object} data - The parsed message data
+     */
+    handleRealtimeSub(client, topic, data) {
+        // PRESERVED: Emit 'subscription' event (original behavior)
+        client.emit('subscription', {
+            query: topic.path,
+            data: data,
+            topic: topic,
+        });
+    }
+    get name() {
+        return 'Realtime Sub';
+    }
+}
+exports.RealtimeSubMixin = RealtimeSubMixin;

package/dist-ts/dist/realtime/parsers/graphql-parser.js

@@ -0,0 +1,43 @@
+/**
+ * GraphQL Parser
+ *
+ * Parses GraphQL messages from Instagram's realtime system.
+ * These messages contain GraphQL queries, mutations, and subscriptions.
+ */
+class GraphqlParser {
+    /**
+     * Parse a GraphQL message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed GraphQL data
+     */
+    parse(data) {
+        try {
+            const message = Buffer.isBuffer(data) ? data.toString() : data;
+            // Try to parse as JSON first
+            try {
+                const parsed = JSON.parse(message);
+                return {
+                    type: 'graphql',
+                    data: parsed,
+                    raw: message
+                };
+            }
+            catch (jsonError) {
+                // If not JSON, treat as GraphQL query string
+                return {
+                    type: 'graphql',
+                    data: { query: message },
+                    raw: message
+                };
+            }
+        }
+        catch (error) {
+            return {
+                type: 'graphql',
+                data: { error: error.message },
+                raw: data.toString()
+            };
+        }
+    }
+}
+module.exports = GraphqlParser;

package/dist-ts/dist/realtime/parsers/graphql.parser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlParser = void 0;
+const thrift_1 = require("../../thrift");
+const shared_1 = require("../../shared");
+class GraphqlParser {
+    parseMessage(topic, payload) {
+        var _a;
+        const message = (0, shared_1.isJson)(payload)
+            ? payload.toString()
+            : (_a = (0, thrift_1.thriftReadToObject)(payload, GraphqlParser.descriptors)) !== null && _a !== void 0 ? _a : '';
+        if (message.payload) {
+            message.json = JSON.parse(message.payload);
+        }
+        return { topic, data: { message } };
+    }
+}
+exports.GraphqlParser = GraphqlParser;
+GraphqlParser.descriptors = [
+    thrift_1.ThriftDescriptors.binary('topic', 1),
+    thrift_1.ThriftDescriptors.binary('payload', 2),
+];

package/dist-ts/dist/realtime/parsers/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function (m, exports) {
+    for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+            __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./graphql.parser"), exports);
+__exportStar(require("./iris.parser"), exports);
+__exportStar(require("./json.parser"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./region-hint.parser"), exports);
+__exportStar(require("./skywalker.parser"), exports);

package/dist-ts/dist/realtime/parsers/iris-parser.js

@@ -0,0 +1,43 @@
+/**
+ * Iris Parser
+ *
+ * Parses Iris messages from Instagram's realtime system.
+ * Iris is Instagram's internal messaging system for real-time updates.
+ */
+class IrisParser {
+    /**
+     * Parse an Iris message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed Iris data
+     */
+    parse(data) {
+        try {
+            const message = Buffer.isBuffer(data) ? data.toString() : data;
+            // Try to parse as JSON first
+            try {
+                const parsed = JSON.parse(message);
+                return {
+                    type: 'iris',
+                    data: parsed,
+                    raw: message
+                };
+            }
+            catch (jsonError) {
+                // If not JSON, treat as plain text
+                return {
+                    type: 'iris',
+                    data: { message: message },
+                    raw: message
+                };
+            }
+        }
+        catch (error) {
+            return {
+                type: 'iris',
+                data: { error: error.message },
+                raw: data.toString()
+            };
+        }
+    }
+}
+module.exports = IrisParser;

package/dist-ts/dist/realtime/parsers/iris.parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IrisParser = void 0;
+class IrisParser {
+    parseMessage(topic, payload) {
+        return JSON.parse(payload.toString('utf8')).map((x) => ({ topic, data: x }));
+    }
+}
+exports.IrisParser = IrisParser;

package/dist-ts/dist/realtime/parsers/json-parser.js

@@ -0,0 +1,43 @@
+/**
+ * JSON Parser
+ *
+ * Parses JSON messages from Instagram's realtime system.
+ * This is a general-purpose parser for JSON-formatted messages.
+ */
+class JsonParser {
+    /**
+     * Parse a JSON message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed JSON data
+     */
+    parse(data) {
+        try {
+            const message = Buffer.isBuffer(data) ? data.toString() : data;
+            // Try to parse as JSON
+            try {
+                const parsed = JSON.parse(message);
+                return {
+                    type: 'json',
+                    data: parsed,
+                    raw: message
+                };
+            }
+            catch (jsonError) {
+                // If not valid JSON, return as plain text
+                return {
+                    type: 'json',
+                    data: { text: message },
+                    raw: message
+                };
+            }
+        }
+        catch (error) {
+            return {
+                type: 'json',
+                data: { error: error.message },
+                raw: data.toString()
+            };
+        }
+    }
+}
+module.exports = JsonParser;

package/dist-ts/dist/realtime/parsers/json.parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonParser = void 0;
+class JsonParser {
+    parseMessage(topic, payload) {
+        return { topic, data: payload.length > 0 ? JSON.parse(payload.toString()) : {} };
+    }
+}
+exports.JsonParser = JsonParser;

package/dist-ts/dist/realtime/parsers/parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-ts/dist/realtime/parsers/region-hint-parser.js

@@ -0,0 +1,43 @@
+/**
+ * Region Hint Parser
+ *
+ * Parses region hint messages from Instagram's realtime system.
+ * These messages contain information about the user's region/location.
+ */
+class RegionHintParser {
+    /**
+     * Parse a region hint message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed region hint data
+     */
+    parse(data) {
+        try {
+            const message = Buffer.isBuffer(data) ? data.toString() : data;
+            // Try to parse as JSON first
+            try {
+                const parsed = JSON.parse(message);
+                return {
+                    type: 'region_hint',
+                    data: parsed,
+                    raw: message
+                };
+            }
+            catch (jsonError) {
+                // If not JSON, treat as plain text
+                return {
+                    type: 'region_hint',
+                    data: { hint: message },
+                    raw: message
+                };
+            }
+        }
+        catch (error) {
+            return {
+                type: 'region_hint',
+                data: { error: error.message },
+                raw: data.toString()
+            };
+        }
+    }
+}
+module.exports = RegionHintParser;

package/dist-ts/dist/realtime/parsers/region-hint.parser.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionHintParser = void 0;
+const thrift_1 = require("../../thrift");
+class RegionHintParser {
+    constructor() {
+        this.parseMessage = (topic, payload) => ({
+            topic,
+            data: (0, thrift_1.thriftReadToObject)(payload, RegionHintParser.descriptors),
+        });
+    }
+}
+exports.RegionHintParser = RegionHintParser;
+RegionHintParser.descriptors = [thrift_1.ThriftDescriptors.binary('hint', 1)];

package/dist-ts/dist/realtime/parsers/skywalker-parser.js

@@ -0,0 +1,43 @@
+/**
+ * Skywalker Parser
+ *
+ * Parses Skywalker messages from Instagram's realtime system.
+ * Skywalker is Instagram's pub/sub system for real-time updates.
+ */
+class SkywalkerParser {
+    /**
+     * Parse a Skywalker message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed Skywalker data
+     */
+    parse(data) {
+        try {
+            const message = Buffer.isBuffer(data) ? data.toString() : data;
+            // Try to parse as JSON first
+            try {
+                const parsed = JSON.parse(message);
+                return {
+                    type: 'skywalker',
+                    data: parsed,
+                    raw: message
+                };
+            }
+            catch (jsonError) {
+                // If not JSON, treat as plain text
+                return {
+                    type: 'skywalker',
+                    data: { message: message },
+                    raw: message
+                };
+            }
+        }
+        catch (error) {
+            return {
+                type: 'skywalker',
+                data: { error: error.message },
+                raw: data.toString()
+            };
+        }
+    }
+}
+module.exports = SkywalkerParser;

package/dist-ts/dist/realtime/parsers/skywalker.parser.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkywalkerParser = void 0;
+const thrift_1 = require("../../thrift");
+class SkywalkerParser {
+    parseMessage(topic, payload) {
+        return {
+            topic,
+            data: (0, thrift_1.thriftReadToObject)(payload, SkywalkerParser.descriptors),
+        };
+    }
+}
+exports.SkywalkerParser = SkywalkerParser;
+SkywalkerParser.descriptors = [thrift_1.ThriftDescriptors.int32('topic', 1), thrift_1.ThriftDescriptors.binary('payload', 2)];

package/dist-ts/dist/realtime/parsers-advanced.js

@@ -0,0 +1,138 @@
+const debug = require('debug')('ig:parsers');
+const ProtoParser = require('./proto-parser');
+const protoParser = new ProtoParser();
+/**
+ * Advanced Topic-Specific Parsers
+ */
+// Parse Iris (Direct Messages)
+function parseIris(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    if (result.success && result.messages) {
+        return {
+            type: 'iris',
+            messages: result.messages.filter(m => m.type === 'message' || !m.type),
+            threads: result.messages.filter(m => m.type === 'thread').map(m => m.thread),
+            typing: result.messages.filter(m => m.type === 'typing').map(m => m.typing)
+        };
+    }
+    return { type: 'iris', error: result.error, raw: result.raw };
+}
+// Parse GraphQL (Presence, Typing)
+function parseGraphQL(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    if (result.success) {
+        return {
+            type: 'graphql',
+            data: result.decoded,
+            messages: result.messages
+        };
+    }
+    return { type: 'graphql', error: result.error };
+}
+// Parse Delta (Sync updates)
+function parseDelta(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    if (result.success && result.decoded) {
+        return {
+            type: 'delta',
+            seqId: result.decoded.seq_id,
+            action: result.decoded.action,
+            items: result.messages,
+            metadata: result.decoded.metadata
+        };
+    }
+    return { type: 'delta', error: result.error };
+}
+// Parse Presence
+function parsePresence(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    if (result.success) {
+        return {
+            type: 'presence',
+            items: result.messages.map(m => {
+                var _a;
+                return ({
+                    userId: m.id,
+                    status: ((_a = m.typing) === null || _a === void 0 ? void 0 : _a.state) || 'unknown',
+                    timestamp: m.timestamp
+                });
+            })
+        };
+    }
+    return { type: 'presence', error: result.error };
+}
+// Parse Feed
+function parseFeed(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    return {
+        type: 'feed',
+        decoded: result.decoded,
+        items: result.messages,
+        error: result.error
+    };
+}
+// Parse Live
+function parseLive(topicId, payload) {
+    const result = protoParser.decode(topicId, payload);
+    return {
+        type: 'live',
+        decoded: result.decoded,
+        items: result.messages,
+        error: result.error
+    };
+}
+// Parse Region Hint
+function parseRegionHint(topicId, payload) {
+    try {
+        const text = payload.toString('utf-8');
+        const hint = JSON.parse(text);
+        return {
+            type: 'region-hint',
+            region: hint.region,
+            endpoint: hint.endpoint,
+            data: hint
+        };
+    }
+    catch (e) {
+        return {
+            type: 'region-hint',
+            raw: payload.toString('utf-8', 0, 200),
+            error: e.message
+        };
+    }
+}
+// Unified router
+const PARSERS = {
+    iris: parseIris,
+    graphql: parseGraphQL,
+    delta: parseDelta,
+    presence: parsePresence,
+    feed: parseFeed,
+    live: parseLive,
+    'region-hint': parseRegionHint
+};
+function parseByType(topicType, topicId, payload) {
+    const parser = PARSERS[topicType];
+    if (!parser) {
+        debug(`⚠️  Unknown topic type: ${topicType}`);
+        return { type: topicType, error: 'Unknown parser', raw: payload.toString('utf-8', 0, 200) };
+    }
+    try {
+        return parser(topicId, payload);
+    }
+    catch (e) {
+        debug(`Parse error for ${topicType}:`, e.message);
+        return { type: topicType, error: e.message };
+    }
+}
+module.exports = {
+    parseIris,
+    parseGraphQL,
+    parseDelta,
+    parsePresence,
+    parseFeed,
+    parseLive,
+    parseRegionHint,
+    parseByType,
+    ProtoParser
+};