ghost 4.47.4 → 5.0.1

package/core/cli/README.md

@@ -0,0 +1,88 @@
+# CLI Commands
+
+## Writing new commands
+
+Commands are classes which extend the base `Command` class (see [`command.js`](command.js)).
+
+The only required override is the `handle()` method, which defines the logic for the command:
+```javascript
+const Command = require('./command');
+
+module.exports = class REPL extends Command {
+    async handle(argv = {}) {
+        // this is where your logic is implemented
+    }
+};
+```
+
+### Arguments
+
+Optionally, you can override the `setup()` method, where you can define any command-line arguments and help text etc:
+```javascript
+    setup() {
+        this.help('A brief explanation of what your command does, shown when the --help flag is used');
+        // arguments are passed to sywac - see https://sywac.io/docs/
+        this.argument('--color', {type: 'string', defaultValue: 'yellow'});
+    }
+```
+
+Arguments specified in `setup()` are accessed from the `argv` object passed to the `handle()` method:
+```javascript
+async handle(argv = {}) {
+    this.log(`Your color is ${argv.color}`);
+}
+```
+
+### Output
+
+You can write console output using a number of helper methods:
+```javascript
+this.log('Writes a line to the console');
+```
+
+Available helpers are `log`, `ok`, `info`, `error`, `fatal`, `warn`, and `debug`.
+
+### Interactive input
+
+**Confirm an action** with:
+```javascript
+const confirm = await this.confirm('Are you sure you want to continue?');
+if (!confirm) {
+    // ...
+}
+```
+
+**Ask for user input** with:
+```javascript
+const fruit = await this.ask('Favorite fruit?');
+this.info(`You answered: ${fruit}`);
+```
+
+**Get masked input** with:
+```javascript
+const password = await this.secret('Password:');
+this.log(`Your password is: ${password}`);
+```
+
+### Progress bars
+
+You can show a progress bar to e.g. display progress through a long-running task.
+
+`this.progressBar()` returns an instance of a [cli-progress](https://github.com/npkgz/cli-progress) progress bar. You can add a status to the output by calling `.update({status: 'Your status message'})`, and the progress bar can be advanced by `.increment()`:
+
+```javascript
+const progressBar = this.progressBar(listOfTasks.length);
+for (const task in listOfTasks) {
+    progressBar.update({status: `Running ${task.name}`});
+    await task.run();
+    progressBar.increment();
+}
+```
+
+## Registering commands
+
+New commands need to be registered in `ghost.js` before they can be called.
+
+Commands are called by passing them to `command.run()` either as a class definition, or as the name of the file to be required in the `core/cli` directory.
+
+`command.run()` is a static method on the Command class that handles instantiating the command, resolving arguments, and calling the `handle` method. You can instantiate and call a command outside of this structure, but you'll need to resolve/provide the arguments (`argv` object) manually.

package/core/cli/command.js

@@ -0,0 +1,129 @@
+const cli = require('@tryghost/pretty-cli');
+const logging = cli.ui.log;
+const chalk = require('chalk');
+
+const errors = {
+    ERR_INVALID_COMMAND: 1,
+    ERR_INVALID_ENV: 2
+};
+
+module.exports = class Command {
+    constructor() {
+        this.checkEnv();
+        this.init();
+        this.setup();
+    }
+
+    /**
+     * @private
+     */
+    init() {
+        this.cli = cli;
+        this.cli.strict();
+        // this is always present but not used
+        this.cli.positional('<command>', {hidden: true});
+    }
+
+    setup() {
+        // init cli options
+    }
+
+    permittedEnvironments() {
+        return ['development', 'local'];
+    }
+
+    /**
+     * @private
+     */
+    checkEnv() {
+        const env = process.env.NODE_ENV ?? 'development';
+        this.warn(`Node environment: ${chalk.bold(env)}`);
+        if (!this.permittedEnvironments().includes(env)) {
+            this.fatal(`Command ${this.constructor.name} is not permitted in ${env}`);
+            process.exit(errors.ERR_INVALID_ENV);
+        }
+    }
+
+    handle() {
+        this.warn(`Command ${this.constructor.name} has not been implemented.`);
+    }
+
+    async ask(message, opts = {type: 'input'}) {
+        const inquirer = require('inquirer');
+        const response = await inquirer.prompt([{
+            message,
+            ...opts,
+            name: 'value'
+        }]);
+        return response.value;
+    }
+
+    async confirm(message) {
+        return this.ask(message, {type: 'confirm', default: false});
+    }
+
+    async secret(message) {
+        return this.ask(message, {type: 'password'});
+    }
+
+    progressBar(total, opts = {}) {
+        const progress = require('cli-progress');
+        const bar = new progress.Bar({
+            format: `|${chalk[opts.color ?? 'cyan']('{bar}')}| {percentage}% | {value}/{total} {status}`,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+            hideCursor: true,
+            clearOnComplete: true,
+            stopOnComplete: true,
+            forceRedraw: true,
+            ...opts
+        });
+        bar.start(total, 0, {status: ''});
+        return bar;
+    }
+
+    argument(key, opts = {}) {
+        this.cli[opts.type ?? 'positional'](key, opts);
+    }
+
+    help(message) {
+        this.cli.preface(`\n${message}`);
+    }
+
+    /* output aliases */
+    log() {
+        logging(...arguments);
+    }
+    ok() {
+        logging.ok(...arguments);
+    }
+    info() {
+        logging.info(...arguments);
+    }
+    error() {
+        logging.error(...arguments);
+    }
+    fatal() {
+        logging.fatal(...arguments);
+    }
+    warn() {
+        logging.warn(...arguments);
+    }
+    debug() {
+        logging.debug(...arguments);
+    }
+
+    static async run(command) {
+        // attempt to load a cli command by name
+        if (typeof command === 'string') {
+            command = require(`./${command}`);
+        }
+        const cmd = new command();
+        if (cmd instanceof Command !== true) {
+            logging.fatal('Invalid command.');
+            process.exit(errors.ERR_INVALID_COMMAND);
+        }
+        const argv = await cmd.cli.parseAndExit();
+        return await cmd.handle(argv);
+    }
+};

package/core/cli/repl.js

@@ -0,0 +1,32 @@
+const Command = require('./command');
+const chalk = require('chalk');
+
+module.exports = class REPL extends Command {
+    setup() {
+        this.help('Launches a REPL environment with access to a configured db instance and models');
+        // this is only here to demo how to set a default value for an arg :)
+        this.argument('--color', {type: 'string', defaultValue: 'yellow', hidden: true});
+    }
+
+    initializeContext(context) {
+        const models = require('../server/models');
+        const knex = require('../server/data/db/connection');
+
+        models.init();
+
+        context.models = models;
+        context.m = models;
+        context.knex = knex;
+        context.k = knex;
+    }
+
+    async handle(argv = {}) {
+        this.debug(chalk[argv.color]('== Ghost development REPL =='));
+        this.info(`a knex database instance is available as ${chalk.magenta('knex')}`);
+        this.info(`bookshelf models are available as ${chalk.magenta('models')}`);
+        const repl = require('repl');
+        const cli = repl.start('> ');
+        this.initializeContext(cli.context);
+        cli.on('reset', this.initializeContext);
+    }
+};

package/core/cli/timetravel.js

@@ -0,0 +1,87 @@
+const Command = require('./command');
+const chalk = require('chalk');
+
+// we use logins as the basis for our offset
+const datum = {
+    table: 'members_login_events',
+    column: 'created_at'
+};
+
+const helpText = `Updates the Ghost db and shifts all dates up to present day.
+By default the offset is based on the date of the last member login.\n
+${chalk.red('warning')} This is a destructive operation for testing purposes only. DO NOT run it against a database you care about.`;
+
+module.exports = class TimeTravel extends Command {
+    setup() {
+        this.help(helpText);
+        this.argument('--offset', {type: 'number', desc: 'Specify a date offset (in days)'});
+        this.argument('--force', {type: 'boolean', desc: 'Continue without confirmation'});
+    }
+
+    async handle(argv = {}) {
+        const _ = require('lodash');
+        // knex has to be loaded _after_ the call to setup()
+        // the db connection requires nconf which passes argv to yargs,
+        // which intercepts --help and stops execution
+        const knex = require('../server/data/db/connection');
+        const schema = require('../server/data/schema');
+        const {DateTime} = require('luxon');
+
+        if (!argv.offset) {
+            const datumPoint = await knex(datum.table)
+                .max(datum.column, {as: datum.column})
+                .first();
+
+            if (!datumPoint[datum.column]) {
+                this.error('No data to use as baseline. Use --offset instead');
+                knex.destroy();
+                return;
+            }
+
+            argv.offset = Math.floor(
+                DateTime.utc()
+                    .diff(DateTime.fromJSDate(datumPoint[datum.column]), 'days')
+                    .toObject()
+                    .days
+            );
+        }
+
+        const dateOffset = argv.offset;
+
+        this.info(`Timetravel will use an offset of +${dateOffset} days`);
+        this.warn('This is a destructive command that will modify your database.');
+
+        const confirm = argv.force || await this.confirm('Are you sure you want to continue?');
+        if (!confirm) {
+            this.warn('Aborting');
+            process.exit(1);
+        }
+
+        // map schema to {table: [dateTimeColumn,...]}
+        const dateTimeFields = _.pickBy(
+            _.mapValues(schema.tables, (table) => {
+                return _.keys(_.pickBy(table, (spec) => {
+                    return spec.type === 'dateTime';
+                }));
+            }),
+            fields => fields.length > 0
+        );
+
+        const totalFields = _.reduce(dateTimeFields, (result, value) => {
+            return result + value.length;
+        }, 0);
+        const progressBar = this.progressBar(totalFields);
+        const db = await knex.transaction();
+        for (const table in dateTimeFields) {
+            for (const column of dateTimeFields[table]) {
+                progressBar.update({status: `Updating ${table}.${column}`});
+                await db(table)
+                    .update(column, db.raw(`DATE_ADD(${column}, interval ${dateOffset} day)`));
+                progressBar.increment();
+            }
+        }
+        this.info(`Updated ${totalFields} fields`);
+        await db.commit();
+        knex.destroy();
+    }
+};

package/core/frontend/apps/amp/lib/helpers/amp_content.js

@@ -6,8 +6,6 @@
 //
 // Converts normal HTML into AMP HTML with Amperize module and uses a cache to return it from
 // there if available. The cacheId is a combination of `updated_at` and the `slug`.
-const Promise = require('bluebird');
-
 const {DateTime, Interval} = require('luxon');
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
@@ -170,19 +168,16 @@ function getAmperizeHTML(html, post) {
     return Promise.resolve(amperizeCache[post.id].amp);
 }
 
-function ampContent() {
+module.exports = async function amp_content() { // eslint-disable-line camelcase
     let sanitizeHtml = require('sanitize-html');
     let cheerio = require('cheerio');
 
-    let amperizeHTML = {
-        amperize: getAmperizeHTML(this.html, this)
-    };
-
-    return Promise.props(amperizeHTML).then((result) => {
+    try {
+        const response = await getAmperizeHTML(this.html, this);
         let $ = null;
 
         // our Amperized HTML
-        ampHTML = result.amperize || '';
+        ampHTML = response ?? '';
 
         // Use cheerio to traverse through HTML and make little clean-ups
         $ = cheerio.load(ampHTML);
@@ -208,9 +203,12 @@ function ampContent() {
         });
 
         return new SafeString(cleanHTML);
-    });
-}
+    } catch (error) {
+        logging.error(error);
 
-module.exports = ampContent;
+        // Return an empty safe string
+        return new SafeString('');
+    }
+};
 
 module.exports.async = true;

