@infuro/cms-core 1.0.34 → 1.0.35

package/dist/chunk-CNTSLED2.cjs

@@ -0,0 +1,559 @@
+'use strict';
+
+var chunk3KPNTQBV_cjs = require('./chunk-3KPNTQBV.cjs');
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var jwt = require('next-auth/jwt');
+var _CredentialsProvider = require('next-auth/providers/credentials');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _CredentialsProvider__default = /*#__PURE__*/_interopDefault(_CredentialsProvider);
+
+// src/auth/seed-permissions.ts
+async function seedAdministratorPermissions(dataSource, entityMap) {
+  const entities = chunk3KPNTQBV_cjs.getPermissionableEntityKeys(entityMap);
+  const groupRepo = dataSource.getRepository(entityMap.user_groups);
+  const permRepo = dataSource.getRepository(entityMap.permissions);
+  const adminGroup = await groupRepo.findOne({
+    where: {
+      name: chunk3KPNTQBV_cjs.ADMIN_GROUP_NAME,
+      deleted: false
+    }
+  });
+  console.log("ADMIN GROUP", adminGroup);
+  if (!adminGroup) return;
+  const fullCrud = {
+    canCreate: true,
+    canRead: true,
+    canUpdate: true,
+    canDelete: true
+  };
+  for (const entity of entities) {
+    const existing = await permRepo.findOne({
+      where: {
+        groupId: adminGroup.id,
+        entity
+      }
+    });
+    console.log("EXISTING", existing);
+    if (existing) {
+      existing.canCreate = true;
+      existing.canRead = true;
+      existing.canUpdate = true;
+      existing.canDelete = true;
+      await permRepo.save(existing);
+    } else {
+      await permRepo.save(permRepo.create({
+        groupId: adminGroup.id,
+        entity,
+        ...fullCrud
+      }));
+    }
+  }
+}
+chunkUSNT2KNT_cjs.__name(seedAdministratorPermissions, "seedAdministratorPermissions");
+
+// src/auth/auth-debug.ts
+var LOG_PREFIX = "[cms-auth]";
+function isAuthDebugEnabled() {
+  const v = process.env.CMS_AUTH_DEBUG?.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "yes") return true;
+  if (v === "0" || v === "false" || v === "no") return false;
+  return process.env.NODE_ENV === "development";
+}
+chunkUSNT2KNT_cjs.__name(isAuthDebugEnabled, "isAuthDebugEnabled");
+function isAuthDebugClientEnabled() {
+  if (typeof window === "undefined") return false;
+  const v = process.env.NEXT_PUBLIC_CMS_AUTH_DEBUG?.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "yes") return true;
+  if (v === "0" || v === "false" || v === "no") return false;
+  return process.env.NODE_ENV === "development";
+}
+chunkUSNT2KNT_cjs.__name(isAuthDebugClientEnabled, "isAuthDebugClientEnabled");
+function logAuth(message, data) {
+  if (!isAuthDebugEnabled()) return;
+  if (data) console.info(LOG_PREFIX, message, data);
+  else console.info(LOG_PREFIX, message);
+}
+chunkUSNT2KNT_cjs.__name(logAuth, "logAuth");
+function logAuthClient(message, data) {
+  if (!isAuthDebugClientEnabled()) return;
+  if (data) console.info(LOG_PREFIX, message, data);
+  else console.info(LOG_PREFIX, message);
+}
+chunkUSNT2KNT_cjs.__name(logAuthClient, "logAuthClient");
+function summarizeSessionUserForLog(user) {
+  if (!user || typeof user !== "object") return {
+    present: false
+  };
+  const u = user;
+  return {
+    present: true,
+    email: u.email ?? null,
+    id: u.id ?? null,
+    adminAccess: u.adminAccess ?? null,
+    isRBACAdmin: u.isRBACAdmin ?? null,
+    isVendorPortal: u.isVendorPortal ?? null,
+    groupName: u.groupName ?? null
+  };
+}
+chunkUSNT2KNT_cjs.__name(summarizeSessionUserForLog, "summarizeSessionUserForLog");
+function nextAuthCookieDebugInfo() {
+  const nextAuthUrl = process.env.NEXTAUTH_URL ?? "(unset)";
+  const isHttps = nextAuthUrl.startsWith("https");
+  return {
+    nextAuthUrl,
+    hasSecret: Boolean(process.env.NEXTAUTH_SECRET),
+    cookieName: isHttps ? "__Secure-next-auth.session-token" : "next-auth.session-token",
+    cookieSecure: isHttps,
+    nodeEnv: process.env.NODE_ENV ?? "(unset)"
+  };
+}
+chunkUSNT2KNT_cjs.__name(nextAuthCookieDebugInfo, "nextAuthCookieDebugInfo");
+
+// src/auth/middleware.ts
+var defaultPublicApiMethods = {
+  "/api/contacts": [
+    "POST"
+  ],
+  "/api/form-submissions": [
+    "POST"
+  ],
+  "/api/blogs": [
+    "GET"
+  ],
+  "/api/forms": [
+    "GET"
+  ],
+  "/api/auth": [
+    "GET",
+    "POST"
+  ],
+  "/api/health": [
+    "GET"
+  ],
+  "/api/users/forgot-password": [
+    "POST"
+  ],
+  "/api/users/set-password": [
+    "POST"
+  ],
+  "/api/users/invite": [
+    "POST"
+  ]
+};
+function legacyGetSessionToken(request) {
+  const secure = request.cookies.get("__Secure-next-auth.session-token")?.value;
+  const regular = request.cookies.get("next-auth.session-token")?.value;
+  return secure ?? regular;
+}
+chunkUSNT2KNT_cjs.__name(legacyGetSessionToken, "legacyGetSessionToken");
+function sessionCookiePresence(request) {
+  const secure = request.cookies.get("__Secure-next-auth.session-token")?.value;
+  const regular = request.cookies.get("next-auth.session-token")?.value;
+  const hasChunked = Boolean(request.cookies.get("next-auth.session-token.0")?.value) || Boolean(request.cookies.get("__Secure-next-auth.session-token.0")?.value);
+  return {
+    hasSecureToken: Boolean(secure),
+    hasRegularToken: Boolean(regular),
+    hasChunkedToken: hasChunked,
+    resolved: Boolean(secure ?? regular)
+  };
+}
+chunkUSNT2KNT_cjs.__name(sessionCookiePresence, "sessionCookiePresence");
+function isPublicMethod(pathname, method, publicApiMethods) {
+  for (const [endpoint, methods] of Object.entries(publicApiMethods)) {
+    if (pathname.startsWith(endpoint) && methods.includes(method)) return true;
+  }
+  return false;
+}
+chunkUSNT2KNT_cjs.__name(isPublicMethod, "isPublicMethod");
+async function hasValidSession(request, secret, legacyGetToken) {
+  if (request.req) {
+    const token = await jwt.getToken({
+      req: request.req,
+      secret
+    });
+    return token != null;
+  }
+  return Boolean(legacyGetToken(request));
+}
+chunkUSNT2KNT_cjs.__name(hasValidSession, "hasValidSession");
+function createCmsMiddleware(config = {}) {
+  const { publicAdminPaths = [
+    "/admin/signin",
+    "/admin/forgot-password",
+    "/admin/reset-password",
+    "/admin/invite"
+  ], publicApiMethods = defaultPublicApiMethods, signInPath = "/admin/signin", getSessionToken = legacyGetSessionToken, secret = process.env.NEXTAUTH_SECRET } = config;
+  return /* @__PURE__ */ chunkUSNT2KNT_cjs.__name(async function cmsMiddleware(request) {
+    const pathname = request.nextUrl.pathname;
+    const method = request.method;
+    if (publicAdminPaths.some((p) => pathname === p || pathname.startsWith(p + "/"))) {
+      return {
+        type: "next"
+      };
+    }
+    if (pathname.startsWith("/admin")) {
+      const authenticated = await hasValidSession(request, secret, getSessionToken);
+      const cookies = sessionCookiePresence(request);
+      if (!authenticated) {
+        logAuth("middleware: admin redirect to signin (no session)", {
+          pathname,
+          method,
+          usesGetToken: Boolean(request.req),
+          ...cookies,
+          expectedCookieName: process.env.NEXTAUTH_URL?.startsWith("https") ? "__Secure-next-auth.session-token" : "next-auth.session-token"
+        });
+        return {
+          type: "redirect",
+          url: new URL(signInPath, request.url).toString()
+        };
+      }
+      logAuth("middleware: admin allowed", {
+        pathname,
+        method,
+        usesGetToken: Boolean(request.req),
+        ...cookies
+      });
+    }
+    if (pathname.startsWith("/api")) {
+      if (isPublicMethod(pathname, method, publicApiMethods)) {
+        return {
+          type: "next"
+        };
+      }
+      const authenticated = await hasValidSession(request, secret, getSessionToken);
+      if (!authenticated) {
+        logAuth("middleware: api 401 (no session)", {
+          pathname,
+          method,
+          usesGetToken: Boolean(request.req),
+          ...sessionCookiePresence(request)
+        });
+        return {
+          type: "json",
+          status: 401,
+          body: {
+            error: "Unauthorized"
+          }
+        };
+      }
+    }
+    return {
+      type: "next"
+    };
+  }, "cmsMiddleware");
+}
+chunkUSNT2KNT_cjs.__name(createCmsMiddleware, "createCmsMiddleware");
+var CredentialsProvider = _CredentialsProvider__default.default.default ?? _CredentialsProvider__default.default;
+function sessionUserFromNextAuthUser(user) {
+  const g = user.group;
+  const isRBACAdmin = chunk3KPNTQBV_cjs.isSuperAdmin({
+    groupId: user.groupId ?? void 0,
+    groupName: g?.name,
+    isRBACAdmin: false
+  });
+  const entityPerms = chunk3KPNTQBV_cjs.permissionRowsToRecord(g?.permissions);
+  const rawAdminAccess = user.adminAccess;
+  const adminAccess = rawAdminAccess === true ? true : rawAdminAccess === false ? false : void 0;
+  const vendorIds = user.vendorIds ?? [];
+  const vendorRole = user.vendorRole ?? null;
+  const isVendorRoleOwner = user.isVendorRoleOwner ?? false;
+  const { isVendorPortal, isVendorOwner: isVendorOwner2 } = chunk3KPNTQBV_cjs.vendorPortalFlagsFromUser({
+    email: user.email,
+    isRBACAdmin,
+    groupName: g?.name,
+    vendorIds,
+    vendorRole,
+    isVendorRoleOwner
+  });
+  return {
+    id: user.id.toString(),
+    email: user.email,
+    name: user.name,
+    groupId: user.groupId ?? void 0,
+    groupName: g?.name ?? void 0,
+    isRBACAdmin,
+    entityPerms,
+    adminAccess,
+    vendorIds,
+    activeVendorId: user.activeVendorId ?? vendorIds[0] ?? null,
+    vendorRole,
+    vendorRoleId: user.vendorRoleId ?? null,
+    vendorRoleName: user.vendorRoleName ?? null,
+    isVendorRoleOwner,
+    vendorEntityPerms: user.vendorEntityPerms,
+    isVendorPortal,
+    isVendorOwner: isVendorOwner2
+  };
+}
+chunkUSNT2KNT_cjs.__name(sessionUserFromNextAuthUser, "sessionUserFromNextAuthUser");
+function isCustomerGroupUser(user) {
+  return user.group?.name?.toLocaleLowerCase().trim() === "customer";
+}
+chunkUSNT2KNT_cjs.__name(isCustomerGroupUser, "isCustomerGroupUser");
+function callbackUrlTargetsAdmin(callbackUrl) {
+  const raw = callbackUrl.trim();
+  if (!raw) return false;
+  if (raw.startsWith("/admin")) return true;
+  try {
+    const path = raw.startsWith("http") ? new URL(raw).pathname : raw.split("?")[0] ?? raw;
+    return path.startsWith("/admin");
+  } catch {
+    return raw.includes("/admin");
+  }
+}
+chunkUSNT2KNT_cjs.__name(callbackUrlTargetsAdmin, "callbackUrlTargetsAdmin");
+function permitsCustomerLogin(allowCustomerLogin, credentials) {
+  if (allowCustomerLogin === true) return true;
+  if (allowCustomerLogin === false) return false;
+  const callbackUrl = typeof credentials?.callbackUrl === "string" ? credentials.callbackUrl : "";
+  return !callbackUrlTargetsAdmin(callbackUrl);
+}
+chunkUSNT2KNT_cjs.__name(permitsCustomerLogin, "permitsCustomerLogin");
+function getNextAuthOptions(config) {
+  const { getUserByEmail, comparePassword, signInPage = "/admin/signin", secret, extend, enablePasswordLogin = true, enableOtpLogin = false, authorizeOtp, allowCustomerLogin } = config;
+  logAuth("getNextAuthOptions init", nextAuthCookieDebugInfo());
+  const providers = [];
+  if (enablePasswordLogin) {
+    providers.push(CredentialsProvider({
+      name: "credentials",
+      credentials: {
+        email: {
+          label: "Email",
+          type: "email"
+        },
+        password: {
+          label: "Password",
+          type: "password"
+        }
+      },
+      async authorize(credentials) {
+        const creds = credentials;
+        const email = creds?.email?.trim() ?? "";
+        if (!email || !creds?.password) {
+          logAuth("authorize(credentials) rejected", {
+            reason: "missing_email_or_password"
+          });
+          return null;
+        }
+        try {
+          const user = await getUserByEmail(email);
+          if (!user) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "user_not_found",
+              email
+            });
+            return null;
+          }
+          if (user.blocked) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "blocked",
+              email,
+              userId: user.id
+            });
+            return null;
+          }
+          if (user.deleted) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "deleted",
+              email,
+              userId: user.id
+            });
+            return null;
+          }
+          if (!user.password) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "no_password",
+              email,
+              userId: user.id
+            });
+            return null;
+          }
+          const valid = await comparePassword(creds.password, user.password);
+          if (!valid) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "invalid_password",
+              email,
+              userId: user.id
+            });
+            return null;
+          }
+          if (isCustomerGroupUser(user) && !permitsCustomerLogin(allowCustomerLogin, creds)) {
+            logAuth("authorize(credentials) rejected", {
+              reason: "customer_group",
+              email,
+              userId: user.id,
+              callbackUrl: creds?.callbackUrl ?? null
+            });
+            return null;
+          }
+          const sessionUser = sessionUserFromNextAuthUser(user);
+          logAuth("authorize(credentials) ok", summarizeSessionUserForLog(sessionUser));
+          return sessionUser;
+        } catch (err) {
+          console.error("[cms-auth] authorize error (credentials):", err instanceof Error ? err.message : err);
+          logAuth("authorize(credentials) error", {
+            email,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          return null;
+        }
+      }
+    }));
+  }
+  if (enableOtpLogin && authorizeOtp) {
+    providers.push(CredentialsProvider({
+      id: "otp",
+      name: "otp",
+      credentials: {
+        identifier: {
+          label: "Email or phone",
+          type: "text"
+        },
+        code: {
+          label: "Code",
+          type: "text"
+        },
+        channel: {
+          label: "Channel",
+          type: "text"
+        }
+      },
+      async authorize(credentials) {
+        const creds = credentials;
+        const identifier = typeof creds?.identifier === "string" ? creds.identifier.trim() : "";
+        const code = typeof creds?.code === "string" ? creds.code.trim() : "";
+        const ch = creds?.channel === "sms" ? "sms" : "email";
+        if (!identifier || !code) return null;
+        try {
+          const user = await authorizeOtp({
+            identifier,
+            channel: ch,
+            code
+          });
+          if (!user || user.blocked || user.deleted) return null;
+          if (isCustomerGroupUser(user) && !permitsCustomerLogin(allowCustomerLogin, creds)) {
+            logAuth("authorize(otp) rejected", {
+              reason: "customer_group",
+              identifier,
+              callbackUrl: creds?.callbackUrl ?? null
+            });
+            return null;
+          }
+          return sessionUserFromNextAuthUser(user);
+        } catch (err) {
+          console.error("[cms-auth] authorize error (otp):", err instanceof Error ? err.message : err);
+          return null;
+        }
+      }
+    }));
+  }
+  const options = {
+    secret: secret ?? process.env.NEXTAUTH_SECRET,
+    providers,
+    session: {
+      strategy: "jwt"
+    },
+    pages: {
+      signIn: signInPage
+    },
+    cookies: {
+      sessionToken: {
+        name: process.env.NEXTAUTH_URL?.startsWith("https") ? "__Secure-next-auth.session-token" : "next-auth.session-token",
+        options: {
+          httpOnly: true,
+          sameSite: "lax",
+          path: "/",
+          secure: process.env.NEXTAUTH_URL?.startsWith("https") ?? false
+        }
+      }
+    },
+    callbacks: {
+      async jwt({ token, user, trigger, session }) {
+        if (user) {
+          logAuth("jwt callback: new sign-in", {
+            trigger,
+            user: summarizeSessionUserForLog(user)
+          });
+          const u = user;
+          token.id = u.id;
+          token.groupId = u.groupId;
+          token.groupName = u.groupName;
+          token.isRBACAdmin = u.isRBACAdmin;
+          token.entityPerms = u.entityPerms;
+          token.adminAccess = u.adminAccess;
+          token.vendorIds = u.vendorIds;
+          token.activeVendorId = u.activeVendorId;
+          token.vendorRole = u.vendorRole;
+          token.vendorRoleId = u.vendorRoleId;
+          token.vendorRoleName = u.vendorRoleName;
+          token.isVendorRoleOwner = u.isVendorRoleOwner;
+          token.vendorEntityPerms = u.vendorEntityPerms;
+          token.isVendorPortal = u.isVendorPortal;
+          token.isVendorOwner = u.isVendorOwner;
+        }
+        if (trigger === "update" && session && typeof session === "object") {
+          logAuth("jwt callback: session update", {
+            trigger
+          });
+          const s = session;
+          const t = token;
+          if (typeof s.name === "string") t.name = s.name;
+          if (typeof s.email === "string") t.email = s.email;
+          if (typeof s.activeVendorId === "number") t.activeVendorId = s.activeVendorId;
+        }
+        return token;
+      },
+      async session({ session, token }) {
+        const t = token;
+        logAuth("session callback", {
+          tokenHasId: t.id != null,
+          tokenEmail: typeof t.email === "string" ? t.email : null,
+          sessionUser: summarizeSessionUserForLog(session.user)
+        });
+        if (session.user) {
+          if (typeof t.name === "string") session.user.name = t.name;
+          if (typeof t.email === "string") session.user.email = t.email;
+          session.user.id = t.id;
+          session.user.groupId = t.groupId;
+          session.user.groupName = t.groupName;
+          session.user.isRBACAdmin = t.isRBACAdmin;
+          session.user.entityPerms = t.entityPerms;
+          session.user.adminAccess = t.adminAccess;
+          session.user.vendorIds = t.vendorIds;
+          session.user.activeVendorId = t.activeVendorId;
+          session.user.vendorRole = t.vendorRole;
+          session.user.vendorRoleId = t.vendorRoleId;
+          session.user.vendorRoleName = t.vendorRoleName;
+          session.user.isVendorRoleOwner = t.isVendorRoleOwner;
+          session.user.vendorEntityPerms = t.vendorEntityPerms;
+          session.user.isVendorPortal = t.isVendorPortal;
+          session.user.isVendorOwner = t.isVendorOwner;
+        }
+        return session;
+      }
+    }
+  };
+  return extend ? extend(options) : options;
+}
+chunkUSNT2KNT_cjs.__name(getNextAuthOptions, "getNextAuthOptions");
+function getStorefrontNextAuthOptions(config) {
+  return getNextAuthOptions({
+    ...config,
+    allowCustomerLogin: true
+  });
+}
+chunkUSNT2KNT_cjs.__name(getStorefrontNextAuthOptions, "getStorefrontNextAuthOptions");
+
+exports.createCmsMiddleware = createCmsMiddleware;
+exports.defaultPublicApiMethods = defaultPublicApiMethods;
+exports.getNextAuthOptions = getNextAuthOptions;
+exports.getStorefrontNextAuthOptions = getStorefrontNextAuthOptions;
+exports.isAuthDebugClientEnabled = isAuthDebugClientEnabled;
+exports.isAuthDebugEnabled = isAuthDebugEnabled;
+exports.logAuth = logAuth;
+exports.logAuthClient = logAuthClient;
+exports.nextAuthCookieDebugInfo = nextAuthCookieDebugInfo;
+exports.seedAdministratorPermissions = seedAdministratorPermissions;
+exports.summarizeSessionUserForLog = summarizeSessionUserForLog;

