ghost 6.60.0 → 6.62.0

package/core/server/services/jobs-service/register-job-handlers.js

@@ -37,25 +37,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = registerJobHandlers;
-const errors_1 = __importDefault(require("@tryghost/errors"));
-const index_1 = require("./index");
 const clean_tokens_job_1 = __importDefault(require("../members/jobs/clean-tokens-job"));
-const clean_tokens_task_1 = __importDefault(require("../members/jobs/clean-tokens-task"));
-const gifts = __importStar(require("../gifts"));
+const clean_expired_comped_job_1 = __importDefault(require("../members/jobs/clean-expired-comped-job"));
 const clean_gifts_job_1 = __importDefault(require("../gifts/jobs/clean-gifts-job"));
-const logging = require('@tryghost/logging');
-function registerJobHandlers() {
-    const jobsService = (0, index_1.getInstance)();
-    const db = require('../../data/db');
+const external_media_inliner_job_1 = __importDefault(require("../media-inliner/external-media-inliner-job"));
+const content_csv_import_job_1 = __importDefault(require("../content-import/jobs/content-csv-import-job"));
+const contentImport = __importStar(require("../content-import"));
+const update_check_job_1 = __importDefault(require("../update-check/jobs/update-check-job"));
+const process_webmention_job_1 = __importDefault(require("../mentions/process-webmention-job"));
+const updateCheck = require('../update-check');
+function registerJobHandlers({ jobsService, memberJobs, giftService, mediaInliner, mentionsController, }) {
     jobsService.handle(clean_tokens_job_1.default, async () => {
-        await (0, clean_tokens_task_1.default)({ db, logging });
+        await memberJobs.cleanTokens();
+    });
+    jobsService.handle(clean_expired_comped_job_1.default, async () => {
+        await memberJobs.cleanExpiredComped();
     });
     jobsService.handle(clean_gifts_job_1.default, async () => {
-        if (!gifts.service) {
-            throw new errors_1.default.IncorrectUsageError({
-                message: 'clean-gifts ran before the gifts service was initialised',
-            });
-        }
-        await gifts.service.cleanup();
+        await giftService.cleanup();
+    });
+    jobsService.handle(external_media_inliner_job_1.default, async (job) => {
+        await mediaInliner.inline(job.domains);
+    });
+    jobsService.handle(content_csv_import_job_1.default, async (job) => {
+        await contentImport.handleJob(job);
+    });
+    jobsService.handle(update_check_job_1.default, async () => {
+        await updateCheck({ rethrowErrors: true });
+    });
+    jobsService.handle(process_webmention_job_1.default, async (job) => {
+        await mentionsController.processWebmention(job);
     });
 }

package/core/server/services/lib/mailgun-client.js

@@ -165,8 +165,8 @@ module.exports = class MailgunClient {
    * @param {Object} mailgunOptions
    * @param {Function} batchHandler
    * @param {Object} options
-   * @param {number} [options.maxEvents] Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
-   * @returns {Promise<void>}
+   * @param {number} [options.maxEvents] Per-domain soft maximum. We stop fetching a domain after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
+   * @returns {Promise<{safeCursor?: Date} | void>}
    */
   async fetchEvents(mailgunOptions, batchHandler, { maxEvents = Infinity } = {}) {
     const mailgunInstance = this.getInstance();
@@ -184,12 +184,33 @@ module.exports = class MailgunClient {
     // Determine which domains to fetch from
     const domains = this.#getDomainsToFetch(mailgunConfig);
 
+    const cappedDomainCursors = [];
+
     // Fetch events from each domain
     for (const domain of domains) {
-      await this.#fetchEventsFromDomain(domain, mailgunInstance, mailgunOptions, batchHandler, {
-        maxEvents,
-      });
+      const result = await this.#fetchEventsFromDomain(
+        domain,
+        mailgunInstance,
+        mailgunOptions,
+        batchHandler,
+        { maxEvents },
+      );
+
+      if (
+        result.capped &&
+        result.lastEventTimestamp &&
+        Number.isFinite(result.lastEventTimestamp.getTime())
+      ) {
+        cappedDomainCursors.push(result.lastEventTimestamp);
+      }
     }
+
+    const safeCursor = cappedDomainCursors.reduce(
+      (earliest, cursor) => (!earliest || cursor < earliest ? cursor : earliest),
+      undefined,
+    );
+
+    return { safeCursor };
   }
 
   /**
@@ -220,7 +241,7 @@ module.exports = class MailgunClient {
    * @param {Function} batchHandler
    * @param {Object} options
    * @param {number} options.maxEvents
-   * @returns {Promise<void>}
+   * @returns {Promise<{capped: boolean, eventCount: number, lastEventTimestamp?: Date}>}
    */
   async #fetchEventsFromDomain(
     domain,
