@fayz-ai/shop 0.10.0 → 0.11.0

package/dist/{chunk-U3O2I3RM.js → chunk-U6HV3LVP.js}

@@ -1,8 +1,192 @@
 import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS, MOCK_VARIANTS } from './chunk-IKNGCRUM.js';
-import { resolveEntityStore, createMockEntityStore, validateSidecarWrite } from './chunk-XOP6SHPB.js';
+import { resolveEntityStore, createMockEntityStore } from './chunk-NWW3WJ7Y.js';
 import { buildRuleContext, computePromotionActions, discountToPromotion } from './chunk-3GERSY5F.js';
 import { resolveEntityDeclaration } from '@fayz-ai/core';
 
+// src/data/media.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "bmp"]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "mov", "webm", "m4v", "avi", "mkv"]);
+function mediaKindOf(name, mime) {
+  if (mime?.startsWith("image/")) return "image";
+  if (mime?.startsWith("video/")) return "video";
+  const ext = (name.split(".").pop() ?? "").toLowerCase();
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return "document";
+}
+function storagePathOf(url) {
+  const match = /\/object\/(?:public|sign|authenticated)\/[^/]+\/([^?]+)/.exec(url);
+  if (!match) return null;
+  try {
+    return decodeURIComponent(match[1]);
+  } catch {
+    return match[1];
+  }
+}
+function displayNameOf(path) {
+  const base = path.split("/").pop() ?? path;
+  return base.replace(/^\d{10,}-/, "");
+}
+function productImageToMediaFile(image, productName) {
+  const path = storagePathOf(image.url);
+  const name = displayNameOf(path ?? image.url);
+  return {
+    // Fall back to the URL as identity: an image row that points outside our
+    // bucket still belongs in the library, it just cannot be deleted by path.
+    id: path ?? image.url,
+    name,
+    url: image.url,
+    kind: mediaKindOf(name),
+    size: 0,
+    extension: (name.split(".").pop() ?? "").toUpperCase(),
+    createdAt: image.createdAt ?? "",
+    reference: {
+      type: "product",
+      id: image.productId,
+      label: productName?.trim() || "Produto sem nome",
+      attachmentId: image.id,
+      isCover: image.isPrimary
+    }
+  };
+}
+function mergeMediaFiles(attached, library) {
+  const seen = new Set(attached.map((f) => f.id));
+  return [...attached, ...library.filter((f) => !seen.has(f.id))].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+// src/lib/variant-matrix.ts
+var MAX_VARIANT_AXES = 3;
+var MAX_VARIANT_COMBINATIONS = 100;
+function variantOptionsKey(options) {
+  return JSON.stringify(
+    Object.keys(options).sort().map((key) => [key, options[key]])
+  );
+}
+function normalizeVariantAxes(axes) {
+  const seenNames = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const axis of axes) {
+    const name = axis.name.trim();
+    if (!name || seenNames.has(name)) continue;
+    const values = [];
+    const seenValues = /* @__PURE__ */ new Set();
+    for (const raw of axis.values) {
+      const value = raw.trim();
+      if (!value || seenValues.has(value)) continue;
+      seenValues.add(value);
+      values.push(value);
+    }
+    if (values.length === 0) continue;
+    seenNames.add(name);
+    result.push({ name, values });
+  }
+  return result;
+}
+function variantCombinations(axes) {
+  const clean = normalizeVariantAxes(axes);
+  if (clean.length === 0) return [];
+  let rows = [{}];
+  for (const axis of clean) {
+    const next = [];
+    for (const row of rows) {
+      for (const value of axis.values) next.push({ ...row, [axis.name]: value });
+    }
+    rows = next;
+  }
+  return rows;
+}
+function validateVariantAxes(axes) {
+  const clean = normalizeVariantAxes(axes);
+  if (clean.length > MAX_VARIANT_AXES) {
+    return `Um produto aceita no m\xE1ximo ${MAX_VARIANT_AXES} op\xE7\xF5es (ex.: Tamanho, Cor, Material).`;
+  }
+  const total = clean.reduce((acc, axis) => acc * axis.values.length, 1);
+  if (clean.length > 0 && total > MAX_VARIANT_COMBINATIONS) {
+    return `Essas op\xE7\xF5es gerariam ${total} variantes, e o limite \xE9 ${MAX_VARIANT_COMBINATIONS}. Reduza os valores ou separe em dois produtos.`;
+  }
+  return null;
+}
+function planVariantMatrix(axes, existing) {
+  const wanted = variantCombinations(axes);
+  const wantedKeys = new Set(wanted.map(variantOptionsKey));
+  const byKey = /* @__PURE__ */ new Map();
+  let defaultVariant = null;
+  for (const variant of existing) {
+    if (variant.isDefaultVariant) {
+      defaultVariant = variant;
+      continue;
+    }
+    byKey.set(variantOptionsKey(variant.options), variant);
+  }
+  const plan = {
+    rows: [],
+    create: [],
+    reactivate: [],
+    keep: [],
+    archive: [],
+    defaultVariant
+  };
+  for (const [position, options] of wanted.entries()) {
+    const variant = byKey.get(variantOptionsKey(options)) ?? null;
+    const row = { options, position, variant };
+    plan.rows.push(row);
+    if (!variant) plan.create.push(row);
+    else if (variant.status === "archived") plan.reactivate.push(row);
+    else plan.keep.push(row);
+  }
+  for (const [key, variant] of byKey) {
+    if (!wantedKeys.has(key) && variant.status === "active") plan.archive.push(variant);
+  }
+  return plan;
+}
+function hasOnlyDefaultVariant(variants) {
+  const active = variants.filter((variant) => variant.status === "active");
+  return active.length === 1 && Boolean(active[0].isDefaultVariant);
+}
+function leavesNothingSellable(plan) {
+  const willHaveReal = plan.keep.length + plan.reactivate.length + plan.create.length;
+  return willHaveReal === 0 && plan.defaultVariant === null;
+}
+function axesFromOptions(options) {
+  return [...options].sort((a, b) => a.position - b.position).map((option) => ({ name: option.name, values: [...option.values] }));
+}
+async function applyVariantMatrix(provider, productId, axes, existing) {
+  const refusal = validateVariantAxes(axes);
+  if (refusal) throw new Error(refusal);
+  if (!provider.saveProductOptions || !provider.createProductVariant || !provider.updateProductVariant) {
+    throw new Error("Este provider n\xE3o administra variantes.");
+  }
+  const clean = normalizeVariantAxes(axes);
+  const plan = planVariantMatrix(clean, existing);
+  await provider.saveProductOptions(productId, clean);
+  for (const row of plan.create) {
+    await provider.createProductVariant(productId, { options: row.options, position: row.position });
+  }
+  for (const row of plan.reactivate) {
+    await provider.updateProductVariant(row.variant.id, { status: "active", position: row.position });
+  }
+  for (const row of plan.keep) {
+    if (row.variant.position !== row.position) {
+      await provider.updateProductVariant(row.variant.id, { position: row.position });
+    }
+  }
+  for (const variant of plan.archive) {
+    await (provider.archiveProductVariant?.(variant.id) ?? provider.updateProductVariant(variant.id, { status: "archived" }));
+  }
+  const real = plan.create.length + plan.reactivate.length + plan.keep.length;
+  if (plan.defaultVariant) {
+    if (real > 0 && plan.defaultVariant.status === "active") {
+      await provider.updateProductVariant(plan.defaultVariant.id, { status: "archived" });
+    } else if (real === 0 && plan.defaultVariant.status === "archived") {
+      await provider.updateProductVariant(plan.defaultVariant.id, { status: "active" });
+    }
+  }
+  return plan;
+}
+function formatVariantCombination(options, axes) {
+  const order = axes?.map((axis) => axis.name) ?? Object.keys(options).sort();
+  return order.filter((name) => options[name] != null).map((name) => `${name}: ${options[name]}`).join(" \xB7 ");
+}
 function uid() {
   return Math.random().toString(36).slice(2);
 }
