universal-agent-memory 0.7.3 → 0.7.4

package/dist/utils/order-processor-refactored.js

@@ -0,0 +1,165 @@
+/**
+ * Order Processing - Refactored using SOLID Principles
+ *
+ * This implementation follows:
+ * - Single Responsibility Principle: Each strategy handles one order type
+ * - Open/Closed Principle: New order types can be added without modifying existing code
+ * - Liskov Substitution Principle: All strategies are interchangeable
+ * - Interface Segregation Principle: Focused interfaces for specific behaviors
+ * - Dependency Inversion Principle: High-level module depends on abstractions
+ */
+// ============================================================================
+// Strategy Implementations (Single Responsibility Principle)
+// ============================================================================
+/**
+ * Strategy for processing digital orders
+ */
+export class DigitalOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'digital';
+    }
+    process(order, logger) {
+        logger.log('Sending email with download link');
+        const processedOrder = {
+            ...order,
+            status: 'delivered',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Digital order delivered via email',
+        };
+    }
+}
+/**
+ * Strategy for processing physical orders
+ */
+export class PhysicalOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'physical';
+    }
+    process(order, logger) {
+        logger.log('Creating shipping label');
+        const processedOrder = {
+            ...order,
+            status: 'shipped',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Physical order shipped',
+        };
+    }
+}
+/**
+ * Strategy for processing subscription orders
+ */
+export class SubscriptionOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'subscription';
+    }
+    process(order, logger) {
+        logger.log('Activating subscription');
+        const processedOrder = {
+            ...order,
+            status: 'active',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Subscription activated',
+        };
+    }
+}
+// ============================================================================
+// Default Logger Implementation
+// ============================================================================
+/**
+ * Console-based logger implementation
+ */
+export class ConsoleLogger {
+    log(message) {
+        console.log(message);
+    }
+}
+// ============================================================================
+// Order Processor (Dependency Inversion Principle)
+// ============================================================================
+/**
+ * Main order processor that uses strategies to handle different order types
+ */
+export class OrderProcessor {
+    strategies;
+    logger;
+    constructor(strategies, logger) {
+        this.strategies = strategies;
+        this.logger = logger;
+    }
+    /**
+     * Process an order using the appropriate strategy
+     */
+    processOrder(order) {
+        const strategy = this.strategies.find((s) => s.canHandle(order.type));
+        if (!strategy) {
+            return {
+                success: false,
+                order,
+                message: `No strategy found for order type: ${order.type}`,
+            };
+        }
+        const result = strategy.process(order, this.logger);
+        this.logger.log(`Order processed: ${order.id}`);
+        return result;
+    }
+}
+// ============================================================================
+// Factory for Easy Setup
+// ============================================================================
+/**
+ * Factory function to create a fully configured OrderProcessor
+ */
+export function createOrderProcessor(logger) {
+    const strategies = [
+        new DigitalOrderStrategy(),
+        new PhysicalOrderStrategy(),
+        new SubscriptionOrderStrategy(),
+    ];
+    return new OrderProcessor(strategies, logger ?? new ConsoleLogger());
+}
+// ============================================================================
+// Usage Example
+// ============================================================================
+/**
+ * Example usage demonstrating the refactored code
+ */
+export function exampleUsage() {
+    const processor = createOrderProcessor();
+    const digitalOrder = {
+        id: 'order-001',
+        type: 'digital',
+        status: 'pending',
+        downloadUrl: 'https://example.com/download/abc',
+    };
+    const physicalOrder = {
+        id: 'order-002',
+        type: 'physical',
+        status: 'pending',
+        shippingAddress: '123 Main St, City, Country',
+    };
+    const subscriptionOrder = {
+        id: 'order-003',
+        type: 'subscription',
+        status: 'pending',
+        subscriptionPlan: 'premium-monthly',
+    };
+    console.log('Processing digital order:');
+    const digitalResult = processor.processOrder(digitalOrder);
+    console.log('Result:', digitalResult);
+    console.log('\nProcessing physical order:');
+    const physicalResult = processor.processOrder(physicalOrder);
+    console.log('Result:', physicalResult);
+    console.log('\nProcessing subscription order:');
+    const subscriptionResult = processor.processOrder(subscriptionOrder);
+    console.log('Result:', subscriptionResult);
+}
+//# sourceMappingURL=order-processor-refactored.js.map

