@fabrix/spool-broadcast/dist/BroadcastChannel.js

Spool: broadcast for Fabrix to implement CQRS and Event Sourcing

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const regexdot_1 = require("@fabrix/regexdot");
const BroadcastEntity_1 = require("./BroadcastEntity");
class BroadcastSubscriber {
    constructor(app, { channel, event, options, broker, broadcaster }) {
        this.app = app;
        this.app = app;
        this.channel = channel;
        this.event = event;
        this.options = options;
        this.broker = broker;
        this.broadcaster = broadcaster;
        this.isAcknowledged = false;
    }
    get name() {
        return this.constructor.name;
    }
    run() {
        return __awaiter(this, void 0, void 0, function* () {
            return Promise.resolve(this);
        });
    }
    publish() {
        return __awaiter(this, void 0, void 0, function* () {
            const json = this.event.toJSON();
            const rooms = this.channel.patterns(this.broker.pattern_raw, this.event);
            rooms.forEach(v => {
                this.app.sockets.room(v).clients((ids = []) => {
                    this.app.log.debug(`Publishing ${v} to ${(ids || []).length} subscribers`);
                });
                this.app.sockets.room(v).write(json);
            });
            return Promise.resolve(this);
        });
    }
}
exports.BroadcastSubscriber = BroadcastSubscriber;
class BroadcastChannel extends BroadcastEntity_1.BroadcastEntity {
    constructor(app) {
        super(app, 'channels');
        this._subscribers = new Map();
        this.permissions = new Map();
    }
    get channel() {
        return this._channel;
    }
    get subscribers() {
        return this._subscribers;
    }
    hasSubscriber(name) {
        return this._subscribers.has(name);
    }
    initialize() { }
    patterns(pattern, event) {
        const queryOr = new Set([`${pattern}`]);
        let built = pattern;
        const { keys } = regexdot_1.regexdot(pattern);
        if (keys !== false
            && typeof keys !== 'boolean'
            && lodash_1.isArray(keys)) {
            const compare = !lodash_1.isArray(event.data) ? event.data : event.data[0];
            keys.forEach(k => {
                if (k && compare && compare[k]) {
                    built = built.replace(`:${k}`, `${compare[k]}`);
                    queryOr.add(built);
                    const singleParam = (`${pattern}`).replace(`:${k}`, `${compare[k]}`);
                    queryOr.add(singleParam);
                }
            });
        }
        return Array.from(queryOr).map(k => {
            return `${this.name}.${k}`;
        });
    }
    subscribed(spark, room) {
        return;
    }
    unsubscribed(spark, room) {
        return;
    }
    disconnect(spark, data) {
        return;
    }
    destroy() {
    }
}
exports.BroadcastChannel = BroadcastChannel;
//# sourceMappingURL=BroadcastChannel.js.map