1#!/usr/bin/env node
2'use strict';
3
4// Public-only, read-only WooCommerce quick-mode capture. This deliberately contains no
5// credentials, browser automation, or fallback endpoint guessing.
6const capabilities = require('../../../lib/execution-capability');
7const siteRegional = require('../../../lib/site-regional');
8const wixAuth = require('../../../lib/wix-auth');
9const

quick-mode.js on GitHub

documentUrlGuard

=

require

(

'../../../lib/document-url-guard'

);

const catalogBaseline = require('../../../lib/catalog-baseline');

const fs = require('node:fs/promises');

const path = require('node:path');

const crypto = require('node:crypto');

const ADAPTER_DIR = path.resolve(__dirname, '..');

const CONTRACT_PATH = path.join(ADAPTER_DIR, 'quick-mode.json');

const CONTRACT = require(CONTRACT_PATH);

const sourceCoverage = require(path.join(ADAPTER_DIR, '..', '..', 'lib', 'source-coverage.js'));

const sourceRegional = require(path.join(ADAPTER_DIR, '..', '..', 'lib', 'source-regional.js'));

const { buildQuickWooCommerceRegional } = require(path.join(ADAPTER_DIR, '..', 'rp-source-wordpress', 'lib', 'regional-capture.js'));

const recovery = require(path.join(ADAPTER_DIR, '..', 'rp-quick-runtime', 'lib', 'limit-recovery.js'));

const importProgress = require(path.join(ADAPTER_DIR, '..', 'rp-quick-runtime', 'lib', 'import-progress.js'));

// On the public Store API this is a no-op — `src` there is already the original — so

// the URLs produced here do not change. It is called anyway because naming an image field

// directly is how a whole catalog once shipped as thumbnails: the same idiom got copied onto the

// authenticated wc/v3 payload, where `src` can be the smallest crop.

const { resolveImageUrls } = require(path.join(ADAPTER_DIR, '..', 'rp-source-wordpress', 'lib', 'wp-image-url.js'));

const { composeProductDescription } = require(path.join(ADAPTER_DIR, '..', 'rp-target-wix', 'lib', 'wix-build.js'));

async function readJson(filePath) {

return JSON.parse(await fs.readFile(filePath, 'utf8'));

}

async function writeJson(filePath, value) {

await fs.mkdir(path.dirname(filePath), { recursive: true });

await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');

}

// A dry run never touches the live audit log.

async function appendAudit(projectDir, entry, dryRun = false) {

if (dryRun) return;

const file = path.join(projectDir, 'logs', 'quick-mode-audit.ndjson');

await fs.mkdir(path.dirname(file), { recursive: true });

await fs.appendFile(file, `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`, 'utf8');

}

function origin(value) {

const url = new URL(value);

if (!['http:', 'https:'].includes(url.protocol)) throw new Error('sourceUrl must use http or https');

// Every capture below fetches this origin from the operator's machine: refuse loopback, private and

// link-local (cloud metadata) hosts. Lexical only; it does not resolve DNS. RP_TRUSTED_ORIGINS (the

// same variable the headless bundle uses) names origins the operator explicitly trusts, e.g. a local

// test server.

const trusted = String(process.env.RP_TRUSTED_ORIGINS || '').split(',').map((entry) => entry.trim()).filter(Boolean);

if (!trusted.includes(url.origin) && documentUrlGuard.isPrivateHostname(url.hostname)) throw new Error('sourceUrl must be a public host, not a loopback, private or link-local address');

return url.origin;

}

function fingerprint(value) {

return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');

}

async function projectContext(projectDir) {

const decisions = await readJson(path.join(projectDir, 'orchestration', 'decisions.json'));

const sourceUrl = decisions.sourceUrl && decisions.sourceUrl.value;

const sourcePlatform = decisions.sourcePlatform && decisions.sourcePlatform.value;

if (!sourceUrl) throw new Error('quick mode requires orchestration.decisions.sourceUrl');

if (sourcePlatform !== 'woocommerce') throw new Error(`quick WooCommerce adapter requires sourcePlatform=woocommerce (got ${sourcePlatform || 'missing'})`);

return { sourceUrl: origin(sourceUrl), decisions };

}

