ghost 6.60.0 → 6.62.0

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

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostMediaInliner = exports.MediaInliningFailure = void 0;
+exports.isBlockedMediaUrl = isBlockedMediaUrl;
+const cheerio = require('cheerio');
+class MediaInliningFailure extends Error {
+    failures;
+    constructor(failures) {
+        const noun = failures.length === 1 ? 'file' : 'files';
+        super(`Could not import ${failures.length} media ${noun}.`);
+        this.name = 'MediaInliningFailure';
+        this.failures = failures;
+    }
+}
+exports.MediaInliningFailure = MediaInliningFailure;
+const DIRECT_MEDIA_FIELDS = {
+    image: ['src'],
+    audio: ['src', 'thumbnailSrc'],
+    video: ['src', 'thumbnailSrc', 'customThumbnailSrc'],
+    file: ['src'],
+    product: ['productImageSrc'],
+    header: ['backgroundImageSrc'],
+    signup: ['backgroundImageSrc'],
+    'call-to-action': ['imageUrl'],
+    bookmark: ['metadata.icon', 'metadata.thumbnail'],
+    embed: ['metadata.thumbnail_url'],
+    'before-after': ['beforeImage.src', 'afterImage.src'],
+};
+const HTML_MEDIA_FIELDS = {
+    html: ['html'],
+    email: ['html'],
+    'email-cta': ['html'],
+    toggle: ['heading', 'content'],
+    image: ['caption'],
+    gallery: ['caption'],
+    video: ['caption'],
+    product: ['productTitle', 'productDescription'],
+    header: ['header', 'subheader'],
+    bookmark: ['caption'],
+    codeblock: ['caption'],
+};
+const MARKDOWN_MEDIA_FIELDS = {
+    markdown: ['markdown'],
+};
+const BLOCKED_MEDIA_DOMAINS = ['images.unsplash.com', 'gravatar.com'];
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isRemoteMediaUrl(value) {
+    return /^(?:https?:)?\/\//i.test(value.trim());
+}
+function isBlockedMediaUrl(value) {
+    try {
+        const url = new URL(value.trim().replace(/^\/\//, 'https://'));
+        return BLOCKED_MEDIA_DOMAINS.some((domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`));
+    }
+    catch {
+        return false;
+    }
+}
+function getPath(record, path) {
+    return path.split('.').reduce((value, part) => {
+        return isRecord(value) ? value[part] : undefined;
+    }, record);
+}
+function setPath(record, path, value) {
+    const parts = path.split('.');
+    const leaf = parts.pop();
+    let target = record;
+    for (const part of parts) {
+        target = target[part];
+    }
+    target[leaf] = value;
+}
+async function replaceAsync(input, pattern, replacer) {
+    let result = '';
+    let lastIndex = 0;
+    for (const match of input.matchAll(pattern)) {
+        const index = match.index;
+        result += input.slice(lastIndex, index);
+        result += await replacer(match);
+        lastIndex = index + match[0].length;
+    }
+    return result + input.slice(lastIndex);
+}
+class PostMediaInliner {
+    _media;
+    _isLocalMediaUrl;
+    _cache = new Map();
+    _failures = new Map();
+    constructor({ media, isLocalMediaUrl, }) {
+        this._media = media;
+        this._isLocalMediaUrl = isLocalMediaUrl;
+    }
+    async inline(data) {
+        this._failures = new Map();
+        if (data.feature_image) {
+            data.feature_image = await this.inlineUrl(data.feature_image);
+        }
+        if (data.posts_meta?.og_image) {
+            data.posts_meta.og_image = await this.inlineUrl(data.posts_meta.og_image);
+        }
+        if (data.posts_meta?.twitter_image) {
+            data.posts_meta.twitter_image = await this.inlineUrl(data.posts_meta.twitter_image);
+        }
+        if (data.lexical) {
+            data.lexical = await this.inlineLexical(data.lexical);
+        }
+        if (this._failures.size > 0) {
+            throw new MediaInliningFailure([...this._failures.values()]);
+        }
+    }
+    async inlineUrl(sourceUrl) {
+        if (!isRemoteMediaUrl(sourceUrl) ||
+            isBlockedMediaUrl(sourceUrl) ||
+            this._isLocalMediaUrl(sourceUrl)) {
+            return sourceUrl;
+        }
+        let resultPromise = this._cache.get(sourceUrl);
+        if (!resultPromise) {
+            resultPromise = this._media.importUrl(sourceUrl);
+            this._cache.set(sourceUrl, resultPromise);
+        }
+        const result = await resultPromise;
+        if (result.status === 'failed') {
+            this.recordFailure(sourceUrl, result.reason);
+            return sourceUrl;
+        }
+        return result.storedUrl;
+    }
+    recordFailure(sourceUrl, reason) {
+        if (!this._failures.has(sourceUrl)) {
+            this._failures.set(sourceUrl, { sourceUrl, reason });
+        }
+    }
+    async inlineLexical(serializedLexical) {
+        const lexical = JSON.parse(serializedLexical);
+        if (!isRecord(lexical) || !isRecord(lexical.root) || !Array.isArray(lexical.root.children)) {
+            return serializedLexical;
+        }
+        await this.inlineLexicalChildren(lexical.root.children);
+        return JSON.stringify(lexical);
+    }
+    async inlineLexicalChildren(children) {
+        for (const child of children) {
+            if (!isRecord(child)) {
+                continue;
+            }
+            const type = typeof child.type === 'string' ? child.type : '';
+            for (const path of DIRECT_MEDIA_FIELDS[type] ?? []) {
+                const value = getPath(child, path);
+                if (typeof value === 'string' && value) {
+                    setPath(child, path, await this.inlineUrl(value));
+                }
+            }
+            if (type === 'gallery' && Array.isArray(child.images)) {
+                for (const image of child.images) {
+                    if (isRecord(image) && typeof image.src === 'string' && image.src) {
+                        image.src = await this.inlineUrl(image.src);
+                    }
+                }
+            }
+            for (const path of HTML_MEDIA_FIELDS[type] ?? []) {
+                const value = getPath(child, path);
+                if (typeof value === 'string' && value) {
+                    setPath(child, path, await this.inlineHtml(value));
+                }
+            }
+            for (const path of MARKDOWN_MEDIA_FIELDS[type] ?? []) {
+                const value = getPath(child, path);
+                if (typeof value === 'string' && value) {
+                    setPath(child, path, await this.inlineMarkdown(value));
+                }
+            }
+            if (Array.isArray(child.children)) {
+                await this.inlineLexicalChildren(child.children);
+            }
+        }
+    }
+    async inlineHtml(html) {
+        const $ = cheerio.load(html, { decodeEntities: false }, false);
+        const attributes = [
+            ['img[src]', 'src'],
+            ['img[data-src]', 'data-src'],
+            ['video[src]', 'src'],
+            ['video[poster]', 'poster'],
+            ['audio[src]', 'src'],
+            ['source[src]', 'src'],
+        ];
+        for (const [selector, attribute] of attributes) {
+            for (const element of $(selector).toArray()) {
+                const value = $(element).attr(attribute);
+                if (value) {
+                    $(element).attr(attribute, await this.inlineUrl(value));
+                }
+            }
+        }
+        for (const element of $('[srcset]').toArray()) {
+            const value = $(element).attr('srcset');
+            if (value) {
+                $(element).attr('srcset', await this.inlineSrcset(value));
+            }
+        }
+        for (const element of $('[style]').toArray()) {
+            const value = $(element).attr('style');
+            if (value) {
+                $(element).attr('style', await this.inlineCss(value));
+            }
+        }
+        for (const element of $('style').toArray()) {
+            const value = $(element).html();
+            if (value) {
+                $(element).html(await this.inlineCss(value));
+            }
+        }
+        return $.root().html();
+    }
+    async inlineSrcset(srcset) {
+        if (srcset.trimStart().startsWith('data:')) {
+            return srcset;
+        }
+        const candidates = srcset.split(',');
+        const inlined = [];
+        for (const candidate of candidates) {
+            const match = candidate.match(/^(\s*)(\S+)(.*)$/s);
+            if (!match) {
+                inlined.push(candidate);
+                continue;
+            }
+            const [, leading, sourceUrl, descriptor] = match;
+            inlined.push(`${leading}${await this.inlineUrl(sourceUrl)}${descriptor}`);
+        }
+        return inlined.join(',');
+    }
+    inlineCss(css) {
+        return replaceAsync(css, /url\(\s*(?:(["'])(.*?)\1|([^)'"\s][^)]*?))\s*\)/gi, async (match) => {
+            const sourceUrl = (match[2] ?? match[3]).trim();
+            if (!sourceUrl) {
+                return match[0];
+            }
+            const storedUrl = await this.inlineUrl(sourceUrl);
+            return match[0].replace(sourceUrl, storedUrl);
+        });
+    }
+    async inlineMarkdown(markdown) {
+        let result = await replaceAsync(markdown, /!\[[^\]]*]\(\s*(?:<([^>\s]+)>|((?:https?:)?\/\/[^\s)]+))(?=[\s)])/gi, async (match) => {
+            const sourceUrl = (match[1] ?? match[2]);
+            return match[0].replace(sourceUrl, await this.inlineUrl(sourceUrl));
+        });
+        result = await replaceAsync(result, /<(?:img|video|audio|source)\b[^>]*>/gi, async (match) => this.inlineHtml(match[0]));
+        return replaceAsync(result, /<style\b[^>]*>[\s\S]*?<\/style>/gi, async (match) => this.inlineHtml(match[0]));
+    }
+}
+exports.PostMediaInliner = PostMediaInliner;

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',
@@ -32,7 +33,6 @@ const META_FIELDS = [
     'twitter_image',
     'twitter_title',
     'twitter_description',
-    'frontmatter',
 ];
 function buildPostData(row, htmlToLexical, importTagNames, markdownToHtml, cleanHTML) {
     const check = row_1.importableRowSchema.safeParse(row);

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlForImportedPost = urlForImportedPost;
+function urlForImportedPost(post, options) {
+    const data = post.toJSON();
+    if (data.status === 'draft') {
+        const editorType = data.type === 'page' ? 'page' : 'post';
+        return new URL(`#/editor/${editorType}/${post.id}`, options.adminUrl).href;
+    }
+    return options.publishedUrl(post);
+}

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

@@ -0,0 +1,100 @@
+"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,
+                ...(metadata.runTagName ? { withRelated: ['tags'] } : {}),
+            };
+            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.`,
+                        matchedBy: 'source_id',
+                    };
+                }
+            }
+            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.`,
+                        matchedBy: 'slug',
+                    };
+                }
+            }
+            if (existingMatch) {
+                const { post: existing, duplicateReason, matchedBy } = existingMatch;
+                const duplicate = {
+                    origin: hasRunTag(existing, metadata.runTagName) ? 'this_import' : 'pre_existing',
+                    matchedBy,
+                };
+                if (!metadata.sourceUpdatedAt) {
+                    return { status: 'skipped', reason: duplicateReason, duplicate };
+                }
+                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.',
+                        duplicate,
+                    };
+                }
+                // 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;
+function hasRunTag(post, runTagName) {
+    if (!runTagName) {
+        return false;
+    }
+    const tags = post.toJSON().tags;
+    return (Array.isArray(tags) &&
+        tags.some((tag) => typeof tag === 'object' &&
+            tag !== null &&
+            'name' in tag &&
+            tag.name === runTagName));
+}

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

