@agent-foundry/studio 1.0.0

package/src/db/deployments.ts

@@ -0,0 +1,316 @@
+/**
+ * Deployments Repository
+ *
+ * CRUD operations for studio_deployments table.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type {
+  Deployment,
+  CreateDeploymentInput,
+  UpdateDeploymentInput,
+  DeploymentListFilters,
+  DeploymentStatus,
+  DeploymentMetadata,
+} from '../types/deployment';
+
+/**
+ * Database row type (snake_case)
+ */
+interface DeploymentRow {
+  id: string;
+  project_id: string;
+  user_id: string;
+  version: string;
+  status: DeploymentStatus;
+  oss_bucket: string | null;
+  oss_key: string | null;
+  oss_url: string | null;
+  bundle_size_bytes: number | null;
+  build_log: string | null;
+  error_message: string | null;
+  metadata: DeploymentMetadata;
+  created_at: string;
+  published_at: string | null;
+}
+
+/**
+ * Convert database row to Deployment
+ */
+function rowToDeployment(row: DeploymentRow): Deployment {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    userId: row.user_id,
+    version: row.version,
+    status: row.status,
+    ossBucket: row.oss_bucket ?? undefined,
+    ossKey: row.oss_key ?? undefined,
+    ossUrl: row.oss_url ?? undefined,
+    bundleSizeBytes: row.bundle_size_bytes ?? undefined,
+    buildLog: row.build_log ?? undefined,
+    errorMessage: row.error_message ?? undefined,
+    metadata: row.metadata,
+    createdAt: row.created_at,
+    publishedAt: row.published_at ?? undefined,
+  };
+}
+
+/**
+ * Generate a version string based on timestamp
+ */
+function generateVersion(): string {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  return `${year}.${month}.${day}-${hours}${minutes}`;
+}
+
+/**
+ * Deployments Repository - manages studio_deployments table
+ */
+export class DeploymentsRepository {
+  private readonly TABLE = 'studio_deployments';
+
+  constructor(private readonly supabase: SupabaseClient) {}
+
+  /**
+   * Create a new deployment
+   */
+  async create(input: CreateDeploymentInput): Promise<Deployment> {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) {
+      throw new Error('Not authenticated');
+    }
+
+    const version = input.version ?? generateVersion();
+
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .insert({
+        project_id: input.projectId,
+        user_id: user.id,
+        version,
+        status: 'pending',
+        metadata: input.metadata ?? {},
+      })
+      .select()
+      .single();
+
+    if (error) {
+      throw new Error(`Failed to create deployment: ${error.message}`);
+    }
+
+    return rowToDeployment(data as DeploymentRow);
+  }
+
+  /**
+   * Get a deployment by ID
+   */
+  async getById(id: string): Promise<Deployment | null> {
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .select()
+      .eq('id', id)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null; // Not found
+      }
+      throw new Error(`Failed to get deployment: ${error.message}`);
+    }
+
+    return rowToDeployment(data as DeploymentRow);
+  }
+
+  /**
+   * List deployments with optional filters
+   */
+  async list(filters: DeploymentListFilters = {}): Promise<Deployment[]> {
+    let query = this.supabase.from(this.TABLE).select();
+
+    // Apply filters
+    if (filters.projectId) {
+      query = query.eq('project_id', filters.projectId);
+    }
+
+    if (filters.status) {
+      query = query.eq('status', filters.status);
+    }
+
+    // Ordering
+    const orderBy = filters.orderBy ?? 'createdAt';
+    const orderColumn = orderBy === 'createdAt' ? 'created_at' :
+                        orderBy === 'publishedAt' ? 'published_at' : 'version';
+    const ascending = filters.orderDir === 'asc';
+    query = query.order(orderColumn, { ascending, nullsFirst: false });
+
+    // Pagination
+    if (filters.limit) {
+      query = query.limit(filters.limit);
+    }
+    if (filters.offset) {
+      query = query.range(filters.offset, filters.offset + (filters.limit ?? 50) - 1);
+    }
+
+    const { data, error } = await query;
+
+    if (error) {
+      throw new Error(`Failed to list deployments: ${error.message}`);
+    }
+
+    return (data as DeploymentRow[]).map(rowToDeployment);
+  }
+
+  /**
+   * Update a deployment
+   */
+  async update(id: string, input: UpdateDeploymentInput): Promise<Deployment> {
+    const updateData: Record<string, unknown> = {};
+
+    if (input.status !== undefined) {
+      updateData.status = input.status;
+    }
+    if (input.ossBucket !== undefined) {
+      updateData.oss_bucket = input.ossBucket;
+    }
+    if (input.ossKey !== undefined) {
+      updateData.oss_key = input.ossKey;
+    }
+    if (input.ossUrl !== undefined) {
+      updateData.oss_url = input.ossUrl;
+    }
+    if (input.bundleSizeBytes !== undefined) {
+      updateData.bundle_size_bytes = input.bundleSizeBytes;
+    }
+    if (input.buildLog !== undefined) {
+      updateData.build_log = input.buildLog;
+    }
+    if (input.errorMessage !== undefined) {
+      updateData.error_message = input.errorMessage;
+    }
+    if (input.metadata !== undefined) {
+      // Merge with existing metadata
+      const existing = await this.getById(id);
+      if (!existing) {
+        throw new Error('Deployment not found');
+      }
+      updateData.metadata = { ...existing.metadata, ...input.metadata };
+    }
+    if (input.publishedAt !== undefined) {
+      updateData.published_at = input.publishedAt;
+    }
+
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .update(updateData)
+      .eq('id', id)
+      .select()
+      .single();
+
+    if (error) {
+      throw new Error(`Failed to update deployment: ${error.message}`);
+    }
+
+    return rowToDeployment(data as DeploymentRow);
+  }
+
+  /**
+   * Mark deployment as building
+   */
+  async markBuilding(id: string): Promise<Deployment> {
+    return this.update(id, { status: 'building' });
+  }
+
+  /**
+   * Mark deployment as uploading
+   */
+  async markUploading(id: string): Promise<Deployment> {
+    return this.update(id, { status: 'uploading' });
+  }
+
+  /**
+   * Mark deployment as published
+   */
+  async markPublished(
+    id: string,
+    ossInfo: { bucket: string; key: string; url: string; sizeBytes: number }
+  ): Promise<Deployment> {
+    return this.update(id, {
+      status: 'published',
+      ossBucket: ossInfo.bucket,
+      ossKey: ossInfo.key,
+      ossUrl: ossInfo.url,
+      bundleSizeBytes: ossInfo.sizeBytes,
+      publishedAt: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * Mark deployment as failed
+   */
+  async markFailed(id: string, errorMessage: string, buildLog?: string): Promise<Deployment> {
+    return this.update(id, {
+      status: 'failed',
+      errorMessage,
+      buildLog,
+    });
+  }
+
+  /**
+   * Get the latest successful deployment for a project
+   */
+  async getLatestPublished(projectId: string): Promise<Deployment | null> {
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .select()
+      .eq('project_id', projectId)
+      .eq('status', 'published')
+      .order('published_at', { ascending: false })
+      .limit(1)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null; // Not found
+      }
+      throw new Error(`Failed to get latest deployment: ${error.message}`);
+    }
+
+    return rowToDeployment(data as DeploymentRow);
+  }
+
+  /**
+   * Delete a deployment
+   */
+  async delete(id: string): Promise<void> {
+    const { error } = await this.supabase
+      .from(this.TABLE)
+      .delete()
+      .eq('id', id);
+
+    if (error) {
+      throw new Error(`Failed to delete deployment: ${error.message}`);
+    }
+  }
+
+  /**
+   * Append to build log
+   */
+  async appendBuildLog(id: string, logLine: string): Promise<void> {
+    const existing = await this.getById(id);
+    if (!existing) {
+      throw new Error('Deployment not found');
+    }
+
+    const newLog = existing.buildLog 
+      ? `${existing.buildLog}\n${logLine}`
+      : logLine;
+
+    await this.update(id, { buildLog: newLog });
+  }
+}