async function fetchCollection(baseUrl, route) {

const records = [];

const pages = [];

for (let page = 1; ; page += 1) {

const url = new URL(route, `${baseUrl}/`);

url.searchParams.set('page', String(page));

url.searchParams.set('per_page', '100');

const response = await fetch(url, { headers: { accept: 'application/json' } });

const text = await response.text();

let body;

try { body = text ? JSON.parse(text) : null; } catch { body = null; }

if (!response.ok || !Array.isArray(body)) {

return { ok: false, status: response.status, url: url.toString(), bodyType: Array.isArray(body) ? 'array' : typeof body, records, pages };

}

records.push(...body);

pages.push({ page, count: body.length, url: url.toString() });

const totalPages = Number(response.headers.get('x-wp-totalpages'));

if (Number.isFinite(totalPages) ? page >= totalPages : body.length < 100) break;

}

return { ok: true, records, pages };

}

async function preflight(projectDir) {

const { sourceUrl } = await projectContext(projectDir);

const checks = [];

for (const entity of CONTRACT.entities) {

const result = await fetchCollection(sourceUrl, entity.route);

checks.push({ entity: entity.id, route: entity.route, ok: result.ok, status: result.status || 200, url: result.url || result.pages[0]?.url || null, responseShape: result.ok ? 'array' : result.bodyType });

}

const out = { schemaVersion: 1, generatedAt: new Date().toISOString(), adapter: { id: CONTRACT.id, version: CONTRACT.version, fingerprint: fingerprint(CONTRACT) }, sourceUrl, status: checks.every((check) => check.ok) ? 'passed' : 'blocked', checks };

await writeJson(path.join(projectDir, 'quick-mode', 'preflight.json'), out);

return out;

}

// Two bounded public GETs -- the first Store API product and the storefront home page -- for the

// store's currency and language. A read that fails is an explicit unknown in the file, never a

// plan failure.

async function readPublic(url, accept, parse) {

try {

const response = await fetch(url, { headers: { accept }, signal: AbortSignal.timeout(15000) });

return response.ok ? parse(await response.text()) : null;

} catch { return null; }

}

async function captureRegional(projectDir, sourceUrl, generatedAt) {

const products = await readPublic(new URL('/wp-json/wc/store/v1/products?per_page=1', sourceUrl), 'application/json', (body) => { const parsed = JSON.parse(body); return Array.isArray(parsed) ? parsed : null; });

const page = await readPublic(new URL('/', sourceUrl), 'text/html', (html) => ({ html }));

return sourceRegional.writeSourceRegional(projectDir, buildQuickWooCommerceRegional({ products, page, generatedAt }));

}

async function plan(projectDir) {

const { sourceUrl } = await projectContext(projectDir);

const preflightResult = await readJson(path.join(projectDir, 'quick-mode', 'preflight.json'));

if (preflightResult.status !== 'passed') throw new Error('quick mode preflight must pass before planning');

const adapter = { id: CONTRACT.id, version: CONTRACT.version, fingerprint: fingerprint(CONTRACT) };

const generatedAt = new Date().toISOString();

// Every excluded[] capability becomes a declared-exclusion coverage row, checked by the same

// reconcile rule as a full run before the plan is written.

const coverage = await sourceCoverage.writeQuickPlanCoverage(projectDir, CONTRACT, { rawText: await fs.readFile(CONTRACT_PATH, 'utf8'), generatedAt });

await captureRegional(projectDir, sourceUrl, generatedAt);

const planResult = { schemaVersion: 1, generatedAt, managementImportMode: 'quick', adapter, sourceUrl, entities: CONTRACT.entities, requiredWixCapabilities: CONTRACT.requiredWixCapabilities, excluded: CONTRACT.excluded, excludedCapabilities: CONTRACT.excludedCapabilities, sourceAuth: 'none', sourceCoverageContract: coverage.sourceCoverageContract };

await writeJson(path.join(projectDir, 'quick-mode', 'plan.json'), planResult);

await writeJson(path.join(projectDir, 'execution', 'execution-manifest.json'), { schemaVersion: 1, generatedAt: planResult.generatedAt, managementImportMode: 'quick', adapter, extractCommand: 'rp-quick-woocommerce extract', importCommand: 'rp-quick-woocommerce import', entities: CONTRACT.entities.map((entity) => entity.id) });

return planResult;

}