package/dist/utils/order-processor-refactored.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-refactored.js","sourceRoot":"","sources":["../../src/utils/order-processor-refactored.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA0FH,+EAA+E;AAC/E,6DAA6D;AAC7D,+EAA+E;AAE/E;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAC/B,SAAS,CAAC,SAAoB;QAC5B,OAAO,SAAS,KAAK,SAAS,CAAC;IACjC,CAAC;IAED,OAAO,CAAC,KAAe,EAAE,MAAc;QACrC,MAAM,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;QAC/C,MAAM,cAAc,GAAiB;YACnC,GAAI,KAAsB;YAC1B,MAAM,EAAE,WAAW;SACpB,CAAC;QACF,OAAO;YACL,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,cAAc;YACrB,OAAO,EAAE,mCAAmC;SAC7C,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,qBAAqB;IAChC,SAAS,CAAC,SAAoB;QAC5B,OAAO,SAAS,KAAK,UAAU,CAAC;IAClC,CAAC;IAED,OAAO,CAAC,KAAe,EAAE,MAAc;QACrC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;QACtC,MAAM,cAAc,GAAkB;YACpC,GAAI,KAAuB;YAC3B,MAAM,EAAE,SAAS;SAClB,CAAC;QACF,OAAO;YACL,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,cAAc;YACrB,OAAO,EAAE,wBAAwB;SAClC,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,yBAAyB;IACpC,SAAS,CAAC,SAAoB;QAC5B,OAAO,SAAS,KAAK,cAAc,CAAC;IACtC,CAAC;IAED,OAAO,CAAC,KAAe,EAAE,MAAc;QACrC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;QACtC,MAAM,cAAc,GAAsB;YACxC,GAAI,KAA2B;YAC/B,MAAM,EAAE,QAAQ;SACjB,CAAC;QACF,OAAO;YACL,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,cAAc;YACrB,OAAO,EAAE,wBAAwB;SAClC,CAAC;IACJ,CAAC;CACF;AAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E;;GAEG;AACH,MAAM,OAAO,aAAa;IACxB,GAAG,CAAC,OAAe;QACjB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;CACF;AAED,+EAA+E;AAC/E,mDAAmD;AACnD,+EAA+E;AAE/E;;GAEG;AACH,MAAM,OAAO,cAAc;IACR,UAAU,CAA4B;IACtC,MAAM,CAAS;IAEhC,YAAY,UAAqC,EAAE,MAAc;QAC/D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,KAAe;QAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK;gBACL,OAAO,EAAE,qCAAqC,KAAK,CAAC,IAAI,EAAE;aAC3D,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,oBAAoB,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;QAEhD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED,+EAA+E;AAC/E,yBAAyB;AACzB,+EAA+E;AAE/E;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAe;IAClD,MAAM,UAAU,GAA8B;QAC5C,IAAI,oBAAoB,EAAE;QAC1B,IAAI,qBAAqB,EAAE;QAC3B,IAAI,yBAAyB,EAAE;KAChC,CAAC;IAEF,OAAO,IAAI,cAAc,CAAC,UAAU,EAAE,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC,CAAC;AACvE,CAAC;AAED,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E;;GAEG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,SAAS,GAAG,oBAAoB,EAAE,CAAC;IAEzC,MAAM,YAAY,GAAiB;QACjC,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,SAAS;QACjB,WAAW,EAAE,kCAAkC;KAChD,CAAC;IAEF,MAAM,aAAa,GAAkB;QACnC,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,SAAS;QACjB,eAAe,EAAE,4BAA4B;KAC9C,CAAC;IAEF,MAAM,iBAAiB,GAAsB;QAC3C,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,SAAS;QACjB,gBAAgB,EAAE,iBAAiB;KACpC,CAAC;IAEF,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;IACzC,MAAM,aAAa,GAAG,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IAC3D,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IAEtC,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;IAC5C,MAAM,cAAc,GAAG,SAAS,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IAEvC,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;IAChD,MAAM,kBAAkB,GAAG,SAAS,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;IACrE,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;AAC7C,CAAC"}

