sea-dev 1.0.0

package/libs/dal/src/document.ts

@@ -0,0 +1,192 @@
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import type { DocumentInsert } from "@sea/schemas";
+import { invariant } from "@sea/util/invariant";
+import { and, eq, getTableColumns, inArray, isNull } from "drizzle-orm";
+
+export async function getDocument({ member, documentId }: { member: Member; documentId: string }) {
+  const [document] = await db
+    .select({ ...getTableColumns(schema.document) })
+    .from(schema.document)
+    .innerJoin(schema.deal, eq(schema.deal.id, schema.document.dealId))
+    .where(
+      and(
+        eq(schema.document.id, documentId),
+        eq(schema.deal.organizationId, member.organizationId),
+        isNull(schema.document.deletedAt),
+      ),
+    );
+  invariant(document);
+  return document;
+}
+
+export async function createDocument({ member, data }: { member: Member; data: DocumentInsert }) {
+  // Verify deal belongs to organization
+  const deal = await db.query.deal.findFirst({
+    where: and(
+      eq(schema.deal.id, data.dealId),
+      eq(schema.deal.organizationId, member.organizationId),
+    ),
+  });
+  invariant(deal);
+
+  const [document] = await db.insert(schema.document).values(data).returning();
+  invariant(document);
+
+  return document;
+}
+
+export async function getDocumentExtraction({
+  member,
+  documentExtractionId,
+}: {
+  member: Member;
+  documentExtractionId: string;
+}) {
+  const [extraction] = await db
+    .select({
+      ...getTableColumns(schema.documentExtraction),
+      document: { ...getTableColumns(schema.document) },
+    })
+    .from(schema.documentExtraction)
+    .innerJoin(schema.submission, eq(schema.submission.id, schema.documentExtraction.submissionId))
+    .innerJoin(schema.document, eq(schema.document.id, schema.documentExtraction.documentId))
+    .where(
+      and(
+        eq(schema.documentExtraction.id, documentExtractionId),
+        eq(schema.submission.organizationId, member.organizationId),
+        isNull(schema.documentExtraction.deletedAt),
+      ),
+    );
+  invariant(extraction);
+
+  return extraction;
+}
+
+export async function getCitationsByIds({
+  member,
+  citationIds,
+}: {
+  member: Member;
+  citationIds: string[];
+}) {
+  if (citationIds.length === 0) {
+    return [];
+  }
+
+  const citations = await db.query.documentCitation.findMany({
+    where: inArray(schema.documentCitation.id, citationIds),
+    with: {
+      extraction: {
+        with: {
+          document: true,
+          submission: {
+            columns: { id: true, organizationId: true },
+          },
+        },
+      },
+    },
+  });
+
+  // Filter to only return citations that belong to the member's organization
+  const filteredCitations = citations.filter(
+    (citation) => citation.extraction.submission.organizationId === member.organizationId,
+  );
+
+  return filteredCitations;
+}
+
+/**
+ * Create a document with extraction in a transaction
+ */
+export async function createDocumentWithExtraction({
+  member,
+  documentId,
+  dealId,
+  submissionId,
+  name,
+  contentType,
+  storageProvider,
+  displayType,
+  blobKey,
+  extractionModel,
+}: {
+  member: Member;
+  documentId: string;
+  dealId: string;
+  submissionId: string;
+  name: string;
+  contentType: string;
+  storageProvider: "azure" | "gcp";
+  displayType: string;
+  blobKey: string;
+  extractionModel: string;
+}) {
+  const result = await db.transaction(async (tx) => {
+    const [insertedDocument] = await tx
+      .insert(schema.document)
+      .values({
+        id: documentId,
+        dealId,
+        name,
+        contentType,
+        storageProvider,
+        displayType,
+        blobKey,
+      })
+      .returning();
+    invariant(insertedDocument);
+
+    const [documentExtraction] = await tx
+      .insert(schema.documentExtraction)
+      .values({
+        documentId: insertedDocument.id,
+        submissionId,
+        status: "pending",
+        extractionModel,
+      })
+      .returning({ id: schema.documentExtraction.id });
+    invariant(documentExtraction);
+
+    return {
+      documentId: insertedDocument.id,
+      extractionId: documentExtraction.id,
+      blobKey,
+    };
+  });
+
+  return result;
+}
+
+/**
+ * Update document after upload
+ */
+export async function updateDocumentAfterUpload({
+  member,
+  documentId,
+  blobUrl,
+  blobUrlExpiry,
+}: {
+  member: Member;
+  documentId: string;
+  blobUrl: string;
+  blobUrlExpiry: Date;
+}): Promise<void> {
+  // Verify document belongs to organization via deal
+  const document = await db.query.document.findFirst({
+    where: eq(schema.document.id, documentId),
+    with: {
+      deal: {
+        columns: { organizationId: true },
+      },
+    },
+  });
+
+  invariant(document);
+  invariant(document.deal.organizationId === member.organizationId);
+
+  await db
+    .update(schema.document)
+    .set({ uploaded: true, blobUrl, blobUrlExpiry })
+    .where(eq(schema.document.id, documentId));
+}