async function extract(projectDir) {

const { sourceUrl } = await projectContext(projectDir);

const planResult = await readJson(path.join(projectDir, 'quick-mode', 'plan.json'));

if (planResult.adapter.fingerprint !== fingerprint(CONTRACT)) throw new Error('quick adapter contract changed; re-run preflight and plan');

const entities = {};

for (const entity of CONTRACT.entities) {

const result = await fetchCollection(sourceUrl, entity.route);

if (!result.ok) throw new Error(`${entity.id} extraction failed: ${result.status} ${result.url}`);

const file = path.join(projectDir, 'data', 'source-extract', `${entity.id}.ndjson`);

await fs.mkdir(path.dirname(file), { recursive: true });

await fs.writeFile(file, result.records.map((record) => JSON.stringify(record)).join('\n') + (result.records.length ? '\n' : ''), 'utf8');

entities[entity.id] = { file: path.relative(projectDir, file), route: entity.route, recordCount: result.records.length, pages: result.pages };

}

const manifest = { schemaVersion: 1, generatedAt: new Date().toISOString(), managementImportMode: 'quick', adapter: planResult.adapter, sourceUrl, entities };

await writeJson(path.join(projectDir, 'data', 'source-extract', 'manifest.json'), manifest);

return manifest;

}

function nonEmpty(value) { const text = value == null ? '' : String(value).trim(); return text || undefined; }

