ghost 6.55.0 → 6.57.0

package/core/server/data/migrations/versions/6.57/2026-08-04-18-00-00-store-custom-field-values-as-leaf-rows.js

@@ -0,0 +1,74 @@
+const logging = require('@tryghost/logging');
+const {createNonTransactionalMigration} = require('../../utils');
+const {addColumn, dropColumn, addUnique, dropUnique, addIndex, dropIndex} = require('../../../schema/commands');
+
+const TABLE = 'members_custom_field_values';
+
+// Named explicitly; the derived name would overrun MySQL's identifier limit, which
+// schema.test.js checks for every table.
+const LEAF_UNIQUE = 'members_custom_field_values_leaf_unique';
+
+// Values are discarded rather than converted: custom fields sit behind a private flag and
+// have never been released, so only a site deliberately opted in can hold one.
+async function discardStoredValues(knex) {
+    const discarded = await knex(TABLE).del();
+    if (discarded > 0) {
+        logging.warn(`Discarded ${discarded} custom field value(s): the storage format changed before the feature was released`);
+    }
+}
+
+// Column changes ask for `auto` so MySQL picks an in-place algorithm where it can; the
+// helpers otherwise default to a full table copy, which blocks writes.
+//
+// Two constraints shape the order of everything below.
+//
+// MySQL refuses to drop the last index serving a foreign key, counting any index whose
+// leftmost column is the referencing one, so each replacement is added before the thing
+// it replaces is dropped.
+//
+// This migration is not transactional, so a crash leaves the table half-changed with
+// nothing recorded as done and knex-migrator runs it again on the next boot. Every step
+// therefore tolerates having already happened: the constraint and index helpers swallow
+// that themselves, the column steps ask first.
+module.exports = createNonTransactionalMigration(
+    async function up(knex) {
+        // First, so nothing can collide with the new constraint.
+        await discardStoredValues(knex);
+
+        if (!await knex.schema.hasColumn(TABLE, 'path')) {
+            await addColumn(TABLE, 'path', knex, undefined, {algorithm: 'auto'});
+        }
+
+        // `member_id` stays leftmost, covering that foreign key the moment this exists.
+        await addUnique(TABLE, ['member_id', 'custom_field_id', 'path'], knex, LEAF_UNIQUE);
+        await dropUnique(TABLE, ['member_id', 'custom_field_id'], knex);
+
+        if (await knex.schema.hasColumn(TABLE, 'value_json')) {
+            await dropColumn(TABLE, 'value_json', knex, {}, {algorithm: 'auto'});
+        }
+        await addIndex(TABLE, ['custom_field_id', 'path'], knex);
+
+        // Only present after a rollback, where `down` adds it to keep a foreign key
+        // covered. Leaving it would be drift against a fresh install.
+        await dropIndex(TABLE, ['custom_field_id'], knex);
+    },
+    async function down(knex) {
+        // Rebuilding a composite would need the field-type catalog, which a migration must
+        // not read: it has to keep working when the catalog moves on.
+        await discardStoredValues(knex);
+
+        await addUnique(TABLE, ['member_id', 'custom_field_id'], knex);
+        await dropUnique(TABLE, ['member_id', 'custom_field_id', 'path'], knex, LEAF_UNIQUE);
+
+        // Back before the composite one goes, or MySQL has nothing covering that key.
+        await addIndex(TABLE, ['custom_field_id'], knex);
+        await dropIndex(TABLE, ['custom_field_id', 'path'], knex);
+
+        if (!await knex.schema.hasColumn(TABLE, 'value_json')) {
+            await addColumn(TABLE, 'value_json', knex, {type: 'text', maxlength: 65535, nullable: true}, {algorithm: 'auto'});
+        }
+        if (await knex.schema.hasColumn(TABLE, 'path')) {
+            await dropColumn(TABLE, 'path', knex, {}, {algorithm: 'auto'});
+        }
+    }
+);

