ghost 6.60.0 → 6.61.0

package/core/server/data/importer/import-archive.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const glob_1 = require("glob");
+const { extract } = require('@tryghost/zip');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+const messages = {
+    noContentToImport: 'Zip did not include any content to import.',
+    invalidZipStructure: 'Invalid zip file structure.',
+    invalidZipFileBaseDirectory: 'Invalid zip file: base directory read failed',
+    invalidZipFileNameEncoding: 'The uploaded zip could not be read',
+    invalidZipFileNameEncodingContext: 'The filename was too long or contained invalid characters',
+    invalidZipFileNameEncodingHelp: 'Remove any special characters from the file name, or alternatively try another archiving tool if using MacOS Archive Utility',
+};
+const ROOT_ONLY = 0;
+const ROOT_OR_SINGLE_DIR = 1;
+const ALL_DIRS = 2;
+class ImportArchive {
+    extensions;
+    directories;
+    extractArchive;
+    constructor({ extensions, directories }, { extract: extractArchive = extract } = {}) {
+        this.extensions = extensions;
+        this.directories = directories;
+        this.extractArchive = extractArchive;
+    }
+    getGlobPattern(items) {
+        return `+(${items.join('|')})`;
+    }
+    getExtensionGlob(extensions, level) {
+        const prefix = level === ALL_DIRS ? '**/*' : level === ROOT_OR_SINGLE_DIR ? '{*/*,*}' : '*';
+        return prefix + this.getGlobPattern(extensions);
+    }
+    getDirectoryGlob(directories, level) {
+        const prefix = level === ALL_DIRS ? '**/' : level === ROOT_OR_SINGLE_DIR ? '{*/,}' : '';
+        return prefix + this.getGlobPattern(directories);
+    }
+    isValid(directory) {
+        const extMatchesBase = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ROOT_OR_SINGLE_DIR), {
+            cwd: directory,
+            nocase: true,
+        });
+        const extMatchesAll = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ALL_DIRS), {
+            cwd: directory,
+            nocase: true,
+        });
+        const dirMatches = this.directories.length
+            ? (0, glob_1.globSync)(this.getDirectoryGlob(this.directories, ROOT_OR_SINGLE_DIR), {
+                cwd: directory,
+            })
+            : [];
+        if (extMatchesBase.length > 0 || (dirMatches.length > 0 && extMatchesAll.length > 0)) {
+            return true;
+        }
+        if (extMatchesAll.length < 1) {
+            throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.noContentToImport) });
+        }
+        throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.invalidZipStructure) });
+    }
+    getBaseDirectory(directory) {
+        const extMatches = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ROOT_ONLY), {
+            cwd: directory,
+            nocase: true,
+        });
+        const dirMatches = this.directories.length
+            ? (0, glob_1.globSync)(this.getDirectoryGlob(this.directories, ROOT_ONLY), {
+                cwd: directory,
+                nocase: true,
+            })
+            : [];
+        if (extMatches.length > 0 || dirMatches.length > 0) {
+            return;
+        }
+        const extMatchesAll = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ALL_DIRS), {
+            cwd: directory,
+            nocase: true,
+        });
+        const firstMatch = extMatchesAll[0];
+        if (!firstMatch) {
+            throw new errors.ValidationError({ message: tpl(messages.invalidZipFileBaseDirectory) });
+        }
+        return firstMatch.split('/')[0];
+    }
+    getFiles(directory, extensions) {
+        const globPattern = this.getExtensionGlob(extensions, ALL_DIRS);
+        return (0, glob_1.globSync)(globPattern, { cwd: directory, nocase: true }).map((file) => ({
+            name: file,
+            path: node_path_1.default.join(directory, file),
+        }));
+    }
+    async extract(filePath) {
+        const tmpDir = node_path_1.default.join(node_os_1.default.tmpdir(), node_crypto_1.default.randomUUID());
+        try {
+            await this.extractArchive(filePath, tmpDir);
+            const files = (0, glob_1.globSync)('**/*', { cwd: tmpDir, nodir: true });
+            await Promise.all(files.map((file) => fs_extra_1.default.chmod(node_path_1.default.join(tmpDir, file), 0o644)));
+        }
+        catch (error) {
+            await fs_extra_1.default.remove(tmpDir).catch(() => { });
+            const message = messageOf(error);
+            if (message.startsWith('ENAMETOOLONG:')) {
+                throw new errors.UnsupportedMediaTypeError({
+                    message: tpl(messages.invalidZipFileNameEncoding),
+                    context: tpl(messages.invalidZipFileNameEncodingContext),
+                    help: tpl(messages.invalidZipFileNameEncodingHelp),
+                    code: 'INVALID_ZIP_FILE_NAME_ENCODING',
+                });
+            }
+            if (message.includes('end of central directory record signature not found') ||
+                message.includes('invalid comment length')) {
+                throw new errors.UnsupportedMediaTypeError({
+                    message: tpl(messages.invalidZipFileNameEncoding),
+                    code: 'INVALID_ZIP_FILE',
+                });
+            }
+            throw error;
+        }
+        return tmpDir;
+    }
+}
+exports.default = ImportArchive;
+function messageOf(error) {
+    return error instanceof Error ? error.message : '';
+}

