ghost 6.53.0 → 6.54.1

package/core/server/services/members-custom-fields/values-service.js

@@ -14,10 +14,13 @@ const queries_1 = require("./queries");
 const storage_1 = require("./storage");
 const FIELDS_TABLE = 'members_custom_fields';
 const VALUES_TABLE = 'members_custom_field_values';
-// Values arrive keyed by field key. The values themselves stay `unknown` here —
-// each one is validated by its own field type's schema, which isn't known until
-// the key is resolved to a definition.
-const ValuesInput = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+// Matches the `members_custom_fields.key` column (schema.js), so no key a site
+// could actually have minted is ever refused by it.
+const MAX_KEY_LENGTH = 191;
+// Values arrive keyed by field key. Each value stays `unknown` here: it is
+// validated by its own field type's schema, which isn't known until the key is
+// resolved to a definition.
+const ValuesInput = zod_1.z.record(zod_1.z.string().max(MAX_KEY_LENGTH), zod_1.z.unknown());
 /**
  * The value half of member custom fields: reading and writing what a member holds
  * for each defined field. It belongs to the member aggregate — a value is data
@@ -31,8 +34,15 @@ const ValuesInput = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
  */
 class CustomFieldValuesService {
     knex;
-    constructor({ knex }) {
+    /**
+     * @private
+     * A getter rather than a number: the ceiling is an operator setting that can
+     * change between requests.
+     */
+    getMaxDefinitions;
+    constructor({ knex, getMaxDefinitions }) {
         this.knex = knex;
+        this.getMaxDefinitions = getMaxDefinitions;
     }
     /**
      * The active fields for a set of keys, keyed by key, for resolving a write.
@@ -97,6 +107,33 @@ class CustomFieldValuesService {
         }
         return byMember;
     }
+    /**
+     * @private
+     * Input as the values object it claims to be, rejecting anything that isn't
+     * one. Shared by every caller so they cannot disagree on what a values object
+     * is, or on the error when it isn't one.
+     */
+    parseValues(input) {
+        const parsed = ValuesInput.safeParse(input);
+        if (!parsed.success) {
+            throw new errors_1.default.ValidationError({ message: 'Custom field values must be an object keyed by field key.', property: 'custom_fields' });
+        }
+        return parsed.data;
+    }
+    /**
+     * Whether input names any values. An absent key names none; anything present
+     * that isn't a values object throws, with the same error resolving it would
+     * have raised.
+     *
+     * Answers the shape question alone, with no catalog lookup, so it can be asked
+     * before a write is known to be permitted.
+     */
+    namesValues(input) {
+        if (input === undefined) {
+            return false;
+        }
+        return Object.keys(this.parseValues(input)).length > 0;
+    }
     /**
      * Resolve input into the writes it implies, rejecting anything invalid, and
      * writing nothing. Returned so a caller can validate before it commits to a
@@ -104,13 +141,22 @@ class CustomFieldValuesService {
      * apply the same plan without re-resolving or re-validating.
      */
     async planWrite(input) {
-        const parsed = ValuesInput.safeParse(input);
-        if (!parsed.success) {
-            throw new errors_1.default.ValidationError({ message: 'Custom field values must be an object keyed by field key.', property: 'custom_fields' });
+        const values = this.parseValues(input);
+        const keys = Object.keys(values);
+        // A write cannot name more fields than the site may define, so the
+        // definitions ceiling bounds it. This also holds the lookup below within the
+        // database driver's bound-parameter limit, which one key per parameter would
+        // otherwise exceed.
+        const maxKeys = this.getMaxDefinitions();
+        if (keys.length > maxKeys) {
+            throw new errors_1.default.ValidationError({
+                message: `Custom field values are limited to ${maxKeys} fields per request.`,
+                property: 'custom_fields'
+            });
         }
-        const byKey = await this.activeFieldsByKey(Object.keys(parsed.data));
+        const byKey = await this.activeFieldsByKey(keys);
         const writes = [];
-        for (const [key, raw] of Object.entries(parsed.data)) {
+        for (const [key, raw] of Object.entries(values)) {
             const field = byKey.get(key);
             if (!field) {
                 // Unknown (or archived) key. Rejected rather than ignored: a typo

package/core/server/services/members-custom-fields/values-service.ts

@@ -11,10 +11,14 @@ import {storageCodecFor, storageColumnsFor} from './storage';
 const FIELDS_TABLE = 'members_custom_fields';
 const VALUES_TABLE = 'members_custom_field_values';
 
-// Values arrive keyed by field key. The values themselves stay `unknown` here —
-// each one is validated by its own field type's schema, which isn't known until
-// the key is resolved to a definition.
-const ValuesInput = z.record(z.string(), z.unknown());
+// Matches the `members_custom_fields.key` column (schema.js), so no key a site
+// could actually have minted is ever refused by it.
+const MAX_KEY_LENGTH = 191;
+
+// Values arrive keyed by field key. Each value stays `unknown` here: it is
+// validated by its own field type's schema, which isn't known until the key is
+// resolved to a definition.
+const ValuesInput = z.record(z.string().max(MAX_KEY_LENGTH), z.unknown());
 
 // The field facts the value path needs: the id to write the FK, the key to match
 // input against, the name for error messages, and the type to pick the validator
@@ -47,9 +51,16 @@ interface PlannedWrite {
  */
 export class CustomFieldValuesService {
     private knex: Knex;
+    /**
+     * @private
+     * A getter rather than a number: the ceiling is an operator setting that can
+     * change between requests.
+     */
+    private getMaxDefinitions: () => number;
 
-    constructor({knex}: {knex: Knex}) {
+    constructor({knex, getMaxDefinitions}: {knex: Knex, getMaxDefinitions: () => number}) {
         this.knex = knex;
+        this.getMaxDefinitions = getMaxDefinitions;
     }
 
     /**
@@ -119,6 +130,37 @@ export class CustomFieldValuesService {
         return byMember;
     }
 
+    /**
+     * @private
+     * Input as the values object it claims to be, rejecting anything that isn't
+     * one. Shared by every caller so they cannot disagree on what a values object
+     * is, or on the error when it isn't one.
+     */
+    private parseValues(input: unknown): Record<string, unknown> {
+        const parsed = ValuesInput.safeParse(input);
+        if (!parsed.success) {
+            throw new errors.ValidationError({message: 'Custom field values must be an object keyed by field key.', property: 'custom_fields'});
+        }
+
+        return parsed.data;
+    }
+
+    /**
+     * Whether input names any values. An absent key names none; anything present
+     * that isn't a values object throws, with the same error resolving it would
+     * have raised.
+     *
+     * Answers the shape question alone, with no catalog lookup, so it can be asked
+     * before a write is known to be permitted.
+     */
+    namesValues(input: unknown): boolean {
+        if (input === undefined) {
+            return false;
+        }
+
+        return Object.keys(this.parseValues(input)).length > 0;
+    }
+
     /**
      * Resolve input into the writes it implies, rejecting anything invalid, and
      * writing nothing. Returned so a caller can validate before it commits to a
@@ -126,15 +168,25 @@ export class CustomFieldValuesService {
      * apply the same plan without re-resolving or re-validating.
      */
     async planWrite(input: unknown): Promise<PlannedWrite[]> {
-        const parsed = ValuesInput.safeParse(input);
-        if (!parsed.success) {
-            throw new errors.ValidationError({message: 'Custom field values must be an object keyed by field key.', property: 'custom_fields'});
+        const values = this.parseValues(input);
+        const keys = Object.keys(values);
+
+        // A write cannot name more fields than the site may define, so the
+        // definitions ceiling bounds it. This also holds the lookup below within the
+        // database driver's bound-parameter limit, which one key per parameter would
+        // otherwise exceed.
+        const maxKeys = this.getMaxDefinitions();
+        if (keys.length > maxKeys) {
+            throw new errors.ValidationError({
+                message: `Custom field values are limited to ${maxKeys} fields per request.`,
+                property: 'custom_fields'
+            });
         }
 
-        const byKey = await this.activeFieldsByKey(Object.keys(parsed.data));
+        const byKey = await this.activeFieldsByKey(keys);
         const writes: PlannedWrite[] = [];
 
-        for (const [key, raw] of Object.entries(parsed.data)) {
+        for (const [key, raw] of Object.entries(values)) {
             const field = byKey.get(key);
             if (!field) {
                 // Unknown (or archived) key. Rejected rather than ignored: a typo

package/core/server/services/mentions/mention-sending-service.js

@@ -5,14 +5,16 @@ module.exports = class MentionSendingService {
     #discoveryService;
     #externalRequest;
     #getSiteUrl;
+    #getPostData;
     #getPostUrl;
     #isEnabled;
     #jobService;
 
-    constructor({discoveryService, externalRequest, getSiteUrl, getPostUrl, isEnabled, jobService}) {
+    constructor({discoveryService, externalRequest, getSiteUrl, getPostData, getPostUrl, isEnabled, jobService}) {
         this.#discoveryService = discoveryService;
         this.#externalRequest = externalRequest;
         this.#getSiteUrl = getSiteUrl;
+        this.#getPostData = getPostData;
         this.#getPostUrl = getPostUrl;
         this.#isEnabled = isEnabled;
         this.#jobService = jobService;
@@ -66,9 +68,12 @@ module.exports = class MentionSendingService {
             let html = post.get('status') === 'published' ? post.get('html') : null;
             let previousHtml = post.previous('status') === 'published' ? post.previous('html') : null;
             if (html || previousHtml) {
+                // Capture the source URL now, from the event's data, rather than
+                // deferring the model into the job.
+                const url = new URL(await this.#resolvePostUrl(post));
                 await this.#jobService.addJob('sendWebmentions', async () => {
                     await this.sendForHTMLResource({
-                        url: new URL(this.#getPostUrl(post)),
+                        url,
                         html: html,
                         previousHtml: previousHtml
                     });
@@ -80,6 +85,21 @@ module.exports = class MentionSendingService {
         }
     }
 
+    // Deleting a published post fires `unpublished` from onDestroyed with the
+    // model already destroyed: its own attributes are cleared, but its previous
+    // state and loaded relations remain. Resolve the URL from that previous
+    // data, the same way we read previous('html') above; live models resolve
+    // straight from the model.
+    async #resolvePostUrl(post) {
+        // A deleted post arrives destroyed: its own attributes are cleared, so
+        // its data lives in the previous attributes (its relations remain).
+        // A live post loads whatever the URL service still needs.
+        if (post.attributes && Object.keys(post.attributes).length === 0) {
+            return this.#getPostUrl(post.previous('id'), {...post.toJSON(), ...post.previousAttributes()});
+        }
+        return this.#getPostUrl(post.id, await this.#getPostData(post));
+    }
+
     /**
      * @param {{source: URL, target: URL, endpoint: URL}} options
      * @returns

package/core/server/services/mentions/service.js

@@ -9,16 +9,27 @@ const RoutingService = require('./routing-service');
 const models = require('../../models');
 const events = require('../../lib/common/events');
 const externalRequest = require('../../../server/lib/request-external.js');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const outputSerializerUrlUtil = require('../../../server/api/endpoints/utils/serializers/output/utils/url');
 const urlService = require('../url');
 const settingsCache = require('../../../shared/settings-cache');
 const DomainEvents = require('@tryghost/domain-events');
 const jobsService = require('../mentions-jobs');
 
-function getPostUrl(post) {
-    const jsonModel = post.toJSON();
-    outputSerializerUrlUtil.forPost(post.id, jsonModel, {options: {}});
+// Serializes a post model to the data the URL service needs, loading the
+// relations it reads for filtered collections (event-emitted models don't
+// reliably carry them).
+async function getPostData(post) {
+    const missing = urlService.facade.getRequiredRelations().filter(relation => !post.relations[relation]);
+    if (missing.length) {
+        await post.load(missing);
+    }
+    return post.toJSON();
+}
+
+function getPostUrl(id, postData) {
+    const jsonModel = {...postData};
+    outputSerializerUrlUtil.forPost(id, jsonModel, {options: {}});
     return jsonModel.url;
 }
 
@@ -99,7 +110,8 @@ module.exports = {
             discoveryService,
             externalRequest,
             getSiteUrl: () => urlUtils.urlFor('home', true),
-            getPostUrl: post => getPostUrl(post),
+            getPostData: post => getPostData(post),
+            getPostUrl: (id, data) => getPostUrl(id, data),
             isEnabled: () => !settingsCache.get('is_private'),
             jobService: {
                 async addJob(name, fn) {
@@ -116,3 +128,7 @@ module.exports = {
         this.sendingService = sendingService;
     }
 };
+
+// exposed for testing
+module.exports.getPostData = getPostData;
+module.exports.getPostUrl = getPostUrl;

package/core/server/services/newsletters/index.js

@@ -2,7 +2,7 @@ const NewslettersService = require('./newsletters-service.js');
 const SingleUseTokenProvider = require('../members/single-use-token-provider');
 const mail = require('../mail');
 const models = require('../../models');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const limitService = require('../limits');
 const labs = require('../../../shared/labs');
 const emailAddressService = require('../email-address');

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

@@ -13,6 +13,8 @@ const crypto = require('crypto');
 // Some sites block non-standard user agents so we need to mimic a typical browser
 // Note: the Ghost/5.0 string _may_ be in use by 3rd parties so use caution when updating across majors
 const USER_AGENT = 'Mozilla/5.0 (compatible; Ghost/5.0; +https://ghost.org/)';
+const DEFAULT_BOOKMARK_ICON = 'https://static.ghost.org/v5.0.0/images/link-icon.svg';
+const DEFAULT_REQUEST_TIMEOUT = 5000;
 
 // metascraper-amazon's built-in URL test is a substring regex that misfires on
 // any host ending in a letter followed by `.co/` (e.g. `rangemedia.co`), causing
@@ -77,9 +79,8 @@ const findUrlWithProvider = (url) => {
  */
 
 /**
- * @typedef {Object} IStorage
- * @prop {(feature: string) => Object} getStorage
- */
+ * @typedef {import('ghost-storage-base').StorageBase} IImageStore
+ *
 
 /**
  * @typedef {import('got').GotRequestFunction} IExternalRequest
@@ -96,12 +97,12 @@ class OEmbedService {
      *
      * @param {Object} dependencies
      * @param {IConfig} dependencies.config
-     * @param {IStorage} dependencies.storage
+     * @param {IImageStore} dependencies.imageStore
      * @param {IExternalRequest} dependencies.externalRequest
      */
-    constructor({config, externalRequest, storage}) {
+    constructor({config, externalRequest, imageStore}) {
         this.config = config;
-        this.storage = storage;
+        this.imageStore = imageStore;
 
         /** @type {IExternalRequest} */
         this.externalRequest = externalRequest;
@@ -130,12 +131,13 @@ class OEmbedService {
 
     /**
      * @param {string} url
+     * @param {Object} [options]
      */
-    async knownProvider(url) {
+    async knownProvider(url, options = {}) {
         const {extract} = require('@extractus/oembed-extractor');
 
         try {
-            return await extract(url);
+            return await extract(url, {}, options);
         } catch (err) {
             if (err.message === 'Request failed with error code 401' || err.message === 'Request failed with error code 403') {
                 throw new errors.ValidationError({
@@ -163,25 +165,66 @@ class OEmbedService {
 
     /**
      * Process and store image from a URL
-     * @param {string} imageUrl - URL of the image to process
+     * @param {string|null|undefined} imageUrl - URL of the image to process
      * @param {string} imageType - What is the image used for. Example - icon, thumbnail
-     * @returns {Promise<String>} - URL where the image is stored
+     * @returns {Promise<String|null>} - URL where the image is stored
      */
     async processImageFromUrl(imageUrl, imageType) {
+        if (!imageUrl) {
+            return null;
+        }
+
         // Fetch image buffer from the URL
         const imageBuffer = await this.fetchImageBuffer(imageUrl);
-        const store = this.storage.getStorage('images');
 
         // Extract file name from URL
         const fileName = path.basename(new URL(imageUrl).pathname);
         const ext = path.extname(fileName);
         const baseName = ext ? path.basename(fileName, ext) : fileName;
-        const name = store.getSanitizedFileName(baseName);
+        const name = this.imageStore.getSanitizedFileName(baseName);
 
         const uniqueFileName = `${name}-${crypto.randomUUID()}${ext}`;
         const targetPath = path.join(imageType, uniqueFileName);
 
-        return store.saveRaw(imageBuffer, targetPath);
+        return this.imageStore.saveRaw(imageBuffer, targetPath);
+    }
+
+    /**
+     * Fetch bookmark enrichment from an allowlisted oEmbed provider without
+     * exposing provider-supplied HTML.
+     *
+     * @param {string} url
+     * @param {Object} [options]
+     * @returns {Promise<Object|undefined>}
+     */
+    async fetchBookmarkEnrichment(url, options = {}) {
+        const {url: providerUrl, provider} = findUrlWithProvider(url);
+        if (!provider) {
+            return;
+        }
+
+        const timeout = options.timeout?.request ?? DEFAULT_REQUEST_TIMEOUT;
+        const signal = AbortSignal.timeout(timeout);
+
+        let oembed;
+        try {
+            oembed = await this.knownProvider(providerUrl, {signal});
+        } catch {
+            // oEmbed metadata is a best-effort enhancement. If it fails, keep
+            // the bookmark metadata scraped from the page.
+            return;
+        }
+
+        if (!oembed) {
+            return;
+        }
+
+        return _.pickBy({
+            title: oembed.title,
+            author: oembed.author_name,
+            publisher: oembed.provider_name,
+            thumbnail: oembed.thumbnail_url || (oembed.type === 'photo' ? oembed.url : undefined)
+        }, value => value !== null && value !== undefined && value !== '');
     }
 
     /**
@@ -198,7 +241,7 @@ class OEmbedService {
                     'user-agent': USER_AGENT
                 },
                 timeout: {
-                    request: 5000
+                    request: DEFAULT_REQUEST_TIMEOUT
                 },
                 followRedirect: true,
                 ...options
@@ -274,6 +317,8 @@ class OEmbedService {
     /**
      * @param {string} url
      * @param {string} html
+     * @param {string} type
+     * @param {Object} [enrichment]
      *
      * @returns {Promise<{
      *     version: '1.0',
@@ -285,7 +330,7 @@ class OEmbedService {
      *     }
      * }>}
      */
-    async fetchBookmarkData(url, html, type) {
+    async fetchBookmarkData(url, html, type, enrichment = {}) {
         const requestOptions = this.externalRequest.defaults?.options || {};
         const gotOpts = {
             hooks: requestOptions.hooks,
@@ -374,11 +419,24 @@ class OEmbedService {
         const metadata = Object.assign({}, scraperResponse, {
             thumbnail: scraperResponse.image,
             icon: scraperResponse.logo
-        });
+        }, enrichment);
         // We want to use standard naming for image and logo
         delete metadata.image;
         delete metadata.logo;
 
+        return this.buildBookmarkData(url, metadata, type);
+    }
+
+    /**
+     * Validate and process bookmark metadata after it has been scraped,
+     * enriched, or assembled from enrichment alone.
+     *
+     * @param {string} url
+     * @param {Object} metadata
+     * @param {string} type
+     * @returns {Promise<Object>}
+     */
+    async buildBookmarkData(url, metadata, type) {
         if (!metadata.title) {
             throw new errors.ValidationError({
                 message: tpl(messages.insufficientMetadata),
@@ -391,24 +449,31 @@ class OEmbedService {
                 try {
                     await this.externalRequest.head(metadata.icon);
                 } catch (err) {
-                    metadata.icon = 'https://static.ghost.org/v5.0.0/images/link-icon.svg';
+                    metadata.icon = DEFAULT_BOOKMARK_ICON;
                     logging.error(err);
                 }
             }
         } else {
-            await this.processImageFromUrl(metadata.icon, 'icon')
-                .then((processedImageUrl) => {
-                    metadata.icon = processedImageUrl;
-                }).catch((err) => {
-                    metadata.icon = 'https://static.ghost.org/v5.0.0/images/link-icon.svg';
-                    logging.error(err);
-                });
-            await this.processImageFromUrl(metadata.thumbnail, 'thumbnail')
-                .then((processedImageUrl) => {
-                    metadata.thumbnail = processedImageUrl;
-                }).catch((err) => {
-                    logging.error(err);
-                });
+            if (metadata.icon) {
+                await this.processImageFromUrl(metadata.icon, 'icon')
+                    .then((processedImageUrl) => {
+                        metadata.icon = processedImageUrl;
+                    }).catch((err) => {
+                        metadata.icon = DEFAULT_BOOKMARK_ICON;
+                        logging.error(err);
+                    });
+            } else {
+                metadata.icon = DEFAULT_BOOKMARK_ICON;
+            }
+
+            if (metadata.thumbnail) {
+                await this.processImageFromUrl(metadata.thumbnail, 'thumbnail')
+                    .then((processedImageUrl) => {
+                        metadata.thumbnail = processedImageUrl;
+                    }).catch((err) => {
+                        logging.error(err);
+                    });
+            }
         }
 
         return {
@@ -508,7 +573,7 @@ class OEmbedService {
      * @param {string} url - oembed URL
      * @param {string} type - card type
      * @param {Object} [options] Specific fetch options
-     * @param {number} [options.timeout] Change the default timeout for fetching html
+     * @param {Object} [options.timeout] Change the default request timeout, got-style ({request: ms})
      *
      * @returns {Promise<Object>}
      */
@@ -553,11 +618,35 @@ class OEmbedService {
             }
 
             // Not in the list, we need to fetch the content
-            const {url: pageUrl, body, contentType} = await this.fetchPageHtml(url, fetchOptions);
+            const bookmarkEnrichmentPromise = type === 'bookmark' ? this.fetchBookmarkEnrichment(url, fetchOptions) : undefined;
+            const [pageResult, enrichmentResult] = await Promise.allSettled([
+                this.fetchPageHtml(url, fetchOptions),
+                bookmarkEnrichmentPromise
+            ]);
+            const bookmarkEnrichment = enrichmentResult.status === 'fulfilled' ? enrichmentResult.value : undefined;
+
+            if (pageResult.status === 'rejected') {
+                if (type === 'bookmark' && bookmarkEnrichment?.title) {
+                    return this.buildBookmarkData(url, {
+                        url,
+                        title: null,
+                        description: null,
+                        author: null,
+                        publisher: null,
+                        thumbnail: null,
+                        icon: null,
+                        ...bookmarkEnrichment
+                    }, type);
+                }
+
+                throw pageResult.reason;
+            }
+
+            const {url: pageUrl, body, contentType} = pageResult.value;
 
             // fetch only bookmark when explicitly requested
             if (type === 'bookmark') {
-                return this.fetchBookmarkData(url, body, type);
+                return this.fetchBookmarkData(url, body, type, bookmarkEnrichment);
             }
 
             // mentions need to return bookmark data (metadata) and body (html) for link verification

package/core/server/services/oembed/service.js

@@ -1,9 +1,11 @@
 const config = require('../../../shared/config');
-const storage = require('../../adapters/storage');
+const adapterManager = require('../../services/adapter-manager').default;
 const externalRequest = require('../../lib/request-external');
 
 const OEmbedService = require('./oembed-service');
-const oembed = new OEmbedService({config, externalRequest, storage});
+
+const imageStore = adapterManager.getAdapter('storage:images');
+const oembed = new OEmbedService({config, externalRequest, imageStore});
 
 const NFT = require('./nft-oembed-provider');
 const nft = new NFT({

package/core/server/services/offers/service.js

@@ -1,6 +1,6 @@
 const DynamicRedirectManager = require('../lib/dynamic-redirect-manager');
 const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const models = require('../../models');
 const OfferBookshelfRepository = require('./offer-bookshelf-repository');
 const OffersModule = require('./offers-module');

package/core/server/services/post-scheduling/index.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const post_scheduling_1 = __importDefault(require("./post-scheduling"));
 const internal_keys_1 = __importDefault(require("../internal-keys"));
+const adapter_manager_1 = __importDefault(require("../adapter-manager"));
+const error_capture_1 = require("../../adapters/scheduling/error-capture");
 // CJS modules without TS declarations — typed loosely at the boundary.
-const adapterManager = require('../adapter-manager');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 exports.default = new post_scheduling_1.default({
     apiUrl: urlUtils.urlFor('api', { type: 'admin' }, true),
-    adapter: adapterManager.getAdapter('scheduling'),
+    adapter: (0, error_capture_1.withErrorCapture)(adapter_manager_1.default.getAdapter('scheduling')),
     internalKeys: internal_keys_1.default
 });

package/core/server/services/post-scheduling/index.ts

@@ -1,12 +1,13 @@
 import PostScheduling from './post-scheduling';
 import internalKeys from '../internal-keys';
+import adapterManager from '../adapter-manager';
+import {withErrorCapture} from '../../adapters/scheduling/error-capture';
 
 // CJS modules without TS declarations — typed loosely at the boundary.
-const adapterManager = require('../adapter-manager');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 
 export default new PostScheduling({
     apiUrl: urlUtils.urlFor('api', {type: 'admin'}, true),
-    adapter: adapterManager.getAdapter('scheduling'),
+    adapter: withErrorCapture(adapterManager.getAdapter('scheduling')),
     internalKeys
 });

package/core/server/services/post-scheduling/post-scheduling.js

@@ -8,7 +8,7 @@ const logging_1 = __importDefault(require("@tryghost/logging"));
 // CJS-only modules — typed loosely below. models is the Bookshelf registry
 // without TS declarations; the rest are JS modules without types.
 const models = require('../../models');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const { getSignedAdminToken } = require('../../adapters/scheduling/utils');
 const events = require('../../lib/common/events');
 // Pages live in the posts table with type:'page', so both types are