ghost 4.47.4 → 5.0.1

package/core/server/data/migrations/versions/5.0/2022-05-04-15-24-map-existing-emails-to-default-newsletter.js

@@ -0,0 +1,44 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Linking existing emails and related posts to the default newsletter');
+
+        // Get the default newsletter
+        // Note we intentionally use the default newsletter slug instead of the usual orderBy logic
+        let newsletter = await knex('newsletters')
+            .where('slug', 'default-newsletter')
+            .first('id', 'slug');
+
+        if (!newsletter) {
+            // Fall back to orderBy - just in case
+            logging.warn(`Original default newsletter not found - using first in sort order`);
+            newsletter = await knex('newsletters')
+                .where('status', 'active')
+                .orderBy('sort_order', 'asc')
+                .orderBy('created_at', 'asc')
+                .orderBy('id', 'asc')
+                .first('id', 'slug');
+        }
+
+        if (!newsletter) {
+            logging.error(`Newsletter not found - skipping`);
+            return;
+        }
+
+        logging.info(`Assigning existing emails to newsletter ID ${newsletter.id} (${newsletter.slug})`);
+
+        // Set newsletter ID only on posts with related email records without a newsletter assigned
+        await knex('posts')
+            .update('newsletter_id', newsletter.id)
+            .whereIn('id', knex.raw('SELECT post_id FROM emails WHERE emails.newsletter_id IS NULL'));
+
+        await knex('emails')
+            .update('newsletter_id', newsletter.id)
+            .whereNull('newsletter_id');
+    },
+    async function down() {
+        // Not required
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-05-13-13-migrate-legacy-recipient-filters.js

@@ -0,0 +1,30 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(transaction) {
+        const postsFreeCount = await transaction('posts')
+            .where('email_recipient_filter', 'free')
+            .update('email_recipient_filter', 'status:free');
+        logging.info(`Migrated ${postsFreeCount} posts with 'email_recipient_filter' = 'free' to 'status:free'`);
+
+        const postsPaidCount = await transaction('posts')
+            .where('email_recipient_filter', 'paid')
+            .update('email_recipient_filter', 'status:-free');
+        logging.info(`Migrated ${postsPaidCount} posts with 'email_recipient_filter' = 'paid' to 'status:-free'`);
+
+        const emailsFreeCount = await transaction('emails')
+            .where('recipient_filter', 'free')
+            .update('recipient_filter', 'status:free');
+        logging.info(`Migrated ${emailsFreeCount} emails with 'recipient_filter' = 'free' to 'status:free'`);
+
+        const emailsPaidCount = await transaction('emails')
+            .where('recipient_filter', 'paid')
+            .update('recipient_filter', 'status:-free');
+        logging.info(`Migrated ${emailsPaidCount} emails with 'recipient_filter' = 'paid' to 'status:-free'`);
+    },
+    async function down() {
+        // no-op: we don't want to migrate values back to the old-style
+        // when they are supported anyway
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-05-13-29-add-newsletters-admin-integration-permission-roles.js

@@ -0,0 +1,20 @@
+const {combineTransactionalMigrations, addPermissionToRole} = require('../../utils');
+
+module.exports = combineTransactionalMigrations(
+    addPermissionToRole({
+        permission: 'Browse newsletters',
+        role: 'Admin Integration'
+    }),
+    addPermissionToRole({
+        permission: 'Read newsletters',
+        role: 'Admin Integration'
+    }),
+    addPermissionToRole({
+        permission: 'Edit newsletters',
+        role: 'Admin Integration'
+    }),
+    addPermissionToRole({
+        permission: 'Add newsletters',
+        role: 'Admin Integration'
+    })
+);

package/core/server/data/migrations/versions/5.0/2022-05-05-15-17-drop-oauth-table.js

@@ -0,0 +1,3 @@
+const {dropTables} = require('../../utils');
+
+module.exports = dropTables(['oauth']);

package/core/server/data/migrations/versions/5.0/2022-05-06-08-16-cleanup-client-subscriber-permissions.js

@@ -0,0 +1,68 @@
+const {combineTransactionalMigrations, createRemovePermissionMigration} = require('../../utils');
+
+const ROLES = [
+    'Admin Integration',
+    'Administrator',
+    'Author',
+    'Editor',
+    'Contributor'
+];
+
+const PERMISSIONS = [
+    {
+        name: 'Browse clients',
+        object: 'client',
+        action: 'browse'
+    },
+    {
+        name: 'Read clients',
+        object: 'client',
+        action: 'read'
+    },
+    {
+        name: 'Edit clients',
+        object: 'client',
+        action: 'edit'
+    },
+    {
+        name: 'Add clients',
+        object: 'client',
+        action: 'add'
+    },
+    {
+        name: 'Delete clients',
+        object: 'client',
+        action: 'delete'
+    },
+    {
+        name: 'Browse subscribers',
+        object: 'subscriber',
+        action: 'browse'
+    },
+    {
+        name: 'Read subscribers',
+        object: 'subscriber',
+        action: 'read'
+    },
+    {
+        name: 'Edit subscribers',
+        object: 'subscriber',
+        action: 'edit'
+    },
+    {
+        name: 'Add subscribers',
+        object: 'subscriber',
+        action: 'add'
+    },
+    {
+        name: 'Delete subscribers',
+        object: 'subscriber',
+        action: 'delete'
+    }
+];
+
+module.exports = combineTransactionalMigrations(...PERMISSIONS.map(p => createRemovePermissionMigration(p, ROLES)));
+
+module.exports.down = async function () {
+    // no-op: we don't want to re-add the permissions
+};

package/core/server/data/migrations/versions/5.0/2022-05-06-13-22-add-frontend-integration.js

@@ -0,0 +1,68 @@
+const logging = require('@tryghost/logging');
+const ObjectID = require('bson-objectid');
+const security = require('@tryghost/security');
+const {createTransactionalMigration} = require('../../utils');
+
+const frontendIntegration = {
+    slug: 'ghost-internal-frontend',
+    name: 'Ghost Internal Frontend',
+    description: 'Internal frontend integration',
+    type: 'internal'
+};
+
+const addInternalIntegrationAndKey = async (knex, integration) => {
+    const message = `Adding ${integration.name} integration`;
+
+    const existing = await knex('integrations').select('id').where('slug', integration.slug).first();
+
+    if (existing && existing.id) {
+        logging.warn(`Skipping ${message}`);
+        return;
+    }
+
+    const now = knex.raw('CURRENT_TIMESTAMP');
+    integration.id = ObjectID().toHexString();
+    integration.created_at = now;
+    integration.created_by = 1;
+
+    await knex('integrations').insert(integration);
+
+    const contentKey = {
+        id: ObjectID().toHexString(),
+        type: 'content',
+        secret: security.secret.create('content'),
+        role_id: null,
+        integration_id: integration.id,
+        created_at: now,
+        created_by: 1
+    };
+
+    logging.info(message);
+
+    await knex('api_keys').insert(contentKey);
+};
+
+const removeInternalIntegrationAndKey = async (knex, integration) => {
+    const message = `Removing ${integration.name} integration`;
+
+    const existing = await knex('integrations').select('id').where('slug', integration.slug).first();
+
+    if (!existing) {
+        logging.warn(`Skipping ${message}`);
+        return;
+    }
+
+    logging.info(message);
+
+    await knex('api_keys').where('integration_id', existing.id).delete();
+    await knex('integrations').where('id', existing.id).delete();
+};
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        await addInternalIntegrationAndKey(knex, frontendIntegration);
+    },
+    async function down(knex) {
+        await removeInternalIntegrationAndKey(knex, frontendIntegration);
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-09-10-00-drop-members-subscribed-column.js

@@ -0,0 +1,18 @@
+const {createDropColumnMigration} = require('../../utils');
+
+// Preferably I could use `createIrreversibleMigration` here like
+// `createIrreversibleMigration(createDropColumnMigration(...).up)` but
+// that seems to throw some obscure error that I'm not sure about... something
+// to look into for the future
+module.exports = {
+    ...createDropColumnMigration('members', 'subscribed', {}),
+
+    down: async () => {
+        // no-op: we're setting this migration to irreversible so we won't
+        // execute the `down`
+    },
+
+    config: {
+        irreversible: true
+    }
+};

package/core/server/data/migrations/versions/5.0/2022-05-09-14-17-cleanup-invalid-users-status.js

@@ -0,0 +1,17 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info(`Updating users with invalid statuses to 'inactive'`);
+
+        const affectedRows = await knex('users')
+            .update('status', 'inactive')
+            .whereNotIn('status', ['active', 'inactive', 'locked', 'warn-1', 'warn-2', 'warn-3', 'warn-4']);
+
+        logging.info(`Updated ${affectedRows} users with invalid statuses to 'inactive'`);
+    },
+    async function down() {
+        // no-op: we don't want to revert users back to an invalid status
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-10-08-33-drop-members-analytics-table.js

@@ -0,0 +1,3 @@
+const {dropTables} = require('../../utils');
+
+module.exports = dropTables(['temp_member_analytic_events']);

package/core/server/data/migrations/versions/5.0/2022-05-10-14-57-cleanup-invalid-posts-status.js

@@ -0,0 +1,17 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info(`Updating posts with invalid statuses to 'draft'`);
+
+        const affectedRows = await knex('posts')
+            .update('status', 'draft')
+            .whereNotIn('status', ['published', 'draft', 'scheduled', 'sent']);
+
+        logging.info(`Updated ${affectedRows} posts with invalid statuses to 'draft'`);
+    },
+    async function down() {
+        // no-op: we don't want to set posts back to invalid statuses
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-11-12-08-drop-webhooks-status-column.js

@@ -0,0 +1,18 @@
+const {createDropColumnMigration} = require('../../utils');
+
+// Preferably I could use `createIrreversibleMigration` here like
+// `createIrreversibleMigration(createDropColumnMigration(...).up)` but
+// that seems to throw some obscure error that I'm not sure about... something
+// to look into for the future
+module.exports = {
+    ...createDropColumnMigration('webhooks', 'status', {}),
+
+    down: async () => {
+        // no-op: we're setting this migration to irreversible so we won't
+        // execute the `down`
+    },
+
+    config: {
+        irreversible: true
+    }
+};

package/core/server/data/migrations/versions/5.0/2022-05-11-13-12-rename-settings.js

@@ -0,0 +1,51 @@
+const logging = require('@tryghost/logging');
+const _ = require('lodash');
+const {createTransactionalMigration} = require('../../utils');
+
+const renameMappings = [{
+    from: 'lang',
+    to: 'locale'
+}, {
+    from: 'session_secret',
+    to: 'admin_session_secret'
+}];
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const keys = _.flatMap(renameMappings, (m) => {
+            return [m.from, m.to];
+        });
+
+        const settings = await knex('settings').select('key', 'value').whereIn('key', keys);
+
+        // eslint-disable-next-line no-restricted-syntax
+        for (const renameMapping of renameMappings) {
+            if (_.find(settings, {key: renameMapping.to}) && _.find(settings, {key: renameMapping.from})) {
+                let updatedValue = _.find(settings, {key: renameMapping.from}).value;
+                // CASE: default settings were added already, update them with old values & remove old settings
+                logging.info(`Updating ${renameMapping.to} with value from ${renameMapping.from}`);
+                await knex('settings')
+                    .where('key', renameMapping.to)
+                    .update('value', updatedValue);
+
+                logging.info(`Deleting ${renameMapping.from}`);
+                await knex('settings')
+                    .where('key', renameMapping.from)
+                    .del();
+            } else if (_.find(settings, {key: renameMapping.from})) {
+                // CASE: old settings exist, update them
+                logging.info(`Renaming ${renameMapping.from} to ${renameMapping.to}`);
+                await knex('settings')
+                    .where('key', renameMapping.from)
+                    .update('key', renameMapping.to);
+            } else {
+                // CASE: old settings don't exist, let default settings create them
+                logging.warn(`Setting ${renameMapping.from} is missing, skipping update`);
+            }
+        }
+    },
+
+    async function down() {
+        // no-op: we can't rollback as there are irreversible migrations in 5.0
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-11-16-36-remove-unused-settings.js

@@ -0,0 +1,54 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+const settingsToRemove = [
+    'editor_is_launch_complete',
+    'members_free_price_name',
+    'members_free_price_description',
+    'members_paid_signup_redirect',
+    'members_free_signup_redirect',
+    'members_from_address',
+    'members_reply_address',
+    'stripe_product_name',
+    'newsletter_show_badge',
+    'newsletter_header_image',
+    'newsletter_show_header_icon',
+    'newsletter_show_header_title',
+    'newsletter_title_alignment',
+    'newsletter_title_font_category',
+    'newsletter_show_feature_image',
+    'newsletter_body_font_category',
+    'newsletter_footer_content',
+    'oauth_client_id',
+    'oauth_client_secret'
+];
+
+// Settings that cannot be removed, but should not be used anymore
+// 'members_monthly_price_id',
+// 'members_yearly_price_id',
+// 'portal_products',
+// 'stripe_plans'
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const existingSettings = await knex('settings')
+            .whereIn('key', settingsToRemove)
+            .pluck('key');
+
+        const settingsInDatabase = settingsToRemove.filter(s => existingSettings.includes(s));
+        if (settingsInDatabase.length) {
+            logging.info(`Deleting settings: ${settingsInDatabase.join(', ')}`);
+            await knex('settings')
+                .whereIn('key', settingsInDatabase)
+                .del();
+        }
+
+        const settingsNotInDatabase = settingsToRemove.filter(s => !existingSettings.includes(s));
+        if (settingsNotInDatabase.length) {
+            logging.warn(`Unable to delete missing settings: ${settingsNotInDatabase.join(', ')}`);
+        }
+    },
+    async function down() {
+        // no-op: we don't want to recreate these settings without values
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-12-10-29-add-newsletter-permissions-for-editors-and-authors.js

@@ -0,0 +1,20 @@
+const {combineTransactionalMigrations, addPermissionToRole} = require('../../utils');
+
+module.exports = combineTransactionalMigrations(
+    addPermissionToRole({
+        permission: 'Browse newsletters',
+        role: 'Editor'
+    }),
+    addPermissionToRole({
+        permission: 'Read newsletters',
+        role: 'Editor'
+    }),
+    addPermissionToRole({
+        permission: 'Browse newsletters',
+        role: 'Author'
+    }),
+    addPermissionToRole({
+        permission: 'Read newsletters',
+        role: 'Author'
+    })
+);

package/core/server/data/migrations/versions/5.0/2022-05-12-13-51-add-label-permissions-for-authors.js

@@ -0,0 +1,12 @@
+const {combineTransactionalMigrations, addPermissionToRole} = require('../../utils');
+
+module.exports = combineTransactionalMigrations(
+    addPermissionToRole({
+        permission: 'Browse labels',
+        role: 'Author'
+    }),
+    addPermissionToRole({
+        permission: 'Read labels',
+        role: 'Author'
+    })
+);

package/core/server/data/migrations/versions/5.0/2022-05-13-11-38-drop-none-email-recipient-filter.js

@@ -0,0 +1,28 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        // The 'none' value is no longer supported/used
+        logging.info(`Updating posts with email_recipient_filter 'none' to 'all' and newsletter_id to null`);
+
+        const affectedRows = await knex('posts')
+            .update({
+                email_recipient_filter: 'all',
+                newsletter_id: null
+            })
+            .where('email_recipient_filter', 'none');
+
+        logging.info(`Updated ${affectedRows} posts' email_recipient_filter to 'all' and newsletter_id to null`);
+    },
+    async function down(knex) {
+        // In previous versions, none meant that no email was sent.
+        logging.info(`Updating posts' email_recipient_filter to 'none' if they have no newsletter`);
+
+        const affectedRows = await knex('posts')
+            .update('email_recipient_filter', 'none')
+            .where('newsletter_id', null);
+
+        logging.info(`Updated ${affectedRows} posts' email_recipient_filter to 'none'`);
+    }
+);

