burdy/src/server/business-logic/server.bl.js

Open Source Headless Platform

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.importContent = exports.exportContent = void 0;
const typeorm_1 = require("typeorm");
const utility_1 = require("../../admin/helpers/utility");
const fs_extra_1 = __importDefault(require("fs-extra"));
const path_util_1 = __importDefault(require("../../scripts/util/path.util"));
const content_type_bl_1 = require("./content-type-bl");
const assets_bl_1 = require("./assets.bl");
const post_bl_1 = require("./post.bl");
const logger_1 = __importDefault(require("../../shared/features/logger"));
const rimraf_1 = __importDefault(require("rimraf"));
const console_output_util_1 = __importDefault(require("../../scripts/util/console-output.util"));
const archiver_1 = __importDefault(require("archiver"));
const tags_bl_1 = require("./tags.bl");
const async_1 = __importDefault(require("async"));
const unzipper_1 = __importDefault(require("unzipper"));
const path_1 = __importDefault(require("path"));
const defer_promise_1 = __importDefault(require("defer-promise"));
const handlers = [
    {
        type: 'tags',
        exportBinding: tags_bl_1.exportTags,
        importBinding: tags_bl_1.importTags,
        filename: 'tags.json',
    },
    {
        type: 'contentTypes',
        exportBinding: content_type_bl_1.exportContentTypes,
        importBinding: content_type_bl_1.importContentTypes,
        filename: 'contentTypes.json',
    },
    {
        type: 'assets',
        exportBinding: assets_bl_1.exportAssets,
        importBinding: assets_bl_1.importAssets,
        filename: 'assets.json',
    },
    {
        type: 'posts',
        exportBinding: post_bl_1.exportPosts,
        importBinding: post_bl_1.importPosts,
        filename: 'posts.json',
    },
];
const exportContent = ({ output, force = false, include, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
    yield (0, typeorm_1.getManager)().transaction((entityManager) => __awaiter(void 0, void 0, void 0, function* () {
        yield (() => __awaiter(void 0, void 0, void 0, function* () {
            if (!output)
                return;
            if (!output.endsWith('.zip')) {
                console_output_util_1.default.info('File not ending with .zip, appending extension to name.');
                output = `${output}.zip`;
            }
            const fileExists = yield fs_extra_1.default.pathExists(output);
            if (fileExists && !force) {
                console_output_util_1.default.error(`File ${output} already exists. Skipping...`);
                return;
            }
            if (fileExists && force) {
                console_output_util_1.default.info('Force flag provided, deleting previous entry.');
                yield new Promise((resolve) => (0, rimraf_1.default)(output, resolve));
            }
        }))();
        yield new Promise((resolve) => (0, rimraf_1.default)(path_util_1.default.burdyRoot('export'), resolve));
        yield fs_extra_1.default.ensureDir(path_util_1.default.burdyRoot('export'));
        const exporters = !include
            ? handlers
            : handlers.filter(({ type }) => include.includes(type));
        let exports = yield async_1.default.map(exporters, (exporter, next) => __awaiter(void 0, void 0, void 0, function* () {
            try {
                const { exportBinding, filename } = exporter;
                const result = yield exportBinding({ entityManager });
                next(null, { result, filename });
            }
            catch (e) {
                logger_1.default.error(`Failed to export ${exporter.type}. Skipping...`);
                next(null, null);
            }
        }));
        exports = exports.map((i) => i);
        yield Promise.all(exports.map(({ result, filename }) => {
            return fs_extra_1.default.writeJson(path_util_1.default.burdyRoot('export', filename), result);
        }));
        if (output) {
            const deferred = (0, defer_promise_1.default)();
            const outputStream = fs_extra_1.default.createWriteStream(output);
            const zipArchive = (0, archiver_1.default)('zip');
            yield zipArchive.directory(path_util_1.default.burdyRoot('export'), false);
            zipArchive.pipe(outputStream);
            outputStream.on('close', () => {
                console_output_util_1.default.info(`${zipArchive.pointer()} total bytes written to zip file.`);
                deferred.resolve();
            });
            outputStream.on('error', (e) => {
                console.log(e);
                deferred.reject(e);
            });
            yield zipArchive.finalize();
            yield deferred.promise;
        }
        console_output_util_1.default.info('Export finished.');
    }));
});
exports.exportContent = exportContent;
const importContent = ({ user, options, file, include, }) => __awaiter(void 0, void 0, void 0, function* () {
    yield (0, typeorm_1.getManager)().transaction((entityManager) => __awaiter(void 0, void 0, void 0, function* () {
        const force = (0, utility_1.isTrue)(options === null || options === void 0 ? void 0 : options.force);
        const publish = (0, utility_1.isTrue)(options === null || options === void 0 ? void 0 : options.publish);
        logger_1.default.info('Starting import');
        const entry = path_util_1.default.burdyRoot('export');
        yield (() => __awaiter(void 0, void 0, void 0, function* () {
            if (!file)
                return;
            const fileInput = file;
            const zipExists = yield fs_extra_1.default.pathExists(file);
            if (!zipExists) {
                console_output_util_1.default.info('Zip not found. Skipping archive deflation...');
                return;
            }
            yield new Promise((resolve) => (0, rimraf_1.default)(entry, resolve));
            console_output_util_1.default.info(`Exporting ${file}...`);
            yield fs_extra_1.default
                .createReadStream(fileInput)
                .pipe(unzipper_1.default.Extract({ path: entry }))
                .promise();
        }))();
        const importers = !include
            ? handlers
            : handlers.filter(({ type }) => include.includes(type));
        let imports = yield async_1.default.map(importers, (handler, next) => __awaiter(void 0, void 0, void 0, function* () {
            try {
                const { filename, importBinding } = handler;
                const result = yield fs_extra_1.default.readJson(path_1.default.join(entry, filename));
                next(null, { result, importBinding });
            }
            catch (e) {
                next(null, null);
            }
        }));
        imports = imports.filter((i) => i);
        yield async_1.default.each(imports, (importData, next) => __awaiter(void 0, void 0, void 0, function* () {
            try {
                const { result, importBinding } = importData;
                yield importBinding({
                    entityManager,
                    user,
                    data: result,
                    options: { force, publish },
                });
                next();
            }
            catch (e) {
                next(e);
            }
        }));
        logger_1.default.info('Import finished.');
        console_output_util_1.default.info('Import finished.');
    }));
});
exports.importContent = importContent;