sea-dev 1.0.0

package/libs/dal/src/report.ts

@@ -0,0 +1,199 @@
+import { db, schema } from "@sea/db";
+import type { ReportParams } from "@sea/db/schema";
+import type { Member, Report } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { and, asc, desc, eq, inArray, isNull } from "drizzle-orm";
+import type { DalResult } from "./result";
+import type { DenormTable } from "./submission";
+
+export type ReportEntryRow = Awaited<ReturnType<typeof getReportData>>["data"][number];
+
+export async function getReportData({ member, reportId }: { member: Member; reportId: string }) {
+  const report = await db.query.report.findFirst({
+    where: and(
+      eq(schema.report.organizationId, member.organizationId),
+      eq(schema.report.id, reportId),
+    ),
+    with: {
+      conversation: {
+        with: { messages: { orderBy: asc(schema.message.createdAt) } },
+      },
+      form: { with: { groups: { with: { fields: true, derived: true } } } },
+      deal: true,
+    },
+  });
+  invariant(report);
+  invariant(report.form);
+  invariant(report.deal);
+
+  const targetDealIds = [report.deal.id, ...(report.params?.dealIds ?? [])];
+
+  // we just pick the first one i guess...
+  const statusFilter = report.params?.status ?? "latest";
+  const submissions = await db.query.submission.findMany({
+    where: and(
+      eq(schema.submission.organizationId, member.organizationId),
+      eq(schema.submission.formId, report.form.id),
+      inArray(schema.submission.dealId, targetDealIds),
+      isNull(schema.submission.deletedAt),
+      statusFilter !== "all" && statusFilter !== "latest"
+        ? eq(schema.submission.status, statusFilter)
+        : undefined,
+    ),
+    with: {
+      deal: true,
+      groups: {
+        orderBy: asc(schema.submissionGroup.order),
+        with: {
+          formGroup: true,
+          items: {
+            with: {
+              formField: true,
+              versions: {
+                orderBy: [
+                  desc(schema.submissionItemVersion.selected),
+                  desc(schema.submissionItemVersion.updatedAt),
+                ],
+                limit: 1,
+              },
+            },
+          },
+          derived: { with: { formDerived: true } },
+        },
+      },
+    },
+    orderBy: desc(schema.submission.updatedAt),
+    limit: 10, // TODO: pagination
+  });
+
+  const data = submissions.flatMap((submission) => {
+    const denorm = {
+      id: submission.id,
+      name: submission.name,
+      summary: submission.summary,
+      formName: report.form.name,
+      hint: report.form.hint,
+      groups: submission.groups.map((group) => ({
+        id: group.id,
+        formGroupId: group.formGroup.id,
+        name: group.formGroup.name,
+        multi: group.formGroup.multi,
+        hint: group.formGroup.hint,
+        order: group.formGroup.order,
+        items: group.items
+          .map((item) => ({
+            id: item.id,
+            name: item.formField.name,
+            type: item.formField.type,
+            hint: item.formField.hint,
+            order: item.formField.order,
+            value: item.versions.at(0)?.value ?? null,
+          }))
+          .sort((a, b) => a.order - b.order),
+        derived: group.derived.map((item) => ({
+          id: item.id,
+          name: item.formDerived.name,
+          prompt: item.formDerived.prompt,
+          value: item.value,
+        })),
+      })),
+    };
+
+    const processedDenorm = {
+      ...denorm,
+      groups: denorm.groups.filter((g) => !g.multi).sort((a, b) => a.order - b.order),
+      tables: denorm.groups
+        .filter((g) => g.multi === true)
+        .sort((a, b) => a.order - b.order)
+        .reduce((acc, group) => {
+          const existing = acc.find((t) => t.formGroupId === group.formGroupId);
+          if (existing) {
+            existing.rows.push({ items: group.items, derived: group.derived });
+          } else {
+            acc.push({
+              ...group,
+              columns: [...group.items.map((i) => i.name), ...group.derived.map((d) => d.name)],
+              rows: [{ items: group.items, derived: group.derived }],
+            });
+          }
+          return acc;
+        }, [] as DenormTable[]),
+    };
+
+    return {
+      dealId: submission.dealId,
+      dealName: submission.deal.name,
+      status: submission.status,
+      updatedAt: submission.updatedAt,
+      ...processedDenorm,
+    };
+  });
+
+  return { report, data };
+}
+
+export async function createReport({
+  member,
+  dealId,
+  formId,
+  params,
+}: {
+  member: Member;
+  dealId: string;
+  formId: string;
+  params?: ReportParams;
+}): Promise<DalResult<{ report: Report }>> {
+  const deal = await db.query.deal.findFirst({
+    where: and(
+      eq(schema.deal.organizationId, member.organizationId),
+      eq(schema.deal.id, dealId),
+      isNull(schema.deal.deletedAt),
+    ),
+    columns: { id: true },
+  });
+  if (!deal) {
+    return { ok: false, error: "not-found" };
+  }
+
+  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: { id: true },
+  });
+  if (!form) {
+    return { ok: false, error: "not-found" };
+  }
+
+  // Create conversation and report in a transaction
+  const result = await db.transaction(async (tx) => {
+    const [conversation] = await tx
+      .insert(schema.conversation)
+      .values({
+        organizationId: member.organizationId,
+        name: "Report Chat",
+        model: "openai/gpt-5.2",
+        memory: {},
+      })
+      .returning();
+    invariant(conversation);
+
+    const [report] = await tx
+      .insert(schema.report)
+      .values({
+        organizationId: member.organizationId,
+        conversationId: conversation.id,
+        dealId,
+        formId,
+        params,
+      })
+      .returning();
+    invariant(report);
+
+    return { report: report };
+  });
+
+  return { ok: true, data: result };
+}

