@nimee/inforu 1.0.16 → 1.0.18

package/src/ecommerce.ts

@@ -0,0 +1,346 @@
+import { CustomError } from "@nimee/error-handler";
+import logger from "@nimee/logger";
+import axios from "axios";
+
+// Type definitions for ecommerce order
+export interface IProductAttribute {
+  label: string;
+  value: string;
+}
+
+export interface IOrderItem {
+  ProductCode: string;
+  ProductName: string;
+  ProductPrice: number;
+  ProductQty: number;
+  ProductDescription?: string | null;
+  ProductLink?: string;
+  ProductImage?: string;
+  Custom1?: string;
+  Custom2?: string;
+  Custom3?: string;
+  Custom4?: string;
+  Custom5?: string;
+  ProductAttributes?: IProductAttribute[];
+}
+
+export interface IEcommerceOrderData {
+  Event: string;
+  Category?: string; // Original event type (e.g., PURCHASED_PHYSICAL_BOOK)
+  StoreName: string;
+  StoreBaseUrl: string;
+  LinkToCart?: string;
+  IP?: string;
+  CustomerEmail: string;
+  CustomerFirstName: string;
+  CustomerLastName: string;
+  ContactRefId?: string;
+  SubscriberStatus?: string;
+  AddToGroupName?: string[];
+  OrderNumber: string;
+  OrderAmount: string | number;
+  OrderStatus: string;
+  BillingAddress?: string;
+  ShippingAddress?: string;
+  PaymentDescription?: string;
+  ShippingDescription?: string;
+  OrderTime: string;
+  OrderItems: IOrderItem[];
+}
+
+export interface IEcommercePayload {
+  Data: IEcommerceOrderData;
+}
+
+// Type for ecommerce events
+export enum EcommerceEventType {
+  // Purchase events
+  PURCHASED_PHYSICAL_BOOK = "PURCHASED_PHYSICAL_BOOK",
+  PURCHASED_DIGITAL_BOOK = "PURCHASED_DIGITAL_BOOK",
+  PURCHASED_VOD_PRODUCT = "PURCHASED_VOD_PRODUCT",
+  PURCHASED_EVENT_TICKET = "PURCHASED_EVENT_TICKET",
+
+  // Abandoned cart events
+  ABANDONED_CART_BOOK = "ABANDONED_CART_BOOK",
+  ABANDONED_CART = "ABANDONED_CART", // Generic abandoned cart
+}
+
+// Map internal event types to InfoRu API event names
+const EVENT_TYPE_TO_API_EVENT: Record<EcommerceEventType, string> = {
+  [EcommerceEventType.PURCHASED_PHYSICAL_BOOK]: "sales_order_place_after",
+  [EcommerceEventType.PURCHASED_DIGITAL_BOOK]: "sales_order_place_after",
+  [EcommerceEventType.PURCHASED_VOD_PRODUCT]: "sales_order_place_after",
+  [EcommerceEventType.PURCHASED_EVENT_TICKET]: "sales_order_place_after",
+  [EcommerceEventType.ABANDONED_CART_BOOK]: "cart_abandoned",
+  [EcommerceEventType.ABANDONED_CART]: "cart_abandoned",
+};
+
+// Interface for product/item in order
+export interface IOrderProduct {
+  code: string;
+  name: string;
+  price: number;
+  quantity: number;
+  description?: string;
+  link?: string;
+  image?: string;
+  // Book-specific fields
+  isbn?: string;
+  author?: string;
+  publisher?: string;
+  format?: string; // "physical" or "digital"
+  downloadLink?: string; // for digital products
+  // Event-specific fields
+  eventDate?: string | Date;
+  eventLocation?: string;
+  seatNumber?: string;
+  // VOD-specific fields
+  vodDuration?: string;
+  vodExpiry?: string | Date;
+  vodStreamUrl?: string;
+}
+
+// Interface for ecommerce purchase input data
+export interface IEcommercePurchaseData {
+  customerEmail: string;
+  customerFirstName: string;
+  customerLastName: string;
+  orderNumber: string;
+  orderAmount: number | string;
+  orderStatus?: string;
+  billingAddress?: string;
+  shippingAddress?: string;
+  paymentMethod?: string;
+  shippingMethod?: string;
+  orderTime?: string | Date;
+  products: IOrderProduct[];
+  storeName?: string;
+  storeUrl?: string;
+  ip?: string;
+  contactRefId?: string;
+  // Additional fields for abandoned carts
+  cartUrl?: string;
+  abandonedAt?: string | Date;
+  reminderCount?: number;
+}
+
+/**
+ * Helper function to determine product type from event type
+ */
+function getProductType(eventType: EcommerceEventType): string {
+  switch (eventType) {
+    case EcommerceEventType.PURCHASED_PHYSICAL_BOOK:
+      return "physical_book";
+    case EcommerceEventType.PURCHASED_DIGITAL_BOOK:
+      return "digital_book";
+    case EcommerceEventType.PURCHASED_VOD_PRODUCT:
+      return "vod";
+    case EcommerceEventType.PURCHASED_EVENT_TICKET:
+      return "event_ticket";
+    case EcommerceEventType.ABANDONED_CART_BOOK:
+      return "abandoned_book";
+    case EcommerceEventType.ABANDONED_CART:
+      return "abandoned_cart";
+    default:
+      return "product";
+  }
+}
+
+/**
+ * Transforms purchase data into ecommerce API format
+ */
+function prepareEcommercePayload(
+  eventType: EcommerceEventType,
+  data: IEcommercePurchaseData
+): IEcommercePayload {
+  const isAbandonedCart = eventType === EcommerceEventType.ABANDONED_CART_BOOK || eventType === EcommerceEventType.ABANDONED_CART;
+
+  // Map products to order items
+  const orderItems: IOrderItem[] = data.products.map((product: IOrderProduct) => ({
+    ProductCode: product.code || product.isbn || "",
+    ProductName: product.name,
+    ProductPrice: product.price,
+    ProductQty: product.quantity,
+    ProductDescription: product.description || null,
+    ProductLink: product.link,
+    ProductImage: product.image,
+    // Custom fields based on product type
+    Custom1: product.isbn || product.eventDate?.toString() || product.vodDuration,
+    Custom2: product.author || product.eventLocation || product.vodExpiry?.toString(),
+    Custom3: product.publisher || product.seatNumber || product.vodStreamUrl,
+    Custom4: product.format || getProductType(eventType),
+    Custom5: eventType, // Add the original event type (e.g., PURCHASED_PHYSICAL_BOOK)
+    ProductAttributes: [
+      // Always include the event category
+      { label: "event_category", value: eventType },
+      ...(product.format ? [{ label: "format", value: product.format }] : []),
+      ...(product.author ? [{ label: "author", value: product.author }] : []),
+      ...(product.publisher ? [{ label: "publisher", value: product.publisher }] : []),
+      ...(product.eventDate ? [{ label: "event_date", value: product.eventDate.toString() }] : []),
+      ...(product.eventLocation ? [{ label: "location", value: product.eventLocation }] : []),
+      ...(product.seatNumber ? [{ label: "seat", value: product.seatNumber }] : []),
+      ...(product.downloadLink ? [{ label: "download_link", value: product.downloadLink }] : []),
+    ].filter(attr => attr.value) // Remove empty attributes
+  }));
+
+  // Format order time
+  const orderTime = data.orderTime
+    ? (data.orderTime instanceof Date
+        ? data.orderTime.toISOString().replace('T', ' ').substring(0, 19)
+        : data.orderTime)
+    : new Date().toISOString().replace('T', ' ').substring(0, 19);
+
+  // Get the appropriate InfoRu API event name
+  const apiEventName = EVENT_TYPE_TO_API_EVENT[eventType];
+
+  // Determine group names based on event type
+  const groupNames: string[] = [];
+  switch (eventType) {
+    case EcommerceEventType.PURCHASED_PHYSICAL_BOOK:
+      groupNames.push("physical_book_buyers");
+      break;
+    case EcommerceEventType.PURCHASED_DIGITAL_BOOK:
+      groupNames.push("digital_book_buyers");
+      break;
+    case EcommerceEventType.PURCHASED_VOD_PRODUCT:
+      groupNames.push("vod_purchasers");
+      break;
+    case EcommerceEventType.PURCHASED_EVENT_TICKET:
+      groupNames.push("event_attendees");
+      break;
+    case EcommerceEventType.ABANDONED_CART_BOOK:
+      groupNames.push("abandoned_cart_books");
+      break;
+    case EcommerceEventType.ABANDONED_CART:
+      groupNames.push("abandoned_cart_general");
+      break;
+  }
+
+  // Determine if physical shipping is needed
+  const needsShipping = eventType === EcommerceEventType.PURCHASED_PHYSICAL_BOOK ||
+                       eventType === EcommerceEventType.PURCHASED_EVENT_TICKET;
+
+  return {
+    Data: {
+      Event: apiEventName,
+      Category: eventType, // Add the original event type (e.g., PURCHASED_PHYSICAL_BOOK)
+      StoreName: data.storeName || "Nimi Store",
+      StoreBaseUrl: data.storeUrl || "https://www.nimi.co.il/",
+      LinkToCart: isAbandonedCart && data.cartUrl
+        ? data.cartUrl
+        : `${data.storeUrl || "https://www.nimi.co.il"}/checkout/cart/`,
+      IP: data.ip,
+      CustomerEmail: data.customerEmail,
+      CustomerFirstName: data.customerFirstName,
+      CustomerLastName: data.customerLastName,
+      ContactRefId: data.contactRefId || "",
+      SubscriberStatus: "Subscribed",
+      AddToGroupName: groupNames,
+      OrderNumber: data.orderNumber,
+      OrderAmount: String(data.orderAmount),
+      OrderStatus: isAbandonedCart ? "abandoned" : (data.orderStatus || "processing"),
+      BillingAddress: data.billingAddress,
+      ShippingAddress: needsShipping ? data.shippingAddress : undefined,
+      PaymentDescription: data.paymentMethod || "credit card",
+      ShippingDescription: needsShipping
+        ? (data.shippingMethod || "Standard shipping")
+        : "Digital delivery - Instant",
+      OrderTime: orderTime,
+      OrderItems: orderItems
+    }
+  };
+}
+
+/**
+ * Sends ecommerce order data to InfoRu API based on event type
+ */
+export async function sendEcommerceOrder(params: {
+  apiKey: string;
+  eventType: EcommerceEventType;
+  data: IEcommercePurchaseData;
+}) {
+  try {
+    const { apiKey, eventType, data } = params;
+
+    if (!apiKey) {
+      throw new CustomError("MISSING_API_KEY", 400, "API key is required");
+    }
+
+    if (!eventType || !Object.values(EcommerceEventType).includes(eventType)) {
+      throw new CustomError("INVALID_EVENT_TYPE", 400, `Invalid event type. Must be one of: ${Object.values(EcommerceEventType).join(', ')}`);
+    }
+
+    if (!data || !data.customerEmail || !data.orderNumber) {
+      throw new CustomError("MISSING_REQUIRED_DATA", 400, "Customer email and order number are required");
+    }
+
+    if (!data.products || data.products.length === 0) {
+      throw new CustomError("NO_ORDER_ITEMS", 400, "Order must contain at least one product");
+    }
+
+    // Prepare the payload based on event type
+    const payload = prepareEcommercePayload(eventType, data);
+
+    // API endpoint for ecommerce
+    const apiUrl = "https://capi.inforu.co.il/api/v2/EcommerceApi";
+
+    // Send the request
+    const response = await axios.post(apiUrl, payload, {
+      headers: {
+        "Authorization": apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+
+    return {
+      success: true,
+      data: response.data,
+      orderNumber: data.orderNumber,
+      eventType
+    };
+
+  } catch (error) {
+    logger.error("Failed to send ecommerce order", {
+      error: error instanceof Error ? error.message : error,
+      eventType: params.eventType,
+      orderNumber: params.data?.orderNumber
+    });
+
+    if (axios.isAxiosError(error)) {
+      throw new CustomError(
+        "ECOMMERCE_API_ERROR",
+        error.response?.status || 500,
+        `Failed to send ecommerce order: ${error.response?.data?.message || error.message}`
+      );
+    }
+
+    throw new CustomError(
+      "ECOMMERCE_ORDER_ERROR",
+      500,
+      `Failed to process ecommerce order: ${error instanceof Error ? error.message : JSON.stringify(error)}`
+    );
+  }
+}
+
+/**
+ * Helper function to determine if an event is an ecommerce event
+ */
+export function isEcommerceEvent(eventName: string): boolean {
+  return Object.values(EcommerceEventType).includes(eventName as EcommerceEventType);
+}
+
+/**
+ * Helper function to validate and parse ecommerce event type
+ */
+export function parseEcommerceEventType(eventName: string): EcommerceEventType | null {
+  if (Object.values(EcommerceEventType).includes(eventName as EcommerceEventType)) {
+    return eventName as EcommerceEventType;
+  }
+  return null;
+}
+
+// Backward compatibility aliases for book events
+export const BookPurchaseEventType = EcommerceEventType; // Type alias
+export type IBookPurchaseData = IEcommercePurchaseData; // Interface alias with books instead of products
+export const isBookPurchaseEvent = isEcommerceEvent;
+export const parseBookPurchaseEventType = parseEcommerceEventType;

package/src/index.ts

@@ -4,3 +4,4 @@ export * from "./createGroup";
 export * from "./automations";
 export * from "./sendWA";
 export * from "./sendEmail";
+export * from "./ecommerce";