ghost 6.61.0 → 6.62.0

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

@@ -38,6 +38,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const post_data_1 = __importStar(require("./post-data"));
+const media_1 = require("./media");
+const content_csv_import_job_1 = __importDefault(require("../jobs/content-csv-import-job"));
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 const tpl = require('@tryghost/tpl');
@@ -49,7 +51,7 @@ const messages = {
 };
 function logLifecycle(message) {
     try {
-        logging.info(`[Background Job] content-import ${message}`);
+        logging.info(`[Background Job] ${content_csv_import_job_1.default.type} ${message}`);
     }
     catch {
         // Observability must not change whether an import is queued or resolves.
@@ -69,21 +71,27 @@ class ContentCSVImporter {
     _getHtmlToLexical;
     _getMarkdownToHtml;
     _getCleanHTML;
-    _addJob;
+    _createMediaInliner;
+    _email;
+    _dispatchJob;
+    _fileStager;
     _report;
     _store;
     _urlForPost;
     _newRunId;
     _getTimezone;
     _now;
-    constructor({ readRows, prepareSource = async ({ filePath }) => ({ filePath, cleanup: async () => { } }), 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, createMediaInliner, email, dispatchJob, fileStager, report, store, urlForPost, newRunId, getTimezone, now = () => new Date(), }) {
         this._readRows = readRows;
         this._prepareSource = prepareSource;
         this._posts = posts;
         this._getHtmlToLexical = getHtmlToLexical;
         this._getMarkdownToHtml = getMarkdownToHtml;
         this._getCleanHTML = getCleanHTML;
-        this._addJob = addJob;
+        this._createMediaInliner = createMediaInliner;
+        this._email = email;
+        this._dispatchJob = dispatchJob;
+        this._fileStager = fileStager;
         this._report = report;
         this._store = store;
         this._urlForPost = urlForPost;
@@ -92,75 +100,114 @@ class ContentCSVImporter {
         this._now = now;
     }
     async importCSV(request) {
-        const source = await this._prepareSource(request);
-        let rows;
+        const emailRecipient = request.requestUserEmail ?? (await this._email.getDefaultRecipient());
+        let stagedFile;
         try {
-            rows = await this._readRows(source.filePath, request.mapping);
+            stagedFile = await this._fileStager.stage(request);
         }
         catch (error) {
-            await this.cleanupSource(source.cleanup);
             throw new errors.ValidationError({
                 message: tpl(messages.unreadableFile),
                 err: error,
             });
         }
-        // Temporary while import state is held in memory: the durable job
-        // system milestone removes the cap.
-        if (rows.length > MAX_POSTS) {
+        let handedOff = false;
+        try {
+            const stagedRequest = {
+                filePath: stagedFile.path,
+                fileName: stagedFile.name,
+                mapping: request.mapping,
+                requestUserEmail: request.requestUserEmail,
+            };
+            const { source, preparedRows } = await this.readPreparedRows(stagedRequest);
             await this.cleanupSource(source.cleanup);
-            throw new errors.ValidationError({
-                message: tpl(messages.tooManyPosts, { max: MAX_POSTS }),
+            this.assertWithinPostLimit(preparedRows.rows);
+            const runId = this._newRunId();
+            const importTagNames = buildImportTagNames(runId, this._getTimezone(), this._now());
+            this._store.create(runId, preparedRows.rows.length, preparedRows.columns);
+            const job = new content_csv_import_job_1.default({
+                importId: runId,
+                file: stagedFile,
+                mapping: request.mapping,
+                importTagNames,
+                emailRecipient,
             });
+            logLifecycle('queued');
+            try {
+                await this._dispatchJob(job);
+            }
+            catch (error) {
+                this._store.fail(runId, messageOf(error));
+                this._store.release(runId);
+                throw error;
+            }
+            handedOff = true;
+            return { importId: runId, total: preparedRows.rows.length };
         }
-        const runId = this._newRunId();
-        const importTagNames = buildImportTagNames(runId, this._getTimezone(), this._now());
-        this._store.create(runId, rows.length);
-        logLifecycle('queued');
+        finally {
+            if (!handedOff) {
+                await this.cleanupStagedFile(stagedFile);
+            }
+        }
+    }
+    async handle(job) {
+        let source;
         try {
-            this._addJob({
-                job: () => this.runImportJob(runId, importTagNames, rows, source),
-                offloaded: false,
-                name: 'content-import',
+            const prepared = await this.readPreparedRows({
+                filePath: job.file.path,
+                fileName: job.file.name,
+                mapping: job.mapping,
             });
+            source = prepared.source;
+            this.assertWithinPostLimit(prepared.preparedRows.rows);
+            await this.processRows(job.importId, job.importTagNames, prepared.preparedRows.rows, prepared.source);
         }
         catch (error) {
-            this._store.fail(runId, messageOf(error));
-            await this.cleanupSource(source.cleanup);
+            this._store.fail(job.importId, messageOf(error));
             throw error;
         }
-        return { importId: runId, total: rows.length };
+        finally {
+            if (source) {
+                await this.cleanupSource(source.cleanup);
+            }
+            const run = this._store.get(job.importId);
+            if (run) {
+                await this.settle(() => this._email.send(run, job.emailRecipient));
+            }
+            this._store.release(job.importId);
+            await this.cleanupStagedFile(job.file);
+        }
+    }
+    allSettled() {
+        return this._store.allSettled();
     }
-    // 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, source) {
-        const startedAt = Date.now();
-        logLifecycle('started');
+    async processRows(runId, importTagNames, rows, source) {
         let urlFailureCount = 0;
         let firstUrlFailure;
-        let failed = false;
         try {
             if (source.assets) {
                 await source.assets.store();
-                source.assets.rewriteRows(rows);
+                source.assets.rewriteRows(rows.map(({ data }) => data));
             }
             const htmlToLexical = this._getHtmlToLexical();
             const markdownToHtml = this._getMarkdownToHtml();
             const cleanHTML = this._getCleanHTML();
+            const media = this._createMediaInliner();
             let successfulWrites = 0;
-            let failedWrites = 0;
-            let firstWriteFailure;
-            for (const [index, row] of rows.entries()) {
-                const line = index + 2;
+            let failedRows = 0;
+            let firstRowFailure;
+            for (const preparedRow of rows) {
+                const { data: row, source: sourceCells, line } = preparedRow;
                 let data;
                 try {
                     data = (0, post_data_1.default)(row, htmlToLexical, importTagNames, markdownToHtml, cleanHTML);
                 }
                 catch (error) {
                     if (error instanceof post_data_1.RowSkipped) {
-                        this._store.record(runId, {
+                        this.recordOutcome(runId, sourceCells, {
                             line,
                             title: row.title || null,
-                            status: 'skipped',
+                            status: 'failed',
                             reason: messageOf(error),
                         });
                         continue;
@@ -169,6 +216,26 @@ class ContentCSVImporter {
                     // failure. Stop the run before misclassifying it as a lost write.
                     throw error;
                 }
+                try {
+                    await media.inline(data);
+                }
+                catch (error) {
+                    if (error instanceof media_1.MediaInliningFailure) {
+                        if (failedRows === 0) {
+                            firstRowFailure = error;
+                        }
+                        failedRows += 1;
+                        this.recordOutcome(runId, sourceCells, {
+                            line,
+                            title: row.title,
+                            status: 'failed',
+                            reason: messageOf(error),
+                            mediaFailures: error.failures,
+                        });
+                        continue;
+                    }
+                    throw error;
+                }
                 let post;
                 let writeStatus;
                 let warnings;
@@ -184,16 +251,18 @@ class ContentCSVImporter {
                         context: { internal: true },
                     }, {
                         sourceUpdatedAt: row.updated_at,
+                        runTagName: importTagNames[1],
                         authorNames: row.authors,
                         authorEmails: row.author_emails,
                         tagNames: row.tags,
                     });
                     if (result.status === 'skipped') {
-                        this._store.record(runId, {
+                        this.recordOutcome(runId, sourceCells, {
                             line,
                             title: row.title,
                             status: 'skipped',
                             reason: result.reason,
+                            duplicate: result.duplicate,
                         });
                         continue;
                     }
@@ -203,11 +272,11 @@ class ContentCSVImporter {
                     successfulWrites += 1;
                 }
                 catch (error) {
-                    if (failedWrites === 0) {
-                        firstWriteFailure = error;
+                    if (failedRows === 0) {
+                        firstRowFailure = error;
                     }
-                    failedWrites += 1;
-                    this._store.record(runId, {
+                    failedRows += 1;
+                    this.recordOutcome(runId, sourceCells, {
                         line,
                         title: row.title,
                         status: 'failed',
@@ -220,6 +289,7 @@ class ContentCSVImporter {
                     title: row.title,
                     status: writeStatus,
                     postId: post.id,
+                    postType: data.type,
                     ...(warnings.length > 0 ? { warnings } : {}),
                 };
                 try {
@@ -231,32 +301,53 @@ class ContentCSVImporter {
                     }
                     urlFailureCount += 1;
                 }
-                this._store.record(runId, outcome);
+                this.recordOutcome(runId, sourceCells, outcome);
             }
-            if (failedWrites > 0 && successfulWrites === 0) {
+            if (failedRows > 0 && successfulWrites === 0) {
                 this._report(new errors.InternalServerError({
                     message: tpl(messages.allWritesFailed, {
-                        count: failedWrites,
-                        postNoun: failedWrites === 1 ? 'post' : 'posts',
+                        count: failedRows,
+                        postNoun: failedRows === 1 ? 'post' : 'posts',
                     }),
-                    err: firstWriteFailure,
+                    err: firstRowFailure,
                 }));
             }
             this.reportUrlFailures(urlFailureCount, firstUrlFailure);
             this._store.finish(runId);
         }
         catch (error) {
-            failed = true;
             this.reportUrlFailures(urlFailureCount, firstUrlFailure);
-            this._report(error);
-            this._store.fail(runId, messageOf(error));
+            throw error;
         }
-        finally {
+    }
+    async readPreparedRows(request) {
+        const source = await this._prepareSource(request);
+        try {
+            const result = await this._readRows(source.filePath, request.mapping);
+            const preparedRows = Array.isArray(result)
+                ? { columns: [], rows: result.map((data, index) => ({ data, line: index + 2 })) }
+                : result;
+            return { source, preparedRows };
+        }
+        catch (error) {
             await this.cleanupSource(source.cleanup);
-            const outcome = failed ? 'failed after' : 'completed in';
-            logLifecycle(`${outcome} ${Date.now() - startedAt}ms`);
+            throw new errors.ValidationError({
+                message: tpl(messages.unreadableFile),
+                err: error,
+            });
+        }
+    }
+    assertWithinPostLimit(rows) {
+        // Temporary while import state is held in memory: M8 removes the cap.
+        if (rows.length > MAX_POSTS) {
+            throw new errors.ValidationError({
+                message: tpl(messages.tooManyPosts, { max: MAX_POSTS }),
+            });
         }
     }
+    recordOutcome(runId, source, outcome) {
+        this._store.record(runId, source ? { ...outcome, source } : outcome);
+    }
     reportUrlFailures(count, firstFailure) {
         if (count > 0) {
             this._report(new errors.InternalServerError({
@@ -276,6 +367,22 @@ class ContentCSVImporter {
             this._report(error);
         }
     }
+    async cleanupStagedFile(file) {
+        try {
+            await this._fileStager.remove(file);
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
+    async settle(operation) {
+        try {
+            await operation();
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
 }
 function messageOf(error) {
     if (error &&

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalMediaUrl = isLocalMediaUrl;
+const CONTENT_PATH_PREFIXES = ['/content/images', '/content/media', '/content/files'];
+function normalizedPathPrefix(value) {
+    if (!value.startsWith('/')) {
+        return `/${value}`.replace(/\/+$/, '');
+    }
+    return value.replace(/\/+$/, '');
+}
+function pathHasPrefix(pathname, prefix) {
+    return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function isContentPath(pathname, subdirs) {
+    const normalizedPathname = normalizedPathPrefix(pathname);
+    const prefixes = subdirs.flatMap((subdir) => {
+        const normalizedSubdir = normalizedPathPrefix(subdir);
+        return CONTENT_PATH_PREFIXES.map((prefix) => `${normalizedSubdir}${prefix}`);
+    });
+    return [...CONTENT_PATH_PREFIXES, ...prefixes].some((prefix) => pathHasPrefix(normalizedPathname, prefix));
+}
+function parseUrl(value) {
+    try {
+        return new URL(value.startsWith('//') ? `https:${value}` : value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchesBaseUrl(source, baseUrl) {
+    const base = parseUrl(baseUrl.trim());
+    if (!base || source.host !== base.host) {
+        return false;
+    }
+    const basePath = normalizedPathPrefix(base.pathname);
+    return basePath === '' || basePath === '/' || pathHasPrefix(source.pathname, basePath);
+}
+/**
+ * Returns whether a media reference already belongs to this Ghost site or one
+ * of its configured asset hosts. This only classifies URLs; it never checks
+ * whether the referenced file exists.
+ */
+function isLocalMediaUrl(sourceUrl, options) {
+    const value = sourceUrl.trim();
+    if (value.startsWith('__GHOST_URL__')) {
+        return true;
+    }
+    if (value.startsWith('/') && !value.startsWith('//')) {
+        return isContentPath(value, [options.subdir]);
+    }
+    const source = parseUrl(value);
+    if (!source) {
+        return false;
+    }
+    if (options.assetBaseUrls.some((baseUrl) => typeof baseUrl === 'string' && matchesBaseUrl(source, baseUrl))) {
+        return true;
+    }
+    const site = parseUrl(options.siteUrl);
+    if (!site || source.host !== site.host) {
+        return false;
+    }
+    return isContentPath(source.pathname, [options.subdir, site.pathname]);
+}

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

@@ -33,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);