Initial commit of akmon project
This commit is contained in:
435
utils/trainingRealtimeService.uts
Normal file
435
utils/trainingRealtimeService.uts
Normal file
@@ -0,0 +1,435 @@
|
||||
import supa, { supaReady } from '@/components/supadb/aksupainstance.uts'
|
||||
import AkSupaRealtime from '@/components/supadb/aksuparealtime.uts'
|
||||
import { WS_URL, SUPA_KEY } from '@/ak/config.uts'
|
||||
|
||||
export type TrainingStreamEvent = {
|
||||
training_id: string
|
||||
event_type: string
|
||||
class_id?: string | null
|
||||
student_id?: string | null
|
||||
device_id?: string | null
|
||||
ack?: boolean | null
|
||||
status?: string | null
|
||||
metrics?: UTSJSONObject | null
|
||||
payload?: UTSJSONObject | null
|
||||
ingest_source?: string | null
|
||||
ingest_note?: string | null
|
||||
recorded_at?: string | null
|
||||
ingested_at?: string | null
|
||||
}
|
||||
|
||||
export type TrainingRealtimeHandlers = {
|
||||
onAck?: (event: TrainingStreamEvent) => void
|
||||
onLiveMetrics?: (event: TrainingStreamEvent) => void
|
||||
onStateChange?: (event: TrainingStreamEvent) => void
|
||||
onEvent?: (event: TrainingStreamEvent) => void
|
||||
onError?: (err: any) => void
|
||||
}
|
||||
|
||||
export type TrainingRealtimeSubscription = {
|
||||
dispose: () => void
|
||||
}
|
||||
|
||||
export type TrainingRealtimeSubscriptionParams = {
|
||||
trainingId: string
|
||||
classId?: string | null
|
||||
}
|
||||
|
||||
type SubscriptionGuard = {
|
||||
active: boolean
|
||||
}
|
||||
|
||||
type ActiveSubscription = {
|
||||
params: TrainingRealtimeSubscriptionParams
|
||||
handlers: TrainingRealtimeHandlers
|
||||
guard: SubscriptionGuard
|
||||
}
|
||||
|
||||
async function ensureSupaSession(): Promise<void> {
|
||||
try {
|
||||
await supaReady
|
||||
} catch (err) {
|
||||
console.error('Supabase session initialization error', err)
|
||||
}
|
||||
}
|
||||
|
||||
function extractRecord(payload: any): UTSJSONObject | null {
|
||||
try {
|
||||
if (payload == null) return null
|
||||
const wrapper = payload as UTSJSONObject
|
||||
const directNew = wrapper.get('new') as UTSJSONObject | null
|
||||
if (directNew != null) return directNew
|
||||
const record = wrapper.get('record') as UTSJSONObject | null
|
||||
if (record != null) return record
|
||||
const dataSection = wrapper.get('data') as UTSJSONObject | null
|
||||
if (dataSection != null) {
|
||||
const dataRecord = dataSection.get('record') as UTSJSONObject | null
|
||||
if (dataRecord != null) return dataRecord
|
||||
const dataNew = dataSection.get('new') as UTSJSONObject | null
|
||||
if (dataNew != null) return dataNew
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('extractRecord error', err)
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
function toStreamEvent(row: UTSJSONObject | null): TrainingStreamEvent | null {
|
||||
if (row == null) return null
|
||||
try {
|
||||
const trainingId = row.getString('training_id') as string | null
|
||||
const eventType = row.getString('event_type') as string | null
|
||||
if (trainingId == null || trainingId == '' || eventType == null || eventType == '') {
|
||||
return null
|
||||
}
|
||||
const studentId = row.getString('student_id') as string | null
|
||||
const classId = row.getString('class_id') as string | null
|
||||
const deviceId = row.getString('device_id') as string | null
|
||||
const ackRaw = row.get('ack')
|
||||
const status = row.getString('status') as string | null
|
||||
const metrics = row.get('metrics') as UTSJSONObject | null
|
||||
const payload = row.get('payload') as UTSJSONObject | null
|
||||
const ingestSource = row.getString('ingest_source') as string | null
|
||||
const ingestNote = row.getString('ingest_note') as string | null
|
||||
const recordedAt = row.getString('recorded_at') as string | null
|
||||
const ingestedAt = row.getString('ingested_at') as string | null
|
||||
const ack = typeof ackRaw == 'boolean' ? (ackRaw as boolean) : null
|
||||
return {
|
||||
training_id: trainingId,
|
||||
event_type: eventType,
|
||||
class_id: classId ?? null,
|
||||
student_id: studentId ?? null,
|
||||
device_id: deviceId ?? null,
|
||||
ack: ack,
|
||||
status: status ?? null,
|
||||
metrics: metrics ?? null,
|
||||
payload: payload ?? null,
|
||||
ingest_source: ingestSource ?? null,
|
||||
ingest_note: ingestNote ?? null,
|
||||
recorded_at: recordedAt ?? null,
|
||||
ingested_at: ingestedAt ?? null
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('toStreamEvent error', err)
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export class TrainingRealtimeService {
|
||||
private static rt: AkSupaRealtime | null = null
|
||||
private static initializing: Promise<void> | null = null
|
||||
private static initialized: boolean = false
|
||||
private static subscriptions: Array<ActiveSubscription> = []
|
||||
private static reconnectAttempts: number = 0
|
||||
private static reconnectTimer: number | null = null
|
||||
private static reconnecting: boolean = false
|
||||
|
||||
private static async waitForRealtimeOpen(timeoutMs: number = 5000): Promise<void> {
|
||||
const start = Date.now()
|
||||
while (true) {
|
||||
if (this.rt != null && this.rt.isOpen == true) {
|
||||
return
|
||||
}
|
||||
if (Date.now() - start > timeoutMs) {
|
||||
throw new Error('Realtime socket not ready')
|
||||
}
|
||||
await new Promise<void>((resolve) => {
|
||||
setTimeout(() => resolve(), 50)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
private static clearReconnectTimer(): void {
|
||||
const timer = this.reconnectTimer
|
||||
if (timer != null) {
|
||||
clearTimeout(timer)
|
||||
this.reconnectTimer = null
|
||||
}
|
||||
}
|
||||
|
||||
private static handleSocketClose(origin: string | null): void {
|
||||
this.initialized = false
|
||||
this.rt = null
|
||||
if (this.subscriptions.length == 0) {
|
||||
this.clearReconnectTimer()
|
||||
this.reconnectAttempts = 0
|
||||
return
|
||||
}
|
||||
if (this.reconnecting == true) {
|
||||
return
|
||||
}
|
||||
console.warn('[TrainingRealtimeService] realtime closed, scheduling reconnect', origin ?? 'unknown')
|
||||
this.scheduleReconnect()
|
||||
}
|
||||
|
||||
private static async scheduleReconnect(): Promise<void> {
|
||||
if (this.reconnectTimer != null) return
|
||||
if (this.subscriptions.every((sub) => sub.guard.active !== true)) {
|
||||
this.subscriptions = []
|
||||
this.reconnectAttempts = 0
|
||||
return
|
||||
}
|
||||
const attempt = this.reconnectAttempts + 1
|
||||
this.reconnectAttempts = attempt
|
||||
const baseDelay = Math.min(Math.pow(2, attempt - 1) * 1000, 10000)
|
||||
const jitter = Math.floor(Math.random() * 200)
|
||||
const delay = baseDelay + jitter
|
||||
console.log('[TrainingRealtimeService] reconnect scheduled in', delay, 'ms (attempt', attempt, ')')
|
||||
this.reconnectTimer = setTimeout(() => {
|
||||
const runner = async () => {
|
||||
this.reconnectTimer = null
|
||||
if (this.subscriptions.every((sub) => sub.guard.active !== true)) {
|
||||
this.subscriptions = []
|
||||
this.reconnectAttempts = 0
|
||||
return
|
||||
}
|
||||
this.reconnecting = true
|
||||
try {
|
||||
await this.ensureRealtime()
|
||||
await this.waitForRealtimeOpen(3000)
|
||||
this.reconnectAttempts = 0
|
||||
await this.resubscribeAll()
|
||||
} catch (err) {
|
||||
console.error('reconnect attempt failed', err)
|
||||
this.scheduleReconnect()
|
||||
} finally {
|
||||
this.reconnecting = false
|
||||
}
|
||||
}
|
||||
runner().catch((err) => {
|
||||
console.error('reconnect timer runner error', err)
|
||||
})
|
||||
}, delay)
|
||||
}
|
||||
|
||||
private static async resubscribeAll(): Promise<void> {
|
||||
let hadFailure = false
|
||||
for (let i = 0; i < this.subscriptions.length; i++) {
|
||||
const record = this.subscriptions[i]
|
||||
if (record.guard.active !== true) continue
|
||||
try {
|
||||
await this.performSubscription(record)
|
||||
} catch (err) {
|
||||
console.error('resubscribe error', err)
|
||||
record.handlers?.onError?.(err)
|
||||
hadFailure = true
|
||||
}
|
||||
}
|
||||
if (hadFailure) {
|
||||
this.scheduleReconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private static removeSubscription(record: ActiveSubscription): void {
|
||||
const index = this.subscriptions.indexOf(record)
|
||||
if (index >= 0) {
|
||||
this.subscriptions.splice(index, 1)
|
||||
}
|
||||
if (this.subscriptions.length == 0) {
|
||||
this.clearReconnectTimer()
|
||||
this.reconnectAttempts = 0
|
||||
}
|
||||
}
|
||||
|
||||
private static async performSubscription(record: ActiveSubscription): Promise<void> {
|
||||
if (record.guard.active !== true) return
|
||||
const params = record.params
|
||||
const handlers = record.handlers
|
||||
const filter = `training_id=eq.${params.trainingId}`
|
||||
const maxAttempts = 2
|
||||
let attempt = 0
|
||||
while (attempt < maxAttempts) {
|
||||
attempt += 1
|
||||
if (record.guard.active !== true) return
|
||||
try {
|
||||
if (this.rt == null || this.rt.isOpen !== true) {
|
||||
await this.ensureRealtime()
|
||||
await this.waitForRealtimeOpen(2000)
|
||||
}
|
||||
const realtime = this.rt
|
||||
if (realtime == null) {
|
||||
throw new Error('Realtime client not initialized')
|
||||
}
|
||||
console.log('[TrainingRealtimeService] realtime ready, preparing subscription', params)
|
||||
console.log('[TrainingRealtimeService] subscribing to training_stream_events', filter, 'attempt', attempt)
|
||||
realtime.subscribePostgresChanges({
|
||||
event: '*',
|
||||
schema: 'public',
|
||||
table: 'training_stream_events',
|
||||
filter: filter,
|
||||
onChange: (payload: any) => {
|
||||
if (record.guard.active !== true) return
|
||||
const recordPayload = extractRecord(payload)
|
||||
const event = toStreamEvent(recordPayload)
|
||||
if (event == null) return
|
||||
console.log('[TrainingRealtimeService] incoming event', event?.event_type ?? 'unknown', event?.training_id ?? '')
|
||||
if (params.classId != null && params.classId !== '') {
|
||||
if ((event.class_id ?? '') !== params.classId) {
|
||||
return
|
||||
}
|
||||
}
|
||||
try {
|
||||
handlers?.onEvent?.(event)
|
||||
switch (event.event_type) {
|
||||
case 'ack':
|
||||
case 'ack_pending':
|
||||
case 'ack_fail':
|
||||
handlers?.onAck?.(event)
|
||||
break
|
||||
case 'telemetry':
|
||||
case 'metrics':
|
||||
handlers?.onLiveMetrics?.(event)
|
||||
break
|
||||
case 'state':
|
||||
case 'session':
|
||||
case 'summary':
|
||||
handlers?.onStateChange?.(event)
|
||||
break
|
||||
default:
|
||||
break
|
||||
}
|
||||
} catch (handlerErr) {
|
||||
console.error('training event handler error', handlerErr)
|
||||
}
|
||||
}
|
||||
})
|
||||
console.log('[TrainingRealtimeService] subscription ready', params.trainingId)
|
||||
return
|
||||
} catch (subscribeErr) {
|
||||
console.error('performSubscription error', subscribeErr, 'attempt', attempt)
|
||||
if (attempt >= maxAttempts) {
|
||||
throw subscribeErr
|
||||
}
|
||||
await new Promise<void>((resolve) => {
|
||||
setTimeout(() => resolve(), 200)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static async ensureRealtime(): Promise<void> {
|
||||
if (this.rt != null && this.rt.isOpen == true) {
|
||||
this.initialized = true
|
||||
return
|
||||
}
|
||||
if (this.initializing != null) {
|
||||
await this.initializing
|
||||
return
|
||||
}
|
||||
await ensureSupaSession()
|
||||
let token: string | null = null
|
||||
try {
|
||||
const session = supa.getSession()
|
||||
if (session != null) {
|
||||
token = session.session?.access_token ?? null
|
||||
}
|
||||
} catch (_) { }
|
||||
|
||||
let resolveReady: ((value: void) => void) | null = null
|
||||
let rejectReady: ((reason: any) => void) | null = null
|
||||
const readyPromise = new Promise<void>((resolve, reject) => {
|
||||
resolveReady = resolve as (value: void) => void
|
||||
rejectReady = reject
|
||||
})
|
||||
|
||||
this.initializing = readyPromise
|
||||
const realtime = new AkSupaRealtime({
|
||||
url: WS_URL,
|
||||
channel: 'realtime:training_stream',
|
||||
apikey: SUPA_KEY,
|
||||
token: token,
|
||||
onMessage: (_data: any) => { },
|
||||
onOpen: (_res: any) => {
|
||||
this.initialized = true
|
||||
this.reconnectAttempts = 0
|
||||
this.clearReconnectTimer()
|
||||
this.reconnecting = false
|
||||
const resolver = resolveReady
|
||||
resolveReady = null
|
||||
rejectReady = null
|
||||
this.initializing = null
|
||||
resolver?.()
|
||||
},
|
||||
onError: (err: any) => {
|
||||
if (resolveReady != null) {
|
||||
const rejector = rejectReady
|
||||
resolveReady = null
|
||||
rejectReady = null
|
||||
this.initializing = null
|
||||
rejector?.(err)
|
||||
}
|
||||
},
|
||||
onClose: (_res: any) => {
|
||||
if (resolveReady != null) {
|
||||
const rejector = rejectReady
|
||||
resolveReady = null
|
||||
rejectReady = null
|
||||
this.initializing = null
|
||||
rejector?.(new Error('Realtime connection closed before ready'))
|
||||
} else {
|
||||
this.handleSocketClose('close')
|
||||
}
|
||||
}
|
||||
})
|
||||
this.rt = realtime
|
||||
this.rt?.connect()
|
||||
try {
|
||||
await readyPromise
|
||||
} finally {
|
||||
this.initializing = null
|
||||
}
|
||||
}
|
||||
|
||||
static async subscribeTrainingSession(params: TrainingRealtimeSubscriptionParams, handlers: TrainingRealtimeHandlers): Promise<TrainingRealtimeSubscription> {
|
||||
if (params.trainingId == null || params.trainingId == '') {
|
||||
throw new Error('trainingId is required')
|
||||
}
|
||||
const guard: SubscriptionGuard = { active: true }
|
||||
const record: ActiveSubscription = {
|
||||
params: {
|
||||
trainingId: params.trainingId,
|
||||
classId: params.classId ?? null
|
||||
},
|
||||
handlers: handlers,
|
||||
guard: guard
|
||||
}
|
||||
this.subscriptions.push(record)
|
||||
try {
|
||||
await this.performSubscription(record)
|
||||
} catch (err) {
|
||||
console.error('subscribeTrainingSession failed', err)
|
||||
guard.active = false
|
||||
this.removeSubscription(record)
|
||||
handlers?.onError?.(err)
|
||||
return { dispose: () => { } }
|
||||
}
|
||||
console.log('[TrainingRealtimeService] subscription active', params.trainingId)
|
||||
return {
|
||||
dispose: () => {
|
||||
if (guard.active !== true) return
|
||||
guard.active = false
|
||||
this.removeSubscription(record)
|
||||
console.log('[TrainingRealtimeService] subscription disposed', params.trainingId)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static closeRealtime(): void {
|
||||
try {
|
||||
if (this.rt != null) {
|
||||
this.rt.close({ code: 1000, reason: 'manual close' })
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('closeRealtime error', err)
|
||||
} finally {
|
||||
this.rt = null
|
||||
this.initialized = false
|
||||
this.initializing = null
|
||||
this.reconnecting = false
|
||||
this.clearReconnectTimer()
|
||||
this.reconnectAttempts = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default TrainingRealtimeService
|
||||
Reference in New Issue
Block a user