feat(import): add import functionality (#1043)

refs #468
- add `--from-export` argument to install command
- add import command to import a ghost export file into an existing
instance
- add import parsing/loading code

Author: acburdine

lib/commands/import.js

@@ -0,0 +1,37 @@
+const Command = require('../command');
+
+class ImportCommand extends Command {
+    async run(argv) {
+        const semver = require('semver');
+        const importTask = require('../tasks/import');
+        const {SystemError} = require('../errors');
+
+        const instance = this.system.getInstance();
+        const {version} = importTask.parseExport(argv.file);
+
+        if (semver.major(version) === 0 && semver.major(instance.version) > 1) {
+            throw new SystemError(`v0.x export files can only be imported by Ghost v1.x versions. You are running Ghost v${instance.version}.`);
+        }
+
+        const isRunning = await instance.isRunning();
+
+        if (!isRunning) {
+            const shouldStart = await this.ui.confirm('Ghost instance is not currently running. Would you like to start it?', true);
+
+            if (!shouldStart) {
+                throw new SystemError('Ghost instance is not currently running');
+            }
+
+            instance.checkEnvironment();
+            await this.ui.run(() => instance.start(), 'Starting Ghost');
+        }
+
+        const importTasks = await importTask(this.ui, instance, argv.file);
+        await importTasks.run();
+    }
+}
+
+ImportCommand.description = 'Import a Ghost export';
+ImportCommand.params = '[file]';
+
+module.exports = ImportCommand;

lib/commands/install.js

@@ -36,6 +36,24 @@ class InstallCommand extends Command {
             this.system.setEnvironment(true, true);
         }
 
+        if (argv.fromExport) {
+            const semver = require('semver');
+            const {parseExport} = require('../tasks/import');
+            const parsed = parseExport(argv.fromExport);
+
+            if (version) {
+                this.ui.log('Warning: you specified both a specific version and an export file. The version specified in the export file will be used.', 'yellow');
+            }
+
+            if (semver.major(parsed.version) === 0) {
+                this.ui.log('Detected a v0.x export file. Installing latest v1.x version.', 'green');
+                version = null;
+                argv.v1 = true;
+            } else {
+                version = parsed.version;
+            }
+        }
+
         return this.runCommand(DoctorCommand, Object.assign({
             categories: ['install'],
             skipInstanceCheck: true,
@@ -138,6 +156,11 @@ InstallCommand.options = {
         description: '[--no-setup] Enable/Disable auto-running the setup command',
         type: 'boolean',
         default: true
+    },
+    'from-export': {
+        alias: 'f',
+        description: 'Path to a Ghost export file to import after setup',
+        type: 'string'
     }
 };
 InstallCommand.runPreChecks = true;

lib/commands/setup.js

@@ -51,6 +51,7 @@ class SetupCommand extends Command {
         const linux = require('../tasks/linux');
         const migrator = require('../tasks/migrator');
         const configure = require('../tasks/configure');
+        const importTask = require('../tasks/import');
 
         // This is used so we can denote built-in setup steps
         // and disable the "do you wish to set up x?" prompt
@@ -102,14 +103,20 @@ class SetupCommand extends Command {
                     return true;
                 }
 
-                if (argv.start) {
+                if (argv.start || argv.fromExport) {
                     return false;
                 }
 
                 const confirmed = await ui.confirm('Do you want to start Ghost?', true);
                 return !confirmed;
             },
             task: ({instance, argv}) => instance.start(argv.enable)
+        }, {
+            id: 'import',
+            title: 'Importing content',
+            [internal]: true,
+            enabled: ({argv}) => Boolean(argv.fromExport),
+            task: ({ui, instance, argv}) => importTask(ui, instance, argv.fromExport)
         }].map((step) => {
             const name = step.name || step.id;
             const title = step.title || `Setting up ${name}`;

lib/tasks/import/api.js

@@ -0,0 +1,104 @@
+const fs = require('fs-extra');
+const got = require('got');
+const get = require('lodash/get');
+const semver = require('semver');
+const FormData = require('form-data');
+const {Cookie} = require('tough-cookie');
+
+const {SystemError} = require('../../errors');
+
+const bases = {
+    1: '/ghost/api/v0.1',
+    2: '/ghost/api/v2/admin',
+    3: '/ghost/api/v3/admin'
+};
+
+function getBaseUrl(version, url) {
+    const basePath = bases[semver.major(version)];
+
+    if (!basePath) {
+        throw new SystemError(`Unsupported version: ${version}`);
+    }
+
+    return `${url.replace(/\/?$/, '')}${basePath}`;
+}
+
+async function isSetup(version, url) {
+    const baseUrl = getBaseUrl(version, url);
+    const {body} = await got('/authentication/setup/', {baseUrl, json: true});
+    return get(body, 'setup[0].status', false);
+}
+
+async function setup(version, url, data) {
+    const baseUrl = getBaseUrl(version, url);
+    const {name, email, password, blogTitle} = data;
+    const body = {
+        setup: [{name, email, password, blogTitle}]
+    };
+
+    await got.post('/authentication/setup/', {baseUrl, body, json: true});
+}
+
+async function getAuthOpts(version, url, {username, password}) {
+    const baseUrl = getBaseUrl(version, url);
+
+    if (semver.major(version) === 1) {
+        const {body: configBody} = await got('/configuration/', {baseUrl, json: true});
+        const {clientId, clientSecret} = get(configBody, 'configuration[0]', {});
+        const {body: authBody} = await got.post('/authentication/token/', {
+            baseUrl,
+            json: true,
+            form: true,
+            body: {
+                grant_type: 'password',
+                client_id: clientId,
+                client_secret: clientSecret,
+                username,
+                password
+            }
+        });
+
+        return {
+            baseUrl,
+            headers: {
+                Authorization: `Bearer ${authBody.access_token}`
+            }
+        };
+    }
+
+    const {headers} = await got.post('/session/', {
+        baseUrl,
+        headers: {
+            Origin: url,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({username, password})
+    });
+
+    /* istanbul ignore next */
+    const cookies = headers['set-cookie'] || [];
+    const filteredCookies = cookies.map(Cookie.parse).filter(Boolean).map(c => c.cookieString());
+
+    return {
+        baseUrl,
+        headers: {
+            Origin: url,
+            Cookie: filteredCookies
+        }
+    };
+}
+
+async function runImport(version, url, auth, exportFile) {
+    const authOpts = await getAuthOpts(version, url, auth);
+    const body = new FormData();
+
+    body.append('importfile', fs.createReadStream(exportFile));
+    await got.post('/db/', {...authOpts, body});
+}
+
+module.exports = {
+    getBaseUrl,
+    isSetup,
+    setup,
+    runImport
+};

lib/tasks/import/index.js

@@ -0,0 +1,41 @@
+const validator = require('validator');
+
+const parseExport = require('./parse-export');
+const {isSetup, setup, runImport} = require('./api');
+
+async function task(ui, instance, exportFile) {
+    const {data} = parseExport(exportFile);
+    const url = instance.config.get('url');
+
+    const prompts = [{
+        type: 'password',
+        name: 'password',
+        message: 'Enter your Ghost administrator password',
+        validate: val => validator.isLength(`${val}`, {min: 10}) || 'Password must be at least 10 characters long'
+    }];
+
+    const blogIsSetup = await isSetup(instance.version, url);
+    if (blogIsSetup) {
+        prompts.unshift({
+            type: 'string',
+            name: 'username',
+            message: 'Enter your Ghost administrator email address',
+            validate: val => validator.isEmail(`${val}`) || 'You must specify a valid email'
+        });
+    }
+
+    const {username, password} = await ui.prompt(prompts);
+    const importUsername = username || data.email;
+
+    return ui.listr([{
+        title: 'Running blog setup',
+        task: () => setup(instance.version, url, {...data, password}),
+        enabled: () => !blogIsSetup
+    }, {
+        title: 'Running blog import',
+        task: () => runImport(instance.version, url, {username: importUsername, password}, exportFile)
+    }], false);
+}
+
+module.exports = task;
+module.exports.parseExport = parseExport;

lib/tasks/import/parse-export.js

@@ -0,0 +1,53 @@
+const fs = require('fs-extra');
+const get = require('lodash/get');
+const find = require('lodash/find');
+const semver = require('semver');
+
+const {SystemError} = require('../../errors');
+
+const pre1xVersion = /^00[1-9]$/;
+
+/* eslint-disable camelcase */
+function parse(content) {
+    const data = get(content, 'db[0].data', content.data || null);
+    /* istanbul ignore next */
+    const {id: role_id} = find(data.roles, {name: 'Owner'}) || {};
+    /* istanbul ignore next */
+    const {user_id} = find(data.roles_users, {role_id}) || {};
+    /* istanbul ignore next */
+    const {name, email} = find(data.users, {id: user_id}) || {};
+    /* istanbul ignore next */
+    const {value: blogTitle} = find(data.settings, {key: 'title'}) || {};
+
+    return {name, email, blogTitle};
+}
+/* eslint-enable camelcase */
+
+module.exports = function parseExport(file) {
+    let content = {};
+
+    try {
+        content = fs.readJsonSync(file);
+    } catch (err) {
+        throw new SystemError({
+            message: 'Import file not found or is not valid JSON',
+            err
+        });
+    }
+
+    const version = get(content, 'db[0].meta.version', get(content, 'meta.version', null));
+    if (!version) {
+        throw new SystemError('Unable to determine export version');
+    }
+
+    const validVersion = pre1xVersion.test(version) || semver.valid(version);
+    if (!validVersion) {
+        throw new SystemError(`Unrecognized export version: ${version}`);
+    }
+
+    const data = parse(content);
+    return {
+        version: pre1xVersion.test(version) ? '0.11.14' : version,
+        data
+    };
+};

package.json

@@ -57,6 +57,7 @@
     "execa": "1.0.0",
     "find-plugins": "1.1.7",
     "fkill": "6.2.0",
+    "form-data": "2.5.1",
     "fs-extra": "8.1.0",
     "generate-password": "1.4.2",
     "global-modules": "2.0.0",
@@ -84,6 +85,7 @@
     "symlink-or-copy": "1.2.0",
     "systeminformation": "4.14.17",
     "tail": "2.0.3",
+    "tough-cookie": "3.0.1",
     "validator": "7.2.0",
     "yargs": "14.2.0",
     "yarn": "1.19.1"
@@ -95,6 +97,7 @@
     "eslint-plugin-ghost": "0.6.0",
     "has-ansi": "4.0.0",
     "mocha": "6.2.2",
+    "nock": "11.7.0",
     "nyc": "14.1.1",
     "proxyquire": "2.1.3",
     "sinon": "7.5.0",