package/core/server/data/importer/import-manager.js

@@ -1,31 +1,21 @@
 const _ = require('lodash');
 const fs = require('fs-extra');
 const path = require('path');
-const os = require('os');
-const { globSync } = require('glob');
-const crypto = require('crypto');
 const config = require('../../../shared/config');
-const { extract } = require('@tryghost/zip');
 const tpl = require('@tryghost/tpl');
 const debug = require('@tryghost/debug')('import-manager');
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
-const ImageHandler = require('./handlers/image');
-const ImporterContentFileHandler = require('./handlers/importer-content-file-handler');
 const RevueHandler = require('./handlers/revue');
 const JSONHandler = require('./handlers/json');
 const MarkdownHandler = require('./handlers/markdown');
-const ContentFileImporter = require('./importers/content-file-importer');
 const RevueImporter = require('./importers/importer-revue');
 const DataImporter = require('./importers/data');
 const urlUtils = require('../../../shared/url-utils').default;
 const { GhostMailer } = require('../../services/mail');
 const jobManager = require('../../services/jobs');
-const adapterManager = require('../../services/adapter-manager').default;
-
-const mediaStorage = adapterManager.getAdapter('storage:media');
-const imageStorage = adapterManager.getAdapter('storage:images');
-const fileStorage = adapterManager.getAdapter('storage:files');
+const ImportArchive = require('./import-archive').default;
+const { createContentFileHandlers, createContentFileImporters } = require('./content-files');
 
 const { emailTemplate } = require('./email-template');
 const ghostMailer = new GhostMailer();
@@ -36,21 +26,9 @@ const messages = {
     context: 'Your site will continue to work as expected',
   },
   noContentToImport: 'Zip did not include any content to import.',
-  invalidZipStructure: 'Invalid zip file structure.',
-  invalidZipFileBaseDirectory: 'Invalid zip file: base directory read failed',
   zipContainsMultipleDataFormats:
     'Zip file contains multiple data formats. Please split up and import separately.',
-  invalidZipFileNameEncoding: 'The uploaded zip could not be read',
-  invalidZipFileNameEncodingContext: 'The filename was too long or contained invalid characters',
-  invalidZipFileNameEncodingHelp:
-    'Remove any special characters from the file name, or alternatively try another archiving tool if using MacOS Archive Utility',
 };
