@strapi/strapi/dist/src/cli/commands/import/action.js

An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite

'use strict';

var fp = require('lodash/fp');
var chalk = require('chalk');
var fse = require('fs-extra');
var dataTransfer = require('@strapi/data-transfer');
var dataTransfer$1 = require('../../utils/data-transfer.js');
var helpers = require('../../utils/helpers.js');

const { providers: { createLocalFileSourceProvider } } = dataTransfer.file;
const { providers: { createLocalStrapiDestinationProvider, DEFAULT_CONFLICT_STRATEGY } } = dataTransfer.strapi;
const { createTransferEngine, DEFAULT_VERSION_STRATEGY, DEFAULT_SCHEMA_STRATEGY } = dataTransfer.engine;
/**
 * Import command.
 *
 * It transfers data from a Strapi backup file or unpacked export directory to a local Strapi instance
 */ var action = (async (opts)=>{
    // validate inputs from Commander
    if (!fp.isObject(opts)) {
        helpers.exitWith(1, 'Could not parse arguments');
    }
    const backupPath = opts.file ?? '';
    const source = (await fse.stat(backupPath)).isDirectory() ? dataTransfer.directory.providers.createLocalDirectorySourceProvider({
        directory: {
            path: backupPath
        }
    }) : createLocalFileSourceProvider(getLocalFileSourceOptions(opts));
    /**
   * To local Strapi instance
   */ const strapiInstance = await dataTransfer$1.createStrapiInstance();
    /**
   * Configure and run the transfer engine
   */ const engineOptions = {
        versionStrategy: DEFAULT_VERSION_STRATEGY,
        schemaStrategy: DEFAULT_SCHEMA_STRATEGY,
        exclude: opts.exclude,
        only: opts.only,
        throttle: opts.throttle,
        transforms: {
            links: [
                {
                    filter (link) {
                        return !dataTransfer$1.isIgnoredContentType(link.left.type) && !dataTransfer$1.isIgnoredContentType(link.right.type);
                    }
                }
            ],
            entities: [
                {
                    filter: (entity)=>!dataTransfer$1.isIgnoredContentType(entity.type)
                }
            ]
        }
    };
    const destinationOptions = {
        async getStrapi () {
            return strapiInstance;
        },
        autoDestroy: false,
        strategy: opts.conflictStrategy || DEFAULT_CONFLICT_STRATEGY,
        restore: dataTransfer$1.parseRestoreFromOptions(engineOptions, strapiInstance)
    };
    const destination = createLocalStrapiDestinationProvider(destinationOptions);
    destination.onWarning = (message)=>console.warn(`\n${chalk.yellow('warn')}: ${message}`);
    const engine = createTransferEngine(source, destination, engineOptions);
    engine.diagnostics.onDiagnostic(dataTransfer$1.formatDiagnostic('import', opts.verbose));
    const progress = engine.progress.stream;
    const { updateLoader } = dataTransfer$1.loadersFactory();
    engine.onSchemaDiff(dataTransfer$1.getDiffHandler(engine, {
        force: opts.force,
        action: 'import'
    }));
    progress.on(`stage::start`, ({ stage, data })=>{
        updateLoader(stage, data).start();
    });
    progress.on('stage::finish', ({ stage, data })=>{
        updateLoader(stage, data).succeed();
    });
    progress.on('stage::progress', ({ stage, data })=>{
        updateLoader(stage, data);
    });
    progress.on('transfer::start', async ()=>{
        console.log('Starting import...');
        await strapiInstance.telemetry.send('didDEITSProcessStart', dataTransfer$1.getTransferTelemetryPayload(engine));
    });
    let results;
    try {
        // Abort transfer if user interrupts process
        dataTransfer$1.setSignalHandler(()=>dataTransfer$1.abortTransfer({
                engine,
                strapi: strapi
            }));
        results = await engine.transfer();
        try {
            const table = dataTransfer$1.buildTransferTable(results.engine);
            console.log(table?.toString());
        } catch (e) {
            console.error('There was an error displaying the results of the transfer.');
        }
        // Note: we need to await telemetry or else the process ends before it is sent
        await strapiInstance.telemetry.send('didDEITSProcessFinish', dataTransfer$1.getTransferTelemetryPayload(engine));
        await strapiInstance.destroy();
        helpers.exitWith(0, dataTransfer$1.exitMessageText('import'));
    } catch (e) {
        await strapiInstance.telemetry.send('didDEITSProcessFail', dataTransfer$1.getTransferTelemetryPayload(engine));
        helpers.exitWith(1, dataTransfer$1.exitMessageText('import', true));
    }
});
/**
 * Infer local file source provider options based on a given filename
 */ const getLocalFileSourceOptions = (opts)=>{
    const options = {
        file: {
            path: opts.file ?? ''
        },
        compression: {
            enabled: !!opts.decompress
        },
        encryption: {
            enabled: !!opts.decrypt,
            key: opts.key
        }
    };
    return options;
};

module.exports = action;
//# sourceMappingURL=action.js.map