insforge 0.3.2 → 1.2.10

package/backend/src/providers/email/base.provider.ts

@@ -0,0 +1,41 @@
+import { EmailTemplate } from '@/types/email.js';
+
+/**
+ * Email provider interface
+ * Defines the contract that all email providers must implement
+ */
+export interface EmailProvider {
+  /**
+   * Initialize the email provider (optional)
+   */
+  initialize?(): void | Promise<void>;
+
+  /**
+   * Send email using predefined template
+   * @param email - Recipient email address
+   * @param name - Recipient name
+   * @param template - Template type
+   * @param variables - Variables to use in the email template
+   */
+  sendWithTemplate(
+    email: string,
+    name: string,
+    template: EmailTemplate,
+    variables?: Record<string, string>
+  ): Promise<void>;
+
+  /**
+   * Send raw email with custom subject and body
+   * Optional - not all providers may support this
+   * @param to - Recipient email address
+   * @param subject - Email subject
+   * @param html - HTML email body
+   * @param text - Plain text email body (optional)
+   */
+  sendRaw?(to: string, subject: string, html: string, text?: string): Promise<void>;
+
+  /**
+   * Check if provider supports template-based emails
+   */
+  supportsTemplates(): boolean;
+}

package/backend/src/providers/email/cloud.provider.ts

