woo2emdash 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 (2026-09-10)
+
+First working version.
+
+- `analyze` reports what a WooCommerce store contains, with a language breakdown for multilingual stores.
+- `schema show` and `schema apply` create the documented target schema: `products` and `product_variations` collections, `product_category`, `product_tag` and `product_brand` taxonomies, and one taxonomy per WooCommerce global attribute.
+- `import` copies products, variations, taxonomy terms and images, including images inside descriptions. Entries are matched by WooCommerce ID, so re-runs update in place. Options: `--lang`, `--locale`, `--since`, `--limit`, `--dry-run`, `--skip-media`, `--skip-variations`.
+- `redirects` writes a 301 map from the old product URLs to the EmDash ones in the EmDash seed format.
+- Multilingual stores: the language comes from WC Multilang 1.3.0's `wcml_language` field when present (permalink prefix otherwise), `--lang` filters server-side, and `--locale` stores entries and terms under an EmDash locale and links language copies as translations through `wcml_translations`.

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Rafael Minuesa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# woo2emdash
+
+Command line tool that copies a WooCommerce catalog into [EmDash CMS](https://emdashcms.com) collections. It reads the store through the WooCommerce REST API with a read-only key and writes through EmDash's documented REST API, so it works against EmDash on Cloudflare or on Node.
+
+Status: pre-release. `analyze`, `schema apply`, `import` and `redirects` work for products, variations, taxonomy terms and images, including images inside descriptions. Customers, orders and reviews are not in scope yet. The target schema is documented in [docs/target-schema.md](docs/target-schema.md).
+
+## Why
+
+EmDash's built-in WordPress importer keeps titles and body text but drops every product field, and WooCommerce orders are not even in a WordPress export anymore. This tool carries the catalog across with prices, stock, variations, attributes, categories, tags, brands and images intact, into a schema other EmDash tools can rely on.
+
+## Requirements
+
+- Node.js 22.16 or later
+- A WooCommerce REST API key with Read permission (WooCommerce, Settings, Advanced, REST API)
+- An EmDash site. On localhost nothing else is needed. For a remote site, an EmDash API token.
+
+## Usage
+
+```sh
+export WOO_URL=https://shop.example.com
+export WOO_CONSUMER_KEY=ck_...
+export WOO_CONSUMER_SECRET=cs_...
+export EMDASH_URL=http://127.0.0.1:4321
+
+npx woo2emdash analyze                 # what the store contains
+npx woo2emdash analyze --lang en       # multilingual stores, one language at a time
+npx woo2emdash schema show             # the target schema
+npx woo2emdash schema apply --dry-run  # what would be created in EmDash
+npx woo2emdash schema apply            # create collections, fields and taxonomies (safe to re-run)
+npx woo2emdash import --dry-run --lang en --limit 5   # rehearse on five products, nothing written
+npx woo2emdash import --lang en        # the real thing, safe to re-run
+```
+
+Re-running `import` updates entries in place. For large stores, `--since 2026-09-01` limits a re-run to products WooCommerce modified after that date. Every entry is matched by its WooCommerce ID, images are deduplicated by EmDash, and terms are reused by slug. Published products stay published, everything else is a draft.
+
+After the import, `redirects` writes a 301 map from every published product's old WooCommerce URL to its EmDash URL, in the EmDash seed `redirects` format. Pass `--pattern /shop/{slug}` if your product pages do not live under the collection's URL pattern, and `--out redirects.json` to write a file.
+
+```sh
+npx woo2emdash redirects --out redirects.json
+```
+
+Multilingual stores (WPML, Polylang, WC Multilang) hold one product per language. Import one language per run with `--lang`, which matches the language prefix in the product's permalink. Terms are created only for the products actually imported, so the other languages' categories and tags stay out. If the EmDash site has locales configured, add `--locale fr` to store that run's entries and terms under the matching locale. With [WC Multilang](https://github.com/ProWoos-Devs/wc-multilang) 1.3.0 or later on the store, the language is read from the product itself, filtering happens server-side, and each language copy is linked to the already imported ones as an EmDash translation. Import the default language first, then the others.
+
+Run `woo2emdash --help` for every flag.
+
+## Development
+
+```sh
+npm install
+npm run typecheck
+npm run dev -- analyze     # runs the TypeScript source directly
+npm run build              # emits dist/
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { HELP, parseCli } from "./config.js";
+import { log } from "./log.js";
+import { analyze } from "./commands/analyze.js";
+import { schemaApply, schemaShow } from "./commands/schema.js";
+import { runImport } from "./commands/import.js";
+import { redirects } from "./commands/redirects.js";
+async function main() {
+    const cli = parseCli(process.argv.slice(2));
+    const [cmd, sub] = cli.command;
+    if (cli.flags.help || !cmd) {
+        process.stdout.write(HELP);
+        return cmd ? 0 : 1;
+    }
+    switch (`${cmd} ${sub ?? ""}`.trim()) {
+        case "analyze":
+            await analyze(cli);
+            return 0;
+        case "schema show":
+            schemaShow(cli);
+            return 0;
+        case "schema apply":
+            await schemaApply(cli);
+            return 0;
+        case "import":
+            return (await runImport(cli)) ? 0 : 1;
+        case "redirects":
+            await redirects(cli);
+            return 0;
+        default:
+            log.error(`Unknown command: ${cli.command.join(" ")}`);
+            process.stdout.write(HELP);
+            return 1;
+    }
+}
+main()
+    .then((code) => process.exit(code))
+    .catch((e) => {
+    log.error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+});

package/dist/commands/analyze.js

@@ -0,0 +1,117 @@
+import { log } from "../log.js";
+import { WooClient } from "../woo/client.js";
+import { productLanguage } from "../import/convert.js";
+const bump = (rec, key) => {
+    rec[key] = (rec[key] ?? 0) + 1;
+};
+export async function analyze(cli) {
+    const woo = new WooClient(cli.woo());
+    const wooCfg = cli.woo();
+    log.step(`Analyzing ${wooCfg.url}`);
+    const settings = [
+        ...((await woo.optional("settings/general")) ?? []),
+        ...((await woo.optional("settings/products")) ?? []),
+    ];
+    const setting = (id) => {
+        const v = settings.find((s) => s.id === id)?.value;
+        return typeof v === "string" ? v : null;
+    };
+    const store = {
+        url: wooCfg.url,
+        currency: setting("woocommerce_currency"),
+        weightUnit: setting("woocommerce_weight_unit"),
+        dimensionUnit: setting("woocommerce_dimension_unit"),
+    };
+    const warnings = [];
+    if (!store.currency)
+        warnings.push("Could not read woocommerce_currency from settings/general; the key may lack settings access.");
+    const products = {
+        counted: 0,
+        total: 0,
+        byType: {},
+        byStatus: {},
+        byLanguagePrefix: {},
+        withVariations: 0,
+        variationsTotal: 0,
+        withAttributes: 0,
+        withGallery: 0,
+        imagesTotal: 0,
+        onSale: 0,
+        withSku: 0,
+    };
+    products.total = (await woo.get("products", { per_page: 1, status: "any" })).total;
+    const params = { status: "any", _fields: "id,type,status,permalink,variations,attributes,images,sale_price,sku,wcml_language" };
+    if (cli.flags.lang)
+        params.lang = cli.flags.lang; // honored by WC Multilang 1.3.0+, ignored elsewhere
+    let languageField = 0;
+    for await (const p of woo.all("products", params, cli.flags.limit)) {
+        if (typeof p.wcml_language === "string")
+            languageField += 1;
+        const prefix = productLanguage(p);
+        if (cli.flags.lang && prefix !== cli.flags.lang.toLowerCase())
+            continue;
+        products.counted += 1;
+        bump(products.byType, p.type);
+        bump(products.byStatus, p.status);
+        bump(products.byLanguagePrefix, prefix);
+        if (p.variations.length > 0) {
+            products.withVariations += 1;
+            products.variationsTotal += p.variations.length;
+        }
+        if (p.attributes.length > 0)
+            products.withAttributes += 1;
+        if (p.images.length > 1)
+            products.withGallery += 1;
+        products.imagesTotal += p.images.length;
+        if (p.sale_price !== "")
+            products.onSale += 1;
+        if (p.sku !== "")
+            products.withSku += 1;
+    }
+    const categories = (await woo.get("products/categories", { per_page: 1 })).total;
+    const tags = (await woo.get("products/tags", { per_page: 1 })).total;
+    const brandsRes = await woo.optional("products/brands", { per_page: 1 });
+    const brands = brandsRes === null ? null : (await woo.get("products/brands", { per_page: 1 })).total;
+    if (brands === null)
+        warnings.push("No products/brands endpoint on this store (WooCommerce before 9.6); the product_brand taxonomy will stay empty.");
+    const globalAttributes = [];
+    for await (const a of woo.all("products/attributes"))
+        globalAttributes.push({ slug: a.slug, name: a.name });
+    if (languageField === 0 && Object.keys(products.byLanguagePrefix).some((k) => k !== "(none)")) {
+        warnings.push("Language is inferred from permalink prefixes. Stores running WC Multilang 1.3.0+ report it directly (wcml_language).");
+    }
+    const languages = Object.keys(products.byLanguagePrefix).filter((k) => k !== "(none)");
+    if (languages.length > 1 && !cli.flags.lang) {
+        warnings.push(`Products carry ${languages.length} language prefixes (${languages.join(", ")}). Each language is a separate WooCommerce product, so import one language at a time with --lang, or expect duplicates.`);
+    }
+    for (const t of ["grouped", "simple", "variable", "external"]) {
+        if (!products.byType[t])
+            warnings.push(`No ${t} products in this store, that type stays untested here.`);
+    }
+    const report = { store, products, taxonomies: { categories, tags, brands, globalAttributes }, warnings };
+    if (cli.flags.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    const fmt = (rec) => Object.entries(rec)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, v]) => `${k} ${v}`)
+        .join(", ");
+    console.log(`Store            ${store.url}`);
+    console.log(`Currency         ${store.currency ?? "?"}   weight ${store.weightUnit ?? "?"}   dimensions ${store.dimensionUnit ?? "?"}`);
+    console.log(`Products         ${products.counted} counted of ${products.total} total${cli.flags.lang ? ` (language ${cli.flags.lang})` : ""}`);
+    console.log(`  by type        ${fmt(products.byType)}`);
+    console.log(`  by status      ${fmt(products.byStatus)}`);
+    console.log(`  by language    ${fmt(products.byLanguagePrefix)}`);
+    console.log(`  variations     ${products.variationsTotal} across ${products.withVariations} products`);
+    console.log(`  attributes     ${products.withAttributes} products carry attributes`);
+    console.log(`  images         ${products.imagesTotal} total, ${products.withGallery} products with a gallery`);
+    console.log(`  on sale        ${products.onSale}`);
+    console.log(`  with SKU       ${products.withSku}`);
+    console.log(`Categories       ${categories}`);
+    console.log(`Tags             ${tags}`);
+    console.log(`Brands           ${brands ?? "endpoint missing"}`);
+    console.log(`Global attrs     ${globalAttributes.length}${globalAttributes.length ? "  (" + globalAttributes.map((a) => a.slug).join(", ") + ")" : ""}`);
+    for (const w of warnings)
+        log.warn(w);
+}

package/dist/commands/import.js

@@ -0,0 +1,211 @@
+import { EmDashClient } from "../emdash/client.js";
+import { entrySlug, gmtDate, productData, productLanguage, variationData } from "../import/convert.js";
+import { EntryWriter } from "../import/entries.js";
+import { relinkImages } from "../import/images.js";
+import { MediaImporter } from "../import/media.js";
+import { TermSync } from "../import/terms.js";
+import { log } from "../log.js";
+import { PRODUCTS, VARIATIONS } from "../schema/catalog.js";
+import { WooClient } from "../woo/client.js";
+async function storeUnits(woo) {
+    const settings = [
+        ...((await woo.optional("settings/general")) ?? []),
+        ...((await woo.optional("settings/products")) ?? []),
+    ];
+    const get = (id) => {
+        const v = settings.find((s) => s.id === id)?.value;
+        return typeof v === "string" && v !== "" ? v : undefined;
+    };
+    return {
+        currency: get("woocommerce_currency"),
+        weightUnit: get("woocommerce_weight_unit"),
+        dimensionUnit: get("woocommerce_dimension_unit"),
+    };
+}
+async function termAssignments(p, terms) {
+    const out = {};
+    const add = async (taxonomy, slugs) => {
+        const list = (await Promise.all(slugs)).filter((s) => Boolean(s));
+        if (list.length > 0)
+            out[taxonomy] = list;
+    };
+    await add("product_category", p.categories.map((c) => terms.ensureById("product_category", c.id)));
+    await add("product_tag", p.tags.map((t) => terms.ensureById("product_tag", t.id)));
+    if (p.brands)
+        await add("product_brand", p.brands.map((b) => terms.ensureById("product_brand", b.id)));
+    for (const a of p.attributes) {
+        if (a.id === 0 || !a.slug)
+            continue;
+        const taxonomy = terms.attributeTaxonomy(a.slug);
+        if (!taxonomy)
+            continue;
+        await add(taxonomy, a.options.map((o) => terms.ensureByName(taxonomy, o)));
+    }
+    return out;
+}
+async function variationTerms(v, terms) {
+    const out = {};
+    for (const a of v.attributes) {
+        if (a.id === 0 || !a.slug || !a.option)
+            continue;
+        const taxonomy = terms.attributeTaxonomy(a.slug);
+        const slug = taxonomy ? await terms.ensureByName(taxonomy, a.option) : undefined;
+        if (taxonomy && slug)
+            out[taxonomy] = [slug];
+    }
+    return out;
+}
+export async function runImport(cli) {
+    const dryRun = cli.flags.dryRun;
+    const wooCfg = cli.woo();
+    const emdashCfg = cli.emdash();
+    const woo = new WooClient(wooCfg);
+    const emdash = new EmDashClient(emdashCfg);
+    const media = new MediaImporter(emdash, dryRun || cli.flags.skipMedia);
+    const locale = cli.flags.locale;
+    const writer = new EntryWriter(emdash, dryRun, locale);
+    const terms = new TermSync(woo, emdash, dryRun, locale);
+    let relinkedImages = 0;
+    let linkedTranslations = 0;
+    const errors = [];
+    log.step(`${dryRun ? "Dry run: " : ""}importing ${wooCfg.url} into ${emdashCfg.url}${cli.flags.lang ? ` (language ${cli.flags.lang})` : ""}`);
+    const collections = new Set((await emdash.collections()).map((c) => c.slug));
+    if (!collections.has(PRODUCTS) || !collections.has(VARIATIONS)) {
+        log.error(`Collections ${PRODUCTS} and ${VARIATIONS} are missing. Run "schema apply" first.`);
+        return false;
+    }
+    const units = await storeUnits(woo);
+    log.info(`store currency ${units.currency ?? "?"}, weight ${units.weightUnit ?? "?"}, dimensions ${units.dimensionUnit ?? "?"}`);
+    log.step("Terms");
+    await terms.load();
+    log.step("Products");
+    const pending = [];
+    let seen = 0;
+    const productParams = { status: "any" };
+    if (cli.flags.lang)
+        productParams.lang = cli.flags.lang; // server-side filter with WC Multilang 1.3.0+, ignored elsewhere
+    if (cli.flags.since) {
+        productParams.modified_after = new Date(cli.flags.since).toISOString();
+        log.info(`only products modified after ${productParams.modified_after}`);
+    }
+    for await (const p of woo.all("products", productParams, undefined)) {
+        if (cli.flags.lang && productLanguage(p) !== cli.flags.lang.toLowerCase())
+            continue;
+        if (cli.flags.limit !== undefined && seen >= cli.flags.limit)
+            break;
+        seen += 1;
+        try {
+            const [first, ...rest] = p.images;
+            const featured = await media.image(first);
+            const gallery = (await Promise.all(rest.map((img) => media.image(img)))).filter((m) => Boolean(m));
+            const publish = p.status === "publish";
+            const data = productData(p, units, terms.attributeTaxonomy, featured, gallery);
+            if (Array.isArray(data.content) && data.content.length > 0) {
+                const r = await relinkImages(data.content, media);
+                data.content = r.blocks;
+                relinkedImages += r.relinked;
+            }
+            let translationOf;
+            if (locale && p.wcml_translations) {
+                for (const [lang, wooId] of Object.entries(p.wcml_translations)) {
+                    if (wooId === p.id || lang.toLowerCase() === locale.toLowerCase())
+                        continue;
+                    const sibling = await writer.findAnyLocale(PRODUCTS, wooId);
+                    if (sibling) {
+                        translationOf = sibling.id;
+                        linkedTranslations += 1;
+                        break;
+                    }
+                }
+            }
+            const entry = await writer.upsert({
+                collection: PRODUCTS,
+                wooId: p.id,
+                slug: entrySlug(p.slug, p.id),
+                data,
+                publish,
+                createdAt: gmtDate(p.date_created_gmt),
+                taxonomies: await termAssignments(p, terms),
+                translationOf,
+            });
+            pending.push({ product: p, entryId: entry.id, publish });
+            log.info(`${p.type.padEnd(8)} ${p.id} ${p.name}${cli.flags.skipMedia ? "" : ` (${p.images.length} images)`}`);
+        }
+        catch (e) {
+            const msg = `product ${p.id} ${p.name}: ${e instanceof Error ? e.message : String(e)}`;
+            errors.push(msg);
+            log.error(msg);
+        }
+    }
+    let variationsDone = 0;
+    if (!cli.flags.skipVariations) {
+        log.step("Variations");
+        for (const { product, entryId, publish } of pending) {
+            if (product.variations.length === 0)
+                continue;
+            for await (const v of woo.all(`products/${product.id}/variations`, { status: "any" })) {
+                try {
+                    const featured = await media.image(v.image ?? undefined);
+                    const data = variationData(v, product.name, entryId, units, terms.attributeTaxonomy, featured);
+                    if (Array.isArray(data.content) && data.content.length > 0) {
+                        const r = await relinkImages(data.content, media);
+                        data.content = r.blocks;
+                        relinkedImages += r.relinked;
+                    }
+                    await writer.upsert({
+                        collection: VARIATIONS,
+                        wooId: v.id,
+                        slug: `${entrySlug(product.slug, product.id)}-${v.id}`,
+                        data,
+                        publish: publish && v.status === "publish",
+                        createdAt: gmtDate(v.date_created_gmt),
+                        taxonomies: await variationTerms(v, terms),
+                    });
+                    variationsDone += 1;
+                }
+                catch (e) {
+                    const msg = `variation ${v.id} of ${product.name}: ${e instanceof Error ? e.message : String(e)}`;
+                    errors.push(msg);
+                    log.error(msg);
+                }
+            }
+            log.info(`${product.variations.length} variations of ${product.name}`);
+        }
+    }
+    log.step("Cross references");
+    let linked = 0;
+    const resolve = (ids) => ids.map((id) => writer.entryFor(PRODUCTS, id)?.id).filter((id) => Boolean(id));
+    for (const { product, entryId, publish } of pending) {
+        const data = {};
+        const up = resolve(product.upsell_ids);
+        const cross = resolve(product.cross_sell_ids);
+        const grouped = resolve(product.grouped_products);
+        if (up.length)
+            data.upsells = up;
+        if (cross.length)
+            data.cross_sells = cross;
+        if (grouped.length)
+            data.grouped_products = grouped;
+        if (Object.keys(data).length === 0)
+            continue;
+        try {
+            await writer.patch(PRODUCTS, entryId, data, publish);
+            linked += 1;
+        }
+        catch (e) {
+            const msg = `references of ${product.name}: ${e instanceof Error ? e.message : String(e)}`;
+            errors.push(msg);
+            log.error(msg);
+        }
+    }
+    log.step("Summary");
+    log.ok(`${dryRun ? "Would write" : "Wrote"} ${pending.length} products (${writer.created} created, ${writer.updated} updated in total), ${variationsDone} variations, ${terms.created} new terms, ${linked} products with cross references${locale ? `, ${linkedTranslations} linked as translations` : ""}.`);
+    if (!cli.flags.skipMedia && !dryRun)
+        log.ok(`Images: ${media.uploaded} uploaded, ${media.reused} already present, ${media.failed} failed, ${relinkedImages} inside descriptions repointed.`);
+    if (errors.length > 0) {
+        log.error(`${errors.length} errors:`);
+        for (const e of errors)
+            log.error(`  ${e}`);
+    }
+    return errors.length === 0;
+}

package/dist/commands/redirects.js

@@ -0,0 +1,63 @@
+import { writeFile } from "node:fs/promises";
+import { EmDashClient } from "../emdash/client.js";
+import { log } from "../log.js";
+import { PRODUCTS } from "../schema/catalog.js";
+/**
+ * Builds a redirect map from the WooCommerce product URLs (kept in
+ * `woo_permalink`) to the EmDash product URLs. Output uses the EmDash seed
+ * file `redirects` format, so it can be pasted into a seed or converted to
+ * Cloudflare or Astro redirects.
+ */
+export async function redirects(cli) {
+    const emdashCfg = cli.emdash();
+    const client = new EmDashClient(emdashCfg);
+    const locale = cli.flags.locale;
+    let pattern = cli.flags.pattern;
+    if (!pattern) {
+        const col = await client.collectionInfo(PRODUCTS);
+        pattern = col.urlPattern ?? `/${PRODUCTS}/{slug}`;
+        if (!col.urlPattern)
+            log.warn(`The ${PRODUCTS} collection has no URL pattern yet, assuming ${pattern}. Pass --pattern to override.`);
+    }
+    if (!pattern.includes("{slug}"))
+        throw new Error("--pattern must contain {slug}");
+    const out = [];
+    let skipped = 0;
+    let drafts = 0;
+    for await (const item of client.allEntries(PRODUCTS, locale)) {
+        // Drafts never had a public URL in WooCommerce (their permalink is a ?p= preview link).
+        if (item.status !== "published") {
+            drafts += 1;
+            continue;
+        }
+        const permalink = item.data.woo_permalink;
+        if (typeof permalink !== "string") {
+            skipped += 1;
+            continue;
+        }
+        let source;
+        try {
+            const u = new URL(permalink);
+            source = u.pathname + (u.search || "");
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        const destination = pattern.replace("{slug}", item.slug);
+        if (source === destination)
+            continue;
+        out.push({ source, destination, type: 301, groupName: "woocommerce" });
+    }
+    out.sort((a, b) => a.source.localeCompare(b.source));
+    const json = JSON.stringify({ redirects: out }, null, 2) + "\n";
+    const notes = [drafts ? `${drafts} drafts left out` : "", skipped ? `${skipped} entries without a WooCommerce URL skipped` : ""].filter(Boolean).join(", ");
+    if (cli.flags.out) {
+        await writeFile(cli.flags.out, json, "utf8");
+        log.ok(`Wrote ${out.length} redirects to ${cli.flags.out}${notes ? ` (${notes})` : ""}.`);
+    }
+    else {
+        process.stdout.write(json);
+        log.ok(`${out.length} redirects${notes ? ` (${notes})` : ""}.`);
+    }
+}

package/dist/commands/schema.js

@@ -0,0 +1,120 @@
+import { EmDashClient } from "../emdash/client.js";
+import { log } from "../log.js";
+import { attributeTaxonomy, catalogCollections, catalogTaxonomies, } from "../schema/catalog.js";
+import { WooClient } from "../woo/client.js";
+export function schemaShow(cli) {
+    if (cli.flags.json) {
+        console.log(JSON.stringify({ collections: catalogCollections, taxonomies: catalogTaxonomies }, null, 2));
+        return;
+    }
+    for (const c of catalogCollections) {
+        console.log(`Collection ${c.slug}  (${c.label}, routable ${c.routable}, seo ${c.hasSeo})`);
+        for (const f of c.fields) {
+            const flags = [f.required && "required", f.unique && "unique", f.indexed && "indexed"].filter(Boolean).join(" ");
+            console.log(`  ${f.slug.padEnd(20)} ${f.type.padEnd(13)} ${flags.padEnd(24)} <- ${f.source}`);
+        }
+    }
+    for (const t of catalogTaxonomies) {
+        console.log(`Taxonomy ${t.name}  (${t.hierarchical ? "hierarchical" : "flat"}, on ${t.collections.join(", ")}) <- ${t.source}`);
+    }
+    console.log("Taxonomy pa_<attribute>  one flat taxonomy per WooCommerce global attribute, created by schema apply when a store is connected");
+}
+function fieldBody(f, sortOrder) {
+    const body = { slug: f.slug, label: f.label, type: f.type, sortOrder };
+    if (f.required !== undefined)
+        body.required = f.required;
+    if (f.unique !== undefined)
+        body.unique = f.unique;
+    if (f.indexed !== undefined)
+        body.indexed = f.indexed;
+    if (f.defaultValue !== undefined)
+        body.defaultValue = f.defaultValue;
+    if (f.validation !== undefined)
+        body.validation = f.validation;
+    if (f.options !== undefined)
+        body.options = f.options;
+    return body;
+}
+async function applyCollection(client, def, existing, dryRun) {
+    let created = 0;
+    if (!existing.has(def.slug)) {
+        log.info(`${dryRun ? "would create" : "creating"} collection ${def.slug}`);
+        if (!dryRun) {
+            await client.createCollection({
+                slug: def.slug,
+                label: def.label,
+                labelSingular: def.labelSingular,
+                description: def.description,
+                icon: def.icon,
+                supports: def.supports,
+                routable: def.routable,
+                hidden: def.hidden,
+                hasSeo: def.hasSeo,
+                source: "import:woocommerce",
+            });
+        }
+    }
+    const have = new Set();
+    if (!dryRun || existing.has(def.slug)) {
+        const current = await client.fields(def.slug).catch(() => []);
+        for (const f of current)
+            have.add(f.slug);
+    }
+    let i = 0;
+    for (const f of def.fields) {
+        i += 10;
+        if (have.has(f.slug))
+            continue;
+        log.info(`  ${dryRun ? "would add" : "adding"} field ${def.slug}.${f.slug} (${f.type})`);
+        if (!dryRun)
+            await client.createField(def.slug, fieldBody(f, i));
+        created += 1;
+    }
+    return created;
+}
+async function applyTaxonomy(client, def, existing, dryRun) {
+    if (existing.has(def.name))
+        return 0;
+    log.info(`${dryRun ? "would create" : "creating"} taxonomy ${def.name} (${def.hierarchical ? "hierarchical" : "flat"})`);
+    if (!dryRun) {
+        await client.createTaxonomy({
+            name: def.name,
+            label: def.label,
+            labelSingular: def.labelSingular,
+            hierarchical: def.hierarchical,
+            collections: def.collections,
+        });
+    }
+    return 1;
+}
+export async function schemaApply(cli) {
+    const dryRun = cli.flags.dryRun;
+    const emdashCfg = cli.emdash();
+    const client = new EmDashClient(emdashCfg);
+    log.step(`${dryRun ? "Checking" : "Applying"} catalog schema on ${emdashCfg.url}`);
+    const existingCollections = new Set((await client.collections()).map((c) => c.slug));
+    const existingTaxonomies = new Set((await client.taxonomies()).map((t) => t.name));
+    let fields = 0;
+    for (const def of catalogCollections)
+        fields += await applyCollection(client, def, existingCollections, dryRun);
+    const taxonomies = [...catalogTaxonomies];
+    let wooConnected = false;
+    try {
+        const woo = new WooClient(cli.woo());
+        for await (const a of woo.all("products/attributes"))
+            taxonomies.push(attributeTaxonomy(a));
+        wooConnected = true;
+    }
+    catch (e) {
+        if (e instanceof Error && /connection missing/.test(e.message)) {
+            log.warn("No WooCommerce connection given, attribute taxonomies (pa_*) are skipped. Re-run with the store connected before importing.");
+        }
+        else {
+            throw e;
+        }
+    }
+    let created = 0;
+    for (const t of taxonomies)
+        created += await applyTaxonomy(client, t, existingTaxonomies, dryRun);
+    log.ok(`${dryRun ? "Would add" : "Added"} ${fields} fields and ${created} taxonomies${wooConnected ? "" : " (static set only)"}. Collections present: ${catalogCollections.map((c) => c.slug).join(", ")}.`);
+}