package/libs/dal/src/feedback.ts

@@ -0,0 +1,255 @@
+import { db, schema } from "@sea/db";
+import type { SubmissionItemValue } from "@sea/db/schema";
+import type { Member } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { and, desc, eq, inArray } from "drizzle-orm";
+
+export async function createCorrection({
+  member,
+  submissionItemId,
+  extractedValue,
+  correctedValue,
+  feedback,
+  onCacheInvalidate,
+}: {
+  member: Member;
+  submissionItemId: string;
+  extractedValue: SubmissionItemValue | null;
+  correctedValue: SubmissionItemValue | null;
+  feedback?: string | null;
+  onCacheInvalidate?: (organizationId: string) => void;
+}) {
+  // Normalize correctedValue once for consistent checks and storage
+  const normalizedCorrectedValue: SubmissionItemValue | null =
+    typeof correctedValue === "string" ? correctedValue.trim() : correctedValue;
+
+  const correction = await db.transaction(async (tx) => {
+    // Verify the submission item belongs to the member's organization
+    const [submissionItem] = await tx
+      .select({ id: schema.submissionItem.id })
+      .from(schema.submissionItem)
+      .leftJoin(
+        schema.submissionGroup,
+        eq(schema.submissionGroup.id, schema.submissionItem.submissionGroupId),
+      )
+      .leftJoin(schema.submission, eq(schema.submission.id, schema.submissionGroup.submissionId))
+      .where(
+        and(
+          eq(schema.submissionItem.id, submissionItemId),
+          eq(schema.submission.organizationId, member.organizationId),
+        ),
+      );
+    invariant(submissionItem, `Submission item ${submissionItemId} not found or access denied`);
+
+    const [correction] = await tx
+      .insert(schema.fieldCorrection)
+      .values({
+        organizationId: member.organizationId,
+        submissionItemId,
+        extractedValue,
+        correctedValue: normalizedCorrectedValue,
+        feedback,
+      })
+      .returning();
+    invariant(correction);
+
+    const isMeaningfulValue = (v: SubmissionItemValue | null): v is SubmissionItemValue => {
+      if (v === null) return false;
+      if (typeof v === "string") return v.trim().length > 0;
+      if (typeof v === "number") return Number.isFinite(v);
+      return false;
+    };
+
+    if (isMeaningfulValue(normalizedCorrectedValue)) {
+      await tx
+        .update(schema.submissionItemVersion)
+        .set({ selected: false })
+        .where(eq(schema.submissionItemVersion.submissionItemId, submissionItemId));
+      await tx.insert(schema.submissionItemVersion).values({
+        sourceType: "manual",
+        submissionItemId,
+        value: normalizedCorrectedValue,
+        selected: true,
+      });
+    }
+
+    return correction;
+  });
+
+  onCacheInvalidate?.(member.organizationId);
+
+  return correction;
+}
+
+export async function listCorrections({ member, limit = 50 }: { member: Member; limit?: number }) {
+  const corrections = await db.query.fieldCorrection.findMany({
+    with: {
+      submissionItem: {
+        with: {
+          formField: {
+            with: {
+              group: {
+                with: {
+                  form: {
+                    with: {
+                      workflow: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    where: eq(schema.fieldCorrection.organizationId, member.organizationId),
+    orderBy: desc(schema.fieldCorrection.createdAt),
+    limit,
+  });
+  return corrections;
+}
+
+export async function markAddressed({
+  member,
+  correctionId,
+}: {
+  member: Member;
+  correctionId: string;
+}) {
+  await db
+    .update(schema.fieldCorrection)
+    .set({ status: "addressed" })
+    .where(
+      and(
+        eq(schema.fieldCorrection.organizationId, member.organizationId),
+        eq(schema.fieldCorrection.id, correctionId),
+      ),
+    );
+}
+
+export async function markMultipleAddressed({
+  member,
+  correctionIds,
+}: {
+  member: Member;
+  correctionIds: string[];
+}) {
+  if (correctionIds.length === 0) return;
+
+  await db
+    .update(schema.fieldCorrection)
+    .set({ status: "addressed" })
+    .where(
+      and(
+        eq(schema.fieldCorrection.organizationId, member.organizationId),
+        inArray(schema.fieldCorrection.id, correctionIds),
+      ),
+    );
+}
+
+export async function getCorrectionsForItem({
+  member,
+  submissionItemId,
+}: {
+  member: Member;
+  submissionItemId: string;
+}) {
+  // First verify the submission item belongs to the member's organization
+  const [submissionItem] = await db
+    .select({ id: schema.submissionItem.id })
+    .from(schema.submissionItem)
+    .leftJoin(
+      schema.submissionGroup,
+      eq(schema.submissionGroup.id, schema.submissionItem.submissionGroupId),
+    )
+    .leftJoin(schema.submission, eq(schema.submission.id, schema.submissionGroup.submissionId))
+    .where(
+      and(
+        eq(schema.submissionItem.id, submissionItemId),
+        eq(schema.submission.organizationId, member.organizationId),
+      ),
+    );
+  invariant(submissionItem, `Submission item ${submissionItemId} not found or access denied`);
+
+  const corrections = await db.query.fieldCorrection.findMany({
+    with: {
+      submissionItem: {
+        with: {
+          formField: true,
+        },
+      },
+    },
+    where: and(
+      eq(schema.fieldCorrection.organizationId, member.organizationId),
+      eq(schema.fieldCorrection.submissionItemId, submissionItemId),
+    ),
+    orderBy: desc(schema.fieldCorrection.createdAt),
+  });
+  return corrections;
+}
+
+export async function getCorrectionsForForm({
+  member,
+  formId,
+  limit = 100,
+}: {
+  member: Member;
+  formId: string;
+  limit?: number;
+}) {
+  const corrections = await db.query.fieldCorrection.findMany({
+    with: {
+      submissionItem: {
+        with: {
+          formField: true,
+          group: {
+            with: {
+              submission: {
+                with: {
+                  form: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    where: eq(schema.fieldCorrection.organizationId, member.organizationId),
+    orderBy: desc(schema.fieldCorrection.createdAt),
+    limit,
+  });
+
+  // Filter by schema ID at the application level since it's nested
+  return corrections.filter(
+    (correction) => correction.submissionItem?.group?.submission?.form?.id === formId,
+  );
+}
+
+export async function getCorrectionsGroupedByItem({
+  member,
+  formId,
+}: {
+  member: Member;
+  formId?: string;
+}) {
+  const corrections = formId
+    ? await getCorrectionsForForm({ member, formId: formId })
+    : await listCorrections({ member, limit: 200 });
+
+  // Group corrections by form field ID (the field definition, not the submission instance)
+  const groupedCorrections = corrections.reduce(
+    (acc, correction) => {
+      const formFieldId = correction.submissionItem?.formFieldId;
+      if (!formFieldId) return acc;
+
+      if (!acc[formFieldId]) {
+        acc[formFieldId] = [];
+      }
+      acc[formFieldId].push(correction);
+      return acc;
+    },
+    {} as Record<string, (typeof corrections)[number][]>,
+  );
+
+  return groupedCorrections;
+}