ghost 6.61.0 → 6.63.0

package/core/server/services/members/api.js

@@ -22,7 +22,7 @@ const emailSuppressionList = require('../email-suppression-list');
 const commentsService = require('../comments');
 const emailAddressService = require('../email-address');
 const giftService = require('../gifts');
-const customFieldsService = require('../members-custom-fields');
+const metafieldsService = require('../members-metafields');
 const { t } = require('../i18n');
 const sentry = require('../../../shared/sentry');
 
@@ -271,9 +271,10 @@ function createApiInstance(config) {
     giftService,
     // Resolved here rather than passed as the module: the members service needs
     // the values service itself, and reading it at construction is what ties the
-    // two together in boot order. Custom fields is initialised in initCore, the
+    // two together in boot order. Metafields is initialised in initCore, the
     // members API is built in initServices, so this is always the live instance.
-    customFieldValues: customFieldsService.values,
+    metafieldValues: metafieldsService.values,
+    metafieldDefinitions: metafieldsService.definitions,
   });
 
   return membersApiInstance;

package/core/server/services/members/import-export/csv/parse.js

@@ -43,19 +43,12 @@ function parse(path, headerMapping) {
                     // hasOwn, not `in`: a prototype-named header would otherwise match an
                     // inherited method on the mapping and take a function as its mapped name.
                     if (headerMapping && Object.hasOwn(headerMapping, header)) {
-                        // An empty target is the caller naming a column to leave out, which
-                        // it has to name: an unnamed column carries through below, and for a
-                        // custom_fields.* column carrying through means being imported. So
-                        // omitting a column from the mapping is the opposite of excluding it.
                         if (!headerMapping[header]) {
                             continue;
                         }
                         row[headerMapping[header]] = value;
                     }
                     else if (isSafeColumnName(header)) {
-                        // Carry any unmapped column through untouched, so the import is not
-                        // constrained to a known vocabulary: a custom_fields.* column
-                        // survives parsing even though nothing consumes it yet.
                         row[header] = value;
                     }
                 }

package/core/server/services/members/import-export/export/exporter.js

@@ -8,7 +8,7 @@ const moment_1 = __importDefault(require("moment"));
 const node_stream_1 = require("node:stream");
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
-const { csvCellsForFields } = require('@tryghost/custom-field-types/csv');
+const { csvCellsForFields } = require('@tryghost/metafield-types/csv');
 // The columns the export reads off the members table, checked against MemberDbRow so the
 // query cannot select a column the row type does not declare.
 const MEMBER_COLUMNS = ['id', 'email', 'name', 'note', 'status', 'created_at'];
@@ -32,22 +32,22 @@ function toExportCsvRow(row) {
         labels: namesToCsv(row.labels),
         tiers: namesToCsv(row.tiers),
         gift_id: row.gift_id || '',
-        ...row.custom_field_cells,
+        ...row.metafield_cells,
     };
 }
 const BATCH_SIZE = 1000;
 // Streams the matching members as flat rows, each carrying its related data (tiers,
-// labels, subscription, gift, Stripe customer, custom fields) for the output serializer
-// to turn into CSV lines. The members aggregate and custom fields are reached only
+// labels, subscription, gift, Stripe customer, metafields) for the output serializer
+// to turn into CSV lines. The members aggregate and metafields are reached only
 // through the ports above, so nothing Bookshelf- or flag-shaped leaks into the export.
 class MembersCSVExporter {
     _knex;
     _members;
-    _customFields;
-    constructor({ knex, members, customFields }) {
+    _metafields;
+    constructor({ knex, members, metafields }) {
         this._knex = knex;
         this._members = members;
-        this._customFields = customFields;
+        this._metafields = metafields;
     }
     async export(options = {}) {
         const start = Date.now();
@@ -75,7 +75,7 @@ class MembersCSVExporter {
         return processingTransform;
     }
     // products and labels are small, stable tables, read once up front as id->name
-    // maps. Custom field definitions are read once too, which fixes the column set for
+    // maps. Metafield definitions are read once too, which fixes the column set for
     // the whole file: archiving a field mid-export cannot leave the header ragged. It
     // can still leave that field's cells empty from the batch after the archive
     // onwards, because the per-batch value read applies its own active filter.
@@ -94,8 +94,8 @@ class MembersCSVExporter {
             return acc;
         }, {}));
         logging.info({ event: { name: 'members-export.reference_data_read' }, durationMs: Date.now() - start }, 'Read the products and labels an export names');
-        const activeCustomFields = await this._customFields.activeDefinitions();
-        return { allProducts, allLabels, activeCustomFields };
+        const activeMetafields = await this._metafields.activeDefinitions();
+        return { allProducts, allLabels, activeMetafields };
     }
     // Group the member stream into batches so the related-data reads are one query per
     // batch rather than one per member.
