lua-cli 2.5.8 → 3.0.0-alpha.1

package/template/src/tools/SmartBasketTool.ts

@@ -0,0 +1,188 @@
+/**
+ * Smart Basket Tool Example
+ * 
+ * This tool creates a basket AND schedules a follow-up job to check if it was abandoned.
+ * Demonstrates: Dynamic job creation, basket management, and automated follow-ups.
+ * 
+ * Use case: E-commerce abandoned cart recovery
+ */
+
+import { LuaTool, Baskets, Jobs, Data } from "lua-cli";
+import { z } from "zod";
+
+export class CreateSmartBasketTool implements LuaTool {
+  name = "create_smart_basket";
+  description = "Creates a basket with automatic abandoned cart reminder";
+  
+  inputSchema = z.object({
+    currency: z.string().default('USD')
+  });
+
+  async execute(input: { currency: string }) {
+    console.log('🛒 Creating smart basket with auto-reminder...');
+
+    // Step 1: Create the basket
+    const basketData = {
+      currency: input.currency,
+      metadata: {
+        createdBy: 'smart-basket-tool',
+        reminderScheduled: true,
+        createdAt: new Date().toISOString()
+      }
+    };
+
+    const basketInstance = await Baskets.create(basketData);
+    const basketInfo = await basketInstance.getData();
+
+    console.log(`✅ Basket created: ${basketInfo.id}`);
+
+    // Step 2: Schedule a one-time job to check the basket in 3 hours
+    const checkTime = new Date(Date.now() + 3 * 60 * 60 * 1000); // 3 hours from now
+
+    // Capture basketId in closure for the job
+    const basketId = basketInfo.id;
+
+    // Create a dynamic one-time job using the Jobs API!
+    
+    const job = await Jobs.create({
+      name: `check-basket-${basketId}`,
+      description: `Check if basket ${basketId} was checked out`,
+      
+      // One-time job that runs in 3 hours
+      schedule: {
+        type: 'once',
+        executeAt: checkTime
+      },
+      
+      timeout: 60,  // 1 minute timeout
+      
+      // Write normal TypeScript code! It will be compiled automatically
+      execute: async () => {
+        console.log(`⏰ Checking basket ${basketId}...`);
+        
+        const basketInstance = await Baskets.getById(basketId);
+        const basket = await basketInstance.getData();
+        
+        if (basket.status === 'active' || basket.status === 'pending') {
+          // Basket is still active - it was abandoned!
+          console.log(`🛒 Basket ${basketId} was abandoned`);
+          
+          await Data.create('abandoned-baskets', {
+            basketId: basketId,
+            currency: basket.currency,
+            itemCount: basket.items?.length || 0,
+            totalValue: basket.total || 0,
+            abandonedAt: new Date().toISOString()
+          });
+          
+          console.log('📧 Sending abandoned cart reminder email...');
+          // TODO: Integrate with email service
+          // await sendEmail({
+          //   to: userEmail,
+          //   template: 'abandoned-cart',
+          //   data: { basket }
+          // });
+          
+          return { 
+            abandoned: true, 
+            basketId: basketId,
+            reminderSent: true 
+          };
+        }
+        
+        console.log(`✅ Basket ${basketId} was checked out`);
+        return { 
+          abandoned: false, 
+          basketId: basketId,
+          status: basket.status 
+        };
+      }
+    });
+
+    console.log(`⏰ One-time job created: ${job.jobId}`);
+    console.log(`📅 Will execute at: ${checkTime.toLocaleString()}`);
+
+    // Return basket info with job details
+    return {
+      success: true,
+      basket: {
+        id: basketInfo.id,
+        currency: basketInfo.currency,
+        status: basketInfo.status
+      },
+      scheduledJob: {
+        jobId: job.jobId,
+        name: job.name,
+        scheduledFor: checkTime.toISOString(),
+        message: 'One-time job will check basket in 3 hours'
+      }
+    };
+  }
+}
+
+/**
+ * Check Abandoned Baskets Tool
+ * 
+ * This tool can be called manually or by a recurring job to check for abandoned baskets.
+ */
+export class CheckAbandonedBasketsTool implements LuaTool {
+  name = "check_abandoned_baskets";
+  description = "Checks for abandoned baskets and sends reminders";
+  
+  inputSchema = z.object({
+    basketId: z.string().optional()
+  });
+
+  async execute(input: { basketId?: string }) {
+    console.log('🔍 Checking for abandoned baskets...');
+
+    // Get all abandoned baskets from data collection
+    const abandonedBasketsData = await Data.get('abandoned-baskets', {}, 1, 100);
+    const abandonedBaskets = abandonedBasketsData.data || [];
+
+    if (input.basketId) {
+      // Check specific basket
+      const specific = abandonedBaskets.find((ab: any) => ab.data.basketId === input.basketId);
+      
+      if (specific) {
+        return {
+          basketId: input.basketId,
+          abandoned: true,
+          abandonedAt: specific.data.abandonedAt,
+          itemCount: specific.data.itemCount,
+          totalValue: specific.data.totalValue
+        };
+      }
+
+      // Not in abandoned list - check current status
+      const basketInstance = await Baskets.getById(input.basketId);
+      const basket = await basketInstance.getData();
+
+      return {
+        basketId: input.basketId,
+        abandoned: false,
+        status: basket.status,
+        itemCount: basket.items?.length || 0
+      };
+    }
+
+    // Return all abandoned baskets summary
+    const summary = abandonedBaskets.map((ab: any) => ({
+      basketId: ab.data.basketId,
+      currency: ab.data.currency,
+      itemCount: ab.data.itemCount,
+      totalValue: ab.data.totalValue,
+      abandonedAt: ab.data.abandonedAt
+    }));
+
+    console.log(`🛒 Found ${abandonedBaskets.length} abandoned baskets`);
+
+    return {
+      success: true,
+      abandonedCount: abandonedBaskets.length,
+      abandonedBaskets: summary,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+

package/template/src/webhooks/PaymentWebhook.ts

@@ -0,0 +1,113 @@
+/**
+ * Payment Webhook Example
+ * 
+ * This webhook receives payment notifications from payment providers (Stripe, PayPal, etc.).
+ * It validates signatures, processes payment events, and updates order status.
+ * 
+ * Common use case: Stripe webhook for payment confirmations
+ */
+
+import { LuaWebhook, Orders, Data } from "lua-cli";
+import { z } from "zod";
+
+const paymentWebhook = new LuaWebhook({
+  name: "payment-notifications",
+  version: "1.0.0",
+  description: "Receives payment notifications from payment providers",
+  context: "This webhook processes payment confirmation events from Stripe or other providers. " +
+           "It validates the payment, updates order status, and logs the transaction.",
+
+  // Headers typically include webhook signature for verification
+  headerSchema: z.object({
+    'stripe-signature': z.string().optional(),
+    'content-type': z.string()
+  }),
+
+  // Payment event body
+  bodySchema: z.object({
+    type: z.string(),  // e.g., 'payment_intent.succeeded'
+    data: z.object({
+      object: z.object({
+        id: z.string(),
+        amount: z.number(),
+        currency: z.string(),
+        status: z.string(),
+        metadata: z.object({
+          orderId: z.string().optional(),
+          customerId: z.string().optional()
+        }).optional()
+      })
+    })
+  }),
+
+  execute: async ({ headers, body }) => {
+    console.log(`💳 Payment event received:`, body.type);
+
+    // In production: Verify Stripe signature
+    // const signature = headers['stripe-signature'];
+    // const isValid = verifyStripeSignature(body, signature);
+    // if (!isValid) throw new Error('Invalid signature');
+
+    const payment = body.data.object;
+    const eventType = body.type;
+
+    // Handle payment success
+    if (eventType === 'payment_intent.succeeded') {
+      console.log(`✅ Payment successful: ${payment.amount} ${payment.currency}`);
+
+      // Update order if we have orderId in metadata
+      if (payment.metadata?.orderId) {
+        try {
+          await Orders.updateStatus('confirmed', payment.metadata.orderId);
+          console.log(`📦 Order ${payment.metadata.orderId} marked as confirmed`);
+        } catch (error) {
+          console.error('Failed to update order:', error);
+        }
+      }
+
+      // Log the transaction
+      await Data.create('payment-logs', {
+        paymentId: payment.id,
+        amount: payment.amount,
+        currency: payment.currency,
+        orderId: payment.metadata?.orderId,
+        customerId: payment.metadata?.customerId,
+        status: 'succeeded',
+        receivedAt: new Date().toISOString()
+      });
+
+      return {
+        success: true,
+        paymentId: payment.id,
+        orderId: payment.metadata?.orderId,
+        message: 'Payment processed successfully'
+      };
+    }
+
+    // Handle payment failure
+    if (eventType === 'payment_intent.payment_failed') {
+      console.log(`❌ Payment failed: ${payment.id}`);
+
+      await Data.create('payment-logs', {
+        paymentId: payment.id,
+        status: 'failed',
+        receivedAt: new Date().toISOString()
+      });
+
+      return {
+        success: true,
+        paymentId: payment.id,
+        message: 'Payment failure logged'
+      };
+    }
+
+    // Other event types
+    return {
+      success: true,
+      message: `Event ${eventType} received`
+    };
+  }
+});
+
+export default paymentWebhook;
+

package/template/src/webhooks/UserEventWebhook.ts

@@ -0,0 +1,77 @@
+/**
+ * User Event Webhook Example
+ * 
+ * This webhook receives user events from external systems (e.g., CRM, marketing tools).
+ * It validates incoming data and stores events for processing.
+ * 
+ * Webhook URL: {API_URL}/webhooks/{agentId}/{webhookId}
+ */
+
+import { LuaWebhook, Data } from "lua-cli";
+import { z } from "zod";
+
+const userEventWebhook = new LuaWebhook({
+  name: "user-events",
+  version: "1.0.0",
+  description: "Receives user events from external systems",
+  context: "This webhook handles user registration, profile updates, and deletion events. " +
+           "It validates the incoming data, stores events in the database, and can trigger follow-up actions.",
+
+  // Validate query parameters (optional source tracking)
+  querySchema: z.object({
+    source: z.string().optional(),
+    version: z.string().optional()
+  }),
+
+  // Validate headers (require API key for security)
+  headerSchema: z.object({
+    'x-api-key': z.string(),
+    'content-type': z.string().optional()
+  }),
+
+  // Validate request body
+  bodySchema: z.object({
+    eventType: z.enum(['signup', 'update', 'delete']),
+    userId: z.string(),
+    email: z.string().email(),
+    name: z.string().optional(),
+    metadata: z.record(z.any()).optional(),
+    timestamp: z.string()
+  }),
+
+  execute: async ({ query, headers, body }) => {
+    console.log(`📥 Received ${body.eventType} event for user:`, body.email);
+    console.log(`📍 Source:`, query?.source || 'unknown');
+
+    // Security: Validate API key (in production, use env variable)
+    const expectedKey = process.env.WEBHOOK_API_KEY || 'your-secret-key';
+    if (headers['x-api-key'] !== expectedKey) {
+      throw new Error('Invalid API key');
+    }
+
+    // Store the event in custom data collection
+    const eventData = {
+      ...body,
+      source: query?.source,
+      receivedAt: new Date().toISOString(),
+      processed: false
+    };
+
+    const result = await Data.create('user-events', eventData, 
+      `${body.eventType} ${body.email} ${body.name || ''}`
+    );
+
+    console.log('✅ Event stored successfully:', result.id);
+
+    // Return success response
+    return {
+      success: true,
+      eventId: result.id,
+      userId: body.userId,
+      timestamp: new Date().toISOString()
+    };
+  }
+});
+
+export default userEventWebhook;
+