@infuro/cms-core 1.0.34 → 1.0.35

package/dist/chunk-TIAEXJLI.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var chunk3KPNTQBV_cjs = require('./chunk-3KPNTQBV.cjs');
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+
+// src/auth/helpers.ts
+var RBAC_ADMIN_ONLY_ENTITIES = /* @__PURE__ */ new Set([
+  "users",
+  "user_groups",
+  "permissions"
+]);
+function sessionHasEntityAccess(user, entity, action) {
+  return chunk3KPNTQBV_cjs.explainSessionEntityAccess(user, entity, action).allowed;
+}
+chunkUSNT2KNT_cjs.__name(sessionHasEntityAccess, "sessionHasEntityAccess");
+function canManageRoles(user) {
+  return !!(user?.email && user.isRBACAdmin);
+}
+chunkUSNT2KNT_cjs.__name(canManageRoles, "canManageRoles");
+var OPEN_ENDPOINTS = [
+  {
+    "/api/contacts": [
+      "POST"
+    ]
+  },
+  {
+    "/api/form-submissions": [
+      "POST"
+    ]
+  },
+  {
+    "/api/blogs": [
+      "GET"
+    ]
+  }
+];
+var PERMISSION_REQUIRED_ENDPOINTS = {};
+function isOpenEndpoint(pathname) {
+  return OPEN_ENDPOINTS.some((endpoint) => pathname.startsWith(Object.keys(endpoint)[0]));
+}
+chunkUSNT2KNT_cjs.__name(isOpenEndpoint, "isOpenEndpoint");
+function getRequiredPermission(pathname) {
+  return null;
+}
+chunkUSNT2KNT_cjs.__name(getRequiredPermission, "getRequiredPermission");
+function isPublicMethod(pathname, method) {
+  for (const endpoint of OPEN_ENDPOINTS) {
+    const key = Object.keys(endpoint)[0];
+    if (pathname.startsWith(key) && endpoint[key].includes(method)) return true;
+  }
+  return false;
+}
+chunkUSNT2KNT_cjs.__name(isPublicMethod, "isPublicMethod");
+function createAuthHelpers(getSession, NextResponse) {
+  return createAuthHelpersFromGetSession(getSession, NextResponse);
+}
+chunkUSNT2KNT_cjs.__name(createAuthHelpers, "createAuthHelpers");
+function createCmsAuthBundle(getSession, NextResponse) {
+  const auth = createAuthHelpers(getSession, NextResponse);
+  return {
+    requireAuth: auth.requireAuth,
+    requireAdminAccess: auth.requireAdminAccess,
+    requireEntityPermission: auth.requireEntityPermission,
+    getSessionUser: auth.getAuthenticatedUser,
+    getAuthenticatedUser: auth.getAuthenticatedUser
+  };
+}
+chunkUSNT2KNT_cjs.__name(createCmsAuthBundle, "createCmsAuthBundle");
+function createAuthHelpersFromGetSession(getSession, NextResponse) {
+  return {
+    async requireAuth() {
+      const session = await getSession();
+      if (!session?.user?.email) {
+        return NextResponse.json({
+          error: "Unauthorized"
+        }, {
+          status: 401
+        });
+      }
+      return null;
+    },
+    async requirePermission() {
+      const session = await getSession();
+      if (!session?.user?.email) {
+        return NextResponse.json({
+          error: "Unauthorized"
+        }, {
+          status: 401
+        });
+      }
+      return null;
+    },
+    async requireEntityPermission(_req, entity, action) {
+      const session = await getSession();
+      if (!session?.user?.email) {
+        return NextResponse.json({
+          error: "Unauthorized"
+        }, {
+          status: 401
+        });
+      }
+      const u = session.user;
+      const allowed = sessionHasEntityAccess(u, entity, action);
+      const { reason } = chunk3KPNTQBV_cjs.explainSessionEntityAccess(u, entity, action);
+      chunk3KPNTQBV_cjs.logRbac("authHelpers.requireEntityPermission", {
+        entity,
+        action,
+        allowed,
+        reason,
+        email: u.email,
+        groupName: u.groupName,
+        vendorIds: u.vendorIds,
+        isVendorPortal: u.isVendorPortal,
+        isVendorOwner: u.isVendorOwner
+      });
+      if (allowed) return null;
+      return NextResponse.json({
+        error: "Forbidden",
+        entity,
+        action,
+        reason
+      }, {
+        status: 403
+      });
+    },
+    async requireAdminAccess() {
+      const session = await getSession();
+      if (!session?.user?.email) {
+        return NextResponse.json({
+          error: "Unauthorized"
+        }, {
+          status: 401
+        });
+      }
+      const u = session.user;
+      if (u.isRBACAdmin) return null;
+      if (chunk3KPNTQBV_cjs.isVendorPortalUser(u)) return null;
+      if (u.adminAccess === true) return null;
+      if (u.adminAccess === false) {
+        chunk3KPNTQBV_cjs.logRbac("requireAdminAccess denied (adminAccess:false)", {
+          email: u.email,
+          groupName: u.groupName,
+          isVendorPortal: u.isVendorPortal
+        });
+        return NextResponse.json({
+          error: "Forbidden",
+          reason: "admin_access"
+        }, {
+          status: 403
+        });
+      }
+      chunk3KPNTQBV_cjs.logRbac("requireAdminAccess denied (no matching rule)", {
+        email: u.email,
+        adminAccess: u.adminAccess,
+        groupName: u.groupName,
+        isVendorPortal: u.isVendorPortal
+      });
+      return NextResponse.json({
+        error: "Forbidden",
+        reason: "admin_access"
+      }, {
+        status: 403
+      });
+    },
+    async getAuthenticatedUser() {
+      const session = await getSession();
+      return session?.user ?? null;
+    }
+  };
+}
+chunkUSNT2KNT_cjs.__name(createAuthHelpersFromGetSession, "createAuthHelpersFromGetSession");
+
+exports.OPEN_ENDPOINTS = OPEN_ENDPOINTS;
+exports.PERMISSION_REQUIRED_ENDPOINTS = PERMISSION_REQUIRED_ENDPOINTS;
+exports.RBAC_ADMIN_ONLY_ENTITIES = RBAC_ADMIN_ONLY_ENTITIES;
+exports.canManageRoles = canManageRoles;
+exports.createAuthHelpers = createAuthHelpers;
+exports.createCmsAuthBundle = createCmsAuthBundle;
+exports.getRequiredPermission = getRequiredPermission;
+exports.isOpenEndpoint = isOpenEndpoint;
+exports.isPublicMethod = isPublicMethod;
+exports.sessionHasEntityAccess = sessionHasEntityAccess;