package/core/frontend/apps/amp/lib/router.js

@@ -26,8 +26,7 @@ function _renderer(req, res, next) {
     // Format data
     let body = req.body || {};
 
-    // CASE: we only support amp pages for posts that are not static pages
-    if (!body.post || body.post.page) {
+    if (!body.post) {
         return next(new errors.NotFoundError({message: tpl(messages.pageNotFound)}));
     }
 
@@ -70,7 +69,7 @@ function getPostData(req, res, next) {
         }));
     }
 
-    // @NOTE: amp is not supported for static pages
+    // @NOTE: amp is not supported for "page" resource
     // @TODO: https://github.com/TryGhost/Ghost/issues/10548
     dataService.entryLookup(urlWithoutSubdirectoryWithoutAmp, {permalinks, query: {controller: 'postsPublic', resource: 'posts'}}, res.locals)
         .then((result) => {

package/core/frontend/helpers/body_class.js

@@ -10,11 +10,11 @@ module.exports = function body_class(options) { // eslint-disable-line camelcase
     const context = options.data.root.context || [];
     const obj = this.post || this.page;
     const tags = obj && obj.tags ? obj.tags : [];
-    const isPage = !!(obj && obj.page);
+    const isPage = !!(this.page);
 
     if (context.includes('home')) {
         classes.push('home-template');
-    } else if (context.includes('post') && obj) {
+    } else if (context.includes('post') && obj && !isPage) {
         classes.push('post-template');
     } else if (context.includes('page') && obj && isPage) {
         classes.push('page-template');

package/core/frontend/helpers/excerpt.js

@@ -17,8 +17,6 @@ module.exports = function excerpt(options) {
 
     if (this.custom_excerpt) {
         excerptText = String(this.custom_excerpt);
-    } else if (this.html) {
-        excerptText = String(this.html);
     } else if (this.excerpt) {
         excerptText = String(this.excerpt);
     } else {

package/core/frontend/helpers/get.js

@@ -9,7 +9,6 @@ const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
 const _ = require('lodash');
-const Promise = require('bluebird');
 const jsonpath = require('jsonpath');
 
 const messages = {
@@ -46,7 +45,6 @@ const pathAliases = {
 /**
  * ## Is Browse
  * Is this a Browse request or a Read request?
- * @param {Object} resource
  * @param {Object} options
  * @returns {boolean}
  */
@@ -123,9 +121,9 @@ function parseOptions(globals, data, options) {
  * ## Get
  * @param {Object} resource
  * @param {Object} options
- * @returns {Promise}
+ * @returns {Promise<any>}
  */
-module.exports = function get(resource, options) {
+module.exports = async function get(resource, options) {
     options = options || {};
     options.hash = options.hash || {};
     options.data = options.data || {};
@@ -134,58 +132,59 @@ module.exports = function get(resource, options) {
     const start = Date.now();
     const data = createFrame(options.data);
     const ghostGlobals = _.omit(data, ['_parent', 'root']);
-    const apiVersion = _.get(data, 'root._locals.apiVersion');
+
     let apiOptions = options.hash;
     let returnedRowsCount;
 
     if (!options.fn) {
         data.error = tpl(messages.mustBeCalledAsBlock, {helperName: 'get'});
         logging.warn(data.error);
-        return Promise.resolve();
+        return;
     }
 
     if (!RESOURCES[resource]) {
         data.error = tpl(messages.invalidResource);
         logging.warn(data.error);
-        return Promise.resolve(options.inverse(self, {data: data}));
+        return options.inverse(self, {data: data});
     }
 
     const controllerName = RESOURCES[resource].alias;
-    const controller = api[apiVersion][controllerName];
+    const controller = api[controllerName];
     const action = isBrowse(apiOptions) ? 'browse' : 'read';
 
     // Parse the options we're going to pass to the API
     apiOptions = parseOptions(ghostGlobals, this, apiOptions);
     apiOptions.context = {member: data.member};
 
-    // @TODO: https://github.com/TryGhost/Ghost/issues/10548
-    return controller[action](apiOptions).then(function success(result) {
+    try {
+        const response = await controller[action](apiOptions);
+
         // prepare data properties for use with handlebars
-        if (result[resource] && result[resource].length) {
-            result[resource].forEach(prepareContextResource);
+        if (response[resource] && response[resource].length) {
+            response[resource].forEach(prepareContextResource);
         }
 
         // used for logging details of slow requests
-        returnedRowsCount = result[resource] && result[resource].length;
+        returnedRowsCount = response[resource] && response[resource].length;
 
         // block params allows the theme developer to name the data using something like
         // `{{#get "posts" as |result pageInfo|}}`
-        const blockParams = [result[resource]];
-        if (result.meta && result.meta.pagination) {
-            result.pagination = result.meta.pagination;
-            blockParams.push(result.meta.pagination);
+        const blockParams = [response[resource]];
+        if (response.meta && response.meta.pagination) {
+            response.pagination = response.meta.pagination;
+            blockParams.push(response.meta.pagination);
         }
 
         // Call the main template function
-        return options.fn(result, {
+        return options.fn(response, {
             data: data,
             blockParams: blockParams
         });
-    }).catch(function error(err) {
-        logging.error(err);
-        data.error = err.message;
+    } catch (error) {
+        logging.error(error);
+        data.error = error.message;
         return options.inverse(self, {data: data});
-    }).finally(function () {
+    } finally {
         const totalMs = Date.now() - start;
         const logLevel = config.get('logging:slowHelper:level');
         const threshold = config.get('logging:slowHelper:threshold');
@@ -194,13 +193,13 @@ module.exports = function get(resource, options) {
                 message: `{{#get}} helper took ${totalMs}ms to complete`,
                 code: 'SLOW_GET_HELPER',
                 errorDetails: {
-                    api: `${apiVersion}.${controllerName}.${action}`,
+                    api: `${controllerName}.${action}`,
                     apiOptions,
                     returnedRows: returnedRowsCount
                 }
             }));
         }
-    });
+    }
 };
 
 module.exports.async = true;