ghost 4.47.4 → 5.0.1

package/core/server/data/importer/importers/data/stripe-products.js

@@ -0,0 +1,61 @@
+const _ = require('lodash');
+const debug = require('@tryghost/debug')('importer:stripeproducts');
+const BaseImporter = require('./base');
+const models = require('../../../../models');
+
+class StripeProductsImporter extends BaseImporter {
+    constructor(allDataFromFile) {
+        super(allDataFromFile, {
+            modelName: 'StripeProduct',
+            dataKeyToImport: 'stripe_products',
+            requiredImportedData: ['products'],
+            requiredExistingData: ['products']
+        });
+    }
+
+    fetchExisting(modelOptions) {
+        return models.StripeProduct.findAll(_.merge({columns: ['id', 'stripe_product_id']}, modelOptions))
+            .then((existingData) => {
+                this.existingData = existingData.toJSON();
+            });
+    }
+
+    mapImportedData(originalObject, importedObject) {
+        return {
+            id: importedObject.id,
+            originalId: this.originalIdMap[importedObject.id],
+            stripe_product_id: originalObject.stripe_product_id
+        };
+    }
+
+    replaceIdentifiers() {
+        debug('replaceIdentifiers');
+
+        // map product_id -> product.id
+        let invalidProducts = [];
+        _.each(this.dataToImport, (objectInFile) => {
+            const importedObject = _.find(this.requiredImportedData.products, {originalId: objectInFile.product_id});
+            // CASE: we've imported the product and need to map the ID
+            if (importedObject) {
+                debug(`replaced product_id ${objectInFile.product_id} with ${importedObject.id}`);
+                objectInFile.product_id = importedObject.id;
+                return;
+            }
+            const existingObject = _.find(this.requiredExistingData.products, {id: objectInFile.product_id});
+            // CASE: the product exists in the db already
+            if (existingObject) {
+                return;
+            }
+            // CASE: we don't know what product this is for
+            debug(`ignoring stripe product ${objectInFile.stripe_product_id}`);
+            invalidProducts.push(objectInFile.id);
+        });
+        // ignore Stripe products without Ghost products
+        debug(`ignoring ${invalidProducts.length} products`);
+        this.dataToImport = this.dataToImport.filter(item => !invalidProducts.includes(item.id));
+
+        return super.replaceIdentifiers();
+    }
+}
+
+module.exports = StripeProductsImporter;

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

@@ -0,0 +1,3 @@
+module.exports = {
+    MIGRATION_USER: 1
+};

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

@@ -0,0 +1,10 @@
+module.exports = {
+    ...require('./migrations'),
+    ...require('./permissions'),
+    ...require('./schema'),
+    ...require('./settings'),
+    ...require('./tables'),
+    meta: {
+        MIGRATION_USER: require('./constants').MIGRATION_USER
+    }
+};

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

@@ -0,0 +1,156 @@
+const errors = require('@tryghost/errors');
+
+/**
+ * @param {(connection: import('knex').Knex) => Promise<void>} up
+ * @param {(connection: import('knex').Knex) => Promise<void>} down
+ *
+ * @returns {Migration}
+ */
+function createNonTransactionalMigration(up, down) {
+    return {
+        config: {
+            transaction: false
+        },
+        async up(config) {
+            await up(config.connection);
+        },
+        async down(config) {
+            await down(config.connection);
+        }
+    };
+}
+
+/**
+ * @param {(connection: import('knex').Knex) => Promise<void>} up
+ *
+ * @returns {Migration}
+ */
+function createIrreversibleMigration(up) {
+    return {
+        config: {
+            irreversible: true
+        },
+        async up(config) {
+            await up(config.connection);
+        },
+        async down() {
+            return Promise.reject();
+        }
+    };
+}
+
+/**
+ * @param {(connection: import('knex').Knex) => Promise<void>} up
+ * @param {(connection: import('knex').Knex) => Promise<void>} down
+ *
+ * @returns {Migration}
+ */
+function createTransactionalMigration(up, down) {
+    return {
+        config: {
+            transaction: true
+        },
+        async up(config) {
+            await up(config.transacting);
+        },
+        async down(config) {
+            await down(config.transacting);
+        }
+    };
+}
+
+/**
+ * @param {Migration[]} migrations
+ *
+ * @returns {Migration}
+ */
+function combineTransactionalMigrations(...migrations) {
+    return {
+        config: {
+            transaction: true
+        },
+        async up(config) {
+            for (const migration of migrations) {
+                await migration.up(config);
+            }
+        },
+        async down(config) {
+            // Down migrations must be run backwards!!
+            const reverseMigrations = migrations.slice().reverse();
+            for (const migration of reverseMigrations) {
+                await migration.down(config);
+            }
+        }
+    };
+}
+
+/**
+ * @param {Migration[]} migrations
+ *
+ * @returns {Migration}
+ */
+function combineNonTransactionalMigrations(...migrations) {
+    return {
+        config: {
+            transaction: false
+        },
+        async up(config) {
+            for (const migration of migrations) {
+                await migration.up(config);
+            }
+        },
+        async down(config) {
+            // Down migrations must be run backwards!!
+            const reverseMigrations = migrations.slice().reverse();
+            for (const migration of reverseMigrations) {
+                await migration.down(config);
+            }
+        }
+    };
+}
+
+/**
+ * @param {number} major
+ */
+function createFinalMigration(major) {
+    return createTransactionalMigration(
+        async function up() {
+            throw new errors.InternalServerError({
+                message: `Unable to run migrations`,
+                context: `You must be on the latest v${major}.x to update across major versions - https://ghost.org/docs/update/`,
+                help: `Run 'ghost update v${major}' to get the latest v${major}.x version, then run 'ghost update' to get to the latest.`
+            });
+        },
+        async function down() {
+            // no-op
+        });
+}
+
+module.exports = {
+    createFinalMigration,
+    createTransactionalMigration,
+    createNonTransactionalMigration,
+    createIrreversibleMigration,
+    combineTransactionalMigrations,
+    combineNonTransactionalMigrations
+};
+
+/**
+ * @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/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
+ */