Database queries

export async function getUser(email: string): Promise<User[]>

export async function createUser(email: string, password: string)

export async function createGuestUser()

export async function saveChat({
  id,
  userId,
  title,
  visibility,
}: {
  id: string;
  userId: string;
  title: string;
  visibility: VisibilityType;
})

export async function getChatById({ id }: { id: string })

export async function getChatsByUserId({
  id,
  limit,
  startingAfter,
  endingBefore,
}: {
  id: string;
  limit: number;
  startingAfter: string | null;
  endingBefore: string | null;
})

const extendedLimit = limit + 1;

if (startingAfter) {
  // Get chats created after the specified chat
  filteredChats = await query(gt(chat.createdAt, selectedChat.createdAt));
} else if (endingBefore) {
  // Get chats created before the specified chat
  filteredChats = await query(lt(chat.createdAt, selectedChat.createdAt));
} else {
  // Get first page
  filteredChats = await query();
}

const hasMore = filteredChats.length > limit;
return {
  chats: hasMore ? filteredChats.slice(0, limit) : filteredChats,
  hasMore,
};

export async function deleteChatById({ id }: { id: string })

export async function deleteAllChatsByUserId({ userId }: { userId: string })

export async function updateChatTitleById({
  chatId,
  title,
}: {
  chatId: string;
  title: string;
})

export async function updateChatVisibilityById({
  chatId,
  visibility,
}: {
  chatId: string;
  visibility: "private" | "public";
})

export async function saveMessages({ messages }: { messages: DBMessage[] })

{
  id: string;           // UUID
  chatId: string;       // Chat UUID
  role: string;         // "user" | "assistant" | "system"
  parts: any[];         // Array of message parts
  attachments: any[];   // Array of attachments
  createdAt: Date;      // Timestamp
}

export async function getMessagesByChatId({ id }: { id: string })

export async function getMessageById({ id }: { id: string })

export async function updateMessage({
  id,
  parts,
}: {
  id: string;
  parts: DBMessage["parts"];
})

export async function deleteMessagesByChatIdAfterTimestamp({
  chatId,
  timestamp,
}: {
  chatId: string;
  timestamp: Date;
})

export async function getMessageCountByUserId({
  id,
  differenceInHours,
}: {
  id: string;
  differenceInHours: number;
})

export async function voteMessage({
  chatId,
  messageId,
  type,
}: {
  chatId: string;
  messageId: string;
  type: "up" | "down";
})

export async function getVotesByChatId({ id }: { id: string })

export async function saveDocument({
  id,
  title,
  kind,
  content,
  userId,
}: {
  id: string;
  title: string;
  kind: ArtifactKind;
  content: string;
  userId: string;
})

export async function getDocumentsById({ id }: { id: string })

export async function getDocumentById({ id }: { id: string })

export async function deleteDocumentsByIdAfterTimestamp({
  id,
  timestamp,
}: {
  id: string;
  timestamp: Date;
})

export async function saveSuggestions({
  suggestions,
}: {
  suggestions: Suggestion[];
})

{
  id: string;                    // UUID
  documentId: string;            // Document UUID
  documentCreatedAt: Date;       // Document version timestamp
  originalText: string;          // Text to replace
  suggestedText: string;         // Replacement text
  description: string | null;    // Optional description
  isResolved: boolean;           // Resolution status
  userId: string;                // Owner user ID
  createdAt: Date;               // Creation timestamp
}

export async function getSuggestionsByDocumentId({
  documentId,
}: {
  documentId: string;
})

export async function createStreamId({
  streamId,
  chatId,
}: {
  streamId: string;
  chatId: string;
})

export async function getStreamIdsByChatId({ chatId }: { chatId: string })

try {
  // Database operation
} catch (_error) {
  throw new ChatbotError(
    "bad_request:database",
    "Failed to {operation description}"
  );
}

const client = postgres(process.env.POSTGRES_URL!);
const db = drizzle(client);