woo2emdash 0.1.0

package/dist/import/terms.js

@@ -0,0 +1,191 @@
+import { log } from "../log.js";
+import { attributeTaxonomyName } from "../schema/catalog.js";
+/**
+ * Creates EmDash terms on demand, only for terms that imported products
+ * reference (plus their ancestors), and remembers the mapping so entries can
+ * be assigned by slug.
+ *
+ * Why on demand: multilingual WooCommerce stores hold one copy of every term
+ * per language, all sharing a slug. Importing one language must not drag the
+ * other languages' terms along. A term is matched to an existing EmDash term
+ * by slug, so re-runs reuse what is there.
+ */
+export class TermSync {
+    woo;
+    emdash;
+    dryRun;
+    locale;
+    /** taxonomy -> all WooCommerce terms by id (read once per taxonomy) */
+    wooTerms = new Map();
+    /** taxonomy -> all WooCommerce terms by lowercased name (attributes are referenced by name) */
+    wooByName = new Map();
+    /** taxonomy -> EmDash terms by slug */
+    emdashTerms = new Map();
+    /** taxonomy -> woo term id -> EmDash term */
+    resolved = new Map();
+    /** taxonomy -> slug -> woo term id that claimed it in this run */
+    slugOwner = new Map();
+    /** taxonomy -> woo term id -> in-flight resolution, so concurrent callers share one create */
+    inflight = new Map();
+    /** woo attribute taxonomy slug (pa_color) -> EmDash taxonomy name (pa_color) */
+    attributeTaxonomies = new Map();
+    created = 0;
+    constructor(woo, emdash, dryRun, locale) {
+        this.woo = woo;
+        this.emdash = emdash;
+        this.dryRun = dryRun;
+        this.locale = locale;
+    }
+    /** Reads the store's term lists once. Nothing is written here. */
+    async load() {
+        await this.loadTaxonomy("product_category", "products/categories");
+        await this.loadTaxonomy("product_tag", "products/tags");
+        const brands = await this.woo.optional("products/brands", { per_page: 1 });
+        if (brands !== null)
+            await this.loadTaxonomy("product_brand", "products/brands");
+        else
+            log.warn("No products/brands endpoint on this store, product_brand stays empty.");
+        for await (const attr of this.woo.all("products/attributes")) {
+            const name = attributeTaxonomyName(attr.slug);
+            this.attributeTaxonomies.set(attr.slug, name);
+            await this.loadTaxonomy(name, `products/attributes/${attr.id}/terms`);
+        }
+    }
+    attributeTaxonomy = (wooSlug) => this.attributeTaxonomies.get(wooSlug) ?? null;
+    /** EmDash slug for a WooCommerce term id, creating the term (and its ancestors) when needed. */
+    async ensureById(taxonomy, wooId) {
+        const term = this.wooTerms.get(taxonomy)?.get(wooId);
+        if (!term)
+            return undefined;
+        return (await this.ensure(taxonomy, term))?.slug;
+    }
+    /** Same, for attribute options, which WooCommerce reports by name. */
+    async ensureByName(taxonomy, name) {
+        const term = this.wooByName.get(taxonomy)?.get(name.trim().toLowerCase());
+        if (!term)
+            return undefined;
+        return (await this.ensure(taxonomy, term))?.slug;
+    }
+    async loadTaxonomy(taxonomy, wooPath) {
+        const byId = new Map();
+        const byName = new Map();
+        for await (const t of this.woo.all(wooPath)) {
+            byId.set(t.id, t);
+            if (!byName.has(t.name.trim().toLowerCase()))
+                byName.set(t.name.trim().toLowerCase(), t);
+        }
+        this.wooTerms.set(taxonomy, byId);
+        this.wooByName.set(taxonomy, byName);
+        const existing = new Map();
+        for (const t of await this.emdash.terms(taxonomy, this.locale))
+            existing.set(t.slug, { slug: t.slug, id: t.id });
+        this.emdashTerms.set(taxonomy, existing);
+        this.resolved.set(taxonomy, new Map());
+        this.slugOwner.set(taxonomy, new Map());
+        this.inflight.set(taxonomy, new Map());
+        log.info(`${taxonomy}: ${byId.size} terms in WooCommerce, ${existing.size} already in EmDash`);
+    }
+    /**
+     * Callers run concurrently (a product's categories are resolved with
+     * Promise.all), so one term must never be created twice: the first call
+     * for a term id does the work and later ones await the same promise.
+     */
+    ensure(taxonomy, term) {
+        const done = this.resolved.get(taxonomy)?.get(term.id);
+        if (done)
+            return Promise.resolve(done);
+        const flights = this.inflight.get(taxonomy);
+        let p = flights.get(term.id);
+        if (!p) {
+            p = this.ensureNow(taxonomy, term).finally(() => flights.delete(term.id));
+            flights.set(term.id, p);
+        }
+        return p;
+    }
+    async ensureNow(taxonomy, term) {
+        let parent;
+        if (term.parent) {
+            const parentTerm = this.wooTerms.get(taxonomy)?.get(term.parent);
+            if (parentTerm)
+                parent = await this.ensure(taxonomy, parentTerm);
+        }
+        const existing = this.emdashTerms.get(taxonomy);
+        const owners = this.slugOwner.get(taxonomy);
+        // Two WooCommerce terms can share a slug (one per language). The first one
+        // in this run keeps the plain slug, later ones get their WooCommerce id appended.
+        let slug = termSlug(term);
+        const owner = owners.get(slug);
+        if (owner !== undefined && owner !== term.id)
+            slug = `${slug}-${term.id}`;
+        let ref = existing.get(slug);
+        if (!ref) {
+            ref = await this.create(taxonomy, slug, term, parent);
+            if (!ref) {
+                // Conflict: someone else holds that slug in EmDash. Re-read the list
+                // (another process may have created it) before falling back to a suffix.
+                await this.reload(taxonomy);
+                ref = existing.get(slug);
+            }
+            if (!ref) {
+                slug = `${termSlug(term)}-${term.id}`;
+                ref = existing.get(slug) ?? (await this.create(taxonomy, slug, term, parent));
+                if (!ref) {
+                    await this.reload(taxonomy);
+                    ref = existing.get(slug);
+                }
+            }
+            if (!ref)
+                throw new Error(`${taxonomy}: could not create term ${term.slug} (${term.id})`);
+            existing.set(slug, ref);
+            this.created += 1;
+        }
+        owners.set(slug, term.id);
+        this.resolved.get(taxonomy).set(term.id, ref);
+        return ref;
+    }
+    async reload(taxonomy) {
+        const existing = this.emdashTerms.get(taxonomy);
+        for (const t of await this.emdash.terms(taxonomy, this.locale)) {
+            if (!existing.has(t.slug))
+                existing.set(t.slug, { slug: t.slug, id: t.id });
+        }
+    }
+    /** Returns undefined when EmDash reports the slug as already taken (409). */
+    async create(taxonomy, slug, term, parent) {
+        if (this.dryRun)
+            return { slug, id: `dry-run:${slug}` };
+        const body = { slug, label: term.name };
+        if (this.locale)
+            body.locale = this.locale;
+        if (parent)
+            body.parentId = parent.id;
+        if (term.description)
+            body.description = term.description;
+        try {
+            const made = await this.emdash.createTerm(taxonomy, body);
+            return { slug: made.slug, id: made.id };
+        }
+        catch (e) {
+            if (e instanceof Error && /\b409\b|CONFLICT/.test(e.message))
+                return undefined;
+            throw e;
+        }
+    }
+}
+/** WooCommerce percent-encodes non-Latin slugs; EmDash wants a plain slug. */
+function termSlug(term) {
+    let s = term.slug;
+    try {
+        s = decodeURIComponent(s);
+    }
+    catch {
+        /* keep as is */
+    }
+    s = s
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return s || `term-${term.id}`;
+}

