@things-factory/integration-label-studio 9.1.19

package/server/service/prediction/prediction-management.ts

@@ -0,0 +1,281 @@
+import { Resolver, Query, Mutation, Arg, Ctx, Int, Directive } from 'type-graphql'
+import { labelStudioApi } from '../../utils/label-studio-api-client.js'
+import {
+  LabelStudioPrediction,
+  PredictionInput,
+  PredictionImportResult,
+  BulkPredictionInput
+} from '../../types/label-studio-types.js'
+
+@Resolver()
+export class PredictionManagement {
+  /**
+   * Get predictions for a task
+   */
+  @Query(returns => [LabelStudioPrediction], {
+    description: 'Get all predictions for a Label Studio task'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioTaskPredictions(
+    @Arg('taskId', type => Int) taskId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioPrediction[]> {
+    try {
+      const predictions = await labelStudioApi.getPredictions(taskId)
+
+      return predictions.map((prediction: any) => ({
+        id: prediction.id,
+        taskId: prediction.task || taskId,
+        result: JSON.stringify(prediction.result),
+        score: prediction.score || undefined,
+        modelVersion: prediction.model_version || undefined,
+        createdAt: prediction.created_at ? new Date(prediction.created_at) : undefined
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch predictions for task ${taskId}:`, error)
+      throw new Error(`Failed to fetch predictions: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get predictions for a project
+   */
+  @Query(returns => [LabelStudioPrediction], {
+    description: 'Get all predictions for a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioProjectPredictions(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioPrediction[]> {
+    try {
+      const predictions = await labelStudioApi.getProjectPredictions(projectId)
+
+      return predictions.map((prediction: any) => ({
+        id: prediction.id,
+        taskId: prediction.task,
+        result: JSON.stringify(prediction.result),
+        score: prediction.score || undefined,
+        modelVersion: prediction.model_version || undefined,
+        createdAt: prediction.created_at ? new Date(prediction.created_at) : undefined
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch predictions for project ${projectId}:`, error)
+      throw new Error(`Failed to fetch predictions: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get single prediction by ID
+   */
+  @Query(returns => LabelStudioPrediction, {
+    description: 'Get a single prediction by ID',
+    nullable: true
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioPrediction(
+    @Arg('predictionId', type => Int) predictionId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioPrediction | null> {
+    try {
+      const prediction = await labelStudioApi.getPrediction(predictionId)
+
+      if (!prediction) {
+        return null
+      }
+
+      return {
+        id: prediction.id,
+        taskId: prediction.task,
+        result: JSON.stringify(prediction.result),
+        score: prediction.score || undefined,
+        modelVersion: prediction.model_version || undefined,
+        createdAt: prediction.created_at ? new Date(prediction.created_at) : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to fetch prediction ${predictionId}:`, error)
+      return null
+    }
+  }
+
+  /**
+   * Create a prediction for a task
+   */
+  @Mutation(returns => LabelStudioPrediction, {
+    description: 'Create a prediction for a Label Studio task'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async createLabelStudioPrediction(
+    @Arg('input') input: PredictionInput,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioPrediction> {
+    try {
+      // Parse result JSON
+      const result = JSON.parse(input.result)
+
+      // Create prediction
+      const prediction = await labelStudioApi.createPrediction({
+        task: input.taskId,
+        result,
+        score: input.score,
+        model_version: input.modelVersion
+      })
+
+      return {
+        id: prediction.id,
+        taskId: prediction.task,
+        result: JSON.stringify(prediction.result),
+        score: prediction.score || undefined,
+        modelVersion: prediction.model_version || undefined,
+        createdAt: prediction.created_at ? new Date(prediction.created_at) : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to create prediction for task ${input.taskId}:`, error)
+      throw new Error(`Failed to create prediction: ${error.message}`)
+    }
+  }
+
+  /**
+   * Create predictions in bulk
+   */
+  @Mutation(returns => PredictionImportResult, {
+    description: 'Create multiple predictions at once'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async createBulkPredictions(
+    @Arg('predictions', type => [BulkPredictionInput]) predictions: BulkPredictionInput[],
+    @Ctx() context: ResolverContext
+  ): Promise<PredictionImportResult> {
+    const errors: string[] = []
+    let created = 0
+    let failed = 0
+
+    try {
+      // Parse and validate predictions
+      const parsedPredictions = predictions.map((pred, index) => {
+        try {
+          return {
+            task: pred.taskId,
+            result: JSON.parse(pred.result),
+            score: pred.score,
+            model_version: pred.modelVersion
+          }
+        } catch (e) {
+          failed++
+          errors.push(`Invalid JSON in prediction ${index}: ${pred.result}`)
+          return null
+        }
+      })
+
+      const validPredictions = parsedPredictions.filter(p => p !== null)
+
+      if (validPredictions.length === 0) {
+        return {
+          created: 0,
+          failed: predictions.length,
+          errors
+        }
+      }
+
+      // Create predictions
+      const response = await labelStudioApi.createPredictions(validPredictions)
+      created = response.created || validPredictions.length
+
+      return {
+        created,
+        failed,
+        errors: errors.length > 0 ? errors : undefined
+      }
+    } catch (error) {
+      console.error('Failed to create bulk predictions:', error)
+      throw new Error(`Failed to create predictions: ${error.message}`)
+    }
+  }
+
+  /**
+   * Import predictions for a project
+   * This is the recommended way to bulk import AI model predictions
+   */
+  @Mutation(returns => PredictionImportResult, {
+    description: 'Import predictions for a Label Studio project in bulk'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async importPredictionsToProject(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('predictions', type => [BulkPredictionInput]) predictions: BulkPredictionInput[],
+    @Ctx() context: ResolverContext
+  ): Promise<PredictionImportResult> {
+    const errors: string[] = []
+    let created = 0
+    let failed = 0
+
+    try {
+      // Parse and validate predictions
+      const parsedPredictions = predictions.map((pred, index) => {
+        try {
+          return {
+            task: pred.taskId,
+            result: JSON.parse(pred.result),
+            score: pred.score,
+            model_version: pred.modelVersion
+          }
+        } catch (e) {
+          failed++
+          errors.push(`Invalid JSON in prediction ${index}: ${pred.result}`)
+          return null
+        }
+      })
+
+      const validPredictions = parsedPredictions.filter(p => p !== null)
+
+      if (validPredictions.length === 0) {
+        return {
+          created: 0,
+          failed: predictions.length,
+          errors
+        }
+      }
+
+      // Import predictions using project endpoint
+      const response = await labelStudioApi.importPredictions(projectId, validPredictions)
+
+      // Parse response
+      if (response.created !== undefined) {
+        created = response.created
+      } else if (response.task_count !== undefined) {
+        created = response.task_count
+      } else if (Array.isArray(response)) {
+        created = response.length
+      }
+
+      return {
+        created,
+        failed,
+        errors: errors.length > 0 ? errors : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to import predictions to project ${projectId}:`, error)
+      throw new Error(`Failed to import predictions: ${error.message}`)
+    }
+  }
+
+  /**
+   * Delete prediction
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Delete a prediction from Label Studio'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async deleteLabelStudioPrediction(
+    @Arg('predictionId', type => Int) predictionId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.deletePrediction(predictionId)
+      return true
+    } catch (error) {
+      console.error(`Failed to delete prediction ${predictionId}:`, error)
+      throw new Error(`Failed to delete prediction: ${error.message}`)
+    }
+  }
+}

package/server/service/project/project-management.ts

@@ -0,0 +1,284 @@
+import { Resolver, Query, Mutation, Arg, Ctx, Int, Directive } from 'type-graphql'
+import { labelStudioApi } from '../../utils/label-studio-api-client.js'
+import { LabelConfigBuilder } from '../../utils/label-config-builder.js'
+import {
+  LabelStudioProject,
+  CreateProjectInput,
+  CreateProjectWithSpecInput,
+  ProjectMetrics,
+  AnnotatorStats
+} from '../../types/label-studio-types.js'
+
+@Resolver()
+export class ProjectManagement {
+  /**
+   * Get JWT token for Label Studio SSO
+   */
+  @Query(returns => String, {
+    description: 'Get JWT token for Label Studio authentication',
+    nullable: true
+  })
+  async labelStudioToken(@Ctx() context: ResolverContext): Promise<string | null> {
+    try {
+      const { user } = context.state
+      if (!user) {
+        return null
+      }
+
+      // Generate JWT token using User.sign() method
+      const token = await user.sign()
+      return token
+    } catch (error) {
+      console.error('Failed to generate Label Studio token:', error)
+      return null
+    }
+  }
+
+  /**
+   * Get all Label Studio projects
+   */
+  @Query(returns => [LabelStudioProject], {
+    description: 'Get all Label Studio projects accessible to the user'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioProjects(@Ctx() context: ResolverContext): Promise<LabelStudioProject[]> {
+    try {
+      const projects = await labelStudioApi.getProjects()
+
+      return projects.map(project => ({
+        id: project.id,
+        title: project.title,
+        description: project.description || '',
+        labelConfig: project.label_config || '',
+        expertInstruction: project.expert_instruction || '',
+        taskCount: project.task_number || 0,
+        completedTaskCount: project.finished_task_number || 0,
+        completionRate:
+          project.task_number > 0 ? (project.finished_task_number || 0) / project.task_number : 0,
+        createdAt: new Date(project.created_at),
+        updatedAt: project.updated_at ? new Date(project.updated_at) : new Date(project.created_at)
+      }))
+    } catch (error) {
+      console.error('Failed to fetch Label Studio projects:', error)
+      throw new Error(`Failed to fetch projects: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get single Label Studio project by ID
+   */
+  @Query(returns => LabelStudioProject, {
+    description: 'Get a single Label Studio project by ID',
+    nullable: true
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioProject(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioProject | null> {
+    try {
+      const project = await labelStudioApi.getProject(projectId)
+
+      if (!project) {
+        return null
+      }
+
+      return {
+        id: project.id,
+        title: project.title,
+        description: project.description || '',
+        labelConfig: project.label_config || '',
+        expertInstruction: project.expert_instruction || '',
+        taskCount: project.task_number || 0,
+        completedTaskCount: project.finished_task_number || 0,
+        completionRate:
+          project.task_number > 0 ? (project.finished_task_number || 0) / project.task_number : 0,
+        createdAt: new Date(project.created_at),
+        updatedAt: project.updated_at ? new Date(project.updated_at) : new Date(project.created_at)
+      }
+    } catch (error) {
+      console.error(`Failed to fetch Label Studio project ${projectId}:`, error)
+      return null
+    }
+  }
+
+  /**
+   * Create new Label Studio project
+   */
+  @Mutation(returns => LabelStudioProject, {
+    description: 'Create a new Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async createLabelStudioProject(
+    @Arg('input') input: CreateProjectInput,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioProject> {
+    try {
+      const project = await labelStudioApi.createProject({
+        title: input.title,
+        description: input.description,
+        label_config: input.labelConfig,
+        expert_instruction: input.expertInstruction
+      })
+
+      return {
+        id: project.id,
+        title: project.title,
+        description: project.description || '',
+        labelConfig: project.label_config || '',
+        expertInstruction: project.expert_instruction || '',
+        taskCount: 0,
+        completedTaskCount: 0,
+        completionRate: 0,
+        createdAt: new Date(project.created_at),
+        updatedAt: new Date(project.updated_at)
+      }
+    } catch (error) {
+      console.error('Failed to create Label Studio project:', error)
+      throw new Error(`Failed to create project: ${error.message}`)
+    }
+  }
+
+  /**
+   * Update Label Studio project
+   */
+  @Mutation(returns => LabelStudioProject, {
+    description: 'Update an existing Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async updateLabelStudioProject(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('input') input: CreateProjectInput,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioProject> {
+    try {
+      const project = await labelStudioApi.updateProject(projectId, {
+        title: input.title,
+        description: input.description,
+        label_config: input.labelConfig,
+        expert_instruction: input.expertInstruction
+      })
+
+      return {
+        id: project.id,
+        title: project.title,
+        description: project.description || '',
+        labelConfig: project.label_config || '',
+        expertInstruction: project.expert_instruction || '',
+        taskCount: project.task_number || 0,
+        completedTaskCount: project.finished_task_number || 0,
+        completionRate:
+          project.task_number > 0 ? (project.finished_task_number || 0) / project.task_number : 0,
+        createdAt: new Date(project.created_at),
+        updatedAt: project.updated_at ? new Date(project.updated_at) : new Date(project.created_at)
+      }
+    } catch (error) {
+      console.error(`Failed to update Label Studio project ${projectId}:`, error)
+      throw new Error(`Failed to update project: ${error.message}`)
+    }
+  }
+
+  /**
+   * Delete Label Studio project
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Delete a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async deleteLabelStudioProject(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.deleteProject(projectId)
+      return true
+    } catch (error) {
+      console.error(`Failed to delete Label Studio project ${projectId}:`, error)
+      throw new Error(`Failed to delete project: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get project metrics and statistics
+   */
+  @Query(returns => ProjectMetrics, {
+    description: 'Get metrics and statistics for a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioProjectMetrics(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<ProjectMetrics> {
+    try {
+      const stats = await labelStudioApi.getProjectStats(projectId)
+      const annotatorStats = await labelStudioApi.getAnnotatorStats(projectId)
+
+      return {
+        totalTasks: stats.totalTasks,
+        completedTasks: stats.completedTasks,
+        totalAnnotations: stats.totalAnnotations,
+        avgAnnotationsPerTask: stats.avgAnnotationsPerTask,
+        completionRate: stats.completionRate,
+        avgTimePerTask: null, // 계산 필요
+        annotatorStats: annotatorStats.map((stat: any) => ({
+          email: stat.email,
+          annotationCount: stat.annotationCount,
+          avgTime: stat.avgTime,
+          lastAnnotationDate: new Date(stat.lastAnnotationDate)
+        }))
+      }
+    } catch (error) {
+      console.error(`Failed to fetch project metrics for ${projectId}:`, error)
+      throw new Error(`Failed to fetch project metrics: ${error.message}`)
+    }
+  }
+
+  /**
+   * Create project with flexible config specification
+   * Uses LabelConfigBuilder for declarative template generation
+   */
+  @Mutation(returns => LabelStudioProject, {
+    description: 'Create Label Studio project with flexible config specification'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async createLabelStudioProjectWithSpec(
+    @Arg('input') input: CreateProjectWithSpecInput,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioProject> {
+    try {
+      // Parse controls JSON
+      const controls = JSON.parse(input.labelConfigSpec.controls)
+
+      // Build label config using LabelConfigBuilder
+      const labelConfig = LabelConfigBuilder.build({
+        dataType: input.labelConfigSpec.dataType as any,
+        dataName: input.labelConfigSpec.dataName,
+        controls
+      })
+
+      // Create project
+      const project = await labelStudioApi.createProject({
+        title: input.title,
+        description: input.description,
+        label_config: labelConfig,
+        expert_instruction: input.expertInstruction
+      })
+
+      return {
+        id: project.id,
+        title: project.title,
+        description: project.description || '',
+        labelConfig: project.label_config || '',
+        expertInstruction: project.expert_instruction || '',
+        taskCount: 0,
+        completedTaskCount: 0,
+        completionRate: 0,
+        createdAt: new Date(project.created_at),
+        updatedAt: new Date(project.updated_at)
+      }
+    } catch (error) {
+      console.error('Failed to create Label Studio project with spec:', error)
+      throw new Error(`Failed to create project: ${error.message}`)
+    }
+  }
+}