@@ -235,6 +256,9 @@ module.exports = class MailgunClient {
 
     let batchCount = 0;
     let totalBatchTime = 0;
+    let eventCount = 0;
+    let lastEventTimestamp;
+    let capped = false;
 
     try {
       let page = await this.getEventsFromMailgun(mailgunInstance, domain, mailgunOptions);
@@ -248,7 +272,6 @@ module.exports = class MailgunClient {
         `[MailgunClient fetchEventsFromDomain ${domain}]: finished fetching first page with ${events.length} events`,
       );
 
-      let eventCount = 0;
       const beginTimestamp = mailgunOptions.begin
         ? Math.ceil(mailgunOptions.begin * 1000)
         : undefined; // ceil here if we have rounding errors
@@ -263,6 +286,13 @@ module.exports = class MailgunClient {
         totalBatchTime += batchDuration;
 
         eventCount += events.length;
+        const batchLastEventTimestamp = events[events.length - 1].timestamp;
+        if (
+          batchLastEventTimestamp &&
+          (!lastEventTimestamp || batchLastEventTimestamp > lastEventTimestamp)
+        ) {
+          lastEventTimestamp = batchLastEventTimestamp;
+        }
 
         if (
           eventCount >= maxEvents &&
@@ -270,6 +300,7 @@ module.exports = class MailgunClient {
             !events[events.length - 1].timestamp ||
             events[events.length - 1].timestamp.getTime() > beginTimestamp)
         ) {
+          capped = true;
           break;
         }
 
@@ -294,10 +325,15 @@ module.exports = class MailgunClient {
       const overallEndTime = Date.now();
       const totalDuration = overallEndTime - overallStartTime;
       const averageBatchTime = batchCount > 0 ? totalBatchTime / batchCount : 0;
+      const cursor = Number.isFinite(lastEventTimestamp?.getTime())
+        ? lastEventTimestamp.toISOString()
+        : 'none';
 
       logging.info(
-        `[MailgunClient fetchEventsFromDomain ${domain}]: Processed ${batchCount} batches in ${(totalDuration / 1000).toFixed(2)}s. Average batch time: ${(averageBatchTime / 1000).toFixed(2)}s`,
+        `[MailgunClient fetchEventsFromDomain ${domain}]: Processed ${eventCount} events in ${batchCount} batches in ${(totalDuration / 1000).toFixed(2)}s. Average batch time: ${(averageBatchTime / 1000).toFixed(2)}s. Status: ${capped ? 'capped' : 'exhausted'}. Cursor: ${cursor}`,
       );
+
+      return { capped, eventCount, lastEventTimestamp };
     } catch (error) {
       logging.error(`[MailgunClient fetchEventsFromDomain ${domain}]: Error fetching events`);
       logging.error(error);

package/core/server/services/mail/ghost-mailer.js

@@ -17,7 +17,7 @@ const messages = {
   reason: ' Reason: {reason}.',
   messageSent: 'Message sent. Double check inbox and spam folder!',
 };
-const EmailAddressParser = require('../email-address/email-address-parser');
+const emailAddressParser = require('../email-address/email-address-parser');
 const DEFAULT_TAGS = ['ghost-email', 'transactional-email'];
 const MAX_MAILGUN_TAGS = 10;
 
@@ -54,8 +54,8 @@ function getFromAddress(requestedFromAddress, requestedReplyToAddress) {
   }
 
   return {
-    from: EmailAddressParser.stringify(addresses.from),
-    replyTo: addresses.replyTo ? EmailAddressParser.stringify(addresses.replyTo) : null,
+    from: emailAddressParser.stringify(addresses.from),
+    replyTo: addresses.replyTo ? emailAddressParser.stringify(addresses.replyTo) : null,
   };
 }
 
@@ -100,7 +100,7 @@ function createMessage(message) {
  */
 function createMailError({ message, err, ignoreDefaultMessage } = { message: '' }) {
   const helpMessage = tpl(messages.checkEmailConfigInstructions, {
-    url: 'https://ghost.org/docs/config/#mail',
+    url: 'https://docs.ghost.org/config/#mail',
   });
   const defaultErrorMessage = tpl(messages.failedSendingEmailError);
 

package/core/server/services/media-inliner/external-media-inliner-job.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const job_1 = require("../jobs-service/job");
+class ExternalMediaInlinerJob extends job_1.Job {
+    static type = 'external-media-inliner';
+    domains;
+    constructor({ domains }) {
+        super();
+        this.domains = domains;
+    }
+}
+exports.default = ExternalMediaInlinerJob;

package/core/server/services/media-inliner/external-media-inliner.js

@@ -177,6 +177,96 @@ class ExternalMediaInliner {
     }
   }
 
+  /**
+   * Download and store one external media URL without deciding where it came from
+   * or where its replacement belongs. Callers own discovery and replacement.
+   *
+   * @param {string} sourceUrl
+   * @returns {Promise<import('./types').ExternalMediaImportResult>}
+   */
+  async importUrl(sourceUrl) {
+    let response;
+    try {
+      response = await this.getRemoteMedia(sourceUrl);
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'download',
+        reason: 'The media file could not be downloaded.',
+        error,
+      };
+    }
+
+    if (!response) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'download',
+        reason: 'The media file could not be downloaded.',
+      };
+    }
+
+    let media;
+    try {
+      media = await this.extractFileDataFromResponse(sourceUrl, response);
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'extract',
+        reason: 'The downloaded media file could not be read.',
+        error,
+      };
+    }
+
+    try {
+      const storedUrl = await this.storeMediaLocally(media);
+      if (!storedUrl) {
+        return {
+          status: 'failed',
+          sourceUrl,
+          stage: 'unsupported',
+          reason: 'No configured storage accepts this media file.',
+        };
+      }
+
+      return {
+        status: 'stored',
+        sourceUrl,
+        storedUrl,
+      };
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'storage',
+        reason: 'The media file could not be stored in Ghost.',
+        error,
+      };
+    }
+  }
+
+  /**
+   * Convert an import result into the replacement URL expected by the existing
+   * content and field processing. Expected download and unsupported-file failures
+   * return null so the original URL remains unchanged. Results containing an
+   * underlying processing error are rethrown so the established per-resource
+   * catch boundary continues to log and isolate them.
+   *
+   * @param {import('./types').ExternalMediaImportResult} result
+   * @returns {string|null}
+   */
+  #replacementUrlFromImportResult(result) {
+    if (result.status === 'stored') {
+      return result.storedUrl;
+    }
+    if ('error' in result) {
+      throw result.error;
+    }
+    return null;
+  }
+
   static findMatches(content, domain) {
     // NOTE: the src could end with a quote, bracket, apostrophe, double-backslash, or encoded quote.
     //     Backlashes are added to content as an escape character
@@ -208,22 +298,14 @@ class ExternalMediaInliner {
       const matches = this.constructor.findMatches(content, domain);
 
       for (const src of matches) {
-        const response = await this.getRemoteMedia(src);
-
-        let media;
-        if (response) {
-          media = await this.extractFileDataFromResponse(src, response);
-        }
-
-        if (media) {
-          const inlinedSrc = await this.storeMediaLocally(media);
-
-          if (inlinedSrc) {
-            // NOTE: does not account for duplicate images in content
-            //       in those cases would be processed twice
-            content = content.replace(src, inlinedSrc);
-            logging.info(`Inlined media: ${src} -> ${inlinedSrc}`);
-          }
+        const result = await this.importUrl(src);
+        const replacementUrl = this.#replacementUrlFromImportResult(result);
+
+        if (replacementUrl) {
+          // NOTE: does not account for duplicate images in content
+          //       in those cases would be processed twice
+          content = content.replace(src, replacementUrl);
+          logging.info(`Inlined media: ${src} -> ${replacementUrl}`);
         }
       }
     }
@@ -246,20 +328,12 @@ class ExternalMediaInliner {
         const src = resourceModel.get(field);
 
         if (src && src.startsWith(domain)) {
-          const response = await this.getRemoteMedia(src);
-
-          let media;
-          if (response) {
-            media = await this.extractFileDataFromResponse(src, response);
-          }
-
-          if (media) {
-            const inlinedSrc = await this.storeMediaLocally(media);
+          const result = await this.importUrl(src);
+          const replacementUrl = this.#replacementUrlFromImportResult(result);
 
-            if (inlinedSrc) {
-              updatedFields[field] = inlinedSrc;
-              logging.info(`Added media to inline: ${src} -> ${inlinedSrc}`);
-            }
+          if (replacementUrl) {
+            updatedFields[field] = replacementUrl;
+            logging.info(`Added media to inline: ${src} -> ${replacementUrl}`);
           }
         }
       }

package/core/server/services/media-inliner/service.js

@@ -1,10 +1,11 @@
+const errors = require('@tryghost/errors');
+
+let instance;
+
 module.exports = {
   async init() {
-    const debug = require('@tryghost/debug')('mediaInliner');
     const MediaInliner = require('./external-media-inliner');
-    const logging = require('@tryghost/logging');
     const models = require('../../models');
-    const jobsService = require('../jobs');
     const adapterManager = require('../../services/adapter-manager').default;
 
     const mediaStorage = adapterManager.getAdapter('storage:media');
@@ -31,45 +32,16 @@ module.exports = {
       },
     });
 
-    this.api = {
-      startMediaInliner: async (domains) => {
-        if (!domains || !domains.length) {
-          // default domains to inline from if none are provided
-          domains = ['https://s3.amazonaws.com/revue', 'https://substackcdn.com'];
-        }
-
-        debug('[Inliner] Starting media inlining job for domains: ', domains);
+    instance = mediaInliner;
+  },
 
-        // @NOTE: the job is "inline" (aka non-offloaded into a thread), because usecases are currently
-        //        limited to migrational, so there is no expectations for site's availability etc.
-        logging.info('[Background Job] external-media-inliner queued');
-        await jobsService.addJob({
-          name: 'external-media-inliner',
-          job: async (data) => {
-            const startedAt = Date.now();
-            logging.info('[Background Job] external-media-inliner started');
-            try {
-              const result = await mediaInliner.inline(data.domains);
-              logging.info(
-                `[Background Job] external-media-inliner completed in ${Date.now() - startedAt}ms`,
-              );
-              return result;
-            } catch (err) {
-              logging.error(
-                err,
-                `[Background Job] external-media-inliner failed after ${Date.now() - startedAt}ms`,
-              );
-              throw err;
-            }
-          },
-          data: { domains },
-          offloaded: false,
-        });
+  getInstance() {
+    if (!instance) {
+      throw new errors.IncorrectUsageError({
+        message: 'Media inliner used before init(). Call init() from boot first.',
+      });
+    }
 
-        return {
-          status: 'success',
-        };
-      },
-    };
+    return instance;
   },
 };

package/core/server/services/media-inliner/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/server/services/member-welcome-emails/service.js

@@ -7,7 +7,7 @@ const MagicLink = require('../lib/magic-link/magic-link');
 const sentry = require('../../../shared/sentry');
 const emailAddressService = require('../email-address');
 const settingsHelpers = require('../settings-helpers');
-const EmailAddressParser = require('../email-address/email-address-parser');
+const emailAddressParser = require('../email-address/email-address-parser');
 const mail = require('../mail');
 const MailgunClient = require('../lib/mailgun-client');
 const config = require('../../../shared/config');
@@ -152,7 +152,7 @@ class MemberWelcomeEmailService {
       },
     });
 
