chore: import upstream snapshot with attribution

apps/sim/app/api/memory/[id]/route.ts

@@ -0,0 +1,254 @@
+import { db } from '@sim/db'
+import { memory } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNull } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  agentMemoryDataSchemaContract,
+  deleteMemoryByIdContract,
+  getMemoryByIdContract,
+  updateMemoryByIdContract,
+} from '@/lib/api/contracts/memory'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('MemoryByIdAPI')
+
+interface MemoryRouteContext {
+  params: Promise<{ id: string }>
+}
+
+function memoryEnvelopeError(message: string, status: number) {
+  return NextResponse.json({ success: false, error: { message } }, { status })
+}
+
+async function validateMemoryAccess(
+  request: NextRequest,
+  workspaceId: string,
+  requestId: string,
+  action: 'read' | 'write'
+): Promise<{ userId: string } | { error: NextResponse }> {
+  const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+  if (!authResult.success || !authResult.userId) {
+    logger.warn(`[${requestId}] Unauthorized memory ${action} attempt`)
+    return { error: memoryEnvelopeError('Authentication required', 401) }
+  }
+
+  const access = await checkWorkspaceAccess(workspaceId, authResult.userId)
+  if (!access.exists || !access.hasAccess) {
+    return { error: memoryEnvelopeError('Workspace not found', 404) }
+  }
+
+  if (action === 'write' && !access.canWrite) {
+    return { error: memoryEnvelopeError('Write access denied', 403) }
+  }
+
+  return { userId: authResult.userId }
+}
+
+export const dynamic = 'force-dynamic'
+export const runtime = 'nodejs'
+
+export const GET = withRouteHandler(async (request: NextRequest, context: MemoryRouteContext) => {
+  const requestId = generateRequestId()
+  const { id } = await context.params
+
+  try {
+    const validation = await parseRequest(getMemoryByIdContract, request, context, {
+      validationErrorResponse: (error) =>
+        memoryEnvelopeError(
+          error.issues.map((err) => `${err.path.join('.')}: ${err.message}`).join(', '),
+          400
+        ),
+    })
+    if (!validation.success) return validation.response
+    const { workspaceId: validatedWorkspaceId } = validation.data.query
+
+    const accessCheck = await validateMemoryAccess(request, validatedWorkspaceId, requestId, 'read')
+    if ('error' in accessCheck) {
+      return accessCheck.error
+    }
+
+    const memories = await db
+      .select()
+      .from(memory)
+      .where(
+        and(
+          eq(memory.key, id),
+          eq(memory.workspaceId, validatedWorkspaceId),
+          isNull(memory.deletedAt)
+        )
+      )
+      .orderBy(memory.createdAt)
+      .limit(1)
+
+    if (memories.length === 0) {
+      return NextResponse.json({ success: true, data: null }, { status: 200 })
+    }
+
+    const mem = memories[0]
+
+    logger.info(`[${requestId}] Memory retrieved: ${id} for workspace: ${validatedWorkspaceId}`)
+    return NextResponse.json(
+      { success: true, data: { conversationId: mem.key, data: mem.data } },
+      { status: 200 }
+    )
+  } catch (error: any) {
+    logger.error(`[${requestId}] Error retrieving memory`, { error })
+    return memoryEnvelopeError(error.message || 'Failed to retrieve memory', 500)
+  }
+})
+
+export const DELETE = withRouteHandler(
+  async (request: NextRequest, context: MemoryRouteContext) => {
+    const requestId = generateRequestId()
+    const { id } = await context.params
+
+    try {
+      const validation = await parseRequest(deleteMemoryByIdContract, request, context, {
+        validationErrorResponse: (error) =>
+          memoryEnvelopeError(
+            error.issues.map((err) => `${err.path.join('.')}: ${err.message}`).join(', '),
+            400
+          ),
+      })
+      if (!validation.success) return validation.response
+      const { workspaceId: validatedWorkspaceId } = validation.data.query
+
+      const accessCheck = await validateMemoryAccess(
+        request,
+        validatedWorkspaceId,
+        requestId,
+        'write'
+      )
+      if ('error' in accessCheck) {
+        return accessCheck.error
+      }
+
+      const existingMemory = await db
+        .select({ id: memory.id })
+        .from(memory)
+        .where(
+          and(
+            eq(memory.key, id),
+            eq(memory.workspaceId, validatedWorkspaceId),
+            isNull(memory.deletedAt)
+          )
+        )
+        .limit(1)
+
+      if (existingMemory.length === 0) {
+        return memoryEnvelopeError('Memory not found', 404)
+      }
+
+      await db
+        .delete(memory)
+        .where(
+          and(
+            eq(memory.key, id),
+            eq(memory.workspaceId, validatedWorkspaceId),
+            isNull(memory.deletedAt)
+          )
+        )
+
+      logger.info(`[${requestId}] Memory deleted: ${id} for workspace: ${validatedWorkspaceId}`)
+      return NextResponse.json(
+        { success: true, data: { message: 'Memory deleted successfully' } },
+        { status: 200 }
+      )
+    } catch (error: any) {
+      logger.error(`[${requestId}] Error deleting memory`, { error })
+      return memoryEnvelopeError(error.message || 'Failed to delete memory', 500)
+    }
+  }
+)
+
+export const PUT = withRouteHandler(async (request: NextRequest, context: MemoryRouteContext) => {
+  const requestId = generateRequestId()
+  const { id } = await context.params
+
+  try {
+    const validation = await parseRequest(updateMemoryByIdContract, request, context, {
+      validationErrorResponse: (error) =>
+        memoryEnvelopeError(
+          `Invalid request body: ${error.issues.map((err) => `${err.path.join('.')}: ${err.message}`).join(', ')}`,
+          400
+        ),
+      invalidJsonResponse: () => memoryEnvelopeError('Invalid JSON in request body', 400),
+    })
+    if (!validation.success) return validation.response
+    const { data: validatedData, workspaceId: validatedWorkspaceId } = validation.data.body
+
+    const accessCheck = await validateMemoryAccess(
+      request,
+      validatedWorkspaceId,
+      requestId,
+      'write'
+    )
+    if ('error' in accessCheck) {
+      return accessCheck.error
+    }
+
+    const existingMemories = await db
+      .select()
+      .from(memory)
+      .where(
+        and(
+          eq(memory.key, id),
+          eq(memory.workspaceId, validatedWorkspaceId),
+          isNull(memory.deletedAt)
+        )
+      )
+      .limit(1)
+
+    if (existingMemories.length === 0) {
+      return memoryEnvelopeError('Memory not found', 404)
+    }
+
+    const agentValidation = agentMemoryDataSchemaContract.safeParse(validatedData)
+    if (!agentValidation.success) {
+      const errorMessage = agentValidation.error.issues
+        .map((err) => `${err.path.join('.')}: ${err.message}`)
+        .join(', ')
+      return memoryEnvelopeError(`Invalid agent memory data: ${errorMessage}`, 400)
+    }
+
+    const now = new Date()
+    await db
+      .update(memory)
+      .set({ data: validatedData, updatedAt: now })
+      .where(
+        and(
+          eq(memory.key, id),
+          eq(memory.workspaceId, validatedWorkspaceId),
+          isNull(memory.deletedAt)
+        )
+      )
+
+    const updatedMemories = await db
+      .select()
+      .from(memory)
+      .where(
+        and(
+          eq(memory.key, id),
+          eq(memory.workspaceId, validatedWorkspaceId),
+          isNull(memory.deletedAt)
+        )
+      )
+      .limit(1)
+
+    const mem = updatedMemories[0]
+
+    logger.info(`[${requestId}] Memory updated: ${id} for workspace: ${validatedWorkspaceId}`)
+    return NextResponse.json(
+      { success: true, data: { conversationId: mem.key, data: mem.data } },
+      { status: 200 }
+    )
+  } catch (error: any) {
+    logger.error(`[${requestId}] Error updating memory`, { error })
+    return memoryEnvelopeError(error.message || 'Failed to update memory', 500)
+  }
+})

