spine-framework-cortex 0.2.24 → 0.2.26

package/pages/support/TicketDetailPage.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
 import { useAppPath } from '@core/hooks/useAppPath'
 import { apiFetch } from '@core/lib/api'
@@ -78,14 +78,16 @@ const STATUS_BADGE: Record<string, string> = {
 }
 
 // Merged Thread Panel - combines internal and external messages
-function MergedThreadPanel({ 
-  ticketId, 
-  externalThread, 
-  internalThread 
-}: { 
+function MergedThreadPanel({
+  ticketId,
+  externalThread,
+  internalThread,
+  refreshThreads,
+}: {
   ticketId: string
   externalThread: Thread | null
   internalThread: Thread | null
+  refreshThreads: () => Promise<void>
 }) {
   const [messages, setMessages] = useState<Message[]>([])
   const [loading, setLoading] = useState(true)
@@ -132,29 +134,19 @@ function MergedThreadPanel({
     try {
       // Create internal thread if it doesn't exist
       if (!targetThread && replyType === 'internal') {
-        const threadTypesRes = await apiFetch('/api/types?kind=thread&limit=1').then(r => r.json())
-        const threadTypes = Array.isArray(threadTypesRes?.data) ? threadTypesRes.data : Array.isArray(threadTypesRes) ? threadTypesRes : []
-        if (!threadTypes.length) {
-          console.error('No thread type found')
-          return
-        }
-
         const threadRes = await apiFetch('/api/admin-data?action=create&entity=threads', {
           method: 'POST', headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
             target_type: 'item',
             target_id: ticketId,
             visibility: 'internal',
-            type_id: threadTypes[0].id
+            type_slug: 'support_thread'
           }),
         })
         const newThread = await threadRes.json()
         if (newThread?.id) {
           targetThread = newThread
-          // Refresh threads list
-          const thr = await apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${ticketId}&limit=10`).then(r => r.json())
-          const threadList = thr?.data ?? thr
-          setThreads(Array.isArray(threadList) ? threadList : [])
+          await refreshThreads()
         }
       }
 
@@ -163,14 +155,6 @@ function MergedThreadPanel({
         return
       }
 
-      // Resolve message type_id
-      const typesRes = await apiFetch('/api/types?kind=message&limit=1').then(r => r.json())
-      const types = Array.isArray(typesRes?.data) ? typesRes.data : Array.isArray(typesRes) ? typesRes : []
-      if (!types.length) {
-        console.error('No message type found')
-        return
-      }
-
       // Get current message count for sequencing
       const currentMsgs = await apiFetch(`/api/admin-data?action=list&entity=messages&thread_id=${targetThread.id}&limit=1000`).then(r => r.json())
       const msgCount = Array.isArray(currentMsgs?.data) ? currentMsgs.data.length : Array.isArray(currentMsgs) ? currentMsgs.length : 0
@@ -178,11 +162,11 @@ function MergedThreadPanel({
 
       const res = await apiFetch('/api/admin-data?action=create&entity=messages', {
         method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ 
-          thread_id: targetThread.id, 
-          content: reply.trim(), 
-          direction: 'outbound', 
-          type_id: types[0].id,
+        body: JSON.stringify({
+          thread_id: targetThread.id,
+          content: reply.trim(),
+          direction: 'outbound',
+          type_slug: 'support_reply',
           sequence: nextSeq,
           visibility: replyType
         }),
@@ -740,18 +724,25 @@ export default function TicketDetailPage() {
   const [watchLoading, setWatchLoading] = useState(false)
   const [analysisLoading, setAnalysisLoading] = useState(false)
 
-  useEffect(() => {
+  const loadTicketAndThreads = useCallback(async () => {
     if (!id) return
-    Promise.all([
-      apiFetch(`/api/admin-data?action=get&entity=items&id=${id}`).then(r => r.json()),
-      apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${id}&limit=10`).then(r => r.json()),
-    ]).then(([ir, thr]) => {
+    setLoading(true)
+    try {
+      const [ir, thr] = await Promise.all([
+        apiFetch(`/api/admin-data?action=get&entity=items&id=${id}`).then(r => r.json()),
+        apiFetch(`/api/admin-data?action=list&entity=threads&target_id=${id}&type_slug=support_thread&limit=10`).then(r => r.json()),
+      ])
       setTicket(ir?.data ?? ir ?? null)
       const threadList = thr?.data ?? thr
       setThreads(Array.isArray(threadList) ? threadList : [])
-    }).catch(() => {}).finally(() => setLoading(false))
+    } catch {
+    } finally {
+      setLoading(false)
+    }
   }, [id])
 
+  useEffect(() => { loadTicketAndThreads() }, [loadTicketAndThreads])
+
   // Check if current user is watching this ticket
   useEffect(() => {
     if (!id || !user?.id) return
@@ -776,16 +767,12 @@ export default function TicketDetailPage() {
         setIsWatching(false)
         setWatcherId(null)
       } else {
-        // Resolve watcher type_id via types API
-        const typeRes = await apiFetch('/api/types?kind=watcher&limit=1').then(r => r.json())
-        const types = Array.isArray(typeRes?.data) ? typeRes.data : Array.isArray(typeRes) ? typeRes : []
-        if (!types.length) { console.error('No watcher type found'); return }
         const res = await apiFetch('/api/admin-data?action=create&entity=watchers', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
             entity: 'watchers',
-            type_id: types[0].id,
+            type_slug: 'watcher',
             target_type: 'item',
             target_id: id,
             person_id: user.id,
@@ -887,10 +874,11 @@ export default function TicketDetailPage() {
       <div className="flex flex-1 min-h-0">
         {/* Main Conversation Panel */}
         <div className="flex-1 min-w-0 border-r border-border">
-          <MergedThreadPanel 
-            ticketId={id || ''} 
-            externalThread={externalThread} 
-            internalThread={internalThread} 
+          <MergedThreadPanel
+            ticketId={id || ''}
+            externalThread={externalThread}
+            internalThread={internalThread}
+            refreshThreads={loadTicketAndThreads}
           />
         </div>
 

package/seed/types.json

@@ -1868,7 +1868,7 @@
     "kind": "item",
     "slug": "course_lesson",
     "name": "Course Lesson",
-    "description": "Learning content unit — part of a course sequence",
+    "description": "Learning content unit \u2014 part of a course sequence",
     "icon": "graduation-cap",
     "color": "#F97316",
     "ownership": "tenant",
@@ -1986,4 +1986,4 @@
     },
     "validation_schema": {}
   }
-]
+]

package/hooks/useTypeRegistry.ts

@@ -1,74 +0,0 @@
-import { useState, useEffect } from 'react'
-import { supabase } from '@core/lib/supabase'
-
-interface TypeRecord {
-  id: string
-  slug: string
-  name: string
-  description?: string
-}
-
-// Module-level cache - persists across renders, shared across hooks
-let typeCache: Map<string, TypeRecord> | null = null
-let loadPromise: Promise<Map<string, TypeRecord>> | null = null
-
-async function fetchTypes(): Promise<Map<string, TypeRecord>> {
-  if (typeCache) return typeCache
-  if (loadPromise) return loadPromise
-
-  loadPromise = (async () => {
-    try {
-      // Query Supabase directly - types is a config table, not exposed via admin-data
-      const { data: types, error } = await supabase
-        .from('types')
-        .select('id, slug, name, description')
-        .eq('is_active', true)
-        .limit(100)
-
-      if (error) throw error
-
-      typeCache = new Map((types || []).map(t => [t.slug, t]))
-      return typeCache
-    } catch (e) {
-      console.error('Failed to load types:', e)
-      typeCache = new Map() // Empty cache on error
-      return typeCache
-    } finally {
-      loadPromise = null
-    }
-  })()
-
-  return loadPromise
-}
-
-export function useTypeRegistry() {
-  const [types, setTypes] = useState<Map<string, TypeRecord>>(typeCache || new Map())
-  const [loading, setLoading] = useState(!typeCache)
-  const [error, setError] = useState<string | null>(null)
-
-  useEffect(() => {
-    if (typeCache) return
-
-    fetchTypes()
-      .then(cache => {
-        setTypes(cache)
-        setLoading(false)
-      })
-      .catch(e => {
-        setError(e.message)
-        setLoading(false)
-      })
-  }, [])
-
-  const getTypeId = (slug: string): string | null => {
-    return types.get(slug)?.id || null
-  }
-
-  return { types, loading, error, getTypeId }
-}
-
-// Synchronous version for use inside async functions
-export async function getTypeIdAsync(slug: string): Promise<string | null> {
-  const cache = await fetchTypes()
-  return cache.get(slug)?.id || null
-}