@fayz-ai/shop 0.9.0-next.1 → 0.10.0

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

@@ -1,6 +1,8 @@
-import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS } from './chunk-CTKZ6O2J.js';
+import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS, MOCK_VARIANTS } from './chunk-IKNGCRUM.js';
+import { resolveEntityStore, createMockEntityStore, validateSidecarWrite } from './chunk-XOP6SHPB.js';
+import { buildRuleContext, computePromotionActions, discountToPromotion } from './chunk-3GERSY5F.js';
+import { resolveEntityDeclaration } from '@fayz-ai/core';
 
-// src/mock-provider.ts
 function uid() {
   return Math.random().toString(36).slice(2);
 }
@@ -30,8 +32,27 @@ function store(key, value) {
   } catch {
   }
 }
+var COLLECTIONS_KEY = "fayz.shop.mock.collections.v1";
+var GIFT_CARDS_KEY = "fayz.shop.mock.gift-cards.v1";
+var EMAIL_TEMPLATES_KEY = "fayz.shop.mock.email-templates.v1";
+var CUSTOMER_GROUPS_KEY = "fayz.shop.mock.customer-groups.v1";
+var CUSTOMER_SEGMENTS_KEY = "fayz.shop.mock.customer-segments.v1";
+function mockGiftCardCode() {
+  const alphabet = "ABCDEFGHJKLMNPQRTUVWXY2346789";
+  const pick = () => alphabet[Math.floor(Math.random() * alphabet.length)];
+  const block = () => Array.from({ length: 4 }, pick).join("");
+  return `${block()}-${block()}-${block()}`;
+}
+function mockSlugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
 var MockShopProvider = class {
   constructor(seed) {
+    this.collections = loadStored(COLLECTIONS_KEY);
+    this.giftCards = loadStored(GIFT_CARDS_KEY);
+    this.emailTemplates = loadStored(EMAIL_TEMPLATES_KEY);
+    this.customerGroups = loadStored(CUSTOMER_GROUPS_KEY);
+    this.customerSegments = loadStored(CUSTOMER_SEGMENTS_KEY);
     this.orders = loadStored(ORDERS_KEY);
     this.customers = loadStored(CUSTOMERS_KEY);
     this.enquiries = loadStored(ENQUIRIES_KEY);
@@ -39,9 +60,37 @@ var MockShopProvider = class {
       const stored = loadStored(CHANNELS_KEY);
       return stored.length ? stored : DEFAULT_CHANNELS.map((c) => ({ ...c }));
     })();
+    this.entityStores = /* @__PURE__ */ new Map();
+    this.sidecars = /* @__PURE__ */ new Map();
     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 }));
+    this.variantSets = Object.fromEntries(
+      Object.entries(seed?.variants ?? (seed?.products ? {} : MOCK_VARIANTS)).map(([productId, set]) => [
+        productId,
+        { options: set.options.map((o) => ({ ...o, values: [...o.values] })), variants: set.variants.map((v) => ({ ...v, options: { ...v.options } })) }
+      ])
+    );
+    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.
+   *  Lazy on purpose — the seed is validated against the declaration, which
+   *  the app may register after constructing the provider. */
+  entityStore(entity) {
+    resolveEntityDeclaration(entity);
+    return resolveEntityStore(entity, (key) => {
+      let store2 = this.entityStores.get(key);
+      if (!store2) {
+        store2 = createMockEntityStore(key, { seed: this.entitySeed[key] });
+        this.entityStores.set(key, store2);
+      }
+      return store2;
+    });
   }
   // Re-read before mutating: HMR can re-instantiate the provider mid-session
   // and a stale in-memory copy must not clobber persisted records.
@@ -86,18 +135,24 @@ var MockShopProvider = class {
     }
     const orderBy = opts?.orderBy ?? "sort_order";
     const dir = opts?.order === "desc" ? -1 : 1;