package/core/server/data/migrations/versions/5.0/2022-05-21-00-00-regenerate-posts-html.js

@@ -0,0 +1,70 @@
+const logging = require('@tryghost/logging');
+const {createIrreversibleMigration} = require('../../utils');
+const mobiledocLib = require('../../../../lib/mobiledoc');
+const htmlToPlaintext = require('../../../../../shared/html-to-plaintext');
+
+module.exports = createIrreversibleMigration(async (knex) => {
+    logging.info(`Starting regeneration of posts HTML`);
+
+    await knex.transaction(async (trx) => {
+        // get list of posts ids, use .forUpdate to lock rows until the transaction is finished
+        const postIdRows = await knex('posts')
+            .transacting(trx)
+            .forUpdate()
+            .select('id')
+            .where('mobiledoc', 'like', '%["video%')
+            .orWhere('mobiledoc', 'like', '%["product%');
+
+        logging.info(`Updating HTML for ${postIdRows.length} posts`);
+
+        // transform each post individually to avoid dumping all posts into memory and
+        // pushing all queries into the query builder buffer in parallel
+        // https://stackoverflow.com/questions/54105280/how-to-loop-through-multi-line-sql-query-and-use-them-in-knex-transactions
+
+        // eslint-disable-next-line no-restricted-syntax
+        for (const postIdRow of postIdRows) {
+            const {id} = postIdRow;
+            const [post] = await knex('posts')
+                .transacting(trx)
+                .where({id})
+                .select('mobiledoc', 'html', 'plaintext');
+
+            let mobiledoc;
+
+            try {
+                mobiledoc = JSON.parse(post.mobiledoc || null);
+
+                if (!mobiledoc) {
+                    logging.warn(`No mobiledoc for ${id}. Skipping.`);
+                    continue;
+                }
+            } catch (err) {
+                logging.warn(`Invalid JSON structure for ${id}. Skipping`);
+                continue;
+            }
+
+            const html = mobiledocLib.mobiledocHtmlRenderer.render(mobiledoc);
+
+            const updatedAttrs = {
+                html
+            };
+
+            if (html !== post.html || !post.plaintext) {
+                const plaintext = htmlToPlaintext.excerpt(html);
+
+                if (plaintext !== post.plaintext) {
+                    updatedAttrs.plaintext = plaintext;
+                }
+            }
+
+            await knex('posts')
+                .transacting(trx)
+                .where({id})
+                .update(updatedAttrs);
+        }
+
+        return 'transaction complete';
+    });
+
+    logging.info('Finished regeneration of posts HTML');
+});