package/dist/chunk-CRFV5WJK.js

@@ -0,0 +1,16 @@
+import { __name } from './chunk-SHUYVCID.js';
+
+// src/message-templates/interpolate.ts
+function applyTemplateVars(template, variables) {
+  let out = template;
+  for (const [k, v] of Object.entries(variables)) {
+    out = out.split(`{{${k}}}`).join(v);
+  }
+  if (variables.code !== void 0) {
+    out = out.split("{{otp}}").join(variables.code);
+  }
+  return out;
+}
+__name(applyTemplateVars, "applyTemplateVars");
+
+export { applyTemplateVars };

package/dist/chunk-D5FBNKQM.cjs

@@ -0,0 +1,104 @@
+'use strict';
+
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+
+// src/plugins/erp/erp-log.ts
+var ERP_LOG = "[webcore:erp]";
+function logErp(event, detail) {
+  if (detail && Object.keys(detail).length) console.info(ERP_LOG, event, detail);
+  else console.info(ERP_LOG, event);
+}
+chunkUSNT2KNT_cjs.__name(logErp, "logErp");
+function warnErp(event, detail) {
+  console.warn(ERP_LOG, event, detail);
+}
+chunkUSNT2KNT_cjs.__name(warnErp, "warnErp");
+function errorErp(event, detail) {
+  console.error(ERP_LOG, event, detail);
+}
+chunkUSNT2KNT_cjs.__name(errorErp, "errorErp");
+function erpSafeWebhookUrl(url) {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return "(invalid webhook URL)";
+  }
+}
+chunkUSNT2KNT_cjs.__name(erpSafeWebhookUrl, "erpSafeWebhookUrl");
+
+// src/plugins/erp/erp-queue.ts
+var ERP_QUEUE_NAME = "erp";
+function queuePayloadSummary(payload) {
+  if (payload.kind === "order") {
+    const o = payload.order;
+    return {
+      kind: payload.kind,
+      platformOrderId: o.platformOrderId ?? o.platformOrderNumber,
+      itemCount: Array.isArray(o.items) ? o.items.length : 0
+    };
+  }
+  return {
+    kind: payload.kind
+  };
+}
+chunkUSNT2KNT_cjs.__name(queuePayloadSummary, "queuePayloadSummary");
+async function queueErp(cms, payload) {
+  const queue = cms.getPlugin("queue");
+  if (!queue) {
+    warnErp("queue:add_skipped", {
+      reason: "queue_plugin_missing",
+      ...queuePayloadSummary(payload)
+    });
+    return;
+  }
+  logErp("queue:add", {
+    job: ERP_QUEUE_NAME,
+    ...queuePayloadSummary(payload)
+  });
+  await queue.add(ERP_QUEUE_NAME, payload);
+}
+chunkUSNT2KNT_cjs.__name(queueErp, "queueErp");
+function registerErpQueueProcessor(cms) {
+  const queue = cms.getPlugin("queue");
+  if (!queue) return;
+  queue.registerProcessor(ERP_QUEUE_NAME, async (data) => {
+    const erp = cms.getPlugin("erp");
+    if (!erp) {
+      warnErp("queue:processor_skip", {
+        reason: "erp_plugin_missing"
+      });
+      return;
+    }
+    const payload = data;
+    logErp("queue:job_start", queuePayloadSummary(payload));
+    try {
+      if (payload.kind === "lead") {
+        await erp.submission.submitContact(payload.contact);
+      } else if (payload.kind === "formOpportunity") {
+        await erp.submission.submitFormOpportunity(payload.contact);
+      } else if (payload.kind === "createContact") {
+        await erp.submission.submitCreateContact(payload.contact);
+      } else if (payload.kind === "order") {
+        await erp.submission.submitOrder(payload.order);
+      } else if (payload.kind === "productUpsert") {
+        await erp.submission.submitProductUpsert(payload.product);
+      }
+      logErp("queue:job_done", queuePayloadSummary(payload));
+    } catch (e) {
+      errorErp("queue:job_failed", {
+        ...queuePayloadSummary(payload),
+        message: e instanceof Error ? e.message : String(e)
+      });
+      throw e;
+    }
+  });
+}
+chunkUSNT2KNT_cjs.__name(registerErpQueueProcessor, "registerErpQueueProcessor");
+
+exports.erpSafeWebhookUrl = erpSafeWebhookUrl;
+exports.errorErp = errorErp;
+exports.logErp = logErp;
+exports.queueErp = queueErp;
+exports.registerErpQueueProcessor = registerErpQueueProcessor;
+exports.warnErp = warnErp;