package/dist/log.js

@@ -0,0 +1,10 @@
+const useColor = process.stderr.isTTY && !process.env.NO_COLOR;
+const ESC = String.fromCharCode(27);
+const paint = (code, s) => (useColor ? `${ESC}[${code}m${s}${ESC}[0m` : s);
+export const log = {
+    info: (msg) => console.error(paint("36", "i ") + msg),
+    ok: (msg) => console.error(paint("32", "+ ") + msg),
+    warn: (msg) => console.error(paint("33", "! ") + msg),
+    error: (msg) => console.error(paint("31", "x ") + msg),
+    step: (msg) => console.error(paint("1", msg)),
+};

package/dist/schema/catalog.js

@@ -0,0 +1,136 @@
+/**
+ * Target EmDash schema for a WooCommerce catalog. This is the contract other
+ * tools (storefront themes, commerce plugins, exporters) can rely on; the
+ * human-readable version lives in docs/target-schema.md and must stay in sync.
+ *
+ * Slug rules come from EmDash: /^[a-z][a-z0-9_]*$/, max 63 chars, and a reserved
+ * list (id, slug, status, created_at, terms, bylines, ...). Nothing here uses them.
+ */
+export const PRODUCTS = "products";
+export const VARIATIONS = "product_variations";
+const STOCK_STATUS = ["instock", "outofstock", "onbackorder"];
+const BACKORDERS = ["no", "notify", "yes"];
+const TAX_STATUS = ["taxable", "shipping", "none"];
+/** Fields shared by products and variations, in this order. */
+function commerceFields() {
+    return [
+        { slug: "sku", label: "SKU", type: "string", indexed: true, source: "sku" },
+        { slug: "gtin", label: "GTIN / UPC / EAN / ISBN", type: "string", source: "global_unique_id" },
+        { slug: "featured_image", label: "Featured image", type: "image", source: "images[0] (product) or image (variation), uploaded to EmDash media" },
+        { slug: "regular_price", label: "Regular price", type: "number", source: "regular_price, decimal in the store currency" },
+        { slug: "sale_price", label: "Sale price", type: "number", source: "sale_price, empty when not on sale" },
+        { slug: "price", label: "Current price", type: "number", indexed: true, source: "price, the effective price WooCommerce computed" },
+        { slug: "currency", label: "Currency", type: "string", source: "store setting woocommerce_currency (settings/general), ISO 4217" },
+        { slug: "sale_from", label: "Sale starts", type: "datetime", source: "date_on_sale_from_gmt" },
+        { slug: "sale_to", label: "Sale ends", type: "datetime", source: "date_on_sale_to_gmt" },
+        { slug: "stock_status", label: "Stock status", type: "select", validation: { options: STOCK_STATUS }, defaultValue: "instock", source: "stock_status" },
+        { slug: "manage_stock", label: "Manage stock", type: "boolean", defaultValue: false, source: "manage_stock" },
+        { slug: "stock_quantity", label: "Stock quantity", type: "integer", source: "stock_quantity" },
+        { slug: "backorders", label: "Backorders", type: "select", validation: { options: BACKORDERS }, defaultValue: "no", source: "backorders" },
+        { slug: "low_stock_amount", label: "Low stock threshold", type: "integer", source: "low_stock_amount" },
+        { slug: "weight", label: "Weight", type: "number", source: "weight" },
+        { slug: "length", label: "Length", type: "number", source: "dimensions.length" },
+        { slug: "width", label: "Width", type: "number", source: "dimensions.width" },
+        { slug: "height", label: "Height", type: "number", source: "dimensions.height" },
+        { slug: "weight_unit", label: "Weight unit", type: "string", source: "store setting woocommerce_weight_unit (settings/products)" },
+        { slug: "dimension_unit", label: "Dimension unit", type: "string", source: "store setting woocommerce_dimension_unit (settings/products)" },
+        { slug: "shipping_class", label: "Shipping class", type: "string", source: "shipping_class (slug)" },
+        { slug: "tax_status", label: "Tax status", type: "select", validation: { options: TAX_STATUS }, defaultValue: "taxable", source: "tax_status" },
+        { slug: "tax_class", label: "Tax class", type: "string", source: "tax_class" },
+        { slug: "virtual", label: "Virtual", type: "boolean", defaultValue: false, source: "virtual" },
+        { slug: "downloadable", label: "Downloadable", type: "boolean", defaultValue: false, source: "downloadable" },
+        { slug: "downloads", label: "Downloadable files", type: "json", source: "downloads, array of { id, name, file }" },
+        { slug: "download_limit", label: "Download limit", type: "integer", source: "download_limit, -1 means unlimited" },
+        { slug: "download_expiry", label: "Download expiry (days)", type: "integer", source: "download_expiry, -1 means never" },
+    ];
+}
+function bookkeepingFields() {
+    return [
+        { slug: "woo_id", label: "WooCommerce ID", type: "integer", required: true, unique: true, indexed: true, source: "id, the key for idempotent re-runs" },
+        { slug: "woo_permalink", label: "WooCommerce URL", type: "url", source: "permalink, kept for redirects" },
+        { slug: "woo_modified", label: "Last modified in WooCommerce", type: "datetime", indexed: true, source: "date_modified_gmt, for incremental syncs" },
+    ];
+}
+export const productsCollection = {
+    slug: PRODUCTS,
+    label: "Products",
+    labelSingular: "Product",
+    description: "Catalog imported from WooCommerce. One entry per product; variations live in Product variations.",
+    icon: "package",
+    supports: ["drafts", "revisions", "search", "seo"],
+    routable: true,
+    hidden: false,
+    hasSeo: true,
+    fields: [
+        { slug: "title", label: "Name", type: "string", required: true, source: "name" },
+        { slug: "content", label: "Description", type: "portableText", source: "description, HTML converted to Portable Text" },
+        { slug: "excerpt", label: "Short description", type: "text", source: "short_description, HTML converted to plain text" },
+        { slug: "product_type", label: "Product type", type: "select", required: true, validation: { options: ["simple", "variable", "grouped", "external"] }, defaultValue: "simple", source: "type" },
+        ...commerceFields(),
+        { slug: "gallery", label: "Gallery", type: "repeater", validation: { subFields: [{ slug: "image", type: "image", label: "Image" }] }, source: "images[1..], each uploaded to EmDash media" },
+        { slug: "external_url", label: "External URL", type: "url", source: "external_url (external products)" },
+        { slug: "button_text", label: "Button text", type: "string", source: "button_text (external products)" },
+        { slug: "featured", label: "Featured", type: "boolean", defaultValue: false, indexed: true, source: "featured" },
+        { slug: "catalog_visibility", label: "Catalog visibility", type: "select", validation: { options: ["visible", "catalog", "search", "hidden"] }, defaultValue: "visible", source: "catalog_visibility" },
+        { slug: "menu_order", label: "Sort order", type: "integer", defaultValue: 0, indexed: true, source: "menu_order" },
+        { slug: "sold_individually", label: "Sold individually", type: "boolean", defaultValue: false, source: "sold_individually" },
+        { slug: "purchase_note", label: "Purchase note", type: "text", source: "purchase_note" },
+        { slug: "reviews_allowed", label: "Reviews allowed", type: "boolean", defaultValue: true, source: "reviews_allowed" },
+        { slug: "average_rating", label: "Average rating", type: "number", source: "average_rating" },
+        { slug: "rating_count", label: "Rating count", type: "integer", source: "rating_count" },
+        { slug: "attributes", label: "Attributes", type: "json", source: "attributes, array of { name, taxonomy, visible, variation, options[] }; taxonomy is the EmDash taxonomy name for global attributes, null for custom ones" },
+        { slug: "default_attributes", label: "Default variation attributes", type: "json", source: "default_attributes" },
+        { slug: "upsells", label: "Upsells", type: "reference", options: { collection: PRODUCTS, allowMultiple: true }, source: "upsell_ids, resolved to EmDash entry ids" },
+        { slug: "cross_sells", label: "Cross-sells", type: "reference", options: { collection: PRODUCTS, allowMultiple: true }, source: "cross_sell_ids" },
+        { slug: "grouped_products", label: "Grouped products", type: "reference", options: { collection: PRODUCTS, allowMultiple: true }, source: "grouped_products (grouped products)" },
+        ...bookkeepingFields(),
+    ],
+};
+export const variationsCollection = {
+    slug: VARIATIONS,
+    label: "Product variations",
+    labelSingular: "Product variation",
+    description: "One entry per WooCommerce variation, linked to its parent product.",
+    icon: "layers",
+    supports: ["drafts", "revisions"],
+    routable: false,
+    hidden: false,
+    hasSeo: false,
+    fields: [
+        { slug: "title", label: "Name", type: "string", required: true, source: "name, WooCommerce builds it from the parent name and the attribute values" },
+        { slug: "product", label: "Parent product", type: "reference", required: true, indexed: true, options: { collection: PRODUCTS }, source: "parent_id, resolved to the EmDash product entry" },
+        { slug: "content", label: "Description", type: "portableText", source: "description" },
+        ...commerceFields(),
+        { slug: "attributes", label: "Attribute values", type: "json", source: "attributes, array of { name, taxonomy, option }" },
+        { slug: "menu_order", label: "Sort order", type: "integer", defaultValue: 0, indexed: true, source: "menu_order" },
+        ...bookkeepingFields(),
+    ],
+};
+export const catalogCollections = [productsCollection, variationsCollection];
+export const catalogTaxonomies = [
+    { name: "product_category", label: "Product categories", labelSingular: "Product category", hierarchical: true, collections: [PRODUCTS], source: "product_cat" },
+    { name: "product_tag", label: "Product tags", labelSingular: "Product tag", hierarchical: false, collections: [PRODUCTS], source: "product_tag" },
+    { name: "product_brand", label: "Brands", labelSingular: "Brand", hierarchical: true, collections: [PRODUCTS], source: "product_brand (WooCommerce 9.6 and later)" },
+];
+/**
+ * EmDash taxonomy name for a WooCommerce global attribute taxonomy.
+ * WooCommerce allows hyphens (pa_plug-type); EmDash slugs do not.
+ */
+export function attributeTaxonomyName(wooTaxonomy) {
+    const name = wooTaxonomy
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, "_")
+        .replace(/^_+/, "")
+        .replace(/_+$/, "");
+    return name.startsWith("pa_") ? name : `pa_${name}`;
+}
+export function attributeTaxonomy(attr) {
+    return {
+        name: attributeTaxonomyName(attr.slug),
+        label: attr.name,
+        labelSingular: attr.name,
+        hierarchical: false,
+        collections: [PRODUCTS, VARIATIONS],
+        source: `global attribute ${attr.slug}`,
+    };
+}

