insforge 1.3.0 → 1.4.8

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

@@ -109,7 +109,7 @@ export class StorageService {
     // This query finds all files matching the pattern and extracts the counter number
     const result = await this.getPool().query(
       `
-        SELECT key FROM _storage
+        SELECT key FROM storage.objects
         WHERE bucket = $1
         AND (key = $2 OR key LIKE $3)
       `,
@@ -169,7 +169,7 @@ export class StorageService {
       // Save metadata to database and return the timestamp in one operation
       const result = await client.query(
         `
-        INSERT INTO _storage (bucket, key, size, mime_type, uploaded_by)
+        INSERT INTO storage.objects (bucket, key, size, mime_type, uploaded_by)
         VALUES ($1, $2, $3, $4, $5)
         RETURNING uploaded_at as "uploadedAt"
       `,
@@ -207,7 +207,7 @@ export class StorageService {
     this.validateKey(key);
 
     const result = await this.getPool().query(
-      'SELECT * FROM _storage WHERE bucket = $1 AND key = $2',
+      'SELECT * FROM storage.objects WHERE bucket = $1 AND key = $2',
       [bucket, key]
     );
 
@@ -249,7 +249,7 @@ export class StorageService {
       // Check permissions
       if (!isAdmin) {
         const fileResult = await client.query(
-          'SELECT uploaded_by FROM _storage WHERE bucket = $1 AND key = $2',
+          'SELECT uploaded_by FROM storage.objects WHERE bucket = $1 AND key = $2',
           [bucket, key]
         );
 
@@ -273,10 +273,10 @@ export class StorageService {
       await this.provider.deleteObject(bucket, key);
 
       // Delete from database
-      const result = await client.query('DELETE FROM _storage WHERE bucket = $1 AND key = $2', [
-        bucket,
-        key,
-      ]);
+      const result = await client.query(
+        'DELETE FROM storage.objects WHERE bucket = $1 AND key = $2',
+        [bucket, key]
+      );
 
       return result.rowCount !== null && result.rowCount > 0;
     } finally {
@@ -295,8 +295,8 @@ export class StorageService {
 
     const client = await this.getPool().connect();
     try {
-      let query = 'SELECT * FROM _storage WHERE bucket = $1';
-      let countQuery = 'SELECT COUNT(*) as count FROM _storage WHERE bucket = $1';
+      let query = 'SELECT * FROM storage.objects WHERE bucket = $1';
+      let countQuery = 'SELECT COUNT(*) as count FROM storage.objects WHERE bucket = $1';
       const params: (string | number)[] = [bucket];
       let paramIndex = 2;
 
@@ -338,7 +338,7 @@ export class StorageService {
 
   async isBucketPublic(bucket: string): Promise<boolean> {
     const result = await this.getPool().query(
-      'SELECT public FROM _storage_buckets WHERE name = $1',
+      'SELECT public FROM storage.buckets WHERE name = $1',
       [bucket]
     );
     return result.rows[0]?.public || false;
@@ -348,7 +348,7 @@ export class StorageService {
     const client = await this.getPool().connect();
     try {
       // Check if bucket exists
-      const bucketResult = await client.query('SELECT name FROM _storage_buckets WHERE name = $1', [
+      const bucketResult = await client.query('SELECT name FROM storage.buckets WHERE name = $1', [
         bucket,
       ]);
 
@@ -356,9 +356,9 @@ export class StorageService {
         throw new Error(`Bucket "${bucket}" does not exist`);
       }
 
-      // Update bucket visibility in _storage_buckets table
+      // Update bucket visibility in storage.buckets table
       await client.query(
-        'UPDATE _storage_buckets SET public = $1, updated_at = CURRENT_TIMESTAMP WHERE name = $2',
+        'UPDATE storage.buckets SET public = $1, updated_at = CURRENT_TIMESTAMP WHERE name = $2',
         [isPublic, bucket]
       );
 
@@ -370,9 +370,9 @@ export class StorageService {
   }
 
   async listBuckets(): Promise<StorageBucketSchema[]> {
-    // Get all buckets with their metadata from _storage_buckets table
+    // Get all buckets with their metadata from storage.buckets table
     const result = await this.getPool().query(
-      'SELECT name, public, created_at as "createdAt" FROM _storage_buckets ORDER BY name'
+      'SELECT name, public, created_at as "createdAt" FROM storage.buckets ORDER BY name'
     );
 
     return result.rows as StorageBucketSchema[];
@@ -384,7 +384,7 @@ export class StorageService {
     const client = await this.getPool().connect();
     try {
       // Check if bucket already exists
-      const existing = await client.query('SELECT name FROM _storage_buckets WHERE name = $1', [
+      const existing = await client.query('SELECT name FROM storage.buckets WHERE name = $1', [
         bucket,
       ]);
 
@@ -392,8 +392,8 @@ export class StorageService {
         throw new Error(`Bucket "${bucket}" already exists`);
       }
 
-      // Insert bucket into _storage_buckets table
-      await client.query('INSERT INTO _storage_buckets (name, public) VALUES ($1, $2)', [
+      // Insert bucket into storage.buckets table
+      await client.query('INSERT INTO storage.buckets (name, public) VALUES ($1, $2)', [
         bucket,
         isPublic,
       ]);
@@ -414,7 +414,7 @@ export class StorageService {
     const client = await this.getPool().connect();
     try {
       // Check if bucket exists
-      const bucketResult = await client.query('SELECT name FROM _storage_buckets WHERE name = $1', [
+      const bucketResult = await client.query('SELECT name FROM storage.buckets WHERE name = $1', [
         bucket,
       ]);
 
@@ -425,8 +425,8 @@ export class StorageService {
       // Delete bucket using backend (handles all files)
       await this.provider.deleteBucket(bucket);
 
-      // Delete from storage table (cascade will handle _storage entries)
-      await client.query('DELETE FROM _storage_buckets WHERE name = $1', [bucket]);
+      // Delete from storage table (cascade will handle storage.objects entries)
+      await client.query('DELETE FROM storage.buckets WHERE name = $1', [bucket]);
 
       // Update storage metadata
       // Metadata is now updated on-demand
@@ -451,7 +451,7 @@ export class StorageService {
     const client = await this.getPool().connect();
     try {
       // Check if bucket exists
-      const bucketResult = await client.query('SELECT name FROM _storage_buckets WHERE name = $1', [
+      const bucketResult = await client.query('SELECT name FROM storage.buckets WHERE name = $1', [
         bucket,
       ]);
 
@@ -503,7 +503,7 @@ export class StorageService {
     try {
       // Check if already confirmed
       const existingResult = await client.query(
-        'SELECT key FROM _storage WHERE bucket = $1 AND key = $2',
+        'SELECT key FROM storage.objects WHERE bucket = $1 AND key = $2',
         [bucket, key]
       );
 
@@ -514,7 +514,7 @@ export class StorageService {
       // Save metadata to database and return the timestamp in one operation
       const result = await client.query(
         `
-        INSERT INTO _storage (bucket, key, size, mime_type, uploaded_by)
+        INSERT INTO storage.objects (bucket, key, size, mime_type, uploaded_by)
         VALUES ($1, $2, $3, $4, $5)
         RETURNING uploaded_at as "uploadedAt"
       `,
@@ -548,9 +548,9 @@ export class StorageService {
    * Get storage metadata
    */
   async getMetadata(): Promise<StorageMetadataSchema> {
-    // Get storage buckets from _storage_buckets table
+    // Get storage buckets from storage.buckets table
     const result = await this.getPool().query(
-      'SELECT name, public, created_at as "createdAt" FROM _storage_buckets ORDER BY name'
+      'SELECT name, public, created_at as "createdAt" FROM storage.buckets ORDER BY name'
     );
 
     const storageBuckets = result.rows as StorageBucketSchema[];
@@ -572,7 +572,7 @@ export class StorageService {
     try {
       // Query to get object count for each bucket
       const result = await this.getPool().query(
-        'SELECT bucket, COUNT(*) as count FROM _storage GROUP BY bucket'
+        'SELECT bucket, COUNT(*) as count FROM storage.objects GROUP BY bucket'
       );
 
       const bucketCounts = result.rows as { bucket: string; count: string }[];
@@ -595,11 +595,11 @@ export class StorageService {
 
   private async getStorageSizeInGB(): Promise<number> {
     try {
-      // Query the _storage table to sum all file sizes
+      // Query the storage.objects table to sum all file sizes
       const result = await this.getPool().query(
         `
         SELECT COALESCE(SUM(size), 0) as total_size
-        FROM _storage
+        FROM storage.objects
       `
       );
 

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

@@ -54,7 +54,7 @@ export class UsageService {
   async recordMCPUsage(toolName: string, success: boolean = true): Promise<{ created_at: string }> {
     try {
       const result = await this.getPool().query(
-        `INSERT INTO _mcp_usage (tool_name, success)
+        `INSERT INTO system.mcp_usage (tool_name, success)
          VALUES ($1, $2)
          RETURNING created_at`,
         [toolName, success]
@@ -75,7 +75,7 @@ export class UsageService {
     try {
       const result = await this.getPool().query(
         `SELECT tool_name, success, created_at
-         FROM _mcp_usage
+         FROM system.mcp_usage
          WHERE success = $1
          ORDER BY created_at DESC
          LIMIT $2`,
@@ -98,7 +98,7 @@ export class UsageService {
       // Get MCP tool usage count
       const mcpResult = await this.getPool().query(
         `SELECT COUNT(*) as count
-         FROM _mcp_usage
+         FROM system.mcp_usage
          WHERE success = true
            AND created_at >= $1
            AND created_at < $2`,
@@ -112,7 +112,7 @@ export class UsageService {
 
       // Get total storage size
       const storageResult = await this.getPool().query(
-        `SELECT COALESCE(SUM(size), 0) as total_size FROM _storage`
+        `SELECT COALESCE(SUM(size), 0) as total_size FROM storage.objects`
       );
 
       // Get AI usage breakdown by model (only billable metrics)
@@ -122,8 +122,8 @@ export class UsageService {
           COALESCE(SUM(u.input_tokens), 0) as total_input_tokens,
           COALESCE(SUM(u.output_tokens), 0) as total_output_tokens,
           COALESCE(SUM(u.image_count), 0) as total_images
-        FROM _ai_usage u
-        LEFT JOIN _ai_configs c ON u.config_id = c.id
+        FROM ai.usage u
+        LEFT JOIN ai.configs c ON u.config_id = c.id
         WHERE u.created_at >= $1 AND u.created_at < $2
         GROUP BY COALESCE(u.model_id, c.model_id)
         ORDER BY (COALESCE(SUM(u.input_tokens), 0) + COALESCE(SUM(u.output_tokens), 0)) DESC`,

package/backend/src/types/ai.ts

@@ -11,6 +11,14 @@ export interface OpenRouterImageMessage {
   };
 }
 
+export interface OpenRouterAudioMessage {
+  type: 'input_audio';
+  input_audio: {
+    data: string; // Base64-encoded audio data
+    format: string; // wav, mp3, aiff, aac, ogg, flac, m4a
+  };
+}
+
 // ============= OpenRouter API Types =============
 
 export interface RawOpenRouterModel {

package/backend/src/types/auth.ts

@@ -1,9 +1,13 @@
 // Type definitions for database user records
+
 export interface UserRecord {
   id: string;
   email: string;
-  name: string;
+  profile: Record<string, unknown> | null;
+  metadata: Record<string, unknown> | null;
   email_verified: boolean;
+  is_project_admin: boolean;
+  is_anonymous: boolean;
   created_at: string;
   updated_at: string;
   password?: string;

package/backend/src/types/database.ts

@@ -102,6 +102,7 @@ export type ForeignKeyInfo = ForeignKeySchema & {
 export interface ForeignKeyRow {
   constraint_name: string;
   from_column: string;
+  foreign_schema: string;
   foreign_table: string;
   foreign_column: string;
   on_delete: string;
@@ -112,6 +113,7 @@ export interface ForeignKeyRow {
 export interface ColumnInfo {
   column_name: string;
   data_type: string;
+  udt_name: string;
   is_nullable: string;
   column_default: string | null;
   character_maximum_length: number | null;

package/backend/src/types/deployments.ts

@@ -0,0 +1,33 @@
+// Backend-only types for deployments
+
+/**
+ * Deployment status constants
+ * WAITING -> UPLOADING -> (Vercel statuses: QUEUED/BUILDING/READY/ERROR/CANCELED)
+ */
+export const DeploymentStatus = {
+  // InsForge internal statuses
+  WAITING: 'WAITING', // Record created, waiting for client to upload zip to S3
+  UPLOADING: 'UPLOADING', // Server is downloading from S3 and uploading to Vercel
+  // Vercel statuses (stored directly)
+  QUEUED: 'QUEUED',
+  BUILDING: 'BUILDING',
+  READY: 'READY',
+  ERROR: 'ERROR',
+  CANCELED: 'CANCELED',
+} as const;
+
+export type DeploymentStatusType = (typeof DeploymentStatus)[keyof typeof DeploymentStatus];
+
+/**
+ * Internal deployment record with Date objects (database returns Date, not string)
+ */
+export interface DeploymentRecord {
+  id: string;
+  providerDeploymentId: string | null; // Provider's deployment ID, null until deployment starts
+  provider: string;
+  status: DeploymentStatusType;
+  url: string | null;
+  metadata: Record<string, unknown> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/backend/src/types/storage.ts

@@ -10,7 +10,7 @@ export interface StorageRecord {
   uploaded_at: string;
 }
 
-// Bucket record from _storage_buckets table
+// Bucket record from storage.buckets table
 export type BucketRecord = Omit<StorageBucketSchema, 'created_at'>;
 
 // Form field types for file uploads

package/backend/src/types/webhooks.ts

@@ -0,0 +1,45 @@
+// Webhook types for external integrations
+
+// ============================================================================
+// Vercel Webhooks
+// ============================================================================
+
+/**
+ * Vercel webhook event types we handle for deployments
+ */
+export type VercelDeploymentEventType =
+  | 'deployment.created'
+  | 'deployment.succeeded'
+  | 'deployment.error'
+  | 'deployment.canceled';
+
+/**
+ * Map Vercel webhook event types to our deployment status
+ */
+export const VERCEL_EVENT_TO_STATUS: Record<VercelDeploymentEventType, string> = {
+  'deployment.created': 'BUILDING',
+  'deployment.succeeded': 'READY',
+  'deployment.error': 'ERROR',
+  'deployment.canceled': 'CANCELED',
+};
+
+/**
+ * Vercel webhook payload structure for deployment events
+ */
+export interface VercelWebhookPayload {
+  type: string;
+  id: string;
+  createdAt: string;
+  payload: {
+    team?: { id: string };
+    user?: { id: string };
+    deployment: {
+      id: string;
+      url: string;
+      name: string;
+      meta?: Record<string, unknown>;
+    };
+    target?: string;
+    project?: { id: string };
+  };
+}

package/backend/src/utils/cookies.ts

@@ -1,35 +1,34 @@
-import { Response } from 'express';
-import { isProduction } from './environment';
-
-/**
- * Cookie names
- */
-export const REFRESH_TOKEN_COOKIE_NAME = 'insforge_refresh_token';
-
-/**
- * Set an auth cookie on response
- * @param name - Cookie name
- * @param value - Cookie value
- */
-export function setAuthCookie(res: Response, name: string, value: string): void {
-  res.cookie(name, value, {
-    httpOnly: true,
-    secure: isProduction(),
-    sameSite: 'none',
-    path: '/api/auth',
-    maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
-  });
-}
-
-/**
- * Clear an auth cookie on response
- * IMPORTANT: Must use the same options (especially path) as when setting the cookie
- */
-export function clearAuthCookie(res: Response, name: string): void {
-  res.clearCookie(name, {
-    httpOnly: true,
-    secure: isProduction(),
-    sameSite: 'none',
-    path: '/api/auth',
-  });
-}
+import { Request, Response } from 'express';
+
+/**
+ * Cookie names
+ */
+export const REFRESH_TOKEN_COOKIE_NAME = 'insforge_refresh_token';
+
+/**
+ * Set an auth cookie on response
+ * @param name - Cookie name
+ * @param value - Cookie value
+ */
+export function setAuthCookie(req: Request, res: Response, name: string, value: string): void {
+  res.cookie(name, value, {
+    httpOnly: true,
+    secure: req.secure,
+    sameSite: 'none',
+    path: '/api/auth',
+    maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+  });
+}
+
+/**
+ * Clear an auth cookie on response
+ * IMPORTANT: Must use the same options (especially path) as when setting the cookie
+ */
+export function clearAuthCookie(req: Request, res: Response, name: string): void {
+  res.clearCookie(name, {
+    httpOnly: true,
+    secure: req.secure,
+    sameSite: 'none',
+    path: '/api/auth',
+  });
+}

package/backend/src/utils/environment.ts

@@ -18,20 +18,6 @@ export function isOAuthSharedKeysAvailable(): boolean {
   return isCloudEnvironment();
 }
 
-/**
- * Check if running in development mode
- */
-export function isDevelopment(): boolean {
-  return process.env.NODE_ENV === 'development' || !process.env.NODE_ENV;
-}
-
-/**
- * Check if running in production mode
- */
-export function isProduction(): boolean {
-  return process.env.NODE_ENV === 'production';
-}
-
 /**
  * Get the API base URL from environment variable or default to localhost
  * @returns The API base URL

package/backend/src/utils/s3-config-loader.ts

@@ -1,64 +1,64 @@
-import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
-import logger from '@/utils/logger.js';
-
-// TODO: make these configurable in env variables in cloud backend
-const CONFIG_BUCKET = process.env.AWS_CONFIG_BUCKET || 'insforge-config';
-const CONFIG_REGION = process.env.AWS_CONFIG_REGION || 'us-east-2';
-
-let s3Client: S3Client | null = null;
-
-/**
- * Get or create S3 client for config loading
- */
-function getS3Client(): S3Client {
-  if (s3Client) {
-    return s3Client;
-  }
-
-  const s3Config: {
-    region: string;
-    credentials?: { accessKeyId: string; secretAccessKey: string };
-  } = {
-    region: CONFIG_REGION,
-  };
-
-  // Use explicit credentials if provided, otherwise IAM role
-  if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
-    s3Config.credentials = {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    };
-  }
-
-  s3Client = new S3Client(s3Config);
-  return s3Client;
-}
-
-/**
- * Fetches a JSON config file from the S3 config bucket
- * @param key - The S3 object key (e.g., 'default-ai-models.json')
- * @returns Parsed JSON content or null if fetch fails
- */
-export async function fetchS3Config<T>(key: string): Promise<T | null> {
-  try {
-    const command = new GetObjectCommand({
-      Bucket: CONFIG_BUCKET,
-      Key: key,
-    });
-
-    const response = await getS3Client().send(command);
-    const body = await response.Body?.transformToString();
-
-    if (!body) {
-      logger.warn(`Empty config file from S3: ${key}`);
-      return null;
-    }
-
-    return JSON.parse(body) as T;
-  } catch (error) {
-    logger.warn(`Failed to fetch config from S3: ${key}`, {
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return null;
-  }
-}
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import logger from '@/utils/logger.js';
+
+// TODO: make these configurable in env variables in cloud backend
+const CONFIG_BUCKET = process.env.AWS_CONFIG_BUCKET || 'insforge-config';
+const CONFIG_REGION = process.env.AWS_CONFIG_REGION || 'us-east-2';
+
+let s3Client: S3Client | null = null;
+
+/**
+ * Get or create S3 client for config loading
+ */
+function getS3Client(): S3Client {
+  if (s3Client) {
+    return s3Client;
+  }
+
+  const s3Config: {
+    region: string;
+    credentials?: { accessKeyId: string; secretAccessKey: string };
+  } = {
+    region: CONFIG_REGION,
+  };
+
+  // Use explicit credentials if provided, otherwise IAM role
+  if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
+    s3Config.credentials = {
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    };
+  }
+
+  s3Client = new S3Client(s3Config);
+  return s3Client;
+}
+
+/**
+ * Fetches a JSON config file from the S3 config bucket
+ * @param key - The S3 object key (e.g., 'default-ai-models.json')
+ * @returns Parsed JSON content or null if fetch fails
+ */
+export async function fetchS3Config<T>(key: string): Promise<T | null> {
+  try {
+    const command = new GetObjectCommand({
+      Bucket: CONFIG_BUCKET,
+      Key: key,
+    });
+
+    const response = await getS3Client().send(command);
+    const body = await response.Body?.transformToString();
+
+    if (!body) {
+      logger.warn(`Empty config file from S3: ${key}`);
+      return null;
+    }
+
+    return JSON.parse(body) as T;
+  } catch (error) {
+    logger.warn(`Failed to fetch config from S3: ${key}`, {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+}