package/dist/utils/order-processor-strategy.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Strategy Pattern Implementation for Order Processing
+ *
+ * The Strategy pattern allows defining a family of algorithms, encapsulating each one,
+ * and making them interchangeable. This refactoring replaces conditional logic with
+ * polymorphic behavior.
+ */
+type OrderType = 'digital' | 'physical' | 'subscription';
+interface Order {
+    type: OrderType;
+    status?: string;
+    [key: string]: any;
+}
+/**
+ * OrderProcessingStrategy defines the contract for all order processing strategies.
+ * Each concrete strategy implements the process method according to its specific logic.
+ */
+interface OrderProcessingStrategy {
+    process(order: Order): Order;
+}
+/**
+ * DigitalOrderStrategy handles digital product orders.
+ * Digital orders are immediately delivered upon processing.
+ */
+declare class DigitalOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+}
+/**
+ * PhysicalOrderStrategy handles physical product orders.
+ * Physical orders require shipping and physical delivery.
+ */
+declare class PhysicalOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+    private estimateDelivery;
+}
+/**
+ * SubscriptionOrderStrategy handles subscription orders.
+ * Subscriptions activate immediately and require ongoing billing.
+ */
+declare class SubscriptionOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+    private calculateNextBilling;
+}
+/**
+ * OrderProcessor acts as the context that uses strategies to process orders.
+ * It maintains a strategy registry and delegates order processing to the appropriate strategy.
+ */
+declare class OrderProcessor {
+    private strategies;
+    constructor();
+    /**
+     * Process an order using the appropriate strategy based on its type.
+     * @param order The order to process
+     * @returns The processed order with status and additional metadata
+     * @throws Error if no strategy is found for the order type
+     */
+    processOrder(order: Order): Order;
+    /**
+     * Register a custom strategy for a specific order type.
+     * This allows extending the processor with new order types at runtime.
+     * @param orderType The order type this strategy handles
+     * @param strategy The strategy to register
+     */
+    registerStrategy(orderType: string, strategy: OrderProcessingStrategy): void;
+    /**
+     * Get all registered order types.
+     * @returns Array of supported order types
+     */
+    getSupportedOrderTypes(): OrderType[];
+}
+export { Order, OrderType, OrderProcessingStrategy, DigitalOrderStrategy, PhysicalOrderStrategy, SubscriptionOrderStrategy, OrderProcessor };
+//# sourceMappingURL=order-processor-strategy.d.ts.map

package/dist/utils/order-processor-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-strategy.d.ts","sourceRoot":"","sources":["../../src/utils/order-processor-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,KAAK,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAGzD,UAAU,KAAK;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAMD;;;GAGG;AACH,UAAU,uBAAuB;IAC/B,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;CAC9B;AAMD;;;GAGG;AACH,cAAM,oBAAqB,YAAW,uBAAuB;IAC3D,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;CAQ7B;AAED;;;GAGG;AACH,cAAM,qBAAsB,YAAW,uBAAuB;IAC5D,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAU5B,OAAO,CAAC,gBAAgB;CAKzB;AAED;;;GAGG;AACH,cAAM,yBAA0B,YAAW,uBAAuB;IAChE,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAW5B,OAAO,CAAC,oBAAoB;CAK7B;AAMD;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,UAAU,CAA0C;;IAW5D;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAUjC;;;;;OAKG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAI5E;;;OAGG;IACH,sBAAsB,IAAI,SAAS,EAAE;CAGtC;AAgDD,OAAO,EACL,KAAK,EACL,SAAS,EACT,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,cAAc,EACf,CAAC"}