package/core/server/data/schema/commands.js

@@ -71,10 +71,26 @@ function dropNullable(tableName, column, transaction = db.knex) {
     });
 }
 
-function addColumn(tableName, column, transaction = db.knex, columnSpec) {
-    return transaction.schema.table(tableName, function (table) {
+async function addColumn(tableName, column, transaction = db.knex, columnSpec) {
+    const addColumnBuilder = transaction.schema.table(tableName, function (table) {
         addTableColumn(tableName, table, column, columnSpec);
     });
+
+    // Use the default flow for SQLite because .toSQL() is tricky with SQLite when
+    // it does the table dance
+    if (DatabaseInfo.isSQLite(transaction)) {
+        await addColumnBuilder;
+        return;
+    }
+
+    let sql = addColumnBuilder.toSQL()[0].sql;
+
+    if (DatabaseInfo.isMySQL(transaction)) {
+        // Guard against an ending semicolon
+        sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
+    }
+
+    await transaction.raw(sql);
 }
 
 async function dropColumn(tableName, column, transaction = db.knex, columnSpec = {}) {
@@ -83,9 +99,25 @@ async function dropColumn(tableName, column, transaction = db.knex, columnSpec =
         await dropForeign({fromTable: tableName, fromColumn: column, toTable, toColumn, transaction});
     }
 
-    return transaction.schema.table(tableName, function (table) {
+    const dropTableBuilder = transaction.schema.table(tableName, function (table) {
         table.dropColumn(column);
     });
+
+    // Use the default flow for SQLite because .toSQL() is tricky with SQLite when
+    // it does the table dance
+    if (DatabaseInfo.isSQLite(transaction)) {
+        await dropTableBuilder;
+        return;
+    }
+
+    let sql = dropTableBuilder.toSQL()[0].sql;
+
+    if (DatabaseInfo.isMySQL(transaction)) {
+        // Guard against an ending semicolon
+        sql = sql.replace(/;\s*$/, '') + ', algorithm=copy';
+    }
+
+    await transaction.raw(sql);
 }
 
 /**