insforge 0.3.2 → 1.2.10

package/backend/src/services/email/email.service.ts

@@ -0,0 +1,75 @@
+import { EmailProvider } from '@/providers/email/base.provider.js';
+import { CloudEmailProvider } from '@/providers/email/cloud.provider.js';
+import { EmailTemplate } from '@/types/email.js';
+import logger from '@/utils/logger.js';
+
+/**
+ * Email service that orchestrates different email providers
+ */
+export class EmailService {
+  private static instance: EmailService;
+  private provider: EmailProvider;
+
+  private constructor() {
+    // For now, we only support cloud provider
+    // In the future, this can be configured via environment variables
+    // Example:
+    // if (process.env.EMAIL_PROVIDER === 'smtp') {
+    //   this.provider = new SMTPEmailProvider(config.email.smtp);
+    // } else if (process.env.EMAIL_PROVIDER === 'sendgrid') {
+    //   this.provider = new SendGridEmailProvider(config.email.sendgrid);
+    // } else {
+    //   this.provider = new CloudEmailProvider();
+    // }
+
+    this.provider = new CloudEmailProvider();
+    logger.info('Using email provider: Cloud (Insforge)');
+  }
+
+  /**
+   * Get singleton instance of EmailService
+   */
+  public static getInstance(): EmailService {
+    if (!EmailService.instance) {
+      EmailService.instance = new EmailService();
+    }
+    return EmailService.instance;
+  }
+
+  /**
+   * 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
+   */
+  public async sendWithTemplate(
+    email: string,
+    name: string,
+    template: EmailTemplate,
+    variables?: Record<string, string>
+  ): Promise<void> {
+    return this.provider.sendWithTemplate(email, name, template, variables);
+  }
+
+  /**
+   * Send raw email (if provider supports it)
+   * @param to - Recipient email address
+   * @param subject - Email subject
+   * @param html - HTML email body
+   * @param text - Plain text email body (optional)
+   */
+  public async sendRaw(to: string, subject: string, html: string, text?: string): Promise<void> {
+    if (!this.provider.sendRaw) {
+      throw new Error('Current email provider does not support raw email sending');
+    }
+    return this.provider.sendRaw(to, subject, html, text);
+  }
+
+  /**
+   * Check if current provider supports templates
+   */
+  public supportsTemplates(): boolean {
+    return this.provider.supportsTemplates();
+  }
+}

package/backend/src/{core/functions/functions.ts → services/functions/function.service.ts}

@@ -1,13 +1,13 @@
-import { DatabaseManager } from '@/core/database/manager.js';
+import { DatabaseManager } from '@/infra/database/database.manager.js';
 import {
   EdgeFunctionMetadataSchema,
   FunctionUploadRequest,
   FunctionUpdateRequest,
 } from '@insforge/shared-schemas';
 import logger from '@/utils/logger.js';
-import { DatabaseError } from 'pg';
+import { DatabaseError, Pool } from 'pg';
 import fetch from 'node-fetch';
-import { AppError } from '@/api/middleware/error.js';
+import { AppError } from '@/api/middlewares/error.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
 
 export interface FunctionWithRuntime {
@@ -17,19 +17,25 @@ export interface FunctionWithRuntime {
   };
 }
 
