sea-dev 1.0.0

package/libs/dal/src/conversation.ts

@@ -0,0 +1,532 @@
+import { db, schema } from "@sea/db";
+import type { ChatModel } from "@sea/db/schema";
+import { memorySchema } from "@sea/db/schema";
+import type {
+  Context,
+  Conversation,
+  Message as DbMessage,
+  InsertMessage,
+  Member,
+} from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { type UIMessage } from "ai";
+import { and, asc, desc, eq, inArray, isNull } from "drizzle-orm";
+import type z from "zod/v4";
+import type { DalResult } from "./result";
+
+export async function getFormConversation({
+  member,
+  formId,
+}: {
+  member: Member;
+  formId: string;
+}): Promise<DalResult<{ conversationId: string }>> {
+  const form = await db.query.form.findFirst({
+    where: and(
+      eq(schema.form.organizationId, member.organizationId),
+      eq(schema.form.id, formId),
+      isNull(schema.form.deletedAt),
+    ),
+    columns: { conversationId: true },
+  });
+
+  if (!form?.conversationId) {
+    return { ok: false, error: "not-found" };
+  }
+
+  return { ok: true, data: { conversationId: form.conversationId } };
+}
+
+export async function getSubmissionConversation({
+  member,
+  submissionId,
+}: {
+  member: Member;
+  submissionId: string;
+}): Promise<DalResult<{ conversationId: string }>> {
+  const submission = await db.query.submission.findFirst({
+    where: and(
+      eq(schema.submission.organizationId, member.organizationId),
+      eq(schema.submission.id, submissionId),
+      isNull(schema.submission.deletedAt),
+    ),
+    columns: { conversationId: true },
+  });
+
+  if (!submission?.conversationId) {
+    return { ok: false, error: "not-found" };
+  }
+
+  return { ok: true, data: { conversationId: submission.conversationId } };
+}
+
+export async function persistMessages({
+  member,
+  conversationId,
+  messages,
+}: {
+  member: Member;
+  conversationId: string;
+  messages: UIMessage[];
+}) {
+  await db.transaction(async (tx) => {
+    const [conversation] = await tx
+      .update(schema.conversation)
+      .set({ updatedAt: new Date() })
+      .where(
+        and(
+          eq(schema.conversation.organizationId, member.organizationId),
+          eq(schema.conversation.id, conversationId),
+          isNull(schema.conversation.deletedAt),
+        ),
+      )
+      .returning();
+    // Validate auth access
+    invariant(conversation);
+    const msgs: InsertMessage[] = messages.map((m) => ({ ...m, conversationId }));
+
+    await tx.insert(schema.message).values(msgs).onConflictDoNothing();
+  });
+}
+
+export async function getConversation({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}): Promise<DalResult<Conversation & { messages: DbMessage[]; contexts: Context[] }>> {
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.id, conversationId),
+      isNull(schema.conversation.deletedAt),
+    ),
+    with: {
+      messages: {
+        orderBy: asc(schema.message.createdAt),
+      },
+      contexts: true,
+    },
+  });
+  if (!conversation) {
+    return { ok: false, error: "not-found" };
+  }
+
+  return { ok: true, data: conversation };
+}
+
+export async function eraseConversation({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}) {
+  // Check permission
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.id, conversationId),
+      isNull(schema.conversation.deletedAt),
+    ),
+  });
+  invariant(conversation);
+
+  await db.delete(schema.message).where(eq(schema.message.conversationId, conversation.id));
+}
+
+export async function setConversationModel({
+  member,
+  conversationId,
+  chatModel,
+}: {
+  member: Member;
+  conversationId: string;
+  chatModel: ChatModel;
+}) {
+  await db
+    .update(schema.conversation)
+    .set({
+      model: chatModel,
+    })
+    .where(
+      and(
+        eq(schema.conversation.organizationId, member.organizationId),
+        eq(schema.conversation.id, conversationId),
+        isNull(schema.conversation.deletedAt),
+      ),
+    );
+}
+
+export async function summarizeEraseConversation({
+  member,
+  conversationId,
+  summary,
+}: {
+  member: Member;
+  conversationId: string;
+  summary: string;
+}) {
+  // Check permission
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.id, conversationId),
+      isNull(schema.conversation.deletedAt),
+    ),
+    with: { messages: { orderBy: asc(schema.message.createdAt) } },
+  });
+  invariant(conversation);
+
+  await db.transaction(async (tx) => {
+    await tx.delete(schema.message).where(eq(schema.message.conversationId, conversation.id));
+    await tx.insert(schema.context).values({
+      conversationId: conversation.id,
+      content: summary,
+    });
+  });
+
+  return { summary };
+}
+
+export async function getAgentConversation({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}): Promise<DalResult<Conversation & { messages: DbMessage[] }>> {
+  const existingConversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.agent, true),
+      isNull(schema.conversation.deletedAt),
+    ),
+    with: {
+      messages: {
+        orderBy: asc(schema.message.createdAt),
+      },
+      contexts: true,
+    },
+  });
+
+  if (!existingConversation) {
+    return { ok: false, error: "not-found" };
+  }
+
+  return { ok: true, data: existingConversation };
+}
+
+export async function createAgentConversation({ member }: { member: Member }) {
+  const [newAgent] = await db
+    .insert(schema.conversation)
+    .values({
+      organizationId: member.organizationId,
+      name: "New Agent",
+      agent: true,
+      model: "openai/gpt-5.2",
+      memory: {},
+    })
+    .returning();
+  invariant(newAgent);
+
+  return newAgent;
+}
+
+export async function getAgentConversations({
+  member,
+  limit = 10,
+}: {
+  member: Member;
+  limit?: number;
+}) {
+  const conversations = await db.query.conversation.findMany({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.agent, true),
+      isNull(schema.conversation.deletedAt),
+    ),
+    orderBy: desc(schema.conversation.updatedAt),
+    limit,
+  });
+
+  return conversations;
+}
+
+type Memory = z.infer<typeof memorySchema>;
+
+function mergeById<T extends { id: string }>(entries: T[]): T[] {
+  const map = new Map(entries.map((entry) => [entry.id, entry]));
+  return [...map.values()];
+}
+
+function mergeMemoryObjects(obj1: Memory, obj2: Memory): Memory {
+  return {
+    dealIds: [...new Set([...obj1.dealIds, ...obj2.dealIds])],
+    submissionIds: [...new Set([...obj1.submissionIds, ...obj2.submissionIds])],
+    workflowIds: [...new Set([...obj1.workflowIds, ...obj2.workflowIds])],
+    formIds: [...new Set([...obj1.formIds, ...obj2.formIds])],
+    documentIds: [...new Set([...obj1.documentIds, ...obj2.documentIds])],
+    progress: mergeById([...obj1.progress, ...obj2.progress]),
+    artifacts: mergeById([...obj1.artifacts, ...obj2.artifacts]),
+  };
+}
+
+export async function addToAgentMemory({
+  member,
+  conversationId,
+  memory,
+}: {
+  member: Member;
+  conversationId: string;
+  memory: object;
+}) {
+  const conversation = await getAgentConversation({ member, conversationId });
+  if (!conversation.ok) {
+    return conversation;
+  }
+  const oldMemory = memorySchema.parse(conversation.data.memory);
+  const newMemory = memorySchema.parse(memory);
+  const merged = mergeMemoryObjects(oldMemory, newMemory);
+  await db
+    .update(schema.conversation)
+    .set({ memory: merged })
+    .where(
+      and(
+        eq(schema.conversation.organizationId, member.organizationId),
+        eq(schema.conversation.id, conversationId),
+        eq(schema.conversation.agent, true),
+        isNull(schema.conversation.deletedAt),
+      ),
+    );
+}
+
+export async function removeFromAgentMemory({
+  member,
+  conversationId,
+  itemType,
+  itemId,
+}: {
+  member: Member;
+  conversationId: string;
+  itemType: keyof Memory;
+  itemId: string;
+}) {
+  const conversation = await getAgentConversation({ member, conversationId });
+  if (!conversation.ok) {
+    return conversation;
+  }
+  const oldMemory = memorySchema.parse(conversation.data.memory);
+
+  const currentEntries = oldMemory[itemType];
+  const newMemory = {
+    ...oldMemory,
+    [itemType]:
+      itemType === "progress" || itemType === "artifacts"
+        ? currentEntries.filter((entry) => (entry as { id: string }).id !== itemId)
+        : currentEntries.filter((entry) => entry !== itemId),
+  };
+
+  await db
+    .update(schema.conversation)
+    .set({ memory: newMemory })
+    .where(
+      and(
+        eq(schema.conversation.organizationId, member.organizationId),
+        eq(schema.conversation.id, conversationId),
+        eq(schema.conversation.agent, true),
+        isNull(schema.conversation.deletedAt),
+      ),
+    );
+}
+
+export async function updateAgentConversation({
+  member,
+  conversationId,
+  name,
+  memory,
+}: {
+  member: Member;
+  conversationId: string;
+  name?: string;
+  memory?: object;
+}) {
+  await db
+    .update(schema.conversation)
+    .set({ name, memory })
+    .where(
+      and(
+        eq(schema.conversation.organizationId, member.organizationId),
+        eq(schema.conversation.id, conversationId),
+        eq(schema.conversation.agent, true),
+        isNull(schema.conversation.deletedAt),
+      ),
+    );
+}
+
+type RelevantItem = { id: string; name: string | null; updatedAt: Date };
+
+export async function getRelevantItems({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}): Promise<
+  DalResult<{
+    deals: RelevantItem[];
+    workflows: RelevantItem[];
+    forms: RelevantItem[];
+    submissions: RelevantItem[];
+    documents: RelevantItem[];
+  }>
+> {
+  // Get the agent conversation's memory to find relevant items
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.agent, true),
+      isNull(schema.conversation.deletedAt),
+    ),
+    columns: { memory: true },
+  });
+
+  if (!conversation) {
+    return { ok: false, error: "not-found" };
+  }
+
+  const { dealIds, workflowIds, formIds, submissionIds, documentIds } = memorySchema.parse(
+    conversation.memory,
+  );
+
+  const documents = await db
+    .select({
+      id: schema.document.id,
+      name: schema.document.name,
+      updatedAt: schema.document.updatedAt,
+    })
+    .from(schema.document)
+    .innerJoin(schema.deal, eq(schema.deal.id, schema.document.dealId))
+    .where(
+      and(
+        inArray(schema.document.id, documentIds),
+        eq(schema.deal.organizationId, member.organizationId),
+      ),
+    );
+
+  const [deals, workflows, forms, submissions] = await Promise.all([
+    db.query.deal.findMany({
+      where: and(
+        eq(schema.deal.organizationId, member.organizationId),
+        inArray(schema.deal.id, dealIds),
+      ),
+      columns: { id: true, name: true, updatedAt: true },
+      orderBy: desc(schema.deal.updatedAt),
+    }),
+    db.query.workflow.findMany({
+      where: and(
+        eq(schema.workflow.organizationId, member.organizationId),
+        inArray(schema.workflow.id, workflowIds),
+      ),
+      columns: { id: true, name: true, updatedAt: true },
+      orderBy: desc(schema.workflow.updatedAt),
+    }),
+    db.query.form.findMany({
+      where: and(
+        eq(schema.form.organizationId, member.organizationId),
+        inArray(schema.form.id, formIds),
+      ),
+      columns: { id: true, name: true, updatedAt: true },
+      orderBy: desc(schema.form.updatedAt),
+    }),
+    db.query.submission.findMany({
+      where: and(
+        eq(schema.submission.organizationId, member.organizationId),
+        inArray(schema.submission.id, submissionIds),
+        eq(schema.submission.type, "extraction"),
+      ),
+      columns: { id: true, name: true, updatedAt: true },
+      orderBy: desc(schema.submission.updatedAt),
+    }),
+  ]);
+
+  return {
+    ok: true,
+    data: {
+      deals,
+      workflows,
+      forms,
+      submissions,
+      documents,
+    },
+  };
+}
+
+export async function createConversationForPipeline({
+  member,
+  pipelineId,
+  pipelineName,
+}: {
+  member: Member;
+  pipelineId: string;
+  pipelineName: string;
+}): Promise<DalResult<{ conversationId: string }>> {
+  const result = await db.transaction(async (tx) => {
+    const [conversation] = await tx
+      .insert(schema.conversation)
+      .values({
+        organizationId: member.organizationId,
+        agent: true,
+        name: `Pipeline: ${pipelineName}`,
+        model: "openai/gpt-5.2",
+        memory: {},
+      })
+      .returning();
+    invariant(conversation);
+
+    // Link conversation to pipeline via conversation_resource
+    await tx.insert(schema.conversationResource).values({
+      conversationId: conversation.id,
+      resourceType: "pipeline",
+      resourceId: pipelineId,
+      source: "system",
+    });
+
+    return conversation;
+  });
+
+  return { ok: true, data: { conversationId: result.id } };
+}
+
+export async function findConversationResourceByPipeline({
+  member,
+  pipelineId,
+}: {
+  member: Member;
+  pipelineId: string;
+}): Promise<DalResult<{ conversationId: string } | null>> {
+  const existingResource = await db.query.conversationResource.findFirst({
+    where: and(
+      eq(schema.conversationResource.resourceType, "pipeline"),
+      eq(schema.conversationResource.resourceId, pipelineId),
+    ),
+    with: {
+      conversation: true,
+    },
+  });
+
+  if (existingResource?.conversation) {
+    // Verify conversation belongs to the same organization
+    if (existingResource.conversation.organizationId === member.organizationId) {
+      return {
+        ok: true,
+        data: { conversationId: existingResource.conversationId },
+      };
+    }
+  }
+
+  return { ok: true, data: null };
+}

