@infuro/cms-core 1.0.44 → 1.0.46

package/dist/chunk-3K5AIEIZ.js

@@ -0,0 +1,256 @@
+import { __name } from './chunk-SHUYVCID.js';
+
+// src/lib/order-inventory.ts
+var STOCK_HELD = /* @__PURE__ */ new Set([
+  "confirmed",
+  "completed"
+]);
+function orderStatusHoldsStock(status) {
+  return STOCK_HELD.has(String(status ?? "").trim().toLowerCase());
+}
+__name(orderStatusHoldsStock, "orderStatusHoldsStock");
+function orderInventorySnapshotFromRow(order) {
+  return {
+    status: order.status ?? "pending",
+    lines: (order.items ?? []).map((i) => {
+      const meta = i.metadata && typeof i.metadata === "object" ? i.metadata : null;
+      const metaVid = meta?.variantId ?? meta?.variant_id;
+      const fromCol = i.variantId != null ? Number(i.variantId) : NaN;
+      const fromMeta = metaVid != null && String(metaVid).trim() !== "" ? Number(metaVid) : NaN;
+      const variantId = Number.isFinite(fromCol) && fromCol > 0 ? fromCol : Number.isFinite(fromMeta) && fromMeta > 0 ? fromMeta : null;
+      return {
+        productId: Number(i.productId),
+        quantity: Math.max(0, Math.floor(Number(i.quantity) || 0)),
+        variantId
+      };
+    }).filter((l) => l.productId > 0 && l.quantity > 0)
+  };
+}
+__name(orderInventorySnapshotFromRow, "orderInventorySnapshotFromRow");
+function lineKey(productId, variantId) {
+  const vid = variantId != null && Number.isFinite(Number(variantId)) && Number(variantId) > 0 ? Number(variantId) : 0;
+  return `${productId}:${vid}`;
+}
+__name(lineKey, "lineKey");
+function mergeInventoryLines(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const productId = Number(line.productId);
+    const quantity = Math.max(0, Math.floor(Number(line.quantity) || 0));
+    if (!Number.isFinite(productId) || productId <= 0 || quantity <= 0) continue;
+    const variantId = line.variantId != null && Number.isFinite(Number(line.variantId)) && Number(line.variantId) > 0 ? Number(line.variantId) : null;
+    const key = lineKey(productId, variantId);
+    const prev = m.get(key);
+    if (prev) {
+      prev.quantity += quantity;
+    } else {
+      m.set(key, {
+        productId,
+        quantity,
+        variantId
+      });
+    }
+  }
+  return m;
+}
+__name(mergeInventoryLines, "mergeInventoryLines");
+function productRepo(ds, entityMap) {
+  const target = entityMap.products;
+  if (!target) throw new Error("products entity not configured");
+  return ds.getRepository(target);
+}
+__name(productRepo, "productRepo");
+function variantRepo(ds, entityMap) {
+  const target = entityMap.product_variants;
+  if (!target) return null;
+  return ds.getRepository(target);
+}
+__name(variantRepo, "variantRepo");
+async function validateInventoryForConfirmedOrderLines(ds, entityMap, lines) {
+  const merged = mergeInventoryLines(lines);
+  const byProduct = /* @__PURE__ */ new Map();
+  for (const line of merged.values()) {
+    byProduct.set(line.productId, (byProduct.get(line.productId) ?? 0) + line.quantity);
+  }
+  const pRepo = productRepo(ds, entityMap);
+  const vRepo = variantRepo(ds, entityMap);
+  for (const [productId, qty] of byProduct) {
+    const row = await pRepo.findOne({
+      where: {
+        id: productId,
+        deleted: false
+      }
+    });
+    if (!row) return `Product #${productId} not found`;
+    if (row.type === "service") continue;
+    const name = row.name ?? String(productId);
+    const productQty = Number(row.quantity ?? 0);
+    if (productQty < qty) {
+      return `Insufficient stock for ${name}: available ${productQty}, required ${qty}`;
+    }
+  }
+  for (const line of merged.values()) {
+    if (!line.variantId || !vRepo) continue;
+    const row = await pRepo.findOne({
+      where: {
+        id: line.productId,
+        deleted: false
+      }
+    });
+    if (!row) continue;
+    if (row.type === "service") continue;
+    const name = row.name ?? String(line.productId);
+    const variant = await vRepo.findOne({
+      where: {
+        id: line.variantId,
+        productId: line.productId
+      }
+    });
+    if (!variant) return `Variant #${line.variantId} not found for ${name}`;
+    const inv = Number(variant.inventory ?? 0);
+    if (inv < line.quantity) {
+      return `Insufficient variant stock for ${name}: available ${inv}, required ${line.quantity}`;
+    }
+  }
+  return null;
+}
+__name(validateInventoryForConfirmedOrderLines, "validateInventoryForConfirmedOrderLines");
+async function validateInventoryForOrderBecomingConfirmed(ds, entityMap, prevSnap, nextLines) {
+  const mergedNext = mergeInventoryLines(nextLines);
+  const prevByKey = prevSnap && orderStatusHoldsStock(prevSnap.status) ? mergeInventoryLines(prevSnap.lines) : /* @__PURE__ */ new Map();
+  const nextByProduct = /* @__PURE__ */ new Map();
+  for (const line of mergedNext.values()) {
+    nextByProduct.set(line.productId, (nextByProduct.get(line.productId) ?? 0) + line.quantity);
+  }
+  const prevByProduct = /* @__PURE__ */ new Map();
+  for (const line of prevByKey.values()) {
+    prevByProduct.set(line.productId, (prevByProduct.get(line.productId) ?? 0) + line.quantity);
+  }
+  const pRepo = productRepo(ds, entityMap);
+  const vRepo = variantRepo(ds, entityMap);
+  for (const [productId, need] of nextByProduct) {
+    const row = await pRepo.findOne({
+      where: {
+        id: productId,
+        deleted: false
+      }
+    });
+    if (!row) return `Product #${productId} not found`;
+    if (row.type === "service") continue;
+    const name = row.name ?? String(productId);
+    const available = Number(row.quantity ?? 0) + (prevByProduct.get(productId) ?? 0);
+    if (available < need) {
+      return `Insufficient stock for ${name}: available ${available}, required ${need}`;
+    }
+  }
+  for (const line of mergedNext.values()) {
+    if (!line.variantId || !vRepo) continue;
+    const row = await pRepo.findOne({
+      where: {
+        id: line.productId,
+        deleted: false
+      }
+    });
+    if (!row || row.type === "service") continue;
+    const name = row.name ?? String(line.productId);
+    const key = lineKey(line.productId, line.variantId);
+    const variant = await vRepo.findOne({
+      where: {
+        id: line.variantId,
+        productId: line.productId
+      }
+    });
+    if (!variant) return `Variant #${line.variantId} not found for ${name}`;
+    let inv = Number(variant.inventory ?? 0);
+    inv += prevByKey.get(key)?.quantity ?? 0;
+    if (inv < line.quantity) {
+      return `Insufficient variant stock for ${name}: available ${inv}, required ${line.quantity}`;
+    }
+  }
+  return null;
+}
+__name(validateInventoryForOrderBecomingConfirmed, "validateInventoryForOrderBecomingConfirmed");
+async function applyInventoryDelta(ds, entityMap, lines, sign, validateDeduct) {
+  const merged = mergeInventoryLines(lines);
+  const pRepo = productRepo(ds, entityMap);
+  const vRepo = variantRepo(ds, entityMap);
+  for (const line of merged.values()) {
+    const row = await pRepo.findOne({
+      where: sign === 1 ? {
+        id: line.productId
+      } : {
+        id: line.productId,
+        deleted: false
+      }
+    });
+    if (!row) return `Product #${line.productId} not found`;
+    if (row.type === "service") continue;
+    const name = row.name ?? String(line.productId);
+    const cur = Number(row.quantity ?? 0);
+    if (line.variantId && vRepo) {
+      const variant = await vRepo.findOne({
+        where: {
+          id: line.variantId,
+          productId: line.productId
+        }
+      });
+      if (!variant) return `Variant #${line.variantId} not found for ${name}`;
+      const inv = Number(variant.inventory ?? 0);
+      if (sign === -1) {
+        if (validateDeduct && inv < line.quantity) {
+          return `Insufficient variant stock for ${name}: available ${inv}, required ${line.quantity}`;
+        }
+        await vRepo.update(line.variantId, {
+          inventory: Math.max(0, inv - line.quantity)
+        });
+      } else {
+        await vRepo.update(line.variantId, {
+          inventory: inv + line.quantity
+        });
+      }
+    }
+    if (sign === -1) {
+      if (validateDeduct && cur < line.quantity) {
+        return `Insufficient stock for ${name}: available ${cur}, required ${line.quantity}`;
+      }
+      await pRepo.update(line.productId, {
+        quantity: Math.max(0, cur - line.quantity)
+      });
+    } else {
+      await pRepo.update(line.productId, {
+        quantity: cur + line.quantity
+      });
+    }
+  }
+  return null;
+}
+__name(applyInventoryDelta, "applyInventoryDelta");
+async function reconcileOrderInventoryBetweenSnapshots(ds, entityMap, prev, next) {
+  const wasHeld = orderStatusHoldsStock(prev.status);
+  const isHeld = orderStatusHoldsStock(next.status);
+  if (wasHeld) {
+    const err = await applyInventoryDelta(ds, entityMap, prev.lines, 1, false);
+    if (err) return err;
+  }
+  if (isHeld) {
+    const err = await applyInventoryDelta(ds, entityMap, next.lines, -1, true);
+    if (err) return err;
+  }
+  return null;
+}
+__name(reconcileOrderInventoryBetweenSnapshots, "reconcileOrderInventoryBetweenSnapshots");
+async function deductInventoryForConfirmedOrder(ds, entityMap, lines, options) {
+  const validate = options?.validate !== false;
+  if (validate) {
+    const err = await validateInventoryForConfirmedOrderLines(ds, entityMap, lines);
+    if (err) return err;
+  }
+  return applyInventoryDelta(ds, entityMap, lines, -1, validate);
+}
+__name(deductInventoryForConfirmedOrder, "deductInventoryForConfirmedOrder");
+async function restoreInventoryForCancelledOrder(ds, entityMap, lines) {
+  return applyInventoryDelta(ds, entityMap, lines, 1, false);
+}
+__name(restoreInventoryForCancelledOrder, "restoreInventoryForCancelledOrder");
+
+export { deductInventoryForConfirmedOrder, mergeInventoryLines, orderInventorySnapshotFromRow, orderStatusHoldsStock, reconcileOrderInventoryBetweenSnapshots, restoreInventoryForCancelledOrder, validateInventoryForConfirmedOrderLines, validateInventoryForOrderBecomingConfirmed };

package/dist/{chunk-I6NH72MO.js → chunk-57O3HZPG.js}

@@ -399,6 +399,14 @@ function getNextAuthOptions(config) {
             });
             return null;
           }
+          if (user.inviteStatus === "pending") {
+            logAuth("authorize(credentials) rejected", {
+              reason: "invite_pending",
+              email,
+              userId: user.id
+            });
+            return null;
+          }
           if (user.deleted) {
             logAuth("authorize(credentials) rejected", {
               reason: "deleted",
@@ -488,7 +496,7 @@ function getNextAuthOptions(config) {
             channel: ch,
             code
           });
-          if (!user || user.blocked || user.deleted) return null;
+          if (!user || user.blocked || user.inviteStatus === "pending" || user.deleted) return null;
           if (isCustomerGroupUser(user) && !permitsCustomerLogin(allowCustomerLogin, creds)) {
             logAuth("authorize(otp) rejected", {
               reason: "customer_group",