-export class FunctionsService {
-  private static instance: FunctionsService;
-  private db;
+export class FunctionService {
+  private static instance: FunctionService;
+  private pool: Pool | null = null;
 
-  private constructor() {
-    this.db = DatabaseManager.getInstance();
+  private constructor() {}
+
+  static getInstance(): FunctionService {
+    if (!FunctionService.instance) {
+      FunctionService.instance = new FunctionService();
+    }
+    return FunctionService.instance;
   }
 
-  static getInstance(): FunctionsService {
-    if (!FunctionsService.instance) {
-      FunctionsService.instance = new FunctionsService();
+  private getPool(): Pool {
+    if (!this.pool) {
+      const dbManager = DatabaseManager.getInstance();
+      this.pool = dbManager.getPool();
     }
-    return FunctionsService.instance;
+    return this.pool;
   }
 
   /**
@@ -37,15 +43,15 @@ export class FunctionsService {
    */
   async listFunctions(): Promise<FunctionWithRuntime> {
     try {
-      const functions = await this.db
-        .prepare(
-          `SELECT 
-            id, slug, name, description, status, 
-            created_at, updated_at, deployed_at
-          FROM _functions
-          ORDER BY created_at DESC`
-        )
-        .all();
+      const result = await this.getPool().query(
+        `SELECT
+          id, slug, name, description, status,
+          created_at, updated_at, deployed_at
+        FROM _functions
+        ORDER BY created_at DESC`
+      );
+
+      const functions = result.rows;
 
       // Check if Deno runtime is healthy
       let runtimeHealthy = false;
@@ -82,17 +88,16 @@ export class FunctionsService {
    */
   async getFunction(slug: string): Promise<Record<string, unknown> | undefined> {
     try {
-      const func = await this.db
-        .prepare(
-          `SELECT 
-            id, slug, name, description, code, status,
-            created_at, updated_at, deployed_at
-          FROM _functions
-          WHERE slug = ?`
-        )
-        .get(slug);
-
-      return func;
+      const result = await this.getPool().query(
+        `SELECT
+          id, slug, name, description, code, status,
+          created_at, updated_at, deployed_at
+        FROM _functions
+        WHERE slug = $1`,
+        [slug]
+      );
+
+      return result.rows[0];
     } catch (error) {
       logger.error('Failed to get function', {
         error: error instanceof Error ? error.message : String(error),
@@ -107,6 +112,7 @@ export class FunctionsService {
    * Create a new function
    */
   async createFunction(data: FunctionUploadRequest): Promise<Record<string, unknown>> {
+    const client = await this.getPool().connect();
     try {
       const { name, code, description, status } = data;
       const slug = data.slug || name.toLowerCase().replace(/\s+/g, '-');
@@ -118,29 +124,27 @@ export class FunctionsService {
       const id = crypto.randomUUID();
 
       // Insert function
-      await this.db
-        .prepare(
-          `INSERT INTO _functions (id, slug, name, description, code, status)
-          VALUES (?, ?, ?, ?, ?, ?)`
-        )
-        .run(id, slug, name, description || null, code, status);
+      await client.query(
+        `INSERT INTO _functions (id, slug, name, description, code, status)
+        VALUES ($1, $2, $3, $4, $5, $6)`,
+        [id, slug, name, description || null, code, status]
+      );
 
       // If status is active, update deployed_at
       if (status === 'active') {
-        await this.db
-          .prepare(`UPDATE _functions SET deployed_at = CURRENT_TIMESTAMP WHERE id = ?`)
-          .run(id);
+        await client.query(`UPDATE _functions SET deployed_at = CURRENT_TIMESTAMP WHERE id = $1`, [
+          id,
+        ]);
       }
 
       // Fetch the created function
-      const created = await this.db
-        .prepare(
-          `SELECT id, slug, name, description, status, created_at
-          FROM _functions WHERE id = ?`
-        )
-        .get(id);
-
-      return created;
+      const result = await client.query(
+        `SELECT id, slug, name, description, status, created_at
+        FROM _functions WHERE id = $1`,
+        [id]
+      );
+
+      return result.rows[0];
     } catch (error) {
       // Re-throw AppErrors as-is
       if (error instanceof AppError) {
@@ -162,6 +166,8 @@ export class FunctionsService {
       }
 
       throw error;
+    } finally {
+      client.release();
     }
   }
 
@@ -172,10 +178,13 @@ export class FunctionsService {
     slug: string,
     updates: FunctionUpdateRequest
   ): Promise<Record<string, unknown> | null> {
+    const client = await this.getPool().connect();
     try {
       // Check if function exists
-      const existing = await this.db.prepare('SELECT id FROM _functions WHERE slug = ?').get(slug);
-      if (!existing) {
+      const existingResult = await client.query('SELECT id FROM _functions WHERE slug = $1', [
+        slug,
+      ]);
+      if (existingResult.rows.length === 0) {
         return null;
       }
 
@@ -186,50 +195,48 @@ export class FunctionsService {
 
       // Update fields
       if (updates.name !== undefined) {
-        await this.db
-          .prepare('UPDATE _functions SET name = ? WHERE slug = ?')
-          .run(updates.name, slug);
+        await client.query('UPDATE _functions SET name = $1 WHERE slug = $2', [updates.name, slug]);
       }
 
       if (updates.description !== undefined) {
-        await this.db
-          .prepare('UPDATE _functions SET description = ? WHERE slug = ?')
-          .run(updates.description, slug);
+        await client.query('UPDATE _functions SET description = $1 WHERE slug = $2', [
+          updates.description,
+          slug,
+        ]);
       }
 
       if (updates.code !== undefined) {
-        await this.db
-          .prepare('UPDATE _functions SET code = ? WHERE slug = ?')
-          .run(updates.code, slug);
+        await client.query('UPDATE _functions SET code = $1 WHERE slug = $2', [updates.code, slug]);
       }
 
       if (updates.status !== undefined) {
-        await this.db
-          .prepare('UPDATE _functions SET status = ? WHERE slug = ?')
-          .run(updates.status, slug);
+        await client.query('UPDATE _functions SET status = $1 WHERE slug = $2', [
+          updates.status,
+          slug,
+        ]);
 
         // Update deployed_at if status changes to active
         if (updates.status === 'active') {
-          await this.db
-            .prepare('UPDATE _functions SET deployed_at = CURRENT_TIMESTAMP WHERE slug = ?')
-            .run(slug);
+          await client.query(
+            'UPDATE _functions SET deployed_at = CURRENT_TIMESTAMP WHERE slug = $1',
+            [slug]
+          );
         }
       }
 
       // Update updated_at
-      await this.db
-        .prepare('UPDATE _functions SET updated_at = CURRENT_TIMESTAMP WHERE slug = ?')
-        .run(slug);
+      await client.query('UPDATE _functions SET updated_at = CURRENT_TIMESTAMP WHERE slug = $1', [
+        slug,
+      ]);
 
       // Fetch updated function
-      const updated = await this.db
-        .prepare(
-          `SELECT id, slug, name, description, status, updated_at
-          FROM _functions WHERE slug = ?`
-        )
-        .get(slug);
-
-      return updated;
+      const result = await client.query(
+        `SELECT id, slug, name, description, status, updated_at
+        FROM _functions WHERE slug = $1`,
+        [slug]
+      );
+
+      return result.rows[0];
     } catch (error) {
       logger.error('Failed to update function', {
         error: error instanceof Error ? error.message : String(error),
@@ -237,6 +244,8 @@ export class FunctionsService {
         slug,
       });
       throw error;
+    } finally {
+      client.release();
     }
   }
 
@@ -245,9 +254,9 @@ export class FunctionsService {
    */
   async deleteFunction(slug: string): Promise<boolean> {
     try {
-      const result = await this.db.prepare('DELETE FROM _functions WHERE slug = ?').run(slug);
+      const result = await this.getPool().query('DELETE FROM _functions WHERE slug = $1', [slug]);
 
-      if (result.changes === 0) {
+      if (result.rowCount === 0) {
         return false;
       }
 
@@ -267,15 +276,13 @@ export class FunctionsService {
    */
   async getMetadata(): Promise<Array<EdgeFunctionMetadataSchema>> {
     try {
-      const functions = await this.db
-        .prepare(
-          `SELECT slug, name, description, status
-          FROM _functions
-          ORDER BY created_at DESC`
-        )
-        .all();
-
-      return functions as Array<EdgeFunctionMetadataSchema>;
+      const result = await this.getPool().query(
+        `SELECT slug, name, description, status
+        FROM _functions
+        ORDER BY created_at DESC`
+      );
+
+      return result.rows as Array<EdgeFunctionMetadataSchema>;
     } catch (error) {
       logger.error('Failed to get edge functions metadata', {
         error: error instanceof Error ? error.message : String(error),

package/backend/src/{core/logs/audit.ts → services/logs/audit.service.ts}

@@ -1,20 +1,26 @@
-import { DatabaseManager } from '@/core/database/manager.js';
+import { Pool } from 'pg';
+import { DatabaseManager } from '@/infra/database/database.manager.js';
 import logger from '@/utils/logger.js';
-import { AppError } from '@/api/middleware/error.js';
+import { AppError } from '@/api/middlewares/error.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
 import type { AuditLogEntry, AuditLogQuery } from '@/types/logs.js';
 import { AuditLogSchema, GetAuditLogStatsResponse } from '@insforge/shared-schemas';
 
 export class AuditService {
   private static instance: AuditService;
-  private db: ReturnType<DatabaseManager['getDb']>;
+  private pool: Pool | null = null;
 
   private constructor() {
-    const dbManager = DatabaseManager.getInstance();
-    this.db = dbManager.getDb();
     logger.info('AuditService initialized');
   }
 
+  private getPool(): Pool {
+    if (!this.pool) {
+      this.pool = DatabaseManager.getInstance().getPool();
+    }
+    return this.pool;
+  }
+
   public static getInstance(): AuditService {
     if (!AuditService.instance) {
       AuditService.instance = new AuditService();
@@ -27,19 +33,21 @@ export class AuditService {
    */
   async log(entry: AuditLogEntry): Promise<AuditLogSchema> {
     try {
-      const result = await this.db
-        .prepare(
-          `INSERT INTO _audit_logs (actor, action, module, details, ip_address)
-           VALUES ($1, $2, $3, $4, $5)
-           RETURNING *`
-        )
-        .get(
+      const pool = this.getPool();
+      const result = await pool.query(
+        `INSERT INTO _audit_logs (actor, action, module, details, ip_address)
+         VALUES ($1, $2, $3, $4, $5)
+         RETURNING *`,
+        [
           entry.actor,
           entry.action,
           entry.module,
           entry.details ? JSON.stringify(entry.details) : null,
-          entry.ip_address || null
-        );
+          entry.ip_address || null,
+        ]
+      );
+
+      const row = result.rows[0];
 
       logger.info('Audit log created', {
         actor: entry.actor,
@@ -48,14 +56,14 @@ export class AuditService {
       });
 
       return {
-        id: result.id,
-        actor: result.actor,
-        action: result.action,
-        module: result.module,
-        details: result.details,
-        ipAddress: result.ip_address,
-        createdAt: result.created_at,
-        updatedAt: result.updated_at,
+        id: row.id,
+        actor: row.actor,
+        action: row.action,
+        module: row.module,
+        details: row.details,
+        ipAddress: row.ip_address,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
       };
     } catch (error) {
       logger.error('Failed to create audit log', error);
@@ -68,6 +76,8 @@ export class AuditService {
    */
   async query(query: AuditLogQuery): Promise<{ records: AuditLogSchema[]; total: number }> {
     try {
+      const pool = this.getPool();
+
       // Build base WHERE clause
       let whereClause = 'WHERE 1=1';
       const params: unknown[] = [];
@@ -100,8 +110,8 @@ export class AuditService {
 
       // Get total count first
       const countSql = `SELECT COUNT(*) as count FROM _audit_logs ${whereClause}`;
-      const countResult = (await this.db.prepare(countSql).get(...params)) as { count: number };
-      const total = countResult.count;
+      const countResult = await pool.query(countSql, params);
+      const total = parseInt(countResult.rows[0].count, 10);
 
       // Get paginated records
       let dataSql = `SELECT * FROM _audit_logs ${whereClause} ORDER BY created_at DESC`;
@@ -117,10 +127,10 @@ export class AuditService {
         dataParams.push(query.offset);
       }
 
-      const records = await this.db.prepare(dataSql).all(...dataParams);
+      const dataResult = await pool.query(dataSql, dataParams);
 
       return {
-        records: records.map((record) => ({
+        records: dataResult.rows.map((record) => ({
           id: record.id,
           actor: record.actor,
           action: record.action,
@@ -143,18 +153,21 @@ export class AuditService {
    */
   async getById(id: string): Promise<AuditLogSchema | null> {
     try {
-      const result = await this.db.prepare('SELECT * FROM _audit_logs WHERE id = $1').get(id);
+      const pool = this.getPool();
+      const result = await pool.query('SELECT * FROM _audit_logs WHERE id = $1', [id]);
+
+      const row = result.rows[0];
 
-      return result
+      return row
         ? {
-            id: result.id,
-            actor: result.actor,
-            action: result.action,
-            module: result.module,
-            details: result.details,
-            ipAddress: result.ip_address,
-            createdAt: result.created_at,
-            updatedAt: result.updated_at,
+            id: row.id,
+            actor: row.actor,
+            action: row.action,
+            module: row.module,
+            details: row.details,
+            ipAddress: row.ip_address,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
           }
         : null;
     } catch (error) {
@@ -168,50 +181,52 @@ export class AuditService {
    */
   async getStats(days: number = 7): Promise<GetAuditLogStatsResponse> {
     try {
+      const pool = this.getPool();
       const startDate = new Date();
       startDate.setDate(startDate.getDate() - days);
 
-      const [totalLogs] = await this.db
-        .prepare('SELECT COUNT(*) as count FROM _audit_logs WHERE created_at >= $1')
-        .get(startDate.toISOString());
-
-      const [uniqueActors] = await this.db
-        .prepare('SELECT COUNT(DISTINCT actor) as count FROM _audit_logs WHERE created_at >= $1')
-        .get(startDate.toISOString());
-
-      const [uniqueModules] = await this.db
-        .prepare('SELECT COUNT(DISTINCT module) as count FROM _audit_logs WHERE created_at >= $1')
-        .get(startDate.toISOString());
-
-      const actionsByModule = await this.db
-        .prepare(
-          `SELECT module, COUNT(*) as count
-           FROM _audit_logs
-           WHERE created_at >= $1
-           GROUP BY module`
-        )
-        .all(startDate.toISOString());
-
-      const recentActivity = await this.db
-        .prepare(
-          `SELECT * FROM _audit_logs
-           WHERE created_at >= $1
-           ORDER BY created_at DESC
-           LIMIT 10`
-        )
-        .all(startDate.toISOString());
+      const totalLogsResult = await pool.query(
+        'SELECT COUNT(*) as count FROM _audit_logs WHERE created_at >= $1',
+        [startDate.toISOString()]
+      );
+
+      const uniqueActorsResult = await pool.query(
+        'SELECT COUNT(DISTINCT actor) as count FROM _audit_logs WHERE created_at >= $1',
+        [startDate.toISOString()]
+      );
+
+      const uniqueModulesResult = await pool.query(
+        'SELECT COUNT(DISTINCT module) as count FROM _audit_logs WHERE created_at >= $1',
+        [startDate.toISOString()]
+      );
+
+      const actionsByModuleResult = await pool.query(
+        `SELECT module, COUNT(*) as count
+         FROM _audit_logs
+         WHERE created_at >= $1
+         GROUP BY module`,
+        [startDate.toISOString()]
+      );
+
+      const recentActivityResult = await pool.query(
+        `SELECT * FROM _audit_logs
+         WHERE created_at >= $1
+         ORDER BY created_at DESC
+         LIMIT 10`,
+        [startDate.toISOString()]
+      );
 
       const moduleStats: Record<string, number> = {};
-      actionsByModule.forEach((row: { module: string; count: string }) => {
-        moduleStats[row.module] = parseInt(row.count);
+      actionsByModuleResult.rows.forEach((row: { module: string; count: string }) => {
+        moduleStats[row.module] = parseInt(row.count, 10);
       });
 
       return {
-        totalLogs: parseInt(totalLogs?.count || 0),
-        uniqueActors: parseInt(uniqueActors?.count || 0),
-        uniqueModules: parseInt(uniqueModules?.count || 0),
+        totalLogs: parseInt(totalLogsResult.rows[0]?.count || '0', 10),
+        uniqueActors: parseInt(uniqueActorsResult.rows[0]?.count || '0', 10),
+        uniqueModules: parseInt(uniqueModulesResult.rows[0]?.count || '0', 10),
         actionsByModule: moduleStats,
-        recentActivity: recentActivity.map((record) => ({
+        recentActivity: recentActivityResult.rows.map((record) => ({
           id: record.id,
           actor: record.actor,
           action: record.action,
@@ -233,14 +248,16 @@ export class AuditService {
    */
   async cleanup(daysToKeep: number = 90): Promise<number> {
     try {
+      const pool = this.getPool();
       const cutoffDate = new Date();
       cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
 
-      const result = await this.db
-        .prepare('DELETE FROM _audit_logs WHERE created_at < $1 RETURNING id')
-        .all(cutoffDate.toISOString());
+      const result = await pool.query(
+        'DELETE FROM _audit_logs WHERE created_at < $1 RETURNING id',
+        [cutoffDate.toISOString()]
+      );
 
-      const deletedCount = result.length;
+      const deletedCount = result.rows.length;
 
       if (deletedCount > 0) {
         logger.info(`Cleaned up ${deletedCount} audit logs older than ${daysToKeep} days`);