@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 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.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));
            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));
                        }
                        yield pages_util_1.writeWorkspaceFile(workspace, sanitized, this.options);
                    }
                }
            }
            resolve();
        }));
    }
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            amqplib_1.connect(this.options.queue.uri)
                .then(conn => {
                conn.on('error', this.retryConnection.bind(this, this.options.queue));
                return conn.createChannel();
            })
                .then(channel => {
                channel
                    .assertExchange(this.options.queue.exchangeName || 'paperboy', 'fanout', {
                    durable: false
                })
                    .then(() => {
                    return channel.assertQueue(null, {
                        autoDelete: true
                    });
                })
                    .then(qok => {
                    channel.bindQueue(qok.queue, this.options.queue.exchangeName || 'paperboy', '');
                    channel.consume(qok.queue, this.consumeMessage.bind(this), {
                        noAck: true
                    });
                });
            })
                .catch(() => {
                this.retryConnection();
            });
        });
    }
    retryConnection() {
        console.info('Connection to queue failed, will retry in 10s...');
        setTimeout(() => {
            this.start();
        }, 10000);
    }
    consumeMessage(message) {
        console.info("[x] from Magnolia: %s -> '%s'", message.fields.routingKey, message.content.toString());
        this.generationLock.acquire('generationLock', (done) => {
            this.generate().then(() => {
                this.callback().then(() => done());
            }).catch((err) => {
                console.error('Generation failed.', err);
                done();
            });
        }, (err, ret) => {
            if (err) {
                console.info('Already another pending message. Message discarded!');
            }
        });
    }
}
exports.MagnoliaSource = MagnoliaSource;
//# sourceMappingURL=magnolia-source.module.js.map