insforge 0.3.3 → 1.3.0

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

@@ -0,0 +1,127 @@
+import { DatabaseManager } from '@/infra/database/database.manager.js';
+import type {
+  DatabaseFunctionsResponse,
+  DatabaseIndexesResponse,
+  DatabasePoliciesResponse,
+  DatabaseTriggersResponse,
+} from '@insforge/shared-schemas';
+
+export class DatabaseService {
+  private static instance: DatabaseService;
+  private dbManager = DatabaseManager.getInstance();
+
+  private constructor() {}
+
+  public static getInstance(): DatabaseService {
+    if (!DatabaseService.instance) {
+      DatabaseService.instance = new DatabaseService();
+    }
+    return DatabaseService.instance;
+  }
+
+  /**
+   * Get all database functions (excluding system and extension functions)
+   */
+  async getFunctions(): Promise<DatabaseFunctionsResponse> {
+    const pool = this.dbManager.getPool();
+
+    const result = await pool.query(`
+      SELECT
+        p.proname as "functionName",
+        pg_get_functiondef(p.oid) as "functionDef",
+        p.prokind as "kind"
+      FROM pg_proc p
+      JOIN pg_namespace n ON p.pronamespace = n.oid
+      WHERE n.nspname = 'public'
+        AND p.prokind IN ('f', 'p', 'w')
+        AND NOT EXISTS (
+          SELECT 1 FROM pg_depend d
+          JOIN pg_extension e ON d.refobjid = e.oid
+          WHERE d.objid = p.oid
+        )
+      ORDER BY p.proname
+    `);
+
+    return {
+      functions: result.rows,
+    };
+  }
+
+  /**
+   * Get all indexes across all tables (excluding system tables)
+   */
+  async getIndexes(): Promise<DatabaseIndexesResponse> {
+    const pool = this.dbManager.getPool();
+
+    const result = await pool.query(`
+      SELECT
+        pi.tablename as "tableName",
+        pi.indexname as "indexName",
+        pi.indexdef as "indexDef",
+        idx.indisunique as "isUnique",
+        idx.indisprimary as "isPrimary"
+      FROM pg_indexes pi
+      JOIN pg_class cls ON cls.relname = pi.indexname
+        AND cls.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = pi.schemaname)
+      JOIN pg_index idx ON idx.indexrelid = cls.oid
+      WHERE pi.schemaname = 'public'
+        AND pi.tablename NOT LIKE '\\_%' ESCAPE '\\'
+      ORDER BY pi.tablename, pi.indexname
+    `);
+
+    return {
+      indexes: result.rows,
+    };
+  }
+
+  /**
+   * Get all RLS policies across all tables (excluding system tables)
+   */
+  async getPolicies(): Promise<DatabasePoliciesResponse> {
+    const pool = this.dbManager.getPool();
+
+    const result = await pool.query(`
+      SELECT
+        tablename as "tableName",
+        policyname as "policyName",
+        cmd,
+        roles,
+        qual,
+        with_check as "withCheck"
+      FROM pg_policies
+      WHERE schemaname = 'public'
+        AND tablename NOT LIKE '\\_%' ESCAPE '\\'
+      ORDER BY tablename, policyname
+    `);
+
+    return {
+      policies: result.rows,
+    };
+  }
+
+  /**
+   * Get all triggers across all tables (excluding system tables)
+   */
+  async getTriggers(): Promise<DatabaseTriggersResponse> {
+    const pool = this.dbManager.getPool();
+
+    const result = await pool.query(`
+      SELECT
+        event_object_table as "tableName",
+        trigger_name as "triggerName",
+        action_timing as "actionTiming",
+        event_manipulation as "eventManipulation",
+        action_orientation as "actionOrientation",
+        action_condition as "actionCondition",
+        action_statement as "actionStatement"
+      FROM information_schema.triggers
+      WHERE event_object_schema = 'public'
+        AND event_object_table NOT LIKE '\\_%' ESCAPE '\\'
+      ORDER BY event_object_table, trigger_name
+    `);
+
+    return {
+      triggers: result.rows,
+    };
+  }
+}

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

@@ -0,0 +1,73 @@
+import { EmailProvider } from '@/providers/email/base.provider.js';
+import { CloudEmailProvider } from '@/providers/email/cloud.provider.js';
+import { EmailTemplate } from '@/types/email.js';
+import { SendRawEmailRequest } from '@insforge/shared-schemas';
+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 custom/raw email
+   * @param options - Email options (to, subject, html, cc, bcc, from, replyTo)
+   */
+  public async sendRaw(options: SendRawEmailRequest): Promise<void> {
+    if (!this.provider.sendRaw) {
+      throw new Error('Current email provider does not support raw email sending');
+    }
+    return this.provider.sendRaw(options);
+  }
+
+  /**
+   * 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),