package/dist/woo/client.js

@@ -0,0 +1,59 @@
+/** Minimal WooCommerce REST API (wc/v3) reader. Read permission is all it needs. */
+export class WooClient {
+    base;
+    auth;
+    constructor(cfg) {
+        this.base = `${cfg.url}/wp-json/wc/v3`;
+        this.auth = "Basic " + Buffer.from(`${cfg.consumerKey}:${cfg.consumerSecret}`).toString("base64");
+    }
+    async get(path, params = {}) {
+        const url = new URL(`${this.base}/${path.replace(/^\//, "")}`);
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, String(v));
+        const res = await fetch(url, { headers: { Authorization: this.auth, Accept: "application/json" } });
+        if (!res.ok) {
+            let detail = "";
+            try {
+                const body = (await res.json());
+                detail = body.message ? ` (${body.code ?? "error"}: ${body.message})` : "";
+            }
+            catch {
+                /* not JSON */
+            }
+            throw new Error(`WooCommerce ${res.status} on ${url.pathname}${detail}`);
+        }
+        return {
+            data: (await res.json()),
+            totalPages: Number(res.headers.get("x-wp-totalpages") ?? "1"),
+            total: Number(res.headers.get("x-wp-total") ?? "0"),
+        };
+    }
+    /** Iterate every item of a paginated collection endpoint, 100 per request. */
+    async *all(path, params = {}, limit) {
+        let page = 1;
+        let yielded = 0;
+        for (;;) {
+            const { data, totalPages } = await this.get(path, { ...params, per_page: 100, page });
+            for (const item of data) {
+                yield item;
+                yielded += 1;
+                if (limit !== undefined && yielded >= limit)
+                    return;
+            }
+            if (page >= totalPages || data.length === 0)
+                return;
+            page += 1;
+        }
+    }
+    /** Returns null when the endpoint does not exist on this store (older WooCommerce). */
+    async optional(path, params = {}) {
+        try {
+            return (await this.get(path, params)).data;
+        }
+        catch (e) {
+            if (e instanceof Error && /WooCommerce 404/.test(e.message))
+                return null;
+            throw e;
+        }
+    }
+}

