ghost 4.48.0 → 5.0.0

package/core/server/data/migrations/utils/permissions.js

@@ -0,0 +1,291 @@
+const ObjectId = require('bson-objectid').default;
+const logging = require('@tryghost/logging');
+const errors = require('@tryghost/errors');
+const tpl = require('@tryghost/tpl');
+
+const {createTransactionalMigration, combineTransactionalMigrations} = require('./migrations');
+const {MIGRATION_USER} = require('./constants');
+
+const messages = {
+    permissionRoleActionError: 'Cannot {action} permission({permission}) with role({role}) - {resource} does not exist'
+};
+
+async function addPermissionHelper(connection, config) {
+    const existingPermission = await connection('permissions').where({
+        name: config.name,
+        action_type: config.action,
+        object_type: config.object
+    }).first();
+
+    if (existingPermission) {
+        logging.warn(`Permission for ${config.action}:${config.object} already added`);
+        return;
+    }
+
+    logging.info(`Adding permission for ${config.action}:${config.object}`);
+
+    const date = connection.raw('CURRENT_TIMESTAMP');
+
+    await connection('permissions').insert({
+        id: ObjectId().toHexString(),
+        name: config.name,
+        action_type: config.action,
+        object_type: config.object,
+        created_at: date,
+        created_by: MIGRATION_USER,
+        updated_at: date,
+        updated_by: MIGRATION_USER
+    });
+}
+
+async function removePermissionHelper(connection, config) {
+    const existingPermission = await connection('permissions').where({
+        name: config.name,
+        action_type: config.action,
+        object_type: config.object
+    }).first();
+
+    if (!existingPermission) {
+        logging.warn(`Permission for ${config.action}:${config.object} already removed`);
+        return;
+    }
+
+    logging.info(`Removing permission for ${config.action}:${config.object}`);
+
+    await connection('permissions').where({
+        action_type: config.action,
+        object_type: config.object
+    }).del();
+}
+
+/**
+ * Creates a migration which will add a permission to the database
+ *
+ * @param {Object} config
+ * @param {string} config.name - The name of the permission
+ * @param {string} config.action - The action_type of the permission
+ * @param {string} config.object - The object_type of the permission
+ *
+ * @returns {Migration}
+ */
+function addPermission(config) {
+    return createTransactionalMigration(
+        async function up(connection) {
+            await addPermissionHelper(connection, config);
+        },
+        async function down(connection) {
+            await removePermissionHelper(connection, config);
+        }
+    );
+}
+
+/**
+ * Creates a migration which will remove a permission from the database
+ *
+ * @param {Object} config
+ * @param {string} config.name - The name of the permission
+ * @param {string} config.action - The action_type of the permission
+ * @param {string} config.object - The object_type of the permission
+ *
+ * @returns {Migration}
+ */
+function removePermission(config) {
+    return createTransactionalMigration(
+        async function up(connection) {
+            await removePermissionHelper(connection, config);
+        },
+        async function down(connection) {
+            await addPermissionHelper(connection, config);
+        }
+    );
+}
+
+async function addPermissionToRoleHelper(connection, config) {
+    const permission = await connection('permissions').where({
+        name: config.permission
+    }).first();
+
+    if (!permission) {
+        throw new errors.InternalServerError({
+            message: tpl(messages.permissionRoleActionError, {
+                action: 'add',
+                permission: config.permission,
+                role: config.role,
+                resource: 'permission'
+            })
+        });
+    }
+
+    const role = await connection('roles').where({
+        name: config.role
+    }).first();
+
+    if (!role) {
+        throw new errors.InternalServerError({
+            message: tpl(messages.permissionRoleActionError, {
+                action: 'add',
+                permission: config.permission,
+                role: config.role,
+                resource: 'role'
+            })
+        });
+    }
+
+    const existingRelation = await connection('permissions_roles').where({
+        permission_id: permission.id,
+        role_id: role.id
+    }).first();
+
+    if (existingRelation) {
+        logging.warn(`Adding permission(${config.permission}) to role(${config.role}) - already exists`);
+        return;
+    }
+
+    logging.info(`Adding permission(${config.permission}) to role(${config.role})`);
+    await connection('permissions_roles').insert({
+        id: ObjectId().toHexString(),
+        permission_id: permission.id,
+        role_id: role.id
+    });
+}
+
+async function removePermissionFromRoleHelper(connection, config) {
+    const permission = await connection('permissions').where({
+        name: config.permission
+    }).first();
+
+    if (!permission) {
+        logging.warn(`Removing permission(${config.permission}) from role(${config.role}) - Permission not found.`);
+        return;
+    }
+
+    const role = await connection('roles').where({
+        name: config.role
+    }).first();
+
+    if (!role) {
+        logging.warn(`Removing permission(${config.permission}) from role(${config.role}) - Role not found.`);
+        return;
+    }
+
+    const existingRelation = await connection('permissions_roles').where({
+        permission_id: permission.id,
+        role_id: role.id
+    }).first();
+
+    if (!existingRelation) {
+        logging.warn(`Removing permission(${config.permission}) from role(${config.role}) - already removed`);
+        return;
+    }
+
+    logging.info(`Removing permission(${config.permission}) from role(${config.role})`);
+    await connection('permissions_roles').where({
+        permission_id: permission.id,
+        role_id: role.id
+    }).del();
+}
+
+/**
+ * Creates a migration which will link a permission to a role in the database
+ *
+ * @param {Object} config
+ * @param {string} config.permission - The name of the permission
+ * @param {string} config.role - The name of the role
+ *
+ * @returns {Migration}
+ */
+function addPermissionToRole(config) {
+    return createTransactionalMigration(
+        async function up(connection) {
+            await addPermissionToRoleHelper(connection, config);
+        },
+        async function down(connection) {
+            await removePermissionFromRoleHelper(connection, config);
+        }
+    );
+}
+
+/**
+ * Creates a migration which will remove the permission from roles
+ *
+ * @param {Object} config
+ * @param {string} config.permission - The name of the permission
+ * @param {string} config.role - The name of the role
+ *
+ * @returns {Migration}
+ */
+function removePermissionFromRole(config) {
+    return createTransactionalMigration(
+        async function up(connection) {
+            await removePermissionFromRoleHelper(connection, config);
+        },
+        async function down(connection) {
+            await addPermissionToRoleHelper(connection, config);
+        }
+    );
+}
+
+/**
+ * Creates a migration which will add a permission to the database, and then link it to roles
+ *
+ * @param {Object} config
+ * @param {string} config.name - The name of the permission
+ * @param {string} config.action - The action_type of the permission
+ * @param {string} config.object - The object_type of the permission
+ *
+ * @param {string[]} roles - A list of role names
+ *
+ * @returns {Migration}
+ */
+function addPermissionWithRoles(config, roles) {
+    return combineTransactionalMigrations(
+        addPermission(config),
+        ...roles.map((role => addPermissionToRole({permission: config.name, role})))
+    );
+}
+
+/**
+ * Creates a migration which will remove permissions from roles, and then remove the permission
+ *
+ * @param {Object} config
+ * @param {string} config.name - The name of the permission
+ * @param {string} config.action - The action_type of the permission
+ * @param {string} config.object - The object_type of the permission
+ *
+ * @param {string[]} roles - A list of role names
+ *
+ * @returns {Migration}
+ */
+function createRemovePermissionMigration(config, roles) {
+    return combineTransactionalMigrations(
+        ...roles.map((role => removePermissionFromRole({permission: config.name, role}))),
+        removePermission(config)
+    );
+}
+
+module.exports = {
+    addPermission,
+    addPermissionToRole,
+    addPermissionWithRoles,
+    createRemovePermissionMigration
+};
+
+/**
+ * @typedef {Object} TransactionalMigrationFunctionOptions
+ *
+ * @prop {import('knex').Knex} transacting
+ */
+
+/**
+ * @typedef {(options: TransactionalMigrationFunctionOptions) => Promise<void>} TransactionalMigrationFunction
+ */
+
+/**
+ * @typedef {Object} Migration
+ *
+ * @prop {Object} config
+ * @prop {boolean} config.transaction
+ *
+ * @prop {TransactionalMigrationFunction} up
+ * @prop {TransactionalMigrationFunction} down
+ */

