@amplience/dc-cli/dist/common/media/media-rewriter.js

Dynamic Content CLI Tool

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MediaRewriter = void 0;
const ch_client_factory_1 = __importDefault(require("../../services/ch-client-factory"));
const media_link_injector_1 = require("../content-item/media-link-injector");
class MediaRewriter {
    constructor(config, items) {
        this.config = config;
        this.items = items;
        this.injector = new media_link_injector_1.MediaLinkInjector(items);
    }
    escapeForRegex(url) {
        return url.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    }
    connectDam() {
        this.dam = (0, ch_client_factory_1.default)(this.config);
    }
    async getEndpoint() {
        let endpoint;
        try {
            const settings = await this.dam.settings.get();
            endpoint = settings.di.endpoints.find(endpoint => {
                return endpoint.id === settings.di.defaultEndpoint;
            });
        }
        catch (e) {
            throw new Error(`Could not obtain settings from DAM. Make sure you have the required permissions: ${e.message}`);
        }
        if (endpoint == null) {
            throw new Error('Could not find the default endpoint.');
        }
        this.endpoint = endpoint.path;
        this.defaultHost = endpoint.dynamicHost;
    }
    async queryAndAdd(query, count, assets) {
        const result = await this.dam.assets.list({
            q: '(' + query + ')',
            n: count
        });
        const items = result.getItems();
        items.forEach(asset => {
            assets.set(asset.name, asset);
        });
        return items.length;
    }
    getLinkNames() {
        return new Set(this.injector.all.flatMap(links => links.links.map(link => link.link.name)));
    }
    replaceLinks(assetsByName) {
        const missingAssets = new Set();
        this.injector.all.forEach(links => {
            links.links.forEach(link => {
                const asset = assetsByName.get(link.link.name);
                if (asset != null) {
                    link.link.id = asset.id;
                    link.link.defaultHost = this.defaultHost;
                    link.link.endpoint = this.endpoint;
                }
                else {
                    missingAssets.add(link.link.name);
                }
            });
        });
        return missingAssets;
    }
    async rewrite() {
        this.connectDam();
        await this.getEndpoint();
        const allNames = this.getLinkNames();
        if (allNames.size == 0) {
            return new Set();
        }
        const maxQueryLength = 3000;
        const assetsByName = new Map();
        const names = Array.from(allNames);
        if (names.length > 0) {
            let requestBuilder = 'name:/';
            let first = true;
            let requestCount = 0;
            for (const name of names) {
                const additionalRequest = `${this.escapeForRegex(name)}`;
                const lengthSoFar = requestBuilder.length;
                if (first) {
                    requestBuilder += additionalRequest;
                    requestCount++;
                    first = false;
                }
                else {
                    if (lengthSoFar + 1 + additionalRequest.length < maxQueryLength) {
                        requestBuilder += '|' + additionalRequest;
                        requestCount++;
                    }
                    else {
                        await this.queryAndAdd(requestBuilder + '/', requestCount, assetsByName);
                        requestBuilder = 'name:/' + additionalRequest;
                    }
                }
            }
            if (requestBuilder.length > 0) {
                await this.queryAndAdd(requestBuilder + '/', requestCount, assetsByName);
            }
        }
        return this.replaceLinks(assetsByName);
    }
}
exports.MediaRewriter = MediaRewriter;