-    list.sort((a, b) => {
-      switch (orderBy) {
-        case "name":
-          return a.name.localeCompare(b.name) * dir;
-        case "price":
-          return (a.price - b.price) * dir;
-        case "created_at":
-          return a.createdAt.localeCompare(b.createdAt) * dir;
-        default:
-          return (a.sortOrder - b.sortOrder) * dir;
-      }
-    });
+    if (opts?.search && !opts.orderBy) {
+      const q = opts.search.toLowerCase();
+      const rank = (p) => p.name.toLowerCase().startsWith(q) ? 0 : p.name.toLowerCase().includes(q) ? 1 : 2;
+      list.sort((a, b) => rank(a) - rank(b) || a.sortOrder - b.sortOrder);
+    } else {
+      list.sort((a, b) => {
+        switch (orderBy) {
+          case "name":
+            return a.name.localeCompare(b.name) * dir;
+          case "price":
+            return (a.price - b.price) * dir;
+          case "created_at":
+            return a.createdAt.localeCompare(b.createdAt) * dir;
+          default:
+            return (a.sortOrder - b.sortOrder) * dir;
+        }
+      });
+    }
     const offset = opts?.offset ?? 0;
     if (offset || opts?.limit) list = list.slice(offset, opts?.limit ? offset + opts.limit : void 0);
     return list;
@@ -105,6 +160,16 @@ var MockShopProvider = class {
   async getProduct(id) {
     return this.products.find((p) => p.id === id) ?? null;
   }
+  /** Option axes + variants (spine M5) — active variants only, like the 0028
+   *  storefront RLS. Answers empty sets for a variantless product. */
+  async getProductVariants(productId) {
+    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)
+    };
+  }
   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() };
     this.products.push(p);
@@ -258,8 +323,9 @@ var MockShopProvider = class {
     return this.orders[i];
   }
   // Trusted placement (mock parity with the shop_place_order RPC): re-reads
