@novha/anlia-core-lib 0.1.0

package/src/orders/services/square/SquareOrderServiceImpl.ts

@@ -0,0 +1,330 @@
+import { Inject, Injectable } from "@nestjs/common";
+import { randomUUID } from "crypto";
+import { IOrder } from "../../domain/Order";
+import { IOrderItem, IOrderItemModifier } from "../../domain/OrderItem";
+import { OrderStatus, OrderType } from "../../domain/Enums";
+import { SquareOrder, SquareOrderLineItem, SquareMoney } from "../../domain/posDto/SquareOrder";
+import { ISquareOrderService } from "./SquareOrderService";
+import { IPayment } from "../../../interfaces/domain/Payment";
+import { Money } from "../../../interfaces/domain/Money";
+import { PaymentMethod, PaymentStatus } from "../../../enums/domain/Payments";
+import { Vendor, VendorStatus, VendorType } from "../../../enums/domain/Vendors";
+import { IEventBridgeService } from "../../../eventBridge/service/EventBridgeService";
+import { EventBridgeSymbols } from "../../../eventBridge/ioc";
+import {
+    OrderCancelled, OrderClosed, OrderCompleted, OrderConfirmed,
+    OrderCreated, OrderItemAdded, OrderItemRemoved, OrderItemPrepared,
+    OrderItemServed, OrderItemUpdated, OrderItemVoided,
+    OrderRejected, OrderReopened, OrderSubmitted, OrderUpdated,
+} from "../../../events/domain/OrderEvents";
+import { AggregateType, DomainEventType } from "../../../events/domain/DomainEventType";
+
+@Injectable()
+export class SquareOrderServiceImpl implements ISquareOrderService {
+    constructor(
+        @Inject(EventBridgeSymbols.EventBridgeService)
+        private readonly eventBridge: IEventBridgeService,
+    ) {}
+
+    // ─── Order lifecycle ──────────────────────────────────────────────────────
+
+    async createOrder(order: SquareOrder): Promise<IOrder> {
+        const items    = (order.line_items ?? []).map((item, i) => this.mapSquareLineItem(item, i));
+        const payments = this.mapSquarePayments(order);
+        const net      = order.net_amounts;
+
+        const result: IOrder = {
+            id:           order.id,
+            externalId:   order.id,
+            restaurantId: order.location_id,
+            locationId:   order.location_id,
+            vendor: {
+                id:           Vendor.SQUARE,
+                restaurantId: order.location_id,
+                name:         "Square",
+                vendorCode:   Vendor.SQUARE,
+                type:         VendorType.TECHNOLOGY,
+                status:       VendorStatus.ACTIVE,
+                createdAt:    new Date(),
+                updatedAt:    new Date(),
+            },
+            customer:   order.customer_id ? { id: order.customer_id } : undefined,
+            items,
+            status:     this.mapSquareOrderStatus(order.state),
+            type:       this.mapSquareOrderType(order),
+            subtotal:   this.toMoney(net?.total_money ?? order.total_money),
+            discount:   this.toMoney(net?.discount_money ?? order.total_discount_money),
+            tax:        this.toMoney(net?.tax_money ?? order.total_tax_money),
+            tip:        this.toMoney(net?.tip_money ?? order.total_tip_money),
+            total:      this.toMoney(order.total_money),
+            payments,
+            createdAt:   order.created_at ? new Date(order.created_at) : new Date(),
+            updatedAt:   order.updated_at ? new Date(order.updated_at) : new Date(),
+            completedAt: order.closed_at  ? new Date(order.closed_at)  : undefined,
+        };
+
+        const event: OrderCreated = {
+            ...this.baseEvent(result.id, result.restaurantId),
+            eventType:     DomainEventType.OrderCreated,
+            aggregateType: AggregateType.Order,
+            order:         result,
+        };
+        await this.eventBridge.publish(event);
+        return result;
+    }
+
+    async updateOrder(orderId: string, restaurantId: string, before: Partial<IOrder>, after: Partial<IOrder>): Promise<void> {
+        const event: OrderUpdated = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderUpdated,
+            aggregateType: AggregateType.Order,
+            before,
+            after,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async submitOrder(orderId: string, restaurantId: string, submittedBy?: string): Promise<void> {
+        const event: OrderSubmitted = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderSubmitted,
+            aggregateType: AggregateType.Order,
+            submittedAt:   new Date(),
+            submittedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async confirmOrder(orderId: string, restaurantId: string, confirmedBy?: string): Promise<void> {
+        const event: OrderConfirmed = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderConfirmed,
+            aggregateType: AggregateType.Order,
+            confirmedAt:   new Date(),
+            confirmedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async rejectOrder(orderId: string, restaurantId: string, reason?: string, rejectedBy?: string): Promise<void> {
+        const event: OrderRejected = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderRejected,
+            aggregateType: AggregateType.Order,
+            reason,
+            rejectedAt:    new Date(),
+            rejectedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async cancelOrder(orderId: string, restaurantId: string, previousStatus: OrderStatus, reason?: string, cancelledBy?: string): Promise<void> {
+        const event: OrderCancelled = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderCancelled,
+            aggregateType: AggregateType.Order,
+            previousStatus,
+            reason,
+            cancelledAt:   new Date(),
+            cancelledBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async completeOrder(orderId: string, restaurantId: string, completedBy?: string): Promise<void> {
+        const event: OrderCompleted = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderCompleted,
+            aggregateType: AggregateType.Order,
+            completedAt:   new Date(),
+            completedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async reopenOrder(orderId: string, restaurantId: string, previousStatus: OrderStatus, reason?: string, reopenedBy?: string): Promise<void> {
+        const event: OrderReopened = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderReopened,
+            aggregateType: AggregateType.Order,
+            previousStatus,
+            reason,
+            reopenedAt:    new Date(),
+            reopenedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async closeOrder(orderId: string, restaurantId: string, closedBy?: string): Promise<void> {
+        const event: OrderClosed = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderClosed,
+            aggregateType: AggregateType.Order,
+            closedAt:      new Date(),
+            closedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    // ─── Order items ──────────────────────────────────────────────────────────
+
+    async addOrderItem(orderId: string, restaurantId: string, item: IOrderItem, addedBy?: string): Promise<void> {
+        const event: OrderItemAdded = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemAdded,
+            aggregateType: AggregateType.Order,
+            item,
+            addedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async updateOrderItem(orderId: string, restaurantId: string, before: Partial<IOrderItem>, after: Partial<IOrderItem>, updatedBy?: string): Promise<void> {
+        const event: OrderItemUpdated = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemUpdated,
+            aggregateType: AggregateType.Order,
+            before,
+            after,
+            updatedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async removeOrderItem(orderId: string, restaurantId: string, itemId: string, reason?: string, removedBy?: string): Promise<void> {
+        const event: OrderItemRemoved = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemRemoved,
+            aggregateType: AggregateType.Order,
+            itemId,
+            reason,
+            removedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async markOrderItemPrepared(orderId: string, restaurantId: string, itemId: string, preparedBy?: string): Promise<void> {
+        const event: OrderItemPrepared = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemPrepared,
+            aggregateType: AggregateType.Order,
+            itemId,
+            preparedAt:    new Date(),
+            preparedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async markOrderItemServed(orderId: string, restaurantId: string, itemId: string, servedBy?: string): Promise<void> {
+        const event: OrderItemServed = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemServed,
+            aggregateType: AggregateType.Order,
+            itemId,
+            servedAt:      new Date(),
+            servedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    async voidOrderItem(orderId: string, restaurantId: string, itemId: string, reason?: string, voidedBy?: string): Promise<void> {
+        const event: OrderItemVoided = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType:     DomainEventType.OrderItemVoided,
+            aggregateType: AggregateType.Order,
+            itemId,
+            reason,
+            voidedAt:      new Date(),
+            voidedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+
+    // ─── Private helpers ──────────────────────────────────────────────────────
+
+    private baseEvent(aggregateId: string, restaurantId: string) {
+        return {
+            eventId:      randomUUID(),
+            aggregateId,
+            restaurantId,
+            version:      1,
+            occurredAt:   new Date(),
+        };
+    }
+
+    private toMoney(m?: SquareMoney): Money {
+        return {
+            amount:   m?.amount ?? 0,
+            currency: (m?.currency ?? "USD") as Money["currency"],
+        };
+    }
+
+    private mapSquareOrderType(order: SquareOrder): OrderType {
+        const fulfillment = order.fulfillments?.[0];
+        switch (fulfillment?.type) {
+            case "DELIVERY":
+            case "SHIPMENT":  return OrderType.DELIVERY;
+            case "PICKUP": {
+                if (fulfillment.pickup_details?.is_curbside_pickup) return OrderType.CURBSIDE;
+                return OrderType.TAKEAWAY;
+            }
+            default: return OrderType.DINE_IN;
+        }
+    }
+
+    private mapSquareOrderStatus(state?: string): OrderStatus {
+        switch (state) {
+            case "OPEN":      return OrderStatus.IN_PROGRESS;
+            case "COMPLETED": return OrderStatus.COMPLETED;
+            case "CANCELED":  return OrderStatus.CANCELLED;
+            default:          return OrderStatus.PENDING;
+        }
+    }
+
+    private mapSquareTenderType(type?: string): PaymentMethod {
+        switch (type) {
+            case "CASH":             return PaymentMethod.CASH;
+            case "CARD":
+            case "THIRD_PARTY_CARD": return PaymentMethod.CREDIT_CARD;
+            case "SQUARE_GIFT_CARD": return PaymentMethod.GIFT_CARD;
+            case "WALLET":           return PaymentMethod.MOBILE_PAYMENT;
+            case "BANK_ACCOUNT":     return PaymentMethod.BANK_TRANSFER;
+            default:                 return PaymentMethod.OTHER;
+        }
+    }
+
+    private mapSquareLineItem(item: SquareOrderLineItem, index: number): IOrderItem {
+        const modifiers: IOrderItemModifier[] = (item.modifiers ?? []).map((mod, i) => ({
+            id:       mod.uid ?? `mod-${i}`,
+            name:     mod.name ?? "",
+            quantity: mod.quantity !== undefined ? parseFloat(mod.quantity) : undefined,
+            price:    mod.base_price_money ? this.toMoney(mod.base_price_money) : undefined,
+        }));
+
+        return {
+            id:        item.uid ?? `item-${index}`,
+            productId: item.catalog_object_id ?? item.uid ?? `item-${index}`,
+            name:      item.name ?? "",
+            quantity:  parseFloat(item.quantity ?? "1"),
+            unitPrice: this.toMoney(item.base_price_money),
+            discount:  this.toMoney(item.total_discount_money),
+            tax:       this.toMoney(item.total_tax_money),
+            total:     this.toMoney(item.total_money),
+            notes:     undefined,
+            modifiers: modifiers.length > 0 ? modifiers : undefined,
+        };
+    }
+
+    private mapSquarePayments(order: SquareOrder): IPayment[] {
+        return (order.tenders ?? []).map((tender, i) => ({
+            id:                tender.id ?? `tender-${i}`,
+            externalId:        tender.id,
+            method:            this.mapSquareTenderType(tender.type),
+            amount:            this.toMoney(tender.amount_money),
+            status:            PaymentStatus.COMPLETED,
+            authorizationCode: tender.card_details?.card?.fingerprint,
+            reference:         tender.transaction_id,
+            paidAt:            tender.created_at ? new Date(tender.created_at) : new Date(),
+        }));
+    }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["es2020"],
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true,
+    "types": ["node", "jest"],
+    "outDir": "dist"
+  },
+  "include": ["cdk/**/*.ts", "src/**/*.ts"]
+}