-    const from = EmailAddressParser.stringify(fromAddresses.from);
+    const from = emailAddressParser.stringify(fromAddresses.from);
     const replyToSetting = newsletter.get('sender_reply_to');
     let replyTo = null;
 
@@ -173,7 +173,7 @@ class MemberWelcomeEmailService {
       });
 
       if (addresses.replyTo) {
-        replyTo = EmailAddressParser.stringify(addresses.replyTo);
+        replyTo = emailAddressParser.stringify(addresses.replyTo);
       }
     }
 
@@ -199,10 +199,10 @@ class MemberWelcomeEmailService {
   async #getEffectiveSenderOptions(automatedSender = {}) {
     const defaultOptions = await this.#getSenderOptions();
     const defaultFrom =
-      EmailAddressParser.parse(defaultOptions.from || '') ||
+      emailAddressParser.parse(defaultOptions.from || '') ||
       emailAddressService.service.defaultFromEmail;
     const defaultReplyTo = defaultOptions.replyTo
-      ? EmailAddressParser.parse(defaultOptions.replyTo)
+      ? emailAddressParser.parse(defaultOptions.replyTo)
       : undefined;
 
     const senderName = trimValue(automatedSender.senderName) || defaultFrom?.name || undefined;
@@ -218,10 +218,10 @@ class MemberWelcomeEmailService {
     });
 
     return {
-      from: EmailAddressParser.stringify(addresses.from),
+      from: emailAddressParser.stringify(addresses.from),
       ...(addresses.replyTo
         ? {
-            replyTo: EmailAddressParser.stringify(addresses.replyTo),
+            replyTo: emailAddressParser.stringify(addresses.replyTo),
           }
         : {}),
     };

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

