sea-dev 1.0.0

package/libs/db/src/relations.ts

@@ -0,0 +1,549 @@
+import { relations } from "drizzle-orm";
+import {
+  account,
+  apiKey,
+  artifact,
+  context,
+  conversation,
+  conversationResource,
+  dataTransformation,
+  deal,
+  document,
+  documentCitation,
+  documentExtraction,
+  fieldCorrection,
+  form,
+  formDerived,
+  formField,
+  formGroup,
+  impersonation,
+  invitation,
+  member,
+  message,
+  organization,
+  orgSettings,
+  pipeline,
+  pipelineRun,
+  pipelineRunArtifact,
+  pipelineRunIntegrationRequest,
+  pipelineRunStep,
+  pipelineRunStepBlocker,
+  pipelineRunStepDocument,
+  pipelineRunStepOutputSubmission,
+  pipelineRunStepToolCall,
+  pipelineStep,
+  pipelineStepDependency,
+  pipelineStepIntegrationConfig,
+  pipelineStepOutputForm,
+  report,
+  session,
+  submission,
+  submissionDerived,
+  submissionGroup,
+  submissionItem,
+  submissionItemVersion,
+  tool,
+  toolCall,
+  user,
+  workflow,
+} from "./schemas";
+
+// Organization relations
+export const organizationRelations = relations(organization, ({ many, one }) => ({
+  members: many(member),
+  invitations: many(invitation),
+  workflows: many(workflow),
+  deals: many(deal),
+  apiKeys: many(apiKey),
+  pipelines: many(pipeline),
+  pipelineRuns: many(pipelineRun),
+  settings: one(orgSettings, {
+    fields: [organization.id],
+    references: [orgSettings.organizationId],
+  }),
+}));
+
+// Member relations
+export const memberRelations = relations(member, ({ one }) => ({
+  user: one(user, {
+    fields: [member.userId],
+    references: [user.id],
+  }),
+  organization: one(organization, {
+    fields: [member.organizationId],
+    references: [organization.id],
+  }),
+}));
+
+// Invitation relations
+export const invitationRelations = relations(invitation, ({ one }) => ({
+  organization: one(organization, {
+    fields: [invitation.organizationId],
+    references: [organization.id],
+  }),
+}));
+
+// User relations
+export const userRelations = relations(user, ({ many }) => ({
+  accounts: many(account),
+  sessions: many(session),
+  members: many(member),
+}));
+
+// Session relations
+export const sessionRelations = relations(session, ({ one }) => ({
+  user: one(user, {
+    fields: [session.userId],
+    references: [user.id],
+  }),
+}));
+
+// Impersonation relations
+export const impersonationRelations = relations(impersonation, ({ one }) => ({
+  impersonatedUser: one(user, {
+    fields: [impersonation.impersonatedUserId],
+    references: [user.id],
+  }),
+  impersonatedByUser: one(user, {
+    fields: [impersonation.impersonatedByUserId],
+    references: [user.id],
+  }),
+}));
+
+// Account relations
+export const accountRelations = relations(account, ({ one }) => ({
+  user: one(user, {
+    fields: [account.userId],
+    references: [user.id],
+  }),
+}));
+
+// Conversation relations
+export const conversationRelations = relations(conversation, ({ one, many }) => ({
+  messages: many(message),
+  contexts: many(context),
+  tools: many(tool),
+  resources: many(conversationResource),
+  pipelineRuns: many(pipelineRun),
+  artifacts: many(artifact),
+  form: one(form),
+}));
+
+// Message relations
+export const messageRelations = relations(message, ({ one }) => ({
+  conversation: one(conversation, {
+    fields: [message.conversationId],
+    references: [conversation.id],
+  }),
+}));
+
+// Context relations
+export const contextRelations = relations(context, ({ one }) => ({
+  conversation: one(conversation, {
+    fields: [context.conversationId],
+    references: [conversation.id],
+  }),
+}));
+
+// Tool relations
+export const toolRelations = relations(tool, ({ one }) => ({
+  conversation: one(conversation, {
+    fields: [tool.conversationId],
+    references: [conversation.id],
+  }),
+}));
+
+// Agent runtime relations
+export const conversationResourceRelations = relations(conversationResource, ({ one }) => ({
+  conversation: one(conversation, {
+    fields: [conversationResource.conversationId],
+    references: [conversation.id],
+  }),
+}));
+
+// Workflow relations
+export const workflowRelations = relations(workflow, ({ one, many }) => ({
+  organization: one(organization, {
+    fields: [workflow.organizationId],
+    references: [organization.id],
+  }),
+  forms: many(form),
+}));
+
+// Deal relations
+export const dealRelations = relations(deal, ({ one, many }) => ({
+  organization: one(organization, {
+    fields: [deal.organizationId],
+    references: [organization.id],
+  }),
+  submissions: many(submission),
+}));
+
+// Form relations
+export const formRelations = relations(form, ({ one, many }) => ({
+  workflow: one(workflow, {
+    fields: [form.workflowId],
+    references: [workflow.id],
+  }),
+  conversation: one(conversation, {
+    fields: [form.conversationId],
+    references: [conversation.id],
+  }),
+  groups: many(formGroup),
+  submissions: many(submission),
+}));
+
+// FormGroup relations
+export const formGroupRelations = relations(formGroup, ({ one, many }) => ({
+  form: one(form, {
+    fields: [formGroup.formId],
+    references: [form.id],
+  }),
+  fields: many(formField),
+  derived: many(formDerived),
+  submissionGroups: many(submissionGroup),
+}));
+
+// FormField relations
+export const formFieldRelations = relations(formField, ({ one, many }) => ({
+  group: one(formGroup, {
+    fields: [formField.formGroupId],
+    references: [formGroup.id],
+  }),
+  submissionItems: many(submissionItem),
+}));
+
+// FormDerived relations
+export const formDerivedRelations = relations(formDerived, ({ one, many }) => ({
+  group: one(formGroup, {
+    fields: [formDerived.formGroupId],
+    references: [formGroup.id],
+  }),
+  submissionDerived: many(submissionDerived),
+}));
+
+// Submission relations
+export const submissionRelations = relations(submission, ({ one, many }) => ({
+  form: one(form, {
+    fields: [submission.formId],
+    references: [form.id],
+  }),
+  deal: one(deal, {
+    fields: [submission.dealId],
+    references: [deal.id],
+  }),
+  conversation: one(conversation, {
+    fields: [submission.conversationId],
+    references: [conversation.id],
+  }),
+  groups: many(submissionGroup),
+  extractions: many(documentExtraction),
+}));
+
+// SubmissionGroup relations
+export const submissionGroupRelations = relations(submissionGroup, ({ one, many }) => ({
+  formGroup: one(formGroup, {
+    fields: [submissionGroup.formGroupId],
+    references: [formGroup.id],
+  }),
+  submission: one(submission, {
+    fields: [submissionGroup.submissionId],
+    references: [submission.id],
+  }),
+  items: many(submissionItem),
+  derived: many(submissionDerived),
+}));
+
+// SubmissionItem relations
+export const submissionItemRelations = relations(submissionItem, ({ one, many }) => ({
+  group: one(submissionGroup, {
+    fields: [submissionItem.submissionGroupId],
+    references: [submissionGroup.id],
+  }),
+  formField: one(formField, {
+    fields: [submissionItem.formFieldId],
+    references: [formField.id],
+  }),
+  versions: many(submissionItemVersion),
+}));
+
+// SubmissionDerived relations
+export const submissionDerivedRelations = relations(submissionDerived, ({ one }) => ({
+  group: one(submissionGroup, {
+    fields: [submissionDerived.submissionGroupId],
+    references: [submissionGroup.id],
+  }),
+  formDerived: one(formDerived, {
+    fields: [submissionDerived.formDerivedId],
+    references: [formDerived.id],
+  }),
+}));
+
+// SubmissionItemVersion relations
+export const submissionItemVersionRelations = relations(submissionItemVersion, ({ one }) => ({
+  submissionItem: one(submissionItem, {
+    fields: [submissionItemVersion.submissionItemId],
+    references: [submissionItem.id],
+  }),
+  documentSource: one(documentCitation, {
+    fields: [submissionItemVersion.sourceId],
+    references: [documentCitation.id],
+  }),
+  messageSource: one(message, {
+    fields: [submissionItemVersion.sourceId],
+    references: [message.id],
+  }),
+  transformationSource: one(dataTransformation, {
+    fields: [submissionItemVersion.sourceId],
+    references: [dataTransformation.id],
+  }),
+}));
+
+// Document relations
+export const documentRelations = relations(document, ({ one, many }) => ({
+  deal: one(deal, {
+    fields: [document.dealId],
+    references: [deal.id],
+  }),
+  extractions: many(documentExtraction),
+}));
+
+// DocumentExtraction relations
+export const documentExtractionRelations = relations(documentExtraction, ({ one, many }) => ({
+  document: one(document, {
+    fields: [documentExtraction.documentId],
+    references: [document.id],
+  }),
+  submission: one(submission, {
+    fields: [documentExtraction.submissionId],
+    references: [submission.id],
+  }),
+  citations: many(documentCitation),
+}));
+
+// DocumentCitation relations
+export const documentCitationDataRelations = relations(documentCitation, ({ one }) => ({
+  extraction: one(documentExtraction, {
+    fields: [documentCitation.documentExtractionId],
+    references: [documentExtraction.id],
+  }),
+}));
+
+// ApiKey relations
+export const apiKeyRelations = relations(apiKey, ({ one }) => ({
+  organization: one(organization, {
+    fields: [apiKey.organizationId],
+    references: [organization.id],
+  }),
+  member: one(member, {
+    fields: [apiKey.memberId],
+    references: [member.id],
+  }),
+  submission: one(submission, {
+    fields: [apiKey.targetId],
+    references: [submission.id],
+  }),
+}));
+
+// FieldCorrection relations
+export const fieldCorrectionRelations = relations(fieldCorrection, ({ one }) => ({
+  organization: one(organization, {
+    fields: [fieldCorrection.organizationId],
+    references: [organization.id],
+  }),
+  submissionItem: one(submissionItem, {
+    fields: [fieldCorrection.submissionItemId],
+    references: [submissionItem.id],
+  }),
+}));
+
+// Report relations
+export const reportRelations = relations(report, ({ one }) => ({
+  organization: one(organization, {
+    fields: [report.organizationId],
+    references: [organization.id],
+  }),
+  conversation: one(conversation, {
+    fields: [report.conversationId],
+    references: [conversation.id],
+  }),
+  form: one(form, {
+    fields: [report.formId],
+    references: [form.id],
+  }),
+  deal: one(deal, {
+    fields: [report.dealId],
+    references: [deal.id],
+  }),
+}));
+
+// Pipeline relations
+export const pipelineRelations = relations(pipeline, ({ one, many }) => ({
+  organization: one(organization, {
+    fields: [pipeline.organizationId],
+    references: [organization.id],
+  }),
+  steps: many(pipelineStep),
+  runs: many(pipelineRun),
+}));
+
+export const pipelineStepRelations = relations(pipelineStep, ({ one, many }) => ({
+  pipeline: one(pipeline, {
+    fields: [pipelineStep.pipelineId],
+    references: [pipeline.id],
+  }),
+  integrationConfig: one(pipelineStepIntegrationConfig, {
+    fields: [pipelineStep.id],
+    references: [pipelineStepIntegrationConfig.stepId],
+  }),
+  parentDependencies: many(pipelineStepDependency, {
+    relationName: "childStep",
+  }),
+  childDependencies: many(pipelineStepDependency, {
+    relationName: "parentStep",
+  }),
+  outputForms: many(pipelineStepOutputForm),
+}));
+
+export const pipelineRunRelations = relations(pipelineRun, ({ one, many }) => ({
+  organization: one(organization, {
+    fields: [pipelineRun.organizationId],
+    references: [organization.id],
+  }),
+  pipeline: one(pipeline, {
+    fields: [pipelineRun.pipelineId],
+    references: [pipeline.id],
+  }),
+  steps: many(pipelineRunStep),
+  artifactMappings: many(pipelineRunArtifact),
+}));
+
+export const pipelineRunStepRelations = relations(pipelineRunStep, ({ one, many }) => ({
+  run: one(pipelineRun, {
+    fields: [pipelineRunStep.runId],
+    references: [pipelineRun.id],
+  }),
+  step: one(pipelineStep, {
+    fields: [pipelineRunStep.stepId],
+    references: [pipelineStep.id],
+  }),
+  submissionGroup: one(submissionGroup, {
+    fields: [pipelineRunStep.submissionGroupId],
+    references: [submissionGroup.id],
+  }),
+  toolCallMappings: many(pipelineRunStepToolCall),
+  artifactMappings: many(pipelineRunArtifact),
+  blockers: many(pipelineRunStepBlocker),
+  outputSubmissions: many(pipelineRunStepOutputSubmission),
+  documents: many(pipelineRunStepDocument),
+}));
+
+export const pipelineRunStepToolCallRelations = relations(pipelineRunStepToolCall, ({ one }) => ({
+  runStep: one(pipelineRunStep, {
+    fields: [pipelineRunStepToolCall.runStepId],
+    references: [pipelineRunStep.id],
+  }),
+  toolCall: one(toolCall, {
+    fields: [pipelineRunStepToolCall.toolCallId],
+    references: [toolCall.id],
+  }),
+}));
+
+export const pipelineRunArtifactRelations = relations(pipelineRunArtifact, ({ one }) => ({
+  run: one(pipelineRun, {
+    fields: [pipelineRunArtifact.runId],
+    references: [pipelineRun.id],
+  }),
+  runStep: one(pipelineRunStep, {
+    fields: [pipelineRunArtifact.runStepId],
+    references: [pipelineRunStep.id],
+  }),
+  artifact: one(artifact, {
+    fields: [pipelineRunArtifact.artifactId],
+    references: [artifact.id],
+  }),
+}));
+
+export const toolCallRelations = relations(toolCall, ({ one, many }) => ({
+  tool: one(tool, {
+    fields: [toolCall.toolId],
+    references: [tool.id],
+  }),
+  runStepMappings: many(pipelineRunStepToolCall),
+}));
+
+export const artifactRelations = relations(artifact, ({ many }) => ({
+  runMappings: many(pipelineRunArtifact),
+}));
+
+export const pipelineRunStepBlockerRelations = relations(pipelineRunStepBlocker, ({ one }) => ({
+  runStep: one(pipelineRunStep, {
+    fields: [pipelineRunStepBlocker.runStepId],
+    references: [pipelineRunStep.id],
+  }),
+}));
+
+export const pipelineRunStepOutputSubmissionRelations = relations(
+  pipelineRunStepOutputSubmission,
+  ({ one }) => ({
+    runStep: one(pipelineRunStep, {
+      fields: [pipelineRunStepOutputSubmission.runStepId],
+      references: [pipelineRunStep.id],
+    }),
+    submission: one(submission, {
+      fields: [pipelineRunStepOutputSubmission.submissionId],
+      references: [submission.id],
+    }),
+  }),
+);
+
+export const pipelineRunStepDocumentRelations = relations(pipelineRunStepDocument, ({ one }) => ({
+  runStep: one(pipelineRunStep, {
+    fields: [pipelineRunStepDocument.runStepId],
+    references: [pipelineRunStep.id],
+  }),
+}));
+
+export const pipelineRunIntegrationRequestRelations = relations(
+  pipelineRunIntegrationRequest,
+  ({ one }) => ({
+    runStep: one(pipelineRunStep, {
+      fields: [pipelineRunIntegrationRequest.runStepId],
+      references: [pipelineRunStep.id],
+    }),
+  }),
+);
+
+export const pipelineStepIntegrationConfigRelations = relations(
+  pipelineStepIntegrationConfig,
+  ({ one }) => ({
+    step: one(pipelineStep, {
+      fields: [pipelineStepIntegrationConfig.stepId],
+      references: [pipelineStep.id],
+    }),
+  }),
+);
+
+export const pipelineStepDependencyRelations = relations(pipelineStepDependency, ({ one }) => ({
+  childStep: one(pipelineStep, {
+    fields: [pipelineStepDependency.childStepId],
+    references: [pipelineStep.id],
+    relationName: "childStep",
+  }),
+  parentStep: one(pipelineStep, {
+    fields: [pipelineStepDependency.parentStepId],
+    references: [pipelineStep.id],
+    relationName: "parentStep",
+  }),
+}));
+
+export const pipelineStepOutputFormRelations = relations(pipelineStepOutputForm, ({ one }) => ({
+  step: one(pipelineStep, {
+    fields: [pipelineStepOutputForm.stepId],
+    references: [pipelineStep.id],
+  }),
+  form: one(form, {
+    fields: [pipelineStepOutputForm.formId],
+    references: [form.id],
+  }),
+}));