-
-// Glob levels
-const ROOT_ONLY = 0;
-
-const ROOT_OR_SINGLE_DIR = 1;
-const ALL_DIRS = 2;
 let defaults = {
   extensions: ['.zip'],
   contentTypes: ['application/zip', 'application/x-zip-compressed'],
@@ -59,68 +37,23 @@ let defaults = {
 
 class ImportManager {
   constructor() {
-    const mediaHandler = new ImporterContentFileHandler({
-      type: 'media',
-      // @NOTE: making the second parameter strict folder "content/media" brakes the glob pattern
-      //        in the importer, so we need to keep it as general "content" unless
-      //        it becomes a strict requirement
-      directories: ['media', 'content'],
-      ignoreRootFolderFiles: true,
-      extensions: config.get('uploads').media.extensions,
-      contentTypes: config.get('uploads').media.contentTypes,
-      urlUtils: urlUtils,
-      storage: mediaStorage,
-    });
-
-    const filesHandler = new ImporterContentFileHandler({
-      type: 'files',
-      // @NOTE: making the second parameter strict folder "content/files" brakes the glob pattern
-      //        in the importer, so we need to keep it as general "content" unless
-      //        it becomes a strict requirement
-      directories: ['files', 'content'],
-      ignoreRootFolderFiles: true,
-      extensions: config.get('uploads').files.extensions,
-      contentTypes: config.get('uploads').files.contentTypes,
-      urlUtils: urlUtils,
-      storage: fileStorage,
-    });
-
-    const imageImporter = new ContentFileImporter({
-      type: 'images',
-      store: imageStorage,
-    });
-    const mediaImporter = new ContentFileImporter({
-      type: 'media',
-      store: mediaStorage,
-    });
-
-    const contentFilesImporter = new ContentFileImporter({
-      type: 'files',
-      store: fileStorage,
-    });
+    const contentFileHandlers = createContentFileHandlers();
+    const contentFileImporters = createContentFileImporters();
 
     /**
      * @type {Importer[]} importers
      */
-    this.importers = [
-      imageImporter,
-      mediaImporter,
-      contentFilesImporter,
-      RevueImporter,
-      DataImporter,
-    ];
+    this.importers = [...contentFileImporters, RevueImporter, DataImporter];
 
     /**
      * @type {Handler[]}
      */
-    this.handlers = [
-      ImageHandler,
-      mediaHandler,
-      filesHandler,
-      RevueHandler,
-      JSONHandler,
-      MarkdownHandler,
-    ];
+    this.handlers = [...contentFileHandlers, RevueHandler, JSONHandler, MarkdownHandler];
+
+    this.archive = new ImportArchive({
+      extensions: this.getExtensions(),
+      directories: this.getDirectories(),
+    });
 
     // Keep track of file to cleanup at the end
     /**
@@ -159,17 +92,7 @@ class ImportManager {
    * @returns {string}
    */
   getGlobPattern(items) {
-    return (
-      '+(' +
-      _.reduce(
-        items,
-        function (memo, ext) {
-          return memo !== '' ? memo + '|' + ext : ext;
-        },
-        '',
-      ) +
-      ')'
-    );
+    return this.archive.getGlobPattern(items);
   }
 
   /**
@@ -178,9 +101,7 @@ class ImportManager {
    * @returns {string}
    */
   getExtensionGlob(extensions, level) {
-    const prefix = level === ALL_DIRS ? '**/*' : level === ROOT_OR_SINGLE_DIR ? '{*/*,*}' : '*';
-
-    return prefix + this.getGlobPattern(extensions);
+    return this.archive.getExtensionGlob(extensions, level);
   }
 
   /**
@@ -190,9 +111,7 @@ class ImportManager {
    * @returns {string}
    */
   getDirectoryGlob(directories, level) {
-    const prefix = level === ALL_DIRS ? '**/' : level === ROOT_OR_SINGLE_DIR ? '{*/,}' : '';
-
-    return prefix + this.getGlobPattern(directories);
+    return this.archive.getDirectoryGlob(directories, level);
   }
 
   /**
@@ -212,31 +131,7 @@ class ImportManager {
    * @returns {boolean}
    */
   isValidZip(directory) {
-    // Globs match content in the root or inside a single directory
-    const extMatchesBase = globSync(
-      this.getExtensionGlob(this.getExtensions(), ROOT_OR_SINGLE_DIR),
-      { cwd: directory, nocase: true },
-    );
-
-    const extMatchesAll = globSync(this.getExtensionGlob(this.getExtensions(), ALL_DIRS), {
-      cwd: directory,
-      nocase: true,
-    });
-
-    const dirMatches = globSync(this.getDirectoryGlob(this.getDirectories(), ROOT_OR_SINGLE_DIR), {
-      cwd: directory,
-    });
-
-    // If this folder contains importable files or a content or images directory
-    if (extMatchesBase.length > 0 || (dirMatches.length > 0 && extMatchesAll.length > 0)) {
-      return true;
-    }
-
-    if (extMatchesAll.length < 1) {
-      throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.noContentToImport) });
-    }
-
-    throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.invalidZipStructure) });
+    return this.archive.isValid(directory);
   }
 
   /**
@@ -245,37 +140,8 @@ class ImportManager {
    * @returns {Promise<string>} full path to the extracted folder
    */
   async extractZip(filePath) {
-    const tmpDir = path.join(os.tmpdir(), crypto.randomUUID());
+    const tmpDir = await this.archive.extract(filePath);
     this.fileToDelete = tmpDir;
-
-    try {
-      await extract(filePath, tmpDir);
-
-      // Set permissions for all extracted files
-      const files = globSync('**/*', { cwd: tmpDir, nodir: true });
-      await Promise.all(files.map((file) => fs.chmod(path.join(tmpDir, file), 0o644)));
-    } catch (err) {
-      if (err.message.startsWith('ENAMETOOLONG:')) {
-        // The file was probably zipped with MacOS zip utility. Which doesn't correctly set UTF-8 encoding flag.
-        // This causes ENAMETOOLONG error on Linux, because the resulting filename length is too long when decoded using the default string encoder.
-        throw new errors.UnsupportedMediaTypeError({
-          message: tpl(messages.invalidZipFileNameEncoding),
-          context: tpl(messages.invalidZipFileNameEncodingContext),
-          help: tpl(messages.invalidZipFileNameEncodingHelp),
-          code: 'INVALID_ZIP_FILE_NAME_ENCODING',
-        });
-      } else if (
-        err.message.includes('end of central directory record signature not found') ||
-        err.message.includes('invalid comment length')
-      ) {
-        // This comes from Yauzl when the zip is invalid
-        throw new errors.UnsupportedMediaTypeError({
-          message: tpl(messages.invalidZipFileNameEncoding),
-          code: 'INVALID_ZIP_FILE',
-        });
-      }
-      throw err;
-    }
     return tmpDir;
   }
 