package/core/server/data/migrations/utils/schema.js

@@ -0,0 +1,158 @@
+const logging = require('@tryghost/logging');
+const {commands} = require('../../schema');
+const DatabaseInfo = require('@tryghost/database-info');
+
+const {createNonTransactionalMigration, createTransactionalMigration} = require('./migrations');
+
+/**
+ * @param {string} table
+ * @param {string} column
+ * @param {Object} columnDefinition
+ *
+ * @returns {Migration}
+ */
+function createAddColumnMigration(table, column, columnDefinition) {
+    return createNonTransactionalMigration(
+        // up
+        commands.createColumnMigration({
+            table,
+            column,
+            dbIsInCorrectState: hasColumn => hasColumn === true,
+            operation: commands.addColumn,
+            operationVerb: 'Adding',
+            columnDefinition
+        }),
+        // down
+        commands.createColumnMigration({
+            table,
+            column,
+            dbIsInCorrectState: hasColumn => hasColumn === false,
+            operation: commands.dropColumn,
+            operationVerb: 'Removing',
+            columnDefinition
+        })
+    );
+}
+
+/**
+ * @param {string} table
+ * @param {string} column
+ * @param {Object} columnDefinition
+ *
+ * @returns {Migration}
+ */
+function createDropColumnMigration(table, column, columnDefinition) {
+    return createNonTransactionalMigration(
+        // up
+        commands.createColumnMigration({
+            table,
+            column,
+            dbIsInCorrectState: hasColumn => hasColumn === false,
+            operation: commands.dropColumn,
+            operationVerb: 'Removing'
+        }),
+        // down
+        commands.createColumnMigration({
+            table,
+            column,
+            dbIsInCorrectState: hasColumn => hasColumn === true,
+            operation: commands.addColumn,
+            operationVerb: 'Adding',
+            columnDefinition
+        })
+    );
+}
+
+/**
+ * @param {string} table
+ * @param {string} column
+ * @param {Object} options
+ * @param {boolean} options.disableForeignKeyChecks Disable foreign key checks for the down operation (when dropping nullable)
+ * @returns {Migration}
+ */
+function createSetNullableMigration(table, column, options = {}) {
+    return createTransactionalMigration(
+        async function up(knex) {
+            logging.info(`Setting nullable: ${table}.${column}`);
+            await commands.setNullable(table, column, knex);
+        },
+        async function down(knex) {
+            if (DatabaseInfo.isSQLite(knex)) {
+                options.disableForeignKeyChecks = false;
+            }
+            logging.info(`Dropping nullable:  ${table}.${column}${options.disableForeignKeyChecks ? ' with foreign keys disabled' : ''}`);
+            if (options.disableForeignKeyChecks) {
+                await knex.raw('SET FOREIGN_KEY_CHECKS=0;').transacting(knex);
+            }
+
+            try {
+                await commands.dropNullable(table, column, knex);
+            } finally {
+                if (options.disableForeignKeyChecks) {
+                    await knex.raw('SET FOREIGN_KEY_CHECKS=1;').transacting(knex);
+                }
+            }            
+        }
+    );
+}
+
+/**
+ * @param {string} table
+ * @param {string} column
+ * @param {Object} options
+ * @param {boolean} options.disableForeignKeyChecks Disable foreign key checks for the up operation (when dropping nullable)
+ * @returns {Migration}
+ */
+function createDropNullableMigration(table, column, options = {}) {
+    return createTransactionalMigration(
+        async function up(knex) {
+            if (DatabaseInfo.isSQLite(knex)) {
+                options.disableForeignKeyChecks = false;
+            }
+            logging.info(`Dropping nullable: ${table}.${column}${options.disableForeignKeyChecks ? ' with foreign keys disabled' : ''}`);
+
+            if (options.disableForeignKeyChecks) {
+                await knex.raw('SET FOREIGN_KEY_CHECKS=0;').transacting(knex);
+            }
+
+            try {
+                await commands.dropNullable(table, column, knex);
+            } finally {
+                if (options.disableForeignKeyChecks) {
+                    await knex.raw('SET FOREIGN_KEY_CHECKS=1;').transacting(knex);
+                }
+            }
+        },
+        async function down(knex) {
+            logging.info(`Setting nullable: ${table}.${column}`);
+            await commands.setNullable(table, column, knex);
+        }
+    );
+}
+
+module.exports = {
+    createAddColumnMigration,
+    createDropColumnMigration,
+    createSetNullableMigration,
+    createDropNullableMigration
+};
+
+/**
+ * @typedef {Object} TransactionalMigrationFunctionOptions
+ *
+ * @prop {import('knex').Knex} transacting
+ */
+
+/**
+ * @typedef {(options: TransactionalMigrationFunctionOptions) => Promise<void>} TransactionalMigrationFunction
+ */
+
+/**
+ * @typedef {Object} Migration
+ *
+ * @prop {Object} config
+ * @prop {boolean} config.transaction
+ *
+ * @prop {TransactionalMigrationFunction} up
+ * @prop {TransactionalMigrationFunction} down
+ */

