ghost 6.47.0 → 6.48.0

package/core/server/models/outbox.js

@@ -1,24 +0,0 @@
-const ghostBookshelf = require('./base');
-
-const OUTBOX_STATUSES = {
-    PENDING: 'pending',
-    PROCESSING: 'processing',
-    FAILED: 'failed',
-    COMPLETED: 'completed'
-};
-
-const Outbox = ghostBookshelf.Model.extend({
-    tableName: 'outbox',
-
-    defaults() {
-        return {
-            status: OUTBOX_STATUSES.PENDING,
-            retry_count: 0
-        };
-    }
-});
-
-module.exports = {
-    Outbox: ghostBookshelf.model('Outbox', Outbox),
-    OUTBOX_STATUSES
-};

package/core/server/services/outbox/events/start-outbox-processing-event.js

@@ -1,22 +0,0 @@
-/**
- * This is an event that is used to circumvent the job manager that currently isn't able to run scheduled jobs on the main thread (not offloaded).
- * We simply emit this event in the job manager and listen for it on the main thread.
- */
-module.exports = class StartOutboxProcessingEvent {
-    /**
-     * @param {any} data
-     * @param {Date} timestamp
-     */
-    constructor(data, timestamp) {
-        this.data = data;
-        this.timestamp = timestamp;
-    }
-
-    /**
-     * @param {any} [data]
-     * @param {Date} [timestamp]
-     */
-    static create(data, timestamp) {
-        return new StartOutboxProcessingEvent(data, timestamp ?? new Date());
-    }
-};

package/core/server/services/outbox/handlers/member-created.js

@@ -1,85 +0,0 @@
-const {OUTBOX_LOG_KEY} = require('../jobs/lib/constants');
-const memberWelcomeEmailService = require('../../member-welcome-emails/service');
-const logging = require('@tryghost/logging');
-const {Automation, AutomatedEmailRecipient} = require('../../../models');
-const {MEMBER_WELCOME_EMAIL_SLUGS} = require('../../member-welcome-emails/constants');
-
-const LOG_KEY = `${OUTBOX_LOG_KEY}[MEMBER-WELCOME-EMAIL]`;
-
-async function handle({payload}) {
-    await memberWelcomeEmailService.api.send({member: payload, memberStatus: payload.status});
-
-    try {
-        const slug = MEMBER_WELCOME_EMAIL_SLUGS[payload.status];
-        if (!slug) {
-            logging.warn({
-                system: {
-                    event: 'outbox.member_created.no_slug_mapping',
-                    member_status: payload.status
-                }
-            }, `${LOG_KEY} No automated email slug found for member status`);
-            return;
-        }
-
-        const automation = await Automation.findOne({slug}, {withRelated: ['welcomeEmailAutomatedEmail']});
-        if (!automation) {
-            logging.warn({
-                system: {
-                    event: 'outbox.member_created.no_automated_email',
-                    slug
-                }
-            }, `${LOG_KEY} No automated email found for slug: ${slug}`);
-            return;
-        }
-
-        // NOTE(NY-1190): This naively assumes each drip sequence will have
-        // just one email. When we change that assumption, this line will need
-        // to change to something like:
-        //
-        // ```
-        // SELECT * FROM welcome_email_automated_emails
-        // WHERE welcome_email_automation_id IS ?
-        // AND id NOT IN (
-        //   SELECT next_id FROM welcome_email_automated_emails
-        //   WHERE next_id IS NOT NULL
-        //   AND welcome_email_automation_id IS ?
-        // );
-        // ```
-        const email = automation.related('welcomeEmailAutomatedEmail');
-        if (!email || !email.id) {
-            logging.warn({
-                system: {
-                    event: 'outbox.member_created.no_automated_email',
-                    slug
-                }
-            }, `${LOG_KEY} No automated email content found for slug: ${slug}`);
-            return;
-        }
-
-        await AutomatedEmailRecipient.add({
-            member_id: payload.memberId,
-            automated_email_id: email.id,
-            member_uuid: payload.uuid,
-            member_email: payload.email,
-            member_name: payload.name
-        });
-    } catch (err) {
-        logging.error({
-            system: {
-                event: 'outbox.member_created.track_send_failed'
-            },
-            err
-        }, `${LOG_KEY} Failed to track automated email send`);
-    }
-}
-
-function getLogInfo(payload) {
-    const email = payload?.email || 'unknown member';
-    return payload?.name ? `${payload.name} (${email})` : email;
-}
-
-module.exports = {
-    handle,
-    getLogInfo,
-    LOG_KEY
-};

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

