lua-cli 2.5.8 → 3.0.0-alpha.4

package/template/src/tools/GameScoreTrackerTool.ts

@@ -0,0 +1,356 @@
+/**
+ * Game Score Tracker Tool - Complex Dynamic Job Example
+ * 
+ * This tool demonstrates:
+ * 1. Creating a game tracking record
+ * 2. Creating an interval job that starts at game time
+ * 3. Job fetches score updates periodically
+ * 4. Job checks if game is over
+ * 5. Job deactivates itself when game ends
+ * 
+ * Use case: Live sports score tracking, esports matches, auction monitoring
+ */
+
+import { LuaTool, Jobs, Data } from "lua-cli";
+import { z } from "zod";
+
+export class TrackGameScoresTool implements LuaTool {
+  name = "track_game_scores";
+  description = "Track live scores for a game with automatic updates";
+  
+  inputSchema = z.object({
+    gameId: z.string(),
+    gameName: z.string(),
+    startTime: z.string(), // ISO 8601 timestamp
+    updateIntervalSeconds: z.number().min(30).max(600).default(60), // 30s to 10min
+    apiEndpoint: z.string().optional() // Optional external API
+  });
+
+  async execute(input: {
+    gameId: string;
+    gameName: string;
+    startTime: string;
+    updateIntervalSeconds: number;
+    apiEndpoint?: string;
+  }) {
+    console.log(`🎮 Setting up score tracking for: ${input.gameName}`);
+
+    // Step 1: Create game record in database
+    const gameRecord = {
+      gameId: input.gameId,
+      gameName: input.gameName,
+      startTime: input.startTime,
+      status: 'scheduled',
+      currentScore: { home: 0, away: 0 },
+      lastUpdate: new Date().toISOString(),
+      createdAt: new Date().toISOString()
+    };
+
+    const game = await Data.create('games', gameRecord, 
+      `${input.gameName} ${input.gameId}`
+    );
+
+    console.log(`✅ Game record created: ${game.id}`);
+
+    // Step 2: Calculate when the job should start
+    const gameStartTime = new Date(input.startTime);
+    const now = new Date();
+
+    // If game hasn't started yet, schedule job to start at game time
+    // If game already started, start immediately
+    const jobStartTime = gameStartTime > now ? gameStartTime : now;
+
+    console.log(`⏰ Job will start at: ${jobStartTime.toLocaleString()}`);
+    console.log(`🔄 Updates every ${input.updateIntervalSeconds} seconds`);
+
+    // Step 3: Capture variables for the job closure
+    const gameId = input.gameId;
+    const gameName = input.gameName;
+    const intervalSeconds = input.updateIntervalSeconds;
+    const apiEndpoint = input.apiEndpoint || 'https://api.example.com/scores';
+    const gameRecordId = game.id;
+
+    // Step 4: Create an interval job that monitors the game
+    // This job will run every X seconds and stop itself when game ends
+    const job = await Jobs.create({
+      name: `track-game-${gameId}`,
+      description: `Live score tracking for ${gameName}`,
+      
+      // Important: Use interval schedule
+      schedule: {
+        type: 'interval',
+        seconds: intervalSeconds
+      },
+      
+      timeout: 30,  // Each update should complete in 30 seconds
+      
+      retry: {
+        maxAttempts: 2,  // Retry failed updates
+        backoffSeconds: 10
+      },
+      
+      // The job logic - runs every interval until game ends
+      execute: async () => {
+        console.log('🎮 Fetching score update for game ' + gameId + '...');
+        
+        try {
+          // Fetch current game data from our database
+          const gameData = await Data.getEntry('games', gameRecordId);
+          
+          // Check if game is already over
+          if (gameData.data.status === 'finished') {
+            console.log('🏁 Game ' + gameId + ' is already finished. Stopping job.');
+            
+            // IMPORTANT: Job stops itself!
+            await Jobs.deactivate(job.jobId);
+            
+            return {
+              action: 'job-stopped',
+              reason: 'game-finished',
+              gameId: gameId,
+              finalScore: gameData.data.currentScore
+            };
+          }
+          
+          // Fetch latest scores from external API
+          let scoreUpdate;
+          try {
+            const response = await fetch(apiEndpoint + '/' + gameId);
+            
+            if (!response.ok) {
+              throw new Error('API returned ' + response.status);
+            }
+            
+            scoreUpdate = await response.json();
+          } catch (apiError) {
+            // If external API fails, generate mock data for demo
+            console.warn('External API failed, using mock data:', apiError);
+            
+            // Simulate score progression
+            const currentScore = gameData.data.currentScore;
+            scoreUpdate = {
+              home: currentScore.home + Math.floor(Math.random() * 2),
+              away: currentScore.away + Math.floor(Math.random() * 2),
+              quarter: Math.min(4, Math.floor(Date.now() / 1000 / 60 / 15) % 5),
+              timeRemaining: '12:34',
+              isFinished: Math.random() > 0.9  // 10% chance game ends
+            };
+          }
+          
+          // Update game record with new scores
+          const updatedGame = await Data.update('games', gameRecordId, {
+            ...gameData.data,
+            currentScore: {
+              home: scoreUpdate.home,
+              away: scoreUpdate.away
+            },
+            quarter: scoreUpdate.quarter,
+            timeRemaining: scoreUpdate.timeRemaining,
+            status: scoreUpdate.isFinished ? 'finished' : 'in-progress',
+            lastUpdate: new Date().toISOString()
+          });
+          
+          console.log('📊 Score update: ' + scoreUpdate.home + ' - ' + scoreUpdate.away);
+          
+          // Check if game just ended
+          if (scoreUpdate.isFinished) {
+            console.log('🏁 Game ' + gameId + ' has finished!');
+            console.log('Final score: ' + scoreUpdate.home + ' - ' + scoreUpdate.away);
+            
+            // Store final game result
+            await Data.create('game-results', {
+              gameId: gameId,
+              gameName: gameName,
+              finalScore: {
+                home: scoreUpdate.home,
+                away: scoreUpdate.away
+              },
+              finishedAt: new Date().toISOString()
+            });
+            
+            // IMPORTANT: Job stops itself when game ends!
+            await Jobs.deactivate(job.jobId);
+            
+            console.log('⏹️  Score tracking job stopped for game ' + gameId);
+            
+            return {
+              action: 'game-ended-job-stopped',
+              gameId: gameId,
+              finalScore: {
+                home: scoreUpdate.home,
+                away: scoreUpdate.away
+              }
+            };
+          }
+          
+          // Game still in progress
+          return {
+            action: 'score-updated',
+            gameId: gameId,
+            currentScore: {
+              home: scoreUpdate.home,
+              away: scoreUpdate.away
+            },
+            quarter: scoreUpdate.quarter,
+            timeRemaining: scoreUpdate.timeRemaining
+          };
+          
+        } catch (error: any) {
+          console.error('❌ Error updating score for game ' + gameId + ':', error);
+          
+          // Don't stop job on errors - just log and continue
+          return {
+            action: 'error',
+            gameId: gameId,
+            error: error.message
+          };
+        }
+      }
+    });
+
+    console.log(`✅ Score tracking job created: ${job.jobId}`);
+    console.log(`📊 Job will update scores every ${input.updateIntervalSeconds} seconds`);
+    console.log(`⏹️  Job will automatically stop when game ends`);
+
+    return {
+      success: true,
+      game: {
+        id: game.id,
+        gameId: input.gameId,
+        name: input.gameName,
+        startTime: input.startTime,
+        status: 'scheduled'
+      },
+      scoreTracker: {
+        jobId: job.jobId,
+        jobName: job.name,
+        updateInterval: input.updateIntervalSeconds,
+        startsAt: jobStartTime.toISOString(),
+        message: 'Job will automatically stop when game ends'
+      }
+    };
+  }
+}
+
+/**
+ * Get Game Scores Tool
+ * 
+ * Retrieves current scores for a game or all active games
+ */
+export class GetGameScoresTool implements LuaTool {
+  name = "get_game_scores";
+  description = "Get current scores for tracked games";
+  
+  inputSchema = z.object({
+    gameId: z.string().optional()
+  });
+
+  async execute(input: { gameId?: string }) {
+    if (input.gameId) {
+      // Get specific game
+      const games = await Data.get('games', {}, 1, 100);
+      const game = games.data?.find((g: any) => g.data.gameId === input.gameId);
+      
+      if (!game) {
+        return {
+          found: false,
+          gameId: input.gameId,
+          message: 'Game not found'
+        };
+      }
+
+      return {
+        found: true,
+        game: {
+          gameId: game.data.gameId,
+          name: game.data.gameName,
+          status: game.data.status,
+          currentScore: game.data.currentScore,
+          quarter: game.data.quarter,
+          timeRemaining: game.data.timeRemaining,
+          lastUpdate: game.data.lastUpdate
+        }
+      };
+    }
+
+    // Get all active games
+    const allGames = await Data.get('games', {}, 1, 50);
+    
+    const activeGames = (allGames.data || [])
+      .filter((g: any) => g.data.status === 'in-progress' || g.data.status === 'scheduled')
+      .map((g: any) => ({
+        gameId: g.data.gameId,
+        name: g.data.gameName,
+        status: g.data.status,
+        currentScore: g.data.currentScore,
+        lastUpdate: g.data.lastUpdate
+      }));
+
+    return {
+      activeGamesCount: activeGames.length,
+      games: activeGames
+    };
+  }
+}
+
+/**
+ * Stop Game Tracking Tool
+ * 
+ * Manually stops score tracking for a game
+ */
+export class StopGameTrackingTool implements LuaTool {
+  name = "stop_game_tracking";
+  description = "Manually stop score tracking for a game";
+  
+  inputSchema = z.object({
+    gameId: z.string()
+  });
+
+  async execute(input: { gameId: string }) {
+    console.log(`⏹️  Stopping score tracking for game ${input.gameId}...`);
+
+    // Find the tracking job
+    const allJobs = await Jobs.getAll();
+    
+    if (!allJobs.success || !allJobs.data) {
+      throw new Error('Failed to fetch jobs');
+    }
+
+    const trackingJob = allJobs.data.jobs.find((j: any) => 
+      j.name === `track-game-${input.gameId}`
+    );
+
+    if (!trackingJob) {
+      return {
+        success: false,
+        gameId: input.gameId,
+        message: 'No tracking job found for this game'
+      };
+    }
+
+    // Deactivate the job
+    const result = await Jobs.deactivate(trackingJob.id);
+
+    // Update game status
+    const games = await Data.get('games', {}, 1, 100);
+    const game = games.data?.find((g: any) => g.data.gameId === input.gameId);
+    
+    if (game) {
+      await Data.update('games', game.id, {
+        ...game.data,
+        status: 'stopped',
+        stoppedAt: new Date().toISOString()
+      });
+    }
+
+    console.log(`✅ Score tracking stopped for game ${input.gameId}`);
+
+    return {
+      success: true,
+      gameId: input.gameId,
+      jobId: trackingJob.id,
+      message: 'Score tracking stopped successfully'
+    };
+  }
+}
+

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;
+