@artinstack/migrator 0.1.2 → 0.1.4

package/README.md

@@ -11,6 +11,7 @@ See [docs/architecture.md](./docs/architecture.md) for the high-level blueprint:
 ```
 src/
   parsers/          WordPress, SmugMug, Squarespace, Wix → normalizer DTOs
+    wordpress/      WXR parse, builder flattening (theme registry)
   normalizer/       Canonical DTOs + portable idempotency types
   sinks/            filesystem export, MigrationSink interface
   cli/              artinstack-migrate
@@ -56,6 +57,8 @@ artinstack-migrate validate <platform> <export-file>
 | `--dry-run` | Parse and analyze only; no export files |
 | `--report <dir>` | With `--dry-run`, write `conflicts.json` and `migration-report.json` |
 | `--offline` | Skip network HEAD requests for asset size estimates |
+| `--rewrite-gateway <url>` | WordPress: legacy API-gateway base (use with `--rewrite-public`) |
+| `--rewrite-public <url>` | WordPress: public origin for `/wp-content/` asset paths |
 | `--sink filesystem` | Run through `MigrationSink` before writing (requires `--out`) |
 | `--urls <file>` | Wix only: URL list or `sitemap.xml` for static page snapshots |
 
@@ -68,6 +71,12 @@ artinstack-migrate wordpress export.xml --out ./output
 # Preview conflicts without writing content
 artinstack-migrate wordpress export.xml --dry-run --report ./preview/
 
+# WordPress: rewrite legacy gateway URLs before dry-run / export (e.g. API Gateway → public CDN)
+artinstack-migrate wordpress export.xml \
+  --rewrite-gateway "https://gateway.example/prod" \
+  --rewrite-public "https://www.example.com" \
+  --dry-run --report ./preview/
+
 # Validate export structure (JSON result on stdout, exit 0/1)
 artinstack-migrate validate wordpress export.xml
 
@@ -119,8 +128,10 @@ pnpm dev          # watch build
 | Piece | `@artinstack/migrator` | Host application |
 |-------|------------------------|------------------|
 | Parsers + normalizer DTOs | Yes | No |
+| WordPress builder flattening + origin URL rewrite (pre-DTO) | Yes | Optional same config on adapter input |
 | CLI + filesystem JSON export | Yes | No |
 | `MigrationSink` interface | Yes | Implementation |
+| Dynamic shortcodes (`[portfolio]`, `[recent_posts]`), forms, sanitize | No | Yes |
 | Jobs, worker, credentials, UI | No | Yes |
 
 ## License

package/dist/{chunk-VXEHAQKK.js → chunk-Q6M5JEL3.js}

@@ -1,20 +1,226 @@
 import {
   SquarespaceCollectionClient,
+  WORDPRESS_BUILDER_REGISTRY,
   enumerateSquarespaceEntities,
   linkToPath,
   sanitizeSlug,
   summarizeSquarespaceExport,
   validateSquarespaceExportFile
-} from "./chunk-HH7666MQ.js";
+} from "./chunk-XKWWXKP3.js";
 import {
-  discoverContentAssetUrls
+  discoverContentAssetUrls,
+  normalizeAssetUrl
 } from "./chunk-2PNSVE5Y.js";
 
+// src/lib/origin-url-rewrite.ts
+function rewriteOriginUrlsInText(text, config) {
+  if (!text || config.rules.length === 0) return text;
+  let result = text;
+  for (const rule of config.rules) {
+    if (typeof rule.match === "string") {
+      if (!rule.match) continue;
+      result = result.split(rule.match).join(rule.replace);
+      continue;
+    }
+    result = result.replace(rule.match, rule.replace);
+  }
+  return result;
+}
+function createWpContentGatewayRewrite(gatewayBase, publicOrigin) {
+  const normalizedGateway = gatewayBase.replace(/\/$/, "");
+  const normalizedPublic = publicOrigin.replace(/\/$/, "");
+  return {
+    rules: [
+      {
+        match: `${normalizedGateway}/wp-content/`,
+        replace: `${normalizedPublic}/wp-content/`
+      }
+    ]
+  };
+}
+
 // src/parsers/wordpress/parse-wxr.ts
 import { readFile } from "fs/promises";
 import { basename } from "path";
 import { XMLParser } from "fast-xml-parser";
+
+// src/parsers/wordpress/builders/flatten.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractQuotedParam(params, name) {
+  const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*`, "i");
+  const match = pattern.exec(params);
+  if (!match) return void 0;
+  let index = match.index + match[0].length;
+  while (index < params.length && /\s/.test(params[index])) index += 1;
+  const quote = params[index];
+  if (quote !== '"' && quote !== "'") return void 0;
+  index += 1;
+  let value = "";
+  while (index < params.length) {
+    const char = params[index];
+    if (char === "\\" && index + 1 < params.length) {
+      value += params[index + 1];
+      index += 2;
+      continue;
+    }
+    if (char === quote) break;
+    value += char;
+    index += 1;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function extractShortcodeParam(params, names) {
+  for (const name of names) {
+    const value = extractQuotedParam(params, name);
+    if (value) return value;
+  }
+  return void 0;
+}
+function escapeHtmlText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function textToHtml(text, tag) {
+  const paragraphs = text.split(/\n{2,}/).map((part) => part.trim()).filter(Boolean);
+  if (paragraphs.length === 0) return "";
+  return paragraphs.map((paragraph) => {
+    const inner = escapeHtmlText(paragraph).replace(/\n/g, "<br />");
+    return `<${tag}>${inner}</${tag}>`;
+  }).join("\n");
+}
+function emitHtmlTag(tag, url) {
+  const normalized = normalizeAssetUrl(url) ?? url;
+  const escaped = normalized.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  switch (tag) {
+    case "img":
+      return `<img src="${escaped}" alt="" />`;
+    case "video":
+      return `<video src="${escaped}" controls></video>`;
+    case "iframe":
+      return `<iframe src="${escaped}" loading="lazy"></iframe>`;
+  }
+}
+function convertUrlRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, (block, params) => {
+    const url = extractShortcodeParam(params, rule.urlParams);
+    if (!url) return block;
+    return emitHtmlTag(rule.tag, url);
+  });
+}
+function convertTextRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gis"
+  );
+  return content.replace(pattern, (block, params) => {
+    const parts = [];
+    for (const field of rule.fields) {
+      const text = extractQuotedParam(params, field.param);
+      if (!text) continue;
+      const html = textToHtml(text, field.tag);
+      if (html) parts.push(html);
+    }
+    return parts.length > 0 ? parts.join("\n") : block;
+  });
+}
+function convertWrapperRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]([\\s\\S]*?)\\[\\/${prefix}\\b[^\\]]*\\]`,
+    "gi"
+  );
+  return content.replace(pattern, (_, params, inner) => {
+    const parts = [];
+    if (rule.urlParams?.length) {
+      const url = extractShortcodeParam(params, rule.urlParams);
+      if (url) parts.push(emitHtmlTag("img", url));
+    }
+    parts.push(inner.trim());
+    return parts.filter(Boolean).join("\n");
+  });
+}
+function convertPlaceholderRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, rule.html);
+}
+function stripScaffoldingPrefix(content, prefix) {
+  const escaped = escapeRegExp(prefix);
+  const opener = new RegExp(`\\[${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  const closer = new RegExp(`\\[\\/${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  return content.replace(opener, "").replace(closer, "");
+}
+function stripLegacyTokens(content, tokens) {
+  let result = content;
+  for (const token of tokens) {
+    const escaped = escapeRegExp(token);
+    const opener = new RegExp(`\\[${escaped}\\b[^\\]]*\\]`, "gi");
+    const closer = new RegExp(`\\[\\/${escaped}\\b[^\\]]*\\]`, "gi");
+    result = result.replace(opener, "").replace(closer, "");
+  }
+  return result;
+}
+function detectThemes(content, registry) {
+  return registry.filter((theme) => theme.detect.test(content));
+}
+function flattenWordPressBuilders(content, options = {}) {
+  if (!content.trim()) {
+    return { html: content, detectedThemes: [] };
+  }
+  const registry = options.registry ?? WORDPRESS_BUILDER_REGISTRY;
+  const themes = detectThemes(content, registry);
+  if (themes.length === 0) {
+    return { html: content, detectedThemes: [] };
+  }
+  let html = content;
+  for (const theme of themes) {
+    for (const rule of theme.wrapperRules ?? []) {
+      html = convertWrapperRule(html, rule);
+    }
+    for (const rule of theme.textRules ?? []) {
+      html = convertTextRule(html, rule);
+    }
+    for (const rule of theme.urlRules ?? []) {
+      html = convertUrlRule(html, rule);
+    }
+    for (const rule of theme.placeholderRules ?? []) {
+      html = convertPlaceholderRule(html, rule);
+    }
+    for (const prefix of theme.scaffoldingPrefixes ?? []) {
+      html = stripScaffoldingPrefix(html, prefix);
+    }
+    if (theme.legacyScaffoldingTokens?.length) {
+      html = stripLegacyTokens(html, theme.legacyScaffoldingTokens);
+    }
+  }
+  html = html.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    html,
+    detectedThemes: themes.map((theme) => theme.id)
+  };
+}
+
+// src/parsers/wordpress/parse-wxr.ts
 var PLATFORM = "wordpress";
+var WOOCOMMERCE_STUB_PAGE_SLUGS = /* @__PURE__ */ new Set(["cart", "checkout", "my-account"]);
+var WOOCOMMERCE_STUB_SHORTCODE = /^\[woocommerce_(?:cart|checkout|my_account)\]\s*$/i;
+function isWooCommerceStubPage(slug, contentHtml) {
+  if (WOOCOMMERCE_STUB_PAGE_SLUGS.has(slug)) return true;
+  const trimmed = contentHtml.trim();
+  if (!trimmed) return false;
+  return WOOCOMMERCE_STUB_SHORTCODE.test(trimmed);
+}
 function asArray(value) {
   if (value === void 0) return [];
   return Array.isArray(value) ? value : [value];
@@ -80,13 +286,16 @@ function parseItems(xml) {
   const doc = parser.parse(xml);
   return asArray(doc.rss?.channel?.item);
 }
-function buildAttachmentIndex(items) {
+function buildAttachmentIndex(items, originUrlRewrite) {
   const index = /* @__PURE__ */ new Map();
   for (const item of items) {
     if (textValue(item.post_type) !== "attachment") continue;
     const id = textValue(item.post_id);
-    const url = textValue(item.attachment_url) || textValue(item.link);
+    let url = textValue(item.attachment_url) || textValue(item.link);
     if (!id || !url) continue;
+    if (originUrlRewrite) {
+      url = rewriteOriginUrlsInText(url, originUrlRewrite);
+    }
     const filename = basename(new URL(url, "http://local.invalid").pathname) || `attachment-${id}`;
     index.set(id, {
       sourceUrl: url,
@@ -171,10 +380,32 @@ function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt) {
   }
   return assets;
 }
+function preprocessContent(rawHtml, options) {
+  let html = rawHtml;
+  if (options.originUrlRewrite) {
+    html = rewriteOriginUrlsInText(html, options.originUrlRewrite);
+  }
+  if (options.flattenBuilders !== false) {
+    html = flattenWordPressBuilders(html).html;
+  }
+  return html;
+}
+function resolveFeaturedAssetSourceId(thumbnailId, attachmentIndex, contentHtml) {
+  if (thumbnailId && attachmentIndex.has(thumbnailId)) {
+    return thumbnailId;
+  }
+  const firstInline = discoverContentAssetUrls(contentHtml)[0];
+  return firstInline ? `url:${firstInline}` : void 0;
+}
+function maybeRewriteUrl(url, config) {
+  if (!url) return void 0;
+  if (!config) return url;
+  return rewriteOriginUrlsInText(url, config);
+}
 async function* enumerateWxrEntities(options) {
   const xml = await readFile(options.filePath, "utf8");
   const items = parseItems(xml);
-  const attachmentIndex = buildAttachmentIndex(items);
+  const attachmentIndex = buildAttachmentIndex(items, options.originUrlRewrite);
   const { categories, tags } = collectTaxonomies(items);
   const seenAssetUrls = /* @__PURE__ */ new Set();
   const emittedAttachmentIds = /* @__PURE__ */ new Set();
@@ -201,11 +432,14 @@ async function* enumerateWxrEntities(options) {
     const postType = textValue(item.post_type);
     if (postType !== "post" && postType !== "page") continue;
     const id = textValue(item.post_id);
-    const link = textValue(item.link);
+    const link = maybeRewriteUrl(textValue(item.link), options.originUrlRewrite);
     const slug = sanitizeSlug(textValue(item.post_name) || textValue(item.title) || id);
-    const rawHtml = getContentEncoded(item);
+    const contentHtml = preprocessContent(getContentEncoded(item), options);
+    if (postType === "page" && options.skipWooCommerceStubPages !== false && isWooCommerceStubPage(slug, contentHtml)) {
+      continue;
+    }
     for (const asset of collectInlineAssets(
-      rawHtml,
+      contentHtml,
       attachmentIndex,
       seenAssetUrls,
       options.exportedAt
@@ -223,10 +457,11 @@ async function* enumerateWxrEntities(options) {
     }
     if (postType === "post") {
       const thumbnailId = getPostMeta(item, "_thumbnail_id");
-      let featuredAssetSourceId;
-      if (thumbnailId && attachmentIndex.has(thumbnailId)) {
-        featuredAssetSourceId = thumbnailId;
-      }
+      const featuredAssetSourceId = resolveFeaturedAssetSourceId(
+        thumbnailId,
+        attachmentIndex,
+        contentHtml
+      );
       const post = {
         type: "post",
         source: sourceMeta(id, link, options.exportedAt),
@@ -234,7 +469,7 @@ async function* enumerateWxrEntities(options) {
         title: textValue(item.title) || slug,
         slug,
         excerpt: getExcerpt(item) || void 0,
-        contentHtml: rawHtml,
+        contentHtml,
         publishedAt: textValue(item.post_date) || void 0,
         status: mapPublishStatus(textValue(item.status)),
         categorySlugs: categorySlugs.length ? categorySlugs : void 0,
@@ -251,7 +486,7 @@ async function* enumerateWxrEntities(options) {
         sourceId: id,
         title: textValue(item.title) || slug,
         slug,
-        contentHtml: rawHtml,
+        contentHtml,
         isHomePage: isHomePage || void 0,
         status: mapPublishStatus(textValue(item.status))
       };
@@ -291,18 +526,28 @@ async function validateWxrFile(filePath) {
 }
 
 // src/parsers/wordpress/index.ts
-function resolvePath(input) {
-  if (typeof input === "string") return input;
+function resolveWxrOptions(input) {
+  if (typeof input === "string") {
+    return { filePath: input };
+  }
   if (input && typeof input === "object" && "path" in input) {
-    return String(input.path);
+    const obj = input;
+    return {
+      filePath: String(obj.path),
+      originUrlRewrite: obj.originUrlRewrite,
+      flattenBuilders: obj.flattenBuilders,
+      skipWooCommerceStubPages: obj.skipWooCommerceStubPages
+    };
   }
-  throw new Error("WordPress adapter requires input path (string or { path })");
+  throw new Error(
+    "WordPress adapter requires input path (string or { path, originUrlRewrite?, flattenBuilders?, skipWooCommerceStubPages? })"
+  );
 }
 var wordpressAdapter = {
   platform: "wordpress",
   async validateInput(input) {
-    const path = resolvePath(input);
-    const result = await validateWxrFile(path);
+    const { filePath } = resolveWxrOptions(input);
+    const result = await validateWxrFile(filePath);
     return {
       ok: result.ok,
       issues: result.issues,
@@ -310,8 +555,7 @@ var wordpressAdapter = {
     };
   },
   enumerateEntities(ctx) {
-    const path = resolvePath(ctx.input);
-    return enumerateWxrEntities({ filePath: path });
+    return enumerateWxrEntities(resolveWxrOptions(ctx.input));
   }
 };
 
@@ -2272,6 +2516,8 @@ function getAdapter(platform) {
 }
 
 export {
+  rewriteOriginUrlsInText,
+  createWpContentGatewayRewrite,
   wordpressAdapter,
   SMUGMUG_API_BASE,
   SMUGMUG_OAUTH_ENDPOINTS,
@@ -2287,4 +2533,4 @@ export {
   wixAdapter,
   getAdapter
 };
-//# sourceMappingURL=chunk-VXEHAQKK.js.map
+//# sourceMappingURL=chunk-Q6M5JEL3.js.map