ghost 6.60.0 → 6.61.0

package/core/server/services/automations/database-automations-repository.js

@@ -13,7 +13,7 @@ const dequal_1 = require("dequal");
 const lexical_1 = __importDefault(require("../../lib/lexical"));
 const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
 const constants_1 = require("../member-welcome-emails/constants");
-const db_date_1 = require("../../lib/db-date");
+const date_1 = require("../../lib/db-types/date");
 const stale_lock_cutoff_1 = require("./stale-lock-cutoff");
 const HOUR_MS = 60 * 60 * 1000;
 const DEFAULT_WELCOME_EMAIL_AUTOMATIONS = [
@@ -93,7 +93,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier, })
                 const updatedAutomation = await updateAutomation(trx, {
                     ...automation,
                     status: data.status,
-                    updated_at: (0, db_date_1.toDatabaseDate)(now),
+                    updated_at: (0, date_1.toDatabaseDate)(now),
                 });
                 await replaceAutomationGraph(trx, updatedAutomation.id, data.actions, data.edges);
                 if (updatedAutomation.status === 'inactive') {
@@ -130,7 +130,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier, })
                     .update({
                     email_sent_count: trx.raw('COALESCE(??, 0) + ?', ['email_sent_count', 1]),
                 });
-                const now = (0, db_date_1.toDatabaseDate)(new Date());
+                const now = (0, date_1.toDatabaseDate)(new Date());
                 await trx('automated_email_recipients').insert({
                     id: (0, bson_objectid_1.default)().toHexString(),
                     member_id: options.memberId,
@@ -281,7 +281,7 @@ async function ensureDefaultAutomations(trx) {
     }
 }
 async function ensureAutomation(trx, defaults) {
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const id = (0, bson_objectid_1.default)().toHexString();
     await trx('automations')
         .insert({
@@ -313,7 +313,7 @@ async function ensureWelcomeEmailAction(trx, automationId) {
     if (!email) {
         return;
     }
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const actionId = (0, bson_objectid_1.default)().toHexString();
     await insertActions(trx, [
         {
@@ -347,7 +347,7 @@ async function trigger(trx, options) {
         return;
     }
     const now = new Date();
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     const readyAt = getReadyAtForAction(firstAction, now, fakeWaitHoursMultiplier);
     const run = {
         id: (0, bson_objectid_1.default)().toHexString(),
@@ -366,14 +366,14 @@ async function trigger(trx, options) {
     });
 }
 async function insertRunStep(trx, { automationRunId, automationActionRevisionId, now, readyAt, }) {
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     await trx('automation_run_steps').insert({
         id: (0, bson_objectid_1.default)().toHexString(),
         created_at: nowString,
         updated_at: nowString,
         automation_run_id: automationRunId,
         automation_action_revision_id: automationActionRevisionId,
-        ready_at: (0, db_date_1.toDatabaseDate)(readyAt),
+        ready_at: (0, date_1.toDatabaseDate)(readyAt),
     });
 }
 async function fetchAndLockSteps(trx, limit) {
@@ -388,9 +388,9 @@ async function fetchAndLockSteps(trx, limit) {
     // 2. Try to lock those rows.
     // 3. Select any rows we successfully locked.
     const now = new Date();
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
+    const nowString = (0, date_1.toDatabaseDate)(now);
     const staleLockCutoff = (0, stale_lock_cutoff_1.getStaleLockCutoff)(now);
-    const staleLockCutoffString = (0, db_date_1.toDatabaseDate)(staleLockCutoff);
+    const staleLockCutoffString = (0, date_1.toDatabaseDate)(staleLockCutoff);
     const lockId = node_crypto_1.default.randomUUID();
     // 1. Select up to `limit` candidate rows.
     const candidates = await trx('automation_run_steps')
@@ -444,17 +444,17 @@ async function findNextPendingReadyAt(trx, staleLockCutoff) {
         .select({ next_ready_at: 'ready_at' })
         .where('status', 'pending')
         .where((builder) => {
-        builder.whereNull('locked_by').orWhere('locked_at', '<', (0, db_date_1.toDatabaseDate)(staleLockCutoff));
+        builder.whereNull('locked_by').orWhere('locked_at', '<', (0, date_1.toDatabaseDate)(staleLockCutoff));
     })
         .orderBy('ready_at')
         .first();
-    return row?.next_ready_at ? (0, db_date_1.fromDatabaseDate)(row.next_ready_at) : null;
+    return row?.next_ready_at ? (0, date_1.fromDatabaseDate)(row.next_ready_at) : null;
 }
 function buildStepToRun(row) {
     const base = {
         id: row.id,
         step_attempts: row.step_attempts,
-        ready_at: (0, db_date_1.fromDatabaseDate)(row.ready_at),
+        ready_at: (0, date_1.fromDatabaseDate)(row.ready_at),
         locked_by: row.locked_by,
         automation_run_id: row.automation_run_id,
         automation_id: row.automation_id,
@@ -544,7 +544,7 @@ async function findNextActionRevision(trx, sourceActionId) {
     return row ?? null;
 }
 async function markStepTerminal(trx, step, status) {
-    const nowString = (0, db_date_1.toDatabaseDate)(new Date());
+    const nowString = (0, date_1.toDatabaseDate)(new Date());
     return await updateStep(trx, step, {
         status,
         finished_at: nowString,
@@ -556,12 +556,12 @@ async function retryStep(trx, step, retryAt) {
         await markStepTerminal(trx, step, 'automation disabled');
         return false;
     }
-    const nowString = (0, db_date_1.toDatabaseDate)(new Date());
+    const nowString = (0, date_1.toDatabaseDate)(new Date());
     return await updateStep(trx, step, {
         status: 'pending',
         started_at: null,
         finished_at: null,
-        ready_at: (0, db_date_1.toDatabaseDate)(retryAt),
+        ready_at: (0, date_1.toDatabaseDate)(retryAt),
         updated_at: nowString,
     });
 }
@@ -586,8 +586,8 @@ function getReadyAtForAction(action, now, fakeWaitHoursMultiplier) {
     }
 }
 async function cancelCancelablePendingStepsForAutomation(trx, automationId, now) {
-    const nowString = (0, db_date_1.toDatabaseDate)(now);
-    const staleLockCutoff = (0, db_date_1.toDatabaseDate)((0, stale_lock_cutoff_1.getStaleLockCutoff)(now));
+    const nowString = (0, date_1.toDatabaseDate)(now);
+    const staleLockCutoff = (0, date_1.toDatabaseDate)((0, stale_lock_cutoff_1.getStaleLockCutoff)(now));
     await trx('automation_run_steps')
         .update({
         status: 'automation disabled',
@@ -707,7 +707,7 @@ async function replaceAutomationGraph(trx, automationId, submittedActions, edges
         revision.action_id,
         revision,
     ]));
-    const now = (0, db_date_1.toDatabaseDate)(new Date());
+    const now = (0, date_1.toDatabaseDate)(new Date());
     const actionsToInsert = [];
     const revisionsToInsert = [];
     for (const action of actions) {
@@ -884,14 +884,14 @@ async function insertActionRevisions(trx, revisions) {
 }
 function getNextRevisionCreatedAt(latestCreatedAt, requestedCreatedAt) {
     if (!latestCreatedAt) {
-        return (0, db_date_1.toDatabaseDate)(requestedCreatedAt);
+        return (0, date_1.toDatabaseDate)(requestedCreatedAt);
     }
-    const requestedTime = (0, db_date_1.fromDatabaseDate)(requestedCreatedAt).getTime();
-    const latestTime = (0, db_date_1.fromDatabaseDate)(latestCreatedAt).getTime();
+    const requestedTime = (0, date_1.fromDatabaseDate)(requestedCreatedAt).getTime();
+    const latestTime = (0, date_1.fromDatabaseDate)(latestCreatedAt).getTime();
     if (requestedTime > latestTime) {
-        return (0, db_date_1.toDatabaseDate)(requestedCreatedAt);
+        return (0, date_1.toDatabaseDate)(requestedCreatedAt);
     }
-    return (0, db_date_1.toDatabaseDate)(new Date(latestTime + 1000));
+    return (0, date_1.toDatabaseDate)(new Date(latestTime + 1000));
 }
 function buildActionRevision(actionId, action, createdAt) {
     switch (action.type) {
@@ -970,7 +970,7 @@ function buildAutomationBrowseResult(automation) {
         ...buildAutomationSummary(automation),
         stats: {
             last_run_created_at: automation.last_run_created_at
-                ? (0, db_date_1.fromDatabaseDate)(automation.last_run_created_at)
+                ? (0, date_1.fromDatabaseDate)(automation.last_run_created_at)
                 : null,
             total_run_count: Number(automation.total_run_count ?? 0),
             in_progress_run_count: Number(automation.in_progress_run_count ?? 0),
@@ -978,7 +978,7 @@ function buildAutomationBrowseResult(automation) {
     };
 }
 function serializeDate(date) {
-    const normalizedDate = (0, db_date_1.fromDatabaseDate)(date);
+    const normalizedDate = (0, date_1.fromDatabaseDate)(date);
     normalizedDate.setMilliseconds(0);
     return normalizedDate.toISOString();
 }

package/core/server/services/automations/poll.js

@@ -119,6 +119,7 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                         subject: step.email_subject,
                     },
                     member: {
+                        // Note that we don't use `automation_run.member_email` here. That's only for the historical record, not for functionality.
                         email: member.get('email'),
                         name: member.get('name'),
                         uuid: member.get('uuid'),

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparedAssetBatch = void 0;
+exports.prepareAssetBatch = prepareAssetBatch;
+exports.belongsToAssetDirectory = belongsToAssetDirectory;
+const content_files_1 = require("../../../data/importer/content-files");
+class PreparedAssetBatch {
+    groups;
+    constructor(groups) {
+        this.groups = groups;
+    }
+    get files() {
+        return this.groups.flatMap((group) => group.files);
+    }
+    async store() {
+        const results = await Promise.allSettled(this.groups.map((group) => group.importer.doImport(group.files)));
+        const failure = results.find((result) => result.status === 'rejected');
+        if (failure) {
+            const rollbackResults = await Promise.allSettled(results.flatMap((result, index) => result.status === 'fulfilled' ? [this.groups[index].importer.rollback(result.value)] : []));
+            const rollbackFailures = rollbackResults.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+            if (rollbackFailures.length > 0) {
+                // AggregateError is the native error for preserving storage and rollback
+                // failures; unlike GhostError it takes an iterable before its options.
+                // eslint-disable-next-line ghost/ghost-custom/ghost-error-usage
+                throw new AggregateError([failure.reason, ...rollbackFailures], 'Asset storage failed and rollback was incomplete.', { cause: failure.reason });
+            }
+            throw failure.reason;
+        }
+    }
+    rewriteRows(rows) {
+        const importData = {
+            data: { data: { posts: rows, tags: [], users: [] } },
+        };
+        for (const group of this.groups) {
+            importData[group.type] = group.files;
+            group.importer.preProcess(importData);
+        }
+    }
+}
+exports.PreparedAssetBatch = PreparedAssetBatch;
+async function prepareAssetBatch(archive, directory, baseDirectory, deps = {}) {
+    const handlers = deps.handlers ?? (0, content_files_1.createContentFileHandlers)();
+    const importers = deps.importers ?? (0, content_files_1.createContentFileImporters)();
+    const importerByType = new Map(importers.map((importer) => [importer.type, importer]));
+    const groups = await Promise.all(handlers.map(async (handler) => {
+        const files = archive
+            .getFiles(directory, handler.extensions)
+            .filter((file) => belongsToAssetDirectory(file.name, handler.type, baseDirectory));
+        if (files.length === 0) {
+            return;
+        }
+        const importer = importerByType.get(handler.type);
+        if (!importer) {
+            return;
+        }
+        return {
+            type: handler.type,
+            files: await handler.loadFile(files, baseDirectory),
+            importer,
+        };
+    }));
+    const presentGroups = groups.filter((group) => group !== undefined);
+    return presentGroups.length > 0 ? new PreparedAssetBatch(presentGroups) : undefined;
+}
+function belongsToAssetDirectory(fileName, type, baseDirectory) {
+    const parts = fileName.split('/').filter(Boolean);
+    if (baseDirectory && parts[0] === baseDirectory) {
+        parts.shift();
+    }
+    if (parts[0] === 'content') {
+        parts.shift();
+    }
+    return parts.length > 1 && parts[0] === type;
+}

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

@@ -45,7 +45,7 @@ const messages = {
     unreadableFile: 'The file could not be parsed as a CSV file.',
     tooManyPosts: 'This file contains more than {max} posts. Imports are temporarily limited to {max} posts at a time — please split the file into smaller files and try again.',
     allWritesFailed: 'Content import failed to write all {count} attempted {postNoun}.',
-    urlResolutionFailed: 'Content import could not resolve a URL for {count} created {postNoun}.',
+    urlResolutionFailed: 'Content import could not resolve a URL for {count} imported {postNoun}.',
 };
 function logLifecycle(message) {
     try {
@@ -64,6 +64,7 @@ function buildImportTagNames(runId, timezone, now) {
 }
 class ContentCSVImporter {
     _readRows;
+    _prepareSource;
     _posts;
     _getHtmlToLexical;
     _getMarkdownToHtml;
@@ -75,8 +76,9 @@ class ContentCSVImporter {
     _newRunId;
     _getTimezone;
     _now;
-    constructor({ readRows, posts, getHtmlToLexical, getMarkdownToHtml, getCleanHTML, addJob, report, store, urlForPost, newRunId, getTimezone, now = () => new Date(), }) {
+    constructor({ readRows, prepareSource = async ({ filePath }) => ({ filePath, cleanup: async () => { } }), posts, getHtmlToLexical, getMarkdownToHtml, getCleanHTML, addJob, report, store, urlForPost, newRunId, getTimezone, now = () => new Date(), }) {
         this._readRows = readRows;
+        this._prepareSource = prepareSource;
         this._posts = posts;
         this._getHtmlToLexical = getHtmlToLexical;
         this._getMarkdownToHtml = getMarkdownToHtml;
@@ -90,11 +92,13 @@ class ContentCSVImporter {
         this._now = now;
     }
     async importCSV(request) {
+        const source = await this._prepareSource(request);
         let rows;
         try {
-            rows = await this._readRows(request.filePath, request.mapping);
+            rows = await this._readRows(source.filePath, request.mapping);
         }
         catch (error) {
+            await this.cleanupSource(source.cleanup);
             throw new errors.ValidationError({
                 message: tpl(messages.unreadableFile),
                 err: error,
@@ -103,6 +107,7 @@ class ContentCSVImporter {
         // Temporary while import state is held in memory: the durable job
         // system milestone removes the cap.
         if (rows.length > MAX_POSTS) {
+            await this.cleanupSource(source.cleanup);
             throw new errors.ValidationError({
                 message: tpl(messages.tooManyPosts, { max: MAX_POSTS }),
             });
@@ -111,26 +116,36 @@ class ContentCSVImporter {
         const importTagNames = buildImportTagNames(runId, this._getTimezone(), this._now());
         this._store.create(runId, rows.length);
         logLifecycle('queued');
-        this._addJob({
-            job: () => this.runImportJob(runId, importTagNames, rows),
-            offloaded: false,
-            name: 'content-import',
-        });
+        try {
+            this._addJob({
+                job: () => this.runImportJob(runId, importTagNames, rows, source),
+                offloaded: false,
+                name: 'content-import',
+            });
+        }
+        catch (error) {
+            this._store.fail(runId, messageOf(error));
+            await this.cleanupSource(source.cleanup);
+            throw error;
+        }
         return { importId: runId, total: rows.length };
     }
     // Must resolve in every case: the job manager reads a rejected inline job as a
     // defect in the job itself, and there is no retry behind it.
-    async runImportJob(runId, importTagNames, rows) {
+    async runImportJob(runId, importTagNames, rows, source) {
         const startedAt = Date.now();
         logLifecycle('started');
         let urlFailureCount = 0;
         let firstUrlFailure;
         let failed = false;
         try {
+            if (source.assets) {
+                await source.assets.store();
+                source.assets.rewriteRows(rows);
+            }
             const htmlToLexical = this._getHtmlToLexical();
             const markdownToHtml = this._getMarkdownToHtml();
             const cleanHTML = this._getCleanHTML();
-            let attemptedWrites = 0;
             let successfulWrites = 0;
             let failedWrites = 0;
             let firstWriteFailure;
@@ -154,8 +169,9 @@ class ContentCSVImporter {
                     // failure. Stop the run before misclassifying it as a lost write.
                     throw error;
                 }
-                attemptedWrites += 1;
                 let post;
+                let writeStatus;
+                let warnings;
                 try {
                     // options.importing preserves the supplied timestamps and keeps the import silent:
                     // the webhook, Slack, IndexNow and mention consumers all stand down on it, and a
@@ -163,10 +179,27 @@ class ContentCSVImporter {
                     // it, one reason status is never 'scheduled'). Pinned by
                     // test/e2e-webhooks/posts-importer.test.js. A fresh options object per row: the
                     // model layer mutates it.
-                    post = await this._posts.create(data, {
+                    const result = await this._posts.write(data, {
                         importing: true,
                         context: { internal: true },
+                    }, {
+                        sourceUpdatedAt: row.updated_at,
+                        authorNames: row.authors,
+                        authorEmails: row.author_emails,
+                        tagNames: row.tags,
                     });
+                    if (result.status === 'skipped') {
+                        this._store.record(runId, {
+                            line,
+                            title: row.title,
+                            status: 'skipped',
+                            reason: result.reason,
+                        });
+                        continue;
+                    }
+                    post = result.post;
+                    writeStatus = result.status;
+                    warnings = result.warnings;
                     successfulWrites += 1;
                 }
                 catch (error) {
@@ -185,8 +218,9 @@ class ContentCSVImporter {
                 const outcome = {
                     line,
                     title: row.title,
-                    status: 'created',
+                    status: writeStatus,
                     postId: post.id,
+                    ...(warnings.length > 0 ? { warnings } : {}),
                 };
                 try {
                     outcome.url = this._urlForPost(post);
@@ -199,7 +233,7 @@ class ContentCSVImporter {
                 }
                 this._store.record(runId, outcome);
             }
-            if (attemptedWrites > 0 && successfulWrites === 0 && failedWrites === attemptedWrites) {
+            if (failedWrites > 0 && successfulWrites === 0) {
                 this._report(new errors.InternalServerError({
                     message: tpl(messages.allWritesFailed, {
                         count: failedWrites,
@@ -218,6 +252,7 @@ class ContentCSVImporter {
             this._store.fail(runId, messageOf(error));
         }
         finally {
+            await this.cleanupSource(source.cleanup);
             const outcome = failed ? 'failed after' : 'completed in';
             logLifecycle(`${outcome} ${Date.now() - startedAt}ms`);
         }
@@ -233,6 +268,14 @@ class ContentCSVImporter {
             }));
         }
     }
+    async cleanupSource(cleanup) {
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
 }
 function messageOf(error) {
     if (error &&

package/core/server/services/content-import/import/post-data.js

@@ -14,6 +14,7 @@ class RowSkipped extends Error {
 }
 exports.RowSkipped = RowSkipped;
 const DIRECT_OPTIONAL_FIELDS = [
+    'comment_id',
     'custom_excerpt',
     'feature_image',
     'canonical_url',

package/core/server/services/content-import/import/post-repository.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookshelfPostsRepository = void 0;
+const relations_1 = require("./relations");
+class BookshelfPostsRepository {
+    _models;
+    _relations;
+    constructor(models, relations = new relations_1.BookshelfPostRelationsResolver(models)) {
+        this._models = models;
+        this._relations = relations;
+    }
+    write(data, options, metadata = {}) {
+        return this._models.Base.transaction(async (transacting) => {
+            const writeOptions = { ...options, transacting };
+            const lookupOptions = { ...writeOptions, forUpdate: true };
+            let existingMatch;
+            if (data.comment_id) {
+                const existing = await this._models.Post.findOne({ comment_id: data.comment_id, status: 'all' }, lookupOptions);
+                if (existing) {
+                    existingMatch = {
+                        post: existing,
+                        duplicateReason: `A post with the source ID "${data.comment_id}" already exists.`,
+                    };
+                }
+            }
+            if (!existingMatch) {
+                const existing = await this._models.Post.findOne({ slug: data.slug, status: 'all' }, lookupOptions);
+                if (existing) {
+                    existingMatch = {
+                        post: existing,
+                        duplicateReason: `A post with the slug "${data.slug}" already exists.`,
+                    };
+                }
+            }
+            if (existingMatch) {
+                const { post: existing, duplicateReason } = existingMatch;
+                if (!metadata.sourceUpdatedAt) {
+                    return { status: 'skipped', reason: duplicateReason };
+                }
+                const incomingInstant = new Date(metadata.sourceUpdatedAt).getTime();
+                const storedUpdatedAt = existing.toJSON().updated_at;
+                const storedInstant = storedUpdatedAt
+                    ? new Date(storedUpdatedAt).getTime()
+                    : undefined;
+                if (Number.isNaN(incomingInstant) ||
+                    (storedInstant !== undefined && incomingInstant <= storedInstant)) {
+                    return {
+                        status: 'skipped',
+                        reason: 'The existing post is newer than or as recent as the imported row.',
+                    };
+                }
+                // Ghost's collision plugin treats updated_at as the client's version token.
+                // First update the content against the locked server version, then persist
+                // the incoming source timestamp on its own. The second edit is safe because
+                // timestamp-only importing edits are excluded from collision detection.
+                const resolved = await this._relations.resolve(data, metadata, writeOptions);
+                const collisionSafeData = { ...resolved.data };
+                if (storedUpdatedAt) {
+                    collisionSafeData.updated_at = storedUpdatedAt;
+                }
+                else {
+                    delete collisionSafeData.updated_at;
+                }
+                const editOptions = {
+                    ...writeOptions,
+                    id: existing.id,
+                };
+                await this._models.Post.edit(collisionSafeData, { ...editOptions });
+                const post = await this._models.Post.edit({ updated_at: metadata.sourceUpdatedAt }, { ...editOptions });
+                return { status: 'updated', post, warnings: resolved.warnings };
+            }
+            const resolved = await this._relations.resolve(data, metadata, writeOptions);
+            const post = await this._models.Post.add(resolved.data, writeOptions);
+            return { status: 'created', post, warnings: resolved.warnings };
+        });
+    }
+}
+exports.BookshelfPostsRepository = BookshelfPostsRepository;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookshelfPostRelationsResolver = void 0;
+exports.parseAuthorReferences = parseAuthorReferences;
+exports.parseTagReferences = parseTagReferences;
+const { slugify } = require('@tryghost/string');
+const validator = require('@tryghost/validator');
+function parseAuthorReferences(authorNames, authorEmails) {
+    const names = splitList(authorNames);
+    const emails = splitList(authorEmails);
+    return Array.from({ length: Math.max(names.length, emails.length) }, (_, index) => ({
+        ...(names[index] ? { name: names[index] } : {}),
+        ...(emails[index] ? { email: emails[index] } : {}),
+    }));
+}
+function parseTagReferences(tagNames) {
+    return splitList(tagNames).filter((tag) => Boolean(tag));
+}
+class BookshelfPostRelationsResolver {
+    _models;
+    constructor(models) {
+        this._models = models;
+    }
+    async resolve(data, source, options) {
+        const { authors, warnings } = await this.resolveAuthors(source, options);
+        const tags = await this.resolveTags(source, options);
+        const resolved = {
+            ...data,
+            tags: [...tags, ...data.tags],
+        };
+        if (authors.length > 0) {
+            resolved.authors = authors;
+        }
+        return { data: resolved, warnings };
+    }
+    async resolveAuthors(source, options) {
+        const authors = [];
+        const warnings = [];
+        const seen = new Set();
+        const authorsByEmail = new Map();
+        let owner;
+        const useOwner = async (warning) => {
+            owner ??= await this._models.User.getOwnerUser({ ...options });
+            warnings.push(warning);
+            if (!seen.has(owner.id)) {
+                seen.add(owner.id);
+                authors.push({ id: owner.id });
+            }
+        };
+        for (const reference of parseAuthorReferences(source.authorNames, source.authorEmails)) {
+            let author = null;
+            if (reference.email) {
+                if (!validator.isEmail(reference.email)) {
+                    await useOwner(`Author email "${reference.email}" is invalid; assigned Owner instead.`);
+                    continue;
+                }
+                const emailKey = reference.email.toLowerCase();
+                author = authorsByEmail.get(emailKey) ?? null;
+                if (!author) {
+                    author = (await this._models.User.getByEmail(emailKey, { ...options })) ?? null;
+                }
+                if (!author && reference.name) {
+                    author = await this._models.User.add({
+                        name: reference.name,
+                        email: emailKey,
+                        roles: ['Contributor'],
+                    }, { ...options });
+                }
+                if (!author) {
+                    await useOwner(`Author email "${reference.email}" has no name; assigned Owner instead.`);
+                    continue;
+                }
+                authorsByEmail.set(emailKey, author);
+            }
+            else if (reference.name) {
+                author = await this._models.User.findOne({ slug: slugify(reference.name) }, { ...options });
+                if (!author) {
+                    await useOwner(`Author "${reference.name}" has no email; assigned Owner instead.`);
+                    continue;
+                }
+            }
+            else {
+                await useOwner('An empty author entry was assigned to Owner instead.');
+                continue;
+            }
+            if (author && !seen.has(author.id)) {
+                seen.add(author.id);
+                authors.push({ id: author.id });
+            }
+        }
+        return { authors, warnings };
+    }
+    async resolveTags(source, options) {
+        const tags = [];
+        const seen = new Set();
+        for (const reference of parseTagReferences(source.tagNames)) {
+            const normalizedSlug = slugify(reference);
+            const lookups = [{ name: reference }, { slug: reference }];
+            if (normalizedSlug && normalizedSlug !== reference) {
+                lookups.push({ slug: normalizedSlug });
+            }
+            const findTag = async (lookupOptions = {}) => {
+                for (const lookup of lookups) {
+                    const tag = await this._models.Tag.findOne(lookup, {
+                        ...options,
+                        ...lookupOptions,
+                    });
+                    if (tag) {
+                        return tag;
+                    }
+                }
+                return null;
+            };
+            let tag = await findTag();
+            if (!tag) {
+                try {
+                    tag = await this._models.Tag.add({ name: reference }, { ...options });
+                }
+                catch (error) {
+                    if (!isUniqueConstraintError(error)) {
+                        throw error;
+                    }
+                    // A concurrent row or import may have created the same slug after our
+                    // lookup. A locking read sees that committed row under MySQL's default
+                    // repeatable-read isolation, where another ordinary select may not.
+                    tag = await findTag({ forUpdate: true });
+                    if (!tag) {
+                        throw error;
+                    }
+                }
+            }
+            if (!seen.has(tag.id)) {
+                seen.add(tag.id);
+                tags.push({ id: tag.id });
+            }
+        }
+        return tags;
+    }
+}
+exports.BookshelfPostRelationsResolver = BookshelfPostRelationsResolver;
+function splitList(value) {
+    return value?.split(',').map((part) => part.trim() || undefined) ?? [];
+}
+function isUniqueConstraintError(error) {
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? error.code
+        : undefined;
+    return (code === 'ER_DUP_ENTRY' || (typeof code === 'string' && code.startsWith('SQLITE_CONSTRAINT')));
+}