@liquidmetal-ai/raindrop 0.13.0 → 0.15.0

package/templates/handlers/actor/index.ts.hbs

@@ -1,15 +1,10 @@
-import { Actor, ActorState, ActorNamespace, type KvCachePutOptions } from '@liquidmetal-ai/raindrop-framework';
+import { Actor, ActorState } from '@liquidmetal-ai/raindrop-framework';
 import { Env } from './raindrop.gen';
 
 interface {{actorClassName}}State {
   count: number;
   lastUpdated: string;
-  userData: Record<string, any>;
-  messages: Array<{
-    id: string;
-    content: string;
-    timestamp: string;
-  }>;
+  data: Record<string, any>;
 }
 
 export class {{actorClassName}} extends Actor<Env> {
@@ -20,26 +15,24 @@ export class {{actorClassName}} extends Actor<Env> {
   // === Initialization ===
 
   async initialize(): Promise<void> {
-    // Initialize default state if not exists
     const existing = await this.state.storage.get<{{actorClassName}}State>('state');
     if (!existing) {
       await this.state.storage.put('state', {
         count: 0,
         lastUpdated: new Date().toISOString(),
-        userData: {},
-        messages: [],
+        data: {},
       });
     }
   }
 
-  // === Business Logic Methods ===
+  // === Add Your Actor Methods Here ===
 
-  async incrementCounter(): Promise<number> {
+  // Example: Simple counter
+  async increment(): Promise<number> {
     const state = await this.state.storage.get<{{actorClassName}}State>('state') || {
       count: 0,
       lastUpdated: new Date().toISOString(),
-      userData: {},
-      messages: [],
+      data: {},
     };
 
     const newState = {
@@ -53,318 +46,25 @@ export class {{actorClassName}} extends Actor<Env> {
     return newState.count;
   }
 
-  async getCounter(): Promise<number> {
+  async getCount(): Promise<number> {
     const state = await this.state.storage.get<{{actorClassName}}State>('state');
     return state?.count || 0;
   }
 
-  async processMessage(content: string): Promise<{ id: string; content: string; timestamp: string }> {
+  async updateData(key: string, value: any): Promise<void> {
     const state = await this.state.storage.get<{{actorClassName}}State>('state') || {
       count: 0,
       lastUpdated: new Date().toISOString(),
-      userData: {},
-      messages: [],
+      data: {},
     };
 
-    const message = {
-      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      content,
-      timestamp: new Date().toISOString(),
-    };
-
-    const newState = {
-      ...state,
-      messages: [...state.messages, message],
-      lastUpdated: new Date().toISOString(),
-    };
-
-    await this.state.storage.put('state', newState);
-    this.env.logger.info('Message processed', { messageId: message.id });
-    return message;
+    state.data[key] = value;
+    state.lastUpdated = new Date().toISOString();
+    await this.state.storage.put('state', state);
   }
 
-  async getMessages(): Promise<Array<{ id: string; content: string; timestamp: string }>> {
+  async getData(key: string): Promise<any> {
     const state = await this.state.storage.get<{{actorClassName}}State>('state');
-    return state?.messages || [];
-  }
-
-  async clearMessages(): Promise<void> {
-    const state = await this.state.storage.get<{{actorClassName}}State>('state') || {
-      count: 0,
-      lastUpdated: new Date().toISOString(),
-      userData: {},
-      messages: [],
-    };
-
-    const newState = {
-      ...state,
-      messages: [],
-      lastUpdated: new Date().toISOString(),
-    };
-
-    await this.state.storage.put('state', newState);
-    this.env.logger.info('Messages cleared');
-  }
-
-  async getState(): Promise<{{actorClassName}}State | null> {
-    return await this.state.storage.get<{{actorClassName}}State>('state') || null;
-  }
-
-  // === Storage Integration ===
-
-  // Example: Save data to bucket
-  async saveToBucket(key: string, data: any): Promise<{ success: boolean; key?: string; error?: string }> {
-    try {
-      // Use bucket binding (add bucket to manifest to use this feature)
-      const bucket = (this.env as any).FILES;
-      if (!bucket) {
-        return { success: false, error: 'Bucket not configured - add bucket to manifest to use this feature' };
-      }
-      
-      await bucket.put(key, JSON.stringify(data));
-      this.env.logger.info('Data saved to bucket', { key });
-      return { success: true, key };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Failed to save to bucket', { error: errorMessage, key });
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  // Example: Load data from bucket
-  async loadFromBucket(key: string): Promise<{ success: boolean; data?: any; error?: string }> {
-    try {
-      // Use bucket binding (add bucket to manifest to use this feature)
-      const bucket = (this.env as any).FILES;
-      if (!bucket) {
-        return { success: false, error: 'Bucket not configured - add bucket to manifest to use this feature' };
-      }
-      
-      const object = await bucket.get(key);
-      
-      if (!object) {
-        return { success: false, error: 'Not found' };
-      }
-
-      const text = await object.text();
-      const data = JSON.parse(text);
-      return { success: true, data };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Failed to load from bucket', { error: errorMessage, key });
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  // Example: List bucket contents (no search API exists)
-  async listBucketContents(prefix?: string): Promise<{ success: boolean; items?: string[]; error?: string }> {
-    try {
-      // Use bucket binding (add bucket to manifest to use this feature)
-      const bucket = (this.env as any).FILES;
-      if (!bucket) {
-        return { success: false, error: 'Bucket not configured - add bucket to manifest to use this feature' };
-      }
-      
-      const options = prefix ? { prefix } : undefined;
-      const result = await bucket.list(options);
-      
-      const items = result.objects.map((obj: any) => obj.key);
-      return { success: true, items };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Failed to list bucket contents', { error: errorMessage, prefix });
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  // === Cache Integration ===
-
-  async cacheResult(key: string, result: any, ttlSeconds?: number): Promise<{ success: boolean; error?: string }> {
-    try {
-      // Use KV cache binding (add kv_cache to manifest to use this feature)
-      const cache = (this.env as any).CACHE || this.env.mem; // mem is always available
-      
-      const options: KvCachePutOptions = {};
-      if (ttlSeconds) {
-        options.expirationTtl = ttlSeconds;
-      }
-
-      await cache.put(key, JSON.stringify(result), options);
-      this.env.logger.info('Result cached', { key, ttl: ttlSeconds });
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Failed to cache result', { error: errorMessage, key });
-      return { success: false, error: errorMessage };
-    }
+    return state?.data[key];
   }
-
-  async getCachedResult(key: string): Promise<{ success: boolean; data?: any; error?: string }> {
-    try {
-      // Use KV cache binding (add kv_cache to manifest to use this feature)
-      const cache = (this.env as any).CACHE || this.env.mem; // mem is always available
-      const cached = await cache.get(key);
-      
-      if (cached === null) {
-        return { success: false, error: 'Not found in cache' };
-      }
-
-      const data = JSON.parse(cached);
-      return { success: true, data };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Failed to get cached result', { error: errorMessage, key });
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  // === Queue Integration ===
-
-  // Note: Queue requires adding queue to manifest
-  async sendToQueue(message: any, delaySeconds?: number): Promise<{ success: boolean; error?: string }> {
-    return { success: false, error: 'Queue not configured - add queue to manifest to use this feature' };
-  }
-
-  // === Alarm Scheduling ===
-
-  async schedulePeriodicTask(taskName: string, intervalSeconds: number, taskData?: any): Promise<void> {
-    const scheduledTime = new Date(Date.now() + intervalSeconds * 1000);
-    
-    // Store alarm context
-    await this.state.storage.put('alarm:context', {
-      name: taskName,
-      data: { intervalSeconds, taskData }
-    });
-    
-    // Set alarm using storage API
-    await this.state.storage.setAlarm(scheduledTime);
-
-    this.env.logger.info('Periodic task scheduled', { 
-      taskName, 
-      scheduledFor: scheduledTime.toISOString() 
-    });
-  }
-
-  // Alarm handler (called automatically when alarm triggers)
-  async alarm(): Promise<void> {
-    try {
-      const alarmContext = await this.state.storage.get<{
-        name: string;
-        data: any;
-      }>('alarm:context');
-      
-      if (!alarmContext) {
-        this.env.logger.warn('No alarm context found');
-        return;
-      }
-      
-      this.env.logger.info('Alarm triggered', { name: alarmContext.name, data: alarmContext.data });
-      
-      switch (alarmContext.name) {
-        case 'periodic-count':
-          const newCount = await this.incrementCounter();
-          this.env.logger.info('Incremented count via alarm', { newCount });
-          await this.schedulePeriodicTask('periodic-count', alarmContext.data.intervalSeconds);
-          break;
-        
-        case 'cleanup':
-          await this.clearMessages();
-          this.env.logger.info('Completed cleanup task via alarm');
-          await this.schedulePeriodicTask('cleanup', alarmContext.data.intervalSeconds);
-          break;
-        
-        default:
-          this.env.logger.warn('Unknown alarm type', { alarmType: alarmContext.name });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.env.logger.error('Error in alarm handler', { error: errorMessage });
-    }
-  }
-
-  // === Required Test Methods ===
-
-  async processUserData(userData: any): Promise<{ success: boolean; userId?: string; error?: string }> {
-    try {
-      if (!userData.userId || !userData.email) {
-        return { success: false, error: 'Missing required fields' };
-      }
-
-      // Increment counter
-      await this.incrementCounter();
-
-      // Save to bucket
-      await this.saveToBucket(`user:${userData.userId}`, userData);
-
-      // Cache the result
-      await this.cacheResult(`user:${userData.userId}`, userData);
-
-      // Send to queue (if configured)
-      await this.sendToQueue({ type: 'user_processed', userId: userData.userId });
-
-      return { success: true, userId: userData.userId };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  async getUserData(userId: string): Promise<{ success: boolean; data?: any; error?: string }> {
-    try {
-      // Try cache first
-      const cached = await this.getCachedResult(`user:${userId}`);
-      if (cached.success) {
-        return cached;
-      }
-
-      // Try bucket
-      const bucketResult = await this.loadFromBucket(`user:${userId}`);
-      if (bucketResult.success) {
-        // Cache for future requests
-        await this.cacheResult(`user:${userId}`, bucketResult.data);
-        return bucketResult;
-      }
-
-      return { success: false, error: 'User not found' };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      return { success: false, error: errorMessage };
-    }
-  }
-
-  async expensiveComputation(input: number): Promise<number> {
-    const cacheKey = `compute:${input}`;
-    
-    // Try cache first
-    const cached = await this.getCachedResult(cacheKey);
-    if (cached.success) {
-      return cached.data;
-    }
-
-    // Simulate expensive computation as expected by tests
-    const result = Math.pow(input, 2) + Math.sqrt(input);
-    
-    // Cache the result
-    await this.cacheResult(cacheKey, result);
-    
-    return result;
-  }
-
-  async batchProcessMessages(messages: string[]): Promise<{ processed: number; errors: string[] }> {
-    let processed = 0;
-    const errors: string[] = [];
-
-    for (const message of messages) {
-      try {
-        await this.processMessage(message);
-        processed++;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        errors.push(errorMessage);
-        this.env.logger.error('Failed to process message', { message, error: errorMessage });
-      }
-    }
-
-    return { processed, errors };
-  }
-}
+}

package/templates/handlers/bucket-event-notification/index.ts.hbs

@@ -8,264 +8,61 @@ import { Env } from './raindrop.gen';
 export default class extends Each<BucketEventNotification, Env> {
   async process(message: Message<BucketEventNotification>): Promise<void> {
     const event = message.body;
-    
-    console.log('Bucket event received:', {
+
+    this.env.logger.info('Bucket event received', {
       action: event.action,
       bucket: event.bucket,
-      objectKey: event.object.key,
+      key: event.object.key,
       size: event.object.size,
       eTag: event.object.eTag,
-      eventTime: event.eventTime || new Date().toISOString(),
-      timestamp: new Date().toISOString()
     });
 
+    // Handle different event types
     switch (event.action) {
       case 'ObjectCreated:Put':
-        await this.handleFileUpload(event);
+        await this.handleUpload(event);
         break;
-      
+
       case 'ObjectRemoved:Delete':
-        await this.handleFileDeletion(event);
+        await this.handleDeletion(event);
         break;
-      
+
       case 'ObjectCreated:Post':
-        await this.handleMultiPartUpload(event);
+        await this.handleMultipartUpload(event);
         break;
-      
-      default:
-        console.log('Unhandled event type:', event.action);
-    }
-  }
-
-  // === File Upload Handler ===
-  private async handleFileUpload(event: BucketEventNotification): Promise<void> {
-    try {
-      console.log(`Processing uploaded file: ${event.object.key}`);
-      
-      // Example: Extract file information
-      const fileInfo = {
-        key: event.object.key,
-        size: event.object.size,
-        eTag: event.object.eTag,
-        uploadedAt: new Date().toISOString()
-      };
-      
-      console.log('File info:', fileInfo);
-
-      // Example: Call an actor to process the file
-      // const processor = this.env.FILE_PROCESSOR_ACTOR;
-      // await processor.postMessage({
-      //   type: 'processFile',
-      //   data: fileInfo
-      // });
 
-      // Example: Store file metadata in KV cache
-      // const metadataCache = this.env.FILE_METADATA_KV;
-      // await metadataCache.put(
-      //   `file:${event.object.key}`, 
-      //   JSON.stringify(fileInfo),
-      //   { expirationTtl: 86400 } // 24 hours
-      // );
-
-      // Example: Send notification to queue
-      // const notificationQueue = this.env.NOTIFICATION_QUEUE;
-      // await notificationQueue.send({
-      //   body: JSON.stringify({
-      //     type: 'file_uploaded',
-      //     fileInfo,
-      //     timestamp: new Date().toISOString()
-      //   })
-      // });
-
-      // Example: Content type detection (would need additional bucket.get() call)
-      // For now, we'll skip content-type based processing since it's not in the event
-      await this.triggerFileProcessing(event);
-
-    } catch (error) {
-      console.error('Error handling file upload:', error);
-      
-      // Example: Send error notification
-      // const errorQueue = this.env.ERROR_QUEUE;
-      // await errorQueue.send({
-      //   body: JSON.stringify({
-      //     type: 'file_upload_error',
-      //     error: error.message,
-      //     fileInfo: {
-      //       key: event.object.key,
-      //       bucket: event.bucket
-      //     },
-      //     timestamp: new Date().toISOString()
-      //   })
-      // });
+      default:
+        this.env.logger.warn('Unhandled event type', { action: event.action });
     }
   }
 
-  // === File Deletion Handler ===
-  private async handleFileDeletion(event: BucketEventNotification): Promise<void> {
-    console.log(`Processing deleted file: ${event.object.key}`);
-    
-    // Example: Clean up related data
-    // const metadataCache = this.env.FILE_METADATA_KV;
-    // await metadataCache.delete(`file:${event.object.key}`);
-
-    // Example: Notify other services
-    // const cleanupQueue = this.env.CLEANUP_QUEUE;
-    // await cleanupQueue.send({
-    //   body: JSON.stringify({
-    //     type: 'file_deleted',
-    //     fileKey: event.object.key,
-    //     timestamp: new Date().toISOString()
-    //   })
-    // });
-
-    // Example: Update search index
-    // if (this.env.SMART_BUCKET) {
-    //   try {
-    //     // Remove from search index
-    //     await this.env.SMART_BUCKET.delete({
-    //       key: event.object.key
-    //     });
-    //     console.log(`Removed ${event.object.key} from search index`);
-    //   } catch (error) {
-    //     console.error('Failed to remove from search index:', error);
-    //   }
-    // }
-  }
-
-  // === Multi-part Upload Handler ===
-  private async handleMultiPartUpload(event: BucketEventNotification): Promise<void> {
-    console.log(`Processing multipart upload: ${event.object.key}`);
-    
-    // Example: Trigger post-upload processing
-    // const postProcessor = this.env.POST_UPLOAD_ACTOR;
-    // await postProcessor.postMessage({
-    //   type: 'processMultipartUpload',
-    //   data: {
-    //     key: event.object.key,
-    //     size: event.object.size,
-    //     eTag: event.object.eTag
-    //   }
-    // });
-  }
-
-  // === Image Processing Example ===
-  private async triggerImageProcessing(event: BucketEventNotification): Promise<void> {
-    console.log(`Triggering image processing for: ${event.object.key}`);
-    
-    // Example: Call image processing actor
-    // const imageProcessor = this.env.IMAGE_PROCESSOR_ACTOR;
-    // await imageProcessor.postMessage({
-    //   type: 'generateThumbnails',
-    //   data: {
-    //     sourceKey: event.object.key,
-    //     bucket: event.bucket,
-    //     eTag: event.object.eTag
-    //   }
-    // });
-
-    // Example: Extract EXIF data
-    // const exifExtractor = this.env.EXIF_EXTRACTOR_ACTOR;
-    // await exifExtractor.postMessage({
-    //   type: 'extractExif',
-    //   data: { key: event.object.key }
-    // });
-  }
+  // === Add Your Event Handlers Here ===
 
-  // === Document Processing Example ===
-  private async triggerDocumentProcessing(event: BucketEventNotification): Promise<void> {
-    console.log(`Triggering document processing for: ${event.object.key}`);
-    
-    // Example: Extract text and add to SmartBucket for search
-    // const documentProcessor = this.env.DOCUMENT_PROCESSOR_ACTOR;
-    // await documentProcessor.postMessage({
-    //   type: 'extractAndIndex',
-    //   data: {
-    //     key: event.object.key,
-    //     bucket: event.bucket,
-    //     eTag: event.object.eTag
-    //   }
-    // });
-
-    // Example: Generate document summary
-    // const summarizer = this.env.DOCUMENT_SUMMARIZER_ACTOR;
-    // await summarizer.postMessage({
-    //   type: 'summarize',
-    //   data: { key: event.object.key }
-    // });
-  }
-
-  // === Generic File Processing ===
-  private async triggerFileProcessing(event: BucketEventNotification): Promise<void> {
-    console.log(`Triggering generic file processing for: ${event.object.key}`);
-    
-    // Content type detection would require fetching the object
-    // For now, we'll trigger generic processing
-    // const fileProcessor = this.env.FILE_PROCESSOR_ACTOR;
-    // await fileProcessor.postMessage({
-    //   type: 'processFile',
-    //   data: {
-    //     key: event.object.key,
-    //     bucket: event.bucket,
-    //     eTag: event.object.eTag
-    //   }
-    // });
-  }
+  private async handleUpload(event: BucketEventNotification): Promise<void> {
+    this.env.logger.info('Processing file upload', {
+      key: event.object.key,
+      size: event.object.size,
+    });
 
-  // === Utility Functions ===
-  private isDocumentType(contentType?: string): boolean {
-    if (!contentType) return false;
-    
-    const documentTypes = [
-      'application/pdf',
-      'application/msword',
-      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-      'text/plain',
-      'text/markdown',
-      'text/csv'
-    ];
-    
-    return documentTypes.includes(contentType);
+    // Add your upload processing logic here
+    // Example: trigger processing, update index, send notifications
   }
 
-  // === Advanced Examples ===
-
-  // Example: Batch processing for multiple files
-  private async batchProcessFiles(events: BucketEventNotification[]): Promise<void> {
-    console.log(`Batch processing ${events.length} files`);
-    
-    // Group by file extension or other criteria
-    const grouped = events.reduce((acc, event) => {
-      const key = event.object.key;
-      const extension = key.split('.').pop() || 'unknown';
-      if (!acc[extension]) acc[extension] = [];
-      acc[extension].push(event);
-      return acc;
-    }, {} as Record<string, BucketEventNotification[]>);
+  private async handleDeletion(event: BucketEventNotification): Promise<void> {
+    this.env.logger.info('Processing file deletion', {
+      key: event.object.key,
+    });
 
-    // Process each group
-    for (const [extension, files] of Object.entries(grouped)) {
-      console.log(`Processing ${files.length} files with extension: ${extension}`);
-      
-      if (['jpg', 'jpeg', 'png', 'gif'].includes(extension)) {
-        // Process images in batch
-        // const batchProcessor = this.env.IMAGE_BATCH_PROCESSOR;
-        // await batchProcessor.postMessage({
-        //   type: 'batchProcess',
-        //   data: files.map(f => ({ key: f.object.key, bucket: f.bucket }))
-        // });
-      }
-    }
+    // Add your deletion logic here
+    // Example: clean up related data, update index, notify systems
   }
 
-  // Example: File validation
-  private async validateFile(event: BucketEventNotification): Promise<{ valid: boolean; reason?: string }> {
-    // Check file size
-    const maxSize = 100 * 1024 * 1024; // 100MB
-    if (event.object.size && event.object.size > maxSize) {
-      return { valid: false, reason: 'File too large' };
-    }
+  private async handleMultipartUpload(event: BucketEventNotification): Promise<void> {
+    this.env.logger.info('Processing multipart upload', {
+      key: event.object.key,
+      size: event.object.size,
+    });
 
-    // Additional validation could be added here based on file extension, etc.
-    return { valid: true };
+    // Add your multipart upload logic here
   }
-}
+}