-  // prices + stock from the catalog, validates the discount, decrements
-  // inventory. The browser-supplied prices are never used.
+  // prices + stock from the catalog, EVALUATES THE DECLARED PROMOTIONS through
+  // the rule engine, validates the legacy discount code, decrements inventory.
+  // The browser-supplied prices and totals are never used.
   async placeOrder(input) {
     this.syncOrders();
     this.syncCustomers();
@@ -279,22 +345,74 @@ var MockShopProvider = class {
     }
     const items = [];
     const lineDetails = [];
+    const snapshotItems = [];
     let subtotal = 0;
-    for (const line of input.items) {
+    for (const [index, line] of input.items.entries()) {
       const product = this.products.find((p) => p.id === line.productId);
       if (!product || product.status !== "active") throw new Error(`Product unavailable: ${line.productId}`);
-      if (product.inventoryCount < line.quantity) throw new Error(`Insufficient stock for ${product.name}`);
-      const name = line.optionsLabel ? `${product.name} (${line.optionsLabel})` : product.name;
-      const lineTotal = product.price * line.quantity;
+      let variant;
+      if (line.variantId) {
+        variant = this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId && v.status === "active");
+        if (!variant) throw new Error(`Variant unavailable: ${line.variantId}`);
+        if (variant.inventoryCount < line.quantity) throw new Error(`Insufficient stock for ${product.name}`);
+      } else if (product.inventoryCount < line.quantity) {
+        throw new Error(`Insufficient stock for ${product.name}`);
+      }
+      const unitPrice = variant?.price ?? product.price;
+      const label = line.optionsLabel || (variant ? Object.entries(variant.options).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join(" \xB7 ") : "");
+      const name = label ? `${product.name} (${label})` : product.name;
+      const lineTotal = unitPrice * line.quantity;
       subtotal += lineTotal;
       lineDetails.push({ productId: product.id, categoryId: product.categoryId, lineTotal });
-      items.push({ productId: product.id, name, sku: product.sku ?? void 0, quantity: line.quantity, unitPrice: product.price, imageUrl: product.images[0]?.url });
+      snapshotItems.push({
+        id: `${index}:${line.variantId ?? product.id}`,
+        productId: product.id,
+        quantity: line.quantity,
+        unitPrice,
+        categoryId: product.categoryId,
+        collectionId: typeof product.metadata?.collection === "string" ? product.metadata.collection : null
+      });
+      items.push({ productId: product.id, name, sku: variant?.sku ?? product.sku ?? void 0, quantity: line.quantity, unitPrice, imageUrl: product.images[0]?.url });
     }
     subtotal = Math.round(subtotal * 100) / 100;
     let shippingTotal = Math.max(input.shippingTotal ?? 0, 0);
     let discountTotal = 0;
     let appliedCode = null;
-    if (input.discountCode) {
+    const entered = input.discountCode ? [input.discountCode.trim()] : [];
+    const cart = {
+      items: snapshotItems,
+      shippingTotal,
+      customer: { email: input.customer?.email ?? null },
+      codes: entered,
+      currency: input.currency
+    };
+    const context = await buildRuleContext(cart);
+    const actions = computePromotionActions(cart, this.promotions, { context });
+    let promotionItemDiscount = 0;
+    let promotionShippingDiscount = 0;
+    const firedPromotionIds = /* @__PURE__ */ new Set();
+    const firedCodes = /* @__PURE__ */ new Set();
+    for (const action of actions) {
+      firedPromotionIds.add(action.promotionId);
+      if (action.code) firedCodes.add(action.code.trim().toUpperCase());
+      if (action.action === "addItemDiscount") promotionItemDiscount += action.amount;
+      else if (action.action === "addShippingDiscount") promotionShippingDiscount += action.amount;
+      else if (action.action === "addFreeItem") {
+        const granted = this.products.find((p) => p.id === action.productId);
+        if (granted) {
+          items.push({ productId: granted.id, name: granted.name, sku: granted.sku ?? void 0, quantity: action.quantity, unitPrice: 0, imageUrl: granted.images[0]?.url });
+        }
+      }
+    }
+    for (const promotion of this.promotions) {
+      if (firedPromotionIds.has(promotion.id)) promotion.timesUsed = (promotion.timesUsed ?? 0) + 1;
+    }
+    discountTotal += Math.round(promotionItemDiscount * 100) / 100;
+    shippingTotal = Math.max(0, Math.round((shippingTotal - promotionShippingDiscount) * 100) / 100);
+    if (input.discountCode && firedCodes.has(input.discountCode.trim().toUpperCase())) {
+      appliedCode = input.discountCode.trim().toUpperCase();
+    }
+    if (input.discountCode && !appliedCode) {
       const code = input.discountCode.trim().toLowerCase();
       const d = this.discounts.find((x) => (x.code ?? "").toLowerCase() === code);
       const ts = now();
@@ -309,8 +427,8 @@ var MockShopProvider = class {
           eligible = lineDetails.filter((l) => l.categoryId && d.categoryIds.includes(l.categoryId)).reduce((s, l) => s + l.lineTotal, 0);
         }
         eligible = Math.round(eligible * 100) / 100;
-        if (d.type === "percentage") discountTotal = Math.round(eligible * d.value) / 100;
-        else if (d.type === "fixed_amount") discountTotal = Math.min(d.value, eligible);
+        if (d.type === "percentage") discountTotal += Math.round(eligible * d.value) / 100;
+        else if (d.type === "fixed_amount") discountTotal += Math.min(d.value, eligible);
         else if (d.type === "free_shipping") shippingTotal = 0;
         d.timesUsed += 1;
       }
@@ -329,7 +447,14 @@ var MockShopProvider = class {
     });
     for (const line of input.items) {
       const product = this.products.find((p) => p.id === line.productId);
-      if (product) product.inventoryCount = Math.max(0, product.inventoryCount - line.quantity);
+      if (!product) continue;
+      const variant = line.variantId ? this.variantSets[line.productId]?.variants.find((v) => v.id === line.variantId) : void 0;
+      if (variant) {
+        variant.inventoryCount = Math.max(0, variant.inventoryCount - line.quantity);
+        product.inventoryCount = this.variantSets[line.productId].variants.filter((v) => v.status === "active").reduce((sum, v) => sum + v.inventoryCount, 0);
+      } else {
+        product.inventoryCount = Math.max(0, product.inventoryCount - line.quantity);
+      }
     }
     return order;
   }
@@ -376,6 +501,20 @@ var MockShopProvider = class {
     return this.createCustomer({ firstName: first || email, lastName: rest.join(" "), email });
   }
   // ---------------------------------------------------------------------------