@@ -13,6 +197,8 @@ var ORDERS_KEY = "fayz.shop.mock.orders.v1";
 var CUSTOMERS_KEY = "fayz.shop.mock.customers.v1";
 var ENQUIRIES_KEY = "fayz.shop.mock.enquiries.v1";
 var CHANNELS_KEY = "fayz.shop.mock.channels.v1";
+var SETTINGS_KEY = "fayz.shop.mock.settings.v1";
+var SHIPPING_SETTINGS_KEY = "fayz.shop.mock.shipping-settings.v1";
 var DEFAULT_CHANNELS = [
   { id: "online-store", tenantId: "mock", kind: "online_store", label: "Loja Online", url: null, enabled: true, position: 0, createdAt: now(), updatedAt: now() }
 ];
@@ -61,7 +247,15 @@ var MockShopProvider = class {
       return stored.length ? stored : DEFAULT_CHANNELS.map((c) => ({ ...c }));
     })();
     this.entityStores = /* @__PURE__ */ new Map();
-    this.sidecars = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // Checkout sessions
+    //
+    // Mirrors the live inversion: the session holds the cart, and the ORDER is
+    // only written when the settle says the money is in. Here the "provider" is a
+    // clock — the second poll pays — which is what lets the four-step checkout be
+    // walked end to end without an acquirer, in demo stores and in the e2e suite.
+    // ---------------------------------------------------------------------------
+    this.checkoutSessions = {};
     this.products = (seed?.products ?? MOCK_PRODUCTS).map((p) => ({ ...p }));
     this.categories = (seed?.categories ?? MOCK_CATEGORIES).map((c) => ({ ...c }));
     this.discounts = (seed?.discounts ?? MOCK_DISCOUNTS).map((d) => ({ ...d }));