package/core/server/data/migrations/versions/6.57/2026-08-04-18-54-14-reset-automation-email-analytics.js

@@ -0,0 +1,25 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Resetting automation email analytics counts');
+
+        const updatedRevisions = await knex('automation_action_revisions').update({
+            email_sent_count: null,
+            email_opened_count: null,
+            email_clicked_count: null
+        });
+
+        logging.info(`Reset automation email analytics counts for ${updatedRevisions} action revisions`);
+
+        const deletedRecipients = await knex('automated_email_recipients')
+            .whereNotNull('automation_action_revision_id')
+            .del();
+
+        logging.info(`Deleted ${deletedRecipients} automation email recipient rows`);
+    },
+    async function down() {
+        logging.info('Skipping rollback for automation email analytics reset');
+    }
+);

package/core/server/data/schema/commands.js

@@ -276,13 +276,18 @@ async function dropIndex(tableName, columns, transaction = db.knex) {
  * @param {string} tableName - name of the table to add unique constraint to
  * @param {string|string[]} columns - column(s) to form unique constraint with
  * @param {import('knex').Knex} [transaction] - connection object containing knex reference
+ * @param {string} [indexName] - name for the constraint; knex derives one from the table
+ * and every column when omitted, which can overrun MySQL's 64-character limit
  */
-async function addUnique(tableName, columns, transaction = db.knex) {
+async function addUnique(tableName, columns, transaction = db.knex, indexName) {
     try {
         logging.info(`Adding unique constraint for '${columns}' in table '${tableName}'`);
 
         return await transaction.schema.table(tableName, function (table) {
-            table.unique(columns);
+            // Knex derives a name from the table and every column when it is not given
+            // one, and that can overrun MySQL's 64-character identifier limit on a wide
+            // table or a constraint over several columns.
+            table.unique(columns, indexName ? {indexName} : undefined);
         });
     } catch (err) {
         if (err.code === 'SQLITE_ERROR') {
@@ -304,12 +309,14 @@ async function addUnique(tableName, columns, transaction = db.knex) {
  * @param {string|string[]} columns - column(s) unique constraint was formed
  * @param {import('knex').Knex} transaction - connection object containing knex reference
  */
-async function dropUnique(tableName, columns, transaction = db.knex) {
+async function dropUnique(tableName, columns, transaction = db.knex, indexName) {
     try {
         logging.info(`Dropping unique constraint for '${columns}' in table '${tableName}'`);
 
         return await transaction.schema.table(tableName, function (table) {
-            table.dropUnique(columns);
+            // Named constraints have to be dropped by that name: the one knex would
+            // derive from the columns is not what is on the table.
+            table.dropUnique(columns, indexName);
         });
     } catch (err) {
         if (err.code === 'SQLITE_ERROR') {
@@ -542,7 +549,16 @@ function createTable(table, transaction = db.knex, tableSpec = schema[table]) {
             });
         }
         if (tableSpec['@@UNIQUE_CONSTRAINTS@@']) {
-            tableSpec['@@UNIQUE_CONSTRAINTS@@'].forEach(unique => t.unique(unique));
+            tableSpec['@@UNIQUE_CONSTRAINTS@@'].forEach((unique) => {
+                // An entry is normally the columns alone, and knex names the constraint
+                // after the table and every one of them. The object form is for when
+                // that derived name would overrun MySQL's 64-character limit.
+                if (unique && typeof unique === 'object' && !Array.isArray(unique)) {
+                    t.unique(unique.columns, {indexName: unique.indexName});
+                } else {
+                    t.unique(unique);
+                }
+            });
         }
         if (tableSpec['@@PRIMARY_KEY@@']) {
             t.primary(tableSpec['@@PRIMARY_KEY@@']);

package/core/server/data/schema/fixtures/fixtures.json

@@ -1066,7 +1066,7 @@
                     "gift_link": "manage"
                 },
                 "Super Editor": {
-                    "notification": "all",
+                    "notification": ["browse", "destroy"],
                     "post": "all",
                     "setting": ["browse", "read"],
                     "slug": "all",
@@ -1091,7 +1091,7 @@
                     "gift_link": "manage"
                 },
                 "Editor": {
-                    "notification": "all",
+                    "notification": ["browse", "destroy"],
                     "post": "all",
                     "setting": ["browse", "read"],
                     "slug": "all",

package/core/server/data/schema/schema.js

@@ -682,15 +682,34 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         custom_field_id: {type: 'string', maxlength: 24, nullable: false, references: 'members_custom_fields.id', cascadeDelete: true},
         member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
-        // Exactly one value column is populated per row, chosen by the field
-        // type's storage type in @tryghost/custom-field-types, whose byte bound
-        // on long_text matches this column exactly.
+        // Which part of the field's value this row carries. A scalar has one part and
+        // stores it under the empty path; a composite stores one row per sub-field it
+        // fills, under that sub-field's key. Not nullable, because MySQL counts NULLs
+        // as distinct in a unique index and the constraint below would stop holding.
+        path: {type: 'string', maxlength: 191, nullable: false, defaultTo: ''},
+        // One row, one value: a part a member has not filled in has no row at all. The
+        // column stays nullable even so, because making it NOT NULL is only reachable
+        // through knex's dropNullable, which rewrites the column on MySQL and widens
+        // TEXT to MEDIUMTEXT — a migrated site would then accept sixteen megabytes in a
+        // column a fresh install bounds at 65,535 bytes. The bound matching long_text's
+        // exactly is worth more than the schema restating what the write path enforces.
         value_text: {type: 'text', maxlength: 65535, nullable: true},
-        value_json: {type: 'text', maxlength: 65535, nullable: true},
         created_at: {type: 'dateTime', nullable: false},
         updated_at: {type: 'dateTime', nullable: true},
+        // Named, because the name knex derives from the table and all three columns is
+        // 65 characters and MySQL stops at 64. The migration that first created this
+        // table already shortened a column for the same reason; a third column spends
+        // what headroom that bought.
         '@@UNIQUE_CONSTRAINTS@@': [
-            ['member_id', 'custom_field_id']
+            {columns: ['member_id', 'custom_field_id', 'path'], indexName: 'members_custom_field_values_leaf_unique'}
+        ],
+        // What a segment filter looks up: every member holding a given value for a
+        // given part of a given field. The value itself is not in the index — it is
+        // TEXT, so MySQL would need a prefix length, and the schema's index builder
+        // applies one length to every column in a composite index rather than to a
+        // single chosen one.
+        '@@INDEXES@@': [
+            ['custom_field_id', 'path']
         ]
     },
     members_stripe_customers: {
@@ -1339,6 +1358,7 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         automated_email_id: {type: 'string', maxlength: 24, nullable: true, references: 'welcome_email_automated_emails.id'},
         automation_action_revision_id: {type: 'string', maxlength: 24, nullable: true, references: 'automation_action_revisions.id'},
+        automation_run_step_id: {type: 'string', maxlength: 24, nullable: true, references: 'automation_run_steps.id'},
         member_id: {type: 'string', maxlength: 24, nullable: false, index: true},
         member_uuid: {type: 'string', maxlength: 36, nullable: false},
         member_email: {type: 'string', maxlength: 191, nullable: false},

package/core/server/lib/common/to-plain.ts

@@ -7,7 +7,7 @@
  * callers accept either shape uniformly:
  *
  *   const data = toPlain(post);
- *   urlService.facade.getUrlForResource({...data, type: 'posts'}, ...)
+ *   urlService.getUrlForResource({...data, type: 'posts'}, ...)
  */
 type JsonSerializable<T> = {
     toJSON(): T;

package/core/server/models/post.js

@@ -1006,8 +1006,8 @@ Post = ghostBookshelf.Model.extend({
      *     - `slug`: /:slug/
      *     - `published_at`: /:year/:slug
      *     - `author_id`: /:author/:slug, /:primary_author/:slug
-     *     - now, the UrlService pre-generates urls based on the resources
-     *     - you can ask `urlService.getUrlByResourceId(post.id)`
+     *     - now, the UrlService computes urls from the routing config
+     *     - you can ask `urlService.getUrlForResource(post)`
      *
      * ### events
      *   - you call `findAll` with `columns: id`
@@ -1346,7 +1346,16 @@ Post = ghostBookshelf.Model.extend({
     destroy: function destroy(unfilteredOptions) {
         let options = this.filterOptions(unfilteredOptions, 'destroy', {extraAllowedProperties: ['id']});
 
-        const destroyPost = () => {
+        const destroyPost = async () => {
+            // The `comments.in_reply_to_id` references form chains between a post's
+            // comments, which MySQL cannot resolve while cascade-deleting them
+            // alongside `comments.parent_id`. Clear the references first so the
+            // `comments.post_id` cascade delete can do its job
+            await ghostBookshelf.knex('comments')
+                .where('post_id', options.id)
+                .update('in_reply_to_id', null)
+                .transacting(options.transacting);
+
             return ghostBookshelf.Model.destroy.call(this, options);
         };
 

package/core/server/services/adapter-manager/adapter-manager.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdapterManager = void 0;
-const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = __importDefault(require("@tryghost/errors"));
 const utils_1 = require("./utils");
 /**
@@ -121,50 +120,7 @@ class AdapterManager {
                 message: `Unable to find ${adapterType} adapter in ${this.pathsToAdapters}.`
             });
         }
-        let Adapter = null;
-        for (const pathToAdapters of this.pathsToAdapters) {
-            let pathToAdapter = node_path_1.default.join(pathToAdapters, adapterType, adapterClassName);
-            if (pathToAdapters === '') {
-                // We are loading from node_modules, we can remove the `adapterType` prefix
-                pathToAdapter = node_path_1.default.join(pathToAdapters, adapterClassName);
-            }
-            // An adapter directory may be a full module with its own
-            // package.json, in which case this resolves the `exports` entry
-            // point; otherwise the path passes through unchanged.
-            const moduleToLoad = (0, utils_1.resolveAdapterEntryPoint)(pathToAdapter);
-            try {
-                const adapterModule = this.loadAdapterFromPath(moduleToLoad);
-                Adapter = (0, utils_1.resolveAdapterExport)(adapterModule);
-                if (Adapter) {
-                    break;
-                }
-            }
-            catch (err) {
-                // Catch runtime errors
-                if (!(err instanceof Error) || err.code !== 'MODULE_NOT_FOUND') {
-                    throw new errors_1.default.IncorrectUsageError({ err: err });
-                }
-                // Catch missing dependencies BUT NOT missing adapter.
-                // Only check the first line — Node appends a "Require stack"
-                // that includes the adapter's own path, which would false-positive.
-                const firstLine = err.message.split('\n')[0];
-                if (!firstLine.includes(pathToAdapter)) {
-                    // Name the unresolved module so the error is actionable, e.g.
-                    // "Cannot find module 'superagent'" -> 'superagent'.
-                    const missingMatch = /Cannot find module '([^']+)'/.exec(firstLine);
-                    const missingModule = missingMatch ? ` '${missingMatch[1]}'` : '';
-                    throw new errors_1.default.IncorrectUsageError({
-                        message: `You are missing a dependency${missingModule} in your adapter ${pathToAdapter}`,
-                        err: err
-                    });
-                }
-            }
-        }
-        if (!Adapter) {
-            throw new errors_1.default.IncorrectUsageError({
-                message: `Unable to find ${adapterType} adapter ${adapterClassName} in ${this.pathsToAdapters}.`
-            });
-        }
+        const Adapter = (0, utils_1.loadAdapterClass)(adapterType, adapterClassName, this.pathsToAdapters, this.loadAdapterFromPath);
         return { Adapter, adapterConfig: adapterConfig ?? {}, adapterType, adapterClassName };
     }
     /**

package/core/server/services/adapter-manager/adapter-manager.ts

@@ -1,6 +1,5 @@
-import path from 'node:path';
 import errors from '@tryghost/errors';
-import {resolveAdapterExport, resolveAdapterEntryPoint, resolveAdapterOptions, normalizeAdapterConfig, getConfiguredFeatures} from './utils';
+import {loadAdapterClass, resolveAdapterOptions, normalizeAdapterConfig, getConfiguredFeatures} from './utils';
 import type {ConfigInstance} from '../../../shared/config/loader';
 import type {
     Adapter,
@@ -186,52 +185,7 @@ export class AdapterManager<BaseClasses extends BaseClassMap = BaseClassMap> {
             });
         }
 
-        let Adapter: AdapterConstructor | null = null;
-        for (const pathToAdapters of this.pathsToAdapters) {
-            let pathToAdapter = path.join(pathToAdapters, adapterType, adapterClassName);
-            if (pathToAdapters === '') {
-                // We are loading from node_modules, we can remove the `adapterType` prefix
-                pathToAdapter = path.join(pathToAdapters, adapterClassName);
-            }
-            // An adapter directory may be a full module with its own
-            // package.json, in which case this resolves the `exports` entry
-            // point; otherwise the path passes through unchanged.
-            const moduleToLoad = resolveAdapterEntryPoint(pathToAdapter);
-
-            try {
-                const adapterModule = this.loadAdapterFromPath(moduleToLoad);
-                Adapter = resolveAdapterExport(adapterModule);
-                if (Adapter) {
-                    break;
-                }
-            } catch (err) {
-                // Catch runtime errors
-                if (!(err instanceof Error) || (err as NodeJS.ErrnoException).code !== 'MODULE_NOT_FOUND') {
-                    throw new errors.IncorrectUsageError({err: err as Error});
-                }
-
-                // Catch missing dependencies BUT NOT missing adapter.
-                // Only check the first line — Node appends a "Require stack"
-                // that includes the adapter's own path, which would false-positive.
-                const firstLine = err.message.split('\n')[0];
-                if (!firstLine.includes(pathToAdapter)) {
-                    // Name the unresolved module so the error is actionable, e.g.
-                    // "Cannot find module 'superagent'" -> 'superagent'.
-                    const missingMatch = /Cannot find module '([^']+)'/.exec(firstLine);
-                    const missingModule = missingMatch ? ` '${missingMatch[1]}'` : '';
-                    throw new errors.IncorrectUsageError({
-                        message: `You are missing a dependency${missingModule} in your adapter ${pathToAdapter}`,
-                        err: err as Error
-                    });
-                }
-            }
-        }
-
-        if (!Adapter) {
-            throw new errors.IncorrectUsageError({
-                message: `Unable to find ${adapterType} adapter ${adapterClassName} in ${this.pathsToAdapters}.`
-            });
-        }
+        const Adapter = loadAdapterClass(adapterType, adapterClassName, this.pathsToAdapters, this.loadAdapterFromPath);
 
         return {Adapter, adapterConfig: adapterConfig ?? {}, adapterType, adapterClassName};
     }

package/core/server/services/adapter-manager/adapter-paths.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterPaths = void 0;
+const config_1 = __importDefault(require("../../../shared/config"));
+/**
+ * Where adapters are looked up, in order. Also read by bin/validate-adapters.ts,
+ * which checks adapter implementations at build time - keep this the only place
+ * the lookup order is declared, so a name resolves there exactly as it does here.
+ */
+exports.adapterPaths = Array.from(new Set([
+    '', // A blank path will cause us to check node_modules for the adapter
+    config_1.default.get('paths').internalAdaptersPath,
+    // custom docker builds may install adapters in a separate path from content,
+    // since the content dir is often bind-mounted into the container. Offering
+    // an escape hatch here to allow for this
+    config_1.default.get('paths').installedAdaptersPath ?? '',
+    // load adapters from content last, so that they don't override any other
+    // internal or platform-installed adapters
+    // TODO: potentially deprecate/remove as part of Ghost 7.0
+    config_1.default.getContentPath('adapters')
+]));

package/core/server/services/adapter-manager/adapter-paths.ts

@@ -0,0 +1,21 @@
+import config from '../../../shared/config';
+
+/**
+ * Where adapters are looked up, in order. Also read by bin/validate-adapters.ts,
+ * which checks adapter implementations at build time - keep this the only place
+ * the lookup order is declared, so a name resolves there exactly as it does here.
+ */
+export const adapterPaths: string[] = Array.from(new Set<string>([
+    '', // A blank path will cause us to check node_modules for the adapter
+    config.get('paths').internalAdaptersPath,
+
+    // custom docker builds may install adapters in a separate path from content,
+    // since the content dir is often bind-mounted into the container. Offering
+    // an escape hatch here to allow for this
+    config.get('paths').installedAdaptersPath ?? '',
+
+    // load adapters from content last, so that they don't override any other
+    // internal or platform-installed adapters
+    // TODO: potentially deprecate/remove as part of Ghost 7.0
+    config.getContentPath('adapters')
+]));

package/core/server/services/adapter-manager/base-classes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseClasses = void 0;
+const ghost_storage_base_1 = require("ghost-storage-base");
+const adapter_base_scheduling_1 = require("@tryghost/adapter-base-scheduling");
+const adapter_base_sso_1 = require("@tryghost/adapter-base-sso");
+const adapter_base_cache_1 = require("@tryghost/adapter-base-cache");
+const adapter_base_redirects_1 = require("@tryghost/adapter-base-redirects");
+const adapter_base_route_settings_1 = require("@tryghost/adapter-base-route-settings");
+/**
+ * The base class every adapter of a given type must extend. Also read by
+ * bin/validate-adapters.js, which checks adapter implementations at build time -
+ * keep this the only place the mapping is declared.
+ */
+exports.baseClasses = {
+    storage: ghost_storage_base_1.StorageBase,
+    scheduling: adapter_base_scheduling_1.SchedulingBase,
+    sso: adapter_base_sso_1.SSOBase,
+    cache: adapter_base_cache_1.CacheBase,
+    redirects: adapter_base_redirects_1.RedirectsStoreBase,
+    'route-settings': adapter_base_route_settings_1.RouteSettingsStoreBase
+};

package/core/server/services/adapter-manager/base-classes.ts

@@ -0,0 +1,22 @@
+import {StorageBase} from 'ghost-storage-base';
+import {SchedulingBase} from '@tryghost/adapter-base-scheduling';
+import {SSOBase} from '@tryghost/adapter-base-sso';
+import {CacheBase} from '@tryghost/adapter-base-cache';
+import {RedirectsStoreBase} from '@tryghost/adapter-base-redirects';
+import {RouteSettingsStoreBase} from '@tryghost/adapter-base-route-settings';
+
+import type {BaseClassMap} from './adapter-manager';
+
+/**
+ * The base class every adapter of a given type must extend. Also read by
+ * bin/validate-adapters.js, which checks adapter implementations at build time -
+ * keep this the only place the mapping is declared.
+ */
+export const baseClasses = {
+    storage: StorageBase,
+    scheduling: SchedulingBase,
+    sso: SSOBase,
+    cache: CacheBase,
+    redirects: RedirectsStoreBase,
+    'route-settings': RouteSettingsStoreBase
+} satisfies BaseClassMap;

package/core/server/services/adapter-manager/index.js

@@ -3,40 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ghost_storage_base_1 = require("ghost-storage-base");
-const adapter_base_scheduling_1 = require("@tryghost/adapter-base-scheduling");
-const adapter_base_sso_1 = require("@tryghost/adapter-base-sso");
-const adapter_base_cache_1 = require("@tryghost/adapter-base-cache");
-const adapter_base_redirects_1 = require("@tryghost/adapter-base-redirects");
-const adapter_base_route_settings_1 = require("@tryghost/adapter-base-route-settings");
 const adapter_manager_1 = require("./adapter-manager");
+const adapter_paths_1 = require("./adapter-paths");
+const base_classes_1 = require("./base-classes");
 const config_1 = __importDefault(require("../../../shared/config"));
-const adapterPaths = new Set([
-    '', // A blank path will cause us to check node_modules for the adapter
-    config_1.default.get('paths').internalAdaptersPath,
-    // custom docker builds may install adapters in a separate path from content,
-    // since the content dir is often bind-mounted into the container. Offering
-    // an escape hatch here to allow for this
-    config_1.default.get('paths').installedAdaptersPath ?? '',
-    // load adapters from content last, so that they don't override any other
-    // internal or platform-installed adapters
-    // TODO: potentially deprecate/remove as part of Ghost 7.0
-    config_1.default.getContentPath('adapters'),
-]);
 // A singleton adapter manager, preconfigured with the base classes for every
 // known adapter type. `getAdapter` resolves the active adapter and its options
 // from config on each call, so runtime config changes are always reflected.
 const adapterManager = new adapter_manager_1.AdapterManager({
     loadAdapterFromPath: require,
     config: config_1.default,
-    pathsToAdapters: Array.from(adapterPaths),
-    baseClasses: {
-        storage: ghost_storage_base_1.StorageBase,
-        scheduling: adapter_base_scheduling_1.SchedulingBase,
-        sso: adapter_base_sso_1.SSOBase,
-        cache: adapter_base_cache_1.CacheBase,
-        redirects: adapter_base_redirects_1.RedirectsStoreBase,
-        'route-settings': adapter_base_route_settings_1.RouteSettingsStoreBase
-    }
+    pathsToAdapters: adapter_paths_1.adapterPaths,
+    baseClasses: base_classes_1.baseClasses
 });
 exports.default = adapterManager;

package/core/server/services/adapter-manager/index.ts

@@ -1,43 +1,16 @@
-import {StorageBase} from 'ghost-storage-base';
-import {SchedulingBase} from '@tryghost/adapter-base-scheduling';
-import {SSOBase} from '@tryghost/adapter-base-sso';
-import {CacheBase} from '@tryghost/adapter-base-cache';
-import {RedirectsStoreBase} from '@tryghost/adapter-base-redirects';
-import {RouteSettingsStoreBase} from '@tryghost/adapter-base-route-settings';
-
 import {AdapterManager} from './adapter-manager';
+import {adapterPaths} from './adapter-paths';
+import {baseClasses} from './base-classes';
 import config from '../../../shared/config';
 
-const adapterPaths = new Set<string>([
-    '', // A blank path will cause us to check node_modules for the adapter
-    config.get('paths').internalAdaptersPath,
-
-    // custom docker builds may install adapters in a separate path from content,
-    // since the content dir is often bind-mounted into the container. Offering
-    // an escape hatch here to allow for this
-    config.get('paths').installedAdaptersPath ?? '',
-
-    // load adapters from content last, so that they don't override any other
-    // internal or platform-installed adapters
-    // TODO: potentially deprecate/remove as part of Ghost 7.0
-    config.getContentPath('adapters'),
-]);
-
 // A singleton adapter manager, preconfigured with the base classes for every
 // known adapter type. `getAdapter` resolves the active adapter and its options
 // from config on each call, so runtime config changes are always reflected.
 const adapterManager = new AdapterManager({
     loadAdapterFromPath: require,
     config,
-    pathsToAdapters: Array.from(adapterPaths),
-    baseClasses: {
-        storage: StorageBase,
-        scheduling: SchedulingBase,
-        sso: SSOBase,
-        cache: CacheBase,
-        redirects: RedirectsStoreBase,
-        'route-settings': RouteSettingsStoreBase
-    }
+    pathsToAdapters: adapterPaths,
+    baseClasses
 });
 
 export default adapterManager;

package/core/server/services/adapter-manager/utils.js

@@ -5,12 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAdapterEntryPoint = resolveAdapterEntryPoint;
 exports.resolveAdapterExport = resolveAdapterExport;
+exports.loadAdapterClass = loadAdapterClass;
 exports.normalizeAdapterConfig = normalizeAdapterConfig;
 exports.getConfiguredFeatures = getConfiguredFeatures;
 exports.resolveAdapterOptions = resolveAdapterOptions;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_module_1 = require("node:module");
+const errors_1 = __importDefault(require("@tryghost/errors"));
 /**
 * Whether `filePath` resolves to a location inside `directory`.
 *
@@ -116,6 +118,54 @@ function resolveAdapterExport(moduleExport) {
     }
     return null;
 }
+/**
+* Locate and load an adapter constructor by type and class name, trying each of
+* `pathsToAdapters` in order. Shared by the adapter manager and by
+* bin/validate-adapters.ts, so a name resolves — and fails — identically at build
+* time and at runtime.
+*/
+function loadAdapterClass(adapterType, adapterClassName, pathsToAdapters, loadAdapterFromPath) {
+    for (const pathToAdapters of pathsToAdapters) {
+        let pathToAdapter = node_path_1.default.join(pathToAdapters, adapterType, adapterClassName);
+        if (pathToAdapters === '') {
+            // We are loading from node_modules, we can remove the `adapterType` prefix
+            pathToAdapter = node_path_1.default.join(pathToAdapters, adapterClassName);
+        }
+        // An adapter directory may be a full module with its own
+        // package.json, in which case this resolves the `exports` entry
+        // point; otherwise the path passes through unchanged.
+        const moduleToLoad = resolveAdapterEntryPoint(pathToAdapter);
+        try {
+            const Adapter = resolveAdapterExport(loadAdapterFromPath(moduleToLoad));
+            if (Adapter) {
+                return Adapter;
+            }
+        }
+        catch (err) {
+            // Catch runtime errors
+            if (!(err instanceof Error) || err.code !== 'MODULE_NOT_FOUND') {
+                throw new errors_1.default.IncorrectUsageError({ err: err });
+            }
+            // Catch missing dependencies BUT NOT missing adapter.
+            // Only check the first line — Node appends a "Require stack"
+            // that includes the adapter's own path, which would false-positive.
+            const firstLine = err.message.split('\n')[0];
+            if (!firstLine.includes(pathToAdapter)) {
+                // Name the unresolved module so the error is actionable, e.g.
+                // "Cannot find module 'superagent'" -> 'superagent'.
+                const missingMatch = /Cannot find module '([^']+)'/.exec(firstLine);
+                const missingModule = missingMatch ? ` '${missingMatch[1]}'` : '';
+                throw new errors_1.default.IncorrectUsageError({
+                    message: `You are missing a dependency${missingModule} in your adapter ${pathToAdapter}`,
+                    err: err
+                });
+            }
+        }
+    }
+    throw new errors_1.default.IncorrectUsageError({
+        message: `Unable to find ${adapterType} adapter ${adapterClassName} in ${pathsToAdapters}.`
+    });
+}
 function getSchedulingConfig(config) {
     const adapterConfig = config.get('adapters:scheduling');
     if (!adapterConfig) {