All files / web/src/app/api/flowcharts/seed-embeddings/task route.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Background Task API for Flowchart Embedding
 *
 * POST /api/flowcharts/seed-embeddings/task
 *   - Start embedding as a background task
 *   - Returns a taskId for Socket.IO subscription
 *
 * GET /api/flowcharts/seed-embeddings/task
 *   - Get active embedding task (if any)
 *
 * DELETE /api/flowcharts/seed-embeddings/task
 *   - Cancel the active embedding task
 */

import { NextResponse } from 'next/server'
import { eq } from 'drizzle-orm'
import { db } from '@/db'
import { backgroundTasks } from '@/db/schema/background-tasks'
import { withAuth } from '@/lib/auth/withAuth'
import { startFlowchartEmbedding } from '@/lib/tasks/flowchart-embed'
import { cancelTask } from '@/lib/task-manager'

export const dynamic = 'force-dynamic'

/**
 * POST - Start flowchart embedding as a background task
 */
export const POST = withAuth(async (request) => {
  try {
    // Check for already-running embedding task
    const existingTask = await db
      .select()
      .from(backgroundTasks)
      .where(eq(backgroundTasks.type, 'flowchart-embed'))
      .all()
      .then((tasks) => tasks.find((t) => t.status === 'running' || t.status === 'pending'))

    if (existingTask) {
      return NextResponse.json({
        taskId: existingTask.id,
        status: 'already_running',
        message: 'Embedding generation already in progress',
      })
    }

    // Parse request body
    let config: { flowchartId?: string } = {}
    try {
      const body = await request.text()
      if (body) {
        config = JSON.parse(body)
      }
    } catch {
      // Use defaults if body parsing fails
    }

    const taskId = await startFlowchartEmbedding({
      flowchartId: config.flowchartId,
    })

    return NextResponse.json({
      taskId,
      status: 'started',
      message: 'Embedding task started',
    })
  } catch (error) {
    console.error('[FlowchartEmbedTaskAPI] Error starting embedding task:', error)
    return NextResponse.json(
      { error: error instanceof Error ? error.message : 'Failed to start embedding' },
      { status: 500 }
    )
  }
})

/**
 * GET - Check for active embedding task
 */
export const GET = withAuth(async () => {
  try {
    const tasks = await db
      .select({
        id: backgroundTasks.id,
        status: backgroundTasks.status,
        progress: backgroundTasks.progress,
        progressMessage: backgroundTasks.progressMessage,
      })
      .from(backgroundTasks)
      .where(eq(backgroundTasks.type, 'flowchart-embed'))
      .all()

    const activeTask = tasks.find((t) => t.status === 'running' || t.status === 'pending')

    if (activeTask) {
      return NextResponse.json({
        taskId: activeTask.id,
        status: activeTask.status,
        progress: activeTask.progress,
        progressMessage: activeTask.progressMessage,
      })
    }

    return NextResponse.json({
      taskId: null,
      status: 'none',
      message: 'No active embedding task',
    })
  } catch (error) {
    console.error('[FlowchartEmbedTaskAPI] Error checking task:', error)
    return NextResponse.json({ error: 'Failed to check task status' }, { status: 500 })
  }
})

/**
 * DELETE - Cancel the active embedding task
 */
export const DELETE = withAuth(async () => {
  try {
    const tasks = await db
      .select()
      .from(backgroundTasks)
      .where(eq(backgroundTasks.type, 'flowchart-embed'))
      .all()

    const activeTask = tasks.find((t) => t.status === 'running' || t.status === 'pending')

    if (!activeTask) {
      return NextResponse.json({ message: 'No embedding in progress' })
    }

    const cancelled = await cancelTask(activeTask.id)
    return NextResponse.json({
      cancelled,
      message: cancelled ? 'Embedding cancellation requested' : 'Could not cancel embedding',
    })
  } catch (error) {
    console.error('[FlowchartEmbedTaskAPI] Error cancelling:', error)
    return NextResponse.json({ error: 'Failed to cancel embedding' }, { status: 500 })
  }
})