@base44/app-plugin-commerce 0.1.6 → 0.1.8

package/base44/functions/commerce/seed-store/entry.ts

@@ -5,31 +5,32 @@
  * per-field errors before anything runs), (2) canary schema validation (probe
  * create+delete per entity; abort with 422 schema_incompatible and write
  * nothing on any failure), (3) seed required defaults (settings groups,
- * gateways, tax classes, fallback zone), (4) the catalog: either the caller's
- * `products`/`coupons`/`tax_rates` (taxonomy get-or-created by name,
+ * gateways, and — only when the payload carries no `locations` — the fallback
+ * Shipping & Tax Location, so caller locations are the store's only shipping
+ * data), (4) the catalog: either the
+ * caller's `products`/`coupons`/`locations` (taxonomy get-or-created by name,
  * variations generated from `attributes` when not given, per-product skip when
  * the sku/slug already exists) or the generic demo catalog
  * (with_sample_data=true, only when the store has zero products) — with
  * best-effort rollback on mid-failure. See seed-catalog.ts for the pipeline.
  *
- * Body: { store_name?, currency?, with_sample_data?, products?, coupons?, tax_rates? }
+ * Body: { store_name?, currency?, weight_unit?, dimension_unit?,
+ *         with_sample_data?, products?, coupons?, locations? }
  * — with_sample_data cannot be combined with the catalog keys.
  *
  * `store_name` is required on a first seed: a function's env is only
  * BASE44_APP_ID, so it cannot read the app's name, and subjects need one.
