insforge 0.3.3 → 1.3.0

package/frontend/src/features/database/services/record.service.ts

@@ -0,0 +1,219 @@
+import { ConvertedValue } from '@/components/datagrid/datagridTypes';
+import { apiClient } from '@/lib/api/client';
+import { ColumnSchema } from '@insforge/shared-schemas';
+import { tableService } from './table.service';
+
+export interface CSVImportResponse {
+  success: boolean;
+  message?: string;
+  data?: {
+    rowCount: number;
+  };
+  error?: string; // For backend error messages
+}
+
+export class RecordService {
+  /**
+   * Data fetching method with built-in search, sorting, and pagination for UI components.
+   *
+   * @param tableName - Name of the table
+   * @param limit - Number of records to fetch
+   * @param offset - Number of records to skip
+   * @param searchQuery - Search term to filter text columns
+   * @param sortColumns - Sorting configuration
+   * @returns Structured response with records and pagination info
+   */
+  async getTableRecords(
+    tableName: string,
+    limit = 10,
+    offset = 0,
+    searchQuery?: string,
+    sortColumns?: { columnKey: string; direction: string }[]
+  ) {
+    const params = new URLSearchParams();
+    params.set('limit', limit.toString());
+    params.set('offset', offset.toString());
+
+    // Construct PostgREST filter directly in frontend if search query is provided
+    if (searchQuery && searchQuery.trim()) {
+      const searchValue = searchQuery.trim();
+
+      // Get table schema to identify text columns
+      const schema = await tableService.getTableSchema(tableName);
+      const textColumns = schema.columns
+        .filter((col: ColumnSchema) => {
+          const type = col.type.toLowerCase();
+          return type === 'string';
+        })
+        .map((col: ColumnSchema) => col.columnName);
+
+      if (textColumns.length) {
+        // Create PostgREST OR filter for text columns
+        const orFilters = textColumns
+          .map((column: string) => `${column}.ilike.*${searchValue}*`)
+          .join(',');
+        params.set('or', `(${orFilters})`);
+      }
+    }
+
+    // Add sorting if provided - PostgREST uses "order" parameter
+    if (sortColumns && sortColumns.length) {
+      const orderParam = sortColumns
+        .map((col) => `${col.columnKey}.${col.direction.toLowerCase()}`)
+        .join(',');
+      params.set('order', orderParam);
+    }
+
+    const response: {
+      data: { [key: string]: ConvertedValue }[];
+      pagination: { offset: number; limit: number; total: number };
+    } = await apiClient.request(`/database/records/${tableName}?${params.toString()}`, {
+      headers: {
+        Prefer: 'count=exact',
+      },
+    });
+
+    return {
+      records: response.data,
+      pagination: response.pagination,
+    };
+  }
+
+  /**
+   * Get a single record by foreign key value.
+   * Specifically designed for foreign key lookups.
+   *
+   * @param tableName - Name of the table to search in
+   * @param columnName - Name of the column to filter by
+   * @param value - Value to match
+   * @returns Single record or null if not found
+   */
+  async getRecordByForeignKeyValue(tableName: string, columnName: string, value: string) {
+    const queryParams = `${columnName}=eq.${encodeURIComponent(value)}&limit=1`;
+    const response = await this.getRecords(tableName, queryParams);
+
+    // Return the first record if found, or null if not found
+    if (response.records && response.records.length) {
+      return response.records[0];
+    }
+    return null;
+  }
+
+  async getRecords(tableName: string, queryParams: string = '') {
+    const url = `/database/records/${tableName}${queryParams ? `?${queryParams}` : ''}`;
+    const response = await apiClient.request(url, {
+      headers: apiClient.withAccessToken(),
+    });
+
+    // Traditional REST: check if response is array (direct data) or wrapped
+    if (Array.isArray(response)) {
+      return {
+        records: response,
+        total: response.length,
+      };
+    }
+
+    // If backend returns wrapped format for this endpoint
+    if (response.data && Array.isArray(response.data)) {
+      return {
+        records: response.data,
+        total: response.data.length,
+      };
+    }
+
+    return {
+      records: response,
+      total: response.length,
+    };
+  }
+
+  createRecords(table: string, records: { [key: string]: ConvertedValue }[]) {
+    // if data is json and data[id] == "" then remove id from data, because can't assign '' to uuid
+    records = records.map((record) => {
+      if (typeof record === 'object' && record.id === '') {
+        delete record.id;
+      }
+      return record;
+    });
+    return apiClient.request(`/database/records/${table}`, {
+      method: 'POST',
+      headers: apiClient.withAccessToken({
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(records),
+    });
+  }
+
+  createRecord(table: string, data: { [key: string]: ConvertedValue }) {
+    if (typeof data === 'object' && data.id === '') {
+      // can't assign '' to uuid, so we need to remove it
+      delete data.id;
+    }
+    return this.createRecords(table, [data]);
+  }
+
+  updateRecord(
+    table: string,
+    pkColumn: string,
+    pkValue: string,
+    data: { [key: string]: ConvertedValue }
+  ) {
+    return apiClient.request(`/database/records/${table}?${pkColumn}=eq.${pkValue}`, {
+      method: 'PATCH',
+      headers: apiClient.withAccessToken({
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(data),
+    });
+  }
+
+  // PostgREST supports bulk deletes via in.() filter
+  deleteRecords(table: string, pkColumn: string, pkValues: string[]) {
+    if (!pkValues.length) {
+      return Promise.resolve();
+    }
+    const pkFilter = `in.(${pkValues.join(',')})`;
+    return apiClient.request(`/database/records/${table}?${pkColumn}=${pkFilter}`, {
+      method: 'DELETE',
+      headers: apiClient.withAccessToken(),
+    });
+  }
+
+  validateCSVFile(file: File): { valid: boolean; error?: string } {
+    if (file.type !== 'text/csv' && !file.name.endsWith('.csv')) {
+      return { valid: false, error: 'Invalid file type. Please upload a CSV file.' };
+    }
+    const maxSizeInBytes = 50 * 1024 * 1024;
+    if (file.size > maxSizeInBytes) {
+      return { valid: false, error: `File size exceeds the limit of ${maxSizeInBytes} bytes.` };
+    }
+    return { valid: true };
+  }
+
+  async importCSV(tableName: string, file: File): Promise<CSVImportResponse> {
+    const validation = this.validateCSVFile(file);
+    if (!validation.valid) {
+      throw new Error(validation.error || 'Invalid CSV file.');
+    }
+
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('table', tableName);
+
+    const response = await apiClient.request(`/database/advance/bulk-upsert`, {
+      method: 'POST',
+      headers: apiClient.withAccessToken(),
+      body: formData,
+    });
+    return {
+      success: response.success,
+      message: response.message,
+      data: {
+        rowCount: response.rowsAffected,
+      },
+      error: response.error,
+    };
+  }
+}
+
+export const recordService = new RecordService();

package/frontend/src/features/database/services/table.service.ts

@@ -0,0 +1,58 @@
+import { apiClient } from '@/lib/api/client';
+import {
+  ColumnSchema,
+  GetTableSchemaResponse,
+  CreateTableRequest,
+  UpdateTableSchemaResponse,
+  UpdateTableSchemaRequest,
+} from '@insforge/shared-schemas';
+
+export class TableService {
+  async listTables(): Promise<string[]> {
+    const data = await apiClient.request('/database/tables', {
+      headers: apiClient.withAccessToken(),
+    });
+    // data is already unwrapped by request method and should be an array
+    // Filter out the 'users' table
+    return Array.isArray(data) ? data.filter((table) => table !== 'users') : [];
+  }
+
+  getTableSchema(tableName: string): Promise<GetTableSchemaResponse> {
+    return apiClient.request(`/database/tables/${tableName}/schema`, {
+      headers: apiClient.withAccessToken(),
+    });
+  }
+
+  createTable(tableName: string, columns: ColumnSchema[]) {
+    const body: CreateTableRequest = { tableName: tableName, columns, rlsEnabled: true };
+    return apiClient.request('/database/tables', {
+      method: 'POST',
+      headers: apiClient.withAccessToken({
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(body),
+    });
+  }
+
+  deleteTable(tableName: string) {
+    return apiClient.request(`/database/tables/${tableName}`, {
+      method: 'DELETE',
+      headers: apiClient.withAccessToken(),
+    });
+  }
+
+  updateTableSchema(
+    tableName: string,
+    operations: UpdateTableSchemaRequest
+  ): Promise<UpdateTableSchemaResponse | void> {
+    return apiClient.request(`/database/tables/${tableName}/schema`, {
+      method: 'PATCH',
+      headers: apiClient.withAccessToken({
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(operations),
+    });
+  }
+}
+
+export const tableService = new TableService();

package/frontend/src/features/database/templates/ai-chatbot.ts

@@ -0,0 +1,402 @@
+import { DatabaseTemplate } from './index';
+
+export const aiChatbotTemplate: DatabaseTemplate = {
+  id: 'ai-chatbot',
+  title: 'AI Chatbot',
+  description:
+    'A chatbot app with conversations, message history, image uploads, and user specific data',
+  tableCount: 4,
+  visualizerSchema: [
+    {
+      tableName: 'conversations',
+      columns: [
+        { columnName: 'id', type: 'uuid', isPrimaryKey: true, isNullable: false, isUnique: true },
+        {
+          columnName: 'user_id',
+          type: 'uuid',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+          foreignKey: {
+            referenceTable: 'users',
+            referenceColumn: 'id',
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+          },
+        },
+        {
+          columnName: 'title',
+          type: 'varchar',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'model',
+          type: 'varchar',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'created_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'updated_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+      ],
+    },
+    {
+      tableName: 'messages',
+      columns: [
+        { columnName: 'id', type: 'uuid', isPrimaryKey: true, isNullable: false, isUnique: true },
+        {
+          columnName: 'conversation_id',
+          type: 'uuid',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+          foreignKey: {
+            referenceTable: 'conversations',
+            referenceColumn: 'id',
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+          },
+        },
+        {
+          columnName: 'role',
+          type: 'varchar',
+          isPrimaryKey: false,
+          isNullable: false,
+          isUnique: false,
+        },
+        {
+          columnName: 'content',
+          type: 'text',
+          isPrimaryKey: false,
+          isNullable: false,
+          isUnique: false,
+        },
+        {
+          columnName: 'tokens_used',
+          type: 'integer',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'created_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+      ],
+    },
+    {
+      tableName: 'feedback',
+      columns: [
+        { columnName: 'id', type: 'uuid', isPrimaryKey: true, isNullable: false, isUnique: true },
+        {
+          columnName: 'message_id',
+          type: 'uuid',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+          foreignKey: {
+            referenceTable: 'messages',
+            referenceColumn: 'id',
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+          },
+        },
+        {
+          columnName: 'user_id',
+          type: 'uuid',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+          foreignKey: {
+            referenceTable: 'users',
+            referenceColumn: 'id',
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+          },
+        },
+        {
+          columnName: 'rating',
+          type: 'integer',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'comment',
+          type: 'text',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'created_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+      ],
+    },
+    {
+      tableName: 'prompts',
+      columns: [
+        { columnName: 'id', type: 'uuid', isPrimaryKey: true, isNullable: false, isUnique: true },
+        {
+          columnName: 'user_id',
+          type: 'uuid',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+          foreignKey: {
+            referenceTable: 'users',
+            referenceColumn: 'id',
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+          },
+        },
+        {
+          columnName: 'title',
+          type: 'varchar',
+          isPrimaryKey: false,
+          isNullable: false,
+          isUnique: false,
+        },
+        {
+          columnName: 'content',
+          type: 'text',
+          isPrimaryKey: false,
+          isNullable: false,
+          isUnique: false,
+        },
+        {
+          columnName: 'category',
+          type: 'varchar',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'is_public',
+          type: 'boolean',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'usage_count',
+          type: 'integer',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'created_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+        {
+          columnName: 'updated_at',
+          type: 'timestamp',
+          isPrimaryKey: false,
+          isNullable: true,
+          isUnique: false,
+        },
+      ],
+    },
+  ],
+  sql: `-- AI Chatbot Database Schema
+-- A comprehensive AI chatbot system with conversations, messages, feedback, and prompt library
+
+-- Conversations table
+CREATE TABLE conversations (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE,
+  title VARCHAR(255),
+  model VARCHAR(100) DEFAULT 'gpt-4',
+  created_at TIMESTAMP DEFAULT NOW(),
+  updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Messages table
+CREATE TABLE messages (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  conversation_id UUID REFERENCES conversations(id) ON UPDATE CASCADE ON DELETE CASCADE,
+  role VARCHAR(50) NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+  content TEXT NOT NULL,
+  tokens_used INTEGER,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Feedback table
+CREATE TABLE feedback (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  message_id UUID REFERENCES messages(id) ON UPDATE CASCADE ON DELETE CASCADE,
+  user_id UUID REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE,
+  rating INTEGER CHECK (rating >= 1 AND rating <= 5),
+  comment TEXT,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Prompts library table
+CREATE TABLE prompts (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE,
+  title VARCHAR(255) NOT NULL,
+  content TEXT NOT NULL,
+  category VARCHAR(100),
+  is_public BOOLEAN DEFAULT FALSE,
+  usage_count INTEGER DEFAULT 0,
+  created_at TIMESTAMP DEFAULT NOW(),
+  updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Indexes for better performance
+CREATE INDEX idx_conversations_user ON conversations(user_id);
+CREATE INDEX idx_conversations_updated ON conversations(updated_at DESC);
+CREATE INDEX idx_messages_conversation ON messages(conversation_id);
+CREATE INDEX idx_messages_role ON messages(role);
+CREATE INDEX idx_messages_created ON messages(created_at DESC);
+CREATE INDEX idx_feedback_message ON feedback(message_id);
+CREATE INDEX idx_feedback_user ON feedback(user_id);
+CREATE INDEX idx_feedback_rating ON feedback(rating);
+CREATE INDEX idx_prompts_user ON prompts(user_id);
+CREATE INDEX idx_prompts_category ON prompts(category);
+CREATE INDEX idx_prompts_public ON prompts(is_public) WHERE is_public = TRUE;
+
+-- =======================
+-- ROW LEVEL SECURITY (RLS)
+-- =======================
+
+-- Enable RLS on all tables
+ALTER TABLE conversations ENABLE ROW LEVEL SECURITY;
+ALTER TABLE messages ENABLE ROW LEVEL SECURITY;
+ALTER TABLE feedback ENABLE ROW LEVEL SECURITY;
+ALTER TABLE prompts ENABLE ROW LEVEL SECURITY;
+
+-- Policies for conversations (users can only see their own)
+CREATE POLICY "Users can view their own conversations"
+  ON conversations FOR SELECT
+  TO authenticated
+  USING (user_id = auth.uid());
+
+CREATE POLICY "Users can create their own conversations"
+  ON conversations FOR INSERT
+  TO authenticated
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can update their own conversations"
+  ON conversations FOR UPDATE
+  TO authenticated
+  USING (user_id = auth.uid())
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can delete their own conversations"
+  ON conversations FOR DELETE
+  TO authenticated
+  USING (user_id = auth.uid());
+
+-- Policies for messages (users can only see messages from their conversations)
+CREATE POLICY "Users can view messages from their conversations"
+  ON messages FOR SELECT
+  TO authenticated
+  USING (
+    conversation_id IN (
+      SELECT id FROM conversations WHERE user_id = auth.uid()
+    )
+  );
+
+CREATE POLICY "Users can create messages in their conversations"
+  ON messages FOR INSERT
+  TO authenticated
+  WITH CHECK (
+    conversation_id IN (
+      SELECT id FROM conversations WHERE user_id = auth.uid()
+    )
+  );
+
+CREATE POLICY "Users can update messages in their conversations"
+  ON messages FOR UPDATE
+  TO authenticated
+  USING (
+    conversation_id IN (
+      SELECT id FROM conversations WHERE user_id = auth.uid()
+    )
+  )
+  WITH CHECK (
+    conversation_id IN (
+      SELECT id FROM conversations WHERE user_id = auth.uid()
+    )
+  );
+
+CREATE POLICY "Users can delete messages from their conversations"
+  ON messages FOR DELETE
+  TO authenticated
+  USING (
+    conversation_id IN (
+      SELECT id FROM conversations WHERE user_id = auth.uid()
+    )
+  );
+
+-- Policies for feedback
+CREATE POLICY "Users can view their own feedback"
+  ON feedback FOR SELECT
+  TO authenticated
+  USING (user_id = auth.uid());
+
+CREATE POLICY "Users can create their own feedback"
+  ON feedback FOR INSERT
+  TO authenticated
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can update their own feedback"
+  ON feedback FOR UPDATE
+  TO authenticated
+  USING (user_id = auth.uid())
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can delete their own feedback"
+  ON feedback FOR DELETE
+  TO authenticated
+  USING (user_id = auth.uid());
+
+-- Policies for prompts (users can see their own and public prompts)
+CREATE POLICY "Users can view their own and public prompts"
+  ON prompts FOR SELECT
+  TO authenticated
+  USING (user_id = auth.uid() OR is_public = TRUE);
+
+CREATE POLICY "Users can create their own prompts"
+  ON prompts FOR INSERT
+  TO authenticated
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can update their own prompts"
+  ON prompts FOR UPDATE
+  TO authenticated
+  USING (user_id = auth.uid())
+  WITH CHECK (user_id = auth.uid());
+
+CREATE POLICY "Users can delete their own prompts"
+  ON prompts FOR DELETE
+  TO authenticated
+  USING (user_id = auth.uid());`,
+};