ghost 6.57.1 → 6.58.0

package/core/server/services/members-custom-fields/storage.ts

@@ -1,122 +0,0 @@
-import errors from '@tryghost/errors';
-
-// A value is a tree; the database stores one row per leaf, under the path addressing it.
-// A value with no parts is a single leaf at the root, a part is a leaf under its key, and
-// a nested part is addressed with a dotted path.
-//
-// Nothing here may consult a field type. Values arrive already parsed against their own,
-// and rows are rebuilt as what they were written as rather than as what the type says
-// today, so a type that changes shape does not rewrite what members already have.
-
-/** Also the notation a segment filter addresses a part by, so the two cannot drift. */
-const SEPARATOR = '.';
-
-/** Empty rather than null: a unique index does not constrain nulls, which would let the same leaf be stored twice. */
-export const ROOT_PATH = '';
-
-export interface Leaf {
-    path: string;
-    value_text: string;
-}
-
-export interface StoredLeaf extends Leaf {
-    member_id: string;
-    key: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Values are rebuilt into plain objects, so a segment naming something every object
- * already has would reach the prototype instead of the value — and a write through
- * `__proto__` reaches every object in the process. Paths come out of the database, so
- * this holds here rather than trusting whatever put them there.
- */
-function isSafeSegment(segment: string): boolean {
-    return !(segment in Object.prototype);
-}
-
-/** Every leaf a value names, at any depth, including the ones it names as empty. */
-export function leavesFor(value: unknown, path: string = ROOT_PATH): Leaf[] {
-    if (typeof value === 'string') {
-        return [{path, value_text: value}];
-    }
-
-    // Thrown rather than stored: the read path rejects a non-string row, so writing one
-    // loses the value with nothing to say it ever arrived.
-    if (!isRecord(value)) {
-        throw new errors.IncorrectUsageError({
-            message: `A custom field value must be a string or a record of them, not ${value === null ? 'null' : typeof value}.`
-        });
-    }
-
-    // Undefined means the value does not name the part, which is not the same as naming
-    // it empty: the first leaves what is stored alone, the second clears it.
-    return Object.entries(value)
-        .filter(([, part]) => part !== undefined)
-        .flatMap(([key, part]) => leavesFor(part, path === ROOT_PATH ? key : `${path}${SEPARATOR}${key}`));
-}
-
-/** A value split into the leaves it sets and the paths it clears. */
-export function leavesToWrite(value: unknown): {set: Leaf[], cleared: string[]} {
-    const named = leavesFor(value);
-
-    return {
-        set: named.filter(leaf => leaf.value_text !== ''),
-        cleared: named.filter(leaf => leaf.value_text === '').map(leaf => leaf.path)
-    };
-}
-
-/** The value a set of leaves adds up to, rebuilt to whatever depth their paths describe. */
-export function valueFromLeaves(leaves: readonly Leaf[]): unknown {
-    const root = leaves.find(leaf => leaf.path === ROOT_PATH);
-    if (root) {
-        return root.value_text;
-    }
-
-    const value: Record<string, unknown> = {};
-    for (const leaf of leaves) {
-        const segments = leaf.path.split(SEPARATOR);
-        if (!segments.every(isSafeSegment)) {
-            continue;
-        }
-
-        const last = segments.pop() as string;
-        // A segment already holding a string is replaced rather than descended into: this
-        // runs over every member of a list response, so a contradictory pair of paths
-        // should cost one odd value rather than the whole response.
-        const parent = segments.reduce<Record<string, unknown>>((target, segment) => {
-            if (!isRecord(target[segment])) {
-                target[segment] = {};
-            }
-            return target[segment] as Record<string, unknown>;
-        }, value);
-        parent[last] = leaf.value_text;
-    }
-
-    return value;
-}
-
-/** Every member's values, keyed by member and then field key; a member with no rows is absent. */
-export function valuesFromLeaves(leaves: readonly StoredLeaf[]): Map<string, Record<string, unknown>> {
-    const byMemberAndField = new Map<string, Map<string, Leaf[]>>();
-
-    for (const {member_id: memberId, key, path, value_text: valueText} of leaves) {
-        const fields = byMemberAndField.get(memberId) ?? new Map<string, Leaf[]>();
-        const forField = fields.get(key) ?? [];
-        forField.push({path, value_text: valueText});
-        fields.set(key, forField);
-        byMemberAndField.set(memberId, fields);
-    }
-
-    const byMember = new Map<string, Record<string, unknown>>();
-    for (const [memberId, fields] of byMemberAndField) {
-        byMember.set(memberId, Object.fromEntries(
-            [...fields].map(([key, forField]) => [key, valueFromLeaves(forField)])
-        ));
-    }
-
-    return byMember;
-}

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

@@ -1,269 +0,0 @@
-import ObjectID from 'bson-objectid';
-import errors from '@tryghost/errors';
-import logging from '@tryghost/logging';
-import type {Knex} from 'knex';
-import {z} from 'zod';
-import {FIELD_TYPES, subFieldsOf, type FieldType} from '@tryghost/custom-field-types';
-import {DbCustomFieldLeaf, DbCustomFieldValue, FIELD_STATUS} from './schema';
-import {activeFields} from './queries';
-import {leavesToWrite, valuesFromLeaves, type StoredLeaf} from './storage';
-
-const FIELDS_TABLE = 'members_custom_fields';
-const VALUES_TABLE = 'members_custom_field_values';
-
-/** Matches the `members_custom_fields.key` column, so no key a site could hold is refused. */
-const MAX_KEY_LENGTH = 191;
-
-/**
- * Rows per insert statement, bounded by knex rather than by either database. SQLite takes
- * a multi-row `VALUES` perfectly well; knex's SQLite dialect emits that form only for a
- * single row and compiles anything longer into `INSERT ... SELECT ? UNION ALL SELECT ?`,
- * which SQLite refuses past 500 terms.
- *
- * Open as knex#721 since 2015, with an approved but unmerged fix in knex#5780. This can
- * go when that lands; until then the alternative is hand-written upsert SQL per engine.
- */
-const UPSERT_CHUNK = 400;
-
-/** Derived, not restated, so a column changing shape in `schema.ts` changes here too. */
-type DbLeafRow = z.infer<typeof DbCustomFieldValue>;
-
-// Values stay `unknown`: each is validated by its own field type, which is not known
-// until the key is resolved to a definition.
-const ValuesInput = z.record(z.string().max(MAX_KEY_LENGTH), z.unknown());
-
-interface ActiveField {
-    id: string;
-    key: string;
-    name: string;
-    type: FieldType;
-}
-
-/** An absent `value` means clear the field. */
-interface PlannedWrite {
-    field: ActiveField;
-    value?: unknown;
-}
-
-/**
- * What a member holds for each defined field. Separate from the definitions service
- * because a value belongs to the member and a definition belongs to the site's settings,
- * which are different aggregates rather than different layers.
- */
-export class CustomFieldValuesService {
-    private knex: Knex;
-    /** A getter, not a number: the ceiling is an operator setting that changes between requests. */
-    private getMaxDefinitions: () => number;
-
-    constructor({knex, getMaxDefinitions}: {knex: Knex, getMaxDefinitions: () => number}) {
-        this.knex = knex;
-        this.getMaxDefinitions = getMaxDefinitions;
-    }
-
-    private async activeFieldsByKey(keys: string[]): Promise<Map<string, ActiveField>> {
-        if (keys.length === 0) {
-            return new Map();
-        }
-        const fields = await activeFields(this.knex)
-            .whereIn('key', keys)
-            .select('id', 'key', 'name', 'type');
-        return new Map(fields.map(field => [field.key, field]));
-    }
-
-    /**
-     * Members' values, keyed by member id then field key; anything absent is unset.
-     *
-     * Archived fields are excluded to match the definitions browse: their values stay in
-     * the database and stop being addressable. A row that will not parse is dropped and
-     * logged rather than failing the read, so one stale row cannot take down a member.
-     */
-    async getValuesForMembers(memberIds: string[]): Promise<Map<string, Record<string, unknown>>> {
-        if (memberIds.length === 0) {
-            return new Map();
-        }
-
-        const rows = await this.knex(VALUES_TABLE)
-            .join(FIELDS_TABLE, `${VALUES_TABLE}.custom_field_id`, `${FIELDS_TABLE}.id`)
-            .whereIn(`${VALUES_TABLE}.member_id`, memberIds)
-            .where(`${FIELDS_TABLE}.status`, FIELD_STATUS.active)
-            .orderBy(`${FIELDS_TABLE}.created_at`, 'asc')
-            .orderBy(`${FIELDS_TABLE}.id`, 'asc')
-            .orderBy(`${VALUES_TABLE}.path`, 'asc')
-            .select(`${VALUES_TABLE}.member_id`, `${FIELDS_TABLE}.key`, `${FIELDS_TABLE}.type`, `${VALUES_TABLE}.path`, `${VALUES_TABLE}.value_text`);
-
-        const leaves: StoredLeaf[] = [];
-        for (const row of rows) {
-            try {
-                leaves.push(DbCustomFieldLeaf.parse(row));
-            } catch (err) {
-                logging.warn(`Skipping unreadable custom field value (field '${row.key}', path '${row.path}'): ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-
-        return valuesFromLeaves(leaves);
-    }
-
-    /** Shared by every caller so they cannot disagree on what a values object is. */
-    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. Asks 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, writing nothing. Returned so a caller can
-     * validate before opening a transaction it would otherwise have to unwind, then apply
-     * the same plan without re-resolving it.
-     */
-    async planWrite(input: unknown): Promise<PlannedWrite[]> {
-        const values = this.parseValues(input);
-        const keys = Object.keys(values);
-
-        // Bounded by the definitions ceiling, which also holds the lookup below inside
-        // the driver's bound-parameter limit.
-        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(keys);
-        const writes: PlannedWrite[] = [];
-
-        for (const [key, raw] of Object.entries(values)) {
-            const field = byKey.get(key);
-            if (!field) {
-                // Unknown or archived. Refused rather than ignored: a typo that silently
-                // drops what somebody typed is worse than a save that fails. The catalog
-                // applies the same rule to the parts of a composite value.
-                throw new errors.ValidationError({message: `Unknown custom field: ${key}`, property: `custom_fields.${key}`});
-            }
-
-            // `null` clears any field, and `''` clears one with no parts. For a value
-            // with parts `''` names nothing, so it is left to fail validation rather than
-            // being read as a silent delete.
-            if (raw === null || (raw === '' && subFieldsOf(field.type) === null)) {
-                writes.push({field});
-                continue;
-            }
-
-            // Message only, no `context`: the API error handler moves a message into
-            // `context` when `context` is empty and prepends it when it is not, so
-            // anything added here reaches the client glued to the front of the reason.
-            // Which field failed rides in `property`.
-            const value = FIELD_TYPES[field.type].value.safeParse(raw);
-            if (!value.success) {
-                const issue = value.error.issues[0];
-                throw new errors.ValidationError({
-                    message: issue.message,
-                    property: [`custom_fields.${key}`, ...issue.path].join('.')
-                });
-            }
-            writes.push({field, value: value.data});
-        }
-
-        return writes;
-    }
-
-    /**
-     * Apply a plan from `planWrite`.
-     *
-     * A write touches the paths it names and nothing else, at every level: naming a path
-     * with an empty value clears that part, naming the field with `null` clears all of
-     * them, and saying nothing about a path leaves it alone. There is no whole-value
-     * replace, so a caller that does not know about a field cannot erase it.
-     *
-     * Always transactional. Given an executor it joins that transaction, so the importer's
-     * failed value write takes its member with it; given none it opens its own.
-     */
-    async applyWrite(
-        memberId: string,
-        writes: PlannedWrite[],
-        {executor = this.knex}: {executor?: Knex} = {}
-    ): Promise<void> {
-        if (writes.length === 0) {
-            return;
-        }
-
-        const apply = async (trx: Knex) => {
-            // Built first, then sent as whole statements: a handful per member rather
-            // than one per part, under one timestamp, because a write happened once
-            // however many rows record it.
-            const now = new Date();
-            const clearedFields: string[] = [];
-            const clearedPaths: Array<{fieldId: string, paths: string[]}> = [];
-            const rows: DbLeafRow[] = [];
-
-            for (const {field, value} of writes) {
-                if (value === undefined) {
-                    clearedFields.push(field.id);
-                    continue;
-                }
-
-                const {set, cleared} = leavesToWrite(value);
-                if (cleared.length > 0) {
-                    clearedPaths.push({fieldId: field.id, paths: cleared});
-                }
-
-                rows.push(...set.map(leaf => ({
-                    id: new ObjectID().toHexString(),
-                    member_id: memberId,
-                    custom_field_id: field.id,
-                    path: leaf.path,
-                    value_text: leaf.value_text,
-                    created_at: now,
-                    updated_at: now
-                })));
-            }
-
-            if (clearedFields.length > 0) {
-                await trx(VALUES_TABLE).where('member_id', memberId).whereIn('custom_field_id', clearedFields).del();
-            }
-
-            if (clearedPaths.length > 0) {
-                // One statement with a group per field, rather than a statement per field.
-                await trx(VALUES_TABLE).where('member_id', memberId).where((builder) => {
-                    for (const {fieldId, paths} of clearedPaths) {
-                        builder.orWhere(pair => pair.where('custom_field_id', fieldId).whereIn('path', paths));
-                    }
-                }).del();
-            }
-
-            for (let from = 0; from < rows.length; from += UPSERT_CHUNK) {
-                // Typed as the plain row because `merge` takes its columns as `keyof` the
-                // builder's record, which for a composite table registration is the scope
-                // names rather than the columns.
-                await trx<DbLeafRow>(VALUES_TABLE)
-                    .insert(rows.slice(from, from + UPSERT_CHUNK))
-                    // Naming the columns rather than giving values takes each from the row
-                    // that lost the conflict, so every part updates to its own value.
-                    .onConflict(['member_id', 'custom_field_id', 'path'])
-                    .merge(['value_text', 'updated_at']);
-            }
-        };
-
-        // knex's marker for a transactor: join it rather than nesting a savepoint under it.
-        if (executor.isTransaction) {
-            await apply(executor);
-        } else {
-            await executor.transaction(apply);
-        }
-    }
-}

package/core/server/services/notifications/notification-email.ts

@@ -1,66 +0,0 @@
-import {sanitizeEmailHtml} from './sanitize-email-html';
-
-interface Mailer {
-    send(options: {to: string; subject: string; html: string; text?: string}): Promise<unknown>;
-}
-
-interface GenerateEmailContent {
-    (options: {template: string; data: Record<string, unknown>}): Promise<{html: string; text?: string}>;
-}
-
-export interface NotificationEmailDeps {
-    mailer: Mailer;
-    generateEmailContent: GenerateEmailContent;
-    getSiteUrl: () => string;
-}
-
-export interface NotificationEmailMessage {
-    /**
-     * Resolved recipient addresses. The service does not decide who receives
-     * the email; callers compose recipients via a separate audience helper.
-     */
-    to: string[];
-    subject: string;
-    /**
-     * Untrusted HTML content. Sanitised before being rendered into the shell,
-     * so the email cannot ship scripts, event handlers or unsafe links even
-     * if the upstream source is compromised.
-     */
-    content: string;
-}
-
-/**
- * Renders a notification email in the shared shell and sends it to each
- * recipient. Recipient resolution is a separate concern handled by the caller.
- */
-export class NotificationEmailService {
-    private readonly mailer: Mailer;
-    private readonly generateEmailContent: GenerateEmailContent;
-    private readonly getSiteUrl: () => string;
-
-    constructor(deps: NotificationEmailDeps) {
-        this.mailer = deps.mailer;
-        this.generateEmailContent = deps.generateEmailContent;
-        this.getSiteUrl = deps.getSiteUrl;
-    }
-
-    async send({to, subject, content}: NotificationEmailMessage): Promise<void> {
-        if (!to.length) {
-            return;
-        }
-        const message = sanitizeEmailHtml(content);
-        const siteUrl = this.getSiteUrl();
-        for (const recipient of to) {
-            const {html, text} = await this.generateEmailContent({
-                template: 'notification',
-                data: {message, siteUrl, recipientEmail: recipient}
-            });
-            await this.mailer.send({
-                to: recipient,
-                subject,
-                html,
-                ...(text ? {text} : {})
-            });
-        }
-    }
-}

package/core/server/services/notifications/sanitize-email-html.ts

@@ -1,35 +0,0 @@
-import sanitizeHtml from 'sanitize-html';
-
-// Even though the upstream feed is operated by Ghost org, the resulting HTML
-// is rendered into admin inboxes on the receiving install. A compromised or
-// malformed feed entry must not be able to ship scripts, event handlers, or
-// non-http(s) URLs to recipients via this path.
-const ALLOWED_TAGS = [
-    'p', 'br', 'hr',
-    'strong', 'b', 'em', 'i', 'u', 'code',
-    'a',
-    'ul', 'ol', 'li',
-    'blockquote',
-    'h1', 'h2', 'h3', 'h4'
-];
-
-const ALLOWED_SCHEMES = ['http', 'https', 'mailto'];
-
-const SANITIZE_OPTIONS: sanitizeHtml.IOptions = {
-    allowedTags: ALLOWED_TAGS,
-    allowedAttributes: {
-        a: ['href', 'title', 'target', 'rel']
-    },
-    allowedSchemes: ALLOWED_SCHEMES,
-    allowProtocolRelative: false,
-    transformTags: {
-        a: sanitizeHtml.simpleTransform('a', {
-            target: '_blank',
-            rel: 'noopener noreferrer'
-        })
-    }
-};
-
-export function sanitizeEmailHtml(html: string): string {
-    return sanitizeHtml(html, SANITIZE_OPTIONS);
-}

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

@@ -1,13 +0,0 @@
-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 urlUtils = require('../../../shared/url-utils').default;
-
-export default new PostScheduling({
-    apiUrl: urlUtils.urlFor('api', {type: 'admin'}, true),
-    adapter: withErrorCapture(adapterManager.getAdapter('scheduling')),
-    internalKeys
-});

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

@@ -1,133 +0,0 @@
-import moment from 'moment';
-import logging from '@tryghost/logging';
-import type {SchedulerAdapter, SchedulerJob} from '@tryghost/adapter-base-scheduling';
-import type {InternalApiKey, InternalKeys} from '../internal-keys';
-
-// 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').default;
-const {getSignedAdminToken} = require('../../adapters/scheduling/utils');
-const events = require('../../lib/common/events');
-
-interface PostSchedulingDeps {
-    apiUrl: string;
-    // Optional in deps so the JS wrapper can pass options.schedulerAdapter
-    // through without TS complaining at the JS/TS boundary. The class field
-    // below is non-optional; the constructor's adapter.register(this) call
-    // throws if undefined is passed through in practice.
-    adapter?: SchedulerAdapter;
-    internalKeys: InternalKeys;
-}
-
-// Pages live in the posts table with type:'page', so both types are
-// queried through models.Post and discriminated via the type filter.
-const SCHEDULED_RESOURCES = ['post', 'page'] as const;
-type ScheduledResource = typeof SCHEDULED_RESOURCES[number];
-
-export default class PostScheduling {
-    readonly #apiUrl: string;
-    readonly #adapter: SchedulerAdapter;
-    readonly #internalKeys: InternalKeys;
-
-    constructor({apiUrl, adapter, internalKeys}: PostSchedulingDeps) {
-        this.#apiUrl = apiUrl;
-        this.#adapter = adapter!;
-        this.#internalKeys = internalKeys;
-
-        SCHEDULED_RESOURCES.forEach((resource) => {
-            events.on(`${resource}.scheduled`, async (model: any) => {
-                try {
-                    const key = await internalKeys.get('ghost-scheduler');
-                    this.#adapter.schedule(this.#normalize({model, key, resourceType: resource}));
-                } catch (err) {
-                    logging.error({event: {name: 'post-scheduling.schedule.error'}, err, resource, id: model.get('id')}, 'Failed to schedule resource');
-                }
-            });
-
-            // Reschedule = matched unschedule + fresh schedule, because tokens
-            // are signed against the published_at timestamp.
-            events.on(`${resource}.rescheduled`, async (model: any) => {
-                try {
-                    const key = await internalKeys.get('ghost-scheduler');
-                    this.#adapter.unschedule(this.#normalize({model, key, resourceType: resource}, 'unscheduled'));
-                    this.#adapter.schedule(this.#normalize({model, key, resourceType: resource}));
-                } catch (err) {
-                    logging.error({event: {name: 'post-scheduling.reschedule.error'}, err, resource, id: model.get('id')}, 'Failed to reschedule resource');
-                }
-            });
-
-            events.on(`${resource}.unscheduled`, async (model: any) => {
-                try {
-                    const key = await internalKeys.get('ghost-scheduler');
-                    this.#adapter.unschedule(this.#normalize({model, key, resourceType: resource}, 'unscheduled'));
-                } catch (err) {
-                    logging.error({event: {name: 'post-scheduling.unschedule.error'}, err, resource, id: model.get('id')}, 'Failed to unschedule resource');
-                }
-            });
-        });
-
-        this.#adapter.register(this);
-    }
-
-    /**
-     * Re-issue every queued schedule under the current internal-keys cache.
-     * On boot the previous key is the same as the current key. For key
-     * rotation, the caller passes `previousKey` so unschedule URLs match
-     * the entries the adapter already holds (signed under the previous
-     * secret); schedule URLs are reissued under the current secret.
-     */
-    async rescheduleAll({previousKey}: {previousKey?: InternalApiKey} = {}): Promise<void> {
-        const scheduledResources = await this.#loadScheduledResources();
-        const currentKey = await this.#internalKeys.get('ghost-scheduler');
-        const unscheduleKey = previousKey ?? currentKey;
-
-        // Same-key rebuild (no previousKey, boot path) → URL signature is
-        // identical to the about-to-be-scheduled job. The default adapter
-        // implements unschedule via tombstones keyed by URL+time, so a same-URL
-        // unschedule poisons the scheduled job. Bootstrap mode skips the
-        // tombstone write. Rotation (previousKey provided) → URLs differ, so
-        // the tombstone correctly targets the old queued entry.
-        const bootstrap = !previousKey;
-
-        for (const resourceType of Object.keys(scheduledResources) as ScheduledResource[]) {
-            for (const model of scheduledResources[resourceType]) {
-                this.#adapter.unschedule(
-                    this.#normalize({model, key: unscheduleKey, resourceType}),
-                    {bootstrap}
-                );
-                this.#adapter.schedule(
-                    this.#normalize({model, key: currentKey, resourceType})
-                );
-            }
-        }
-    }
-
-    async #loadScheduledResources(): Promise<Record<ScheduledResource, any[]>> {
-        const entries = await Promise.all(SCHEDULED_RESOURCES.map(async (resourceType) => {
-            const found = await models.Post.findAll({
-                filter: `status:scheduled+type:${resourceType}`,
-                columns: ['id', 'published_at', 'created_at', 'type']
-            });
-            return [resourceType, found];
-        }));
-        return Object.fromEntries(entries);
-    }
-
-    #normalize({model, resourceType, key}: {model: any; resourceType: ScheduledResource; key: InternalApiKey}, event: '' | 'unscheduled' = ''): SchedulerJob {
-        const resource = `${resourceType}s`;
-        const publishedAt = (event === 'unscheduled') ? model.previous('published_at') : model.get('published_at');
-        const signedAdminToken = getSignedAdminToken({publishedAt, apiUrl: this.#apiUrl, key});
-        const url = `${urlUtils.urlJoin(this.#apiUrl, 'schedules', resource, model.get('id'))}/?token=${signedAdminToken}`;
-
-        return {
-            // NOTE: The scheduler expects a unix timestamp.
-            time: moment(publishedAt).valueOf(),
-            url,
-            extra: {
-                httpMethod: 'PUT',
-                oldTime: model.previous('published_at') ? moment(model.previous('published_at')).valueOf() : null
-            }
-        };
-    }
-}