context-efficient-ai/pages/chat/conversations.ts

import {
  router,
  publicProcedure,
  createCallerFactory,
} from "../../trpc/server";
import type { CommittedMessage } from "../../types.js";
import { db } from "../../database/lowdb";
import { nanoid } from "nanoid";

export const conversations = router({
  fetchAll: publicProcedure.query(async () => {
    const rows = await db.data.conversations;
    return rows;
  }),
  fetchOne: publicProcedure
    .input((x) => x as { id: string })
    .query(async ({ input: { id } }) => {
      const row = await db.data.conversations.find((c) => c.id === id);
      return row;
    }),
  start: publicProcedure.mutation(async () => {
    const title = "New Conversation";
    const row = {
      id: nanoid(),
      title,
      userId: "1",
    };
    await db.data.conversations.push(row);
    db.write();
    return row;
  }),
  deleteOne: publicProcedure
    .input((x) => x as { id: string })
    .mutation(async ({ input: { id } }) => {
      db.data.conversations.splice(
        db.data.conversations.findIndex((c) => c.id === id),
        1
      );
      const deletedMessageIds = db.data.messages
        .filter((m) => m.conversationId === id)
        .map((m) => m.id);
      db.data.messages = db.data.messages.filter(
        (m) => m.conversationId !== id
      );
      const deletedFactIds = db.data.facts
        .filter((fact) => deletedMessageIds.includes(fact.sourceMessageId))
        .map((fact) => fact.id);
      db.data.facts = db.data.facts.filter(
        (fact) => !deletedFactIds.includes(fact.id)
      );
      db.data.factTriggers = db.data.factTriggers.filter(
        (factTrigger) => !deletedFactIds.includes(factTrigger.sourceFactId)
      );
      db.write();
      return { ok: true };
    }),
  updateTitle: publicProcedure
    .input(
      (x) =>
        x as {
          id: string;
          title: string;
        }
    )
    .mutation(async ({ input: { id, title } }) => {
      const conversation = await db.data.conversations.find((c) => c.id === id);
      if (!conversation) throw new Error("Conversation not found");
      conversation.title = title;
      db.write();
      return { ok: true };
    }),
  fetchMessages: publicProcedure
    .input((x) => x as { conversationId: string })
    .query(async ({ input: { conversationId } }) => {
      const rows = await db.data.messages.filter(
        (m) => m.conversationId === conversationId
      );
      return rows as Array<CommittedMessage>;
    }),
});

export const createCaller = createCallerFactory(conversations);