apps/sim/app/api/memory/route.ts

@@ -0,0 +1,329 @@
+import { db } from '@sim/db'
+import { memory } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { getPostgresErrorCode } from '@sim/utils/errors'
+import { generateId } from '@sim/utils/id'
+import { and, eq, isNull, like } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  createMemoryContract,
+  deleteMemoryByQueryContract,
+  listMemoriesContract,
+  memoryMessageSchema,
+} from '@/lib/api/contracts/memory'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('MemoryAPI')
+
+export const dynamic = 'force-dynamic'
+export const runtime = 'nodejs'
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request)
+    if (!authResult.success || !authResult.userId) {
+      logger.warn(`[${requestId}] Unauthorized memory access attempt`)
+      return NextResponse.json(
+        { success: false, error: { message: authResult.error || 'Authentication required' } },
+        { status: 401 }
+      )
+    }
+
+    const validation = await parseRequest(listMemoriesContract, request, {})
+    if (!validation.success) return validation.response
+    const { workspaceId, query: searchQuery, limit } = validation.data.query
+
+    if (!workspaceId) {
+      return NextResponse.json(
+        { success: false, error: { message: 'workspaceId parameter is required' } },
+        { status: 400 }
+      )
+    }
+
+    const access = await checkWorkspaceAccess(workspaceId, authResult.userId)
+    if (!access.exists) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Workspace not found' } },
+        { status: 404 }
+      )
+    }
+    if (!access.hasAccess) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Access denied to this workspace' } },
+        { status: 403 }
+      )
+    }
+
+    const conditions = [isNull(memory.deletedAt), eq(memory.workspaceId, workspaceId)]
+
+    if (searchQuery) {
+      conditions.push(like(memory.key, `%${searchQuery}%`))
+    }
+
+    const rawMemories = await db
+      .select()
+      .from(memory)
+      .where(and(...conditions))
+      .orderBy(memory.createdAt)
+      .limit(limit)
+
+    const enrichedMemories = rawMemories.map((mem) => ({
+      conversationId: mem.key,
+      data: mem.data,
+    }))
+
+    logger.info(
+      `[${requestId}] Found ${enrichedMemories.length} memories for workspace: ${workspaceId}`
+    )
+    return NextResponse.json(
+      { success: true, data: { memories: enrichedMemories } },
+      { status: 200 }
+    )
+  } catch (error: any) {
+    logger.error(`[${requestId}] Error searching memories`, { error })
+    return NextResponse.json(
+      { success: false, error: { message: error.message || 'Failed to search memories' } },
+      { status: 500 }
+    )
+  }
+})
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request)
+    if (!authResult.success || !authResult.userId) {
+      logger.warn(`[${requestId}] Unauthorized memory creation attempt`)
+      return NextResponse.json(
+        { success: false, error: { message: authResult.error || 'Authentication required' } },
+        { status: 401 }
+      )
+    }
+
+    const validation = await parseRequest(createMemoryContract, request, {})
+    if (!validation.success) return validation.response
+    const { key, data, workspaceId } = validation.data.body
+
+    if (!key) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Memory key is required' } },
+        { status: 400 }
+      )
+    }
+
+    if (!data) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Memory data is required' } },
+        { status: 400 }
+      )
+    }
+
+    if (!workspaceId) {
+      return NextResponse.json(
+        { success: false, error: { message: 'workspaceId is required' } },
+        { status: 400 }
+      )
+    }
+
+    const access = await checkWorkspaceAccess(workspaceId, authResult.userId)
+    if (!access.exists) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Workspace not found' } },
+        { status: 404 }
+      )
+    }
+    if (!access.hasAccess) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Access denied to this workspace' } },
+        { status: 403 }
+      )
+    }
+
+    if (!access.canWrite) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Write access denied to this workspace' } },
+        { status: 403 }
+      )
+    }
+
+    const dataToValidate = Array.isArray(data) ? data : [data]
+
+    for (const msg of dataToValidate) {
+      const parsedMessage = memoryMessageSchema.safeParse(msg)
+      if (!parsedMessage.success) {
+        const role =
+          msg && typeof msg === 'object' && 'role' in msg
+            ? (msg as { role?: unknown }).role
+            : undefined
+        const invalidRole = Boolean(role) && !['user', 'assistant', 'system'].includes(String(role))
+        return NextResponse.json(
+          {
+            success: false,
+            error: {
+              message: invalidRole
+                ? 'Message role must be user, assistant, or system'
+                : 'Memory requires messages with role and content',
+            },
+          },
+          { status: 400 }
+        )
+      }
+    }
+
+    const initialData = Array.isArray(data) ? data : [data]
+    const now = new Date()
+    const id = `mem_${generateId().replace(/-/g, '')}`
+
+    const { sql } = await import('drizzle-orm')
+
+    await db
+      .insert(memory)
+      .values({
+        id,
+        workspaceId,
+        key,
+        data: initialData,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: [memory.workspaceId, memory.key],
+        set: {
+          data: sql`${memory.data} || ${JSON.stringify(initialData)}::jsonb`,
+          updatedAt: now,
+        },
+      })
+
+    logger.info(`[${requestId}] Memory operation successful: ${key} for workspace: ${workspaceId}`)
+
+    const allMemories = await db
+      .select()
+      .from(memory)
+      .where(
+        and(eq(memory.key, key), eq(memory.workspaceId, workspaceId), isNull(memory.deletedAt))
+      )
+      .orderBy(memory.createdAt)
+
+    if (allMemories.length === 0) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Failed to retrieve memory after creation/update' } },
+        { status: 500 }
+      )
+    }
+
+    const memoryRecord = allMemories[0]
+
+    return NextResponse.json(
+      { success: true, data: { conversationId: memoryRecord.key, data: memoryRecord.data } },
+      { status: 200 }
+    )
+  } catch (error: any) {
+    if (getPostgresErrorCode(error) === '23505') {
+      return NextResponse.json(
+        { success: false, error: { message: 'Memory with this key already exists' } },
+        { status: 409 }
+      )
+    }
+
+    logger.error(`[${requestId}] Error creating memory`, { error })
+    return NextResponse.json(
+      { success: false, error: { message: 'Failed to create memory' } },
+      { status: 500 }
+    )
+  }
+})
+
+export const DELETE = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request)
+    if (!authResult.success || !authResult.userId) {
+      logger.warn(`[${requestId}] Unauthorized memory deletion attempt`)
+      return NextResponse.json(
+        { success: false, error: { message: authResult.error || 'Authentication required' } },
+        { status: 401 }
+      )
+    }
+
+    const validation = await parseRequest(deleteMemoryByQueryContract, request, {})
+    if (!validation.success) return validation.response
+    const { workspaceId, conversationId } = validation.data.query
+
+    if (!workspaceId) {
+      return NextResponse.json(
+        { success: false, error: { message: 'workspaceId parameter is required' } },
+        { status: 400 }
+      )
+    }
+
+    if (!conversationId) {
+      return NextResponse.json(
+        { success: false, error: { message: 'conversationId must be provided' } },
+        { status: 400 }
+      )
+    }
+
+    const access = await checkWorkspaceAccess(workspaceId, authResult.userId)
+    if (!access.exists) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Workspace not found' } },
+        { status: 404 }
+      )
+    }
+    if (!access.hasAccess) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Access denied to this workspace' } },
+        { status: 403 }
+      )
+    }
+
+    if (!access.canWrite) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Write access denied to this workspace' } },
+        { status: 403 }
+      )
+    }
+
+    const result = await db
+      .delete(memory)
+      .where(
+        and(
+          eq(memory.key, conversationId),
+          eq(memory.workspaceId, workspaceId),
+          isNull(memory.deletedAt)
+        )
+      )
+      .returning({ id: memory.id })
+
+    const deletedCount = result.length
+
+    logger.info(`[${requestId}] Deleted ${deletedCount} memories for workspace: ${workspaceId}`)
+    return NextResponse.json(
+      {
+        success: true,
+        data: {
+          message:
+            deletedCount > 0
+              ? `Successfully deleted ${deletedCount} memories`
+              : 'No memories found matching the criteria',
+          deletedCount,
+        },
+      },
+      { status: 200 }
+    )
+  } catch (error: any) {
+    logger.error(`[${requestId}] Error deleting memories`, { error })
+    return NextResponse.json(
+      { success: false, error: { message: error.message || 'Failed to delete memories' } },
+      { status: 500 }
+    )
+  }
+})