@@ -0,0 +1,187 @@
+import jwt from 'jsonwebtoken';
+import axios from 'axios';
+import { config } from '@/infra/config/app.config.js';
+import logger from '@/utils/logger.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { EmailTemplate } from '@/types/email.js';
+import { EmailProvider } from './base.provider.js';
+
+/**
+ * Cloud email provider for sending emails via Insforge cloud backend
+ */
+export class CloudEmailProvider implements EmailProvider {
+  /**
+   * Generate JWT sign token for cloud API authentication
+   * @returns JWT token signed with project secret
+   */
+  private generateSignToken(): string {
+    const projectId = config.cloud.projectId;
+    const jwtSecret = config.app.jwtSecret;
+
+    if (!projectId || projectId === 'local') {
+      throw new AppError(
+        'PROJECT_ID is not configured. Cannot send emails without cloud project setup.',
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+
+    if (!jwtSecret) {
+      throw new AppError(
+        'JWT_SECRET is not configured. Cannot generate sign token.',
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+
+    const payload = {
+      sub: projectId,
+    };
+
+    return jwt.sign(payload, jwtSecret, {
+      expiresIn: '10m', // Short-lived token for API request
+    });
+  }
+
+  /**
+   * Check if provider supports templates
+   */
+  supportsTemplates(): boolean {
+    return true;
+  }
+
+  /**
+   * Send email using predefined template
+   * @param email - Recipient email address
+   * @param name - Recipient name
+   * @param template - Template type (email-verification or reset-password)
+   * @param variables - Variables to use in the email template
+   * @returns Promise that resolves when email is sent successfully
+   */
+  async sendWithTemplate(
+    email: string,
+    name: string,
+    template: EmailTemplate,
+    variables?: Record<string, string>
+  ): Promise<void> {
+    try {
+      const projectId = config.cloud.projectId;
+      const apiHost = config.cloud.apiHost;
+      const signToken = this.generateSignToken();
+
+      // Validate inputs
+      if (!email || !name || !template) {
+        throw new AppError(
+          'Missing required parameters for sending email',
+          400,
+          ERROR_CODES.INVALID_INPUT
+        );
+      }
+
+      const validTemplates: EmailTemplate[] = [
+        'email-verification-code',
+        'email-verification-link',
+        'reset-password-code',
+        'reset-password-link',
+      ];
+      if (!validTemplates.includes(template)) {
+        throw new AppError(
+          `Invalid template type: ${template}. Must be one of: ${validTemplates.join(', ')}`,
+          400,
+          ERROR_CODES.INVALID_INPUT
+        );
+      }
+
+      const url = `${apiHost}/email/v1/${projectId}/send-with-template`;
+      const response = await axios.post(
+        url,
+        {
+          email,
+          name,
+          template,
+          variables,
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            sign: signToken,
+          },
+          timeout: 10000, // 10 second timeout
+        }
+      );
+
+      if (response.data?.success) {
+        logger.info('Email sent successfully', {
+          projectId,
+          template,
+        });
+      } else {
+        throw new AppError(
+          'Email service returned unsuccessful response',
+          500,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+    } catch (error) {
+      // Handle axios errors
+      if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const message = error.response?.data?.message || error.message;
+
+        logger.error('Failed to send email via cloud backend', {
+          projectId: config.cloud.projectId,
+          template,
+          status,
+          message,
+          error: error.response?.data,
+        });
+
+        // Provide more specific error messages
+        if (status === 401 || status === 403) {
+          throw new AppError(
+            'Authentication failed with cloud email service. Check PROJECT_ID and JWT_SECRET.',
+            status,
+            ERROR_CODES.AUTH_UNAUTHORIZED
+          );
+        } else if (status === 429) {
+          throw new AppError(
+            'Email rate limit exceeded. Free plans are limited to 3000 emails per month.',
+            status,
+            ERROR_CODES.RATE_LIMITED
+          );
+        } else if (status === 400) {
+          throw new AppError(
+            `Invalid email request: ${message}`,
+            status,
+            ERROR_CODES.INVALID_INPUT
+          );
+        } else {
+          throw new AppError(
+            `Failed to send email: ${message}`,
+            status || 500,
+            ERROR_CODES.INTERNAL_ERROR
+          );
+        }
+      }
+
+      // Re-throw AppError
+      if (error instanceof AppError) {
+        throw error;
+      }
+
+      // Handle other errors
+      logger.error('Unexpected error sending email', {
+        projectId: config.cloud.projectId,
+        template,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      });
+
+      throw new AppError(
+        `Failed to send email: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        500,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+}

package/backend/src/{core/logs/providers → providers/logs}/base.provider.ts

@@ -1,21 +1,21 @@
-import { LogSource, AnalyticsLogRecord, LogSourceStats } from '@/types/logs.js';
+import { LogSchema, LogSourceSchema, LogStatsSchema } from '@insforge/shared-schemas';
 
-export interface AnalyticsProvider {
+export interface LogProvider {
   initialize(): Promise<void>;
 
-  getLogSources(): Promise<LogSource[]>;
+  getLogSources(): Promise<LogSourceSchema[]>;
 
   getLogsBySource(
     sourceName: string,
     limit?: number,
     beforeTimestamp?: string
   ): Promise<{
-    logs: AnalyticsLogRecord[];
+    logs: LogSchema[];
     total: number;
     tableName: string;
   }>;
 
-  getLogSourceStats(): Promise<LogSourceStats[]>;
+  getLogSourceStats(): Promise<LogStatsSchema[]>;
 
   searchLogs(
     query: string,
@@ -23,7 +23,7 @@ export interface AnalyticsProvider {
     limit?: number,
     offset?: number
   ): Promise<{
-    logs: (AnalyticsLogRecord & { source: string })[];
+    logs: (LogSchema & { source: string })[];
     total: number;
   }>;
 
@@ -31,7 +31,7 @@ export interface AnalyticsProvider {
 }
 
 // Base class with common functionality
-export abstract class BaseAnalyticsProvider implements AnalyticsProvider {
+export abstract class BaseLogProvider implements LogProvider {
   // Source name mapping for user-friendly display
   protected sourceNameMap: Record<string, string> = {
     'cloudflare.logs.prod': 'insforge.logs',
@@ -59,24 +59,24 @@ export abstract class BaseAnalyticsProvider implements AnalyticsProvider {
   }
 
   abstract initialize(): Promise<void>;
-  abstract getLogSources(): Promise<LogSource[]>;
+  abstract getLogSources(): Promise<LogSourceSchema[]>;
   abstract getLogsBySource(
     sourceName: string,
     limit?: number,
     beforeTimestamp?: string
   ): Promise<{
-    logs: AnalyticsLogRecord[];
+    logs: LogSchema[];
     total: number;
     tableName: string;
   }>;
-  abstract getLogSourceStats(): Promise<LogSourceStats[]>;
+  abstract getLogSourceStats(): Promise<LogStatsSchema[]>;
   abstract searchLogs(
     query: string,
     sourceName?: string,
     limit?: number,
     offset?: number
   ): Promise<{
-    logs: (AnalyticsLogRecord & { source: string })[];
+    logs: (LogSchema & { source: string })[];
     total: number;
   }>;
   abstract close(): Promise<void>;

package/backend/src/{core/logs/providers → providers/logs}/cloudwatch.provider.ts

@@ -4,23 +4,23 @@ import {
   FilterLogEventsCommand,
   StartQueryCommand,
   GetQueryResultsCommand,
+  CreateLogGroupCommand,
+  ResourceAlreadyExistsException,
 } from '@aws-sdk/client-cloudwatch-logs';
-import { LogSource, AnalyticsLogRecord, LogSourceStats } from '@/types/logs.js';
 import logger from '@/utils/logger.js';
-import { BaseAnalyticsProvider } from './base.provider.js';
+import { BaseLogProvider } from './base.provider.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { LogSchema, LogSourceSchema, LogStatsSchema } from '@insforge/shared-schemas';
 
-export class CloudWatchProvider extends BaseAnalyticsProvider {
+export class CloudWatchProvider extends BaseLogProvider {
   private cwClient: CloudWatchLogsClient | null = null;
   private cwLogGroup: string | null = null;
   private cwRegion: string | null = null;
 
-  initialize(): Promise<void> {
+  async initialize(): Promise<void> {
     this.cwRegion = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-2';
-    this.cwLogGroup = process.env.CLOUDWATCH_LOG_GROUP || null;
-
-    if (!this.cwLogGroup) {
-      throw new Error('CLOUDWATCH_LOG_GROUP is required when using CloudWatch analytics');
-    }
+    this.cwLogGroup = process.env.CLOUDWATCH_LOG_GROUP || '/insforge/local';
 
     const cloudwatchOpts: {
       region: string;
@@ -34,8 +34,18 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     }
 
     this.cwClient = new CloudWatchLogsClient({ ...cloudwatchOpts });
-    logger.info(`Using analytics provider: ${this.cwLogGroup ? 'CloudWatch' : 'LocalDB/Postgres'}`);
-    return Promise.resolve();
+
+    // Create log group if it doesn't exist
+    try {
+      await this.cwClient.send(new CreateLogGroupCommand({ logGroupName: this.cwLogGroup }));
+      logger.info(`Created CloudWatch log group: ${this.cwLogGroup}`);
+    } catch (error) {
+      if (error instanceof ResourceAlreadyExistsException) {
+        logger.info(`CloudWatch log group already exists: ${this.cwLogGroup}`);
+      } else {
+        logger.warn(`Could not create CloudWatch log group: ${error}`);
+      }
+    }
   }
 
   private getSuffixMapping(): Record<string, string> {
@@ -47,9 +57,13 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     };
   }
 
-  async getLogSources(): Promise<LogSource[]> {
+  async getLogSources(): Promise<LogSourceSchema[]> {
     if (!this.cwLogGroup || !this.cwClient) {
-      throw new Error('CloudWatch not initialized');
+      throw new AppError(
+        'AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY not found in environment variables',
+        500,
+        ERROR_CODES.LOGS_AWS_NOT_CONFIGURED
+      );
     }
     const logGroup = this.cwLogGroup;
     const client = this.cwClient;
@@ -59,13 +73,13 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     const result = await client.send(cmd);
     const streams = result.logStreams || [];
 
-    const available: LogSource[] = [];
+    const available: LogSourceSchema[] = [];
     let idCounter = 1;
 
     for (const [displayName, suffix] of Object.entries(suffixMapping)) {
       const have = streams.some((s) => (s.logStreamName || '').includes(suffix));
       if (have) {
-        available.push({ id: idCounter++, name: displayName, token: suffix });
+        available.push({ id: String(idCounter++), name: displayName, token: suffix });
       }
     }
 
@@ -77,12 +91,16 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     limit: number = 100,
     beforeTimestamp?: string
   ): Promise<{
-    logs: AnalyticsLogRecord[];
+    logs: LogSchema[];
     total: number;
     tableName: string;
   }> {
     if (!this.cwLogGroup || !this.cwClient) {
-      throw new Error('CloudWatch not initialized');
+      throw new AppError(
+        'AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY not found in environment variables',
+        500,
+        ERROR_CODES.LOGS_AWS_NOT_CONFIGURED
+      );
     }
     const client = this.cwClient;
     const logGroup = this.cwLogGroup;
@@ -127,7 +145,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
         const fle = await client.send(
           new FilterLogEventsCommand({
             logGroupName: logGroup,
-            logStreamNames: streams.length > 0 ? streams.slice(0, 100) : undefined,
+            logStreamNames: streams.length ? streams.slice(0, 100) : undefined,
             startTime: startMs,
             endTime: endMs,
             nextToken,
@@ -185,7 +203,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
           await sleep(300);
         }
 
-        if (results && results.length > 0) {
+        if (results && results.length) {
           // Convert Insights results to our format
           events = results.map((row) => {
             const obj = Object.fromEntries(row.map((c) => [c.field || '', c.value || '']));
@@ -225,7 +243,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
         const fle = await client.send(
           new FilterLogEventsCommand({
             logGroupName: logGroup,
-            logStreamNames: streams.length > 0 ? streams.slice(0, 100) : undefined,
+            logStreamNames: streams.length ? streams.slice(0, 100) : undefined,
             startTime: fallbackStartMs,
             endTime: beforeMs,
             limit: limit * 2, // Get a bit more to ensure we have enough
@@ -238,7 +256,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
       }
     }
     // Keep CloudWatch's default order (oldest first, newest last)
-    const logs: AnalyticsLogRecord[] = events.map((e) => {
+    const logs: LogSchema[] = events.map((e) => {
       const message = e.message || '';
       let parsed: Record<string, unknown> = {};
       try {
@@ -251,7 +269,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
         id: e.eventId || `${e.logStreamName || ''}-${e.timestamp || ''}`,
         // CloudWatch timestamp is in milliseconds
         timestamp: e.timestamp ? new Date(e.timestamp).toISOString() : new Date().toISOString(),
-        event_message:
+        eventMessage:
           typeof parsed === 'object' && parsed && (parsed as Record<string, unknown>).msg
             ? String((parsed as Record<string, unknown>).msg)
             : typeof message === 'string'
@@ -268,14 +286,18 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     };
   }
 
-  async getLogSourceStats(): Promise<LogSourceStats[]> {
+  async getLogSourceStats(): Promise<LogStatsSchema[]> {
     if (!this.cwLogGroup || !this.cwClient) {
-      throw new Error('CloudWatch not initialized');
+      throw new AppError(
+        'AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY not found in environment variables',
+        500,
+        ERROR_CODES.LOGS_AWS_NOT_CONFIGURED
+      );
     }
     const client = this.cwClient;
     const logGroup = this.cwLogGroup;
     const sources = await this.getLogSources();
-    const stats: LogSourceStats[] = [];
+    const stats: LogStatsSchema[] = [];
     const suffixMapping = this.getSuffixMapping();
 
     const dls = await client.send(new DescribeLogStreamsCommand({ logGroupName: logGroup }));
@@ -289,7 +311,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
 
       let lastActivity = '';
 
-      if (sourceStreams.length > 0) {
+      if (sourceStreams.length) {
         try {
           // Use EXACTLY the same approach as getLogsBySource to get consistent results
           const endMs = Date.now();
@@ -297,16 +319,13 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
 
           // Use CloudWatch Insights to efficiently get the latest timestamp
           try {
-            const end = Date.now();
-            const start = end - 24 * 60 * 60 * 1000; // Last 24 hours
-
             const insights = `fields @timestamp | filter @logStream like /${suffix}/ | sort @timestamp desc | limit 1`;
 
             const startQuery = await client.send(
               new StartQueryCommand({
                 logGroupName: logGroup,
-                startTime: Math.floor(start / 1000),
-                endTime: Math.floor(end / 1000),
+                startTime: Math.floor(startMs / 1000),
+                endTime: Math.floor(endMs / 1000),
                 queryString: insights,
                 limit: 1,
               })
@@ -326,7 +345,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
               await sleep(200);
             }
 
-            if (results && results.length > 0) {
+            if (results && results.length) {
               const row = results[0];
               const timestampField = row.find((field) => field.field === '@timestamp');
               if (timestampField && timestampField.value) {
@@ -357,7 +376,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
             const fle = await client.send(
               new FilterLogEventsCommand({
                 logGroupName: logGroup,
-                logStreamNames: sourceStreams.length > 0 ? sourceStreams.slice(0, 100) : undefined,
+                logStreamNames: sourceStreams.length ? sourceStreams.slice(0, 100) : undefined,
                 startTime: startMs,
                 endTime: endMs,
                 limit: 1000, // Reasonable limit for fallback
@@ -365,7 +384,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
             );
 
             const events = fle.events || [];
-            if (events.length > 0) {
+            if (events.length) {
               const latestEvent = events[events.length - 1];
               if (latestEvent.timestamp) {
                 lastActivity = new Date(latestEvent.timestamp).toISOString();
@@ -409,11 +428,15 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     limit: number = 100,
     _offset = 0 // CloudWatch doesn't support offset-based pagination
   ): Promise<{
-    logs: (AnalyticsLogRecord & { source: string })[];
+    logs: (LogSchema & { source: string })[];
     total: number;
   }> {
     if (!this.cwLogGroup || !this.cwClient) {
-      throw new Error('CloudWatch not initialized');
+      throw new AppError(
+        'AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY not found in environment variables',
+        500,
+        ERROR_CODES.LOGS_AWS_NOT_CONFIGURED
+      );
     }
     const client = this.cwClient;
     const logGroup = this.cwLogGroup;
@@ -462,7 +485,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
     const toObj = (row: Array<{ field?: string; value?: string }>) =>
       Object.fromEntries(row.map((c) => [c.field || '', c.value || '']));
 
-    const mapped: (AnalyticsLogRecord & { source: string })[] = rows.map((r) => {
+    const mapped: (LogSchema & { source: string })[] = rows.map((r) => {
       const o = toObj(r);
       const msg = o['@message'] || '';
       let parsed: Record<string, unknown> = {};
@@ -487,7 +510,7 @@ export class CloudWatchProvider extends BaseAnalyticsProvider {
         timestamp: o['@timestamp']
           ? new Date(parseInt(o['@timestamp'])).toISOString()
           : new Date().toISOString(),
-        event_message:
+        eventMessage:
           typeof parsed === 'object' && (parsed as Record<string, unknown>).msg
             ? String((parsed as Record<string, unknown>).msg)
             : typeof msg === 'string'