package/libs/dal/src/deal.test.ts

@@ -0,0 +1,45 @@
+import { resetTestDb } from "@/_tests/mock-db"; // Must always be the first import
+
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { beforeEach, describe, expect, it } from "vitest";
+import { getDeals } from "./deal";
+
+describe("dbtest: getDeals", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents access to deals from other organizations", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create deals for both organizations
+    await db.insert(schema.deal).values([
+      { organizationId: org1!.id, name: "Deal 1 - Org 1" },
+      { organizationId: org1!.id, name: "Deal 2 - Org 1" },
+      { organizationId: org2!.id, name: "Deal 1 - Org 2" },
+      { organizationId: org2!.id, name: "Deal 2 - Org 2" },
+    ]);
+
+    // Create member for org1
+    const member: Member = {
+      id: "member-1",
+      organizationId: org1!.id,
+      userId: "user-1",
+      role: "member",
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    // Get deals - should only return org1 deals
+    const deals = await getDeals({ member });
+
+    expect(deals).toHaveLength(2);
+    expect(deals.every((d) => d.organizationId === org1!.id)).toBe(true);
+    expect(deals.every((d) => d.name.includes("Org 1"))).toBe(true);
+  });
+});

package/libs/dal/src/deal.ts

@@ -0,0 +1,87 @@
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { and, asc, desc, eq, isNull } from "drizzle-orm";
+
+export async function createDeal({
+  member,
+  name,
+  hint,
+  refId,
+  nameAutoGenerated = false,
+}: {
+  member: Member;
+  name: string;
+  hint?: string;
+  refId?: string;
+  nameAutoGenerated?: boolean;
+}) {
+  const [deal] = await db
+    .insert(schema.deal)
+    .values({
+      organizationId: member.organizationId,
+      name,
+      nameAutoGenerated,
+      hint: hint || null,
+      refId: refId || null,
+    })
+    .onConflictDoNothing()
+    .returning();
+  return deal;
+}
+
+export async function getDeals({ member, limit }: { member: Member; limit?: number }) {
+  const deals = await db.query.deal.findMany({
+    where: and(
+      eq(schema.deal.organizationId, member.organizationId),
+      isNull(schema.deal.deletedAt),
+    ),
+    with: {
+      organization: true,
+      submissions: {
+        where: isNull(schema.submission.deletedAt),
+        orderBy: asc(schema.submission.createdAt),
+      },
+    },
+    orderBy: desc(schema.deal.createdAt),
+    limit,
+  });
+  return deals;
+}
+
+export async function getDealByRefId({ member, dealRefId }: { member: Member; dealRefId: string }) {
+  const deal = await db.query.deal.findFirst({
+    where: and(
+      eq(schema.deal.organizationId, member.organizationId),
+      eq(schema.deal.refId, dealRefId),
+    ),
+  });
+  return deal;
+}
+
+export async function updateDeal({
+  member,
+  dealId,
+  name,
+  hint,
+  refId,
+}: {
+  member: Member;
+  dealId: string;
+  name?: string;
+  hint?: string;
+  refId?: string;
+}) {
+  const updateData: { name?: string; hint?: string; refId?: string; nameAutoGenerated?: boolean } =
+    {};
+  if (name !== undefined) {
+    updateData.name = name;
+    updateData.nameAutoGenerated = false;
+  }
+  if (hint !== undefined) updateData.hint = hint;
+  if (refId !== undefined) updateData.refId = refId;
+
+  await db
+    .update(schema.deal)
+    .set(updateData)
+    .where(and(eq(schema.deal.id, dealId), eq(schema.deal.organizationId, member.organizationId)));
+}

package/libs/dal/src/defaults-consumer-lending-uk.ts

@@ -0,0 +1,33 @@
+import type { DenormWorkflow } from "./defaults-types";
+
+// TODO: Extract consumer lending UK forms from original defaults.ts
+// Forms needed:
+// - Credit Application
+// - Personal Financial Statement
+// - Employment Verification
+// - Bank Statement
+// - Personal Credit Report
+// - Security & Collateral
+
+export const defaultWorkflows: DenormWorkflow[] = [
+  {
+    name: "Origination",
+    slug: "origination",
+    hint: "Extract applicant details, loan amounts, business information, contact data",
+    forms: [
+      // TODO: Add Credit Application form
+      // TODO: Add Personal Financial Statement form
+      // TODO: Add Employment Verification form
+      // TODO: Add Bank Statement form
+    ],
+  },
+  {
+    name: "Underwriting",
+    slug: "underwriting",
+    hint: "Extract financial statements, credit scores, collateral, risk assessments",
+    forms: [
+      // TODO: Add Personal Credit Report form
+      // TODO: Add Security & Collateral form
+    ],
+  },
+];