@novha/anlia-core-lib 0.1.0

package/dist/src/orders/services/square/SquareOrderServiceImpl.js

@@ -0,0 +1,308 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareOrderServiceImpl = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const Enums_1 = require("../../domain/Enums");
+const Payments_1 = require("../../../enums/domain/Payments");
+const Vendors_1 = require("../../../enums/domain/Vendors");
+const ioc_1 = require("../../../eventBridge/ioc");
+const DomainEventType_1 = require("../../../events/domain/DomainEventType");
+let SquareOrderServiceImpl = class SquareOrderServiceImpl {
+    constructor(eventBridge) {
+        this.eventBridge = eventBridge;
+    }
+    // ─── Order lifecycle ──────────────────────────────────────────────────────
+    async createOrder(order) {
+        const items = (order.line_items ?? []).map((item, i) => this.mapSquareLineItem(item, i));
+        const payments = this.mapSquarePayments(order);
+        const net = order.net_amounts;
+        const result = {
+            id: order.id,
+            externalId: order.id,
+            restaurantId: order.location_id,
+            locationId: order.location_id,
+            vendor: {
+                id: Vendors_1.Vendor.SQUARE,
+                restaurantId: order.location_id,
+                name: "Square",
+                vendorCode: Vendors_1.Vendor.SQUARE,
+                type: Vendors_1.VendorType.TECHNOLOGY,
+                status: Vendors_1.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 = {
+            ...this.baseEvent(result.id, result.restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderCreated,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            order: result,
+        };
+        await this.eventBridge.publish(event);
+        return result;
+    }
+    async updateOrder(orderId, restaurantId, before, after) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderUpdated,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            before,
+            after,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async submitOrder(orderId, restaurantId, submittedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderSubmitted,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            submittedAt: new Date(),
+            submittedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async confirmOrder(orderId, restaurantId, confirmedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderConfirmed,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            confirmedAt: new Date(),
+            confirmedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async rejectOrder(orderId, restaurantId, reason, rejectedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderRejected,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            reason,
+            rejectedAt: new Date(),
+            rejectedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async cancelOrder(orderId, restaurantId, previousStatus, reason, cancelledBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderCancelled,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            previousStatus,
+            reason,
+            cancelledAt: new Date(),
+            cancelledBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async completeOrder(orderId, restaurantId, completedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderCompleted,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            completedAt: new Date(),
+            completedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async reopenOrder(orderId, restaurantId, previousStatus, reason, reopenedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderReopened,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            previousStatus,
+            reason,
+            reopenedAt: new Date(),
+            reopenedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async closeOrder(orderId, restaurantId, closedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderClosed,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            closedAt: new Date(),
+            closedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    // ─── Order items ──────────────────────────────────────────────────────────
+    async addOrderItem(orderId, restaurantId, item, addedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemAdded,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            item,
+            addedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async updateOrderItem(orderId, restaurantId, before, after, updatedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemUpdated,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            before,
+            after,
+            updatedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async removeOrderItem(orderId, restaurantId, itemId, reason, removedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemRemoved,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            itemId,
+            reason,
+            removedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async markOrderItemPrepared(orderId, restaurantId, itemId, preparedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemPrepared,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            itemId,
+            preparedAt: new Date(),
+            preparedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async markOrderItemServed(orderId, restaurantId, itemId, servedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemServed,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            itemId,
+            servedAt: new Date(),
+            servedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    async voidOrderItem(orderId, restaurantId, itemId, reason, voidedBy) {
+        const event = {
+            ...this.baseEvent(orderId, restaurantId),
+            eventType: DomainEventType_1.DomainEventType.OrderItemVoided,
+            aggregateType: DomainEventType_1.AggregateType.Order,
+            itemId,
+            reason,
+            voidedAt: new Date(),
+            voidedBy,
+        };
+        await this.eventBridge.publish(event);
+    }
+    // ─── Private helpers ──────────────────────────────────────────────────────
+    baseEvent(aggregateId, restaurantId) {
+        return {
+            eventId: (0, crypto_1.randomUUID)(),
+            aggregateId,
+            restaurantId,
+            version: 1,
+            occurredAt: new Date(),
+        };
+    }
+    toMoney(m) {
+        return {
+            amount: m?.amount ?? 0,
+            currency: (m?.currency ?? "USD"),
+        };
+    }
+    mapSquareOrderType(order) {
+        const fulfillment = order.fulfillments?.[0];
+        switch (fulfillment?.type) {
+            case "DELIVERY":
+            case "SHIPMENT": return Enums_1.OrderType.DELIVERY;
+            case "PICKUP": {
+                if (fulfillment.pickup_details?.is_curbside_pickup)
+                    return Enums_1.OrderType.CURBSIDE;
+                return Enums_1.OrderType.TAKEAWAY;
+            }
+            default: return Enums_1.OrderType.DINE_IN;
+        }
+    }
+    mapSquareOrderStatus(state) {
+        switch (state) {
+            case "OPEN": return Enums_1.OrderStatus.IN_PROGRESS;
+            case "COMPLETED": return Enums_1.OrderStatus.COMPLETED;
+            case "CANCELED": return Enums_1.OrderStatus.CANCELLED;
+            default: return Enums_1.OrderStatus.PENDING;
+        }
+    }
+    mapSquareTenderType(type) {
+        switch (type) {
+            case "CASH": return Payments_1.PaymentMethod.CASH;
+            case "CARD":
+            case "THIRD_PARTY_CARD": return Payments_1.PaymentMethod.CREDIT_CARD;
+            case "SQUARE_GIFT_CARD": return Payments_1.PaymentMethod.GIFT_CARD;
+            case "WALLET": return Payments_1.PaymentMethod.MOBILE_PAYMENT;
+            case "BANK_ACCOUNT": return Payments_1.PaymentMethod.BANK_TRANSFER;
+            default: return Payments_1.PaymentMethod.OTHER;
+        }
+    }
+    mapSquareLineItem(item, index) {
+        const modifiers = (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,
+        };
+    }
+    mapSquarePayments(order) {
+        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: Payments_1.PaymentStatus.COMPLETED,
+            authorizationCode: tender.card_details?.card?.fingerprint,
+            reference: tender.transaction_id,
+            paidAt: tender.created_at ? new Date(tender.created_at) : new Date(),
+        }));
+    }
+};
+exports.SquareOrderServiceImpl = SquareOrderServiceImpl;
+exports.SquareOrderServiceImpl = SquareOrderServiceImpl = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(ioc_1.EventBridgeSymbols.EventBridgeService)),
+    __metadata("design:paramtypes", [Object])
+], SquareOrderServiceImpl);

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  testEnvironment: 'node',
+  roots: ['<rootDir>/test'],
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest'
+  }
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@novha/anlia-core-lib",
+  "version": "0.1.0",
+  "private": false,
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "bin": {
+    "anlia-core-lib.js": "bin/anlia-core-lib.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "test": "jest",
+    "cdk": "cdk"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "20.12.7",
+    "aws-cdk": "2.142.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.4.5"
+  },
+  "dependencies": {
+    "@aws-sdk/client-eventbridge": "^3.1090.0",
+    "@aws-sdk/client-secrets-manager": "^3.721.0",
+    "@nestjs/common": "^11.1.28",
+    "@nestjs/core": "^11.1.28",
+    "aws-cdk-lib": "^2.261.0",
+    "constructs": "^10.0.0",
+    "json2typescript": "^1.5.1",
+    "predikt-cdk-lib": "^0.1.7",
+    "reflect-metadata": "^0.2.2",
+    "source-map-support": "^0.5.21"
+  },
+  "author": "Yannick Kazadi",
+  "license": "ISC",
+  "description": "",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/enums/domain/DayOfWeek.ts

@@ -0,0 +1,9 @@
+export enum DayOfWeek {
+    MONDAY = "MONDAY",
+    TUESDAY = "TUESDAY",
+    WEDNESDAY = "WEDNESDAY",
+    THURSDAY = "THURSDAY",
+    FRIDAY = "FRIDAY",
+    SATURDAY = "SATURDAY",
+    SUNDAY = "SUNDAY"
+}

package/src/enums/domain/Delivery.ts

@@ -0,0 +1,20 @@
+export enum DeliveryStatus {
+    PENDING = "PENDING",
+    ASSIGNED = "ASSIGNED",
+    PICKED_UP = "PICKED_UP",
+    IN_TRANSIT = "IN_TRANSIT",
+    DELIVERED = "DELIVERED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+    RETURNED = "RETURNED",
+}
+
+export enum DeliveryProvider {
+    IN_HOUSE = "IN_HOUSE",
+    UBER_EATS = "UBER_EATS",
+    DOORDASH = "DOORDASH",
+    GRUBHUB = "GRUBHUB",
+    SKIPTHEDISHES = "SKIPTHEDISHES",
+    DELIVEROO = "DELIVEROO",
+    OTHER = "OTHER",
+}

package/src/enums/domain/Employee.ts

@@ -0,0 +1,12 @@
+export enum EmployeeRole {
+    OWNER = "OWNER",
+    MANAGER = "MANAGER",
+    SUPERVISOR = "SUPERVISOR",
+    CASHIER = "CASHIER",
+    SERVER = "SERVER",
+    CHEF = "CHEF",
+    KITCHEN = "KITCHEN",
+    DELIVERY_DRIVER = "DELIVERY_DRIVER",
+    HOST = "HOST",
+    OTHER = "OTHER"
+}

package/src/enums/domain/Ingredient.ts

@@ -0,0 +1,33 @@
+export enum IngredientStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    DISCONTINUED = "DISCONTINUED",
+}
+
+export enum AllergenType {
+    GLUTEN = "GLUTEN",
+    CRUSTACEANS = "CRUSTACEANS",
+    EGGS = "EGGS",
+    FISH = "FISH",
+    PEANUTS = "PEANUTS",
+    SOYBEANS = "SOYBEANS",
+    MILK = "MILK",
+    NUTS = "NUTS",
+    CELERY = "CELERY",
+    MUSTARD = "MUSTARD",
+    SESAME = "SESAME",
+    SULPHITES = "SULPHITES",
+    LUPIN = "LUPIN",
+    MOLLUSCS = "MOLLUSCS",
+}
+
+export enum DietaryFlag {
+    VEGAN = "VEGAN",
+    VEGETARIAN = "VEGETARIAN",
+    GLUTEN_FREE = "GLUTEN_FREE",
+    DAIRY_FREE = "DAIRY_FREE",
+    NUT_FREE = "NUT_FREE",
+    HALAL = "HALAL",
+    KOSHER = "KOSHER",
+    ORGANIC = "ORGANIC",
+}

package/src/enums/domain/Inventory.ts

@@ -0,0 +1,39 @@
+export enum InventoryCategory {
+    INGREDIENT = "INGREDIENT",
+    BEVERAGE = "BEVERAGE",
+    PACKAGING = "PACKAGING",
+    CLEANING_SUPPLY = "CLEANING_SUPPLY",
+    EQUIPMENT = "EQUIPMENT",
+    OTHER = "OTHER"
+}
+
+export enum InventoryUnit {
+    PIECE = "PIECE",
+    KILOGRAM = "KILOGRAM",
+    GRAM = "GRAM",
+    LITER = "LITER",
+    MILLILITER = "MILLILITER"
+}
+
+export enum InventoryStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    DISCONTINUED = "DISCONTINUED"
+}
+
+export enum InventoryTransactionType {
+
+    PURCHASE = "PURCHASE",
+
+    SALE_CONSUMPTION = "SALE_CONSUMPTION",
+
+    WASTE = "WASTE",
+
+    SPOILAGE = "SPOILAGE",
+
+    RETURN = "RETURN",
+
+    ADJUSTMENT = "ADJUSTMENT",
+
+    TRANSFER = "TRANSFER"
+}

package/src/enums/domain/Kitchen.ts

@@ -0,0 +1,89 @@
+export enum KitchenStationType {
+    GRILL = "GRILL",
+
+    FRYER = "FRYER",
+
+    PREP = "PREP",
+
+    DESSERT = "DESSERT",
+
+    BAR = "BAR",
+
+    DRINKS = "DRINKS",
+
+    BAKERY = "BAKERY",
+
+    GENERAL = "GENERAL"
+}
+
+export enum KitchenStatus {
+
+    OPEN = "OPEN",
+
+    CLOSED = "CLOSED",
+
+    BUSY = "BUSY",
+
+    MAINTENANCE = "MAINTENANCE"
+}
+
+export enum KitchenTicketStatus {
+
+    QUEUED = "QUEUED",
+
+    IN_PROGRESS = "IN_PROGRESS",
+
+    READY = "READY",
+
+    COMPLETED = "COMPLETED",
+
+    CANCELLED = "CANCELLED"
+}
+
+export enum KitchenPriority {
+
+    LOW = "LOW",
+
+    MEDIUM = "MEDIUM",
+
+    HIGH = "HIGH",
+
+    URGENT = "URGENT"
+}
+
+export enum KitchenStationStatus {
+
+    AVAILABLE = "AVAILABLE",
+
+    BUSY = "BUSY",
+
+    OFFLINE = "OFFLINE",
+
+    MAINTENANCE = "MAINTENANCE"
+}
+
+export enum KitchenTicketItemStatus {
+
+    PENDING = "PENDING",
+
+    IN_PROGRESS = "IN_PROGRESS",
+
+    READY = "READY",
+
+    COMPLETED = "COMPLETED",
+
+    CANCELLED = "CANCELLED"
+}
+
+export enum KitchenItemStatus {
+
+    PENDING = "PENDING",
+
+    IN_PROGRESS = "IN_PROGRESS",
+
+    READY = "READY",
+
+    COMPLETED = "COMPLETED",
+
+    CANCELLED = "CANCELLED"
+}

package/src/enums/domain/Menu.ts

@@ -0,0 +1,14 @@
+export enum MenuItemStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    OUT_OF_STOCK = "OUT_OF_STOCK",
+    SEASONAL = "SEASONAL",
+    DISCONTINUED = "DISCONTINUED",
+}
+
+export enum MenuStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    DRAFT = "DRAFT",
+    ARCHIVED = "ARCHIVED",
+}

package/src/enums/domain/Payments.ts

@@ -0,0 +1,41 @@
+export enum PaymentMethod {
+
+    CASH = "CASH",
+
+    CREDIT_CARD = "CREDIT_CARD",
+
+    DEBIT_CARD = "DEBIT_CARD",
+
+    MOBILE_PAYMENT = "MOBILE_PAYMENT",
+
+    GIFT_CARD = "GIFT_CARD",
+
+    LOYALTY_POINTS = "LOYALTY_POINTS",
+
+    ONLINE_PAYMENT = "ONLINE_PAYMENT",
+
+    BANK_TRANSFER = "BANK_TRANSFER",
+
+    OTHER = "OTHER"
+
+}
+
+export enum PaymentStatus {
+
+    PENDING = "PENDING",
+
+    AUTHORIZED = "AUTHORIZED",
+
+    CAPTURED = "CAPTURED",
+
+    COMPLETED = "COMPLETED",
+
+    FAILED = "FAILED",
+
+    REFUNDED = "REFUNDED",
+
+    PARTIALLY_REFUNDED = "PARTIALLY_REFUNDED",
+
+    CANCELLED = "CANCELLED"
+
+}

package/src/enums/domain/Recipe.ts

@@ -0,0 +1,15 @@
+export enum RecipeStatus {
+    ACTIVE = "ACTIVE",
+    DRAFT = "DRAFT",
+    ARCHIVED = "ARCHIVED",
+}
+
+export enum RecipeYieldUnit {
+    PORTION = "PORTION",
+    PIECE = "PIECE",
+    TRAY = "TRAY",
+    BATCH = "BATCH",
+    LITER = "LITER",
+    KILOGRAM = "KILOGRAM",
+    GRAM = "GRAM",
+}

package/src/enums/domain/Reservation.ts

@@ -0,0 +1,18 @@
+export enum ReservationStatus {
+    PENDING = "PENDING",
+    CONFIRMED = "CONFIRMED",
+    CHECKED_IN = "CHECKED_IN",
+    SEATED = "SEATED",
+    COMPLETED = "COMPLETED",
+    CANCELLED = "CANCELLED",
+    NO_SHOW = "NO_SHOW"
+}
+
+export enum ReservationSource {
+    PHONE = "PHONE",
+    WALK_IN = "WALK_IN",
+    WEBSITE = "WEBSITE",
+    MOBILE_APP = "MOBILE_APP",
+    THIRD_PARTY = "THIRD_PARTY",
+    AI_ASSISTANT = "AI_ASSISTANT"
+}