package/dist/utils/order-processor-strategy.js

@@ -0,0 +1,158 @@
+/**
+ * Strategy Pattern Implementation for Order Processing
+ *
+ * The Strategy pattern allows defining a family of algorithms, encapsulating each one,
+ * and making them interchangeable. This refactoring replaces conditional logic with
+ * polymorphic behavior.
+ */
+// ============================================================================
+// CONCRETE STRATEGIES
+// ============================================================================
+/**
+ * DigitalOrderStrategy handles digital product orders.
+ * Digital orders are immediately delivered upon processing.
+ */
+class DigitalOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'delivered',
+            deliveryMethod: 'digital',
+            deliveryTimestamp: new Date().toISOString()
+        };
+    }
+}
+/**
+ * PhysicalOrderStrategy handles physical product orders.
+ * Physical orders require shipping and physical delivery.
+ */
+class PhysicalOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'shipped',
+            deliveryMethod: 'physical',
+            shippingDate: new Date().toISOString(),
+            estimatedDelivery: this.estimateDelivery()
+        };
+    }
+    estimateDelivery() {
+        const date = new Date();
+        date.setDate(date.getDate() + 5); // 5 business days
+        return date.toISOString();
+    }
+}
+/**
+ * SubscriptionOrderStrategy handles subscription orders.
+ * Subscriptions activate immediately and require ongoing billing.
+ */
+class SubscriptionOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'active',
+            subscriptionType: 'recurring',
+            billingCycle: 'monthly',
+            activationDate: new Date().toISOString(),
+            nextBilling: this.calculateNextBilling()
+        };
+    }
+    calculateNextBilling() {
+        const date = new Date();
+        date.setMonth(date.getMonth() + 1);
+        return date.toISOString();
+    }
+}
+// ============================================================================
+// CONTEXT (ORDER PROCESSOR)
+// ============================================================================
+/**
+ * OrderProcessor acts as the context that uses strategies to process orders.
+ * It maintains a strategy registry and delegates order processing to the appropriate strategy.
+ */
+class OrderProcessor {
+    strategies;
+    constructor() {
+        // Initialize the strategy registry
+        this.strategies = new Map([
+            ['digital', new DigitalOrderStrategy()],
+            ['physical', new PhysicalOrderStrategy()],
+            ['subscription', new SubscriptionOrderStrategy()]
+        ]);
+    }
+    /**
+     * Process an order using the appropriate strategy based on its type.
+     * @param order The order to process
+     * @returns The processed order with status and additional metadata
+     * @throws Error if no strategy is found for the order type
+     */
+    processOrder(order) {
+        const strategy = this.strategies.get(order.type);
+        if (!strategy) {
+            throw new Error(`No processing strategy found for order type: ${order.type}`);
+        }
+        return strategy.process(order);
+    }
+    /**
+     * Register a custom strategy for a specific order type.
+     * This allows extending the processor with new order types at runtime.
+     * @param orderType The order type this strategy handles
+     * @param strategy The strategy to register
+     */
+    registerStrategy(orderType, strategy) {
+        this.strategies.set(orderType, strategy);
+    }
+    /**
+     * Get all registered order types.
+     * @returns Array of supported order types
+     */
+    getSupportedOrderTypes() {
+        return Array.from(this.strategies.keys());
+    }
+}
+// ============================================================================
+// USAGE EXAMPLE
+// ============================================================================
+/**
+ * Example usage demonstrating the Strategy pattern in action.
+ */
+function demonstrateOrderProcessing() {
+    const processor = new OrderProcessor();
+    // Example orders
+    const digitalOrder = {
+        type: 'digital',
+        id: 'DIG-001',
+        product: 'Premium Software License',
+        price: 99.99
+    };
+    const physicalOrder = {
+        type: 'physical',
+        id: 'PHY-001',
+        product: 'Office Chair',
+        price: 249.99,
+        shippingAddress: '123 Main St, City, State'
+    };
+    const subscriptionOrder = {
+        type: 'subscription',
+        id: 'SUB-001',
+        product: 'Cloud Storage Pro',
+        price: 19.99
+    };
+    // Process orders
+    console.log('Processing Digital Order:');
+    console.log(JSON.stringify(processor.processOrder(digitalOrder), null, 2));
+    console.log('\nProcessing Physical Order:');
+    console.log(JSON.stringify(processor.processOrder(physicalOrder), null, 2));
+    console.log('\nProcessing Subscription Order:');
+    console.log(JSON.stringify(processor.processOrder(subscriptionOrder), null, 2));
+    // Show supported order types
+    console.log('\nSupported Order Types:', processor.getSupportedOrderTypes());
+}
+// Export for use in other modules
+export { DigitalOrderStrategy, PhysicalOrderStrategy, SubscriptionOrderStrategy, OrderProcessor };
+// Run demo if executed directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    demonstrateOrderProcessing();
+}
+//# sourceMappingURL=order-processor-strategy.js.map

