sea-dev 1.0.0

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

@@ -0,0 +1,440 @@
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  check,
+  index,
+  integer,
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import { createdAt, deletedAt, id, updatedAt } from "../utils";
+import { tool } from "./conversations";
+import { artifact, deal, submissionGroup } from "./core";
+import { organization } from "./organisations";
+
+// *****************************************
+// Pipeline enums
+// *****************************************
+
+const pipelineStepTypeArray = ["single", "multi"] as const;
+export const pipelineStepTypeEnum = pgEnum("pipeline_step_type_enum", pipelineStepTypeArray);
+
+const pipelineStepRoleArray = ["extraction", "integration", "analysis", "manual"] as const;
+export const pipelineStepRoleEnum = pgEnum("pipeline_step_role_enum", pipelineStepRoleArray);
+export type PipelineStepRole = (typeof pipelineStepRoleArray)[number];
+
+const pipelineRunStepBlockerTypeArray = [
+  "missing_upload",
+  "parent_incomplete",
+  "missing_config",
+  "missing_manual_input",
+] as const;
+export const pipelineRunStepBlockerTypeEnum = pgEnum(
+  "pipeline_run_step_blocker_type_enum",
+  pipelineRunStepBlockerTypeArray,
+);
+export type PipelineRunStepBlockerType = (typeof pipelineRunStepBlockerTypeArray)[number];
+
+// Discriminated union for blocker details based on blocker type
+export type PipelineRunStepBlockerDetails =
+  | {
+      type: "missing_upload";
+      message: string;
+    }
+  | {
+      type: "missing_config";
+      message: string;
+    }
+  | {
+      type: "parent_incomplete";
+      parentStepIds: string[];
+      message: string;
+    }
+  | {
+      type: "missing_manual_input";
+      stepName: string;
+      stepDescription: string;
+      requiredFormId?: string;
+      requiredFormName?: string;
+    };
+
+const pipelineRunStepSpawnTypeArray = ["normal", "template", "instance"] as const;
+export const pipelineRunStepSpawnTypeEnum = pgEnum(
+  "pipeline_run_step_spawn_type_enum",
+  pipelineRunStepSpawnTypeArray,
+);
+export type PipelineRunStepSpawnType = (typeof pipelineRunStepSpawnTypeArray)[number];
+
+// *****************************************
+// Status Constants
+// *****************************************
+
+export const PIPELINE_RUN_STATUS = {
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  BLOCKED: "blocked",
+} as const;
+
+export const PIPELINE_RUN_STEP_STATUS = {
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  BLOCKED: "blocked",
+} as const;
+
+// *****************************************
+// Pipeline tables
+// *****************************************
+
+export const pipeline = pgTable(
+  "pipeline",
+  {
+    id: id(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "restrict" }),
+    name: text("name").notNull().default("Untitled Pipeline"),
+    description: text("description").notNull().default(""),
+    isActive: boolean("is_active").notNull().default(true),
+    version: text("version").notNull().default("1"),
+    metadata: jsonb("metadata").$type<object>(),
+    deletedAt: deletedAt(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("pipeline__organization_id_idx").on(table.organizationId),
+    index("pipeline__is_active_idx").on(table.isActive),
+  ],
+);
+
+export const pipelineStep = pgTable(
+  "pipeline_step",
+  {
+    id: id(),
+    pipelineId: text("pipeline_id")
+      .notNull()
+      .references(() => pipeline.id, { onDelete: "cascade" }),
+
+    // Step configuration
+    type: pipelineStepTypeEnum("type").notNull().default("single"),
+
+    // Role - nullable for backwards compatibility with existing data
+    role: pipelineStepRoleEnum("role"),
+
+    // Step details
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    prompt: text("prompt").notNull().default(""),
+
+    // Execution config
+    toolsAllowed: text("tools_allowed").array(),
+    retryPolicy: jsonb("retry_policy").$type<object>(),
+
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("pipeline_step__pipeline_id_idx").on(table.pipelineId),
+    index("pipeline_step__role_idx").on(table.role),
+  ],
+);
+
+export const pipelineStepIntegrationConfig = pgTable(
+  "pipeline_step_integration_config",
+  {
+    id: id(),
+    stepId: text("step_id")
+      .notNull()
+      .references(() => pipelineStep.id, { onDelete: "cascade" }),
+    method: text("method").notNull(),
+    urlTemplate: text("url_template").notNull(),
+    headers: jsonb("headers").$type<Record<string, string>>().notNull().default({}),
+    bodyTemplate: text("body_template"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [uniqueIndex("pipeline_step_integration_config__step_id_idx").on(table.stepId)],
+);
+
+export const pipelineStepDependency = pgTable(
+  "pipeline_step_dependency",
+  {
+    id: id(),
+    childStepId: text("child_step_id")
+      .notNull()
+      .references(() => pipelineStep.id, { onDelete: "cascade" }),
+    parentStepId: text("parent_step_id")
+      .notNull()
+      .references(() => pipelineStep.id, { onDelete: "cascade" }),
+
+    // Optional: which parent output forms map to which child input expectations
+    formIdMapping: jsonb("form_id_mapping").$type<Record<string, string[]>>(),
+
+    // For multi-type steps: which formGroup from parent output to process
+    multiFormGroupId: text("multi_form_group_id"),
+
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_step_dependency__child_step_id_idx").on(table.childStepId),
+    index("pipeline_step_dependency__parent_step_id_idx").on(table.parentStepId),
+    uniqueIndex("pipeline_step_dependency__child_parent_idx").on(
+      table.childStepId,
+      table.parentStepId,
+    ),
+  ],
+);
+
+export const pipelineStepOutputForm = pgTable(
+  "pipeline_step_output_form",
+  {
+    id: id(),
+    stepId: text("step_id")
+      .notNull()
+      .references(() => pipelineStep.id, { onDelete: "cascade" }),
+    formId: text("form_id").notNull(),
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_step_output_form__step_id_idx").on(table.stepId),
+    index("pipeline_step_output_form__form_id_idx").on(table.formId),
+    uniqueIndex("pipeline_step_output_form__step_id_form_id_idx").on(table.stepId, table.formId),
+  ],
+);
+
+// *****************************************
+// Pipeline Run tables
+// *****************************************
+
+export const pipelineRun = pgTable(
+  "pipeline_run",
+  {
+    id: id(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "restrict" }),
+    pipelineId: text("pipeline_id")
+      .notNull()
+      .references(() => pipeline.id, { onDelete: "cascade" }),
+    dealId: text("deal_id")
+      .notNull()
+      .references(() => deal.id, { onDelete: "restrict" }),
+    status: text("status").notNull().default("pending"),
+    triggerType: text("trigger_type").notNull().default("manual"),
+    errorSummary: text("error_summary"),
+    startedAt: timestamp("started_at").notNull().defaultNow(),
+    completedAt: timestamp("completed_at"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("pipeline_run__organization_id_idx").on(table.organizationId),
+    index("pipeline_run__status_idx").on(table.status),
+    index("pipeline_run__pipeline_id_idx").on(table.pipelineId),
+    index("pipeline_run__deal_id_idx").on(table.dealId),
+  ],
+);
+
+export const pipelineRunStep = pgTable(
+  "pipeline_run_step",
+  {
+    id: id(),
+    runId: text("run_id")
+      .notNull()
+      .references(() => pipelineRun.id, { onDelete: "cascade" }),
+    stepId: text("step_id")
+      .notNull()
+      .references(() => pipelineStep.id, { onDelete: "cascade" }),
+
+    // Spawn type: normal (default), template (spawns instances), instance (spawned execution)
+    spawnType: pipelineRunStepSpawnTypeEnum("spawn_type").notNull().default("normal"),
+
+    // For instances: which submission group this processes
+    submissionGroupId: text("submission_group_id").references(() => submissionGroup.id, {
+      onDelete: "set null",
+    }),
+
+    // For instances: stable ordering index (0, 1, 2...)
+    stepRunIndex: integer("step_run_index"),
+
+    status: text("status").notNull().default("pending"),
+    error: text("error"),
+    startedAt: timestamp("started_at"),
+    completedAt: timestamp("completed_at"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    // Existing indexes
+    index("pipeline_run_step__run_id_idx").on(table.runId),
+    index("pipeline_run_step__step_id_idx").on(table.stepId),
+    index("pipeline_run_step__status_idx").on(table.status),
+    index("pipeline_run_step__run_id_status_idx").on(table.runId, table.status),
+    index("pipeline_run_step__run_id_step_id_idx").on(table.runId, table.stepId),
+
+    // New indexes for spawning
+    index("pipeline_run_step__spawn_type_idx").on(table.spawnType),
+    index("pipeline_run_step__submission_group_id_idx").on(table.submissionGroupId),
+
+    // Check constraint: instances must have submissionGroupId and stepRunIndex
+    check(
+      "spawn_type_instance_fields_check",
+      sql`(
+        (spawn_type = 'instance' AND submission_group_id IS NOT NULL AND step_run_index IS NOT NULL)
+        OR
+        (spawn_type != 'instance' AND submission_group_id IS NULL AND step_run_index IS NULL)
+      )`,
+    ),
+  ],
+);
+
+export const pipelineRunStepToolCall = pgTable(
+  "pipeline_run_step_tool_call",
+  {
+    id: id(),
+    runStepId: text("run_step_id")
+      .notNull()
+      .references(() => pipelineRunStep.id, { onDelete: "cascade" }),
+    toolCallId: text("tool_call_id")
+      .notNull()
+      .references(() => tool.id, { onDelete: "cascade" }),
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_run_step_tool_call__run_step_id_idx").on(table.runStepId),
+    index("pipeline_run_step_tool_call__tool_call_id_idx").on(table.toolCallId),
+    uniqueIndex("pipeline_run_step_tool_call__run_step_id_tool_call_id_idx").on(
+      table.runStepId,
+      table.toolCallId,
+    ),
+  ],
+);
+
+export const pipelineRunArtifact = pgTable(
+  "pipeline_run_artifact",
+  {
+    id: id(),
+    runId: text("run_id")
+      .notNull()
+      .references(() => pipelineRun.id, { onDelete: "cascade" }),
+    artifactId: text("artifact_id")
+      .notNull()
+      .references(() => artifact.id, { onDelete: "cascade" }),
+    runStepId: text("run_step_id").references(() => pipelineRunStep.id, { onDelete: "set null" }),
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_run_artifact__run_id_idx").on(table.runId),
+    index("pipeline_run_artifact__artifact_id_idx").on(table.artifactId),
+    index("pipeline_run_artifact__run_step_id_idx").on(table.runStepId),
+    uniqueIndex("pipeline_run_artifact__run_id_artifact_id_idx").on(table.runId, table.artifactId),
+  ],
+);
+
+// *****************************************
+// Pipeline Run Step Dependency Data
+// *****************************************
+
+export const pipelineRunIntegrationRequest = pgTable(
+  "pipeline_run_integration_request",
+  {
+    id: id(),
+    runStepId: text("run_step_id")
+      .notNull()
+      .references(() => pipelineRunStep.id, { onDelete: "cascade" }),
+    submissionItemVersionId: text("submission_item_version_id"),
+
+    // Request details
+    method: text("method").notNull(),
+    url: text("url").notNull(),
+    requestHeaders: jsonb("request_headers").$type<Record<string, string>>().notNull().default({}),
+    requestBody: jsonb("request_body").$type<unknown>(),
+
+    // Response details
+    statusCode: integer("status_code"),
+    responseHeaders: jsonb("response_headers").$type<Record<string, string>>(),
+    responseBody: jsonb("response_body").$type<unknown>(),
+
+    // Metadata
+    durationMs: integer("duration_ms"),
+    error: text("error"),
+
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("request_call__run_step_id_idx").on(table.runStepId),
+    index("request_call__submission_item_version_id_idx").on(table.submissionItemVersionId),
+    index("request_call__status_code_idx").on(table.statusCode),
+    index("request_call__created_at_idx").on(table.createdAt),
+  ],
+);
+
+export const pipelineRunStepBlocker = pgTable(
+  "pipeline_run_step_blocker",
+  {
+    id: id(),
+    runStepId: text("run_step_id")
+      .notNull()
+      .references(() => pipelineRunStep.id, { onDelete: "cascade" }),
+    blockerType: pipelineRunStepBlockerTypeEnum("blocker_type").notNull(),
+    blockerDetails: jsonb("blocker_details").$type<PipelineRunStepBlockerDetails>().notNull(),
+    resolved: boolean("resolved").notNull().default(false),
+    resolvedAt: timestamp("resolved_at"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("pipeline_run_step_blocker__run_step_id_idx").on(table.runStepId),
+    index("pipeline_run_step_blocker__blocker_type_idx").on(table.blockerType),
+    index("pipeline_run_step_blocker__resolved_idx").on(table.resolved),
+    index("pipeline_run_step_blocker__run_step_id_resolved_idx").on(
+      table.runStepId,
+      table.resolved,
+    ),
+  ],
+);
+
+export const pipelineRunStepOutputSubmission = pgTable(
+  "pipeline_run_step_output_submission",
+  {
+    id: id(),
+    runStepId: text("run_step_id")
+      .notNull()
+      .references(() => pipelineRunStep.id, { onDelete: "cascade" }),
+    submissionId: text("submission_id").notNull(),
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_run_step_output_submission__run_step_id_idx").on(table.runStepId),
+    index("pipeline_run_step_output_submission__submission_id_idx").on(table.submissionId),
+  ],
+);
+
+export const pipelineRunStepDocument = pgTable(
+  "pipeline_run_step_document",
+  {
+    id: id(),
+    runStepId: text("run_step_id")
+      .notNull()
+      .references(() => pipelineRunStep.id, { onDelete: "cascade" }),
+    documentId: text("document_id").notNull(),
+    createdAt: createdAt(),
+  },
+  (table) => [
+    index("pipeline_run_step_document__run_step_id_idx").on(table.runStepId),
+    index("pipeline_run_step_document__document_id_idx").on(table.documentId),
+    uniqueIndex("pipeline_run_step_document__run_step_id_document_id_idx").on(
+      table.runStepId,
+      table.documentId,
+    ),
+  ],
+);

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

@@ -0,0 +1,95 @@
+import { boolean, index, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { createdAt, id, updatedAt } from "../utils";
+import { organization } from "./organisations";
+
+export const userRoleArray = ["user", "admin"] as const;
+export const userRoleEnum = pgEnum("user_type", userRoleArray);
+export const user = pgTable(
+  "user",
+  {
+    id: id(),
+    name: text("name").notNull(),
+    role: userRoleEnum("role").notNull().default("user"),
+    email: text("email").notNull().unique(),
+    emailVerified: boolean("email_verified").notNull(),
+    image: text("image"),
+
+    banned: boolean("banned"),
+    banReason: text("ban_reason"),
+    banExpires: timestamp("ban_expires"),
+
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (_table) => [],
+);
+export const session = pgTable(
+  "session",
+  {
+    id: id(),
+    expiresAt: timestamp("expires_at").notNull(),
+    token: text("token").notNull().unique(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    impersonatedBy: text("impersonated_by"),
+    activeOrganizationId: text("active_organization_id").references(() => organization.id, {
+      onDelete: "set null",
+    }),
+  },
+  (_table) => [],
+);
+export const impersonation = pgTable(
+  "impersonation",
+  {
+    id: id(),
+    // no FK on these as we want to keep them when users are deleted
+    impersonatedUserId: text("impersonated_user_id"),
+    impersonatedByUserId: text("impersonated_by_user_id"),
+    impersonatedEmail: text("impersonated_email"),
+    impersonatedByEmail: text("impersonated_by_email"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    index("impersonation__impersonated_idx").on(table.impersonatedUserId),
+    index("impersonation__impersonated_by_idx").on(table.impersonatedByUserId),
+  ],
+);
+export const account = pgTable(
+  "account",
+  {
+    id: id(),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: timestamp("access_token_expires_at"),
+    refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [index("account__user_id_idx").on(table.userId)],
+);
+export const verification = pgTable(
+  "verification",
+  {
+    id: id(),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: timestamp("expires_at").notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (_table) => [],
+);