@@ -5,6 +5,13 @@ const csv_1 = require("../csv");
 const row_1 = require("./row");
 const FIELD_BY_HEADER = Object.fromEntries(row_1.EDITORIAL_POST_FIELDS.map((field) => [field, field]));
 async function readPostRows(path, mapping) {
-    const rows = await (0, csv_1.parse)(path, mapping ?? FIELD_BY_HEADER);
-    return rows.map((row) => row_1.postImportRowSchema.parse(row));
+    const parsed = await (0, csv_1.parseWithSource)(path, mapping ?? FIELD_BY_HEADER);
+    return {
+        columns: parsed.columns,
+        rows: parsed.rows.map(({ data, source, line }) => ({
+            data: row_1.postImportRowSchema.parse(data),
+            source,
+            line,
+        })),
+    };
 }

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')));
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildImportReport;
+const csv_1 = require("../csv");
+const REPORT_COLUMNS = [
+    'line',
+    'title',
+    'outcome',
+    'reason',
+    'duplicate_origin',
+    'matched_by',
+    'warnings',
+    'media_failures',
+    'post_url',
+];
+function formatMediaFailures(row) {
+    return (row.mediaFailures?.map(({ sourceUrl, reason }) => `${sourceUrl}: ${reason}`).join('\n') ?? '');
+}
+function buildImportReport(run) {
+    if (!run.rows.length) {
+        return undefined;
+    }
+    return (0, csv_1.serialize)(run.rows.map((row) => ({
+        line: row.line,
+        title: row.title ?? '',
+        outcome: row.duplicate ? 'duplicate' : row.status,
+        reason: row.reason ?? '',
+        duplicate_origin: row.duplicate?.origin ?? '',
+        matched_by: row.duplicate?.matchedBy ?? '',
+        warnings: row.warnings?.join('\n') ?? '',
+        media_failures: formatMediaFailures(row),
+        post_url: row.url ?? '',
+    })), { columns: REPORT_COLUMNS });
+}

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