package/libs/db/src/schema.ts

@@ -0,0 +1,2 @@
+export * from "./relations";
+export * from "./schemas";

package/libs/db/src/schemas/api.ts

@@ -0,0 +1,35 @@
+import { index, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { createdAt, deletedAt, id, updatedAt } from "../utils";
+import { member, organization } from "./organisations";
+
+export const apiKeyTargetTypeArray = ["submission"] as const;
+export const apiKeyTargetTypeEnum = pgEnum("api_key_target_type", apiKeyTargetTypeArray);
+export const apiKey = pgTable(
+  "api_key",
+  {
+    id: id(),
+    organizationId: text("organization_id")
+      .references(() => organization.id)
+      .notNull(),
+    memberId: text("member_id")
+      .references(() => member.id, { onDelete: "cascade" })
+      .notNull(),
+    name: text("name").notNull(),
+    keyHash: text("key_hash").notNull(),
+    keyEncrypted: text("key_encrypted"),
+    lastFour: text("last_four").notNull(),
+
+    targetType: apiKeyTargetTypeEnum("target_type"),
+    targetId: text("target_id"),
+
+    expiresAt: timestamp("expires_at"),
+    deletedAt: deletedAt(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("api_key__key_hash_idx").on(table.keyHash),
+    index("api_key__organization_id_idx").on(table.organizationId),
+    index("api_key__member_id_idx").on(table.memberId),
+  ],
+);