@@ -1,49 +0,0 @@
-const logging = require('@tryghost/logging');
-const jobs = require('./jobs');
-const StartOutboxProcessingEvent = require('./events/start-outbox-processing-event');
-const domainEvents = require('@tryghost/domain-events');
-const processOutbox = require('./jobs/lib/process-outbox');
-const {OUTBOX_LOG_KEY} = require('./jobs/lib/constants');
-
-class OutboxServiceWrapper {
-    constructor({jobs: jobsDep = jobs, processOutbox: processOutboxDep = processOutbox} = {}) {
-        this.jobs = jobsDep;
-        this.processOutbox = processOutboxDep;
-    }
-
-    init() {
-        if (this.initialized) {
-            return;
-        }
-
-        this.processing = false;
-        this.jobs.scheduleOutboxJob();
-        domainEvents.subscribe(StartOutboxProcessingEvent, async () => {
-            await this.startProcessing();
-        });
-        this.initialized = true;
-    }
-
-    async startProcessing() {
-        if (this.processing) {
-            logging.info({system: {event: 'outbox.processing.skipped_already_running'}}, `${OUTBOX_LOG_KEY}: Outbox job already running, skipping`);
-            return;
-        }
-        this.processing = true;
-        try {
-            const statusMessage = await this.processOutbox();
-            logging.info(statusMessage);
-        } catch (err) {
-            logging.error({system: {event: 'outbox.processing.error'}, err}, `${OUTBOX_LOG_KEY}: Error while processing outbox`);
-        } finally {
-            this.processing = false;
-        }
-    }
-}
-
-function createOutboxService(deps) {
-    return new OutboxServiceWrapper(deps);
-}
-
-module.exports = createOutboxService();
-module.exports.createOutboxService = createOutboxService;

package/core/server/services/outbox/jobs/index.js

@@ -1,30 +0,0 @@
-const path = require('path');
-const jobsService = require('../../jobs');
-
-let hasScheduled = {
-    processOutbox: false
-};
-
-module.exports = {
-    scheduleOutboxJob() {
-        if (hasScheduled.processOutbox) {
-            return false;
-        }
-
-        // use a random seconds value to avoid spikes to the database on the minute
-        const s = Math.floor(Math.random() * 60); // 0-59
-        // run every 5 minutes, on 1,6,11..., 2,7,12..., 3,8,13..., etc
-        const m = Math.floor(Math.random() * 5); // 0-4
-
-        const cronSchedule = `${s} ${m}/5 * * * *`;
-
-        jobsService.addJob({
-            at: cronSchedule,
-            job: path.resolve(__dirname, 'outbox-job.js'),
-            name: 'process-outbox'
-        });
-
-        hasScheduled.processOutbox = true;
-        return hasScheduled.processOutbox;
-    }
-};

package/core/server/services/outbox/jobs/lib/constants.js

@@ -1,17 +0,0 @@
-const BATCH_SIZE = 100;
-const MAX_ENTRIES_PER_JOB = BATCH_SIZE * 10;
-const MAX_RETRIES = 1;
-const OUTBOX_LOG_KEY = '[OUTBOX]';
-
-const MESSAGES = {
-    CANCELLED: 'Outbox processing cancelled',
-    NO_ENTRIES: 'No pending outbox entries to process'
-};
-
-module.exports = {
-    BATCH_SIZE,
-    MAX_ENTRIES_PER_JOB,
-    MAX_RETRIES,
-    OUTBOX_LOG_KEY,
-    MESSAGES
-};

package/core/server/services/outbox/jobs/lib/process-entries.js