@@ -274,6 +274,7 @@ function createApiInstance(config) {
     // two together in boot order. Custom fields is initialised in initCore, the
     // members API is built in initServices, so this is always the live instance.
     customFieldValues: customFieldsService.values,
+    customFieldDefinitions: customFieldsService.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

@@ -54,14 +54,14 @@ class MembersCSVExporter {
         const hasFilter = options.limit !== 'all' || options.filter || options.search;
         const ids = hasFilter ? await this._members.findFilteredIds(options) : null;
         if (ids) {
-            logging.info(`[MembersExporter] Found ${ids.length} members matching filter criteria`);
+            logging.info({ event: { name: 'members-export.filtered' }, matched: ids.length }, 'Found members matching the export filter');
         }
         const reference = await this.fetchReferenceData();
         const membersQuery = this._knex('members').select(...MEMBER_COLUMNS);
         if (ids) {
             membersQuery.whereIn('id', ids);
         }
-        logging.info('[MembersExporter] Starting streaming export of members');
+        logging.info({ event: { name: 'members-export.started' } }, 'Starting streaming export of members');
         const batchingTransform = this.createBatchingTransform();
         const processingTransform = this.createProcessingTransform(reference);
         (0, node_stream_1.pipeline)(membersQuery.stream(), batchingTransform, processingTransform, (err) => {
@@ -69,9 +69,7 @@ class MembersCSVExporter {
                 logging.error({ event: { name: 'members-export.stream.error' }, err }, 'Members export stream failed');
             }
             else {
-                logging.info('[MembersExporter] Total time taken for member export: ' +
-                    (Date.now() - start) / 1000 +
-                    's');
+                logging.info({ event: { name: 'members-export.completed' }, durationMs: Date.now() - start }, 'Members export completed');
             }
         });
         return processingTransform;
@@ -95,7 +93,7 @@ class MembersCSVExporter {
             acc[label.id] = label.name;
             return acc;
         }, {}));