function text(value) { return String(value || '').replace(/<[^>]*>/g, '').replace(/&/g, '&').replace(/"/g, '"').trim(); }

function slug(value) { return nonEmpty(value)?.toLowerCase().replace(/[_\s]+/g, '-').replace(/[^a-z0-9-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || undefined; }

function price(value, minor = 2) { const n = Number(value); return Number.isFinite(n) ? (n / (10 ** Number(minor || 2))).toFixed(Number(minor || 2)) : '0.00'; }

async function readLines(filePath) { const raw = await fs.readFile(filePath, 'utf8'); return raw.split(/\r?\n/).filter(Boolean).map(JSON.parse); }

async function loadWixEnv(projectDir) {

const values = {};

try {

for (const line of (await fs.readFile(path.join(projectDir, 'config', 'wix.env'), 'utf8')).split(/\r?\n/)) {

const m = line.trim().match(/^([A-Z0-9_]+)=(.*)$/); if (m) values[m[1]] = m[2].replace(/^['"]|['"]$/g, '').trim();

}

} catch (error) { if (error.code !== 'ENOENT') throw error; }

return { ...values, ...process.env };

}

async function loadCrosswalk(projectDir) {

try { return await readJson(path.join(projectDir, 'state', 'crosswalk', 'quick-mode.json')); }

catch (error) { if (error.code === 'ENOENT') return {}; throw error; }

}

// A token from config/wix.env renews itself for this site; a process-env override is used as given.

function wixCredentials(projectDir, env, dryRun) { return dryRun || process.env.WIX_AUTH_TOKEN ? { authToken: env.WIX_AUTH_TOKEN } : { tokenSource: wixAuth.createWixTokenSource({ projectDir, siteId: env.WIX_SITE_ID }) }; }

async function ensureFallbackAuthor(projectDir) {

const env = await loadWixEnv(projectDir);

if (env.WIX_BLOG_FALLBACK_MEMBER_ID) return { status: 'already_configured', memberId: env.WIX_BLOG_FALLBACK_MEMBER_ID };

if (!env.WIX_AUTH_TOKEN || !env.WIX_SITE_ID) throw new Error('WIX_AUTH_TOKEN and WIX_SITE_ID are required to provision the Blog fallback author');

const writers = require(path.join(ADAPTER_DIR, '..', 'rp-target-wix', 'lib', 'wix-writers.js'));

const dryRun = writers.createDryRunConfig(env, process.argv.slice(2)).dryRun;

if (dryRun) return { status: 'planned_dry_run', memberId: null };

const quickRun = capabilities.startQuickRun({ projectDir, adapterId: 'quick-woocommerce', siteId: env.WIX_SITE_ID, dryRun: false });

const wix = writers.createWixClient({ capability: capabilities.bindQuickSetup(quickRun, 'blog-fallback-author'), ...wixCredentials(projectDir, env, false) });

const projectId = path.basename(projectDir).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'migration';

const email = `replatform+${projectId}@wix.com`;

const listed = await writers.listMembers(wix, { limit: 100 });

let member = (listed.members || []).find((item) => String(item.loginEmail || '').toLowerCase() === email);

if (!member) member = await writers.ensureBlogFallbackAuthor(wix, { email, name: 'Imported content', slug: `imported-content-${projectId}` });

if (!member || !member.id) throw new Error('fallback Blog author was not created');

const configPath = path.join(projectDir, 'config', 'wix.env');

let raw = ''; try { raw = await fs.readFile(configPath, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }

await fs.mkdir(path.dirname(configPath), { recursive: true });

await fs.writeFile(configPath, `${raw.replace(/\n?WIX_BLOG_FALLBACK_MEMBER_ID=.*(?:\n|$)/g, '\n').replace(/\s*$/, '\n')}WIX_BLOG_FALLBACK_MEMBER_ID=${member.id}\n`, 'utf8');

return { status: 'provisioned', memberId: member.id };

}

async function importData(projectDir) {

const planResult = await readJson(path.join(projectDir, 'quick-mode', 'plan.json'));

const manifest = await readJson(path.join(projectDir, 'data', 'source-extract', 'manifest.json'));

importProgress.assertQuickImportAdapter({ plan: planResult, manifest, current: { id: CONTRACT.id, version: CONTRACT.version, fingerprint: fingerprint(CONTRACT) } });

// Fail closed before any write: a stamped plan with a missing or unreconciled coverage file

// must not produce a completion summary.

await sourceCoverage.quickSummaryCoverage(projectDir);

const env = await loadWixEnv(projectDir);

if (!env.WIX_AUTH_TOKEN || !env.WIX_SITE_ID) throw new Error('WIX_AUTH_TOKEN and WIX_SITE_ID are required for quick import');

const writers = require(path.join(ADAPTER_DIR, '..', 'rp-target-wix', 'lib', 'wix-writers.js'));

const dryRun = writers.createDryRunConfig(env, process.argv.slice(2)).dryRun;

const quickRun = capabilities.startQuickRun({ projectDir, adapterId: 'quick-woocommerce', siteId: env.WIX_SITE_ID, dryRun });

// The site's currency (and time zone) is checked before an entity that writes money or wall-clock

// records gets its write capability. A refused entity gets no client and writes nothing; whatever

// depends on it is skipped too, and every other entity still imports.

const regionalRefused = {};

const clientFor = async (id) => {

const entity = CONTRACT.entities.find((row) => row.id === id);

const upstream = entity.dependsOn.find((dependency) => regionalRefused[dependency]);

if (upstream) { regionalRefused[id] = 'DEPENDENCY_REFUSED'; return null; }

// Every other entity builds on the regional setup step: a held entity writes nothing (files only; no site read).

const dependency = siteRegional.regionalDependency({ projectDir, siteId: env.WIX_SITE_ID, entityRefs: [entity.target, ...(entity.auxiliaryTargets || [])] });

if (!dependency.ok) { regionalRefused[id] = dependency.code; return null; }

return writers.createWixClient({ capability: capabilities.bindQuickEntity(quickRun, id), ...wixCredentials(projectDir, env, dryRun) });

};

const sourceDir = path.join(projectDir, 'data', 'source-extract');

const crosswalk = await loadCrosswalk(projectDir);

// Durable pre-write evidence, before the first destination create. Some

// crosswalk checkpoints are deferred (blog tags, products), so the crosswalk cannot serve.

if (!dryRun) await importProgress.writeQuickImportStartedMarker(projectDir, planResult.adapter);

const seen = (entity, sourceId) => crosswalk[entity] && crosswalk[entity][String(sourceId)];

const remember = (entity, sourceId, targetId) => { if (!dryRun) { crosswalk[entity] ||= {}; crosswalk[entity][String(sourceId)] = targetId; } };

const checkpointCrosswalk = async () => { if (!dryRun) await writeJson(path.join(projectDir, 'state', 'crosswalk', 'quick-mode.json'), crosswalk); };

const summary = { schemaVersion: 1, generatedAt: new Date().toISOString(), managementImportMode: 'quick', adapter: planResult.adapter, dryRun, imported: {}, recovered: 0, recoveryCounts: {}, excluded: CONTRACT.excluded, regionalRefused };

const categoryIds = new Map(); const productTagIds = new Map(); const blogCategoryIds = new Map(); const blogTagIds = new Map();

// A source record whose slug matches an item that was on the store before this import is held,

// not adopted and not created; the completion report turns these into operator actions.

const holdCollision = (entity, sourceEntity, sourceId, target) => {

if (!dryRun) catalogBaseline.recordCollision(projectDir, { entity, sourceKey: String(sourceId), targetId: target.id, slug: target.slug ?? null });

summary.skipped ||= {}; summary.skipped[sourceEntity] ||= [];

summary.skipped[sourceEntity].push({ sourceId: String(sourceId), reason: catalogBaseline.collisionError(entity, target.id).message });

};

let wix = await clientFor('product_category');

if (wix) {

// Categories that were on the store before this import are never adopted by slug.

const baselineCategoryIds = catalogBaseline.protectedIds(projectDir).categories;

const destinationCategories = await writers.queryAllStoresCategories(wix);

const heldCategories = new Map(destinationCategories.filter((item) => baselineCategoryIds.has(item.id)).map((item) => [slug(item.slug), item]));

const existingCategories = new Map(destinationCategories.filter((item) => !baselineCategoryIds.has(item.id)).map((item) => [slug(item.slug), item]));

for (const row of await readLines(path.join(sourceDir, 'product_category.ndjson'))) {

if (seen('product_category', row.id) && baselineCategoryIds.has(seen('product_category', row.id))) { holdCollision('stores/category', 'product_category', row.id, { id: seen('product_category', row.id) }); continue; }

if (seen('product_category', row.id)) { categoryIds.set(String(row.id), seen('product_category', row.id)); continue; }

const sourceSlug = slug(row.slug); const existing = existingCategories.get(sourceSlug);

if (!existing && heldCategories.has(sourceSlug)) { holdCollision('stores/category', 'product_category', row.id, heldCategories.get(sourceSlug)); continue; }

const target = existing || await writers.createStoresCategory(wix, { name: text(row.name), slug: sourceSlug, description: nonEmpty(text(row.description).slice(0, 600)), treeReference: writers.STORES_TREE_REFERENCE }); categoryIds.set(String(row.id), target.id);

remember('product_category', row.id, target.id); if (!dryRun) catalogBaseline.clearCollision(projectDir, 'stores/category', row.id); await checkpointCrosswalk();

}

summary.imported.product_category = categoryIds.size;

capabilities.finishQuickEntity(quickRun, 'product_category');

}

wix = await clientFor('product_tag');

if (wix) {

const existingProductTags = new Map(((await wix.send(writers.buildListStoresProductTagsRequest())).tags || []).map((item) => [slug(item.name), item]));

for (const row of await readLines(path.join(sourceDir, 'product_tag.ndjson'))) {

if (seen('product_tag', row.id)) { productTagIds.set(String(row.id), seen('product_tag', row.id)); continue; }

const key = slug(row.name); const existing = existingProductTags.get(key);

const response = existing || (await wix.send(writers.buildCreateStoresProductTagRequest(text(row.name)))).tag;

productTagIds.set(String(row.id), response.id); remember('product_tag', row.id, response.id); await checkpointCrosswalk();

}

summary.imported.product_tag = productTagIds.size;

capabilities.finishQuickEntity(quickRun, 'product_tag');

}

wix = await clientFor('blog_category');

if (wix) {

const existingBlogCategories = new Map(((await wix.send(writers.buildQueryBlogCategoriesRequest())).categories || []).map((item) => [slug(item.slug), item]));

for (const row of await readLines(path.join(sourceDir, 'blog_category.ndjson'))) { if (seen('blog_category', row.id)) { blogCategoryIds.set(String(row.id), seen('blog_category', row.id)); continue; } const existing = existingBlogCategories.get(slug(row.slug)); const created = existing || await writers.createBlogCategory(wix, { label: text(row.name), slug: slug(row.slug), description: nonEmpty(text(row.description)) }); blogCategoryIds.set(String(row.id), created.id); remember('blog_category', row.id, created.id); await checkpointCrosswalk(); }

summary.imported.blog_category = blogCategoryIds.size;

capabilities.finishQuickEntity(quickRun, 'blog_category');

}

wix = await clientFor('blog_tag');

if (wix) {

for (const row of await readLines(path.join(sourceDir, 'blog_tag.ndjson'))) { if (seen('blog_tag', row.id)) { blogTagIds.set(String(row.id), seen('blog_tag', row.id)); continue; } const created = await writers.createBlogTag(wix, { label: text(row.name) }); blogTagIds.set(String(row.id), created.id); remember('blog_tag', row.id, created.id); }

summary.imported.blog_tag = blogTagIds.size;

capabilities.finishQuickEntity(quickRun, 'blog_tag');

}

wix = await clientFor('post');

if (wix) {

const fallbackMemberId = env.WIX_BLOG_FALLBACK_MEMBER_ID;

if (!fallbackMemberId) throw new Error('setup must provision WIX_BLOG_FALLBACK_MEMBER_ID before importing blog posts');

let posts = 0;

for (const row of await readLines(path.join(sourceDir, 'post.ndjson'))) {

if (seen('post', row.id)) { posts += 1; continue; }

await appendAudit(projectDir, { phase: 'post', sourceId: String(row.id), state: 'creating_draft' }, dryRun);

const draft = await writers.createDraftPost(wix, { title: text(row.title?.rendered), memberId: fallbackMemberId, richContent: await writers.convertHtmlToRichContent(wix, row.content?.rendered || '<p></p>'), excerpt: text(row.excerpt?.rendered), slug: slug(row.slug), categoryIds: (row.categories || []).map((id) => blogCategoryIds.get(String(id))).filter(Boolean), tagIds: (row.tags || []).map((id) => blogTagIds.get(String(id))).filter(Boolean), firstPublishedDate: Number.isNaN(new Date(row.date).valueOf()) ? undefined : new Date(row.date).toISOString() });

await appendAudit(projectDir, { phase: 'post', sourceId: String(row.id), state: 'publishing_draft', targetId: draft.id }, dryRun);

if (!dryRun) await writers.publishDraftPost(wix, draft.id); remember('post', row.id, draft.id); posts += 1;

await checkpointCrosswalk(); await appendAudit(projectDir, { phase: 'post', sourceId: String(row.id), state: 'completed', targetId: draft.id }, dryRun);

}

summary.imported.post = posts;

capabilities.finishQuickEntity(quickRun, 'post');

}

wix = await clientFor('product');

if (wix) {

let products = 0;

// A process can stop after a product create succeeds but before the crosswalk is

// checkpointed. Build a complete destination slug index up front so a resumed run

// recovers that write instead of treating the source record as a new product.

const baselineProductIds = catalogBaseline.protectedIds(projectDir).products;

const destinationProducts = await writers.queryAllStoresProducts(wix);

const heldProducts = new Map(destinationProducts.filter((item) => baselineProductIds.has(item.id)).map((item) => [slug(item.slug), item]));

const existingProducts = new Map(destinationProducts.filter((item) => !baselineProductIds.has(item.id)).map((item) => [slug(item.slug), item]));

const productRows = await readLines(path.join(sourceDir, 'product.ndjson'));

const productSlugCounts = new Map();

for (const row of productRows) {

const key = slug(row.slug);

productSlugCounts.set(key, (productSlugCounts.get(key) || 0) + 1);

}

for (const row of productRows) {

// A saved target id is checked too: an earlier run may have adopted a baseline product.

if (seen('product', row.id) && baselineProductIds.has(seen('product', row.id))) { holdCollision('stores/product', 'product', row.id, destinationProducts.find((item) => item.id === seen('product', row.id)) || { id: seen('product', row.id) }); continue; }

if (seen('product', row.id)) { products += 1; continue; }

const baseSlug = slug(row.slug);

const sourceSlug = productSlugCounts.get(baseSlug) > 1 ? `${baseSlug}-${row.id}` : baseSlug;

const heldProduct = !existingProducts.has(sourceSlug) && heldProducts.get(sourceSlug);

if (heldProduct) { holdCollision('stores/product', 'product', row.id, heldProduct); continue; }

const actualPrice = price(row.prices?.price, row.prices?.currency_minor_unit); const regular = price(row.prices?.regular_price, row.prices?.currency_minor_unit);

const normalized = recovery.normalizeProduct({ sourceId: row.id, sku: nonEmpty(row.sku) || '', tagIds: (row.tags || []).map((tag) => productTagIds.get(String(tag.id))).filter(Boolean) });

const created = existingProducts.get(sourceSlug) || (productSlugCounts.get(baseSlug) > 1 && existingProducts.get(baseSlug)) || await writers.createStoresProduct(wix, { name: text(row.name), slug: sourceSlug, description: composeProductDescription({ description: row.description, shortDescription: row.short_description }), productType: 'PHYSICAL', visible: true, tags: { publicTags: { tagIds: normalized.tagIds } }, media: { itemsInfo: { items: resolveImageUrls(row.images).map(({ url, altText, displayName }) => ({ url, ...(altText ? { altText } : {}), ...(displayName ? { displayName } : {}) })) } }, variantsInfo: { variants: [{ visible: true, sku: normalized.sku || undefined, inStock: row.is_in_stock !== false, price: { actualPrice: { amount: actualPrice }, ...(Number(regular) > Number(actualPrice) ? { compareAtPrice: { amount: regular } } : {}) } }] } });

if (normalized.recoveries.length) { if (!dryRun) await recovery.appendRecoveries(projectDir, planResult.adapter, row.id, normalized.recoveries); recovery.recordRecoveredRecord(summary, normalized.recoveries); }

const targets = (row.categories || []).map((category) => categoryIds.get(String(category.id))).filter(Boolean); if (targets.length) await writers.bulkAddItemToCategories(wix, { productId: created.id, categoryIds: targets }); remember('product', row.id, created.id); if (!dryRun) catalogBaseline.clearCollision(projectDir, 'stores/product', row.id); products += 1;

}

summary.imported.product = products;

capabilities.finishQuickEntity(quickRun, 'product');

}

if (!dryRun) await writeJson(path.join(projectDir, 'state', 'crosswalk', 'quick-mode.json'), crosswalk);

// A refusal means the run did not import everything: it is never reported completed (as in Shopify's quick mode).

if (!dryRun && Object.keys(regionalRefused).length) summary.status = 'partial';

Object.assign(summary, await sourceCoverage.quickSummaryCoverage(projectDir));

catalogBaseline.quickReport(projectDir, summary);

await recovery.writeFinalReport(projectDir, summary, { dryRun });

await writeJson(path.join(projectDir, 'execution', dryRun ? 'dry-run-completion-report.json' : 'completion-report.json'), summary);

return summary;

}

async function main() {

const [command, projectDirArg] = process.argv.slice(2);

if (!command || !projectDirArg || !['preflight', 'plan', 'setup-author', 'extract', 'import'].includes(command)) throw new Error('Usage: quick-mode.js <preflight|plan|setup-author|extract|import> <projectDir>');

const result = await ({ preflight, plan, 'setup-author': ensureFallbackAuthor, extract, import: importData })[command](path.resolve(projectDirArg));

process.stdout.write(`${JSON.stringify({ ok: true, command, status: result.status || 'completed' })}\n`);

}

main().catch(async (error) => { process.stderr.write(`${error.message}\n`); process.exit(await wixAuth.stopExitCode(error, process.argv[3] && path.resolve(process.argv[3]))); });