@@ -1,117 +0,0 @@
-const logging = require('@tryghost/logging');
-const {MAX_RETRIES, OUTBOX_LOG_KEY} = require('./constants');
-const {OUTBOX_STATUSES} = require('../../../../models/outbox');
-const MemberCreatedEvent = require('../../../../../shared/events/member-created-event');
-const memberCreatedHandler = require('../../handlers/member-created');
-
-const EVENT_HANDLERS = {
-    [MemberCreatedEvent.name]: memberCreatedHandler
-};
-
-async function deleteProcessedEntry({db, entryId}) {
-    await db.knex('outbox')
-        .where('id', entryId)
-        .delete();
-}
-
-async function updateFailedEntry({db, entryId, retryCount, errorMessage}) {
-    const newRetryCount = retryCount + 1;
-    const newStatus = newRetryCount <= MAX_RETRIES ? OUTBOX_STATUSES.PENDING : OUTBOX_STATUSES.FAILED;
-    const truncatedMessage = (errorMessage ?? 'Unknown error').toString().slice(0, 2000);
-
-    await db.knex('outbox')
-        .where('id', entryId)
-        .update({
-            status: newStatus,
-            retry_count: newRetryCount,
-            last_retry_at: db.knex.raw('CURRENT_TIMESTAMP'),
-            message: truncatedMessage,
-            updated_at: db.knex.raw('CURRENT_TIMESTAMP')
-        });
-}
-
-async function markEntryCompleted({db, entryId}) {
-    await db.knex('outbox')
-        .where('id', entryId)
-        .update({
-            status: OUTBOX_STATUSES.COMPLETED,
-            message: 'Processed, but failed to delete outbox entry',
-            updated_at: db.knex.raw('CURRENT_TIMESTAMP')
-        });
-}
-
-async function processEntry({db, entry}) {
-    const handler = EVENT_HANDLERS[entry.event_type];
-    if (!handler) {
-        logging.warn({
-            system: {
-                event: 'outbox.entry.no_handler',
-                event_type: entry.event_type
-            }
-        }, `${OUTBOX_LOG_KEY} No handler for event type: ${entry.event_type}`);
-        await updateFailedEntry({db, entryId: entry.id, retryCount: entry.retry_count, errorMessage: `No handler for event type: ${entry.event_type}`});
-        return {success: false};
-    }
-
-    let payload;
-    try {
-        payload = JSON.parse(entry.payload);
-        await handler.handle({payload});
-    } catch (err) {
-        const errorMessage = err?.message ?? 'Unknown error';
-        await updateFailedEntry({db, entryId: entry.id, retryCount: entry.retry_count, errorMessage});
-
-        if (!payload) {
-            logging.error({
-                system: {
-                    event: 'outbox.entry.payload_parse_failed',
-                    entry_id: entry.id
-                },
-                err
-            }, `${handler.LOG_KEY} Failed to parse payload for entry ${entry.id}.`);
-        } else {
-            logging.error({
-                system: {
-                    event: 'outbox.entry.send_failed',
-                    entry_id: entry.id
-                },
-                err
-            }, `${handler.LOG_KEY} Failed to send to ${handler.getLogInfo(payload)}.`);
-        }
-
-        return {success: false};
-    }
-
-    try {
-        await deleteProcessedEntry({db, entryId: entry.id});
-    } catch (err) {
-        await markEntryCompleted({db, entryId: entry.id});
-        logging.error({
-            system: {
-                event: 'outbox.entry.delete_failed',
-                entry_id: entry.id
-            },
-            err
-        }, `${handler.LOG_KEY} Sent to ${handler.getLogInfo(payload)} but failed to delete outbox entry ${entry.id}.`);
-    }
-
-    return {success: true};
-}
-
-async function processEntries({db, entries}) {
-    let processed = 0;
-    let failed = 0;
-
-    for (const entry of entries) {
-        const result = await processEntry({db, entry});
-        if (result.success) {
-            processed += 1;
-        } else {
-            failed += 1;
-        }
-    }
-
-    return {processed, failed};
-}
-
-module.exports = processEntries;

package/core/server/services/outbox/jobs/lib/process-outbox.js