package/libs/dal/src/result.ts

@@ -0,0 +1,16 @@
+export type DalResult<T> =
+  | { ok: true; data: T }
+  | { ok: false; data?: never; error: "not-found" }
+  | { ok: false; data?: never; error: "validation-error"; message?: string }
+  | { ok: false; data?: never; error: "internal-error" };
+
+export const notFoundResult = { ok: false, error: "not-found" } as const;
+export const internalErrorResult = { ok: false, error: "internal-error" } as const;
+
+export function okResult<T>(data: T): DalResult<T> {
+  return { ok: true, data };
+}
+
+export function validationErrorResult(message?: string): DalResult<never> {
+  return { ok: false, error: "validation-error", message };
+}

package/libs/dal/src/search.ts

@@ -0,0 +1,172 @@
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { and, eq, isNull, type SQL, sql } from "drizzle-orm";
+
+const RESULTS_PER_SOURCE = 5;
+const RESULTS_TOTAL = 15;
+
+export async function searchAll({ member, query }: { member: Member; query: string }) {
+  if (query.length === 0) {
+    return [];
+  }
+
+  const searchTerms = queryToSearchTerms(query);
+  const tsQuery = sql`to_tsquery('english', ${searchTerms})`;
+
+  const deals = await searchDeals({ member, tsQuery });
+  const workflows = await searchWorkflows({ member, tsQuery });
+  const forms = await searchForms({ member, tsQuery });
+  // TODO: add back submissions once we figure out indexing
+  // const submissions = await searchSubmissions({ member, tsQuery });
+
+  const results = [...deals, ...workflows, ...forms]
+    .sort((a, b) => b.rank - a.rank)
+    .slice(0, RESULTS_TOTAL);
+
+  return results;
+}
+
+async function searchDeals({ member, tsQuery }: { member: Member; tsQuery: SQL<unknown> }) {
+  const searchVector = sql`
+    setweight(to_tsvector('english', coalesce(${schema.deal.name}, '')), 'A')
+  `;
+
+  const deals = await db
+    .selectDistinctOn([schema.deal.id], {
+      id: schema.deal.id,
+      type: sql<string>`'deal'`,
+      name: schema.deal.name,
+      rank: sql<number>`ts_rank(${searchVector}, ${tsQuery})`,
+    })
+    .from(schema.deal)
+    .where(
+      and(
+        eq(schema.deal.organizationId, member.organizationId),
+        isNull(schema.deal.deletedAt),
+        sql`${searchVector} @@ ${tsQuery}`,
+      ),
+    )
+    .orderBy(schema.deal.id, sql`ts_rank(${searchVector}, ${tsQuery}) DESC`)
+    .limit(RESULTS_PER_SOURCE);
+
+  return deals;
+}
+
+async function searchWorkflows({ member, tsQuery }: { member: Member; tsQuery: SQL<unknown> }) {
+  const searchVector = sql`
+    setweight(to_tsvector('english', coalesce(${schema.workflow.name}, '')), 'A')
+  `;
+
+  const workflows = await db
+    .selectDistinctOn([schema.workflow.id], {
+      id: schema.workflow.id,
+      type: sql<string>`'workflow'`,
+      name: schema.workflow.name,
+      rank: sql<number>`ts_rank(${searchVector}, ${tsQuery})`,
+    })
+    .from(schema.workflow)
+    .where(
+      and(
+        eq(schema.workflow.organizationId, member.organizationId),
+        isNull(schema.workflow.deletedAt),
+        sql`${searchVector} @@ ${tsQuery}`,
+      ),
+    )
+    .orderBy(schema.workflow.id, sql`ts_rank(${searchVector}, ${tsQuery}) DESC`)
+    .limit(RESULTS_PER_SOURCE);
+
+  return workflows;
+}
+
+async function searchForms({ member, tsQuery }: { member: Member; tsQuery: SQL<unknown> }) {
+  const searchVector = sql`
+    setweight(to_tsvector('english', coalesce(${schema.form.name}, '')), 'A') ||
+    setweight(to_tsvector('english', coalesce(${schema.formGroup.name}, '')), 'B') ||
+    setweight(to_tsvector('english', coalesce(${schema.formField.name}, '')), 'C')
+  `;
+
+  const forms = await db
+    .selectDistinctOn([schema.form.id], {
+      id: schema.form.id,
+      type: sql<string>`'form'`,
+      name: schema.form.name,
+      rank: sql<number>`ts_rank(${searchVector}, ${tsQuery})`,
+    })
+    .from(schema.form)
+    .leftJoin(schema.formGroup, eq(schema.formGroup.formId, schema.form.id))
+    .leftJoin(schema.formField, eq(schema.formField.formGroupId, schema.formGroup.id))
+    .where(
+      and(
+        eq(schema.form.organizationId, member.organizationId),
+        isNull(schema.form.deletedAt),
+        sql`${searchVector} @@ ${tsQuery}`,
+      ),
+    )
+    .orderBy(schema.form.id, sql`ts_rank(${searchVector}, ${tsQuery}) DESC`)
+    .limit(RESULTS_PER_SOURCE);
+
+  return forms;
+}
+
+async function searchSubmissions({ member, tsQuery }: { member: Member; tsQuery: SQL<unknown> }) {
+  const searchVector = sql`
+    setweight(to_tsvector('english', coalesce(${schema.form.name}, '')), 'A') ||
+    setweight(to_tsvector('english', coalesce(${schema.formGroup.name}, '')), 'B') ||
+    setweight(to_tsvector('english', coalesce(${schema.formField.name}, '')), 'C') ||
+    setweight(to_tsvector('english', coalesce(${schema.submissionItemVersion.value}::text, '')), 'A')
+  `;
+
+  const submissions = await db
+    .selectDistinctOn([schema.submission.id], {
+      id: schema.submission.id,
+      type: sql<string>`'submission'`,
+      name: sql<string>`'Submission ' || substr(${schema.submission.id}, 1, 4)`,
+      rank: sql<number>`ts_rank(${searchVector}, ${tsQuery})`,
+    })
+    .from(schema.submission)
+    .leftJoin(schema.submissionGroup, eq(schema.submissionGroup.submissionId, schema.submission.id))
+    .leftJoin(
+      schema.submissionItem,
+      eq(schema.submissionItem.submissionGroupId, schema.submissionGroup.id),
+    )
+
+    .leftJoin(
+      schema.submissionItemVersion,
+      and(
+        eq(schema.submissionItemVersion.submissionItemId, schema.submissionItem.id),
+        sql`${schema.submissionItemVersion.id} = (
+        SELECT ${schema.submissionItemVersion.id}
+        FROM ${schema.submissionItemVersion} siv
+        WHERE siv.submission_item_id = ${schema.submissionItem.id}
+        ORDER BY siv.selected DESC, siv.updated_at DESC
+        LIMIT 1
+      )`,
+      ),
+    )
+
+    .leftJoin(schema.form, eq(schema.form.id, schema.submission.formId))
+    .leftJoin(schema.formGroup, eq(schema.formGroup.formId, schema.form.id))
+    .leftJoin(schema.formField, eq(schema.formField.formGroupId, schema.formGroup.id))
+    .where(
+      and(
+        eq(schema.form.organizationId, member.organizationId),
+        isNull(schema.form.deletedAt),
+        sql`${searchVector} @@ ${tsQuery}`,
+      ),
+    )
+    .orderBy(schema.submission.id, sql`ts_rank(${searchVector}, ${tsQuery}) DESC`)
+    .limit(RESULTS_PER_SOURCE);
+
+  return submissions;
+}
+
+function queryToSearchTerms(query: string): string {
+  const searchTerms = query
+    .trim()
+    .replace(/[&|!:*()]/g, "")
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((term) => `${term}:*`)
+    .join(" & ");
+  return searchTerms;
+}

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