package/core/server/data/migrations/utils/settings.js

@@ -0,0 +1,59 @@
+const ObjectId = require('bson-objectid').default;
+const logging = require('@tryghost/logging');
+
+const {createTransactionalMigration} = require('./migrations');
+const {MIGRATION_USER} = require('./constants');
+
+/**
+ * Creates a migration which will insert a new setting in settings table
+ * @param {object} settingSpec - setting key, value, group and type
+ *
+ * @returns {Object} migration object returning config/up/down properties
+ */
+function addSetting({key, value, type, group}) {
+    return createTransactionalMigration(
+        async function up(connection) {
+            const settingExists = await connection('settings')
+                .where('key', '=', key)
+                .first();
+            if (settingExists) {
+                logging.warn(`Skipping adding setting: ${key} - setting already exists`);
+                return;
+            }
+
+            logging.info(`Adding setting: ${key}`);
+            const now = connection.raw('CURRENT_TIMESTAMP');
+
+            return connection('settings')
+                .insert({
+                    id: ObjectId().toHexString(),
+                    key,
+                    value,
+                    group,
+                    type,
+                    created_at: now,
+                    created_by: MIGRATION_USER,
+                    updated_at: now,
+                    updated_by: MIGRATION_USER
+                });
+        },
+        async function down(connection) {
+            const settingExists = await connection('settings')
+                .where('key', '=', key)
+                .first();
+            if (!settingExists) {
+                logging.warn(`Skipping dropping setting: ${key} - setting does not exist`);
+                return;
+            }
+
+            logging.info(`Dropping setting: ${key}`);
+            return connection('settings')
+                .where('key', '=', key)
+                .del();
+        }
+    );
+}
+
+module.exports = {
+    addSetting
+};

