@legible-sync/example-eda 1.2.0

package/src/plugins/payments/concepts/Payment.ts

@@ -0,0 +1,186 @@
+// plugins/payments/concepts/Payment.ts
+import { Concept } from '@legible-sync/core';
+import { v4 as uuidv4 } from 'uuid';
+
+export const Payment: Concept = {
+  state: {
+    payments: new Map<string, any>(),
+    transactions: new Map<string, any>(),
+  },
+
+  async execute(action: string, input: any) {
+    const state = this.state;
+
+    switch (action) {
+      case 'initiate': {
+        const { orderId, amount, method } = input;
+
+        // Validation
+        if (!orderId || !amount || amount <= 0) {
+          throw new Error('Order ID and positive amount are required');
+        }
+
+        // Create payment
+        const paymentId = uuidv4();
+        const payment = {
+          id: paymentId,
+          orderId,
+          amount,
+          method: method || 'credit_card',
+          status: 'pending',
+          createdAt: new Date(),
+          transactions: []
+        };
+
+        state.payments.set(paymentId, payment);
+
+        return { paymentId, payment };
+      }
+
+      case 'process': {
+        const { paymentId } = input;
+        const payment = state.payments.get(paymentId);
+        if (!payment) {
+          throw new Error('Payment not found');
+        }
+
+        if (payment.status !== 'pending') {
+          throw new Error('Payment is not in pending status');
+        }
+
+        // Simulate payment processing (in real app, integrate with payment gateway)
+        const transactionId = uuidv4();
+        const transaction = {
+          id: transactionId,
+          paymentId,
+          type: 'charge',
+          amount: payment.amount,
+          status: 'processing',
+          gatewayResponse: 'Processing payment...',
+          createdAt: new Date()
+        };
+
+        state.transactions.set(transactionId, transaction);
+        payment.transactions.push(transactionId);
+        payment.status = 'processing';
+        state.payments.set(paymentId, payment);
+
+        return { payment, transaction };
+      }
+
+      case 'confirm': {
+        const { paymentId, transactionId } = input;
+        const payment = state.payments.get(paymentId);
+        const transaction = state.transactions.get(transactionId);
+
+        if (!payment || !transaction) {
+          throw new Error('Payment or transaction not found');
+        }
+
+        if (payment.status !== 'processing') {
+          throw new Error('Payment is not in processing status');
+        }
+
+        // Confirm payment
+        payment.status = 'completed';
+        payment.completedAt = new Date();
+        transaction.status = 'completed';
+        transaction.gatewayResponse = 'Payment successful';
+        transaction.completedAt = new Date();
+
+        state.payments.set(paymentId, payment);
+        state.transactions.set(transactionId, transaction);
+
+        return { payment, transaction };
+      }
+
+      case 'fail': {
+        const { paymentId, reason } = input;
+        const payment = state.payments.get(paymentId);
+        if (!payment) {
+          throw new Error('Payment not found');
+        }
+
+        payment.status = 'failed';
+        payment.failedAt = new Date();
+        payment.failureReason = reason;
+        state.payments.set(paymentId, payment);
+
+        // Mark any pending transactions as failed
+        for (const txId of payment.transactions) {
+          const tx = state.transactions.get(txId);
+          if (tx && tx.status === 'processing') {
+            tx.status = 'failed';
+            tx.gatewayResponse = reason;
+            state.transactions.set(txId, tx);
+          }
+        }
+
+        return { payment };
+      }
+
+      case 'refund': {
+        const { paymentId, amount, reason } = input;
+        const payment = state.payments.get(paymentId);
+        if (!payment) {
+          throw new Error('Payment not found');
+        }
+
+        if (payment.status !== 'completed') {
+          throw new Error('Can only refund completed payments');
+        }
+
+        const refundAmount = amount || payment.amount;
+        if (refundAmount > payment.amount) {
+          throw new Error('Refund amount cannot exceed payment amount');
+        }
+
+        // Create refund transaction
+        const transactionId = uuidv4();
+        const transaction = {
+          id: transactionId,
+          paymentId,
+          type: 'refund',
+          amount: refundAmount,
+          status: 'completed',
+          gatewayResponse: 'Refund processed',
+          reason,
+          createdAt: new Date(),
+          completedAt: new Date()
+        };
+
+        state.transactions.set(transactionId, transaction);
+        payment.transactions.push(transactionId);
+        payment.status = refundAmount === payment.amount ? 'refunded' : 'partially_refunded';
+        state.payments.set(paymentId, payment);
+
+        return { payment, transaction };
+      }
+
+      case 'get': {
+        const { paymentId } = input;
+        const payment = state.payments.get(paymentId);
+        if (!payment) {
+          throw new Error('Payment not found');
+        }
+
+        const transactions = payment.transactions.map((txId: string) => state.transactions.get(txId));
+        return { payment: { ...payment, transactions } };
+      }
+
+      case 'getByOrderId': {
+        const { orderId } = input;
+        for (const [paymentId, payment] of state.payments) {
+          if (payment.orderId === orderId) {
+            const transactions = payment.transactions.map((txId: string) => state.transactions.get(txId));
+            return { payment: { ...payment, transactions }, paymentId };
+          }
+        }
+        throw new Error('Payment not found for order');
+      }
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+};

package/src/plugins/payments/index.ts

@@ -0,0 +1,15 @@
+// plugins/payments/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Payment } from './concepts/Payment';
+import { paymentWorkflowSyncs } from './syncs/payment-workflow.sync';
+
+export const paymentsPlugin: Plugin = {
+  name: 'payments',
+  concepts: {
+    Payment
+  },
+  syncs: paymentWorkflowSyncs,
+  initialize: async (_engine) => {
+    console.log('💳 Payments plugin initialized');
+  }
+};

package/src/plugins/payments/syncs/payment-workflow.sync.ts

@@ -0,0 +1,274 @@
+// plugins/payments/syncs/payment-workflow.sync.ts
+import { SyncRule } from '@legible-sync/core';
+
+export const paymentWorkflowSyncs: SyncRule[] = [
+  // When order is confirmed, initiate payment
+  {
+    name: "InitiatePaymentOnOrderConfirm",
+    when: [
+      {
+        concept: "Order",
+        action: "confirm"
+      }
+    ],
+    then: [
+      {
+        concept: "Payment",
+        action: "initiate",
+        input: {
+          orderId: "?orderId",
+          amount: "?order.total",
+          method: "credit_card"
+        }
+      }
+    ]
+  },
+
+  // When payment is initiated, automatically process it
+  {
+    name: "AutoProcessPayment",
+    when: [
+      {
+        concept: "Payment",
+        action: "initiate"
+      }
+    ],
+    then: [
+      {
+        concept: "Payment",
+        action: "process",
+        input: {
+          paymentId: "?paymentId"
+        }
+      }
+    ]
+  },
+
+  // When payment processing starts, confirm it (simplified for demo)
+  {
+    name: "AutoConfirmPayment",
+    when: [
+      {
+        concept: "Payment",
+        action: "process"
+      }
+    ],
+    then: [
+      {
+        concept: "Payment",
+        action: "confirm",
+        input: {
+          paymentId: "?paymentId",
+          transactionId: "?transaction.id"
+        }
+      }
+    ]
+  },
+
+  // When payment is confirmed, get order details first
+  {
+    name: "GetOrderDetailsAfterPaymentConfirm",
+    when: [
+      {
+        concept: "Payment",
+        action: "confirm"
+      }
+    ],
+    then: [
+      {
+        concept: "Order",
+        action: "get",
+        input: {
+          orderId: "?payment.orderId"
+        }
+      }
+    ]
+  },
+
+  // When order details are retrieved after payment confirmation, get user details
+  {
+    name: "GetUserDetailsAfterPaymentConfirm",
+    when: [
+      {
+        concept: "Order",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "User",
+        action: "get",
+        input: {
+          userId: "?order.userId"
+        }
+      }
+    ]
+  },
+
+  // When user details are retrieved after payment confirmation, send notification
+  {
+    name: "SendPaymentSuccessNotification",
+    when: [
+      {
+        concept: "User",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "Notification",
+        action: "send",
+        input: {
+          type: "email",
+          to: "?user.email",
+          template: "payment-success",
+          data: {
+            orderId: "?payment.orderId",
+            amount: "?payment.amount",
+            paymentId: "?paymentId"
+          }
+        }
+      }
+    ]
+  },
+
+  // When payment fails, get order details first
+  {
+    name: "GetOrderDetailsAfterPaymentFail",
+    when: [
+      {
+        concept: "Payment",
+        action: "fail"
+      }
+    ],
+    then: [
+      {
+        concept: "Order",
+        action: "get",
+        input: {
+          orderId: "?payment.orderId"
+        }
+      },
+      {
+        concept: "Order",
+        action: "cancel",
+        input: {
+          orderId: "?payment.orderId"
+        }
+      }
+    ]
+  },
+
+  // When order details are retrieved after payment failure, get user details
+  {
+    name: "GetUserDetailsAfterPaymentFail",
+    when: [
+      {
+        concept: "Order",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "User",
+        action: "get",
+        input: {
+          userId: "?order.userId"
+        }
+      }
+    ]
+  },
+
+  // When user details are retrieved after payment failure, send notification
+  {
+    name: "SendPaymentFailureNotification",
+    when: [
+      {
+        concept: "User",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "Notification",
+        action: "send",
+        input: {
+          type: "email",
+          to: "?user.email",
+          template: "payment-failed",
+          data: {
+            orderId: "?payment.orderId",
+            reason: "?payment.failureReason"
+          }
+        }
+      }
+    ]
+  },
+
+  // When refund is processed, get order details first
+  {
+    name: "GetOrderDetailsAfterRefund",
+    when: [
+      {
+        concept: "Payment",
+        action: "refund"
+      }
+    ],
+    then: [
+      {
+        concept: "Order",
+        action: "get",
+        input: {
+          orderId: "?payment.orderId"
+        }
+      }
+    ]
+  },
+
+  // When order details are retrieved after refund, get user details
+  {
+    name: "GetUserDetailsAfterRefund",
+    when: [
+      {
+        concept: "Order",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "User",
+        action: "get",
+        input: {
+          userId: "?order.userId"
+        }
+      }
+    ]
+  },
+
+  // When user details are retrieved after refund, send notification
+  {
+    name: "SendRefundNotification",
+    when: [
+      {
+        concept: "User",
+        action: "get"
+      }
+    ],
+    then: [
+      {
+        concept: "Notification",
+        action: "send",
+        input: {
+          type: "email",
+          to: "?user.email",
+          template: "payment-refund",
+          data: {
+            orderId: "?payment.orderId",
+            amount: "?transaction.amount",
+            reason: "?transaction.reason"
+          }
+        }
+      }
+    ]
+  }
+];

package/src/plugins/products/concepts/Product.ts

@@ -0,0 +1,102 @@
+// plugins/products/concepts/Product.ts
+import { Concept } from '@legible-sync/core';
+import { v4 as uuidv4 } from 'uuid';
+
+export const Product: Concept = {
+  state: {
+    products: new Map<string, any>(),
+    skus: new Set<string>(),
+  },
+
+  async execute(action: string, input: any) {
+    const state = this.state;
+
+    switch (action) {
+      case 'create': {
+        const { name, sku, price, description, category } = input;
+
+        // Validation
+        if (!name || !sku || price === undefined) {
+          throw new Error('Name, SKU, and price are required');
+        }
+
+        if (state.skus.has(sku)) {
+          throw new Error('SKU already exists');
+        }
+
+        // Create product
+        const productId = uuidv4();
+        const product = {
+          id: productId,
+          name,
+          sku,
+          price: Number(price),
+          description: description || '',
+          category: category || 'general',
+          status: 'active',
+          createdAt: new Date()
+        };
+
+        state.products.set(productId, product);
+        state.skus.add(sku);
+
+        return { productId, product };
+      }
+
+      case 'get': {
+        const { productId } = input;
+        const product = state.products.get(productId);
+        if (!product) {
+          throw new Error('Product not found');
+        }
+        return { product };
+      }
+
+      case 'update': {
+        const { productId, updates } = input;
+        const product = state.products.get(productId);
+        if (!product) {
+          throw new Error('Product not found');
+        }
+
+        // Update product
+        const updatedProduct = { ...product, ...updates, updatedAt: new Date() };
+        state.products.set(productId, updatedProduct);
+
+        return { product: updatedProduct };
+      }
+
+      case 'deactivate': {
+        const { productId } = input;
+        const product = state.products.get(productId);
+        if (!product) {
+          throw new Error('Product not found');
+        }
+
+        product.status = 'inactive';
+        product.deactivatedAt = new Date();
+        state.products.set(productId, product);
+
+        return { product };
+      }
+
+       case 'list': {
+         const { category, status = 'active' } = input;
+         const products = Array.from(state.products.values())
+           .filter((p: any) => p.status === status)
+           .filter((p: any) => !category || p.category === category);
+
+         return { products };
+       }
+
+       case 'reset': {
+         state.products.clear();
+         state.skus.clear();
+         return { reset: true };
+       }
+
+       default:
+         throw new Error(`Unknown action: ${action}`);
+    }
+  }
+};

package/src/plugins/products/index.ts

@@ -0,0 +1,15 @@
+// plugins/products/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Product } from './concepts/Product';
+import { productEventSyncs } from './syncs/product-events.sync';
+
+export const productsPlugin: Plugin = {
+  name: 'products',
+  concepts: {
+    Product
+  },
+  syncs: productEventSyncs,
+  initialize: async (_engine) => {
+    console.log('📦 Products plugin initialized');
+  }
+};

package/src/plugins/products/syncs/product-events.sync.ts

@@ -0,0 +1,78 @@
+// plugins/products/syncs/product-events.sync.ts
+import { SyncRule } from '@legible-sync/core';
+
+export const productEventSyncs: SyncRule[] = [
+  // When a product is created, publish product.created event
+  {
+    name: "PublishProductCreatedEvent",
+    when: [
+      {
+        concept: "Product",
+        action: "create"
+      }
+    ],
+    then: [
+      {
+        concept: "EventBus",
+        action: "publish",
+        input: {
+          event: "product.created",
+          data: {
+            productId: "?productId",
+            name: "?product.name",
+            sku: "?product.sku",
+            price: "?product.price",
+            category: "?product.category"
+          }
+        }
+      }
+    ]
+  },
+
+  // When a product is updated, publish product.updated event
+  {
+    name: "PublishProductUpdatedEvent",
+    when: [
+      {
+        concept: "Product",
+        action: "update"
+      }
+    ],
+    then: [
+      {
+        concept: "EventBus",
+        action: "publish",
+        input: {
+          event: "product.updated",
+          data: {
+            productId: "?productId",
+            updates: "?updates"
+          }
+        }
+      }
+    ]
+  },
+
+  // When a product is deactivated, publish product.deactivated event
+  {
+    name: "PublishProductDeactivatedEvent",
+    when: [
+      {
+        concept: "Product",
+        action: "deactivate"
+      }
+    ],
+    then: [
+      {
+        concept: "EventBus",
+        action: "publish",
+        input: {
+          event: "product.deactivated",
+          data: {
+            productId: "?productId"
+          }
+        }
+      }
+    ]
+  }
+];