ghost 6.60.0 → 6.62.0

package/core/server/services/auth/passwordreset.js

@@ -11,6 +11,7 @@ const mail = require('../mail');
 
 const messages = {
   userNotFound: 'User not found.',
+  userSuspended: 'This account has been suspended.',
   resetPassword: 'Reset Password',
   expired: {
     message: 'Cannot reset password.',
@@ -46,6 +47,14 @@ function generateToken(email, settingsAPI, transaction) {
         throw new errors.NotFoundError({ message: tpl(messages.userNotFound) });
       }
 
+      // Prevent suspended users from generating a reset token. This same check must appear
+      // below in doReset() to account for password reset tokens that were generated prior
+      // to suspension since they have a 24-hour lifetime.
+      // Locked users must still be able to recover access by resetting their password.
+      if (user.isInactive()) {
+        throw new errors.NoPermissionError({ message: tpl(messages.userSuspended) });
+      }
+
       token = security.tokens.resetToken.generateHash({
         expires: moment().add(1, 'days').valueOf(),
         email: email,
@@ -128,6 +137,10 @@ function doReset(options, tokenParts, settingsAPI) {
         }
       }
 
+      if (user.isInactive()) {
+        throw new errors.NoPermissionError({ message: tpl(messages.userSuspended) });
+      }
+
       const updatedUser = await models.User.changePassword(
         {
           oldPassword: oldPassword,

package/core/server/services/automations/database-automations-repository.js

@@ -13,7 +13,7 @@ const dequal_1 = require("dequal");
 const lexical_1 = __importDefault(require("../../lib/lexical"));
 const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
 const constants_1 = require("../member-welcome-emails/constants");
-const db_date_1 = require("../../lib/db-date");
+const date_1 = require("../../lib/db-types/date");
 const stale_lock_cutoff_1 = require("./stale-lock-cutoff");
 const HOUR_MS = 60 * 60 * 1000;
 const DEFAULT_WELCOME_EMAIL_AUTOMATIONS = [
@@ -93,7 +93,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier, })
                 const updatedAutomation = await updateAutomation(trx, {
                     ...automation,
                     status: data.status,
-                    updated_at: (0, db_date_1.toDatabaseDate)(now),
+                    updated_at: (0, date_1.toDatabaseDate)(now),
                 });
                 await replaceAutomationGraph(trx, updatedAutomation.id, data.actions, data.edges);
                 if (updatedAutomation.status === 'inactive') {
@@ -130,7 +130,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier, })
                     .update({
                     email_sent_count: trx.raw('COALESCE(??, 0) + ?', ['email_sent_count', 1]),
                 });
-                const now = (0, db_date_1.toDatabaseDate)(new Date());
+                const now = (0, date_1.toDatabaseDate)(new Date());
                 await trx('automated_email_recipients').insert({
                     id: (0, bson_objectid_1.default)().toHexString(),
                     member_id: options.memberId,
@@ -281,7 +281,7 @@ async function ensureDefaultAutomations(trx) {
     }
 }
 async function ensureAutomation(trx, defaults) {
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const id = (0, bson_objectid_1.default)().toHexString();
     await trx('automations')
         .insert({
@@ -313,7 +313,7 @@ async function ensureWelcomeEmailAction(trx, automationId) {
     if (!email) {
         return;
     }
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const actionId = (0, bson_objectid_1.default)().toHexString();
     await insertActions(trx, [
         {
@@ -347,7 +347,7 @@ async function trigger(trx, options) {
         return;
     }
     const now = new Date();
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     const readyAt = getReadyAtForAction(firstAction, now, fakeWaitHoursMultiplier);
     const run = {
         id: (0, bson_objectid_1.default)().toHexString(),
@@ -366,14 +366,14 @@ async function trigger(trx, options) {
     });
 }
 async function insertRunStep(trx, { automationRunId, automationActionRevisionId, now, readyAt, }) {
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     await trx('automation_run_steps').insert({
         id: (0, bson_objectid_1.default)().toHexString(),
         created_at: nowString,
         updated_at: nowString,
         automation_run_id: automationRunId,
         automation_action_revision_id: automationActionRevisionId,
-        ready_at: (0, db_date_1.toDatabaseDate)(readyAt),
+        ready_at: (0, date_1.toDatabaseDate)(readyAt),
     });
 }
 async function fetchAndLockSteps(trx, limit) {
@@ -388,9 +388,9 @@ async function fetchAndLockSteps(trx, limit) {
     // 2. Try to lock those rows.
     // 3. Select any rows we successfully locked.
     const now = new Date();
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     const staleLockCutoff = (0, stale_lock_cutoff_1.getStaleLockCutoff)(now);
-    const staleLockCutoffString = (0, db_date_1.toDatabaseDate)(staleLockCutoff);
+    const staleLockCutoffString = (0, date_1.toDatabaseDate)(staleLockCutoff);
     const lockId = node_crypto_1.default.randomUUID();
     // 1. Select up to `limit` candidate rows.
     const candidates = await trx('automation_run_steps')
@@ -444,17 +444,17 @@ async function findNextPendingReadyAt(trx, staleLockCutoff) {
         .select({ next_ready_at: 'ready_at' })
         .where('status', 'pending')
         .where((builder) => {
-        builder.whereNull('locked_by').orWhere('locked_at', '<', (0, db_date_1.toDatabaseDate)(staleLockCutoff));
+        builder.whereNull('locked_by').orWhere('locked_at', '<', (0, date_1.toDatabaseDate)(staleLockCutoff));
     })
         .orderBy('ready_at')
         .first();
-    return row?.next_ready_at ? (0, db_date_1.fromDatabaseDate)(row.next_ready_at) : null;
+    return row?.next_ready_at ? (0, date_1.fromDatabaseDate)(row.next_ready_at) : null;
 }
 function buildStepToRun(row) {
     const base = {
         id: row.id,
         step_attempts: row.step_attempts,
-        ready_at: (0, db_date_1.fromDatabaseDate)(row.ready_at),
+        ready_at: (0, date_1.fromDatabaseDate)(row.ready_at),
         locked_by: row.locked_by,
         automation_run_id: row.automation_run_id,
         automation_id: row.automation_id,
@@ -544,7 +544,7 @@ async function findNextActionRevision(trx, sourceActionId) {
     return row ?? null;
 }
 async function markStepTerminal(trx, step, status) {
-    const nowString = (0, db_date_1.toDatabaseDate)(new Date());
+    const nowString = (0, date_1.toDatabaseDate)(new Date());
     return await updateStep(trx, step, {
         status,
         finished_at: nowString,
@@ -556,12 +556,12 @@ async function retryStep(trx, step, retryAt) {
         await markStepTerminal(trx, step, 'automation disabled');
         return false;
     }
-    const nowString = (0, db_date_1.toDatabaseDate)(new Date());
+    const nowString = (0, date_1.toDatabaseDate)(new Date());
     return await updateStep(trx, step, {
         status: 'pending',
         started_at: null,
         finished_at: null,
-        ready_at: (0, db_date_1.toDatabaseDate)(retryAt),
+        ready_at: (0, date_1.toDatabaseDate)(retryAt),
         updated_at: nowString,
     });
 }
@@ -586,8 +586,8 @@ function getReadyAtForAction(action, now, fakeWaitHoursMultiplier) {
     }
 }
 async function cancelCancelablePendingStepsForAutomation(trx, automationId, now) {
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
-    const staleLockCutoff = (0, db_date_1.toDatabaseDate)((0, stale_lock_cutoff_1.getStaleLockCutoff)(now));
+    const nowString = (0, date_1.toDatabaseDate)(now);
+    const staleLockCutoff = (0, date_1.toDatabaseDate)((0, stale_lock_cutoff_1.getStaleLockCutoff)(now));
     await trx('automation_run_steps')
         .update({
         status: 'automation disabled',
@@ -707,7 +707,7 @@ async function replaceAutomationGraph(trx, automationId, submittedActions, edges
         revision.action_id,
         revision,
     ]));
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const actionsToInsert = [];
     const revisionsToInsert = [];
     for (const action of actions) {
@@ -884,14 +884,14 @@ async function insertActionRevisions(trx, revisions) {
 }
 function getNextRevisionCreatedAt(latestCreatedAt, requestedCreatedAt) {
     if (!latestCreatedAt) {
-        return (0, db_date_1.toDatabaseDate)(requestedCreatedAt);
+        return (0, date_1.toDatabaseDate)(requestedCreatedAt);
     }
-    const requestedTime = (0, db_date_1.fromDatabaseDate)(requestedCreatedAt).getTime();
-    const latestTime = (0, db_date_1.fromDatabaseDate)(latestCreatedAt).getTime();
+    const requestedTime = (0, date_1.fromDatabaseDate)(requestedCreatedAt).getTime();
+    const latestTime = (0, date_1.fromDatabaseDate)(latestCreatedAt).getTime();
     if (requestedTime > latestTime) {
-        return (0, db_date_1.toDatabaseDate)(requestedCreatedAt);
+        return (0, date_1.toDatabaseDate)(requestedCreatedAt);
     }
-    return (0, db_date_1.toDatabaseDate)(new Date(latestTime + 1000));
+    return (0, date_1.toDatabaseDate)(new Date(latestTime + 1000));
 }
 function buildActionRevision(actionId, action, createdAt) {
     switch (action.type) {
@@ -970,7 +970,7 @@ function buildAutomationBrowseResult(automation) {
         ...buildAutomationSummary(automation),
         stats: {
             last_run_created_at: automation.last_run_created_at
-                ? (0, db_date_1.fromDatabaseDate)(automation.last_run_created_at)
+                ? (0, date_1.fromDatabaseDate)(automation.last_run_created_at)
                 : null,
             total_run_count: Number(automation.total_run_count ?? 0),
             in_progress_run_count: Number(automation.in_progress_run_count ?? 0),
@@ -978,7 +978,7 @@ function buildAutomationBrowseResult(automation) {
     };
 }
 function serializeDate(date) {
-    const normalizedDate = (0, db_date_1.fromDatabaseDate)(date);
+    const normalizedDate = (0, date_1.fromDatabaseDate)(date);
     normalizedDate.setMilliseconds(0);
     return normalizedDate.toISOString();
 }

package/core/server/services/automations/poll.js

@@ -119,6 +119,7 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                         subject: step.email_subject,
                     },
                     member: {
+                        // Note that we don't use `automation_run.member_email` here. That's only for the historical record, not for functionality.
                         email: member.get('email'),
                         name: member.get('name'),
                         uuid: member.get('uuid'),

package/core/server/services/comments/comments-controller.js

@@ -14,6 +14,7 @@ const messages = {
   cannotDestroyComments: 'You cannot destroy comments.',
   memberNotFound: 'Unable to find member',
   unsupportedReportCountFilter: 'Unsupported count.reports filter',
+  errorParsingFilter: 'Error parsing filter',
 };
 
 module.exports = class CommentsController {
@@ -26,6 +27,16 @@ module.exports = class CommentsController {
     this.stats = stats;
   }
 
+  #getPostIdFromFilter(query) {
+    if (typeof query.post_id === 'string') {
+      return query.post_id;
+    }
+
+    // Only equality conditions required by an AND can scope a legacy browse.
+    // Choosing an ID from an OR or an exclusion would authorize the wrong posts.
+    return query.$and?.map((part) => this.#getPostIdFromFilter(part)).find(Boolean);
+  }
+
   #withPostFilter(options) {
     const nextOptions = { ...options };
 
@@ -138,7 +149,17 @@ module.exports = class CommentsController {
    * @param {Frame} frame
    */
   async browse(frame) {
-    return await this.service.getComments(this.#withPostFilter(frame.options));
+    const options = { ...frame.options };
+    if (!options.post_id && options.filter) {
+      let query;
+      try {
+        query = nql(options.filter).parse();
+      } catch (err) {
+        throw new errors.BadRequestError({ message: tpl(messages.errorParsingFilter), err });
+      }
+      options.post_id = this.#getPostIdFromFilter(query);
+    }
+    return await this.service.getComments(this.#withPostFilter(options));
   }
 
   async adminBrowse(frame) {
@@ -345,14 +366,14 @@ module.exports = class CommentsController {
   async like(frame) {
     this.#checkMember(frame);
 
+    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
+
     const result = await this.service.likeComment(
       frame.options.id,
       frame.options?.context?.member,
       frame.options,
     );
 
-    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
-
     this.setCacheInvalidationHeaders(comment, frame);
 
     return result;
@@ -364,14 +385,14 @@ module.exports = class CommentsController {
   async unlike(frame) {
     this.#checkMember(frame);
 
+    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
+
     const result = await this.service.unlikeComment(
       frame.options.id,
       frame.options?.context?.member,
       frame.options,
     );
 
-    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
-
     this.setCacheInvalidationHeaders(comment, frame);
 
     return result;
@@ -420,14 +441,14 @@ module.exports = class CommentsController {
   async dislike(frame) {
     this.#checkMember(frame);
 
+    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
+
     const result = await this.service.dislikeComment(
       frame.options.id,
       frame.options?.context?.member,
       frame.options,
     );
 
-    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
-
     this.setCacheInvalidationHeaders(comment, frame);
 
     return result;
@@ -439,14 +460,14 @@ module.exports = class CommentsController {
   async undislike(frame) {
     this.#checkMember(frame);
 
+    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
+
     const result = await this.service.undislikeComment(
       frame.options.id,
       frame.options?.context?.member,
       frame.options,
     );
 
-    const comment = await this.service.getCommentByID(frame.options.id, frame.options);
-
     this.setCacheInvalidationHeaders(comment, frame);
 
     return result;

package/core/server/services/comments/comments-service.js

@@ -13,7 +13,9 @@ const messages = {
   alreadyDisliked: 'This comment was disliked already',
   replyToReply: 'Can not reply to a reply',
   commentsNotEnabled: 'Comments are not enabled for this site.',
+  postIdRequired: 'A post ID is required to read comments.',
   cannotCommentOnPost: 'You do not have permission to comment on this post.',
+  cannotReadComment: 'You do not have permission to read comments on this post',
   cannotEditComment: 'You do not have permission to edit comments',
   cannotPinReply: 'Replies cannot be pinned',
   cannotPinDeletedComment: 'Deleted comments cannot be pinned',
@@ -39,7 +41,7 @@ const COMMENT_STATUSES_IN_REPLY_TO = [COMMENT_STATUS_PUBLISHED, COMMENT_STATUS_H
 // new `comment.get(...)` call has one obvious place to register its column.
 const REPLY_PARENT_REQUIRED_COLUMNS = ['parent_id', 'post_id'];
 const IN_REPLY_TO_REQUIRED_COLUMNS = ['parent_id'];
-const OWNERSHIP_REQUIRED_COLUMNS = ['member_id'];
+const OWNERSHIP_REQUIRED_COLUMNS = ['member_id', 'post_id'];
 const REPORT_REQUIRED_COLUMNS = ['post_id', 'member_id', 'html', 'created_at'];
 
 function getColumnList(columns) {
@@ -167,11 +169,14 @@ class CommentsService {
   }
 
   /** @private */
-  checkPostAccess(postModel, memberModel) {
-    const access = this.contentGating.checkPostAccess(postModel.toJSON(), memberModel.toJSON());
+  checkPostAccess(postModel, memberModel, { action = 'comment' } = {}) {
+    const access = this.contentGating.checkPostAccess(
+      postModel.toJSON(),
+      memberModel ? memberModel.toJSON() : null,
+    );
     if (access === this.contentGating.BLOCK_ACCESS) {
       throw new errors.NoPermissionError({
-        message: tpl(messages.cannotCommentOnPost),
+        message: tpl(action === 'read' ? messages.cannotReadComment : messages.cannotCommentOnPost),
       });
     }
   }
@@ -189,6 +194,32 @@ class CommentsService {
     });
   }
 
+  async #checkPostAccessForRead(postId, options) {
+    if (options.isAdmin) {
+      return;
+    }
+
+    if (!postId) {
+      throw new errors.ValidationError({ message: tpl(messages.postIdRequired) });
+    }
+
+    const postModel = await this.models.Post.findOne(
+      { id: postId },
+      { require: true, transacting: options.transacting, withRelated: ['tiers'] },
+    );
+
+    let memberModel = null;
+    const memberId = options.context?.member?.id;
+    if (memberId) {
+      memberModel = await this.models.Member.findOne(
+        { id: memberId },
+        { require: true, transacting: options.transacting, withRelated: ['products'] },
+      );
+    }
+
+    this.checkPostAccess(postModel, memberModel, { action: 'read' });
+  }
+
   /**
    * Primary comment lookup: a single keyed fetch with the allowed statuses
    * applied in the query (`WHERE id = ? AND status IN (...)`), optionally locked
@@ -520,6 +551,7 @@ class CommentsService {
    */
   async getComments(options) {
     this.checkEnabled();
+    await this.#checkPostAccessForRead(options.post_id, options);
     const page = await this.models.Comment.findPage(
       withPinnedSelect({ ...options, parentId: null, pinnedFirst: true }),
     );
@@ -659,6 +691,17 @@ class CommentsService {
    */
   async getReplies(id, options, { includeHidden = false } = {}) {
     this.checkEnabled();
+
+    const parentComment = await this.#fetchCommentByID(id, options, {
+      requiredColumns: ['post_id'],
+    });
+
+    if (!parentComment) {
+      throw new errors.NotFoundError({ message: tpl(messages.commentNotFound) });
+    }
+
+    await this.#checkPostAccessForRead(parentComment.get('post_id'), options);
+
     const page = await this.models.Comment.findPage(
       withPinnedSelect({ ...options, parentId: id }, { includeHidden }),
     );
@@ -740,7 +783,9 @@ class CommentsService {
   async getCommentByID(id, options = {}) {
     this.checkEnabled();
 
-    return await this.#getReadableCommentByID(id, options);
+    const model = await this.#getReadableCommentByID(id, options, ['post_id']);
+    await this.#checkPostAccessForRead(model.get('post_id'), options);
+    return model;
   }
 
   /**
@@ -908,6 +953,9 @@ class CommentsService {
       });
     }
 
+    // Mutation responses include replies, so they require the same post access as reads.
+    await this.#checkPostAccessForRead(existingComment.get('post_id'), options);
+
     const model = await this.models.Comment.edit(
       {
         status: COMMENT_STATUS_DELETED,
@@ -943,6 +991,8 @@ class CommentsService {
       });
     }
 
+    await this.#checkPostAccessForRead(existingComment.get('post_id'), options);
+
     if (!comment) {
       return existingComment;
     }

package/core/server/services/content-import/csv/formula.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripFormulaGuard = stripFormulaGuard;
+const FORMULA_TRIGGERS = ['=', '+', '-', '@', '\t', '\r'];
+// Report files prefix formula-shaped cells with an apostrophe. Remove exactly
+// that guard during re-import so repeated fixes do not change publisher data.
+function stripFormulaGuard(cell) {
+    if (cell.charAt(0) === "'" && FORMULA_TRIGGERS.includes(cell.charAt(1))) {
+        return cell.slice(1);
+    }
+    return cell;
+}

package/core/server/services/content-import/csv/index.js

@@ -3,6 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
+exports.stripFormulaGuard = exports.serialize = exports.parseWithSource = exports.parse = void 0;
 var parse_1 = require("./parse");
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return __importDefault(parse_1).default; } });
+Object.defineProperty(exports, "parseWithSource", { enumerable: true, get: function () { return parse_1.parseWithSource; } });
+var serialize_1 = require("./serialize");
+Object.defineProperty(exports, "serialize", { enumerable: true, get: function () { return __importDefault(serialize_1).default; } });
+var formula_1 = require("./formula");
+Object.defineProperty(exports, "stripFormulaGuard", { enumerable: true, get: function () { return formula_1.stripFormulaGuard; } });

package/core/server/services/content-import/csv/parse.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = parse;
+exports.parseWithSource = parseWithSource;
 const papaparse_1 = __importDefault(require("papaparse"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const formula_1 = require("./formula");
 const errors = require('@tryghost/errors');
 // A column named after an Object.prototype member is unsafe as a key.
 function isSafeColumnName(name) {
@@ -17,44 +19,63 @@ function isSafeColumnName(name) {
 function isFatal(error) {
     return error.type === 'Quotes';
 }
+function isEmptyRow(row) {
+    return !Object.values(row).some((value) => {
+        if (Array.isArray(value)) {
+            return value.some((cell) => typeof cell === 'string' && cell.trim().length > 0);
+        }
+        return value.trim().length > 0;
+    });
+}
 // headerMapping renames headers to the columns they emit under; unmapped columns
 // carry through, and one mapped to an empty target is dropped.
 async function parse(path, headerMapping) {
+    const parsed = await parseWithSource(path, headerMapping);
+    return parsed.rows.map(({ data }) => data);
+}
+async function parseWithSource(path, headerMapping) {
     // Buffered rather than streamed: files are bounded by the interim row cap, and
     // papaparse's stream mode drops results.errors, which is what catches a
     // malformed quoted field before it imports as garbage.
     const content = (await fs_extra_1.default.readFile(path, 'utf8')).replace(/^\ufeff/, '');
     const parsed = papaparse_1.default.parse(content, {
         header: true,
-        skipEmptyLines: true,
+        // Empty records stay in the parser output long enough to contribute to the
+        // publisher-visible spreadsheet line number, then are dropped below.
+        skipEmptyLines: false,
     });
     const fatal = parsed.errors.find(isFatal);
     if (fatal) {
         throw new errors.ValidationError({ message: `${fatal.code}: ${fatal.message}` });
     }
     const rows = [];
-    for (const parsedRow of parsed.data) {
+    for (const [index, parsedRow] of parsed.data.entries()) {
+        if (isEmptyRow(parsedRow)) {
+            continue;
+        }
         const row = {};
+        const source = Object.create(null);
         for (const [header, value] of Object.entries(parsedRow)) {
             // non-string values are papaparse's __parsed_extra overflow from ragged rows
             if (typeof value !== 'string') {
                 continue;
             }
+            source[header] = value;
             // hasOwn: a prototype-named header must not match an inherited method on the mapping
             if (headerMapping && Object.hasOwn(headerMapping, header)) {
                 if (!headerMapping[header]) {
                     continue;
                 }
-                row[headerMapping[header]] = value;
+                row[headerMapping[header]] = (0, formula_1.stripFormulaGuard)(value);
             }
             else if (isSafeColumnName(header)) {
-                row[header] = value;
+                row[header] = (0, formula_1.stripFormulaGuard)(value);
             }
         }
         if (!Object.keys(row).length) {
             continue;
         }
-        rows.push(row);
+        rows.push({ data: row, source, line: index + 2 });
     }
-    return rows;
+    return { columns: parsed.meta.fields ?? [], rows };
 }

package/core/server/services/content-import/csv/serialize.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serialize;
+const papaparse_1 = __importDefault(require("papaparse"));
+// Import reports are opened in spreadsheets, so formula-shaped cells must never
+// be emitted verbatim. Papa Parse prefixes them with an apostrophe when this
+// option is enabled.
+function serialize(rows, { columns, header = true } = {}) {
+    return papaparse_1.default.unparse(rows, { columns, header, escapeFormulae: true });
+}

package/core/server/services/content-import/import/assets.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparedAssetBatch = void 0;
+exports.prepareAssetBatch = prepareAssetBatch;
+exports.belongsToAssetDirectory = belongsToAssetDirectory;
+const content_files_1 = require("../../../data/importer/content-files");
+class PreparedAssetBatch {
+    groups;
+    constructor(groups) {
+        this.groups = groups;
+    }
+    get files() {
+        return this.groups.flatMap((group) => group.files);
+    }
+    async store() {
+        const results = await Promise.allSettled(this.groups.map((group) => group.importer.doImport(group.files)));
+        const failure = results.find((result) => result.status === 'rejected');
+        if (failure) {
+            const rollbackResults = await Promise.allSettled(results.flatMap((result, index) => result.status === 'fulfilled' ? [this.groups[index].importer.rollback(result.value)] : []));
+            const rollbackFailures = rollbackResults.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+            if (rollbackFailures.length > 0) {
+                // AggregateError is the native error for preserving storage and rollback
+                // failures; unlike GhostError it takes an iterable before its options.
+                // eslint-disable-next-line ghost/ghost-custom/ghost-error-usage
+                throw new AggregateError([failure.reason, ...rollbackFailures], 'Asset storage failed and rollback was incomplete.', { cause: failure.reason });
+            }
+            throw failure.reason;
+        }
+    }
+    rewriteRows(rows) {
+        const importData = {
+            data: { data: { posts: rows, tags: [], users: [] } },
+        };
+        for (const group of this.groups) {
+            importData[group.type] = group.files;
+            group.importer.preProcess(importData);
+        }
+    }
+}
+exports.PreparedAssetBatch = PreparedAssetBatch;
+async function prepareAssetBatch(archive, directory, baseDirectory, deps = {}) {
+    const handlers = deps.handlers ?? (0, content_files_1.createContentFileHandlers)();
+    const importers = deps.importers ?? (0, content_files_1.createContentFileImporters)();
+    const importerByType = new Map(importers.map((importer) => [importer.type, importer]));
+    const groups = await Promise.all(handlers.map(async (handler) => {
+        const files = archive
+            .getFiles(directory, handler.extensions)
+            .filter((file) => belongsToAssetDirectory(file.name, handler.type, baseDirectory));
+        if (files.length === 0) {
+            return;
+        }
+        const importer = importerByType.get(handler.type);
+        if (!importer) {
+            return;
+        }
+        return {
+            type: handler.type,
+            files: await handler.loadFile(files, baseDirectory),
+            importer,
+        };
+    }));
+    const presentGroups = groups.filter((group) => group !== undefined);
+    return presentGroups.length > 0 ? new PreparedAssetBatch(presentGroups) : undefined;
+}
+function belongsToAssetDirectory(fileName, type, baseDirectory) {
+    const parts = fileName.split('/').filter(Boolean);
+    if (baseDirectory && parts[0] === baseDirectory) {
+        parts.shift();
+    }
+    if (parts[0] === 'content') {
+        parts.shift();
+    }
+    return parts.length > 1 && parts[0] === type;
+}