ghost 6.57.1 → 6.58.0

package/core/server/data/seeders/importers/roles-users-importer.js

@@ -1,5 +1,5 @@
 const {faker} = require('@faker-js/faker');
-const TableImporter = require('./table-importer');
+const {TableImporter} = require('./table-importer');
 
 class RolesUsersImporter extends TableImporter {
     static table = 'roles_users';

package/core/server/data/seeders/importers/stripe-prices-importer.js

@@ -1,5 +1,5 @@
 const {faker} = require('@faker-js/faker');
-const TableImporter = require('./table-importer');
+const {TableImporter} = require('./table-importer');
 const {blogStartDate} = require('../utils/blog-info');
 
 const sixWeeksLater = new Date(blogStartDate);

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

@@ -1,5 +1,5 @@
 const {faker} = require('@faker-js/faker');
-const TableImporter = require('./table-importer');
+const {TableImporter} = require('./table-importer');
 const {blogStartDate} = require('../utils/blog-info');
 
 const sixWeeksLater = new Date(blogStartDate);

package/core/server/data/seeders/importers/table-importer.js

@@ -1,187 +1,188 @@
-const debug = require('@tryghost/debug')('TableImporter');
-const dateToDatabaseString = require('../utils/database-date');
-const path = require('path');
-const createCsvWriter = require('csv-writer').createObjectCsvWriter;
-const fs = require('fs');
-const {luck} = require('../utils/random');
-const os = require('os');
-const crypto = require('crypto');
-const logging = require('@tryghost/logging');
-const errors = require('@tryghost/errors');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableImporter = void 0;
+const debug_1 = __importDefault(require("@tryghost/debug"));
+const databaseDate = __importStar(require("../utils/database-date"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const papaparse_1 = __importDefault(require("papaparse"));
+const random_1 = require("../utils/random");
+const node_os_1 = __importDefault(require("node:os"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const debug = (0, debug_1.default)('TableImporter');
 class TableImporter {
-    /**
-     * @type {object|undefined} model Referenced model when generating data
-     */
+    name;
+    knex;
+    transaction;
+    /** Referenced model when generating data. */
     model;
-
-    /**
-     * @type {number|undefined} defaultQuantity Default number of records to import
-     */
+    /** Default number of records to import. */
     defaultQuantity;
-
-    /**
-     * Transaction and knex need to be separate since we're using the batchInsert helper
-     * @param {string} name Name of the table to be generated
-     * @param {import('knex/types').Knex} knex Database connection
-     * @param {import('knex/types').Knex.Transaction} transaction Transaction to be used for import
-     */
+    /** Transaction and knex stay separate because batchInsert needs both. */
     constructor(name, knex, transaction) {
         this.name = name;
         this.knex = knex;
         this.transaction = transaction;
     }
-
     fastFakeObjectId() {
         // It is important that IDs are generated for a timestamp < NOW (for email batch sending) and that
         // generating the ids is fast.
-        return `00000000` + crypto.randomBytes(8).toString('hex');
+        return `00000000` + node_crypto_1.default.randomBytes(8).toString('hex');
     }
-
-    async #generateData(amount = this.defaultQuantity) {
-        let data = [];
-
+    async #generateData(amount = this.defaultQuantity ?? 0) {
+        const data = [];
         for (let i = 0; i < amount; i++) {
             const model = await this.generate();
             if (model) {
                 data.push(model);
             }
         }
-
         return data;
     }
-
     async import(amount = this.defaultQuantity) {
         const generateNow = Date.now();
         const data = await this.#generateData(amount);
         debug(`${this.name} generated ${data.length} records in ${Date.now() - generateNow}ms`);
-
         if (data.length > 0) {
             await this.batchInsert(data);
         }
     }
-
-    /**
-     * @param {Array<Object>} models List of models to reference
-     * @param {Number|function} amount Number of records to import per model
-     */
-    async importForEach(models = [], amount) {
+    async importForEach(models = [], amount = 0) {
         const data = [];
-
-        debug (`Generating data for ${models.length} models x ${amount} for ${this.name}`);
+        debug(`Generating data for ${models.length} models x ${amount} for ${this.name}`);
         const now = Date.now();
         let settingReferenceModel = 0;
-
         for (const model of models) {
-            let s = Date.now();
+            const s = Date.now();
             this.setReferencedModel(model);
             settingReferenceModel += Date.now() - s;
-
             let currentAmount = (typeof amount === 'function') ? amount() : amount;
             if (!Number.isInteger(currentAmount)) {
-                currentAmount = Math.floor(currentAmount) + luck((currentAmount % 1) * 100);
+                currentAmount = Math.floor(currentAmount) + Number((0, random_1.luck)((currentAmount % 1) * 100));
             }
-
             const generatedData = await this.#generateData(currentAmount);
-            if (generatedData.length > 0) {
-                data.push(...generatedData);
+            for (const generatedModel of generatedData) {
+                data.push(generatedModel);
             }
         }
-
         debug(`${this.name} generated ${data.length} records in ${Date.now() - now}ms (${settingReferenceModel}ms setting reference model)`);
-
         if (data.length > 0) {
             await this.batchInsert(data);
         }
     }
-
     async batchInsert(data) {
         // Write to CSV file
-        const rootFolder = os.tmpdir();
-        const filePath = path.join(rootFolder, `${this.name}.csv`);
+        const rootFolder = node_os_1.default.tmpdir();
+        const filePath = node_path_1.default.join(rootFolder, `${this.name}.csv`);
         let now = Date.now();
-
         if (data.length > 5000 && !process.env.DISABLE_FAST_IMPORT) {
             try {
-                await fs.promises.unlink(filePath);
-            } catch (e) {
+                await node_fs_1.default.promises.unlink(filePath);
+            }
+            catch (e) {
                 // Ignore: file doesn't exist
             }
-
-            const csvWriter = createCsvWriter({
-                path: filePath,
-                header: Object.keys(data[0]).map((key) => {
-                    return {id: key, title: key};
-                })
-            });
-
+            const columns = Object.keys(data[0]);
             // Loop the data in chunks of 50.000 items
             const batchSize = 50000;
-
             // Otherwise we get a out of range error because csvWriter tries to create a string that is too long
             for (let i = 0; i < data.length; i += batchSize) {
                 const slicedData = data.slice(i, i + batchSize);
-
                 // Map data to what MySQL expects in the CSV for values like booleans, null and dates
-                for (let j = 0; j < slicedData.length; j++) {
-                    const obj = slicedData[j];
-
-                    for (const [key, value] of Object.entries(obj)) {
+                for (const obj of slicedData) {
+                    const mutableObj = obj;
+                    for (const [key, value] of Object.entries(mutableObj)) {
                         if (typeof value === 'boolean') {
-                            obj[key] = value ? 1 : 0;
-                        } else if (value instanceof Date) {
-                            obj[key] = dateToDatabaseString(value);
-                        } else if (value === null) {
-                            obj[key] = '\\N';
+                            mutableObj[key] = value ? 1 : 0;
+                        }
+                        else if (value instanceof Date) {
+                            mutableObj[key] = databaseDate.dateToDatabaseString(value);
+                        }
+                        else if (value === null) {
+                            mutableObj[key] = '\\N';
                         }
                     }
                 }
-                await csvWriter.writeRecords(slicedData);
+                const csv = papaparse_1.default.unparse(slicedData, {
+                    columns,
+                    header: i === 0,
+                    newline: '\n'
+                });
+                await node_fs_1.default.promises.appendFile(filePath, `${i === 0 ? '' : '\n'}${csv}`);
             }
-
             debug(`${this.name} saved CSV import file in ${Date.now() - now}ms`);
             now = Date.now();
-
             // Import from CSV file
             const [result] = await this.transaction.raw(`LOAD DATA LOCAL INFILE '${filePath}' INTO TABLE \`${this.name}\` FIELDS TERMINATED BY ',' ENCLOSED BY '"' IGNORE 1 LINES (${Object.keys(data[0]).map(d => '`' + d + '`').join(',')});`);
             if (result.affectedRows !== data.length) {
                 if (Math.abs(result.affectedRows - data.length) > 0.01 * data.length) {
-                    throw new errors.InternalServerError({
+                    throw new errors_1.default.InternalServerError({
                         message: `CSV import failed: expected ${data.length} imported rows, got ${result.affectedRows}`
                     });
                 }
-                logging.warn(`CSV import warning: expected ${data.length} imported rows, got ${result.affectedRows}.`);
+                logging_1.default.warn(`CSV import warning: expected ${data.length} imported rows, got ${result.affectedRows}.`);
             }
-        } else {
+        }
+        else {
             await this.knex.batchInsert(this.name, data).transacting(this.transaction);
         }
-
         debug(`${this.name} imported ${data.length} records in ${Date.now() - now}ms`);
     }
-
     /**
      * Finalise the imported data, e.g. adding summary records based on a table's dependents
      */
     async finalise() {
         // No-op by default
     }
-
     /**
      * Sets the model which newly generated data will reference
-     * @param {Object} model Model to reference when generating data
      */
     setReferencedModel(model) {
         this.model = model;
     }
-
     /**
      * Generates the data for a single model to be imported
-     * @returns {Object|null} Data to import, optional
      */
     generate() {
         // Should never be called
-        return false;
     }
 }
-
-module.exports = TableImporter;
+exports.TableImporter = TableImporter;

package/core/server/data/seeders/importers/tags-importer.js

@@ -1,7 +1,7 @@
 const {faker} = require('@faker-js/faker');
 const {slugify} = require('@tryghost/string');
-const TableImporter = require('./table-importer');
-const dateToDatabaseString = require('../utils/database-date');
+const {TableImporter} = require('./table-importer');
+const databaseDate = require('../utils/database-date');
 
 class TagsImporter extends TableImporter {
     static table = 'tags';
@@ -32,7 +32,7 @@ class TagsImporter extends TableImporter {
             name: name,
             slug: slugify(name),
             description: faker.lorem.sentence(),
-            created_at: dateToDatabaseString(faker.date.between({from: threeYearsAgo, to: twoYearsAgo}))
+            created_at: databaseDate.dateToDatabaseString(faker.date.between({from: threeYearsAgo, to: twoYearsAgo}))
         };
     }
 }

package/core/server/data/seeders/importers/users-importer.js

@@ -1,8 +1,8 @@
-const TableImporter = require('./table-importer');
+const {TableImporter} = require('./table-importer');
 const {faker} = require('@faker-js/faker');
 const {slugify} = require('@tryghost/string');
 const security = require('@tryghost/security');
-const dateToDatabaseString = require('../utils/database-date');
+const databaseDate = require('../utils/database-date');
 
 class UsersImporter extends TableImporter {
     static table = 'users';
@@ -24,7 +24,7 @@ class UsersImporter extends TableImporter {
             password: await security.password.hash(faker.color.human()),
             email: faker.internet.email({firstName, lastName}),
             profile_image: faker.image.avatar(),
-            created_at: dateToDatabaseString(faker.date.between({from: new Date(2016, 0), to: new Date()}))
+            created_at: databaseDate.dateToDatabaseString(faker.date.between({from: new Date(2016, 0), to: new Date()}))
         };
     }
 }

package/core/server/data/seeders/importers/web-mentions-importer.js

@@ -1,6 +1,6 @@
-const TableImporter = require('./table-importer');
+const {TableImporter} = require('./table-importer');
 const {faker} = require('@faker-js/faker');
-const dateToDatabaseString = require('../utils/database-date');
+const databaseDate = require('../utils/database-date');
 
 class WebMentionsImporter extends TableImporter {
     static table = 'mentions';
@@ -31,7 +31,7 @@ class WebMentionsImporter extends TableImporter {
             target: `${this.baseUrl}`,
             resource_id: null,
             resource_type: null,
-            created_at: dateToDatabaseString(faker.date.past()),
+            created_at: databaseDate.dateToDatabaseString(faker.date.past()),
             payload: JSON.stringify({}),
             deleted: 0,
             verified: 1

package/core/server/data/seeders/utils/database-date.js

@@ -1,32 +1,28 @@
-const {faker} = require('@faker-js/faker');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateToDatabaseString = dateToDatabaseString;
+exports.parse = parse;
+exports.randomBetween = randomBetween;
+const faker_1 = require("@faker-js/faker");
 const databaseDatePattern = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
-
 function dateToDatabaseString(date) {
     if (typeof date === 'string') {
         // SQLite fix when reusing other dates from the db
         return date;
     }
-    return date.toISOString().replace('Z','').replace('T', ' ');
+    return date.toISOString().replace('Z', '').replace('T', ' ');
 }
-
-dateToDatabaseString.parse = function parseDatabaseDate(date) {
+function parse(date) {
     if (date instanceof Date) {
         return new Date(date);
     }
-
     if (typeof date === 'string' && databaseDatePattern.test(date)) {
         return new Date(date.replace(' ', 'T') + 'Z');
     }
-
     return new Date(date);
-};
-
-dateToDatabaseString.randomBetween = function randomBetween(start, end) {
-    const earliest = dateToDatabaseString.parse(start);
-    const latest = dateToDatabaseString.parse(end);
-
-    return latest > earliest ? faker.date.between({from: earliest, to: latest}) : earliest;
-};
-
-module.exports = dateToDatabaseString;
+}
+function randomBetween(start, end) {
+    const earliest = parse(start);
+    const latest = parse(end);
+    return latest > earliest ? faker_1.faker.date.between({ from: earliest, to: latest }) : earliest;
+}

package/core/server/data/seeders/utils/json-importer.js

@@ -1,4 +1,4 @@
-const TableImporter = require('../importers/table-importer');
+const {TableImporter} = require('../importers/table-importer');
 
 class JsonImporter extends TableImporter {
     constructor(knex, transaction) {

package/core/server/data/seeders/utils/random.js

@@ -1,13 +1,14 @@
-const {faker} = require('@faker-js/faker');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luck = void 0;
+const faker_1 = require("@faker-js/faker");
 /**
  * Adds another degree of randomness into some decisions
- * @param {number} lowerThan Only this % of people will achieve this luck
- * @returns {boolean} Whether this person is lucky enough for the condition
+ * @param lowerThan Only this % of people will achieve this luck
+ * @returns Whether this person is lucky enough for the condition
  */
-const luck = lowerThan => faker.number.int({
+const luck = (lowerThan) => faker_1.faker.number.int({
     min: 1,
     max: 100
 }) <= lowerThan;
-
-module.exports = {luck};
+exports.luck = luck;

package/core/server/data/seeders/utils/topological-sort.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.topologicalSort = topologicalSort;
+const strict_1 = __importDefault(require("node:assert/strict"));
 /**
  * This sorting algorithm is used to make sure that dependent tables are imported after their dependencies.
  */
@@ -19,9 +23,7 @@ function topologicalSort(objects) {
             return;
         }
         const object = objectsByName.get(name);
-        if (!object) {
-            return;
-        }
+        (0, strict_1.default)(object, `Expected an object with name ${name}`);
         visited.add(name);
         for (const dependency of object.dependencies || []) {
             dfs(dependency);

package/core/server/data/tinybird/ARCHITECTURE.md

@@ -10,8 +10,7 @@ to provide real-time analytics.
 2. [MySQL Schema (Ghost Database)](#mysql-schema-ghost-database)
 3. [Tinybird Event Schema](#tinybird-event-schema)
 4. [Data Flow & Relationships](#data-flow--relationships)
-5. [API Endpoints](#api-endpoints)
-6. [Mock Data Considerations](#mock-data-considerations)
+5. [Mock Data Considerations](#mock-data-considerations)
 
 ## Overview
  Ghost's traffic analytics system has two data sources: MySQL and Tinybird

package/core/server/models/base/plugins/crud.js

@@ -2,7 +2,6 @@ const _ = require('lodash');
 const errors = require('@tryghost/errors');
 
 const tpl = require('@tryghost/tpl');
-const labs = require('../../../../shared/labs');
 
 const messages = {
     couldNotUnderstandRequest: 'Could not understand request.'
@@ -180,10 +179,6 @@ module.exports = function (Bookshelf) {
                 options.useBasicCount = unfilteredOptions.useBasicCount;
             }
 
-            if (labs.isSet('smarterCounts')) {
-                options.useSmartCount = true;
-            }
-
             if (skipPagination) {
                 applyManualPaginationWindow(itemCollection, options);
             }

package/core/server/models/index.js

@@ -17,6 +17,7 @@ const {CommentReport} = require('./comment-report');
 const {Comment} = require('./comment');
 const {CustomThemeSetting} = require('./custom-theme-setting');
 const {DonationPaymentEvent} = require('./donation-payment-event');
+const {MachinePaymentEvent} = require('./machine-payment-event');
 const {EmailBatch, EmailBatches} = require('./email-batch');
 const {EmailDesignSetting} = require('./email-design-setting');
 const {EmailRecipientFailure} = require('./email-recipient-failure');
@@ -99,6 +100,7 @@ exports.CommentReport = CommentReport;
 exports.Comment = Comment;
 exports.CustomThemeSetting = CustomThemeSetting;
 exports.DonationPaymentEvent = DonationPaymentEvent;
+exports.MachinePaymentEvent = MachinePaymentEvent;
 exports.EmailBatch = EmailBatch;
 exports.EmailBatches = EmailBatches;
 exports.EmailDesignSetting = EmailDesignSetting;

package/core/server/models/machine-payment-event.js

@@ -0,0 +1,18 @@
+const errors = require('@tryghost/errors');
+const ghostBookshelf = require('./base');
+
+const MachinePaymentEvent = ghostBookshelf.Model.extend({
+    tableName: 'machine_payment_events'
+}, {
+    async edit() {
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MachinePaymentEvent'});
+    },
+
+    async destroy() {
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MachinePaymentEvent'});
+    }
+});
+
+module.exports = {
+    MachinePaymentEvent: ghostBookshelf.model('MachinePaymentEvent', MachinePaymentEvent)
+};

package/core/server/models/member.js

@@ -1,8 +1,11 @@
 const ghostBookshelf = require('./base');
 const crypto = require('crypto');
 const _ = require('lodash');
+const {chainTransformers} = require('@tryghost/mongo-utils');
 const config = require('../../shared/config');
+const labs = require('../../shared/labs');
 const {MemberCommentingCodec} = require('../services/members/commenting');
+const {CUSTOM_FIELDS_RELATION, createCustomFieldsFilterTransformer} = require('../services/members-custom-fields/filter');
 
 const DEEP_OFFSET_THRESHOLD = 1000;
 
@@ -166,8 +169,29 @@ const Member = ghostBookshelf.Model.extend({
         }];
     },
 
+    // Chain the custom-field filter transformer at this single choke point — the method
+    // every members query routes its filter through (list, CSV export, bulk edit/destroy,
+    // count, email send all reach it via findPage or getFilteredCollectionQuery) — so a
+    // saved `custom_fields.*` segment works the same everywhere without each call site
+    // wiring it. Runs only behind the flag and only when the filter names the relation; the
+    // transformer maps the public `key`/`value` grammar onto the leaf-row columns.
+    applyDefaultAndCustomFilters(options) {
+        if (labs.isSet('membersCustomFields') && options.filter && options.filter.includes(`${CUSTOM_FIELDS_RELATION.tableNameAs}.`)) {
+            const transformer = createCustomFieldsFilterTransformer();
+            options.mongoTransformer = options.mongoTransformer
+                ? chainTransformers(options.mongoTransformer, transformer)
+                : transformer;
+        }
+        return ghostBookshelf.Model.prototype.applyDefaultAndCustomFilters.call(this, options);
+    },
+
     filterRelations() {
         return {
+            // Custom field values are filterable only behind the feature flag. Gating the
+            // relation here (rather than the whole model) means a `custom_fields.*` filter
+            // is simply an unknown relation when the flag is off, and the filter is
+            // rejected — nothing to special-case downstream.
+            ...(labs.isSet('membersCustomFields') ? {custom_fields: CUSTOM_FIELDS_RELATION} : {}),
             labels: {
                 tableName: 'labels',
                 type: 'manyToMany',

package/core/server/models/settings.js

@@ -1,6 +1,5 @@
 const _ = require('lodash');
 const crypto = require('crypto');
-const keypair = require('keypair');
 const ObjectID = require('bson-objectid').default;
 const ghostBookshelf = require('./base');
 const tpl = require('@tryghost/tpl');
@@ -22,11 +21,21 @@ let defaultSettings;
 
 const doBlock = fn => fn();
 
+// PKCS#1 PEM, matching the format previously generated by `keypair`
+const generateKeypair = () => {
+    const {publicKey, privateKey} = crypto.generateKeyPairSync('rsa', {
+        modulusLength: 2048,
+        publicKeyEncoding: {type: 'pkcs1', format: 'pem'},
+        privateKeyEncoding: {type: 'pkcs1', format: 'pem'}
+    });
+    return {public: publicKey, private: privateKey};
+};
+
 const getMembersKey = doBlock(() => {
     let UNO_KEYPAIRINO;
     return function getKey(type) {
         if (!UNO_KEYPAIRINO) {
-            UNO_KEYPAIRINO = keypair({bits: 1024});
+            UNO_KEYPAIRINO = generateKeypair();
         }
         return UNO_KEYPAIRINO[type];
     };
@@ -36,7 +45,7 @@ const getGhostKey = doBlock(() => {
     let UNO_KEYPAIRINO;
     return function getKey(type) {
         if (!UNO_KEYPAIRINO) {
-            UNO_KEYPAIRINO = keypair({bits: 1024});
+            UNO_KEYPAIRINO = generateKeypair();
         }
         return UNO_KEYPAIRINO[type];
     };
@@ -58,6 +67,7 @@ function parseDefaultSettings() {
         members_private_key: () => getMembersKey('private'),
         members_email_auth_secret: () => crypto.randomBytes(64).toString('hex'),
         members_otc_secret: () => crypto.randomBytes(64).toString('hex'),
+        machine_payments_secret: () => crypto.randomBytes(64).toString('hex'),
         ghost_public_key: () => getGhostKey('public'),
         ghost_private_key: () => getGhostKey('private'),
         site_uuid: () => getOrGenerateSiteUuid(),
@@ -389,6 +399,25 @@ Settings = ghostBookshelf.Model.extend({
         },
         // @TODO: Maybe move some of the logic into the members service, exporting an isValidStripeKey
         // method which can be called here, cleaning up the duplication, but not removing control
+        async machine_payments_amount(model) {
+            const value = model.get('value');
+            const amount = typeof value === 'string' ? Number(value) : value;
+
+            if (!Number.isSafeInteger(amount) || amount < 1) {
+                throw new errors.ValidationError({
+                    message: 'Machine payments amount must be an integer greater than 0'
+                });
+            }
+        },
+        async machine_payments_currency(model) {
+            const value = model.get('value');
+
+            if (value !== null && (typeof value !== 'string' || !/^[A-Z]{3}$/i.test(value))) {
+                throw new errors.ValidationError({
+                    message: 'Machine payments currency must be a 3 letter ISO currency code'
+                });
+            }
+        },
         stripe_secret_key(model) {
             const value = model.get('value');
             if (value === null) {

package/core/server/models/user.js

@@ -1091,7 +1091,7 @@ User = ghostBookshelf.Model.extend({
             });
         }
 
-        const updatedUser = await user.save({password: newPassword});
+        const updatedUser = await user.save({password: newPassword}, options);
 
         // Destroy every active session for this user. The caller must mint a
         // fresh session (with a new session_id) for self password-changes so