@@ -287,10 +153,7 @@ class ImportManager {
    * @returns {File[]} Files
    */
   getFilesFromZip(handler, directory) {
-    const globPattern = this.getExtensionGlob(handler.extensions, ALL_DIRS);
-    return _.map(globSync(globPattern, { cwd: directory, nocase: true }), function (file) {
-      return { name: file, path: path.join(directory, file) };
-    });
+    return this.archive.getFiles(directory, handler.extensions);
   }
 
   /**
@@ -299,32 +162,7 @@ class ImportManager {
    * @returns {string}
    */
   getBaseDirectory(directory) {
-    // Globs match root level only
-    const extMatches = globSync(this.getExtensionGlob(this.getExtensions(), ROOT_ONLY), {
-      cwd: directory,
-      nocase: true,
-    });
-
-    const dirMatches = globSync(this.getDirectoryGlob(this.getDirectories(), ROOT_ONLY), {
-      cwd: directory,
-      nocase: true,
-    });
-    let extMatchesAll;
-
-    // There is no base directory
-    if (extMatches.length > 0 || dirMatches.length > 0) {
-      return;
-    }
-    // There is a base directory, grab it from any ext match
-    extMatchesAll = globSync(this.getExtensionGlob(this.getExtensions(), ALL_DIRS), {
-      cwd: directory,
-      nocase: true,
-    });
-    if (extMatchesAll.length < 1 || extMatchesAll[0].split('/').length < 1) {
-      throw new errors.ValidationError({ message: tpl(messages.invalidZipFileBaseDirectory) });
-    }
-
-    return extMatchesAll[0].split('/')[0];
+    return this.archive.getBaseDirectory(directory);
   }
 
   /**

package/core/server/data/importer/importers/content-file-importer.js

@@ -1,4 +1,5 @@
 const _ = require('lodash');
+const path = require('node:path');
 let replaceImage;
 let preProcessPosts;
 let preProcessTags;
@@ -9,8 +10,19 @@ replaceImage = function (markdown, image) {
     return;
   }
 
-  // Normalizes to include a trailing slash if there was one
-  const regex = new RegExp('(/)?' + image.originalPath, 'gm');
+  const originalPaths = [image.originalPath];
+  if (image.originalPath.startsWith('content/')) {
+    originalPaths.push(image.originalPath.slice('content/'.length));
+  } else {
+    originalPaths.unshift(`content/${image.originalPath}`);
+  }
+
+  // Match canonical /content/{type} paths before their shorter archive path so
+  // replacing images/image.jpg cannot leave an extra /content prefix behind.
+  // Consume __GHOST_URL__ too: newPath already contains the configured subdir
+  // and the model will normalize it back to transform-ready form on write.
+  const escapedPaths = originalPaths.map((originalPath) => _.escapeRegExp(originalPath));
+  const regex = new RegExp(`(?:__GHOST_URL__)?/?(?:${escapedPaths.join('|')})`, 'gm');
 
   return markdown.replace(regex, image.newPath);
 };
@@ -31,6 +43,12 @@ preProcessPosts = function (data, contentFile) {
     if (post.feature_image) {
       post.feature_image = replaceImage(post.feature_image, contentFile);
     }
+    if (post.og_image) {
+      post.og_image = replaceImage(post.og_image, contentFile);
+    }
+    if (post.twitter_image) {
+      post.twitter_image = replaceImage(post.twitter_image, contentFile);
+    }
   });
 };
 
@@ -114,10 +132,10 @@ class ContentFileImporter {
    * @param {Object[]} contentFilesData
    * @returns
    */
-  doImport(contentFilesData) {
+  async doImport(contentFilesData) {
     const store = this.#store;
 
-    return Promise.all(
+    const results = await Promise.allSettled(
       contentFilesData.map(function (contentFile) {
         return store.save(contentFile, contentFile.targetDir).then(function (result) {
           return {
@@ -128,6 +146,50 @@ class ContentFileImporter {
         });
       }),
     );
+
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure) {
+      const storedFiles = results.flatMap((result) =>
+        result.status === 'fulfilled' ? [result.value] : [],
+      );
+      try {
+        await this.rollback(storedFiles);
+      } catch (rollbackFailure) {
+        // AggregateError is the native error for preserving both storage failures;
+        // it is not a GhostError and therefore does not accept an options object.
+        // eslint-disable-next-line ghost/ghost-custom/ghost-error-usage
+        throw new AggregateError(
+          [failure.reason, rollbackFailure],
+          'Asset storage failed and rollback was incomplete.',
+          { cause: failure.reason },
+        );
+      }
+      throw failure.reason;
+    }
+
+    return results.map((result) => result.value);
+  }
+
+  /**
+   * @param {{stored: string}[]} storedFiles
+   * @returns {Promise<void>}
+   */
+  async rollback(storedFiles) {
+    const store = this.#store;
+    const results = await Promise.allSettled(
+      storedFiles.map(function (storedFile) {
+        const storedPath = store.urlToPath(storedFile.stored);
+        const targetDir = path.posix.dirname(storedPath);
+        return store.delete(
+          path.posix.basename(storedPath),
+          targetDir === '.' ? undefined : targetDir,
+        );
+      }),
+    );
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure) {
+      throw failure.reason;
+    }
   }
 }
 

package/core/server/data/migrations/versions/6.61/2026-08-19-14-30-20-add-written-by-to-members-custom-field-values.js

@@ -0,0 +1,42 @@
+const logging = require('@tryghost/logging');
+const {
+  combineNonTransactionalMigrations,
+  createAddColumnMigration,
+  createNonTransactionalMigration,
+} = require('../../utils');
+
+const TABLE = 'members_custom_field_values';
+
+// Who wrote the value that is here now: a type and an id, the way `actions` records an
+// actor. The type is required because it is the namespace the id resolves in, and a value
+// nobody can be traced to is not a record of provenance. The id is nullable for the one
+// writer that resolves in no table — an import, until runs are tracked.
+//
+// Existing rows have a writer nobody can recover, so they go rather than get backfilled:
+// the feature is behind the `membersCustomFields` flag with no released data, and adding
+// a required column over them ends either in an error, as SQLite refuses one with no
+// default, or in an invented writer wherever the engine supplies its own empty string.
+module.exports = combineNonTransactionalMigrations(
+  createNonTransactionalMigration(
+    async function up(knex) {
+      if (!(await knex.schema.hasColumn(TABLE, 'written_by_type'))) {
+        logging.info(`Clearing ${TABLE} of values with no recorded writer`);
+        await knex(TABLE).del();
+      }
+    },
+    async function down() {
+      // Nothing to undo: the rows are gone, and dropping the columns below is what a
+      // rollback is for.
+    },
+  ),
+  createAddColumnMigration(TABLE, 'written_by_type', {
+    type: 'string',
+    maxlength: 50,
+    nullable: false,
+  }),
+  createAddColumnMigration(TABLE, 'written_by_id', {
+    type: 'string',
+    maxlength: 24,
+    nullable: true,
+  }),
+);

package/core/server/data/migrations/versions/6.61/2026-08-19-14-38-53-add-members-custom-field-bindings-table.js

@@ -0,0 +1,26 @@
+const { addTable } = require('../../utils');
+
+module.exports = addTable('members_custom_field_bindings', {
+  id: { type: 'string', maxlength: 24, nullable: false, primary: true },
+  product_id: {
+    type: 'string',
+    maxlength: 24,
+    nullable: false,
+    references: 'products.id',
+    cascadeDelete: true,
+  },
+  port: { type: 'string', maxlength: 191, nullable: false },
+  custom_field_key: {
+    type: 'string',
+    maxlength: 191,
+    nullable: false,
+    references: 'members_custom_fields.key',
+    cascadeDelete: true,
+  },
+  created_at: { type: 'dateTime', nullable: false },
+  updated_at: { type: 'dateTime', nullable: true },
+  '@@UNIQUE_CONSTRAINTS@@': [
+    { columns: ['product_id', 'port'], indexName: 'members_custom_field_bindings_unique' },
+  ],
+  '@@INDEXES@@': [['custom_field_key']],
+});

package/core/server/data/migrations/versions/6.61/2026-08-19-14-48-06-add-tier-checkout-field-tables.js

@@ -0,0 +1,35 @@
+const { combineNonTransactionalMigrations, addTable } = require('../../utils');
+
+module.exports = combineNonTransactionalMigrations(
+  addTable('products_checkout_fields', {
+    id: { type: 'string', maxlength: 24, nullable: false, primary: true },
+    binding_id: {
+      type: 'string',
+      maxlength: 24,
+      nullable: false,
+      unique: true,
+      references: 'members_custom_field_bindings.id',
+      cascadeDelete: true,
+    },
+    sort_order: { type: 'integer', nullable: false, unsigned: true, defaultTo: 0 },
+    label: { type: 'string', maxlength: 191, nullable: true },
+    optional: { type: 'boolean', nullable: false, defaultTo: true },
+    created_at: { type: 'dateTime', nullable: false },
+    updated_at: { type: 'dateTime', nullable: true },
+  }),
+  addTable('products_checkout_config', {
+    id: { type: 'string', maxlength: 24, nullable: false, primary: true },
+    product_id: {
+      type: 'string',
+      maxlength: 24,
+      nullable: false,
+      unique: true,
+      references: 'products.id',
+      cascadeDelete: true,
+    },
+    shipping_allowed_countries: { type: 'string', maxlength: 2000, nullable: true },
+    tax_number_collect: { type: 'boolean', nullable: false, defaultTo: false },
+    created_at: { type: 'dateTime', nullable: false },
+    updated_at: { type: 'dateTime', nullable: true },
+  }),
+);