package/dist/utils/order-processor-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-strategy.js","sourceRoot":"","sources":["../../src/utils/order-processor-strategy.ts"],"names":[],"mappings":"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"}

package/dist/utils/order-processor.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Order Processing System - SOLID Principles Implementation
+ *
+ * This module demonstrates a refactored order processing system using:
+ * - Single Responsibility Principle: Each strategy handles one order type
+ * - Open/Closed Principle: New order types can be added without modifying existing code
+ * - Liskov Substitution Principle: All strategies can be used interchangeably
+ * - Interface Segregation Principle: Focused interfaces for specific needs
+ * - Dependency Inversion Principle: Depends on abstractions (interfaces) not concretions
+ */
+import { z } from 'zod';
+/**
+ * Order type enum
+ */
+export declare enum OrderType {
+    DIGITAL = "digital",
+    PHYSICAL = "physical",
+    SUBSCRIPTION = "subscription"
+}
+/**
+ * Order status enum
+ */
+export declare enum OrderStatus {
+    PENDING = "pending",
+    DELIVERED = "delivered",
+    SHIPPED = "shipped",
+    ACTIVE = "active"
+}
+/**
+ * Order interface
+ */
+export interface Order {
+    id: string;
+    type: OrderType;
+    status: OrderStatus;
+    customerId: string;
+    items: Array<{
+        productId: string;
+        quantity: number;
+        price: number;
+    }>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Order processing result interface
+ */
+export interface ProcessingResult {
+    success: boolean;
+    order: Order;
+    message: string;
+}
+/**
+ * Order validation schema using Zod
+ */
+export declare const OrderSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNativeEnum<typeof OrderType>;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof OrderStatus>>;
+    customerId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        quantity: z.ZodNumber;
+        price: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        price: number;
+        productId: string;
+        quantity: number;
+    }, {
+        price: number;
+        productId: string;
+        quantity: number;
+    }>, "many">;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    type: OrderType;
+    status: OrderStatus;
+    id: string;
+    createdAt: Date;
+    customerId: string;
+    items: {
+        price: number;
+        productId: string;
+        quantity: number;
+    }[];
+    updatedAt: Date;
+}, {
+    type: OrderType;
+    id: string;
+    createdAt: Date;
+    customerId: string;
+    items: {
+        price: number;
+        productId: string;
+        quantity: number;
+    }[];
+    updatedAt: Date;
+    status?: OrderStatus | undefined;
+}>;
+/**
+ * OrderProcessor strategy interface
+ * All order processors must implement this interface
+ */
+export interface OrderProcessor {
+    /**
+     * Process an order according to its type
+     * @param order - The order to process
+     * @returns Processing result with updated order status
+     * @throws {Error} If processing fails
+     */
+    process(order: Order): Promise<ProcessingResult>;
+    /**
+     * Validate that the order can be processed
+     * @param order - The order to validate
+     * @returns true if valid, false otherwise
+     */
+    validate(order: Order): boolean;
+}
+/**
+ * Digital order processor strategy
+ * Handles delivery of digital products via email
+ */
+export declare class DigitalOrderProcessor implements OrderProcessor {
+    /**
+     * Process a digital order
+     * @param order - The digital order to process
+     * @returns Processing result with delivered status
+     * @throws {Error} If email delivery fails
+     */
+    process(order: Order): Promise<ProcessingResult>;
+    /**
+     * Validate digital order requirements
+     * @param order - The order to validate
+     * @returns true if valid for digital processing
+     */
+    validate(order: Order): boolean;
+    /**
+     * Send download link email to customer
+     * @param order - The order containing customer information
+     * @throws {Error} If email cannot be sent
+     */
+    private sendDownloadLinkEmail;
+}
+/**
+ * Physical order processor strategy
+ * Handles shipping of physical products
+ */
+export declare class PhysicalOrderProcessor implements OrderProcessor {
+    /**
+     * Process a physical order
+     * @param order - The physical order to process
+     * @returns Processing result with shipped status
+     * @throws {Error} If shipping label creation fails
+     */
+    process(order: Order): Promise<ProcessingResult>;
+    /**
+     * Validate physical order requirements
+     * @param order - The order to validate
+     * @returns true if valid for physical processing
+     */
+    validate(order: Order): boolean;
+    /**
+     * Create shipping label for the order
+     * @param order - The order to create label for
+     * @throws {Error} If shipping label cannot be created
+     */
+    private createShippingLabel;
+}
+/**
+ * Subscription order processor strategy
+ * Handles activation of subscription services
+ */
+export declare class SubscriptionOrderProcessor implements OrderProcessor {
+    /**
+     * Process a subscription order
+     * @param order - The subscription order to process
+     * @returns Processing result with active status
+     * @throws {Error} If subscription activation fails
+     */
+    process(order: Order): Promise<ProcessingResult>;
+    /**
+     * Validate subscription order requirements
+     * @param order - The order to validate
+     * @returns true if valid for subscription processing
+     */
+    validate(order: Order): boolean;
+    /**
+     * Activate subscription service
+     * @param order - The order containing subscription details
+     * @throws {Error} If subscription cannot be activated
+     */
+    private activateSubscription;
+}
+/**
+ * OrderProcessor factory
+ * Responsible for selecting the appropriate processor based on order type
+ * Follows Factory pattern for dependency injection
+ */
+export declare class OrderProcessorFactory {
+    private readonly processors;
+    constructor();
+    /**
+     * Get the appropriate processor for the given order type
+     * @param orderType - The type of order
+     * @returns The appropriate order processor
+     * @throws {Error} If no processor is found for the order type
+     */
+    getProcessor(orderType: OrderType): OrderProcessor;
+    /**
+     * Register a new processor for a specific order type
+     * @param orderType - The order type to handle
+     * @param processor - The processor implementation
+     */
+    registerProcessor(orderType: OrderType, processor: OrderProcessor): void;
+    /**
+     * Check if a processor is registered for the given order type
+     * @param orderType - The order type to check
+     * @returns true if a processor exists
+     */
+    hasProcessor(orderType: OrderType): boolean;
+}
+/**
+ * OrderProcessingService
+ * Main service that coordinates order processing using the appropriate strategy
+ */
+export declare class OrderProcessingService {
+    private readonly processorFactory;
+    constructor(processorFactory?: OrderProcessorFactory);
+    /**
+     * Process an order using the appropriate strategy
+     * @param orderInput - The order data to process (may be unvalidated)
+     * @returns Processing result with updated order
+     * @throws {Error} If validation fails or processing encounters an error
+     */
+    processOrder(orderInput: unknown): Promise<ProcessingResult>;
+}
+/**
+ * Example usage demonstrating the refactored code
+ */
+export declare function exampleUsage(): Promise<void>;
+//# sourceMappingURL=order-processor.d.ts.map

package/dist/utils/order-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor.d.ts","sourceRoot":"","sources":["../../src/utils/order-processor.ts"],"names":[],"mappings":"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"}