@legible-sync/example-eda 1.2.0

package/src/plugins/analytics/index.ts

@@ -0,0 +1,15 @@
+// plugins/analytics/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Analytics } from './concepts/Analytics';
+import { analyticsEventSyncs } from './syncs/analytics-events.sync';
+
+export const analyticsPlugin: Plugin = {
+  name: 'analytics',
+  concepts: {
+    Analytics
+  },
+  syncs: analyticsEventSyncs,
+  initialize: async (_engine) => {
+    console.log('📈 Analytics plugin initialized');
+  }
+};

package/src/plugins/analytics/syncs/analytics-events.sync.ts

@@ -0,0 +1,103 @@
+// plugins/analytics/syncs/analytics-events.sync.ts
+import { SyncRule } from '@legible-sync/core';
+
+export const analyticsEventSyncs: SyncRule[] = [
+  // Track user registration events
+  {
+    name: "TrackUserRegistration",
+    when: [
+      {
+        concept: "User",
+        action: "register"
+      }
+    ],
+    then: [
+      {
+        concept: "Analytics",
+        action: "track",
+        input: {
+          event: "user_registered",
+          data: {
+            userId: "?userId",
+            username: "?username",
+            email: "?email"
+          }
+        }
+      }
+    ]
+  },
+
+  // Track product creation events
+  {
+    name: "TrackProductCreation",
+    when: [
+      {
+        concept: "Product",
+        action: "create"
+      }
+    ],
+    then: [
+      {
+        concept: "Analytics",
+        action: "track",
+        input: {
+          event: "product_created",
+          data: {
+            productId: "?productId",
+            name: "?name",
+            category: "?category",
+            price: "?price"
+          }
+        }
+      }
+    ]
+  },
+
+  // Track order events
+  {
+    name: "TrackOrderCreation",
+    when: [
+      {
+        concept: "Order",
+        action: "create"
+      }
+    ],
+    then: [
+      {
+        concept: "Analytics",
+        action: "track",
+        input: {
+          event: "order_created",
+          data: {
+            orderId: "?orderId",
+            userId: "?userId",
+            itemCount: "?items.length"
+          }
+        }
+      }
+    ]
+  },
+
+  {
+    name: "TrackOrderConfirmation",
+    when: [
+      {
+        concept: "Order",
+        action: "confirm"
+      }
+    ],
+    then: [
+      {
+        concept: "Analytics",
+        action: "track",
+        input: {
+          event: "order_confirmed",
+          data: {
+            orderId: "?orderId",
+            total: "?total"
+          }
+        }
+      }
+    ]
+  }
+];

package/src/plugins/inventory/concepts/Inventory.ts

