libfb/dist/Client.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const fs_1 = tslib_1.__importDefault(require("fs"));
const path_1 = tslib_1.__importDefault(require("path"));
const FacebookDeviceId_1 = tslib_1.__importDefault(require("./FacebookDeviceId"));
const HttpApi_1 = tslib_1.__importDefault(require("./http/HttpApi"));
const MqttApi_1 = tslib_1.__importDefault(require("./mqtt/MqttApi"));
const Thread_1 = require("./types/Thread");
const User_1 = require("./types/User");
const debug_1 = tslib_1.__importDefault(require("debug"));
const Message_1 = require("./types/Message");
const parseDeltaMessage_1 = tslib_1.__importDefault(require("./types/message/parseDeltaMessage"));
const parseDeltaEvent_1 = tslib_1.__importDefault(require("./types/events/parseDeltaEvent"));
const events_1 = tslib_1.__importDefault(require("events"));
const Errors_1 = require("./types/Errors");
const debugLog = debug_1.default('fblib');
// 🥖
/**
 * Main client class
 */
class Client extends events_1.default {
    constructor(options = { selfListen: false, session: null }) {
        super();
        this.seqId = '';
        this.loggedIn = false;
        this.getThreadList = (count) => tslib_1.__awaiter(this, void 0, void 0, function* () {
            const threads = yield this.httpApi.threadListQuery(count);
            return threads.viewer.message_threads.nodes.map(Thread_1.parseThread);
        });
        this.mqttApi = new MqttApi_1.default();
        this.httpApi = new HttpApi_1.default();
        let session = options.session;
        if (!session) {
            session = { tokens: null, deviceId: null };
        }
        if (!session.deviceId) {
            const deviceId = FacebookDeviceId_1.default();
            session.deviceId = deviceId;
            this.httpApi.deviceId = deviceId.deviceId;
        }
        if (session.tokens) {
            this.httpApi.token = session.tokens.access_token;
        }
        this.session = session;
    }
    login(email, password) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            // trim to check for spaces (which are truthy)
            if (this.loggedIn)
                throw new Error('Already logged in!');
            if (!email || typeof email !== 'string' || !email.trim() ||
                !password || typeof password !== 'string' || !password.trim())
                throw new Error('Wrong username/password!');
            yield this.doLogin(email, password);
            this.loggedIn = true;
        });
    }
    doLogin(login, password) {
        return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
            if (!this.session.tokens) {
                let tokens;
                try {
                    tokens = yield this.httpApi.auth(login, password);
                }
                catch (err) {
                    return reject(err);
                }
                this.httpApi.token = tokens.access_token;
                this.session.tokens = tokens;
            }
            this.mqttApi.on('publish', (publish) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                debugLog(publish.topic);
                if (publish.topic === '/send_message_response') {
                    const response = JSON.parse(publish.data.toString('utf8'));
                    debugLog(response);
                    this.mqttApi.emit('sentMessage:' + response.msgid, response);
                }
                if (publish.topic === '/t_ms')
                    this.handleMS(publish.data.toString('utf8'));
            }));
            this.mqttApi.on('connected', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
                let viewer;
                try {
                    ({ viewer } = yield this.httpApi.querySeqId());
                }
                catch (err) {
                    return reject(err);
                }
                const seqId = viewer.message_threads.sync_sequence_id;
                this.seqId = seqId;
                resolve();
                if (!this.session.tokens.syncToken) {
                    yield this.createQueue(seqId);
                    return;
                }
                yield this.createQueue(seqId);
            }));
            try {
                yield this.mqttApi.connect(this.session.tokens, this.session.deviceId);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    getSession() {
        return this.session;
    }
    sendMessage(threadId, message) {
        return this.mqttApi.sendMessage(threadId, message);
    }
    sendAttachmentFile(threadId, attachmentPath, extension) {
        if (!fs_1.default.existsSync(attachmentPath))
            throw new Errors_1.AttachmentNotFoundError(attachmentPath);
        const stream = fs_1.default.createReadStream(attachmentPath);
        if (!extension)
            extension = path_1.default.parse(attachmentPath).ext;
        const length = fs_1.default.statSync(attachmentPath).size.toString();
        return this.httpApi.sendImage(stream, extension, this.session.tokens.uid, threadId, length);
    }
    sendAttachmentStream(threadId, extension, attachment) {
        return this.httpApi.sendImage(attachment, extension, this.session.tokens.uid, threadId);
    }
    getAttachmentURL(messageId, attachmentId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const attachment = yield this.httpApi.getAttachment(messageId, attachmentId);
            if (!attachment.redirect_uri)
                throw new Errors_1.AttachmentURLMissingError(attachment);
            return attachment.redirect_uri;
        });
    }
    getAttachmentInfo(messageId, attachmentId) {
        return this.httpApi.getAttachment(messageId, attachmentId);
    }
    getStickerURL(stickerId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const sticker = yield this.httpApi.getSticker(stickerId);
            return sticker[stickerId.toString()].thread_image.uri;
        });
    }
    getThreadInfo(threadId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const res = yield this.httpApi.threadQuery(threadId);
            const thread = res[threadId];
            if (!thread)
                return null;
            return Thread_1.parseThread(thread);
        });
    }
    getUserInfo(userId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const res = yield this.httpApi.userQuery(userId);
            const user = res[userId];
            if (!user)
                return null;
            return User_1.parseUser(user);
        });
    }
    getMessages(threadId, count) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const res = yield this.httpApi.threadMessagesQuery(threadId, count);
            const thread = res[threadId];
            if (!thread)
                return null;
            return thread.messages.nodes.map(message => Message_1.parseThreadMessage(threadId, message));
        });
    }
    createQueue(seqId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const obj = {
                delta_batch_size: 125,
                max_deltas_able_to_process: 1250,
                sync_api_version: 3,
                encoding: 'JSON',
                initial_titan_sequence_id: seqId,
                device_id: this.session.deviceId.deviceId,
                entity_fbid: this.session.tokens.uid,
                queue_params: {
                    buzz_on_deltas_enabled: 'false',
                    graphql_query_hashes: {
                        xma_query_id: '10153919431161729'
                    },
                    graphql_query_params: {
                        '10153919431161729': {
                            xma_id: '<ID>'
                        }
                    }
                }
            };
            yield this.mqttApi.sendPublish('/messenger_sync_create_queue', JSON.stringify(obj));
        });
    }
    connectQueue(seqId) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const obj = {
                delta_batch_size: 125,
                max_deltas_able_to_process: 1250,
                sync_api_version: 3,
                encoding: 'JSON',
                last_seq_id: seqId,
                sync_token: this.session.tokens.syncToken
            };
            yield this.mqttApi.sendPublish('/messenger_sync_get_diffs', JSON.stringify(obj));
        });
    }
    handleMS(ms) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            let data;
            try {
                data = JSON.parse(ms.replace('\u0000', ''));
            }
            catch (err) {
                console.error('Error while parsing the following message:');
                console.error(ms);
                return;
            }
            // Handled on queue creation
            if (data.syncToken) {
                this.session.tokens.syncToken = data.syncToken;
                yield this.connectQueue(this.seqId);
                return;
            }
            if (!data.deltas || !Array.isArray(data.deltas))
                return;
            data.deltas.forEach(delta => {
                debugLog(delta);
                this.handleMessage(delta);
            });
        });
    }
    handleMessage(event) {
        if (event.deltaNewMessage) {
            const message = parseDeltaMessage_1.default(event.deltaNewMessage);
            if (!message || message.authorId === this.session.tokens.uid && !this.options.selfListen)
                return;
            this.emit('message', message);
        }
        const deltaEvent = parseDeltaEvent_1.default(event);
        if (!deltaEvent)
            return;
        this.emit('event', deltaEvent);
        // @ts-ignore TypeScript somehow doesn't recognize that EventType is compatible with the properties defined in ClientEvents
        this.emit(deltaEvent.type, deltaEvent.event);
    }
}
exports.default = Client;
//# sourceMappingURL=Client.js.map