@strapi/data-transfer/dist/directory/providers/destination/index.js

Data transfer capabilities for Strapi

'use strict';

var path = require('path');
var fs$1 = require('fs');
var stream = require('stream');
var fs = require('fs-extra');
var Stringer = require('stream-json/jsonl/Stringer');
var streamChain = require('stream-chain');
var utils = require('./utils.js');
var providers = require('../../../errors/providers.js');
var utils$1 = require('../../../file/providers/destination/utils.js');

function _class_private_field_loose_base(receiver, privateKey) {
    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
        throw new TypeError("attempted to use private field on non-instance");
    }
    return receiver;
}
var id = 0;
function _class_private_field_loose_key(name) {
    return "__private_" + id++ + "_" + name;
}
const createLocalDirectoryDestinationProvider = (options)=>{
    return new LocalDirectoryDestinationProvider(options);
};
var _providersMetadata = /*#__PURE__*/ _class_private_field_loose_key("_providersMetadata"), _rootResolved = /*#__PURE__*/ _class_private_field_loose_key("_rootResolved"), _diagnostics = /*#__PURE__*/ _class_private_field_loose_key("_diagnostics"), _reportInfo = /*#__PURE__*/ _class_private_field_loose_key("_reportInfo"), _writeMetadata = /*#__PURE__*/ _class_private_field_loose_key("_writeMetadata");
class LocalDirectoryDestinationProvider {
    setMetadata(target, metadata) {
        _class_private_field_loose_base(this, _providersMetadata)[_providersMetadata][target] = metadata;
        return this;
    }
    async bootstrap(diagnostics) {
        _class_private_field_loose_base(this, _diagnostics)[_diagnostics] = diagnostics;
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('preparing directory export');
        await fs.mkdir(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], {
            recursive: true
        });
        this.results.file = {
            path: _class_private_field_loose_base(this, _rootResolved)[_rootResolved]
        };
    }
    async close() {
        await _class_private_field_loose_base(this, _writeMetadata)[_writeMetadata]();
    }
    async rollback() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('rolling back');
        await fs.rm(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], {
            recursive: true,
            force: true
        });
    }
    getMetadata() {
        return null;
    }
    createSchemasWriteStream() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('creating schemas write stream');
        const filePathFactory = utils$1.createFilePathFactory('schemas');
        const entryStream = utils.createDirectoryJsonlWriter(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], filePathFactory, this.options.file.maxSizeJsonl);
        return streamChain.chain([
            Stringer.stringer(),
            entryStream
        ]);
    }
    createEntitiesWriteStream() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('creating entities write stream');
        const filePathFactory = utils$1.createFilePathFactory('entities');
        const entryStream = utils.createDirectoryJsonlWriter(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], filePathFactory, this.options.file.maxSizeJsonl);
        return streamChain.chain([
            Stringer.stringer(),
            entryStream
        ]);
    }
    createLinksWriteStream() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('creating links write stream');
        const filePathFactory = utils$1.createFilePathFactory('links');
        const entryStream = utils.createDirectoryJsonlWriter(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], filePathFactory, this.options.file.maxSizeJsonl);
        return streamChain.chain([
            Stringer.stringer(),
            entryStream
        ]);
    }
    createConfigurationWriteStream() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('creating configuration write stream');
        const filePathFactory = utils$1.createFilePathFactory('configuration');
        const entryStream = utils.createDirectoryJsonlWriter(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], filePathFactory, this.options.file.maxSizeJsonl);
        return streamChain.chain([
            Stringer.stringer(),
            entryStream
        ]);
    }
    createAssetsWriteStream() {
        _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('creating assets write stream');
        const root = _class_private_field_loose_base(this, _rootResolved)[_rootResolved];
        return new stream.Writable({
            objectMode: true,
            write (data, _encoding, callback) {
                const { filename } = data;
                const entryPath = path.join(root, 'assets', 'uploads', filename);
                const entryMetadataPath = path.join(root, 'assets', 'metadata', `${filename}.json`);
                const assetWriteError = (cause)=>new providers.ProviderTransferError(`Failed to write asset ${filename}`, {
                        details: {
                            error: cause instanceof Error ? cause : new Error(String(cause))
                        }
                    });
                let fileStream;
                try {
                    fs.mkdirSync(path.dirname(entryPath), {
                        recursive: true
                    });
                    fs.mkdirSync(path.dirname(entryMetadataPath), {
                        recursive: true
                    });
                    fs.writeFileSync(entryMetadataPath, JSON.stringify(data.metadata), 'utf8');
                    fileStream = fs$1.createWriteStream(entryPath);
                } catch (error) {
                    callback(assetWriteError(error));
                    return;
                }
                stream.pipeline(data.stream, fileStream, (err)=>{
                    if (err) {
                        callback(assetWriteError(err));
                        return;
                    }
                    callback(null);
                });
            }
        });
    }
    constructor(options){
        Object.defineProperty(this, _reportInfo, {
            value: reportInfo
        });
        Object.defineProperty(this, _writeMetadata, {
            value: writeMetadata
        });
        Object.defineProperty(this, _providersMetadata, {
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, _rootResolved, {
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, _diagnostics, {
            writable: true,
            value: void 0
        });
        this.name = 'destination::local-directory';
        this.type = 'destination';
        this.results = {};
        _class_private_field_loose_base(this, _providersMetadata)[_providersMetadata] = {};
        this.options = options;
        _class_private_field_loose_base(this, _rootResolved)[_rootResolved] = path.resolve(options.directory.path);
    }
}
function reportInfo(message) {
    _class_private_field_loose_base(this, _diagnostics)[_diagnostics]?.report({
        details: {
            createdAt: new Date(),
            message,
            origin: 'directory-destination-provider'
        },
        kind: 'info'
    });
}
async function writeMetadata() {
    _class_private_field_loose_base(this, _reportInfo)[_reportInfo]('writing metadata');
    const metadata = _class_private_field_loose_base(this, _providersMetadata)[_providersMetadata].source;
    if (metadata) {
        const target = path.join(_class_private_field_loose_base(this, _rootResolved)[_rootResolved], 'metadata.json');
        await fs.mkdir(path.dirname(target), {
            recursive: true
        });
        await fs.writeFile(target, JSON.stringify(metadata, null, 2), 'utf8');
    }
}

exports.createLocalDirectoryDestinationProvider = createLocalDirectoryDestinationProvider;
//# sourceMappingURL=index.js.map