-        logging.info('[MembersExporter] Fetched products and labels in ' + (Date.now() - start) + 'ms');
+        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 };
     }

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

@@ -55,8 +55,6 @@ 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)));
 }
@@ -82,9 +80,8 @@ 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))))];

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

@@ -17,6 +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.',
 };
 // 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
@@ -90,7 +91,7 @@ class MembersCSVImporter {
         // a request without a user actually reaches the deferred path.
         const emailRecipient = requestUserEmail ?? (await this._email.getDefaultRecipient());
         const spooled = await this._spool.write(rows);
-        logging.info('[Background Job] members-import queued');
+        logging.info({ event: { name: 'members.import.queued' }, rows: rows.length }, 'Members import queued');
         this._addJob({
             job: () => this.runImportJob(spooled, { labelName, extraLabels, emailRecipient }, verificationTrigger),
             offloaded: false,
@@ -101,7 +102,7 @@ class MembersCSVImporter {
     // in the job itself, and there is no retry behind it.
     async runImportJob(spooled, { labelName, extraLabels, emailRecipient, }, verificationTrigger) {
         const startedAt = Date.now();
-        logging.info('[Background Job] members-import started');
+        logging.info({ event: { name: 'members.import.started' } }, 'Members import started');
         // Null until the import produces one: parsing and mapping already happened inside
         // the request, so anything failing from here is ours rather than the file's.
         let result = null;
@@ -125,10 +126,15 @@ class MembersCSVImporter {
             links: this._email.links,
         })));
         if (result) {
-            logging.info(`[Background Job] members-import completed in ${Date.now() - startedAt}ms: imported ${result.imported}, ${result.errors.length} row(s) rejected`);
+            logging.info({
+                event: { name: 'members.import.completed' },
+                durationMs: Date.now() - startedAt,
+                imported: result.imported,
+                rejected: result.errors.length,
+            }, 'Members import completed');
         }
         else {
-            logging.info(`[Background Job] members-import failed after ${Date.now() - startedAt}ms`);
+            logging.info({ event: { name: 'members.import.failed' }, durationMs: Date.now() - startedAt }, 'Members import failed');
         }
     }
     // Only the write itself may throw. Callers rely on that to tell an import that never
@@ -300,7 +306,17 @@ class MembersCSVImporter {
                     }
                 }
                 // On the row's transaction, so the values commit or roll back with the member.
-                await this._customFields.applyWrite(member.id, customFieldPlan, trx);
+                try {
+                    await this._customFields.applyWrite(member.id, customFieldPlan, trx);
+                }
+                catch (writeError) {
+                    // planWrite passed every value before the transaction opened, so a failure
+                    // here is ours and not the row's. Operators get the original, which a driver
+                    // 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) });
+                }
                 await trx.commit();
                 imported += 1;
             }

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,