@@ -73,9 +267,6 @@ var MockShopProvider = class {
     );
     this.promotions = (seed?.promotions ?? []).map((p) => ({ ...p }));
     this.entitySeed = seed?.entities ?? {};
-    for (const [key, fields] of Object.entries(seed?.entityFields ?? {})) {
-      this.sidecars.set(key, { ...fields });
-    }
   }
   /** The I5 indirection: a promoted (registered) store wins; otherwise the
    *  entity gets a lazily-built in-memory store seeded from the mock seed.
@@ -162,16 +353,107 @@ var MockShopProvider = class {
   }
   /** Option axes + variants (spine M5) — active variants only, like the 0028
    *  storefront RLS. Answers empty sets for a variantless product. */
-  async getProductVariants(productId) {
+  async getProductVariants(productId, opts) {
     const set = this.variantSets[productId];
     if (!set) return { options: [], variants: [] };
     return {
       options: set.options.map((o) => ({ ...o, values: [...o.values] })).sort((a, b) => a.position - b.position),
-      variants: set.variants.filter((v) => v.status === "active").map((v) => ({ ...v, options: { ...v.options } })).sort((a, b) => a.position - b.position)
+      variants: set.variants.filter((v) => opts?.includeArchived || v.status === "active").map((v) => ({ ...v, options: { ...v.options } })).sort((a, b) => a.position - b.position)
     };
   }
+  // --- The variant admin ------------------------------------------------------
+  // Modelled on the SQL rather than on convenience: 0028's UNIQUE
+  // (product_id, options), 0037's default-variant triggers and 0036's mirror all
+  // have a counterpart here, so a test that passes against this mock is
+  // asserting the real semantics and not a friendlier imitation of them.
+  variantSet(productId) {
+    var _a;
+    (_a = this.variantSets)[productId] ?? (_a[productId] = { options: [], variants: [] });
+    return this.variantSets[productId];
+  }
+  async saveProductOptions(productId, input) {
+    const set = this.variantSet(productId);
+    const existing = new Map(set.options.map((o) => [o.name, o]));
+    set.options = input.map((axis, position) => ({
+      id: existing.get(axis.name)?.id ?? uid(),
+      name: axis.name,
+      values: [...axis.values],
+      position
+    }));
+    return set.options.map((o) => ({ ...o, values: [...o.values] }));
+  }
+  async createProductVariant(productId, input) {
+    const set = this.variantSet(productId);
+    const key = variantOptionsKey(input.options);
+    const existing = set.variants.find((v) => variantOptionsKey(v.options) === key);
+    if (existing) return this.updateProductVariant(existing.id, { ...input, status: input.status ?? "active" });
+    const variant = {
+      id: uid(),
+      productId,
+      options: { ...input.options },
+      sku: input.sku ?? null,
+      price: input.price ?? null,
+      compareAtPrice: input.compareAtPrice ?? null,
+      inventoryCount: 0,
+      position: input.position ?? set.variants.length,
+      status: input.status ?? "active",
+      imageId: input.imageId ?? null,
+      isDefaultVariant: false,
+      weight: input.weight ?? null,
+      weightUnit: input.weightUnit ?? null,
+      heightCm: input.heightCm ?? null,
+      widthCm: input.widthCm ?? null,
+      lengthCm: input.lengthCm ?? null
+    };
+    set.variants.push(variant);
+    for (const other of set.variants) {
+      if (other.isDefaultVariant && other.status === "active") other.status = "archived";
+    }
+    this.syncProductFromVariants(productId);
+    return { ...variant, options: { ...variant.options } };
+  }
+  async updateProductVariant(variantId, input) {
+    for (const [productId, set] of Object.entries(this.variantSets)) {
+      const variant = set.variants.find((v) => v.id === variantId);
+      if (!variant) continue;
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== void 0) variant[key] = value;
+      }
+      this.syncProductFromVariants(productId);
+      return { ...variant, options: { ...variant.options } };
+    }
+    throw new Error("Variant not found");
+  }
+  async archiveProductVariant(variantId) {
+    await this.updateProductVariant(variantId, { status: "archived" });
+  }
+  /**
+   * The 0034→0036 path, compressed: the merchant states a count, the difference
+   * is what gets recorded, and inventory_count is the mirror that follows. The
+   * ledger itself is MockStockStore's business — what matters here is that no
+   * caller ever assigns to inventoryCount.
+   */
+  async setVariantStock(variantId, count) {
+    const target = Math.max(0, Math.trunc(count));
+    for (const [productId, set] of Object.entries(this.variantSets)) {
+      const variant = set.variants.find((v) => v.id === variantId);
+      if (!variant) continue;
+      variant.inventoryCount = target;
+      this.syncProductFromVariants(productId);
+      return target;
+    }
+    throw new Error("Variant not found");
+  }
+  /** 0028's sync trigger: the product row is the SUM of active variant stock. */
+  syncProductFromVariants(productId) {
+    const product = this.products.find((p) => p.id === productId);
+    const set = this.variantSets[productId];
+    if (!product || !set) return;
+    const active = set.variants.filter((v) => v.status === "active");
+    product.inventoryCount = active.reduce((sum, v) => sum + v.inventoryCount, 0);
+  }
   async createProduct(input) {
-    const p = { id: uid(), tenantId: "mock", name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, "-"), description: input.description ?? null, price: input.price, compareAtPrice: input.compareAtPrice ?? null, currency: input.currency ?? "BRL", status: input.status ?? "active", inventoryCount: input.inventoryCount ?? 0, sku: input.sku ?? null, sortOrder: input.sortOrder ?? 0, metadata: input.metadata ?? {}, images: [], categoryId: input.categoryId ?? null, categoryName: null, isPhysical: input.isPhysical ?? true, weight: input.weight ?? null, weightUnit: input.weightUnit ?? "kg", createdAt: now(), updatedAt: now() };
+    const p = { id: uid(), tenantId: "mock", name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, "-"), description: input.description ?? null, price: input.price, compareAtPrice: input.compareAtPrice ?? null, currency: input.currency ?? "BRL", status: input.status ?? "active", inventoryCount: input.inventoryCount ?? 0, sku: input.sku ?? null, sortOrder: input.sortOrder ?? 0, metadata: input.metadata ?? {}, images: [], categoryId: input.categoryId ?? null, categoryName: null, isPhysical: input.isPhysical ?? true, weight: input.weight ?? null, weightUnit: input.weightUnit ?? "kg", handling: input.handling ?? [], createdAt: now(), updatedAt: now() };
     this.products.push(p);
     return p;
   }
