ghost 6.60.0 → 6.62.0

package/core/server/services/content-import/import/source.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareImportSource = prepareImportSource;
+exports.isDataFile = isDataFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const import_archive_1 = __importDefault(require("../../../data/importer/import-archive"));
+const assets_1 = require("./assets");
+const errors = require('@tryghost/errors');
+const DATA_EXTENSIONS = new Set(['.csv', '.json', '.md', '.markdown']);
+const noCleanup = async () => { };
+async function prepareImportSource(request) {
+    const extension = path_1.default.extname(request.fileName).toLowerCase();
+    if (extension === '.csv') {
+        return { filePath: request.filePath, cleanup: noCleanup };
+    }
+    if (extension !== '.zip') {
+        throw new errors.ValidationError({ message: 'Please select a valid CSV or ZIP file.' });
+    }
+    const archive = new import_archive_1.default({
+        extensions: [...DATA_EXTENSIONS],
+        directories: [],
+    });
+    const directory = await archive.extract(request.filePath);
+    let cleaned = false;
+    const cleanup = async () => {
+        if (!cleaned) {
+            cleaned = true;
+            await fs_extra_1.default.remove(directory);
+        }
+    };
+    try {
+        archive.isValid(directory);
+        const baseDirectory = archive.getBaseDirectory(directory);
+        const entries = (0, glob_1.globSync)('**/*', { cwd: directory, nodir: true, dot: true });
+        const dataFiles = entries.filter(isDataFile);
+        const csvFiles = dataFiles.filter((file) => extensionOf(file) === '.csv');
+        if (csvFiles.length === 0) {
+            throw new errors.ValidationError({
+                message: 'ZIP files uploaded here must contain one CSV file.',
+            });
+        }
+        if (csvFiles.length > 1) {
+            throw new errors.ValidationError({
+                message: 'ZIP files can contain only one CSV file. Remove the extra CSV files and try again.',
+            });
+        }
+        if (dataFiles.length > 1 || entries.some(isUnsupportedCompetingDataFile)) {
+            throw new errors.ValidationError({
+                message: 'ZIP files cannot contain CSV, JSON, or Markdown import files together. Keep only the CSV file and try again.',
+            });
+        }
+        validateWrapper(entries, csvFiles[0]);
+        const csvParts = csvFiles[0].split('/').filter(Boolean);
+        const csvBaseDirectory = csvParts.length === 2 ? csvParts[0] : undefined;
+        if (csvBaseDirectory !== baseDirectory) {
+            throw new errors.ValidationError({ message: 'Invalid ZIP file structure.' });
+        }
+        return {
+            filePath: path_1.default.join(directory, csvFiles[0]),
+            assets: await (0, assets_1.prepareAssetBatch)(archive, directory, baseDirectory),
+            cleanup,
+        };
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
+}
+function validateWrapper(entries, csvFile) {
+    const csvParts = csvFile.split('/').filter(Boolean);
+    if (csvParts.length !== 2) {
+        return;
+    }
+    const wrapper = csvParts[0];
+    const outsideWrapper = entries.some((entry) => {
+        const parts = entry.split('/').filter(Boolean);
+        return !isMetadata(parts) && parts[0] !== wrapper;
+    });
+    if (outsideWrapper) {
+        throw new errors.ValidationError({ message: 'Invalid ZIP file structure.' });
+    }
+}
+function isDataFile(fileName) {
+    const parts = fileName.split('/').filter(Boolean);
+    if (parts.length === 0 || isMetadata(parts)) {
+        return false;
+    }
+    const extension = extensionOf(fileName);
+    if (!DATA_EXTENSIONS.has(extension)) {
+        return false;
+    }
+    if (parts.length === 1) {
+        return true;
+    }
+    return parts.length === 2;
+}
+function extensionOf(fileName) {
+    return path_1.default.posix.extname(fileName).toLowerCase();
+}
+function isUnsupportedCompetingDataFile(fileName) {
+    const extension = extensionOf(fileName);
+    if (extension === '.csv' || !DATA_EXTENSIONS.has(extension)) {
+        return false;
+    }
+    const parts = fileName.split('/').filter(Boolean);
+    if (parts.length === 0 || isMetadata(parts) || isFileAttachment(parts)) {
+        return false;
+    }
+    return !isDataFile(fileName);
+}
+function isFileAttachment(parts) {
+    const assetParts = ['content', 'files'].includes(parts[0]) ? [...parts] : parts.slice(1);
+    if (assetParts[0] === 'content') {
+        assetParts.shift();
+    }
+    return assetParts.length > 1 && assetParts[0] === 'files';
+}
+function isMetadata(parts) {
+    return (parts[0] === '__MACOSX' || parts.some((part) => part.startsWith('._') || part === '.DS_Store'));
+}

package/core/server/services/content-import/import/staged-file.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImportFileStager = createImportFileStager;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function createImportFileStager() {
+    return {
+        async stage({ filePath, fileName }) {
+            const stagedPath = node_path_1.default.join(node_os_1.default.tmpdir(), `content-csv-import-${node_crypto_1.default.randomUUID()}`);
+            try {
+                await fs_extra_1.default.copyFile(filePath, stagedPath, fs_extra_1.default.constants.COPYFILE_EXCL);
+                await fs_extra_1.default.chmod(stagedPath, 0o600);
+            }
+            catch (error) {
+                await fs_extra_1.default.remove(stagedPath).catch(() => { });
+                throw error;
+            }
+            return { path: stagedPath, name: fileName };
+        },
+        async remove(file) {
+            await fs_extra_1.default.remove(file.path);
+        },
+    };
+}

package/core/server/services/content-import/import/store.js

@@ -10,17 +10,19 @@ const MAX_RUN_AGE_MS = 60 * 60 * 1000;
 class ImportRunStore {
     // Insertion-ordered, so count-eviction drops the oldest run first.
     _runs = new Map();
+    _settledWaiters = new Set();
     _now;
     constructor({ now = () => new Date() } = {}) {
         this._now = now;
     }
-    create(id, total) {
+    create(id, total, sourceColumns = []) {
         this.evict();
         const run = {
             id,
             status: 'running',
             startedAt: this._now(),
             total,
+            sourceColumns,
             rows: [],
         };
         this._runs.set(id, run);
@@ -47,10 +49,31 @@ class ImportRunStore {
     get(id) {
         return this._runs.get(id);
     }
+    release(id) {
+        this._runs.delete(id);
+        this.resolveSettledWaiters();
+    }
+    allSettled() {
+        if (this._runs.size === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this._settledWaiters.add(resolve);
+        });
+    }
+    resolveSettledWaiters() {
+        if (this._runs.size > 0) {
+            return;
+        }
+        for (const resolve of this._settledWaiters) {
+            resolve();
+        }
+        this._settledWaiters.clear();
+    }
     // A running run is never evicted, whatever its age: the job holds only the runId,
     // so evicting mid-import would silently turn its record()/finish() calls into
     // no-ops and lose the report. The count cap can briefly overshoot while several
-    // imports run at once; the inline job queue bounds how many that can be.
+    // imports run at once; the jobs backend bounds how many that can be.
     evict() {
         const cutoff = this._now().getTime() - MAX_RUN_AGE_MS;
         for (const [id, run] of this._runs) {

package/core/server/services/content-import/index.js

@@ -5,36 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 exports.importCSV = importCSV;
+exports.handleJob = handleJob;
+exports.allSettled = allSettled;
 const zod_1 = require("zod");
 const importer_1 = __importDefault(require("./import/importer"));
+const completion_email_1 = __importDefault(require("./import/completion-email"));
+const post_repository_1 = require("./import/post-repository");
 const reader_1 = __importDefault(require("./import/reader"));
-const row_1 = require("./import/row");
+const schema_1 = require("./import/schema");
 const store_1 = require("./import/store");
+const source_1 = require("./import/source");
+const media_1 = require("./import/media");
+const local_media_url_1 = require("./import/local-media-url");
+const post_link_1 = require("./import/post-link");
+const staged_file_1 = require("./import/staged-file");
+const jobs_service_1 = require("../jobs-service");
 // The request is built from HTTP upload metadata, so it is validated at the
 // service boundary rather than trusted.
-const importableFields = new Set(row_1.EDITORIAL_POST_FIELDS);
-const mappingSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.string()).superRefine((mapping, ctx) => {
-    const targets = new Set();
-    for (const [header, target] of Object.entries(mapping)) {
-        if (!header || header in Object.prototype) {
-            ctx.addIssue({ code: 'custom', message: `Invalid CSV header mapping: "${header}"` });
-        }
-        if (target && !importableFields.has(target)) {
-            ctx.addIssue({ code: 'custom', message: `Unknown post field mapping: "${target}"` });
-        }
-        if (target && targets.has(target)) {
-            ctx.addIssue({ code: 'custom', message: `Post field is mapped more than once: "${target}"` });
-        }
-        targets.add(target);
-    }
-    if (!targets.has('title')) {
-        ctx.addIssue({ code: 'custom', message: 'Post field mapping must include "title"' });
-    }
-});
-const importRequestSchema = zod_1.z.object({
-    filePath: zod_1.z.string().min(1),
-    mapping: mappingSchema.optional(),
-});
 // A junk timezone setting falls back to UTC rather than mis-stamping the batch tag.
 const timezoneSchema = zod_1.z.string().min(1).catch('Etc/UTC');
 const errors = require('@tryghost/errors');
@@ -47,12 +34,16 @@ function makeImporter() {
     // are guaranteed loaded.
     const models = require('../../models');
     const lexicalLib = require('../../lib/lexical');
-    const jobsService = require('../jobs');
     const settingsCache = require('../../../shared/settings-cache');
     const urlService = require('../url');
+    const urlUtils = require('../../../shared/url-utils').default;
+    const mediaInlinerService = require('../media-inliner');
+    const config = require('../../../shared/config');
     const ObjectID = require('bson-objectid').default;
-    // Inline jobs never reach the job manager's Sentry handler, which is wired to the
-    // offloaded worker path only, so a throw here would be seen by nobody.
+    const { GhostMailer } = require('../mail');
+    const ghostMailer = new GhostMailer();
+    // Row aggregates and best-effort cleanup are intentionally reported without
+    // failing a run. Fatal handler errors are reported by the class-based jobs service.
     const report = (error) => {
         try {
             logging.error({ event: { name: 'content.import.error' }, err: error }, '[Background Job] content-import error');
@@ -62,19 +53,38 @@ function makeImporter() {
             // Callers report from catch blocks, so this must not throw.
         }
     };
+    const email = {
+        send: (run, recipient) => ghostMailer.send((0, completion_email_1.default)(run, recipient, urlUtils.urlFor('admin', true))),
+        getDefaultRecipient: async () => (await models.User.getOwnerUser()).get('email'),
+    };
     return new importer_1.default({
         readRows: reader_1.default,
-        posts: {
-            create: (data, options) => models.Post.add(data, options),
-        },
+        prepareSource: source_1.prepareImportSource,
+        posts: new post_repository_1.BookshelfPostsRepository(models),
         getHtmlToLexical: () => lexicalLib.htmlToLexicalConverter,
         getMarkdownToHtml: () => require('@tryghost/kg-markdown-html-renderer').render,
         getCleanHTML: () => require('@tryghost/mg-clean-html').cleanHTML,
-        addJob: jobsService.addJob.bind(jobsService),
+        createMediaInliner: () => new media_1.PostMediaInliner({
+            media: mediaInlinerService.getInstance(),
+            isLocalMediaUrl: (sourceUrl) => (0, local_media_url_1.isLocalMediaUrl)(sourceUrl, {
+                siteUrl: config.getSiteUrl(),
+                subdir: config.getSubdir(),
+                assetBaseUrls: [
+                    config.get('urls:image'),
+                    config.get('urls:media'),
+                    config.get('urls:files'),
+                ],
+            }),
+        }),
+        email,
+        dispatchJob: (job) => (0, jobs_service_1.getInstance)().dispatch(job),
+        fileStager: (0, staged_file_1.createImportFileStager)(),
         report,
         store: new store_1.ImportRunStore(),
-        // Degrades to the 404 URL for a post the URL service cannot route yet (e.g. a draft).
-        urlForPost: (post) => urlService.getUrlForResource({ ...post.toJSON(), type: 'posts' }, { absolute: true }),
+        urlForPost: (post) => (0, post_link_1.urlForImportedPost)(post, {
+            adminUrl: urlUtils.urlFor('admin', true),
+            publishedUrl: (publishedPost) => urlService.getUrlForResource({ ...publishedPost.toJSON(), type: 'posts' }, { absolute: true }),
+        }),
         newRunId: () => new ObjectID().toHexString(),
         getTimezone: () => timezoneSchema.parse(settingsCache.get('timezone')),
     });
@@ -88,7 +98,7 @@ function importCSV(request) {
     if (!importer) {
         throw new errors.InternalServerError({ message: 'Content import service used before init' });
     }
-    const parsedRequest = importRequestSchema.safeParse(request);
+    const parsedRequest = schema_1.importRequestSchema.safeParse(request);
     if (!parsedRequest.success) {
         throw new errors.ValidationError({
             message: parsedRequest.error.issues[0]?.message ?? 'Invalid content import request',
@@ -97,3 +107,17 @@ function importCSV(request) {
     }
     return importer.importCSV(parsedRequest.data);
 }
+function handleJob(job) {
+    if (!importer) {
+        throw new errors.InternalServerError({ message: 'Content import service used before init' });
+    }
+    return importer.handle(job);
+}
+// Test-facing parity with the legacy inline queue while the import run store
+// remains in memory. M8 removes this together with that store.
+function allSettled() {
+    if (!importer) {
+        return Promise.resolve();
+    }
+    return importer.allSettled();
+}

package/core/server/services/content-import/jobs/content-csv-import-job.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const job_1 = require("../../jobs-service/job");
+class ContentCSVImportJob extends job_1.Job {
+    static type = 'content-csv-import';
+    importId;
+    file;
+    mapping;
+    importTagNames;
+    emailRecipient;
+    constructor(data) {
+        super();
+        this.importId = data.importId;
+        this.file = data.file;
+        this.mapping = data.mapping;
+        this.importTagNames = data.importTagNames;
+        this.emailRecipient = data.emailRecipient;
+    }
+}
+exports.default = ContentCSVImportJob;

package/core/server/services/custom-redirects/redirect-config-parser.js

@@ -45,7 +45,7 @@ const messages = {
     jsonInvalid: 'JSON input must be an array of redirect objects.',
     yamlParse: 'Could not parse YAML: {context}.',
     yamlInvalid: 'YAML input is invalid. Check the contents of your YAML file.',
-    redirectsHelp: 'https://ghost.org/docs/themes/routing/#redirects',
+    redirectsHelp: 'https://docs.ghost.org/themes/routing/#redirects',
 };
 const parseJson = (content) => {
     let parsed;
@@ -124,7 +124,7 @@ const parseYaml = (content) => {
 exports.parseYaml = parseYaml;
 // Round-trips through parseYaml to []. Avoids a "download → save →
 // re-upload throws on empty body" footgun on fresh installs.
-const EMPTY_DOWNLOAD_TEMPLATE = '# See https://ghost.org/docs/themes/routing/#redirects\n301: {}\n302: {}\n';
+const EMPTY_DOWNLOAD_TEMPLATE = '# See https://docs.ghost.org/themes/routing/#redirects\n301: {}\n302: {}\n';
 const serializeToYaml = (redirects) => {
     const permanent = [];
     const temporary = [];

package/core/server/services/custom-redirects/redirects-service.js

@@ -44,7 +44,7 @@ const dynamic_redirect_manager_1 = __importDefault(require("../lib/dynamic-redir
 const errify_1 = require("../../../shared/errify");
 const messages = {
     redirectsRegister: 'Could not register custom redirects.',
-    redirectsHelp: 'https://ghost.org/docs/themes/routing/#redirects',
+    redirectsHelp: 'https://docs.ghost.org/themes/routing/#redirects',
     skippedInvalidRedirect: 'Skipped invalid redirect: {context}',
     rejectedRedirect: 'Could not register redirect: {from} -> {to}',
     allRedirectsSkipped: 'None of the {total} redirect(s) in the store could be activated. Check the logged errors above.',

package/core/server/services/custom-redirects/validation.js

@@ -5,7 +5,7 @@ const errors = require('@tryghost/errors');
 const messages = {
   redirectsWrongFormat: 'Incorrect redirects file format.',
   invalidRedirectsFromRegex: 'Incorrect RegEx in redirects file.',
-  redirectsHelp: 'https://ghost.org/docs/themes/routing/#redirects',
+  redirectsHelp: 'https://docs.ghost.org/themes/routing/#redirects',
 };
 
 /**

package/core/server/services/email-address/email-address-parser.js

@@ -1,53 +1,45 @@
-const addressparser = require('nodemailer/lib/addressparser');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.parse = void 0;
+const addressparser_1 = __importDefault(require("nodemailer/lib/addressparser"));
 /**
- * @typedef {Object} EmailAddress
- * @property {string} address - The email address
- * @property {string} [name] - Optional name associated with the email
+ * Parse an email string into an EmailAddress object
+ * @param email Email string to parse
+ * @returns Parsed email or null if invalid
  */
-
-module.exports = class EmailAddressParser {
-  /**
-   * Parse an email string into an EmailAddress object
-   * @param {string} email - Email string to parse
-   * @returns {EmailAddress|null} Parsed email or null if invalid
-   */
-  static parse(email) {
+const parse = (email) => {
     if (!email || typeof email !== 'string' || !email.length) {
-      return null;
+        return null;
     }
-
-    const parsed = addressparser(email);
-
+    const parsed = (0, addressparser_1.default)(email);
     if (parsed.length !== 1) {
-      return null;
+        return null;
     }
     const first = parsed[0];
-
     // Check first has a group property
     if ('group' in first) {
-      // Unsupported format
-      return null;
+        // Unsupported format
+        return null;
     }
-
     return {
-      address: first.address,
-      name: first.name || undefined,
+        address: first.address,
+        name: first.name || undefined,
     };
-  }
-
-  /**
-   * Convert an EmailAddress object to a string representation
-   * @param {EmailAddress} email - Email object to stringify
-   * @returns {string} String representation of the email
-   */
-  static stringify(email) {
+};
+exports.parse = parse;
+/**
+ * Convert an EmailAddress object to a string representation
+ * @param email Email object to stringify
+ * @returns String representation of the email
+ */
+const stringify = (email) => {
     if (!email.name) {
-      return email.address;
+        return email.address;
     }
-
     const escapedName = email.name.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-
     /**
      * https://linear.app/ghost/issue/ONC-969
      *
@@ -65,8 +57,8 @@ module.exports = class EmailAddressParser {
      * We remove these characters from the name.
      */
     const nameCleanedForGmail = escapedName
-      .replace(/[\u2705\u2713\u2714\u2611\u{1F5F8}]/gu, '')
-      .trim();
+        .replace(/[\u2705\u2713\u2714\u2611\u{1F5F8}]/gu, '')
+        .trim();
     return `"${nameCleanedForGmail}" <${email.address}>`;
-  }
 };
+exports.stringify = stringify;

package/core/server/services/email-address/email-address-service.js

@@ -1,11 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmailAddressService = void 0;
 const logging_1 = __importDefault(require("@tryghost/logging"));
-const email_address_parser_js_1 = __importDefault(require("./email-address-parser.js"));
+const emailAddressParser = __importStar(require("./email-address-parser"));
 class EmailAddressService {
     #getManagedEmailEnabled;
     #getSendingDomain;
@@ -25,7 +58,7 @@ class EmailAddressService {
             if (!fallbackAddress) {
                 return null;
             }
-            return email_address_parser_js_1.default.parse(fallbackAddress);
+            return emailAddressParser.parse(fallbackAddress);
         };
         this.#isValidEmailAddress = dependencies.isValidEmailAddress;
     }
@@ -54,8 +87,8 @@ class EmailAddressService {
         return transformed.from.address;
     }
     getAddressFromString(from, replyTo) {
-        const parsedFrom = email_address_parser_js_1.default.parse(from);
-        const parsedReplyTo = replyTo ? email_address_parser_js_1.default.parse(replyTo) : undefined;
+        const parsedFrom = emailAddressParser.parse(from);
+        const parsedReplyTo = replyTo ? emailAddressParser.parse(replyTo) : undefined;
         return this.getAddress({
             from: parsedFrom ?? this.defaultFromEmail,
             replyTo: parsedReplyTo ?? undefined,

package/core/server/services/email-analytics/email-analytics-service.js

@@ -364,15 +364,22 @@ class EmailAnalyticsService {
             }
         };
         try {
-            await this.#fetchEvents({
+            const fetchResult = await this.#fetchEvents({
                 batchHandler: processBatch,
                 begin,
                 end,
                 maxEvents,
                 events: eventTypes,
             });
+            if (fetchResult?.safeCursor &&
+                (!fetchData.lastEventTimestamp || fetchResult.safeCursor < fetchData.lastEventTimestamp)) {
+                fetchData.lastEventTimestamp = fetchResult.safeCursor;
+            }
         }
         catch (err) {
+            // A fetch can process events from one domain before another domain fails. Keep the
+            // in-memory cursor at the start of this run so the next attempt retries every domain.
+            fetchData.lastEventTimestamp = begin;
             if (!(err instanceof Error) || err.message !== 'Fetching canceled') {
                 logging_1.default.error('[EmailAnalytics] Error while fetching');
                 logging_1.default.error(err);

package/core/server/services/email-analytics/index.js

@@ -20,7 +20,6 @@ const constants_1 = require("../member-welcome-emails/constants");
 const automation_email_analytics_batch_processor_1 = require("./automation-email-analytics-batch-processor");
 const gift_email_analytics_batch_processor_1 = require("./gift-email-analytics-batch-processor");
 const start_gift_email_analytics_job_event_1 = require("./events/start-gift-email-analytics-job-event");
-const gifts_1 = require("../gifts");
 const constants_2 = require("../gifts/constants");
 exports.newsletters = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
     logName: 'newsletters',
@@ -31,7 +30,7 @@ exports.automations = new email_analytics_service_wrapper_1.EmailAnalyticsServic
 exports.gifts = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
     logName: 'gifts',
 });
-const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList, membersRepository, models: { Email, EmailRecipientFailure, EmailSpamComplaintEvent }, metrics, prometheusClient, settingsCache, }) => {
+const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList, giftDeliveryService, membersRepository, models: { Email, EmailRecipientFailure, EmailSpamComplaintEvent }, metrics, prometheusClient, settingsCache, }) => {
     const queries = new queries_1.Queries(db.knex);
     const newsletterEmailEventProcessor = new email_event_processor_1.default({
         domainEvents,
@@ -133,11 +132,7 @@ const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList,
         },
         metrics,
         settingsCache,
-        createEventProcessor: () => new gift_email_analytics_batch_processor_1.GiftEmailAnalyticsBatchProcessor({
-            giftDeliveryService: {
-                recordOutcome: (data) => gifts_1.deliveryService.recordOutcome(data),
-            },
-        }),
+        createEventProcessor: () => new gift_email_analytics_batch_processor_1.GiftEmailAnalyticsBatchProcessor({ giftDeliveryService }),
     });
 };
 exports.init = init;

package/core/server/services/email-analytics/lib/queries.js

@@ -122,7 +122,13 @@ class Queries {
      */
     async getLastJobRunTimestamp(jobName) {
         const jobData = await this.getJobData(jobName);
-        return jobData ? jobData.finished_at || jobData.started_at : null;
+        const timestamp = jobData?.finished_at ?? jobData?.started_at ?? null;
+        if (timestamp === null) {
+            return null;
+        }
+        // SQLite returns datetime columns as strings or numbers, so normalise to a Date to match
+        // the declared return type and keep callers using Date methods (e.g. getTime()) safe.
+        return timestamp instanceof Date ? timestamp : new Date(timestamp);
     }
     /**
      * Sets the timestamp of the last seen event for the specified email analytics events.