package/dist/chunk-UPLVMVRX.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+
+// src/plugins/erp/erp-config-enabled.ts
+async function isErpIntegrationEnabled(cms, dataSource, entityMap) {
+  if (!cms.getPlugin("erp")) return false;
+  const configRepo = dataSource.getRepository(entityMap.configs);
+  const cfgRows = await configRepo.find({
+    where: {
+      settings: "erp",
+      deleted: false
+    }
+  });
+  for (const row of cfgRows) {
+    const r = row;
+    if (r.key === "enabled" && r.value === "false") return false;
+  }
+  return true;
+}
+chunkUSNT2KNT_cjs.__name(isErpIntegrationEnabled, "isErpIntegrationEnabled");
+
+exports.isErpIntegrationEnabled = isErpIntegrationEnabled;

package/dist/chunk-USNT2KNT.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+exports.__name = __name;

package/dist/chunk-WEMDMVHQ.js

@@ -0,0 +1,216 @@
+import { isErpIntegrationEnabled } from './chunk-JC6DLWTE.js';
+import { __name } from './chunk-SHUYVCID.js';
+
+// src/plugins/erp/erp-response-map.ts
+function pickString(o, keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return void 0;
+}
+__name(pickString, "pickString");
+function unwrapErpReadData(json) {
+  if (!json || typeof json !== "object") return null;
+  const o = json;
+  const d = o.data;
+  if (d && typeof d === "object" && !Array.isArray(d)) return d;
+  return o;
+}
+__name(unwrapErpReadData, "unwrapErpReadData");
+function firstObject(data, keys) {
+  for (const k of keys) {
+    const v = data[k];
+    if (v && typeof v === "object" && !Array.isArray(v)) return v;
+  }
+  return null;
+}
+__name(firstObject, "firstObject");
+function extractEvents(src) {
+  const timeline = src.timeline ?? src.events ?? src.history ?? src.trackingEvents;
+  if (!Array.isArray(timeline) || !timeline.length) return void 0;
+  const events = [];
+  for (const row of timeline) {
+    if (!row || typeof row !== "object") continue;
+    const r = row;
+    const at = pickString(r, [
+      "at",
+      "timestamp",
+      "date",
+      "occurredAt"
+    ]) ?? (r.at instanceof Date ? r.at.toISOString() : void 0);
+    const label = pickString(r, [
+      "label",
+      "status",
+      "title",
+      "message",
+      "description"
+    ]);
+    const detail = pickString(r, [
+      "detail",
+      "notes",
+      "description"
+    ]);
+    if (at || label || detail) events.push({
+      at,
+      label,
+      detail
+    });
+  }
+  return events.length ? events : void 0;
+}
+__name(extractEvents, "extractEvents");
+function mapErpPayloadToFulfillment(data) {
+  const nested = firstObject(data, [
+    "fulfillment",
+    "packaging",
+    "shipment",
+    "shipping",
+    "delivery"
+  ]);
+  const src = nested || data;
+  const status = pickString(src, [
+    "status",
+    "fulfillmentStatus",
+    "state",
+    "label",
+    "packagingStatus"
+  ]);
+  const trackingId = pickString(src, [
+    "trackingId",
+    "tracking_id",
+    "trackingNumber",
+    "awb",
+    "trackingUrl"
+  ]);
+  const events = extractEvents(src);
+  if (!status && !trackingId && !(events && events.length)) return void 0;
+  return {
+    status,
+    trackingId,
+    events
+  };
+}
+__name(mapErpPayloadToFulfillment, "mapErpPayloadToFulfillment");
+function mapErpPayloadToInvoiceNumber(data) {
+  const nested = firstObject(data, [
+    "invoice",
+    "latestInvoice",
+    "postedInvoice"
+  ]);
+  const src = nested || data;
+  return pickString(src, [
+    "invoiceNumber",
+    "invoice_number",
+    "number",
+    "name",
+    "id"
+  ]);
+}
+__name(mapErpPayloadToInvoiceNumber, "mapErpPayloadToInvoiceNumber");
+function extractChildOrderRefsFromSalePayload(data) {
+  const lists = [
+    data.returns,
+    data.returnOrders,
+    data.relatedReturns,
+    data.childOrders,
+    data.children
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const list of lists) {
+    if (!Array.isArray(list)) continue;
+    for (const item of list) {
+      if (!item || typeof item !== "object") continue;
+      const o = item;
+      const ref = pickString(o, [
+        "platformReturnId",
+        "platform_return_id",
+        "refId",
+        "ref_id"
+      ]) ?? (typeof o.id === "string" ? o.id : void 0);
+      if (!ref || seen.has(ref)) continue;
+      seen.add(ref);
+      const t = (pickString(o, [
+        "kind",
+        "type",
+        "orderKind"
+      ]) || "").toLowerCase();
+      const orderKind = /replac/.test(t) ? "replacement" : "return";
+      out.push({
+        ref,
+        orderKind
+      });
+    }
+  }
+  return out;
+}
+__name(extractChildOrderRefsFromSalePayload, "extractChildOrderRefsFromSalePayload");
+
+// src/plugins/erp/erp-order-invoice.ts
+function pickInvoiceId(data) {
+  const nested = data.invoice && typeof data.invoice === "object" && !Array.isArray(data.invoice) ? data.invoice : null;
+  const src = nested || data;
+  for (const k of [
+    "invoiceId",
+    "invoice_id",
+    "id"
+  ]) {
+    const v = src[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return void 0;
+}
+__name(pickInvoiceId, "pickInvoiceId");
+async function streamOrderInvoicePdf(cms, dataSource, entityMap, orderId, options) {
+  const jsonErr = /* @__PURE__ */ __name((msg, status) => new Response(JSON.stringify({
+    error: msg
+  }), {
+    status,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  }), "jsonErr");
+  const on = await isErpIntegrationEnabled(cms, dataSource, entityMap);
+  if (!on) return jsonErr("Invoice not available", 503);
+  const erp = cms.getPlugin("erp");
+  if (!erp?.submission) return jsonErr("Invoice not available", 503);
+  const orderRepo = dataSource.getRepository(entityMap.orders);
+  const order = await orderRepo.findOne({
+    where: {
+      id: orderId,
+      deleted: false
+    }
+  });
+  if (!order) return jsonErr("Not found", 404);
+  const kind = order.orderKind || "sale";
+  if (kind !== "sale") return jsonErr("Invoice only for sale orders", 400);
+  if (options.ownerContactId != null && order.contactId !== options.ownerContactId) {
+    return jsonErr("Not found", 404);
+  }
+  const meta = order.metadata && typeof order.metadata === "object" && !Array.isArray(order.metadata) ? order.metadata : {};
+  const inv = meta.invoice && typeof meta.invoice === "object" && !Array.isArray(meta.invoice) ? meta.invoice : {};
+  let invoiceId = typeof inv.invoiceId === "string" ? inv.invoiceId.trim() : "";
+  if (!invoiceId) {
+    const refId = String(order.orderNumber || "");
+    const r = await erp.submission.postErpReadAction("get-invoice", {
+      platformOrderId: refId
+    });
+    const d = r.ok ? unwrapErpReadData(r.json) : null;
+    invoiceId = d ? pickInvoiceId(d) || "" : "";
+  }
+  if (!invoiceId) return jsonErr("Invoice not ready", 404);
+  const pdf = await erp.submission.fetchInvoicePdf(invoiceId);
+  if (!pdf.ok || !pdf.buffer) return jsonErr(pdf.error || "PDF fetch failed", 502);
+  const filename = `invoice-${orderId}.pdf`;
+  return new Response(pdf.buffer, {
+    status: 200,
+    headers: {
+      "Content-Type": pdf.contentType || "application/pdf",
+      "Content-Disposition": `attachment; filename="${filename}"`
+    }
+  });
+}
+__name(streamOrderInvoicePdf, "streamOrderInvoicePdf");
+
+export { extractChildOrderRefsFromSalePayload, mapErpPayloadToFulfillment, mapErpPayloadToInvoiceNumber, streamOrderInvoicePdf, unwrapErpReadData };