@@ -121,7 +121,7 @@ class MembersCSVExporter {
     }
     // Each flattened row is pushed individually so a batch's rows do not pile up in memory.
     createProcessingTransform(reference) {
-        const assembleRelatedData = (memberIds) => this.assembleRelatedData(memberIds, reference.activeCustomFields);
+        const assembleRelatedData = (memberIds) => this.assembleRelatedData(memberIds, reference.activeMetafields);
         const flattenBatch = (members, related) => this.flattenBatch(members, related, reference);
         return new node_stream_1.Transform({
             objectMode: true,
@@ -140,11 +140,11 @@ class MembersCSVExporter {
             },
         });
     }
-    // One query per related table for the whole batch, not one per member. Custom field
+    // One query per related table for the whole batch, not one per member. Metafield
     // values are read only when there are columns to fill.
-    async assembleRelatedData(memberIds, activeCustomFields) {
+    async assembleRelatedData(memberIds, activeMetafields) {
         const knex = this._knex;
-        const [tiers, labels, stripeCustomers, subscriptions, gifts, customFieldValuesMap] = await Promise.all([
+        const [tiers, labels, stripeCustomers, subscriptions, gifts, metafieldValuesMap] = await Promise.all([
             knex('members_products')
                 .select('member_id', knex.raw('GROUP_CONCAT(product_id) as tiers'))
                 .whereIn('member_id', memberIds)
@@ -162,8 +162,8 @@ class MembersCSVExporter {
                 .select('id', 'redeemer_member_id')
                 .where('status', 'redeemed')
                 .whereIn('redeemer_member_id', memberIds),
-            activeCustomFields.length > 0
-                ? this._customFields.valuesForMembers(memberIds)
+            activeMetafields.length > 0
+                ? this._metafields.valuesForMembers(memberIds)
                 : new Map(),
         ]);
         return {
@@ -178,12 +178,12 @@ class MembersCSVExporter {
                 row.redeemer_member_id,
                 row.id,
             ])),
-            customFieldValuesMap,
+            metafieldValuesMap,
         };
     }
     flattenBatch(members, related, reference) {
-        const { tiersMap, labelsMap, stripeCustomerMap, subscribedSet, giftIdMap, customFieldValuesMap, } = related;
-        const { allProducts, allLabels, activeCustomFields } = reference;
+        const { tiersMap, labelsMap, stripeCustomerMap, subscribedSet, giftIdMap, metafieldValuesMap } = related;
+        const { allProducts, allLabels, activeMetafields } = reference;
         return members.map((row) => {
             const tierConcat = tiersMap.get(row.id);
             const tierIds = tierConcat ? tierConcat.split(',') : [];
@@ -202,7 +202,7 @@ class MembersCSVExporter {
                 // only knowable from the database. Every member carries a cell for every
                 // active field's column, so a member with no values still contributes the
                 // full set -- the CSV header is taken from whichever row streams first.
-                custom_field_cells: csvCellsForFields(activeCustomFields, customFieldValuesMap.get(row.id) || {}),
+                metafield_cells: csvCellsForFields(activeMetafields, metafieldValuesMap.get(row.id) || {}),
             };
         });
     }

package/core/server/services/members/import-export/import/completion-email.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = buildImportEmail;
 const csv_1 = require("../csv");
 const email_template_1 = __importStar(require("./email-template"));
-const csv_2 = require("@tryghost/custom-field-types/csv");
+const csv_2 = require("@tryghost/metafield-types/csv");
 // Turn an ORM validation error into copy a member manager can act on. Presentation
 // only: the API response keeps the raw messages, and just the emailed report is
 // rewritten. Takes one reason at a time, so a rewrite matching to the end of its input
@@ -55,13 +55,11 @@ function humaniseError(row) {
 function stringifyLabels(labels) {
     return labels.map((label) => (typeof label === 'string' ? label : label.name)).join(',');
 }
-// The custom_fields.* cells a submitted row carried, echoed untouched so a manager can
-// fix a failed row and re-upload the values they mapped.
-function customFieldCells(row) {
-    return Object.fromEntries(Object.entries(row).filter(([column]) => (0, csv_2.isCustomFieldColumn)(column)));
+function metafieldCells(row) {
+    return Object.fromEntries(Object.entries(row).filter(([column]) => (0, csv_2.isMetafieldColumn)(column)));
 }
 // Shape a failed import row into its fixed error-report cells, with the raw ORM message
-// rewritten into copy the member manager can act on. Custom field cells are merged on by
+// rewritten into copy the member manager can act on. Metafield cells are merged on by
 // buildErrorReport, which owns the dynamic column set.
 function toErrorReportRow(row) {
     return {
@@ -82,14 +80,13 @@ function toErrorReportRow(row) {
 }
 // The error report attached to the completion email: the failed rows as CSV, called only
 // when there are rows to list. It shares the serialiser with the export but not the
-// shaping -- the export writes db members, this echoes submitted rows. Member columns come from the shaper's keys (so the type
-// stays the single source); the custom_fields.* columns across the rows are threaded in
-// before the last error column, and each row's custom cells merged on.
+// shaping -- the export writes db members, this echoes submitted rows. Member columns
+// come from the shaper's keys, so the type stays the single source.
 function buildErrorReport(errors) {
     const memberColumns = Object.keys(toErrorReportRow(errors[0])).filter((column) => column !== 'error');
-    const customColumns = [...new Set(errors.flatMap((row) => Object.keys(customFieldCells(row))))];
+    const customColumns = [...new Set(errors.flatMap((row) => Object.keys(metafieldCells(row))))];
     const columns = [...memberColumns, ...customColumns, 'error'];
-    const rows = errors.map((row) => ({ ...toErrorReportRow(row), ...customFieldCells(row) }));
+    const rows = errors.map((row) => ({ ...toErrorReportRow(row), ...metafieldCells(row) }));
     return (0, csv_1.serialize)(rows, { columns });
 }
 // The one email an import sends, whatever became of it. What the publisher is told and

package/core/server/services/members/import-export/import/importer.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const completion_email_1 = __importDefault(require("./completion-email"));
 const csv_1 = require("../csv");
-const csv_2 = require("@tryghost/custom-field-types/csv");
+const csv_2 = require("@tryghost/metafield-types/csv");
 const metrics = require('@tryghost/metrics');
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
@@ -17,7 +17,7 @@ const messages = {
     giftCannotCombineWithImportTier: 'Cannot specify both gift_id and import_tier.',
     giftCannotCombineWithComplimentary: 'Cannot specify both gift_id and complimentary_plan.',
     giftReassignFailed: 'Failed to reassign gift to member.',
-    customFieldWriteFailed: 'Failed to save the custom field values for this member.',
+    metafieldWriteFailed: 'Failed to save the custom field values for this member.',
 };
 // Columns whose presence makes a row slow to import (they reach out to Stripe), so
 // a file carrying any of them is deferred regardless of size. The routing decision
@@ -50,13 +50,13 @@ class MembersCSVImporter {
     _tiers;
     _stripe;
     _gifts;
-    _customFields;
+    _metafields;
     _email;
     _report;
     _addJob;
     _getTimezone;
     _getInlineThreshold;
-    constructor({ knex, readRows, spool, members, tiers, stripe, gifts, customFields, email, report, addJob, getTimezone, getInlineThreshold, }) {
+    constructor({ knex, readRows, spool, members, tiers, stripe, gifts, metafields, email, report, addJob, getTimezone, getInlineThreshold, }) {
         this._knex = knex;
         this._readRows = readRows;
         this._spool = spool;
@@ -64,7 +64,7 @@ class MembersCSVImporter {
         this._tiers = tiers;
         this._stripe = stripe;
         this._gifts = gifts;
-        this._customFields = customFields;
+        this._metafields = metafields;
         this._email = email;
         this._report = report;
         this._addJob = addJob;
@@ -166,14 +166,14 @@ class MembersCSVImporter {
         return {
             defaultTier: await this._tiers.getDefault(),
             // Empty when the feature is off, so a carried-through column is dropped.
-            activeCustomFields: await this._customFields.activeFields(),
+            activeMetafields: await this._metafields.activeFields(),
             globalLabels: [{ name: labelName }, ...extraLabels],
         };
     }
     // Must not throw: once a row has committed, an import that failed halfway is not one
     // that never ran.
     async writeRows(rows, prepared) {
-        const { defaultTier, activeCustomFields } = prepared;
+        const { defaultTier, activeMetafields } = prepared;
         const tierIdCache = new Map();
         const archivableStripePriceIds = [];
         // Copied per row: the member model stamps ids and trims names onto these in
@@ -199,12 +199,12 @@ class MembersCSVImporter {
                         }));
                     }
                 }
-                // Validate the row's custom field values before the transaction opens.
+                // Validate the row's metafield values before the transaction opens.
                 // planWrite only reads, and it throws on an invalid value to fail the row
                 // before any member write -- so there is no reason to hold a transaction
                 // across it, and doing so would deadlock the single-connection SQLite pool.
-                const customFieldPlan = activeCustomFields.length > 0
-                    ? await namingTheColumn(() => this._customFields.planWrite((0, csv_2.fieldValuesFromCsvRow)(activeCustomFields, row, csv_1.stripFormulaGuard)))
+                const metafieldPlan = activeMetafields.length > 0
+                    ? await namingTheColumn(() => this._metafields.planWrite((0, csv_2.fieldValuesFromCsvRow)(activeMetafields, row, csv_1.stripFormulaGuard)))
                     : [];
                 trx = await this._knex.transaction(undefined, { doNotRejectOnRollback: false });
                 const options = { transacting: trx, context: IMPORT_CONTEXT };
@@ -307,7 +307,7 @@ class MembersCSVImporter {
                 }
                 // On the row's transaction, so the values commit or roll back with the member.
                 try {
-                    await this._customFields.applyWrite(member.id, customFieldPlan, trx);
+                    await this._metafields.applyWrite(member.id, metafieldPlan, trx);
                 }
                 catch (writeError) {
                     // planWrite passed every value before the transaction opened, so a failure
@@ -315,7 +315,7 @@ class MembersCSVImporter {
                     // will have written a query into; the publisher gets a sentence instead, in a
                     // file they open next to a spreadsheet.
                     this._report(writeError);
-                    throw new errors.DataImportError({ message: tpl(messages.customFieldWriteFailed) });
+                    throw new errors.DataImportError({ message: tpl(messages.metafieldWriteFailed) });
                 }
                 await trx.commit();
                 imported += 1;
@@ -327,7 +327,7 @@ class MembersCSVImporter {
                     .filter((message) => typeof message === 'string');
                 const errorMessage = reasons.join('\n');
                 // trx is unset if the row failed before the transaction opened (a bad
-                // custom field value or gift combination). A rejected rollback must not
+                // metafield value or gift combination). A rejected rollback must not
                 // escape: rows before this one are already committed, and a throw leaving
                 // here would be read as an import that never wrote anything.
                 if (trx) {

package/core/server/services/members/import-export/import/row.js

@@ -16,9 +16,6 @@ const optionalCell = zod_1.z
 // not defaulted), so a CSV lacking these columns leaves the member's state untouched.
 const isSubscribed = (cell) => cell.toLowerCase() !== 'false';
 const isComplimentary = (cell) => cell.toLowerCase() === 'true';
-// The member import vocabulary as a schema: the single source of truth that coerces the
-// raw string Row into typed member fields. Unknown columns (custom_fields.*, and anything
-// else a source carries) pass through via .loose() so nothing is lost before the kernel.
 exports.memberImportRowSchema = zod_1.z
     .object({
     id: optionalCell,

package/core/server/services/members/import-export/index.js

@@ -12,7 +12,6 @@ const exporter_1 = __importDefault(require("./export/exporter"));
 const MembersCSVImporterStripeUtils = require('./import/stripe-utils');
 const db = require('../../../data/db');
 const models = require('../../../models');
-const labs = require('../../../../shared/labs');
 const logging = require('@tryghost/logging');
 const sentry = require('../../../../shared/sentry');
 // Build the members CSV importer. This is the composition root: today's models and
@@ -57,15 +56,12 @@ function makeImporter(deps) {
             transacting: options.transacting,
         }),
     };
-    // Gated by the same labs flag as the export, so the two halves round-trip or stay
-    // silent together: off, activeFields resolves empty and every custom_fields.* column
-    // is dropped.
-    const customFields = {
-        activeFields: async () => labs.isSet('membersCustomFields') ? deps.customFields.definitions.browse() : [],
-        planWrite: (values) => deps.customFields.values.planWrite(values),
+    const metafields = {
+        activeFields: async () => deps.metafields.definitions.browse(),
+        planWrite: (values) => deps.metafields.values.planWrite(values),
         // Every value the import writes came out of the file, whichever column carried it.
         // An import has no id to give until runs are tracked, so it names its kind only.
-        applyWrite: (memberId, plan, executor) => deps.customFields.values.applyWrite(memberId, plan, {
+        applyWrite: (memberId, plan, executor) => deps.metafields.values.applyWrite(memberId, plan, {
             writtenBy: { type: 'import', id: null },
             executor,
         }),
@@ -95,7 +91,7 @@ function makeImporter(deps) {
             productRepository: deps.productRepository,
         }),
         gifts,
-        customFields,
+        metafields,
         email,
         report,
         addJob: deps.addJob,
@@ -104,10 +100,8 @@ function makeImporter(deps) {
     });
 }
 // Build the members CSV exporter. The same composition root from the other direction:
-// knex and the members id lookup are wired here, and the custom fields definitions and
-// values services are injected (boot builds them before this one). The labs flag alone
-// decides whether custom field columns appear, so nothing flag-shaped leaks into the
-// exporter itself.
+// knex and the members id lookup are wired here, and the metafields definitions and
+// values services are injected (boot builds them before this one).
 function makeExporter({ definitions, values, }) {
     const exporter = new exporter_1.default({
         knex: db.knex,
@@ -124,11 +118,10 @@ function makeExporter({ definitions, values, }) {
                 return page.data.map((member) => member.id);
             },
         },
-        customFields: {
+        metafields: {
             // Boot builds the definitions and values services before this one, so they
-            // are always present -- no not-initialised state to guard. The flag decides
-            // whether their columns are included at all.
-            activeDefinitions: async () => labs.isSet('membersCustomFields') ? definitions.browse() : [],
+            // are always present -- no not-initialised state to guard.
+            activeDefinitions: async () => definitions.browse(),
             valuesForMembers: (memberIds) => values.getValuesForMembers(memberIds),
         },
     });

package/core/server/services/members/jobs/clean-expired-comped-job.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const job_1 = require("../../jobs-service/job");
+class CleanExpiredCompedJob extends job_1.Job {
+    static type = 'clean-expired-comped';
+}
+exports.default = CleanExpiredCompedJob;

package/core/server/services/members/jobs/clean-expired-comped-task.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ObjectId = require('bson-objectid').default;
+const { chunk: chunkArray } = require('lodash');
+const moment = require('moment');
+// Removes expired comped entries from the members_products table, moves the
+// affected members from comped to free and records a comped->free status
+// event for each of them. The three writes commit or roll back together, so a
+// failed run leaves the source rows in place and a repeat run redoes the whole
+// unit of work instead of finishing a half-applied one.
+async function cleanExpiredComped({ db, models, events, logging, sentry, }) {
+    const startedAt = Date.now();
+    const { deletedSubscriptionCount, updatedMemberCount, updatedMembers, now } = await db.knex.transaction(async (trx) => {
+        const expiredCompedRows = await trx('members_products')
+            // we need to be careful about the type here. .format() is the only
+            // thing that works across SQLite and MySQL: an ISO cutoff compares
+            // lexically against SQLite's 'YYYY-MM-DD HH:mm:ss' text and its 'T'
+            // sorts above ' ', wrongly matching same-UTC-day expiries
+            .where('expiry_at', '<', moment.utc().startOf('day').format('YYYY-MM-DD HH:mm:ss'))
+            .select('*');
+        if (!expiredCompedRows.length) {
+            return {
+                deletedSubscriptionCount: 0,
+                updatedMemberCount: 0,
+                updatedMembers: [],
+                now: new Date(),
+            };
+        }
+        const rowIds = expiredCompedRows.map((d) => d.id);
+        const memberIds = expiredCompedRows.map((d) => d.member_id);
+        // Only members still in the comped status change; anyone already paid,
+        // free or deleted is left untouched. The rows are locked for the rest
+        // of the transaction so a concurrent status change cannot slip between
+        // this read and the update below (forUpdate is a no-op on SQLite,
+        // where the single-writer transaction already guarantees this). The
+        // members rows are locked BEFORE the members_products delete so this
+        // transaction acquires locks in the same members -> members_products
+        // order as the member-edit flows (Bookshelf edit, linkSubscription);
+        // the reverse order could deadlock against them.
+        const compedMembers = await trx('members')
+            .whereIn('id', memberIds)
+            .andWhere('status', 'comped')
+            .forUpdate();
+        const deletedCount = await trx('members_products').whereIn('id', rowIds).del();
+        const updateMemberIds = compedMembers.map((d) => d.id);
+        const updatedAt = new Date();
+        const updatedCount = await trx('members').whereIn('id', updateMemberIds).update({
+            status: 'free',
+            updated_at: updatedAt,
+        });
+        const statusEvents = compedMembers.map((member) => {
+            return {
+                id: ObjectId().toHexString(),
+                member_id: member.id,
+                from_status: member.status,
+                to_status: 'free',
+                created_at: updatedAt,
+            };
+        });
+        // SQLite >= 3.32.0 can support 32766 host parameters
+        // each row uses 5 variables so ⌊32766/5⌋ = 6553
+        const chunkSize = 6553;
+        for (const chunk of chunkArray(statusEvents, chunkSize)) {
+            await trx('members_status_events').insert(chunk);
+        }
+        return {
+            deletedSubscriptionCount: deletedCount,
+            updatedMemberCount: updatedCount,
+            updatedMembers: compedMembers,
+            now: updatedAt,
+        };
+    });
+    // Emitted after the commit so listeners never observe state that could
+    // still roll back. A failed emission is logged and skipped rather than
+    // failing the job: the database changes are already durable and the
+    // emitted_event_count below makes the shortfall visible.
+    let emittedEventCount = 0;
+    for (const member of updatedMembers) {
+        const emitted = await emitMemberEditedEvent({ member, now, models, events, logging, sentry });
+        if (emitted) {
+            emittedEventCount += 1;
+        }
+    }
+    logging.info({
+        system: {
+            event: 'clean_expired_comped.completed',
+            deleted_subscription_count: deletedSubscriptionCount,
+            updated_member_count: updatedMemberCount,
+            emitted_event_count: emittedEventCount,
+            duration_ms: Date.now() - startedAt,
+        },
+    }, `[Background Job] clean-expired-comped removed ${deletedSubscriptionCount} expired subscriptions and updated ${updatedMemberCount} members`);
+    return { deletedSubscriptionCount, updatedMemberCount, emittedEventCount };
+}
+// Emits member.edited in the shape its listeners (webhooks in particular)
+// expect: a freshly loaded model whose _previousAttributes carry the
+// pre-cleanup status and _changed the comped->free transition, with an
+// internal context.
+async function emitMemberEditedEvent({ member, now, models, events, logging, sentry, }) {
+    try {
+        const model = await models.Member.findOne({ id: member.id }, { require: true, context: { internal: true } });
+        model._previousAttributes = normalizeDates({
+            ...model.attributes,
+            status: member.status,
+            updated_at: member.updated_at,
+        });
+        model._changed = normalizeDates({
+            status: 'free',
+            updated_at: now,
+        });
+        events.emit('member.edited', model, { context: { internal: true } });
+        return true;
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            logging.warn(`Could not emit member.edited for expired comped member: Member ${member.id} was not found`);
+            return false;
+        }
+        logging.error(err);
+        sentry.captureException(err);
+        return false;
+    }
+}
+function normalizeDates(attributes) {
+    const normalized = { ...attributes };
+    for (const [key, value] of Object.entries(normalized)) {
+        if (key.endsWith('_at') && value && !(value instanceof Date)) {
+            normalized[key] = moment.utc(value).toDate();
+        }
+    }
+    return normalized;
+}
+function isNotFoundError(err) {
+    if (!err || typeof err !== 'object') {
+        return false;
+    }
+    const errorType = 'errorType' in err ? err.errorType : undefined;
+    const name = 'name' in err ? err.name : undefined;
+    const message = 'message' in err ? err.message : undefined;
+    return (errorType === 'NotFoundError' ||
+        name === 'NotFoundError' ||
+        message === 'NotFound' ||
+        message === 'EmptyResponse');
+}
+exports.default = cleanExpiredComped;

package/core/server/services/members/jobs/index.js

@@ -1,13 +1,17 @@
-const path = require('path');
 const logging = require('@tryghost/logging');
-const jobsService = require('../../jobs');
+const errors = require('@tryghost/errors');
 const CleanTokensJob = require('./clean-tokens-job').default;
+const CleanExpiredCompedJob = require('./clean-expired-comped-job').default;
+const cleanTokensTask = require('./clean-tokens-task').default;
+const cleanExpiredCompedTask = require('./clean-expired-comped-task').default;
 
 let hasScheduled = {
   expiredComped: false,
   tokens: false,
 };
 
+let tasks;
+
 function alreadyScheduledOrTest(key) {
   return hasScheduled[key] || process.env.NODE_ENV.startsWith('test');
 }
@@ -19,43 +23,63 @@ function randomDailyCron(maxHour = 24) {
   return `${s} ${m} ${h} * * *`;
 }
 
-function scheduleJob(key, name, jobFile, maxHour = 6) {
-  if (alreadyScheduledOrTest(key)) {
-    return hasScheduled[key];
+function getTasks() {
+  if (!tasks) {
+    throw new errors.IncorrectUsageError({
+      message: 'Member jobs used before init(). Call init() from boot first.',
+    });
   }
+  return tasks;
+}
 
-  const s = Math.floor(Math.random() * 60);
-  const m = Math.floor(Math.random() * 60);
-  const h = Math.floor(Math.random() * maxHour);
+module.exports = {
+  // Composition root for the member cleanup tasks. Idempotent because tests
+  // may boot more than once per process.
+  init() {
+    if (tasks) {
+      return;
+    }
 
-  const at = `${s} ${m} ${h} * * *`;
+    const db = require('../../../data/db');
+    const models = require('../../../models');
+    const events = require('../../../lib/common/events');
+    const sentry = require('../../../../shared/sentry');
 
-  logging.info(`[Background Job] ${name} scheduled at ${at}`);
-  jobsService.addJob({
-    at,
-    job: path.resolve(__dirname, jobFile),
-    name,
-  });
+    tasks = {
+      cleanTokens: () => cleanTokensTask({ db, logging }),
+      cleanExpiredComped: () => cleanExpiredCompedTask({ db, models, events, logging, sentry }),
+    };
+  },
 
-  hasScheduled[key] = true;
+  cleanTokens() {
+    return getTasks().cleanTokens();
+  },
 
-  return true;
-}
+  cleanExpiredComped() {
+    return getTasks().cleanExpiredComped();
+  },
 
-module.exports = {
-  async scheduleExpiredCompCleanupJob() {
-    return scheduleJob('expiredComped', 'clean-expired-comped', 'clean-expired-comped.js');
+  async scheduleExpiredCompCleanupJob(jobsService) {
+    if (alreadyScheduledOrTest('expiredComped')) {
+      return;
+    }
+
+    // Keep the legacy off-peak window: a random time between 00:00 and 05:59
+    const cron = randomDailyCron(6);
+    logging.info(`[Background Job] clean-expired-comped scheduled at ${cron}`);
+    await jobsService.scheduleRecurring(new CleanExpiredCompedJob(), { cron });
+
+    hasScheduled.expiredComped = true;
   },
 
-  async scheduleTokenCleanupJob() {
+  async scheduleTokenCleanupJob(jobsService) {
     if (alreadyScheduledOrTest('tokens')) {
       return;
     }
 
-    const classBasedJobs = require('../../jobs-service').getInstance();
     const cron = randomDailyCron();
     logging.info(`[Background Job] clean-tokens scheduled at ${cron}`);
-    await classBasedJobs.scheduleRecurring(new CleanTokensJob(), { cron });
+    await jobsService.scheduleRecurring(new CleanTokensJob(), { cron });
 
     hasScheduled.tokens = true;
   },