@neoskop/paperboy-source-magnolia/dist/magnolia-source.module.js

"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 amqplib_1 = require("amqplib");
const dam_util_1 = require("./dam.util");
const pages_util_1 = require("./pages.util");
const retry = require("retry");
const AsyncLock = require("async-lock");
class MagnoliaSource {
    constructor(options, callback) {
        this.generationLock = new AsyncLock({ maxPending: 1 });
        this.options = options;
        this.callback = callback;
    }
    generate() {
        return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
            const sitemap = yield pages_util_1.fetchSitemap(this.options);
            const website = yield pages_util_1.fetchPages(this.options);
            const pages = sitemap
                .map(path => website && website.find((page) => page["@path"] === path))
                .filter(page => typeof page !== "undefined");
            const workspaces = {};
            if (this.options.magnolia.workspaces) {
                for (const workspace of this.options.magnolia.workspaces) {
                    workspaces[workspace] = yield pages_util_1.fetchWorkspace(workspace, this.options);
                }
            }
            // get dam jcr ids
            const nodes = pages.concat(Object.keys(workspaces).reduce((prev, current) => prev.concat(workspaces[current]), []));
            const match = JSON.stringify(nodes).match(/jcr:([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/g);
            let damUuids = match ? match.map(id => id.substring(4)) : [];
            damUuids = damUuids.filter((id, pos) => {
                return damUuids.indexOf(id) === pos;
            });
            const damAssets = yield dam_util_1.fetchDamAssets(damUuids, this.options);
            const pagesObj = pages.map((page) => pages_util_1.sanitizeJson(page, damAssets, pages, this.options, workspaces));
            yield pages_util_1.writePagesFile(pagesObj, this.options);
            if (this.options.magnolia.workspaces) {
                for (const workspace of Object.keys(workspaces)) {
                    const workspaceData = workspaces[workspace];
                    if (workspaceData) {
                        const sanitized = [];
                        for (const item of workspaceData) {
                            sanitized.push(pages_util_1.sanitizeJson(item, damAssets, workspaceData, this.options, workspaces));
                        }
                        yield pages_util_1.writeWorkspaceFile(workspace, sanitized, this.options);
                    }
                }
            }
            resolve();
        }));
    }
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            const operation = retry.operation({ forever: true });
            let conn;
            operation.attempt(() => __awaiter(this, void 0, void 0, function* () {
                try {
                    conn = yield amqplib_1.connect(this.options.queue.uri);
                    ["error", "close"].forEach($event => conn.on($event, this.retryConnection.bind(this, this.options.queue)));
                    const channel = yield conn.createChannel();
                    yield channel.assertExchange(this.options.queue.exchangeName || "paperboy", "fanout", {
                        durable: false
                    });
                    const qok = yield channel.assertQueue(null, {
                        autoDelete: true
                    });
                    channel.bindQueue(qok.queue, this.options.queue.exchangeName || "paperboy", "");
                    channel.consume(qok.queue, this.consumeMessage.bind(this), {
                        noAck: true
                    });
                }
                catch (error) {
                    if (operation.retry(error)) {
                        console.error(`Could not establish connection to queue: ${error}`);
                        return;
                    }
                }
            }), {
                timeout: 10 * 1000,
                callback: () => {
                    if (conn) {
                        conn.close();
                    }
                }
            });
        });
    }
    retryConnection() {
        console.info("Connection to queue dropped...");
        this.start();
    }
    consumeMessage(message) {
        console.info("[x] from Magnolia: %s -> '%s'", message.fields.routingKey, message.content.toString());
        this.generationLock.acquire("generationLock", (done) => __awaiter(this, void 0, void 0, function* () {
            try {
                yield this.generate();
                yield this.callback();
            }
            catch (err) {
                console.error("Generation failed.", err);
            }
            done();
        }), err => {
            if (err) {
                console.info("Already another pending message. Message discarded!");
            }
        });
    }
}
exports.MagnoliaSource = MagnoliaSource;
//# sourceMappingURL=magnolia-source.module.js.map