@@ -16,6 +16,9 @@ exports.EDITORIAL_POST_FIELDS = [
     'created_at',
     'updated_at',
     'published_at',
+    'authors',
+    'author_emails',
+    'tags',
     'feature_image',
     'feature_image_alt',
     'feature_image_caption',
@@ -29,10 +32,10 @@ exports.EDITORIAL_POST_FIELDS = [
     'twitter_image',
     'twitter_title',
     'twitter_description',
+    'comment_id',
     'custom_template',
     'codeinjection_head',
     'codeinjection_foot',
-    'frontmatter',
 ];
 // An empty cell (or the literal 'undefined') reads as absent, not as a value.
 const optionalCell = zod_1.z
@@ -58,6 +61,9 @@ exports.postImportRowSchema = zod_1.z
     created_at: optionalCell,
     updated_at: optionalCell,
     published_at: optionalCell,
+    authors: optionalCell,
+    author_emails: optionalCell,
+    tags: optionalCell,
     feature_image: optionalCell,
     feature_image_alt: optionalCell,
     feature_image_caption: optionalCell,
@@ -71,10 +77,10 @@ exports.postImportRowSchema = zod_1.z
     twitter_image: optionalCell,
     twitter_title: optionalCell,
     twitter_description: optionalCell,
+    comment_id: optionalCell,
     custom_template: optionalCell,
     codeinjection_head: optionalCell,
     codeinjection_foot: optionalCell,
-    frontmatter: optionalCell,
 })
     .loose();
 const ENUM_FIELDS = {
@@ -95,6 +101,9 @@ exports.importableRowSchema = exports.postImportRowSchema.superRefine((row, ctx)
     else if (row.title.length > 255) {
         ctx.addIssue({ code: 'custom', message: 'title must be 255 characters or fewer' });
     }
+    if (row.comment_id && row.comment_id.length > 50) {
+        ctx.addIssue({ code: 'custom', message: 'comment_id must be 50 characters or fewer' });
+    }
     for (const field of DATE_FIELDS) {
         const value = row[field];
         if (value && !isValidDate(value)) {

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importRequestSchema = exports.mappingSchema = void 0;
+const zod_1 = require("zod");
+const row_1 = require("./row");
+const importableFields = new Set(row_1.EDITORIAL_POST_FIELDS);
+exports.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"' });
+    }
+});
+exports.importRequestSchema = zod_1.z.object({
+    filePath: zod_1.z.string().min(1),
+    fileName: zod_1.z.string().min(1),
+    mapping: exports.mappingSchema.optional(),
+    requestUserEmail: zod_1.z.string().email().nullable().optional(),
+});