package/src/db/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Database module - Supabase client for Studio
+ */
+
+export { createStudioClient, type StudioClientConfig } from './client';
+export { ProjectsRepository } from './projects';
+export { DeploymentsRepository } from './deployments';

package/src/db/projects.ts

@@ -0,0 +1,246 @@
+/**
+ * Projects Repository
+ *
+ * CRUD operations for studio_projects table.
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import type {
+  StudioProject,
+  CreateProjectInput,
+  UpdateProjectInput,
+  ProjectListFilters,
+  ProjectConfig,
+} from '../types/project';
+
+/**
+ * Database row type (snake_case)
+ */
+interface ProjectRow {
+  id: string;
+  user_id: string;
+  name: string;
+  slug: string;
+  description: string | null;
+  root_path: string;
+  framework: string;
+  config: ProjectConfig;
+  parent_project_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * Convert database row to StudioProject
+ */
+function rowToProject(row: ProjectRow): StudioProject {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description ?? undefined,
+    rootPath: row.root_path,
+    framework: row.framework as StudioProject['framework'],
+    config: row.config,
+    parentProjectId: row.parent_project_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+/**
+ * Projects Repository - manages studio_projects table
+ */
+export class ProjectsRepository {
+  private readonly TABLE = 'studio_projects';
+
+  constructor(private readonly supabase: SupabaseClient) {}
+
+  /**
+   * Create a new project
+   */
+  async create(input: CreateProjectInput): Promise<StudioProject> {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) {
+      throw new Error('Not authenticated');
+    }
+
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .insert({
+        user_id: user.id,
+        name: input.name,
+        slug: input.slug,
+        description: input.description,
+        root_path: input.rootPath,
+        framework: input.framework ?? 'vite-react',
+        config: input.config ?? {},
+        parent_project_id: input.parentProjectId,
+      })
+      .select()
+      .single();
+
+    if (error) {
+      throw new Error(`Failed to create project: ${error.message}`);
+    }
+
+    return rowToProject(data as ProjectRow);
+  }
+
+  /**
+   * Get a project by ID
+   */
+  async getById(id: string): Promise<StudioProject | null> {
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .select()
+      .eq('id', id)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null; // Not found
+      }
+      throw new Error(`Failed to get project: ${error.message}`);
+    }
+
+    return rowToProject(data as ProjectRow);
+  }
+
+  /**
+   * Get a project by slug (for current user)
+   */
+  async getBySlug(slug: string): Promise<StudioProject | null> {
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .select()
+      .eq('slug', slug)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null; // Not found
+      }
+      throw new Error(`Failed to get project: ${error.message}`);
+    }
+
+    return rowToProject(data as ProjectRow);
+  }
+
+  /**
+   * List projects with optional filters
+   */
+  async list(filters: ProjectListFilters = {}): Promise<StudioProject[]> {
+    let query = this.supabase.from(this.TABLE).select();
+
+    // Apply filters
+    if (filters.framework) {
+      query = query.eq('framework', filters.framework);
+    }
+
+    if (filters.search) {
+      query = query.ilike('name', `%${filters.search}%`);
+    }
+
+    // Ordering
+    const orderBy = filters.orderBy ?? 'createdAt';
+    const orderColumn = orderBy === 'createdAt' ? 'created_at' :
+                        orderBy === 'updatedAt' ? 'updated_at' : 'name';
+    const ascending = filters.orderDir === 'asc';
+    query = query.order(orderColumn, { ascending });
+
+    // Pagination
+    if (filters.limit) {
+      query = query.limit(filters.limit);
+    }
+    if (filters.offset) {
+      query = query.range(filters.offset, filters.offset + (filters.limit ?? 50) - 1);
+    }
+
+    const { data, error } = await query;
+
+    if (error) {
+      throw new Error(`Failed to list projects: ${error.message}`);
+    }
+
+    return (data as ProjectRow[]).map(rowToProject);
+  }
+
+  /**
+   * Update a project
+   */
+  async update(id: string, input: UpdateProjectInput): Promise<StudioProject> {
+    const updateData: Record<string, unknown> = {};
+
+    if (input.name !== undefined) {
+      updateData.name = input.name;
+    }
+    if (input.description !== undefined) {
+      updateData.description = input.description;
+    }
+    if (input.config !== undefined) {
+      // Merge with existing config
+      const existing = await this.getById(id);
+      if (!existing) {
+        throw new Error('Project not found');
+      }
+      updateData.config = { ...existing.config, ...input.config };
+    }
+
+    const { data, error } = await this.supabase
+      .from(this.TABLE)
+      .update(updateData)
+      .eq('id', id)
+      .select()
+      .single();
+
+    if (error) {
+      throw new Error(`Failed to update project: ${error.message}`);
+    }
+
+    return rowToProject(data as ProjectRow);
+  }
+
+  /**
+   * Delete a project
+   */
+  async delete(id: string): Promise<void> {
+    const { error } = await this.supabase
+      .from(this.TABLE)
+      .delete()
+      .eq('id', id);
+
+    if (error) {
+      throw new Error(`Failed to delete project: ${error.message}`);
+    }
+  }
+
+  /**
+   * Fork a project (create a copy)
+   */
+  async fork(id: string, newSlug: string, newRootPath: string): Promise<StudioProject> {
+    const original = await this.getById(id);
+    if (!original) {
+      throw new Error('Original project not found');
+    }
+
+    return this.create({
+      name: `${original.name} (Fork)`,
+      slug: newSlug,
+      description: original.description,
+      rootPath: newRootPath,
+      framework: original.framework,
+      config: original.config,
+      parentProjectId: original.id,
+    });
+  }
+
+  /**
+   * Check if a slug is available for current user
+   */
+  async isSlugAvailable(slug: string): Promise<boolean> {
+    const existing = await this.getBySlug(slug);
+    return existing === null;
+  }
+}