@@ -187,7 +469,15 @@ var MockShopProvider = class {
   async uploadProductImage(_productId, _file) {
     throw new Error("Image upload not available in mock mode");
   }
-  async deleteProductImage(_imageId) {
+  async deleteProductImage(imageId) {
+    this.products = this.products.map((p) => p.images.some((i) => i.id === imageId) ? { ...p, images: p.images.filter((i) => i.id !== imageId) } : p);
+  }
+  /** The media library, mock-side: no bucket to walk, so the catalogue's own
+   *  photos ARE the library. Uploading has nowhere to go, which is why
+   *  uploadMediaFile stays unimplemented and the screen hides its button. */
+  async listMediaFiles() {
+    const attached = this.products.flatMap((p) => p.images.map((image) => productImageToMediaFile(image, p.name)));
+    return mergeMediaFiles(attached, []);
   }
   async createProductEnquiry(input) {
     this.syncEnquiries();
@@ -458,6 +748,45 @@ var MockShopProvider = class {
     }
     return order;
   }
+  async openCheckoutSession(input) {
+    const sessionId = uid();
+    this.checkoutSessions[sessionId] = { input, polls: 0 };
+    let total = 0;
+    for (const line of input.items) {
+      const product = this.products.find((p) => p.id === line.productId);
+      if (!product) continue;
+      const variant = line.variantId ? this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId) : void 0;
+      total += (variant?.price ?? product.price) * line.quantity;
+    }
+    return {
+      sessionId,
+      total: Math.round(total * 100) / 100,
+      state: "open",
+      charge: {
+        // Shaped like a real EMV payload so the copy button and the layout are
+        // exercised, not a placeholder that fits in one line.
+        emv: `00020126580014BR.GOV.BCB.PIX0136${sessionId}520400005303986540${total.toFixed(2)}5802BR6304MOCK`,
+        qrcodeBase64: null,
+        expiresAt: new Date(Date.now() + 30 * 6e4).toISOString()
+      }
+    };
+  }
+  async settleCheckoutSession(sessionId) {
+    const session = this.checkoutSessions[sessionId];
+    if (!session) return { state: "expired", reason: "Sess\xE3o de checkout n\xE3o encontrada." };
+    if (session.orderId) return { state: "paid", orderId: session.orderId };
+    session.polls += 1;
+    if (session.polls < 2) return { state: "open" };
+    const order = await this.placeOrder({
+      items: session.input.items,
+      customer: session.input.customer,
+      discountCode: session.input.discountCode ?? void 0,
+      shippingAddress: session.input.shippingAddress
+    });
+    await this.updateOrder(order.id, { financialStatus: "paid" });
+    session.orderId = order.id;
+    return { state: "paid", orderId: order.id };
+  }
   // ---------------------------------------------------------------------------
   // Customers
   // ---------------------------------------------------------------------------
@@ -474,7 +803,7 @@ var MockShopProvider = class {
   }
   async createCustomer(input) {
     this.syncCustomers();
-    const c = { id: uid(), tenantId: "mock", firstName: input.firstName, lastName: input.lastName ?? "", email: input.email ?? null, phone: input.phone ?? null, notes: input.notes ?? null, ordersCount: 0, totalSpent: 0, createdAt: now(), updatedAt: now() };
+    const c = { id: uid(), tenantId: "mock", firstName: input.firstName, lastName: input.lastName ?? "", email: input.email ?? null, phone: input.phone ?? null, document: input.document ?? null, notes: input.notes ?? null, ordersCount: 0, totalSpent: 0, createdAt: now(), updatedAt: now() };
     this.customers.push(c);
     this.persistCustomers();
     return c;
@@ -570,6 +899,49 @@ var MockShopProvider = class {
     this.persistChannels();
   }
   // ---------------------------------------------------------------------------
+  // Store policy + delivery fallback
+  //
+  // A single object behind a list-shaped store helper, so the same loadStored /
+  // store pair serves it. Absent = null, NOT an object of defaults: "nothing
+  // decided" is a state the callers are written to handle, and manufacturing
+  // defaults here would hide the one case the live provider really has.
+  // ---------------------------------------------------------------------------
+  async getStoreSettings() {
+    return loadStored(SETTINGS_KEY)[0] ?? null;
+  }
+  async updateStoreSettings(input) {
+    const next = { ...await this.getStoreSettings() ?? {}, ...input };
+    store(SETTINGS_KEY, [next]);
+    return next;
+  }
+  /** In mock mode there is no publication gate to fail, so the shopper's read
+   *  and the merchant's are the same row. */
+  async getPublicStoreSettings() {
+    return this.getStoreSettings();
+  }
+  /**
+   * Mock mode has no delivery zones at all, so nothing is refused and no zone is
+   * the store's own. Answered rather than omitted so a screen developed against
+   * the mock sees the same shape it will see live — an absent method would make
+   * the caller take its "provider cannot check" branch and never exercise this.
+   */
+  async checkDelivery() {
+    return { refused: false, ownZone: false };
+  }
+  async getShippingSettings() {
+    return loadStored(SHIPPING_SETTINGS_KEY)[0] ?? null;
+  }
+  async updateShippingSettings(input) {
+    const current = await this.getShippingSettings();
+    const next = {
+      flatRate: input.flatRate ?? current?.flatRate ?? 0,
+      freeAbove: input.freeAbove !== void 0 ? input.freeAbove : current?.freeAbove ?? null,
+      currency: input.currency ?? current?.currency ?? "BRL"
+    };
+    store(SHIPPING_SETTINGS_KEY, [next]);
+    return next;
+  }
+  // ---------------------------------------------------------------------------
   // Custom entities (spine M4) — same EntityStore port as the live provider.
   // ---------------------------------------------------------------------------
   async listEntityRecords(entity, options) {
@@ -590,16 +962,6 @@ var MockShopProvider = class {
   async deleteEntityRecord(entity, id) {
     return this.entityStore(entity).delete(id);
   }
-  // Sidecar fields on core records — validated against defineSidecarFields.
-  async getEntityFields(reference, referenceId) {
-    return this.sidecars.get(`${reference}:${referenceId}`) ?? null;
-  }
-  async setEntityFields(reference, referenceId, fields) {
-    validateSidecarWrite(reference, fields);
-    const stored = { ...fields };
-    this.sidecars.set(`${reference}:${referenceId}`, stored);
-    return stored;
-  }
   // Coleções, grupos/segmentos, vale-presente e e-mails — paridade com o
   // provider Supabase. Mídia não entra: é storage, não tem mock honesto.
   async listCollections() {
@@ -803,6 +1165,6 @@ function createMockShopProvider(seed) {
   return new MockShopProvider(seed);
 }
 
-export { MockShopProvider, createMockShopProvider };
-//# sourceMappingURL=chunk-U3O2I3RM.js.map
-//# sourceMappingURL=chunk-U3O2I3RM.js.map
+export { MAX_VARIANT_AXES, MAX_VARIANT_COMBINATIONS, MockShopProvider, applyVariantMatrix, axesFromOptions, createMockShopProvider, displayNameOf, formatVariantCombination, hasOnlyDefaultVariant, leavesNothingSellable, mediaKindOf, mergeMediaFiles, normalizeVariantAxes, planVariantMatrix, productImageToMediaFile, storagePathOf, validateVariantAxes, variantCombinations, variantOptionsKey };
+//# sourceMappingURL=chunk-U6HV3LVP.js.map
+//# sourceMappingURL=chunk-U6HV3LVP.js.map