@things-factory/integration-label-studio 9.1.19

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

@@ -0,0 +1,363 @@
+import { Resolver, Query, Mutation, Arg, Ctx, Int, Directive } from 'type-graphql'
+import { labelStudioApi } from '../../utils/label-studio-api-client.js'
+import { TaskTransformer } from '../../utils/task-transformer.js'
+import { exportAnnotations } from '../../utils/annotation-exporter.js'
+import {
+  LabelStudioTask,
+  TaskDataInput,
+  TaskImportResult,
+  LabelStudioAnnotation,
+  ExportResult,
+  ImportTasksWithTransformInput,
+  ExportAnnotationsInput,
+  AnnotationExportResult
+} from '../../types/label-studio-types.js'
+
+@Resolver()
+export class TaskManagement {
+  /**
+   * Get tasks for a project
+   */
+  @Query(returns => [LabelStudioTask], {
+    description: 'Get all tasks for a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioTasks(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('page', type => Int, { nullable: true, defaultValue: 1 }) page: number,
+    @Arg('pageSize', type => Int, { nullable: true, defaultValue: 100 }) pageSize: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioTask[]> {
+    try {
+      const response = await labelStudioApi.getTasks(projectId, {
+        page,
+        page_size: pageSize
+      })
+
+      const tasks = response.tasks || response.results || response
+
+      return tasks.map((task: any) => ({
+        id: task.id,
+        data: JSON.stringify(task.data),
+        annotationCount: task.annotations?.length || task.total_annotations || 0,
+        isCompleted: task.is_labeled || false,
+        createdAt: task.created_at ? new Date(task.created_at) : undefined
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch tasks for project ${projectId}:`, error)
+      throw new Error(`Failed to fetch tasks: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get single task by ID
+   */
+  @Query(returns => LabelStudioTask, {
+    description: 'Get a single task by ID',
+    nullable: true
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioTask(
+    @Arg('taskId', type => Int) taskId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioTask | null> {
+    try {
+      const task = await labelStudioApi.getTask(taskId)
+
+      if (!task) {
+        return null
+      }
+
+      return {
+        id: task.id,
+        data: JSON.stringify(task.data),
+        annotationCount: task.annotations?.length || task.total_annotations || 0,
+        isCompleted: task.is_labeled || false,
+        createdAt: task.created_at ? new Date(task.created_at) : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to fetch task ${taskId}:`, error)
+      return null
+    }
+  }
+
+  /**
+   * Import tasks to Label Studio project
+   */
+  @Mutation(returns => TaskImportResult, {
+    description: 'Import tasks to a Label Studio project in bulk'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async importTasksToLabelStudio(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('tasks', type => [TaskDataInput]) tasks: TaskDataInput[],
+    @Ctx() context: ResolverContext
+  ): Promise<TaskImportResult> {
+    const errors: string[] = []
+    const taskIds: number[] = []
+    let imported = 0
+    let failed = 0
+
+    try {
+      // Parse task data
+      const parsedTasks = tasks.map(task => {
+        try {
+          return JSON.parse(task.data)
+        } catch (e) {
+          failed++
+          errors.push(`Invalid JSON in task data: ${task.data}`)
+          return null
+        }
+      })
+
+      const validTasks = parsedTasks.filter(task => task !== null)
+
+      if (validTasks.length === 0) {
+        return {
+          imported: 0,
+          failed: tasks.length,
+          taskIds: [],
+          errors
+        }
+      }
+
+      // Import tasks using Label Studio API
+      const response = await labelStudioApi.importTasks(projectId, validTasks)
+
+      // Parse response
+      if (response.task_count !== undefined) {
+        imported = response.task_count
+      } else if (response.annotation_count !== undefined) {
+        imported = response.annotation_count
+      } else if (Array.isArray(response)) {
+        imported = response.length
+        taskIds.push(...response.map((t: any) => t.id))
+      }
+
+      return {
+        imported,
+        failed,
+        taskIds,
+        errors: errors.length > 0 ? errors : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to import tasks to project ${projectId}:`, error)
+      throw new Error(`Failed to import tasks: ${error.message}`)
+    }
+  }
+
+  /**
+   * Delete task
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Delete a task from Label Studio'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async deleteLabelStudioTask(
+    @Arg('taskId', type => Int) taskId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.deleteTask(taskId)
+      return true
+    } catch (error) {
+      console.error(`Failed to delete task ${taskId}:`, error)
+      throw new Error(`Failed to delete task: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get annotations for a task
+   */
+  @Query(returns => [LabelStudioAnnotation], {
+    description: 'Get all annotations for a task'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioTaskAnnotations(
+    @Arg('taskId', type => Int) taskId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelStudioAnnotation[]> {
+    try {
+      const annotations = await labelStudioApi.getAnnotations(taskId)
+
+      return annotations.map((annotation: any) => ({
+        id: annotation.id,
+        taskId: annotation.task || taskId,
+        result: JSON.stringify(annotation.result),
+        completedBy: annotation.completed_by?.email || 'unknown',
+        createdAt: new Date(annotation.created_at),
+        leadTime: annotation.lead_time || undefined
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch annotations for task ${taskId}:`, error)
+      throw new Error(`Failed to fetch annotations: ${error.message}`)
+    }
+  }
+
+  /**
+   * Export annotations from project
+   */
+  @Mutation(returns => ExportResult, {
+    description: 'Export annotations from a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async exportLabelStudioAnnotations(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('format', { defaultValue: 'JSON' })
+    format: 'JSON' | 'JSON_MIN' | 'CSV' | 'TSV' | 'CONLL2003' | 'COCO' | 'VOC' | 'YOLO',
+    @Ctx() context: ResolverContext
+  ): Promise<ExportResult> {
+    try {
+      const exportData = await labelStudioApi.exportAnnotations(projectId, format)
+
+      // For JSON exports, we get the data directly
+      // For file exports, we might get a download URL
+      const annotationCount = Array.isArray(exportData) ? exportData.length : 0
+
+      return {
+        exportPath: JSON.stringify(exportData), // In practice, this would be a file path or URL
+        annotationCount,
+        format
+      }
+    } catch (error) {
+      console.error(`Failed to export annotations from project ${projectId}:`, error)
+      throw new Error(`Failed to export annotations: ${error.message}`)
+    }
+  }
+
+  /**
+   * Sync completed annotations to Things-Factory database
+   * This allows storing annotations in TF for further processing
+   */
+  @Mutation(returns => Int, {
+    description: 'Sync completed annotations from Label Studio to Things-Factory database'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async syncAnnotationsToDatabase(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<number> {
+    try {
+      const { domain } = context.state
+
+      // Export annotations
+      const annotations = await labelStudioApi.exportAnnotations(projectId, 'JSON')
+
+      // TODO: Store annotations in Things-Factory database
+      // This would typically involve:
+      // 1. Creating an Annotation entity
+      // 2. Saving each annotation with project reference
+      // 3. Linking to Things-Factory business objects if needed
+
+      // For now, just return count
+      const count = Array.isArray(annotations) ? annotations.length : 0
+
+      console.log(`Synced ${count} annotations from project ${projectId} to database`)
+
+      return count
+    } catch (error) {
+      console.error(`Failed to sync annotations from project ${projectId}:`, error)
+      throw new Error(`Failed to sync annotations: ${error.message}`)
+    }
+  }
+
+  /**
+   * Import tasks with flexible data transformation
+   * Uses TaskTransformer for mapping source data to Label Studio format
+   */
+  @Mutation(returns => TaskImportResult, {
+    description: 'Import tasks to Label Studio with flexible data transformation'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async importTasksWithTransform(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('input') input: ImportTasksWithTransformInput,
+    @Ctx() context: ResolverContext
+  ): Promise<TaskImportResult> {
+    const errors: string[] = []
+    const taskIds: number[] = []
+    let imported = 0
+    let failed = 0
+
+    try {
+      // Parse source data
+      const sourceData = JSON.parse(input.sourceData)
+      if (!Array.isArray(sourceData)) {
+        throw new Error('Source data must be an array')
+      }
+
+      // Parse transform rule
+      const dataFields = JSON.parse(input.transformRule.dataFields)
+      const predictions = input.transformRule.predictions ? JSON.parse(input.transformRule.predictions) : undefined
+      const meta = input.transformRule.meta ? JSON.parse(input.transformRule.meta) : undefined
+
+      // Transform data using TaskTransformer
+      const lsTasks = TaskTransformer.transform(sourceData, {
+        dataFields,
+        predictions,
+        meta
+      })
+
+      // Import to Label Studio
+      const response = await labelStudioApi.importTasks(projectId, lsTasks)
+
+      if (response.task_count) {
+        imported = response.task_count
+        taskIds.push(...(response.task_ids || []))
+      }
+
+      return {
+        imported,
+        failed,
+        taskIds,
+        errors: errors.length > 0 ? errors : undefined
+      }
+    } catch (error) {
+      console.error(`Failed to import tasks with transform for project ${projectId}:`, error)
+      throw new Error(`Failed to import tasks: ${error.message}`)
+    }
+  }
+
+  /**
+   * Export annotations with flexible format conversion
+   * Uses AnnotationExporter for custom format support
+   */
+  @Mutation(returns => AnnotationExportResult, {
+    description: 'Export annotations from Label Studio with flexible format conversion'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async exportAnnotationsWithFormat(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('input') input: ExportAnnotationsInput,
+    @Ctx() context: ResolverContext
+  ): Promise<AnnotationExportResult> {
+    try {
+      // Get annotations from Label Studio
+      let annotations = await labelStudioApi.exportAnnotations(projectId, 'JSON')
+
+      // Filter by task IDs if specified
+      if (input.taskIds) {
+        const taskIds = JSON.parse(input.taskIds) as number[]
+        annotations = annotations.filter((a: any) => taskIds.includes(a.task))
+      }
+
+      // Export using custom format
+      const exportedData = await exportAnnotations(annotations, input.format, {
+        projectId,
+        exportedAt: new Date().toISOString()
+      })
+
+      // Convert to string if not already
+      const dataString = typeof exportedData === 'string' ? exportedData : JSON.stringify(exportedData)
+
+      return {
+        data: dataString,
+        count: annotations.length,
+        format: input.format
+      }
+    } catch (error) {
+      console.error(`Failed to export annotations for project ${projectId}:`, error)
+      throw new Error(`Failed to export annotations: ${error.message}`)
+    }
+  }
+}

package/server/service/user-provisioning/user-sync-mutation.ts

@@ -0,0 +1,80 @@
+import { Resolver, Mutation, Ctx, Field, ObjectType, Int, Directive } from 'type-graphql'
+import { UserProvisioningService } from '../../controller/user-provisioning-service.js'
+
+@ObjectType({ description: 'User synchronization result' })
+class UserSyncResult {
+  @Field()
+  success: boolean
+
+  @Field()
+  email: string
+
+  @Field()
+  action: string
+
+  @Field({ nullable: true })
+  lsUserId?: string
+
+  @Field({ nullable: true, description: 'Label Studio permissions (Admin/Staff/Inactive)' })
+  lsPermissions?: string
+
+  @Field({ nullable: true })
+  error?: string
+}
+
+@ObjectType({ description: 'User synchronization summary' })
+class UserSyncSummary {
+  @Field(type => Int)
+  total: number
+
+  @Field(type => Int)
+  created: number
+
+  @Field(type => Int)
+  updated: number
+
+  @Field(type => Int)
+  deactivated: number
+
+  @Field(type => Int)
+  skipped: number
+
+  @Field(type => Int)
+  errors: number
+
+  @Field(type => [UserSyncResult])
+  results: UserSyncResult[]
+}
+
+@Resolver()
+export class UserSyncMutation {
+  /**
+   * 현재 사용자를 Label Studio에 동기화
+   */
+  @Mutation(returns => UserSyncResult, {
+    description: 'Synchronize current user to Label Studio'
+  })
+  @Directive('@privilege(domainOwnerGranted: true)')
+  async syncMyUserToLabelStudio(@Ctx() context: ResolverContext): Promise<UserSyncResult> {
+    const { user, domain } = context.state
+
+    const result = await UserProvisioningService.syncUser(domain, user)
+
+    return result as UserSyncResult
+  }
+
+  /**
+   * 도메인의 모든 사용자를 Label Studio에 일괄 동기화
+   */
+  @Mutation(returns => UserSyncSummary, {
+    description: 'Synchronize all domain users to Label Studio (batch operation)'
+  })
+  @Directive('@privilege(domainOwnerGranted: true)')
+  async syncAllUsersToLabelStudio(@Ctx() context: ResolverContext): Promise<UserSyncSummary> {
+    const { domain } = context.state
+
+    const summary = await UserProvisioningService.syncAllUsers(domain)
+
+    return summary as UserSyncSummary
+  }
+}

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

@@ -0,0 +1,109 @@
+import { Resolver, Mutation, Query, Arg, Ctx, Int, Directive, Field, ObjectType } from 'type-graphql'
+import { labelStudioApi } from '../../utils/label-studio-api-client.js'
+
+@ObjectType({ description: 'Webhook information' })
+export class Webhook {
+  @Field(type => Int, { description: 'Webhook ID' })
+  id: number
+
+  @Field({ description: 'Webhook URL' })
+  url: string
+
+  @Field(type => Int, { description: 'Project ID' })
+  projectId: number
+
+  @Field({ description: 'Is webhook active' })
+  isActive: boolean
+
+  @Field({ description: 'Send payload with webhook' })
+  sendPayload: boolean
+}
+
+@Resolver()
+export class WebhookManagement {
+  /**
+   * Register webhook for a project
+   */
+  @Mutation(returns => Webhook, {
+    description: 'Register webhook for Label Studio project to receive real-time updates'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async registerLabelStudioWebhook(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<Webhook> {
+    try {
+      // Get Things-Factory server URL from environment or request
+      const serverUrl = process.env.SERVER_URL || 'http://localhost:3000'
+      const webhookUrl = `${serverUrl}/label-studio/webhook`
+
+      const webhook = await labelStudioApi.createWebhook({
+        project: projectId,
+        url: webhookUrl,
+        send_payload: true,
+        send_for_all_actions: true,
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      return {
+        id: webhook.id,
+        url: webhook.url,
+        projectId: webhook.project,
+        isActive: webhook.is_active || true,
+        sendPayload: webhook.send_payload || true
+      }
+    } catch (error) {
+      console.error(`Failed to register webhook for project ${projectId}:`, error)
+      throw new Error(`Failed to register webhook: ${error.message}`)
+    }
+  }
+
+  /**
+   * Get webhooks for a project
+   */
+  @Query(returns => [Webhook], {
+    description: 'Get all webhooks registered for a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioWebhooks(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<Webhook[]> {
+    try {
+      const webhooks = await labelStudioApi.getWebhooks(projectId)
+
+      return webhooks.map(webhook => ({
+        id: webhook.id,
+        url: webhook.url,
+        projectId: webhook.project,
+        isActive: webhook.is_active || true,
+        sendPayload: webhook.send_payload || true
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch webhooks for project ${projectId}:`, error)
+      throw new Error(`Failed to fetch webhooks: ${error.message}`)
+    }
+  }
+
+  /**
+   * Delete webhook
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Delete a webhook'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async deleteLabelStudioWebhook(
+    @Arg('webhookId', type => Int) webhookId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.deleteWebhook(webhookId)
+      return true
+    } catch (error) {
+      console.error(`Failed to delete webhook ${webhookId}:`, error)
+      throw new Error(`Failed to delete webhook: ${error.message}`)
+    }
+  }
+}

package/server/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "declaration": true,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}