@@ -0,0 +1,73 @@
+// plugins/inventory/concepts/Inventory.ts
+import { Concept } from '@legible-sync/core';
+
+export const Inventory: Concept = {
+  state: {
+    stock: new Map<string, number>(),
+    reservations: new Map<string, any[]>(),
+  },
+
+  async execute(action: string, input: any) {
+    const state = this.state;
+
+    switch (action) {
+      case 'setStock': {
+        const { productId, quantity } = input;
+
+        if (!productId || quantity < 0) {
+          throw new Error('Valid productId and non-negative quantity required');
+        }
+
+        state.stock.set(productId, quantity);
+        return { productId, quantity };
+      }
+
+      case 'checkAvailability': {
+        const { orderId, items } = input;
+
+        let total = 0;
+        const unavailable: any[] = [];
+
+        for (const item of items) {
+          const stock = state.stock.get(item.productId) || 0;
+          if (stock < item.quantity) {
+            unavailable.push({
+              productId: item.productId,
+              requested: item.quantity,
+              available: stock
+            });
+          }
+          // Calculate total from input items (prices should be provided)
+          total += item.quantity * (item.price || 0);
+        }
+
+        const available = unavailable.length === 0;
+        return { available, total, unavailable };
+      }
+
+      case 'deduct': {
+        const { orderId, items } = input;
+
+        for (const item of items) {
+          const currentStock = state.stock.get(item.productId) || 0;
+          if (currentStock < item.quantity) {
+            throw new Error(`Insufficient stock for product ${item.productId}`);
+          }
+
+          state.stock.set(item.productId, currentStock - item.quantity);
+        }
+
+        return { success: true };
+      }
+
+      case 'getStock': {
+        const { productId } = input;
+        const quantity = state.stock.get(productId) || 0;
+        return { productId, quantity };
+      }
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+};

package/src/plugins/inventory/index.ts

@@ -0,0 +1,14 @@
+// plugins/inventory/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Inventory } from './concepts/Inventory';
+
+export const inventoryPlugin: Plugin = {
+  name: 'inventory',
+  concepts: {
+    Inventory
+  },
+  syncs: [],
+  initialize: async (_engine) => {
+    console.log('📊 Inventory plugin initialized');
+  }
+};

package/src/plugins/notifications/concepts/Notification.ts

@@ -0,0 +1,49 @@
+// plugins/notifications/concepts/Notification.ts
+import { Concept } from '@legible-sync/core';
+
+export const Notification: Concept = {
+  state: {
+    sent: new Map<string, any[]>(),
+  },
+
+  async execute(action: string, input: any) {
+    const state = this.state;
+
+    switch (action) {
+      case 'send': {
+        const { type, to, template, data } = input;
+
+        // Simulate sending notification
+        const notificationId = `notif_${Date.now()}`;
+        const notification = {
+          id: notificationId,
+          type,
+          to,
+          template,
+          data,
+          sentAt: new Date(),
+          status: 'sent'
+        };
+
+        // Store sent notifications
+        if (!state.sent.has(to)) {
+          state.sent.set(to, []);
+        }
+        state.sent.get(to)!.push(notification);
+
+        console.log(`📧 ${type.toUpperCase()} sent to ${to}: ${template}`);
+
+        return { notificationId, notification };
+      }
+
+      case 'getHistory': {
+        const { recipient } = input;
+        const history = state.sent.get(recipient) || [];
+        return { notifications: history };
+      }
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+};

package/src/plugins/notifications/index.ts

@@ -0,0 +1,14 @@
+// plugins/notifications/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Notification } from './concepts/Notification';
+
+export const notificationsPlugin: Plugin = {
+  name: 'notifications',
+  concepts: {
+    Notification
+  },
+  syncs: [],
+  initialize: async (_engine) => {
+    console.log('🔔 Notifications plugin initialized');
+  }
+};

package/src/plugins/orders/concepts/Order.ts

@@ -0,0 +1,118 @@
+// plugins/orders/concepts/Order.ts
+import { Concept } from '@legible-sync/core';
+import { v4 as uuidv4 } from 'uuid';
+
+export const Order: Concept = {
+  state: {
+    orders: new Map<string, any>(),
+    orderItems: new Map<string, any[]>(),
+  },
+
+  async execute(action: string, input: any) {
+    const state = this.state;
+
+    switch (action) {
+      case 'create': {
+        const { userId, items } = input;
+
+        // Validation
+        if (!userId || !items || !Array.isArray(items) || items.length === 0) {
+          throw new Error('User ID and items array are required');
+        }
+
+        // Validate items
+        for (const item of items) {
+          if (!item.productId || !item.quantity || item.quantity <= 0) {
+            throw new Error('Each item must have productId and positive quantity');
+          }
+        }
+
+        // Create order
+        const orderId = uuidv4();
+        const order = {
+          id: orderId,
+          userId,
+          status: 'pending',
+          total: 0, // Will be calculated after inventory check
+          createdAt: new Date(),
+          items: items.map((item: any) => ({
+            productId: item.productId,
+            quantity: item.quantity,
+            price: item.price || 0
+          }))
+        };
+
+        state.orders.set(orderId, order);
+        state.orderItems.set(orderId, order.items);
+
+        return { orderId, order };
+      }
+
+      case 'confirm': {
+        const { orderId, total } = input;
+        const order = state.orders.get(orderId);
+        if (!order) {
+          throw new Error('Order not found');
+        }
+
+        if (order.status !== 'pending') {
+          throw new Error('Order is not in pending status');
+        }
+
+        order.status = 'confirmed';
+        order.total = total;
+        order.confirmedAt = new Date();
+        state.orders.set(orderId, order);
+
+        return { order };
+      }
+
+      case 'cancel': {
+        const { orderId } = input;
+        const order = state.orders.get(orderId);
+        if (!order) {
+          throw new Error('Order not found');
+        }
+
+        order.status = 'cancelled';
+        order.cancelledAt = new Date();
+        state.orders.set(orderId, order);
+
+        return { order };
+      }
+
+      case 'ship': {
+        const { orderId, trackingNumber } = input;
+        const order = state.orders.get(orderId);
+        if (!order) {
+          throw new Error('Order not found');
+        }
+
+        if (order.status !== 'confirmed') {
+          throw new Error('Order must be confirmed before shipping');
+        }
+
+        order.status = 'shipped';
+        order.trackingNumber = trackingNumber;
+        order.shippedAt = new Date();
+        state.orders.set(orderId, order);
+
+        return { order };
+      }
+
+      case 'get': {
+        const { orderId } = input;
+        const order = state.orders.get(orderId);
+        if (!order) {
+          throw new Error('Order not found');
+        }
+
+        const items = state.orderItems.get(orderId) || [];
+        return { order: { ...order, items } };
+      }
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+};

package/src/plugins/orders/index.ts

@@ -0,0 +1,15 @@
+// plugins/orders/index.ts
+import { Plugin } from '../../core/PluginManager';
+import { Order } from './concepts/Order';
+import { orderWorkflowSyncs } from './syncs/order-workflow.sync';
+
+export const ordersPlugin: Plugin = {
+  name: 'orders',
+  concepts: {
+    Order
+  },
+  syncs: orderWorkflowSyncs,
+  initialize: async (_engine) => {
+    console.log('🛒 Orders plugin initialized');
+  }
+};

package/src/plugins/orders/syncs/order-workflow.sync.ts

@@ -0,0 +1,173 @@
+// plugins/orders/syncs/order-workflow.sync.ts
+import { SyncRule } from '@legible-sync/core';
+
+export const orderWorkflowSyncs: SyncRule[] = [
+  // After order creation, check inventory availability
+  {
+    name: "CheckInventoryAfterOrderCreation",
+    when: [
+      {
+        concept: "Order",
+        action: "create"
+      }
+    ],
+    then: [
+      {
+        concept: "Inventory",
+        action: "checkAvailability",
+        input: {
+          orderId: "?orderId",
+          items: "?order.items"
+        }
+      }
+    ]
+  },
+
+  // If inventory is available, confirm the order
+  {
+    name: "ConfirmOrderIfInventoryAvailable",
+    when: [
+      {
+        concept: "Inventory",
+        action: "checkAvailability"
+      }
+    ],
+    where: {
+      filter: (bindings) => bindings.available === true
+    },
+    then: [
+      {
+        concept: "Order",
+        action: "confirm",
+        input: {
+          orderId: "?orderId",
+          total: "?total"
+        }
+      }
+    ]
+  },
+
+  // After order confirmation, get user details for notifications
+  {
+    name: "GetUserDetailsAfterOrderConfirm",
+    when: [
+      {
+        concept: "Order",
+        action: "confirm"
+      }
+    ],
+    then: [
+      {
+        concept: "User",
+        action: "get",
+        input: {
+          userId: "?order.userId"
+        }
+      }
+    ]
+  },
+
+  // If inventory is not available, cancel the order
+  {
+    name: "CancelOrderIfInventoryUnavailable",
+    when: [
+      {
+        concept: "Inventory",
+        action: "checkAvailability"
+      }
+    ],
+    where: {
+      filter: (bindings) => bindings.available === false
+    },
+    then: [
+      {
+        concept: "Order",
+        action: "cancel",
+        input: {
+          orderId: "?orderId"
+        }
+      }
+    ]
+  },
+
+  // When order is confirmed, deduct inventory
+  {
+    name: "DeductInventoryOnOrderConfirm",
+    when: [
+      {
+        concept: "Order",
+        action: "confirm"
+      }
+    ],
+    then: [
+      {
+        concept: "Inventory",
+        action: "deduct",
+        input: {
+          orderId: "?orderId",
+          items: "?order.items"
+        }
+      }
+    ]
+  },
+
+  // When user details are retrieved after order confirmation, send notification
+  {
+    name: "SendOrderConfirmationNotification",
+    when: [
+      {
+        concept: "Order",
+        action: "confirm"
+      },
+      {
+        concept: "User",
+        action: "get"
+      }
+    ],
+    where: {
+      filter: (bindings) => bindings.order.userId === bindings.user.id
+    },
+    then: [
+      {
+        concept: "Notification",
+        action: "send",
+        input: {
+          type: "email",
+          to: "?user.email",
+          template: "order-confirmation",
+          data: {
+            orderId: "?order.id",
+            total: "?order.total",
+            items: "?order.items"
+          }
+        }
+      }
+    ]
+  },
+
+  // When order is shipped, send shipping notification
+  {
+    name: "SendShippingNotification",
+    when: [
+      {
+        concept: "Order",
+        action: "ship"
+      }
+    ],
+    then: [
+      {
+        concept: "Notification",
+        action: "send",
+        input: {
+          type: "email",
+          to: "?user.email",
+          template: "order-shipped",
+          data: {
+            orderId: "?orderId",
+            trackingNumber: "?order.trackingNumber"
+          }
+        }
+      }
+    ]
+  }
+];