@@ -1,96 +0,0 @@
-const logging = require('@tryghost/logging');
-const db = require('../../../../data/db');
-const MemberCreatedEvent = require('../../../../../shared/events/member-created-event');
-const {OUTBOX_STATUSES} = require('../../../../models/outbox');
-const {MESSAGES, MAX_ENTRIES_PER_JOB, BATCH_SIZE, OUTBOX_LOG_KEY} = require('./constants');
-const processEntries = require('./process-entries');
-const memberWelcomeEmailService = require('../../../member-welcome-emails/service');
-
-async function fetchPendingEntries({batchSize, jobStartISO}) {
-    let entries = [];
-    await db.knex.transaction(async (trx) => {
-        const query = trx('outbox')
-            .where('event_type', MemberCreatedEvent.name)
-            .where('status', OUTBOX_STATUSES.PENDING)
-            .where(function () {
-                this.whereNull('last_retry_at')
-                    .orWhere('last_retry_at', '<', jobStartISO);
-            });
-
-        entries = await query
-            .orderBy('created_at', 'asc')
-            .limit(batchSize)
-            .forUpdate()
-            .select('*');
-
-        if (entries.length > 0) {
-            const ids = entries.map(e => e.id);
-            await trx('outbox')
-                .whereIn('id', ids)
-                .update({
-                    status: OUTBOX_STATUSES.PROCESSING,
-                    updated_at: db.knex.raw('CURRENT_TIMESTAMP')
-                });
-        }
-    });
-
-    return entries;
-}
-
-async function processOutbox() {
-    const jobStartMs = Date.now();
-    const jobStartISO = new Date(jobStartMs).toISOString().slice(0, 19).replace('T', ' ');
-
-    memberWelcomeEmailService.init();
-    try {
-        await memberWelcomeEmailService.api.loadMemberWelcomeEmails();
-    } catch (err) {
-        logging.error({
-            system: {
-                event: 'outbox.init.failed'
-            },
-            err
-        }, `${OUTBOX_LOG_KEY} Service initialization failed.`);
-        return `${OUTBOX_LOG_KEY} Job aborted: Service initialization failed`;
-    }
-
-    let totalProcessed = 0;
-    let totalFailed = 0;
-
-    while (totalProcessed + totalFailed < MAX_ENTRIES_PER_JOB) {
-        const remainingCapacity = MAX_ENTRIES_PER_JOB - (totalProcessed + totalFailed);
-        const fetchSize = Math.min(BATCH_SIZE, remainingCapacity);
-
-        const entries = await fetchPendingEntries({batchSize: fetchSize, jobStartISO});
-        if (entries.length === 0) {
-            break;
-        }
-
-        const batchStartMs = Date.now();
-        const {processed, failed} = await processEntries({db, entries});
-        const batchDurationMs = Date.now() - batchStartMs;
-        const batchRate = ((processed + failed) / (Math.max(batchDurationMs, 1) / 1000)).toFixed(1);
-
-        totalProcessed += processed;
-        totalFailed += failed;
-
-        logging.info({
-            system: {
-                event: 'outbox.batch.complete',
-                entries_processed: processed,
-                entries_failed: failed,
-                duration_ms: batchDurationMs
-            }
-        }, `${OUTBOX_LOG_KEY} Batch complete: ${processed} processed, ${failed} failed in ${(batchDurationMs / 1000).toFixed(2)}s (${batchRate} entries/sec)`);
-    }
-
-    const durationMs = Date.now() - jobStartMs;
-
-    if (totalProcessed + totalFailed === 0) {
-        return `${OUTBOX_LOG_KEY} ${MESSAGES.NO_ENTRIES}`;
-    }
-
-    return `${OUTBOX_LOG_KEY} Job complete: Processed ${totalProcessed} outbox entries, ${totalFailed} failed in ${(durationMs / 1000).toFixed(2)}s`;
-}
-
-module.exports = processOutbox;

package/core/server/services/outbox/jobs/outbox-job.js

@@ -1,36 +0,0 @@
-const {parentPort} = require('worker_threads');
-const StartOutboxProcessingEvent = require('../events/start-outbox-processing-event');
-
-function cancel() {
-    if (parentPort) {
-        parentPort.postMessage('Outbox job cancelled before completion');
-        parentPort.postMessage('cancelled');
-    } else {
-        setTimeout(() => {
-            process.exit(0);
-        }, 1000);
-    }
-}
-
-if (parentPort) {
-    parentPort.once('message', (message) => {
-        if (message === 'cancel') {
-            return cancel();
-        }
-    });
-}
-
-(async () => {
-    if (parentPort) {
-        parentPort.postMessage({
-            event: {
-                type: StartOutboxProcessingEvent.name
-            }
-        });
-        parentPort.postMessage('done');
-    } else {
-        setTimeout(() => {
-            process.exit(0);
-        }, 1000);
-    }
-})();

package/types/ghost-storage-base.d.ts

@@ -1,22 +0,0 @@
-declare module 'ghost-storage-base' {
-    import {RequestHandler} from 'express';
-
-    export type StorageFile = {
-        name: string;
-        path: string;
-        type?: string;
-    };
-
-    export default abstract class StorageBase {
-        protected storagePath: string;
-        getTargetDir(baseDir?: string): string;
-        getUniqueFileName(file: StorageFile, targetDir: string): Promise<string>;
-        abstract save(file: StorageFile, targetDir?: string): Promise<string>;
-        abstract saveRaw(buffer: Buffer, targetPath: string): Promise<string>;
-        abstract exists(fileName: string, targetDir: string): Promise<boolean>;
-        abstract delete(fileName: string, targetDir: string): Promise<void>;
-        abstract read(file: {path: string}): Promise<Buffer>;
-        abstract serve(): RequestHandler;
-        abstract urlToPath(url: string): string;
-    }
-}