package/dist/woo/types.js

@@ -0,0 +1 @@
+export {};

package/docs/target-schema.md

@@ -0,0 +1,104 @@
+# Target EmDash schema for a WooCommerce catalog
+
+This is the shape woo2emdash creates in an EmDash site and fills from a WooCommerce store. It is meant as a stable contract that storefront themes, commerce plugins and other tools can build on, so changes here are versioned. The code that creates it is `src/schema/catalog.ts`; `woo2emdash schema show` prints the same list from the code, which wins if the two ever disagree.
+
+## Conventions
+
+Money is stored as a decimal number in the store currency, exactly as WooCommerce reports it, with the currency code kept on every entry. Nothing is converted to minor units, that is a consumer's choice.
+
+Every entry carries `woo_id`, the WooCommerce numeric ID, unique and indexed. Re-running the importer looks entries up by `woo_id` and updates them instead of creating duplicates. `woo_modified` allows incremental syncs and `woo_permalink` allows building redirects from the old shop URLs.
+
+Field slugs follow EmDash rules, lowercase letters, digits and underscores, so WooCommerce's hyphenated attribute taxonomies are renamed (pa_plug-type becomes pa_plug_type). The original WooCommerce taxonomy slug is kept inside the `attributes` JSON.
+
+Images referenced inside descriptions are uploaded to EmDash media too, and the Portable Text image blocks point at the EmDash media item, so nothing in an imported description depends on the old site staying up.
+
+Entry status maps WooCommerce publish to published and everything else (draft, pending, private) to draft. Creation and publication dates are preserved from WooCommerce.
+
+## Collection `products`
+
+Routable, with drafts, revisions, search and SEO. One entry per WooCommerce product of any type. Variations are separate entries in `product_variations`.
+
+| Field | Type | Source in wc/v3 |
+|---|---|---|
+| title | string, required | name |
+| content | portableText | description, HTML converted to Portable Text |
+| excerpt | text | short_description, HTML stripped to text |
+| product_type | select simple, variable, grouped, external | type |
+| sku | string, indexed | sku |
+| gtin | string | global_unique_id |
+| featured_image | image | images[0], uploaded to EmDash media |
+| regular_price | number | regular_price |
+| sale_price | number | sale_price |
+| price | number, indexed | price |
+| currency | string | woocommerce_currency (settings/general) |
+| sale_from | datetime | date_on_sale_from_gmt |
+| sale_to | datetime | date_on_sale_to_gmt |
+| stock_status | select instock, outofstock, onbackorder | stock_status |
+| manage_stock | boolean | manage_stock |
+| stock_quantity | integer | stock_quantity |
+| backorders | select no, notify, yes | backorders |
+| low_stock_amount | integer | low_stock_amount |
+| weight | number | weight |
+| length, width, height | number | dimensions |
+| weight_unit, dimension_unit | string | woocommerce_weight_unit, woocommerce_dimension_unit (settings/products) |
+| shipping_class | string | shipping_class slug |
+| tax_status | select taxable, shipping, none | tax_status |
+| tax_class | string | tax_class |
+| virtual | boolean | virtual |
+| downloadable | boolean | downloadable |
+| downloads | json | downloads, array of { id, name, file } |
+| download_limit | integer | download_limit, -1 is unlimited |
+| download_expiry | integer | download_expiry in days, -1 is never |
+| gallery | repeater of image | images[1..], each uploaded to EmDash media |
+| external_url | url | external_url |
+| button_text | string | button_text |
+| featured | boolean, indexed | featured |
+| catalog_visibility | select visible, catalog, search, hidden | catalog_visibility |
+| menu_order | integer, indexed | menu_order |
+| sold_individually | boolean | sold_individually |
+| purchase_note | text | purchase_note |
+| reviews_allowed | boolean | reviews_allowed |
+| average_rating | number | average_rating |
+| rating_count | integer | rating_count |
+| attributes | json | attributes, array of { name, taxonomy, visible, variation, options[] }, taxonomy is the EmDash taxonomy name for global attributes and null for custom ones |
+| default_attributes | json | default_attributes |
+| upsells | reference to products, multiple | upsell_ids |
+| cross_sells | reference to products, multiple | cross_sell_ids |
+| grouped_products | reference to products, multiple | grouped_products |
+| woo_id | integer, required, unique, indexed | id |
+| woo_permalink | url | permalink |
+| woo_modified | datetime, indexed | date_modified_gmt |
+
+## Collection `product_variations`
+
+Not routable, drafts and revisions only. One entry per WooCommerce variation.
+
+| Field | Type | Source in wc/v3 |
+|---|---|---|
+| title | string, required | name |
+| product | reference to products, required, indexed | parent_id |
+| content | portableText | description |
+| sku, gtin, featured_image, regular_price, sale_price, price, currency, sale_from, sale_to | as in products | same fields, featured_image from image |
+| stock_status, manage_stock, stock_quantity, backorders, low_stock_amount | as in products | same fields |
+| weight, length, width, height, weight_unit, dimension_unit, shipping_class | as in products | same fields |
+| tax_status, tax_class, virtual, downloadable, downloads, download_limit, download_expiry | as in products | same fields |
+| attributes | json | attributes, array of { name, taxonomy, option } |
+| menu_order | integer, indexed | menu_order |
+| woo_id, woo_permalink, woo_modified | as in products | id, permalink, date_modified_gmt |
+
+## Taxonomies
+
+| EmDash taxonomy | Shape | Applies to | Source |
+|---|---|---|---|
+| product_category | hierarchical | products | product_cat |
+| product_tag | flat | products | product_tag |
+| product_brand | hierarchical | products | product_brand (WooCommerce 9.6 and later, skipped when the endpoint is missing) |
+| pa_<attribute> | flat, one per global attribute | products, product_variations | the attribute taxonomy, hyphens replaced by underscores |
+
+Custom (per-product) attributes have no taxonomy. They live only in the `attributes` JSON.
+
+Term slugs and labels are copied from WooCommerce, category parents are preserved. Term assignments are made on import; the variation entries are assigned the attribute terms they carry.
+
+## Out of scope for v1
+
+Customers, orders, reviews, coupons, shipping zones and tax rates. Reviews are WooCommerce comments and could map to EmDash comments later. Orders need a schema no commerce plugin has agreed on yet.

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "woo2emdash",
+  "version": "0.1.0",
+  "description": "Migrate a WooCommerce catalog into EmDash CMS collections",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "woo2emdash": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.16"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "node --experimental-strip-types src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --experimental-strip-types --test \"test/**/*.test.ts\"",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "@emdash-cms/gutenberg-to-portable-text": "^0.37.0"
+  },
+  "author": "Rafael Minuesa",
+  "keywords": [
+    "woocommerce",
+    "emdash",
+    "emdash-cms",
+    "migration",
+    "import",
+    "wordpress",
+    "astro"
+  ],
+  "homepage": "https://prowoos.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ProWoos-Devs/woo2emdash.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ProWoos-Devs/woo2emdash/issues"
+  }
+}