- * `currency` is an ISO code; passing it explicitly always wins — it sets
- * general.currency (and the currency's standard num_decimals) whether the
- * group is being created or already exists.
+ * `currency` is an ISO code and `weight_unit`/`dimension_unit` are the
+ * measurement units; passing any of them explicitly always wins — they set the
+ * `general` group whether it is being created or already exists.
  */
 import { createClientFromRequest } from "npm:@base44/sdk";
 import { HttpError, requireAdmin } from "../../../shared/commerce/auth.ts";
 import { CURRENCIES } from "../../../shared/commerce/data/currencies.ts";
 import {
   GATEWAY_DEFAULTS,
-  REST_OF_WORLD_EXAMPLE_METHOD,
-  REST_OF_WORLD_ZONE,
+  REST_OF_WORLD_LOCATION,
   SETTINGS_DEFAULTS,
-  TAX_CLASS_DEFAULTS,
 } from "./defaults.ts";
 import { CatalogPayloadError, normalizeCatalogPayload, sampleCatalog, seedCatalog } from "./seed-catalog.ts";
 
@@ -47,13 +48,25 @@ Deno.serve(async (req) => {
     const storeName = String(body.store_name ?? "").trim();
     const currencyCode = String(body.currency ?? "").trim().toUpperCase();
     const currencyInfo = currencyCode ? CURRENCIES.find((c) => c.code === currencyCode) : undefined;
+    const WEIGHT_UNITS = ["kg", "g", "lbs", "oz"];
+    const DIMENSION_UNITS = ["cm", "m", "mm", "in", "yd"];
+    const weightUnit = String(body.weight_unit ?? "").trim().toLowerCase();
+    const dimensionUnit = String(body.dimension_unit ?? "").trim().toLowerCase();
 
     // ── 0. validate the payload — pure, so bad input fails before canaries
     //       or any write ──────────────────────────────────────────────────────
+    const unitErrors: Array<{ path: string; error: string }> = [];
     if (currencyCode && !currencyInfo) {
-      return fail(400, "Invalid catalog payload — nothing was written.", "invalid_payload", {
-        errors: [{ path: "currency", error: `"${currencyCode}" is not a known ISO currency code` }],
-      });
+      unitErrors.push({ path: "currency", error: `"${currencyCode}" is not a known ISO currency code` });
+    }
+    if (weightUnit && !WEIGHT_UNITS.includes(weightUnit)) {
+      unitErrors.push({ path: "weight_unit", error: `must be one of: ${WEIGHT_UNITS.join(", ")}` });
+    }
+    if (dimensionUnit && !DIMENSION_UNITS.includes(dimensionUnit)) {
+      unitErrors.push({ path: "dimension_unit", error: `must be one of: ${DIMENSION_UNITS.join(", ")}` });
+    }
+    if (unitErrors.length) {
+      return fail(400, "Invalid catalog payload — nothing was written.", "invalid_payload", { errors: unitErrors });
     }
     let catalogSpec = null;
     try {
@@ -73,7 +86,7 @@ Deno.serve(async (req) => {
     }
 
     // ── 2. required defaults (idempotent) ────────────────────────────────────
-    const seeded = { settings_groups: 0, gateways: 0, tax_classes: 0, zones: 0, zone_methods: 0 };
+    const seeded = { settings_groups: 0, gateways: 0, locations: 0 };
 
     const existingSettings = (await sr.entities["commerce.StoreSettings"].list(undefined, 100)) ?? [];
     const existingGroups = new Set(existingSettings.map((s: any) => s.group_id));
@@ -82,31 +95,34 @@ Deno.serve(async (req) => {
     if (!existingGroups.has("emails") && !storeName) {
       return fail(400, "store_name is required — pass the app's name as the platform shows it.", "store_name_required");
     }
+    // The general-group keys the caller can set directly.
+    const generalPatch: Record<string, any> = {};
+    if (currencyInfo) generalPatch.currency = currencyInfo.code;
+    if (weightUnit) generalPatch.weight_unit = weightUnit;
+    if (dimensionUnit) generalPatch.dimension_unit = dimensionUnit;
+
     for (const group of SETTINGS_DEFAULTS) {
       if (existingGroups.has(group.group_id)) continue;
       const values = group.group_id === "emails"
         ? { ...group.values, store_name: storeName }
-        : group.group_id === "general" && currencyInfo
-        ? { ...group.values, currency: currencyInfo.code, num_decimals: currencyInfo.decimals }
+        : group.group_id === "general"
+        ? { ...group.values, ...generalPatch }
         : group.values;
       await sr.entities["commerce.StoreSettings"].create({ ...group, values });
       seeded.settings_groups++;
     }
 
-    // An explicit currency always wins — unlike store_name there is no "blank"
-    // to distinguish a merchant's choice from the seeded USD default, and a
+    // Explicit currency/units always win — unlike store_name there is no
+    // "blank" to distinguish a merchant's choice from the seeded default, and a
     // caller passing one is giving an instruction, not a fallback.
     let currencyAction = currencyInfo ? "created" : "unchanged";
-    if (currencyInfo && existingGroups.has("general")) {
+    if (Object.keys(generalPatch).length && existingGroups.has("general")) {
       const general = existingSettings.find((r: any) => r.group_id === "general");
       const values = general?.values ?? {};
-      if (values.currency === currencyInfo.code && values.num_decimals === currencyInfo.decimals) {
-        currencyAction = "unchanged";
-      } else {
-        await sr.entities["commerce.StoreSettings"].update(general.id, {
-          values: { ...values, currency: currencyInfo.code, num_decimals: currencyInfo.decimals },
-        });
-        currencyAction = "updated";
+      const changed = Object.entries(generalPatch).some(([k, v]) => values[k] !== v);
+      if (changed) {
+        await sr.entities["commerce.StoreSettings"].update(general.id, { values: { ...values, ...generalPatch } });
+        if (currencyInfo) currencyAction = values.currency === currencyInfo.code ? "unchanged" : "updated";
       }
     }
 
@@ -126,6 +142,20 @@ Deno.serve(async (req) => {
       }
     }
 
+    // Upgrade shim: stores installed when the card gateway was slugged "stripe"
+    // carry that row; rename it so it stays THE card option instead of turning
+    // into a dead manual method next to a freshly seeded duplicate.
+    const legacyCard = ((await sr.entities["commerce.PaymentGateway"].filter({ slug: "stripe" }, undefined, 1)) ?? [])[0];
+    if (legacyCard && !((await sr.entities["commerce.PaymentGateway"].filter({ slug: "card" }, undefined, 1)) ?? []).length) {
+      const cardDefaults = GATEWAY_DEFAULTS.find((g) => g.slug === "card")!;
+      await sr.entities["commerce.PaymentGateway"].update(legacyCard.id, {
+        slug: "card",
+        method_title: cardDefaults.method_title,
+        method_description: cardDefaults.method_description,
+        settings: {},
+      });
+    }
+
     for (const gw of GATEWAY_DEFAULTS) {
       const hits = (await sr.entities["commerce.PaymentGateway"].filter({ slug: gw.slug }, undefined, 1)) ?? [];
       if (hits.length) continue;
@@ -133,22 +163,17 @@ Deno.serve(async (req) => {
       seeded.gateways++;
     }
 
-    for (const tc of TAX_CLASS_DEFAULTS) {
-      const hits = (await sr.entities["commerce.TaxClass"].filter({ slug: tc.slug }, undefined, 1)) ?? [];
-      if (hits.length) continue;
-      await sr.entities["commerce.TaxClass"].create(tc);
-      seeded.tax_classes++;
-    }
-
-    let zone = ((await sr.entities["commerce.ShippingZone"].filter({ name: REST_OF_WORLD_ZONE.name }, undefined, 1)) ?? [])[0];
-    if (!zone) {
-      zone = await sr.entities["commerce.ShippingZone"].create(REST_OF_WORLD_ZONE);
-      seeded.zones++;
-    }
-    const zoneMethods = (await sr.entities["commerce.ShippingZoneMethod"].filter({ zone_id: zone.id }, undefined, 5)) ?? [];
-    if (!zoneMethods.length) {
-      await sr.entities["commerce.ShippingZoneMethod"].create({ ...REST_OF_WORLD_EXAMPLE_METHOD, zone_id: zone.id });
-      seeded.zone_methods++;
+    // Caller-supplied `locations` ARE the store's shipping story — seeding the
+    // free-shipping fallback next to them would leave a second no-region
+    // location the merchant never asked for (shadowed while the caller's has a
+    // lower `order`, live the moment theirs is deleted or reordered). Only
+    // create the default when the payload brings no locations of its own.
+    if (!catalogSpec?.locations?.length) {
+      const fallback = ((await sr.entities["commerce.ShippingTaxLocation"].filter({ name: REST_OF_WORLD_LOCATION.name }, undefined, 1)) ?? [])[0];
+      if (!fallback) {
+        await sr.entities["commerce.ShippingTaxLocation"].create(REST_OF_WORLD_LOCATION);
+        seeded.locations++;
+      }
     }
 
     // ── 3. the catalog: caller-supplied, or the demo sample ──────────────────
@@ -189,19 +214,16 @@ function canarySpecs(needsCatalog: boolean): Array<{ entity: string; record: Rec
   const base = [
     { entity: "commerce.StoreSettings", record: { group_id: "general", values: { __canary: true } } },
     { entity: "commerce.PaymentGateway", record: { slug: "__canary", title: "Canary", enabled: false, order: 999, settings: {} } },
-    { entity: "commerce.TaxClass", record: { slug: "__canary", name: "Canary" } },
-    { entity: "commerce.ShippingZone", record: { name: "__canary", order: 998, locations: [] } },
-    { entity: "commerce.ShippingZoneMethod", record: { zone_id: "__canary", method_id: "flat_rate", title: "Canary", enabled: false, order: 0, settings: { cost: 0 } } },
+    { entity: "commerce.ShippingTaxLocation", record: { name: "__canary", order: 998, regions: [], shipping_rates: [], tax_groups: [], shipping_tax: null } },
   ];
   const catalog = [
     { entity: "commerce.ProductCategory", record: { name: "__canary", slug: "__canary", count: 0 } },
-    { entity: "commerce.ProductTag", record: { name: "__canary", count: 0 } },
+    { entity: "commerce.ProductRibbon", record: { name: "__canary", count: 0 } },
     { entity: "commerce.ProductAttribute", record: { name: "__canary", code: "__canary", order: 0 } },
     { entity: "commerce.ProductAttributeTerm", record: { attribute_id: "__canary", name: "__canary", order: 0 } },
     { entity: "commerce.Product", record: { name: "__canary", status: "draft", regular_price: 1, price: 1 } },
     { entity: "commerce.ProductVariation", record: { product_id: "__canary", attributes: [], status: "draft" } },
     { entity: "commerce.Coupon", record: { code: "__canary", discount_type: "percent", amount: 1, usage_count: 0, used_by: [] } },
-    { entity: "commerce.TaxRate", record: { country: "ZZ", rate: 1, name: "__canary", priority: 1, compound: false, shipping: true, tax_class: "standard" } },
   ];
   return needsCatalog ? [...base, ...catalog] : base;
 }

package/base44/functions/commerce/seed-store/sample-data.ts

@@ -1,7 +1,7 @@
 /**
  * Optional demo catalog: 3 categories, 2 shared attributes (+values),
- * 10 products (3 of which carry attributes and ship with variants),
- * 2 coupons, 2 tax rates. Every product ships with a
+ * 10 products (3 of which carry attributes and ship with variants) and
+ * 2 coupons. Every product ships with a
  * description, short description and a small image gallery so the storefront
  * and admin look populated out of the box.
  * Only installed when with_sample_data=true AND the store has no products.
@@ -296,16 +296,3 @@ export const SAMPLE_COUPONS = [
     used_by: [] as string[],
   },
 ];
-
-export const SAMPLE_TAX_RATES = [
-  {
-    country: "US", state: "CA", postcodes: [] as string[], cities: [] as string[],
-    rate: 7.25, name: "CA State Tax", priority: 1, compound: false, shipping: true,
-    tax_class: "standard", menu_order: 0,
-  },
-  {
-    country: "GB", state: "", postcodes: [] as string[], cities: [] as string[],
-    rate: 20, name: "VAT", priority: 1, compound: false, shipping: true,
-    tax_class: "standard", menu_order: 1,
-  },
-];

package/base44/functions/commerce/seed-store/seed-catalog.ts

@@ -3,7 +3,7 @@
  *
  * One pipeline serves two callers: the template's demo catalog
  * (`sampleCatalog()`, over sample-data.ts) and a caller-supplied
- * `products`/`coupons`/`tax_rates` payload (`normalizeCatalogPayload()`).
+ * `products`/`coupons`/`locations` payload (`normalizeCatalogPayload()`).
  * Both normalize to the same CatalogSpec, and `seedCatalog()` writes it:
  * get-or-create taxonomy (never duplicated, never rolled back when it
  * pre-existed), create products and their variations, roll each variant
@@ -12,7 +12,7 @@
  * The caller payload is agent-ergonomic — everything is referenced by display
  * name, and variations are generated from `attributes` when not given:
  *
- *   { name, regular_price, sku?, stock_quantity?, images?, categories?, tags?,
+ *   { name, regular_price, sku?, stock_quantity?, images?, categories?, ribbons?,
  *     attributes?: [{ name: "Size", options: ["S","M"] }] | { Size: ["S","M"] },
  *     default_options?: { Size: "M" },
  *     variations?: [{ options: { Size: "S" }, regular_price?, stock_quantity?, sku?, image? }] }
@@ -35,7 +35,6 @@ import {
   SAMPLE_CATEGORIES,
   SAMPLE_COUPONS,
   SAMPLE_PRODUCTS,
-  SAMPLE_TAX_RATES,
 } from "./sample-data.ts";
 
 // ── shapes ───────────────────────────────────────────────────────────────────
@@ -48,7 +47,7 @@ interface NormalizedVariation {
 interface NormalizedProduct {
   fields: Record<string, any>; // entity passthrough, images normalized
   categorySlugs: string[];
-  tagNames: string[];
+  ribbonNames: string[];
   attributes: Array<{ code: string; options: string[] }>;
   defaultOptions: Record<string, string>;
   variations: NormalizedVariation[];
@@ -60,7 +59,7 @@ export interface CatalogSpec {
   termsByCode: Record<string, Array<{ name: string; order: number }>>;
   products: NormalizedProduct[];
   coupons: any[];
-  tax_rates: any[];
+  locations: any[];
 }
 
 /** 400-payload failure carrying every problem at once. Caught in entry.ts. */
@@ -76,20 +75,20 @@ export class CatalogPayloadError extends Error {
 
 const MAX_PRODUCTS = 100;
 const MAX_COUPONS = 50;
-const MAX_TAX_RATES = 50;
+const MAX_LOCATIONS = 50;
 const MAX_VARIATIONS_PER_PRODUCT = 50; // also the cartesian-explosion guard
 const MAX_TOTAL_VARIATIONS = 500; // every variation is a sequential create
 
 const PRODUCT_KEYS = new Set([
   // spec-only keys
-  "categories", "tags", "attributes", "default_options", "variations",
+  "categories", "ribbons", "attributes", "default_options", "variations",
   // entity fields
   "name", "slug", "sku", "status", "regular_price", "sale_price",
   "date_on_sale_from", "date_on_sale_to", "manage_stock", "stock_quantity",
   "backorders", "description", "short_description", "images", "featured",
-  "catalog_visibility", "virtual", "downloadable", "downloads",
-  "download_limit", "download_expiry", "tax_status", "tax_class", "weight",
-  "dimensions", "sold_individually", "low_stock_amount", "shipping_class_id",
+  "virtual", "downloadable", "downloads",
+  "download_limit", "download_expiry", "tax_status", "tax_group", "weight",
+  "dimensions", "sold_individually", "low_stock_amount",
   "upsell_ids", "cross_sell_ids", "meta_data",
 ]);
 
@@ -103,8 +102,7 @@ const VARIATION_KEYS = new Set([
 const ENUMS: Record<string, string[]> = {
   status: ["draft", "pending", "private", "publish"],
   backorders: ["no", "notify", "yes"],
-  catalog_visibility: ["visible", "catalog", "search", "hidden"],
-  tax_status: ["taxable", "shipping", "none"],
+  tax_status: ["taxable", "none"],
   discount_type: ["percent", "fixed_cart", "fixed_product"],
 };
 
@@ -118,14 +116,14 @@ const PRICE_KEYS = ["regular_price", "sale_price", "stock_quantity", "low_stock_
  * every problem at once, before anything (canaries included) runs.
  */
 export function normalizeCatalogPayload(body: any): CatalogSpec | null {
-  const hasCatalog = ["products", "coupons", "tax_rates"].some((k) => body[k] != null);
+  const hasCatalog = ["products", "coupons", "locations"].some((k) => body[k] != null);
   if (!hasCatalog) return null;
 
   const errors: Array<{ path: string; error: string }> = [];
   const err = (path: string, error: string) => errors.push({ path, error });
 
   if (body.with_sample_data) {
-    err("with_sample_data", "cannot be combined with products/coupons/tax_rates — seed either the demo catalog or your own, not both");
+    err("with_sample_data", "cannot be combined with products/coupons/locations — seed either the demo catalog or your own, not both");
   }
 
   const list = (key: string, cap: number): any[] => {
@@ -141,7 +139,7 @@ export function normalizeCatalogPayload(body: any): CatalogSpec | null {
 
   const products = list("products", MAX_PRODUCTS);
   const coupons = list("coupons", MAX_COUPONS);
-  const taxRates = list("tax_rates", MAX_TAX_RATES);
+  const rawLocations = list("locations", MAX_LOCATIONS);
 
   // shared definition collectors (deduped across products)
   const categoryBySlug = new Map<string, Record<string, any>>();
@@ -175,13 +173,7 @@ export function normalizeCatalogPayload(body: any): CatalogSpec | null {
     if (!Number.isFinite(Number(c.amount)) || Number(c.amount) < 0) err(`${path}.amount`, "must be a non-negative number");
   });
 
-  taxRates.forEach((r, i) => {
-    const path = `tax_rates[${i}]`;
-    if (!r || typeof r !== "object") return err(path, "must be an object");
-    if (!String(r.country ?? "").trim()) err(`${path}.country`, "is required");
-    if (!String(r.name ?? "").trim()) err(`${path}.name`, "is required");
-    if (!Number.isFinite(Number(r.rate)) || Number(r.rate) < 0) err(`${path}.rate`, "must be a non-negative number");
-  });
+  const locations = rawLocations.map((l, i) => normalizeLocation(l, `locations[${i}]`, err)).filter(Boolean);
 
   if (errors.length) throw new CatalogPayloadError(errors);
 
@@ -191,10 +183,68 @@ export function normalizeCatalogPayload(body: any): CatalogSpec | null {
     termsByCode,
     products: normalized,
     coupons,
-    tax_rates: taxRates,
+    locations,
   };
 }
 
+/**
+ * A caller location is Wix-shaped: countries (ISO codes) or explicit regions,
+ * shipping rates, named tax groups and an optional shipping tax:
+ *
+ *   { name: "Israel", countries: ["IL"],
+ *     shipping_rates: [{ name: "Standard", cost: 20, free_over: 150 }],
+ *     tax_groups: [{ name: "Products", rates: [{ name: "VAT", rate: 18 }] }],
+ *     shipping_tax: { type: "percent", value: 18 } }
+ */
+function normalizeLocation(l: any, path: string, err: (p: string, e: string) => void): any | null {
+  if (!l || typeof l !== "object" || Array.isArray(l)) {
+    err(path, "must be an object");
+    return null;
+  }
+  const name = String(l.name ?? "").trim();
+  if (!name) {
+    err(`${path}.name`, "is required");
+    return null;
+  }
+  const regions: any[] = [];
+  for (const c of l.countries ?? []) {
+    const code = String(c ?? "").trim().toUpperCase();
+    if (code) regions.push({ type: "country", code });
+  }
+  for (const r of l.regions ?? []) {
+    if (r?.type && r?.code) regions.push({ type: String(r.type), code: String(r.code).toUpperCase() });
+  }
+  const slugBase = slugify(name);
+  const shippingRates = (Array.isArray(l.shipping_rates) ? l.shipping_rates : []).map((r: any, i: number) => {
+    const rate = { id: r?.id || `${slugBase}-${slugify(String(r?.name || `rate-${i + 1}`))}`,
+      name: String(r?.name ?? "").trim() || "Shipping",
+      cost: Number(r?.cost) || 0,
+      free_over: r?.free_over != null && Number.isFinite(Number(r.free_over)) ? Number(r.free_over) : null };
+    if (rate.cost < 0) err(`${path}.shipping_rates[${i}].cost`, "must be a non-negative number");
+    return rate;
+  });
+  const taxGroups = (Array.isArray(l.tax_groups) ? l.tax_groups : []).map((g: any, i: number) => ({
+    name: String(g?.name ?? "").trim() || "Products",
+    rates: (Array.isArray(g?.rates) ? g.rates : []).map((r: any, j: number) => {
+      const rate = { name: String(r?.name ?? "").trim(), rate: Number(r?.rate) || 0 };
+      if (rate.rate < 0 || rate.rate > 100) err(`${path}.tax_groups[${i}].rates[${j}].rate`, "must be a percentage between 0 and 100");
+      return rate;
+    }),
+  }));
+  if (!taxGroups.some((g: any) => g.name.toLowerCase() === "products")) {
+    taxGroups.unshift({ name: "Products", rates: [] });
+  }
+  let shippingTax: any = null;
+  if (l.shipping_tax != null) {
+    const type = String(l.shipping_tax.type ?? "percent");
+    if (!["percent", "fixed"].includes(type)) err(`${path}.shipping_tax.type`, "must be percent or fixed");
+    const value = Number(l.shipping_tax.value);
+    if (!Number.isFinite(value) || value < 0) err(`${path}.shipping_tax.value`, "must be a non-negative number");
+    shippingTax = { type, value: Number.isFinite(value) ? value : 0 };
+  }
+  return { name, order: Number(l.order) || 0, regions, shipping_rates: shippingRates, tax_groups: taxGroups, shipping_tax: shippingTax };
+}
+
 function normalizeProduct(
   spec: any,
   path: string,
@@ -227,7 +277,7 @@ function normalizeProduct(
     }
     return slug;
   });
-  const tagNames = strList(spec.tags, `${path}.tags`, err);
+  const ribbonNames = strList(spec.ribbons, `${path}.ribbons`, err);
 
   // attribute axes: array form is canonical, map form accepted (insertion order)
   const axes: Array<{ name: string; code: string; options: string[] }> = [];
@@ -363,7 +413,7 @@ function normalizeProduct(
   return {
     fields,
     categorySlugs,
-    tagNames,
+    ribbonNames,
     attributes: axes.map((a) => ({ code: a.code, options: a.options })),
     defaultOptions,
     variations,
@@ -440,7 +490,7 @@ export function sampleCatalog(): CatalogSpec {
       return {
         fields: { ...fields, images: fields.images ?? [] },
         categorySlugs: categories ?? [],
-        tagNames: [],
+        ribbonNames: [],
         attributes: (attributes ?? []).map((a: any) => ({ code: a.code, options: a.options ?? [] })),
         defaultOptions: Object.fromEntries((default_attributes ?? []).map((d: any) => [d.code, d.option])),
         variations: (variations ?? []).map((v: any) => {
@@ -450,7 +500,7 @@ export function sampleCatalog(): CatalogSpec {
       };
     }),
     coupons: SAMPLE_COUPONS,
-    tax_rates: SAMPLE_TAX_RATES,
+    locations: [],
   };
 }
 
@@ -479,7 +529,7 @@ export async function seedCatalog(
   };
   const counts = {
     categories: { created: 0, reused: 0 },
-    tags: { created: 0, reused: 0 },
+    ribbons: { created: 0, reused: 0 },
     attributes: { created: 0, reused: 0 },
     terms: { created: 0, reused: 0 },
   };
@@ -526,20 +576,20 @@ export async function seedCatalog(
       }
     }
 
-    let allTags: any[] | null = null;
-    const tagByLower: Record<string, any> = {};
-    const resolveTag = async (tagName: string) => {
-      const key = tagName.toLowerCase();
-      if (tagByLower[key]) return tagByLower[key];
-      allTags ??= await scanAll(sr.entities["commerce.ProductTag"], null, "name");
-      let tag = allTags!.find((t: any) => String(t.name ?? "").toLowerCase() === key);
-      if (tag) counts.tags.reused++;
+    let allRibbons: any[] | null = null;
+    const ribbonByLower: Record<string, any> = {};
+    const resolveRibbon = async (ribbonName: string) => {
+      const key = ribbonName.toLowerCase();
+      if (ribbonByLower[key]) return ribbonByLower[key];
+      allRibbons ??= await scanAll(sr.entities["commerce.ProductRibbon"], null, "name");
+      let ribbon = allRibbons!.find((t: any) => String(t.name ?? "").toLowerCase() === key);
+      if (ribbon) counts.ribbons.reused++;
       else {
-        tag = await track("commerce.ProductTag", { name: tagName, count: 0 });
-        counts.tags.created++;
+        ribbon = await track("commerce.ProductRibbon", { name: ribbonName, count: 0 });
+        counts.ribbons.created++;
       }
-      tagByLower[key] = tag;
-      return tag;
+      ribbonByLower[key] = ribbon;
+      return ribbon;
     };
 
     let allAttributes: any[] | null = null;
@@ -580,9 +630,9 @@ export async function seedCatalog(
 
     // ── products + variations ──────────────────────────────────────────────
     const results: Array<Record<string, any>> = [];
-    const countDeltas = new Map<string, number>(); // "entityid" → +n
+    const countDeltas = new Map<string, number>(); // "entity|id" → +n
     const bumpLater = (entity: string, id: string) => {
-      const key = `${entity}${id}`;
+      const key = `${entity}|${id}`;
       countDeltas.set(key, (countDeltas.get(key) ?? 0) + 1);
     };
     let variationsCreated = 0;
@@ -594,13 +644,13 @@ export async function seedCatalog(
       }
       const record: any = {
         status: "publish",
-        tag_ids: [],
+        ribbon_ids: [],
         meta_data: [],
         total_sales: 0,
         ...p.fields,
         category_ids: p.categorySlugs.map((slug) => categoryBySlug[slug]?.id).filter(Boolean),
       };
-      for (const tagName of p.tagNames) record.tag_ids = [...record.tag_ids, (await resolveTag(tagName)).id];
+      for (const ribbonName of p.ribbonNames) record.ribbon_ids = [...record.ribbon_ids, (await resolveRibbon(ribbonName)).id];
       record.slug = await ensureUniqueSlug(sr, slugify(record.slug || record.name));
       if (record.manage_stock === undefined && record.stock_quantity != null) record.manage_stock = true;
 
@@ -657,14 +707,14 @@ export async function seedCatalog(
       if (seededVariations.length) await rollUpParent(sr, product, seededVariations);
 
       for (const id of record.category_ids) bumpLater("commerce.ProductCategory", id);
-      for (const id of record.tag_ids) bumpLater("commerce.ProductTag", id);
+      for (const id of record.ribbon_ids) bumpLater("commerce.ProductRibbon", id);
       results.push({ name: product.name, id: product.id, slug: product.slug, sku: product.sku ?? "", variation_count: seededVariations.length });
     }
 
     // deferred so a mid-creation rollback never leaves counts drifted;
     // a failure from here on is count-only and recount-terms repairs it
     for (const [key, delta] of countDeltas) {
-      const [entity, id] = key.split("");
+      const [entity, id] = key.split("|");
       await bumpCount(sr, entity, id, delta);
     }
 
@@ -681,27 +731,27 @@ export async function seedCatalog(
       couponCounts.created++;
     }
 
-    const taxCounts = { created: 0, skipped: 0 };
-    for (const r of spec.tax_rates) {
-      const hits = (await sr.entities["commerce.TaxRate"].filter({ country: r.country, name: r.name }, undefined, 5)) ?? [];
-      if (hits.some((h: any) => String(h.state ?? "") === String(r.state ?? ""))) {
-        taxCounts.skipped++;
+    const locationCounts = { created: 0, skipped: 0 };
+    for (const loc of spec.locations) {
+      const hits = (await sr.entities["commerce.ShippingTaxLocation"].filter({ name: loc.name }, undefined, 1)) ?? [];
+      if (hits.length) {
+        locationCounts.skipped++;
         continue;
       }
-      await track("commerce.TaxRate", { state: "", postcodes: [], cities: [], priority: 1, compound: false, shipping: true, tax_class: "standard", menu_order: 0, ...r });
-      taxCounts.created++;
+      await track("commerce.ShippingTaxLocation", loc);
+      locationCounts.created++;
     }
 
     return {
       categories: counts.categories,
-      tags: counts.tags,
+      ribbons: counts.ribbons,
       attributes: counts.attributes,
       terms: counts.terms,
       products_created: results.filter((r) => !r.skipped).length,
       products_skipped: results.filter((r) => r.skipped).length,
       variations_created: variationsCreated,
       coupons: couponCounts,
-      tax_rates: taxCounts,
+      locations: locationCounts,
       products: results,
     };
   } catch (e) {

package/base44/functions/commerce/storefront-cart/cart-pricing.ts

@@ -36,20 +36,16 @@ export async function loadCart(sr: any, cartToken: string | undefined): Promise<
 
 export interface PricingData {
   settings: Record<string, any>;
-  taxRates: any[];
-  zones: any[];
-  zoneMethods: any[];
+  locations: any[];
 }
 
 /** One round of catalog-config reads shared by every priced response. */
 export async function loadPricingData(sr: any): Promise<PricingData> {
-  const [settings, taxRates, zones, zoneMethods] = await Promise.all([
+  const [settings, locations] = await Promise.all([
     getSettings(sr),
-    scanAll(sr.entities["commerce.TaxRate"], {}, "menu_order", 2000),
-    scanAll(sr.entities["commerce.ShippingZone"], {}, "order", 500),
-    scanAll(sr.entities["commerce.ShippingZoneMethod"], {}, "order", 1000),
+    scanAll(sr.entities["commerce.ShippingTaxLocation"], {}, "order", 500),
   ]);
-  return { settings, taxRates, zones, zoneMethods };
+  return { settings, locations };
 }
 
 export interface ResolvedItem {
@@ -179,9 +175,7 @@ export async function priceCart(sr: any, cart: any, opts: { pricingData?: Pricin
     shipping_address: cart.shipping_address,
     chosenShippingMethodId: chosenShippingMethodId || undefined,
     settings,
-    taxRates: pricingData.taxRates,
-    zones: pricingData.zones,
-    zoneMethods: pricingData.zoneMethods,
+    locations: pricingData.locations,
   });
 
   let totals = priceWith(cart.chosen_shipping_method);
@@ -196,6 +190,7 @@ export async function priceCart(sr: any, cart: any, opts: { pricingData?: Pricin
     shippingEnabled: getSetting(settings, "shipping", "enable_shipping", true) !== false,
     chosenMethodId: cart.chosen_shipping_method,
     available: totals.available_shipping_methods,
+    hasAddress: !!cart.shipping_address?.country,
   });
   if (shippingSelection.method_id !== (cart.chosen_shipping_method || "")) {
     cart.chosen_shipping_method = shippingSelection.method_id;