package/core/server/data/migrations/utils/tables.js

@@ -0,0 +1,94 @@
+const logging = require('@tryghost/logging');
+const {commands} = require('../../schema');
+const {createIrreversibleMigration, createNonTransactionalMigration} = require('./migrations');
+
+/**
+ * Creates a migrations which will add a new table from schema.js to the database
+ * @param {string} name - table name
+ * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration,
+ * this parameter MUST be present, otherwise @daniellockyer will hunt you down
+ *
+ * @returns {Object} migration object returning config/up/down properties
+ */
+function addTable(name, tableSpec) {
+    return createNonTransactionalMigration(
+        async function up(connection) {
+            const tableExists = await connection.schema.hasTable(name);
+            if (tableExists) {
+                logging.warn(`Skipping adding table: ${name} - table already exists`);
+                return;
+            }
+
+            logging.info(`Adding table: ${name}`);
+            return commands.createTable(name, connection, tableSpec);
+        },
+        async function down(connection) {
+            const tableExists = await connection.schema.hasTable(name);
+            if (!tableExists) {
+                logging.warn(`Skipping dropping table: ${name} - table does not exist`);
+                return;
+            }
+
+            logging.info(`Dropping table: ${name}`);
+            return commands.deleteTable(name, connection);
+        }
+    );
+}
+
+/**
+ * Creates migration which will drop a table
+ *
+ * @param {[string]} names  - names of the tables to drop
+ */
+function dropTables(names) {
+    return createIrreversibleMigration(
+        async function up(connection) {
+            for (const name of names) {
+                const exists = await connection.schema.hasTable(name);
+
+                if (!exists) {
+                    logging.warn(`Skipping dropping table: ${name} - table does not exist`);
+                } else {
+                    logging.info(`Dropping table: ${name}`);
+                    await commands.deleteTable(name, connection);
+                }
+            }
+        }
+    );
+}
+
+/**
+ * Creates a migration which will drop an existing table and then re-add a new table based on provided spec
+ * @param {string} name - table name
+ * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration,
+ * this parameter MUST be present, otherwise @daniellockyer will hunt you down
+ *
+ * @returns {Object} migration object returning config/up/down properties
+ */
+function recreateTable(name, tableSpec) {
+    return createNonTransactionalMigration(
+        async function up(connection) {
+            const exists = await connection.schema.hasTable(name);
+
+            if (!exists) {
+                logging.warn(`Skipping dropping table: ${name} - table does not exist`);
+            } else {
+                logging.info(`Dropping table: ${name}`);
+                await commands.deleteTable(name, connection);
+                logging.info(`Re-adding table: ${name}`);
+                await commands.createTable(name, connection, tableSpec);
+            }
+        },
+        async function down() {
+            // noop: we cannot go back to old table schema
+            logging.warn(`Ignoring rollback for table recreate: ${name}`);
+            return Promise.resolve();
+        }
+    );
+}
+
+module.exports = {
+    addTable,
+    dropTables,
+    recreateTable
+};