@@ -0,0 +1,110 @@
+import { resetTestDb } from "@/_tests/mock-db"; // Must always be the first import
+
+import { db, schema } from "@sea/db";
+import { beforeEach, describe, expect, it } from "vitest";
+import { switchOrganization } from "./session";
+
+describe("dbtest: switchOrganization", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents cross-organization access by only allowing users to switch to organizations they are members of", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create users
+    const [user1, user2] = await db
+      .insert(schema.user)
+      .values([
+        { name: "User 1", email: "user1-session@example.com", emailVerified: true },
+        { name: "User 2", email: "user2-session@example.com", emailVerified: true },
+      ])
+      .returning();
+
+    // Create members: user1 in org1, user2 in org2
+    const [member1, _member2] = await db
+      .insert(schema.member)
+      .values([
+        { organizationId: org1!.id, userId: user1!.id, role: "admin" },
+        { organizationId: org2!.id, userId: user2!.id, role: "admin" },
+      ])
+      .returning();
+
+    // Create sessions for both users
+    const [session1, session2] = await db
+      .insert(schema.session)
+      .values([
+        {
+          token: "session-token-1",
+          userId: user1!.id,
+          expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+          activeOrganizationId: org1!.id,
+        },
+        {
+          token: "session-token-2",
+          userId: user2!.id,
+          expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+          activeOrganizationId: org2!.id,
+        },
+      ])
+      .returning();
+
+    // Test 1: user1 tries to switch to org2 (where they are not a member) - should fail
+    await expect(
+      switchOrganization({
+        session: session1!,
+        member: member1!,
+        organizationId: org2!.id,
+      }),
+    ).rejects.toThrow("Invariant failed");
+
+    // Verify session1's active organization was not changed
+    const unchangedSession = await db.query.session.findFirst({
+      where: (table, { eq }) => eq(table.id, session1!.id),
+    });
+    expect(unchangedSession!.activeOrganizationId).toBe(org1!.id);
+
+    // Test 2: user1 switches to org1 (where they are a member) - should succeed
+    await switchOrganization({
+      session: session1!,
+      member: member1!,
+      organizationId: org1!.id,
+    });
+
+    // Verify session1's active organization remains org1
+    const validSession = await db.query.session.findFirst({
+      where: (table, { eq }) => eq(table.id, session1!.id),
+    });
+    expect(validSession!.activeOrganizationId).toBe(org1!.id);
+
+    // Test 3: Add user1 to org2 as well, then they should be able to switch
+    await db.insert(schema.member).values({
+      organizationId: org2!.id,
+      userId: user1!.id,
+      role: "member",
+    });
+
+    // Now user1 should be able to switch to org2
+    await switchOrganization({
+      session: session1!,
+      member: member1!,
+      organizationId: org2!.id,
+    });
+
+    // Verify session1's active organization was changed to org2
+    const switchedSession = await db.query.session.findFirst({
+      where: (table, { eq }) => eq(table.id, session1!.id),
+    });
+    expect(switchedSession!.activeOrganizationId).toBe(org2!.id);
+
+    // Test 4: Verify the function only updates the correct session
+    const otherSession = await db.query.session.findFirst({
+      where: (table, { eq }) => eq(table.id, session2!.id),
+    });
+    expect(otherSession!.activeOrganizationId).toBe(org2!.id); // Should remain unchanged
+  });
+});

package/libs/dal/src/session.ts

@@ -0,0 +1,31 @@
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import type { Session } from "better-auth";
+import { and, eq } from "drizzle-orm";
+
+export async function switchOrganization({
+  session,
+  member,
+  organizationId,
+}: {
+  session: Session;
+  member: Member;
+  organizationId: string;
+}) {
+  // Validate that the user is a member of the target org
+  const targetMember = await db.query.member.findFirst({
+    where: and(
+      eq(schema.member.organizationId, organizationId),
+      eq(schema.member.userId, member.userId),
+    ),
+  });
+  invariant(targetMember);
+
+  await db
+    .update(schema.session)
+    .set({
+      activeOrganizationId: organizationId,
+    })
+    .where(and(eq(schema.session.userId, member.userId), eq(schema.session.id, session.id)));
+}