ghost 4.37.0 → 4.39.0

package/core/server/data/migrations/versions/4.33/2022-01-14-11-51-add-default-free-tier.js

@@ -19,6 +19,9 @@ module.exports = createTransactionalMigration(
         const id = ObjectID().toHexString();
 
         logging.info(`Adding tier "${name}"`);
+
+        // `slugify(id) is used to ensure unique slug here, as existing tiers could be using any name including "Free"
+        // slugs are not used anywhere user-facing so the value is acceptable
         await knex('products')
             .insert({
                 id: id,

package/core/server/data/migrations/versions/4.33/2022-01-18-09-07-remove-duplicate-offer-redemptions.js

@@ -1,10 +1,10 @@
 const logging = require('@tryghost/logging');
-
 const {createTransactionalMigration} = require('../../utils');
+const DatabaseInfo = require('@tryghost/database-info');
 
 module.exports = createTransactionalMigration(
     async function up(knex) {
-        if (knex.client.config.client !== 'mysql') {
+        if (!DatabaseInfo.isMySQL(knex)) {
             logging.warn('Skipping cleanup of duplicate offer redemptions - database is not MySQL');
             return;
         }

package/core/server/data/migrations/versions/4.35/2022-02-01-11-48-update-email-recipient-filter-column-type.js

@@ -1,9 +1,10 @@
 const logging = require('@tryghost/logging');
 const {createNonTransactionalMigration} = require('../../utils');
+const DatabaseInfo = require('@tryghost/database-info');
 
 module.exports = createNonTransactionalMigration(
     async function up(knex) {
-        if (knex.client.config.client === 'sqlite3') {
+        if (DatabaseInfo.isSQLite(knex)) {
             logging.warn('Skipping migration for SQLite3');
             return;
         }

package/core/server/data/migrations/versions/4.35/2022-02-01-12-03-update-recipient-filter-column-type.js

@@ -1,9 +1,10 @@
 const logging = require('@tryghost/logging');
 const {createNonTransactionalMigration} = require('../../utils');
+const DatabaseInfo = require('@tryghost/database-info');
 
 module.exports = createNonTransactionalMigration(
     async function up(knex) {
-        if (knex.client.config.client === 'sqlite3') {
+        if (DatabaseInfo.isSQLite(knex)) {
             logging.warn('Skipping migration for SQLite3');
             return;
         }

package/core/server/data/migrations/versions/4.37/2022-02-21-09-53-backfill-members-last-seen-at-column.js

@@ -1,9 +1,10 @@
 const logging = require('@tryghost/logging');
 const {createTransactionalMigration} = require('../../utils');
+const DatabaseInfo = require('@tryghost/database-info');
 
 module.exports = createTransactionalMigration(
     async function up(knex) {
-        if (knex.client.config.client === 'sqlite3') {
+        if (DatabaseInfo.isSQLite(knex)) {
             logging.warn('Skipping migration for SQLite3');
             return;
         }
@@ -21,7 +22,7 @@ module.exports = createTransactionalMigration(
         `);
     },
     async function down(knex) {
-        if (knex.client.config.client === 'sqlite3') {
+        if (DatabaseInfo.isSQLite(knex)) {
             logging.warn('Skipping migration for SQLite3');
             return;
         }

package/core/server/data/migrations/versions/4.38/2022-03-01-08-46-add-visibility-to-tiers.js

@@ -0,0 +1,11 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('products', 'visible', {
+    type: 'boolean',
+    nullable: false,
+    defaultTo: false
+});
+
+module.exports.up = async () => {
+    // noop - column will be replaced with `visibility` instead
+};

package/core/server/data/migrations/versions/4.38/2022-03-03-16-12-add-visibility-to-tiers.js

@@ -0,0 +1,8 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('products', 'visibility', {
+    type: 'string',
+    maxlength: 50,
+    nullable: false,
+    defaultTo: 'none'
+});

package/core/server/data/migrations/versions/4.38/2022-03-03-16-17-drop-tiers-visible-column.js

@@ -0,0 +1,7 @@
+const {createDropColumnMigration} = require('../../utils');
+
+module.exports = createDropColumnMigration('products', 'visible', {});
+
+module.exports.down = async () => {
+    // noop - column was replaced by `visibility` instead
+};

package/core/server/data/migrations/versions/4.39/2022-03-07-10-57-update-free-products-visibility-column.js

@@ -0,0 +1,66 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const portalPlanSetting = await knex('settings').select('value').where('key', 'portal_plans').first();
+
+        if (!portalPlanSetting) {
+            logging.warn('Could not find portal_plans setting - skipping migration');
+            return;
+        }
+
+        try {
+            const settingData = JSON.parse(portalPlanSetting.value);
+
+            if (!settingData.includes('free')) {
+                logging.warn(`portal_plans does not include "free" - skipping migration`);
+                return;
+            }
+
+            logging.info(`Updating free products to visible`);
+            await knex('products').update('visibility', 'public').where('type', 'free');
+        } catch (err) {
+            logging.error(err);
+            logging.warn('portal_plans setting is invalid - skipping migration');
+            return;
+        }
+    },
+    async function down(knex) {
+        const freeTier = await knex('products').select('id').where('type', 'free').first();
+        const portalPlanSetting = await knex('settings').select('value').where('key', 'portal_plans').first();
+
+        if (!freeTier) {
+            logging.info('Free tier is not visible, not updating portal_plans');
+            return;
+        }
+
+        if (!portalPlanSetting) {
+            logging.warn('Could not find portal_plans setting - skipping migration');
+            return;
+        }
+
+        try {
+            const existingSettingData = JSON.parse(portalPlanSetting.value);
+            let settingData;
+
+            if (freeTier.visibility === 'public') {
+                if (existingSettingData.includes('free')) {
+                    logging.info('portal_plans setting already contains "free" - skipping update');
+                    return;
+                } else {
+                    settingData = JSON.stringify(existingSettingData.concat('free'));
+                }
+            } else {
+                settingData = JSON.stringify(existingSettingData.filter(value => value !== 'free'));
+            }
+
+            logging.info(`Updating portal_plans to ${settingData}`);
+            await knex('settings').update('value', settingData).where('key', 'portal_plans');
+        } catch (err) {
+            logging.error(err);
+            logging.warn('portal_plans setting is invalid - skipping migration');
+            return;
+        }
+    }
+);

package/core/server/data/migrations/versions/4.39/2022-03-07-10-57-update-products-visibility-column.js

@@ -0,0 +1,36 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const portalProductSetting = await knex('settings').select('value').where('key', 'portal_products').first();
+
+        if (!portalProductSetting) {
+            logging.warn('Could not find portal_products setting - skipping migration');
+            return;
+        }
+
+        try {
+            const settingData = JSON.parse(portalProductSetting.value);
+
+            if (settingData.length === 0) {
+                logging.warn(`portal_product is empty, skipping migrations`);
+                return;
+            }
+
+            logging.info(`Updating ${settingData.length} products to visible, ${settingData}`);
+            await knex('products').update('visibility', 'public').whereIn('id', settingData);
+        } catch (err) {
+            logging.warn('portal_products setting is invalid - skipping migration');
+            return;
+        }
+    },
+    async function down(knex) {
+        const visibleTiers = await knex('products').select('id').where('visibility', 'public');
+
+        const settingData = JSON.stringify(visibleTiers.map(obj => obj.id));
+
+        logging.info(`Updating portal_products to ${settingData}`);
+        await knex('settings').update('value', settingData).where('key', 'portal_products');
+    }
+);

package/core/server/data/schema/clients/index.js

@@ -3,5 +3,5 @@ const mysql = require('./mysql');
 
 module.exports = {
     sqlite3: sqlite3,
-    mysql: mysql
+    mysql2: mysql
 };

package/core/server/data/schema/clients/mysql.js

@@ -1,8 +1,8 @@
 const _ = require('lodash');
 const db = require('../../../data/db');
 
-const doRawAndFlatten = function doRaw(query, transaction, flattenFn) {
-    return (transaction || db.knex).raw(query).then(function (response) {
+const doRawAndFlatten = function doRaw(query, transaction = db.knex, flattenFn) {
+    return transaction.raw(query).then(function (response) {
         return _.flatten(flattenFn(response));
     });
 };
@@ -31,8 +31,8 @@ const getColumns = function getColumns(table, transaction) {
 // a wrong datatype in schema.js some installations using mysql could have been created using the
 // data type text instead of mediumtext.
 // For details see: https://github.com/TryGhost/Ghost/issues/1947
-const checkPostTable = function checkPostTable(transaction) {
-    return (transaction || db.knex).raw('SHOW FIELDS FROM posts where Field ="html" OR Field = "markdown"').then(function (response) {
+const checkPostTable = function checkPostTable(transaction = db.knex) {
+    return transaction.raw('SHOW FIELDS FROM posts where Field ="html" OR Field = "markdown"').then(function (response) {
         return _.flatten(_.map(response[0], function (entry) {
             if (entry.Type.toLowerCase() !== 'mediumtext') {
                 return (transaction || db.knex).raw('ALTER TABLE posts MODIFY ' + entry.Field + ' MEDIUMTEXT');

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

@@ -4,6 +4,7 @@ const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 const db = require('../db');
+const DatabaseInfo = require('@tryghost/database-info');
 const schema = require('./schema');
 const clients = require('./clients');
 
@@ -58,14 +59,14 @@ function addTableColumn(tableName, table, columnName, columnSpec = schema[tableN
     }
 }
 
-function addColumn(tableName, column, transaction, columnSpec) {
-    return (transaction || db.knex).schema.table(tableName, function (table) {
+function addColumn(tableName, column, transaction = db.knex, columnSpec) {
+    return transaction.schema.table(tableName, function (table) {
         addTableColumn(tableName, table, column, columnSpec);
     });
 }
 
-function dropColumn(tableName, column, transaction) {
-    return (transaction || db.knex).schema.table(tableName, function (table) {
+function dropColumn(tableName, column, transaction = db.knex) {
+    return transaction.schema.table(tableName, function (table) {
         table.dropColumn(column);
     });
 }
@@ -77,11 +78,11 @@ function dropColumn(tableName, column, transaction) {
  * @param {string|[string]} columns - column(s) to form unique constraint with
  * @param {import('knex')} transaction - connection object containing knex reference
  */
-async function addUnique(tableName, columns, transaction) {
+async function addUnique(tableName, columns, transaction = db.knex) {
     try {
         logging.info(`Adding unique constraint for: ${columns} in table ${tableName}`);
 
-        return await (transaction || db.knex).schema.table(tableName, function (table) {
+        return await transaction.schema.table(tableName, function (table) {
             table.unique(columns);
         });
     } catch (err) {
@@ -104,11 +105,11 @@ async function addUnique(tableName, columns, transaction) {
  * @param {string|[string]} columns - column(s) unique constraint was formed
  * @param {import('knex')} transaction - connection object containing knex reference
  */
-async function dropUnique(tableName, columns, transaction) {
+async function dropUnique(tableName, columns, transaction = db.knex) {
     try {
         logging.info(`Dropping unique constraint for: ${columns} in table: ${tableName}`);
 
-        return await (transaction || db.knex).schema.table(tableName, function (table) {
+        return await transaction.schema.table(tableName, function (table) {
             table.dropUnique(columns);
         });
     } catch (err) {
@@ -134,17 +135,14 @@ async function dropUnique(tableName, columns, transaction) {
  * @param {string} configuration.toColumn - column of the table to point the foreign key to
  * @param {import('knex')} configuration.transaction - connection object containing knex reference
  */
-async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction}) {
-    const knex = (transaction || db.knex);
-    const client = knex.client.config.client;
-
-    if (client !== 'sqlite3') {
+async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction = db.knex}) {
+    if (!DatabaseInfo.isSQLite(transaction)) {
         throw new errors.InternalServerError({
             message: tpl(messages.hasForeignSQLite3)
         });
     }
 
-    const foreignKeys = await knex.raw(`PRAGMA foreign_key_list('${fromTable}');`);
+    const foreignKeys = await transaction.raw(`PRAGMA foreign_key_list('${fromTable}');`);
 
     const hasForeignKey = foreignKeys.some(foreignKey => foreignKey.table === toTable && foreignKey.from === fromColumn && foreignKey.to === toColumn);
 
@@ -162,9 +160,8 @@ async function hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, trans
  * @param {Boolean} configuration.cascadeDelete - adds the "on delete cascade" option if true
  * @param {import('knex')} configuration.transaction - connection object containing knex reference
  */
-async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDelete = false, transaction}) {
-    const isSQLite = db.knex.client.config.client === 'sqlite3';
-    if (isSQLite) {
+async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDelete = false, transaction = db.knex}) {
+    if (DatabaseInfo.isSQLite(transaction)) {
         const foreignKeyExists = await hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction});
         if (foreignKeyExists) {
             logging.warn(`Skipped adding foreign key from ${fromTable}.${fromColumn} to ${toTable}.${toColumn} - foreign key already exists`);
@@ -176,14 +173,14 @@ async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDele
 
         //disable and re-enable foreign key checks on sqlite because of https://github.com/knex/knex/issues/4155
         let foreignKeysEnabled;
-        if (isSQLite) {
+        if (DatabaseInfo.isSQLite(transaction)) {
             foreignKeysEnabled = await db.knex.raw('PRAGMA foreign_keys;');
             if (foreignKeysEnabled[0].foreign_keys) {
                 await db.knex.raw('PRAGMA foreign_keys = OFF;');
             }
         }
 
-        await (transaction || db.knex).schema.table(fromTable, function (table) {
+        await transaction.schema.table(fromTable, function (table) {
             if (cascadeDelete) {
                 table.foreign(fromColumn).references(`${toTable}.${toColumn}`).onDelete('CASCADE');
             } else {
@@ -191,13 +188,13 @@ async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDele
             }
         });
 
-        if (isSQLite) {
+        if (DatabaseInfo.isSQLite(transaction)) {
             if (foreignKeysEnabled[0].foreign_keys) {
                 await db.knex.raw('PRAGMA foreign_keys = ON;');
             }
         }
     } catch (err) {
-        if (err.code === 'ER_DUP_KEY') {
+        if (err.code === 'ER_DUP_KEY' || err.code === 'ER_FK_DUP_KEY' || err.code === 'ER_FK_DUP_NAME') {
             logging.warn(`Skipped adding foreign key from ${fromTable}.${fromColumn} to ${toTable}.${toColumn} - foreign key already exists`);
             return;
         }
@@ -215,9 +212,8 @@ async function addForeign({fromTable, fromColumn, toTable, toColumn, cascadeDele
  * @param {string} configuration.toColumn - column of the table to point the foreign key to
  * @param {import('knex')} configuration.transaction - connection object containing knex reference
  */
-async function dropForeign({fromTable, fromColumn, toTable, toColumn, transaction}) {
-    const isSQLite = db.knex.client.config.client === 'sqlite3';
-    if (isSQLite) {
+async function dropForeign({fromTable, fromColumn, toTable, toColumn, transaction = db.knex}) {
+    if (DatabaseInfo.isSQLite(transaction)) {
         const foreignKeyExists = await hasForeignSQLite({fromTable, fromColumn, toTable, toColumn, transaction});
         if (!foreignKeyExists) {
             logging.warn(`Skipped dropping foreign key from ${fromTable}.${fromColumn} to ${toTable}.${toColumn} - foreign key does not exist`);
@@ -229,18 +225,18 @@ async function dropForeign({fromTable, fromColumn, toTable, toColumn, transactio
 
         //disable and re-enable foreign key checks on sqlite because of https://github.com/knex/knex/issues/4155
         let foreignKeysEnabled;
-        if (isSQLite) {
+        if (DatabaseInfo.isSQLite(transaction)) {
             foreignKeysEnabled = await db.knex.raw('PRAGMA foreign_keys;');
             if (foreignKeysEnabled[0].foreign_keys) {
                 await db.knex.raw('PRAGMA foreign_keys = OFF;');
             }
         }
 
-        await (transaction || db.knex).schema.table(fromTable, function (table) {
+        await transaction.schema.table(fromTable, function (table) {
             table.dropForeign(fromColumn);
         });
 
-        if (isSQLite) {
+        if (DatabaseInfo.isSQLite(transaction)) {
             if (foreignKeysEnabled[0].foreign_keys) {
                 await db.knex.raw('PRAGMA foreign_keys = ON;');
             }
@@ -260,17 +256,14 @@ async function dropForeign({fromTable, fromColumn, toTable, toColumn, transactio
  * @param {string} tableName - name of the table to check primary key constraint on
  * @param {import('knex')} transaction - connection object containing knex reference
  */
-async function hasPrimaryKeySQLite(tableName, transaction) {
-    const knex = (transaction || db.knex);
-    const client = knex.client.config.client;
-
-    if (client !== 'sqlite3') {
+async function hasPrimaryKeySQLite(tableName, transaction = db.knex) {
+    if (!DatabaseInfo.isSQLite(transaction)){
         throw new errors.InternalServerError({
             message: tpl(messages.hasPrimaryKeySQLiteError)
         });
     }
 
-    const rawConstraints = await knex.raw(`PRAGMA index_list('${tableName}');`);
+    const rawConstraints = await transaction.raw(`PRAGMA index_list('${tableName}');`);
     const tablePrimaryKey = rawConstraints.find(c => c.origin === 'pk');
 
     return tablePrimaryKey;
@@ -283,9 +276,8 @@ async function hasPrimaryKeySQLite(tableName, transaction) {
  * @param {string|[string]} columns - column(s) to form primary key constraint with
  * @param {import('knex')} transaction - connection object containing knex reference
  */
-async function addPrimaryKey(tableName, columns, transaction) {
-    const isSQLite = db.knex.client.config.client === 'sqlite3';
-    if (isSQLite) {
+async function addPrimaryKey(tableName, columns, transaction = db.knex) {
+    if (DatabaseInfo.isSQLite(transaction)) {
         const primaryKeyExists = await hasPrimaryKeySQLite(tableName, transaction);
         if (primaryKeyExists) {
             logging.warn(`Primary key constraint for: ${columns} already exists for table: ${tableName}`);
@@ -294,7 +286,7 @@ async function addPrimaryKey(tableName, columns, transaction) {
     }
     try {
         logging.info(`Adding primary key constraint for: ${columns} in table ${tableName}`);
-        return await (transaction || db.knex).schema.table(tableName, function (table) {
+        return await transaction.schema.table(tableName, function (table) {
             table.primary(columns);
         });
     } catch (err) {
@@ -316,8 +308,8 @@ async function addPrimaryKey(tableName, columns, transaction) {
  * @param {import('knex').Transaction} transaction - connection to the DB
  * @param {Object} [tableSpec] - table schema to generate table with
  */
-function createTable(table, transaction, tableSpec = schema[table]) {
-    return (transaction || db.knex).schema.createTable(table, function (t) {
+function createTable(table, transaction = db.knex, tableSpec = schema[table]) {
+    return transaction.schema.createTable(table, function (t) {
         Object.keys(tableSpec)
             .filter(column => !(column.startsWith('@@')))
             .forEach(column => addTableColumn(table, t, column, tableSpec[column]));
@@ -331,12 +323,12 @@ function createTable(table, transaction, tableSpec = schema[table]) {
     });
 }
 
-function deleteTable(table, transaction) {
-    return (transaction || db.knex).schema.dropTableIfExists(table);
+function deleteTable(table, transaction = db.knex) {
+    return transaction.schema.dropTableIfExists(table);
 }
 
-function getTables(transaction) {
-    const client = (transaction || db.knex).client.config.client;
+function getTables(transaction = db.knex) {
+    const client = transaction.client.config.client;
 
     if (_.includes(_.keys(clients), client)) {
         return clients[client].getTables(transaction);
@@ -345,8 +337,8 @@ function getTables(transaction) {
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
 }
 
-function getIndexes(table, transaction) {
-    const client = (transaction || db.knex).client.config.client;
+function getIndexes(table, transaction = db.knex) {
+    const client = transaction.client.config.client;
 
     if (_.includes(_.keys(clients), client)) {
         return clients[client].getIndexes(table, transaction);
@@ -355,8 +347,8 @@ function getIndexes(table, transaction) {
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
 }
 
-function getColumns(table, transaction) {
-    const client = (transaction || db.knex).client.config.client;
+function getColumns(table, transaction = db.knex) {
+    const client = transaction.client.config.client;
 
     if (_.includes(_.keys(clients), client)) {
         return clients[client].getColumns(table);
@@ -365,10 +357,10 @@ function getColumns(table, transaction) {
     return Promise.reject(tpl(messages.noSupportForDatabase, {client: client}));
 }
 
-function checkTables(transaction) {
-    const client = (transaction || db.knex).client.config.client;
+function checkTables(transaction = db.knex) {
+    const client = transaction.client.config.client;
 
-    if (client === 'mysql') {
+    if (DatabaseInfo.isMySQL(transaction)) {
         return clients[client].checkPostTable();
     }
 }

package/core/server/data/schema/default-settings/default-settings.json

@@ -126,11 +126,11 @@
             "type": "string"
         },
         "navigation": {
-            "defaultValue": "[{\"label\":\"Home\",\"url\":\"/\"},{\"label\":\"About\",\"url\":\"/about/\"},{\"label\":\"Collection\",\"url\":\"/tag/getting-started/\"},{\"label\":\"Author\",\"url\":\"/author/ghost/\"},{\"label\":\"Portal\",\"url\":\"/portal/\"}]",
+            "defaultValue": "[{\"label\":\"Home\",\"url\":\"/\"},{\"label\":\"About\",\"url\":\"/about/\"}]",
             "type": "array"
         },
         "secondary_navigation": {
-            "defaultValue": "[{\"label\":\"Data & privacy\",\"url\":\"/privacy/\"},{\"label\":\"Contact\",\"url\":\"/contact/\"},{\"label\":\"Contribute →\",\"url\":\"/contribute/\"}]",
+            "defaultValue": "[{\"label\":\"Sign up\",\"url\":\"#/portal/\"}]",
             "type": "array"
         },
         "meta_title": {