package/core/server/data/migrations/versions/1.25/01-final-v1.js

@@ -0,0 +1,2 @@
+const {createFinalMigration} = require('../../utils');
+module.exports = createFinalMigration(1);

package/core/server/data/migrations/versions/1.25/02-noop.js

@@ -0,0 +1,6 @@
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up() {},
+    async function down() {}
+);

package/core/server/data/migrations/versions/2.37/01-final-v2.js

@@ -0,0 +1,2 @@
+const {createFinalMigration} = require('../../utils');
+module.exports = createFinalMigration(2);

package/core/server/data/migrations/versions/3.41/01-final-v3.js

@@ -0,0 +1,2 @@
+const {createFinalMigration} = require('../../utils');
+module.exports = createFinalMigration(3);

package/core/server/data/migrations/versions/4.0/22-solve-orphaned-webhooks.js

@@ -1,13 +1,7 @@
 const {createIrreversibleMigration} = require('../../utils');
 const logging = require('@tryghost/logging');
 const ObjectID = require('bson-objectid');
-const crypto = require('crypto');
-
-// createSecret is copied from core/server/models/api-key.js
-const createSecret = (type) => {
-    const bytes = type === 'content' ? 13 : 32;
-    return crypto.randomBytes(bytes).toString('hex');
-};
+const security = require('@tryghost/security');
 
 module.exports = createIrreversibleMigration(
     async function up(knex) {
@@ -54,7 +48,7 @@ module.exports = createIrreversibleMigration(
         const contentKey = {
             id: ObjectID().toHexString(),
             type: 'content',
-            secret: createSecret('content'),
+            secret: security.secret.create('content'),
             role_id: null,
             integration_id: integration.id,
             created_at: now,
@@ -67,7 +61,7 @@ module.exports = createIrreversibleMigration(
         const adminKey = {
             id: ObjectID().toHexString(),
             type: 'admin',
-            secret: createSecret('admin'),
+            secret: security.secret.create('admin'),
             role_id: role.id,
             integration_id: integration.id,
             created_at: now,

package/core/server/data/migrations/versions/4.0/23-regenerate-posts-html.js

@@ -1,7 +1,7 @@
 const logging = require('@tryghost/logging');
 const {createIrreversibleMigration} = require('../../utils');
 const mobiledocLib = require('../../../../lib/mobiledoc');
-const htmlToText = require('html-to-text');
+const htmlToPlaintext = require('../../../../../shared/html-to-plaintext');
 
 module.exports = createIrreversibleMigration(async (knex) => {
     logging.info('Starting re-generation of posts html.');
@@ -45,17 +45,8 @@ module.exports = createIrreversibleMigration(async (knex) => {
                 html: html
             };
 
-            // NOTE: block comes straight from the Post model
-            // https://github.com/TryGhost/Ghost/blob/4.0.0-alpha.2/core/server/models/post.js#L484
             if (html !== post.html || !post.plaintext) {
-                const plaintext = htmlToText.fromString(html, {
-                    wordwrap: 80,
-                    ignoreImage: true,
-                    hideLinkHrefIfSameAsText: true,
-                    preserveNewlines: true,
-                    returnDomByDefault: true,
-                    uppercaseHeadings: false
-                });
+                const plaintext = htmlToPlaintext.excerpt(html);
 
                 if (plaintext !== post.plaintext) {
                     updatedAttrs.plaintext = plaintext;

package/core/server/data/migrations/versions/4.11/02-add-email-verification-required-setting.js

@@ -1,6 +1,6 @@
 const ObjectID = require('bson-objectid');
 const logging = require('@tryghost/logging');
-const {createTransactionalMigration} = require('../../utils.js');
+const {createTransactionalMigration} = require('../../utils');
 
 const MIGRATION_USER = 1;