+  // Promotions (spine M6) — the mock provider IS the reference evaluator, so
+  // tests and pilot fixtures exercise the rule engine without a database.
+  // Seeded promotions ride as-is; legacy discounts ride through the adapter
+  // (a percent code = one eligibility rule on code + percentage method).
+  // ---------------------------------------------------------------------------
+  async evaluatePromotions(input) {
+    const promotions = [
+      ...this.promotions,
+      ...this.discounts.map(discountToPromotion).filter((p) => p !== null)
+    ];
+    const context = await buildRuleContext(input.cart);
+    return computePromotionActions(input.cart, promotions, { context });
+  }
+  // ---------------------------------------------------------------------------
   // Discounts
   // ---------------------------------------------------------------------------
   async listDiscounts(opts) {
@@ -430,11 +569,240 @@ var MockShopProvider = class {
     this.channels = this.channels.filter((c) => c.id !== id);
     this.persistChannels();
   }
+  // ---------------------------------------------------------------------------
+  // Custom entities (spine M4) — same EntityStore port as the live provider.
+  // ---------------------------------------------------------------------------
+  async listEntityRecords(entity, options) {
+    return this.entityStore(entity).list(options);
+  }
+  async getEntityRecord(entity, id) {
+    return this.entityStore(entity).get(id);
+  }
+  async getEntityRecordBySlug(entity, slug) {
+    return this.entityStore(entity).getBySlug(slug);
+  }
+  async createEntityRecord(entity, input) {
+    return this.entityStore(entity).create(input);
+  }
+  async updateEntityRecord(entity, id, input) {
+    return this.entityStore(entity).update(id, input);
+  }
+  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() {
+    this.syncCollections();
+    return [...this.collections].sort((a, b) => a.sortOrder - b.sortOrder);
+  }
+  async getCollection(id) {
+    this.syncCollections();
+    return this.collections.find((c) => c.id === id) ?? null;
+  }
+  async createCollection(input) {
+    this.syncCollections();
+    const c = {
+      id: uid(),
+      tenantId: "mock",
+      title: input.title,
+      handle: input.handle?.trim() || mockSlugify(input.title),
+      description: input.description ?? null,
+      imageUrl: input.imageUrl ?? null,
+      seoTitle: input.seoTitle ?? null,
+      seoDescription: input.seoDescription ?? null,
+      published: input.published ?? true,
+      sortOrder: input.sortOrder ?? this.collections.length,
+      productIds: input.productIds ?? [],
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.collections.push(c);
+    this.persistCollections();
+    return c;
+  }
+  async updateCollection(id, input) {
+    this.syncCollections();
+    const i = this.collections.findIndex((c) => c.id === id);
+    if (i < 0) throw new Error("Collection not found");
+    this.collections[i] = { ...this.collections[i], ...input, updatedAt: now() };
+    this.persistCollections();
+    return this.collections[i];
+  }
+  async deleteCollection(id) {
+    this.syncCollections();
+    this.collections = this.collections.filter((c) => c.id !== id);
+    this.persistCollections();
+  }
+  async listCustomerGroups() {
+    const stored = loadStored(CUSTOMER_GROUPS_KEY);
+    if (stored.length) this.customerGroups = stored;
+    return [...this.customerGroups].sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+  }
+  async createCustomerGroup(input) {
+    await this.listCustomerGroups();
+    const g = {
+      id: uid(),
+      tenantId: "mock",
+      name: input.name,
+      description: input.description ?? null,
+      color: input.color ?? null,
+      customerIds: input.customerIds ?? [],
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.customerGroups.push(g);
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+    return g;
+  }
+  async updateCustomerGroup(id, input) {
+    await this.listCustomerGroups();
+    const i = this.customerGroups.findIndex((g) => g.id === id);
+    if (i < 0) throw new Error("Customer group not found");
+    this.customerGroups[i] = { ...this.customerGroups[i], ...input, updatedAt: now() };
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+    return this.customerGroups[i];
+  }
+  async deleteCustomerGroup(id) {
+    await this.listCustomerGroups();
+    this.customerGroups = this.customerGroups.filter((g) => g.id !== id);
+    store(CUSTOMER_GROUPS_KEY, this.customerGroups);
+  }
+  async listCustomerSegments() {
+    const stored = loadStored(CUSTOMER_SEGMENTS_KEY);
+    if (stored.length) this.customerSegments = stored;
+    return [...this.customerSegments].sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+  }
+  async createCustomerSegment(input) {
+    await this.listCustomerSegments();
+    const s = {
+      id: uid(),
+      tenantId: "mock",
+      name: input.name,
+      description: input.description ?? null,
+      minOrders: input.minOrders ?? null,
+      maxOrders: input.maxOrders ?? null,
+      minSpent: input.minSpent ?? null,
+      maxSpent: input.maxSpent ?? null,
+      joinedAfter: input.joinedAfter ?? null,
+      joinedBefore: input.joinedBefore ?? null,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.customerSegments.push(s);
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+    return s;
+  }
+  async updateCustomerSegment(id, input) {
+    await this.listCustomerSegments();
+    const i = this.customerSegments.findIndex((s) => s.id === id);
+    if (i < 0) throw new Error("Customer segment not found");
+    this.customerSegments[i] = { ...this.customerSegments[i], ...input, updatedAt: now() };
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+    return this.customerSegments[i];
+  }
+  async deleteCustomerSegment(id) {
+    await this.listCustomerSegments();
+    this.customerSegments = this.customerSegments.filter((s) => s.id !== id);
+    store(CUSTOMER_SEGMENTS_KEY, this.customerSegments);
+  }
+  async listGiftCards() {
+    this.syncGiftCards();
+    return [...this.giftCards].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+  async createGiftCard(input) {
+    this.syncGiftCards();
+    const amount = Number(input.initialBalance) || 0;
+    const g = {
+      id: uid(),
+      tenantId: "mock",
+      code: (input.code?.trim() || mockGiftCardCode()).toUpperCase(),
+      // Same rule the supabase provider enforces: a new card is worth its face
+      // value, and only redemption moves the remaining balance.
+      initialBalance: amount,
+      balance: amount,
+      currency: input.currency ?? "BRL",
+      status: input.status ?? "active",
+      expiresAt: input.expiresAt ?? null,
+      customerId: input.customerId ?? null,
+      customerEmail: input.customerEmail ?? null,
+      note: input.note ?? null,
+      createdAt: now(),
+      updatedAt: now()
+    };
+    this.giftCards.push(g);
+    this.persistGiftCards();
+    return g;
+  }
+  async updateGiftCard(id, input) {
+    this.syncGiftCards();
+    const i = this.giftCards.findIndex((g) => g.id === id);
+    if (i < 0) throw new Error("Gift card not found");
+    const code = input.code !== void 0 ? input.code.trim().toUpperCase() : this.giftCards[i].code;
+    this.giftCards[i] = { ...this.giftCards[i], ...input, code, updatedAt: now() };
+    this.persistGiftCards();
+    return this.giftCards[i];
+  }
+  async deleteGiftCard(id) {
+    this.syncGiftCards();
+    this.giftCards = this.giftCards.filter((g) => g.id !== id);
+    this.persistGiftCards();
+  }
+  async listEmailTemplates() {
+    this.syncEmailTemplates();
+    return [...this.emailTemplates];
+  }
+  async upsertEmailTemplate(input) {
+    this.syncEmailTemplates();
+    const i = this.emailTemplates.findIndex((t) => t.event === input.event);
+    const base = i >= 0 ? this.emailTemplates[i] : {
+      id: uid(),
+      tenantId: "mock",
+      event: input.event,
+      enabled: false,
+      subject: null,
+      body: null,
+      updatedAt: now()
+    };
+    const next = { ...base, ...input, updatedAt: now() };
+    if (i >= 0) this.emailTemplates[i] = next;
+    else this.emailTemplates.push(next);
+    store(EMAIL_TEMPLATES_KEY, this.emailTemplates);
+    return next;
+  }
+  syncCollections() {
+    const stored = loadStored(COLLECTIONS_KEY);
+    if (stored.length) this.collections = stored;
+  }
+  persistCollections() {
+    store(COLLECTIONS_KEY, this.collections);
+  }
+  syncGiftCards() {
+    const stored = loadStored(GIFT_CARDS_KEY);
+    if (stored.length) this.giftCards = stored;
+  }
+  persistGiftCards() {
+    store(GIFT_CARDS_KEY, this.giftCards);
+  }
+  syncEmailTemplates() {
+    const stored = loadStored(EMAIL_TEMPLATES_KEY);
+    if (stored.length) this.emailTemplates = stored;
+  }
 };
 function createMockShopProvider(seed) {
   return new MockShopProvider(seed);
 }
 
 export { MockShopProvider, createMockShopProvider };
-//# sourceMappingURL=chunk-SVTCJ6HP.js.map
-//# sourceMappingURL=chunk-SVTCJ6HP.js.map
+//# sourceMappingURL=chunk-U3O2I3RM.js.map
+//# sourceMappingURL=chunk-U3O2I3RM.js.map