sea-dev 1.0.0

package/apps/api/src/routes/v2/workflows/index.ts

@@ -0,0 +1,88 @@
+import { type FastifyInstance } from "fastify";
+import { type ZodTypeProvider } from "fastify-type-provider-zod";
+import * as z from "zod/v4";
+import {
+  createWorkflowHandler,
+  getWorkflowsHandler,
+  patchWorkflowHandler,
+  updateWorkflowHandler,
+} from "./handlers";
+import {
+  createWorkflowSchema,
+  patchWorkflowSchema,
+  updateWorkflowSchema,
+  workflowSchema,
+  workflowsListResponseSchema,
+} from "./schemas";
+
+export async function v2WorkflowsRouter(app: FastifyInstance) {
+  app
+    .withTypeProvider<ZodTypeProvider>()
+    .route({
+      method: "GET",
+      url: "/",
+      schema: {
+        tags: ["Workflows"],
+        description:
+          "Retrieve all workflows for the authenticated user's organization. Returns an array of workflow objects including form and submission counts for each workflow. Workflows are automatically filtered by the user's organization membership.",
+        response: {
+          200: workflowsListResponseSchema,
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ member }, reply) => getWorkflowsHandler(member, reply),
+    })
+    .route({
+      method: "POST",
+      url: "/",
+      schema: {
+        tags: ["Workflows"],
+        description:
+          "Create a new workflow for the authenticated user's organization. Requires a workflow name (minimum 1 character). The hint field is optional and can provide additional context for the workflow. Returns the created workflow object with generated ID, slug, timestamps, and organization association.",
+        body: createWorkflowSchema,
+        response: {
+          200: workflowSchema,
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ body, member }, reply) => createWorkflowHandler(body, member, reply),
+    })
+    .route({
+      method: "PUT",
+      url: "/:workflowId",
+      schema: {
+        tags: ["Workflows"],
+        description:
+          "Replace an existing workflow with new values for all required fields. This is a full replacement operation - both name and hint must be provided. Requires the workflowId in the URL path. Returns success status on completion. Will return 404 if the workflow doesn't exist or the user doesn't have permission to modify it.",
+        params: z.object({ workflowId: z.string() }),
+        body: updateWorkflowSchema,
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        updateWorkflowHandler({ workflowId: params.workflowId, ...body }, member, reply),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:workflowId",
+      schema: {
+        tags: ["Workflows"],
+        description:
+          "Partially update an existing workflow with only the fields you want to change. All fields (name, hint) are optional - only provide the ones you want to update. Requires the workflowId in the URL path. Returns success status on completion. Will return 404 if the workflow doesn't exist or the user doesn't have permission to modify it. Use PUT for full replacement of all fields.",
+        params: z.object({ workflowId: z.string() }),
+        body: patchWorkflowSchema,
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        patchWorkflowHandler({ workflowId: params.workflowId, ...body }, member, reply),
+    });
+}

package/apps/api/src/routes/v2/workflows/schemas.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+
+export const createWorkflowSchema = z.object({
+  name: z.string().min(1, "Workflow name is required"),
+  hint: z.string().optional(),
+});
+export type CreateWorkflowRequest = z.infer<typeof createWorkflowSchema>;
+
+export const updateWorkflowSchema = z.object({
+  name: z.string().min(1, "Workflow name is required"),
+  hint: z.string(),
+});
+export type UpdateWorkflowRequest = z.infer<typeof updateWorkflowSchema>;
+
+export const patchWorkflowSchema = z.object({
+  name: z.string().min(1, "Workflow name is required").optional(),
+  hint: z.string().optional(),
+});
+export type PatchWorkflowRequest = z.infer<typeof patchWorkflowSchema>;
+
+export const workflowSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  organizationId: z.string(),
+  name: z.string(),
+  hint: z.string(),
+  deletedAt: z.date().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type WorkflowResponse = z.infer<typeof workflowSchema>;
+
+export const workflowWithCountsSchema = workflowSchema.extend({
+  formCount: z.number(),
+  submissionCount: z.number(),
+});
+export type WorkflowWithCountsResponse = z.infer<typeof workflowWithCountsSchema>;
+
+export const workflowsListResponseSchema = z.array(workflowWithCountsSchema);
+export type WorkflowsListResponse = z.infer<typeof workflowsListResponseSchema>;

package/apps/api/src/server.ts

@@ -0,0 +1,146 @@
+import { fastifyCors } from "@fastify/cors";
+import { fastifyMultipart } from "@fastify/multipart";
+import swagger from "@fastify/swagger";
+import scalar from "@scalar/fastify-api-reference";
+import fastify, { type FastifyError } from "fastify";
+import fastifyFavicon from "fastify-favicon";
+import {
+  jsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler,
+} from "fastify-type-provider-zod";
+import { NotFoundError } from "./errors";
+import { getApiConfig } from "./lib/config";
+import { router } from "./routes";
+
+const { port } = getApiConfig();
+
+const IN_DEV = process.env.NODE_ENV !== "production";
+
+export async function createServer() {
+  const server: ReturnType<typeof fastify> = fastify({
+    logger: {
+      level: process.env.NODE_ENV === "production" ? "info" : "debug",
+    },
+  })
+    .setValidatorCompiler(validatorCompiler)
+    .setSerializerCompiler(serializerCompiler)
+    .register(fastifyFavicon, { path: "./src/static", name: "favicon.ico" })
+    .register(fastifyCors, {
+      origin: true,
+      methods: ["GET", "PUT", "POST", "DELETE", "OPTIONS", "PATCH"],
+    })
+    .register(fastifyMultipart, {
+      attachFieldsToBody: "keyValues",
+      onFile: async (part: {
+        toBuffer: () => Promise<Buffer>;
+        filename?: string;
+        mimetype: string;
+        value?: File;
+      }) => {
+        const buffer = await part.toBuffer();
+        part.value = new File([buffer], part.filename || "untitled", {
+          type: part.mimetype,
+        });
+      },
+      limits: {
+        fileSize: 20 * 1024 * 1024,
+      },
+    })
+    .register(swagger, {
+      transform: jsonSchemaTransform,
+      openapi: {
+        openapi: "3.1.0",
+        info: {
+          title: "sea.dev",
+          description: [
+            "Upload financial documents (PDFs) and automatically extract structured data using AI models.",
+            "",
+            "### Documentation",
+            "- OpenAPI spec: /openapi.json",
+            "- Interactive reference: /docs",
+            "- Web App Documentation: https://docs.sea.dev/",
+            "",
+            "### Concepts",
+            "- Deals group documents and submissions for a specific customer or opportunity.",
+            "- Forms define the structure of the data you want to capture (e.g. Balance Sheet).",
+            "- Submissions connect a form to a deal and store the extracted data aligned to that form.",
+            "- Extractions are the uploaded documents processed into structured data results that feed each submission.",
+            "",
+            "### Model selection",
+            "- general: balanced accuracy and performance for most financial statements.",
+            "- smart: highest accuracy for complex or messy documents; slightly slower.",
+            "- turbo: fastest results for clean, high-quality inputs.",
+            "- bank_statement: tuned specifically for bank statements and transaction tables.",
+            "",
+            "### Quickstart",
+            "1. Create an API key from the sea.dev dashboard.",
+            "2. Send requests with an `Authorization: Bearer <API_KEY>` header.",
+            "3. Create a deal:",
+            "",
+            "```bash",
+            'curl -X POST "https://api.sea.dev/v2/deals" -H "Authorization: Bearer $SEA_API_KEY" -H "Content-Type: application/json" -d \'{"name":"Acme Corp"}\'',
+            "```",
+            "4. Create a submission for the form you want to populate:",
+            "",
+            "```bash",
+            'curl -X POST "https://api.sea.dev/v2/submissions" -H "Authorization: Bearer $SEA_API_KEY" -H "Content-Type: application/json" -d \'{"formId":"<FORM_ID>","dealId":"<DEAL_ID>"}\'',
+            "```",
+            "5. Upload a PDF for extraction (choose a model if desired):",
+            "",
+            "```bash",
+            'curl -X POST "https://api.sea.dev/v2/submissions/<SUBMISSION_ID>/extractions" -H "Authorization: Bearer $SEA_API_KEY" -F files=@balance_sheet.pdf -F model=general',
+            "```",
+            "6. Retrieve the structured data once processing completes:",
+            "",
+            "```bash",
+            'curl -H "Authorization: Bearer $SEA_API_KEY" https://api.sea.dev/v2/submissions/<SUBMISSION_ID>/data',
+            "```",
+          ].join("\n"),
+          version: "1.0.0",
+        },
+        servers: [
+          {
+            url: IN_DEV ? `http://localhost:${port}` : "https://api.sea.dev",
+            description: "sea.dev API",
+          },
+        ],
+        components: {
+          securitySchemes: {
+            bearerAuth: {
+              type: "http",
+              scheme: "bearer",
+              bearerFormat: "API_KEY",
+            },
+          },
+        },
+        security: [{ bearerAuth: [] }],
+        tags: [],
+      },
+    })
+    .register(scalar, {
+      routePrefix: "/docs",
+      configuration: {
+        title: "sea.dev API Reference",
+        theme: "purple",
+      },
+    })
+    .get("/openapi.json", async () => server.swagger())
+    .setErrorHandler<FastifyError>(async (error, request, reply) => {
+      request.log.error(error);
+      const statusCode = error.statusCode || 500;
+      const description = error.message || "An unexpected error occurred";
+
+      reply.status(statusCode).send({ description });
+    })
+    .register(router)
+    .get("/health", async () => {
+      return { status: "ok", timestamp: new Date().toISOString() };
+    })
+    .setNotFoundHandler(async (request) => {
+      console.log(request.url);
+      throw new NotFoundError("No matching routes");
+    });
+
+  return server;
+}

package/apps/api/src/types/api.ts

@@ -0,0 +1,14 @@
+import type { MemberHydrated } from "@sea/dal/member";
+
+declare module "fastify" {
+  interface FastifyRequest {
+    member: MemberHydrated;
+    apiKeyId: string;
+  }
+}
+
+export interface ApiError {
+  statusCode: number;
+  message: string;
+  code?: string;
+}

package/apps/api/src/types/result.ts

@@ -0,0 +1,3 @@
+export type Result<T> =
+  | { ok: true; data: T }
+  | { ok: false; data?: never; message: string; code?: string };

package/apps/api/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2022"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*", "../../libs/dal/src/workflow.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/apps/api/vite.config.ts

@@ -0,0 +1,28 @@
+import { resolve } from "path";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    target: "node22",
+    ssr: true,
+    outDir: "dist",
+    rollupOptions: {
+      input: resolve(__dirname, "src/index.ts"),
+      external: (id) => {
+        // Externalize all dependencies (anything from node_modules)
+        return !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("@/");
+      },
+      output: {
+        format: "es",
+        entryFileNames: "[name].js",
+      },
+    },
+    minify: false,
+    sourcemap: true,
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "./src"),
+    },
+  },
+});

package/apps/api/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    globals: true,
+    setupFiles: [],
+  },
+  resolve: {
+    alias: {
+      "@": new URL("./src", import.meta.url).pathname,
+    },
+  },
+});

package/apps/conversion-worker/Dockerfile

@@ -0,0 +1,59 @@
+# Build stage
+FROM node:22-bookworm-slim AS builder
+
+# Install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+WORKDIR /app
+
+# Copy workspace config files
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+
+# Copy all workspace packages and apps needed for build
+COPY apps/conversion-worker ./apps/conversion-worker
+COPY libs ./libs
+
+# Set CI environment for pnpm
+ENV CI=true
+
+# Install all dependencies (including devDependencies for build)
+RUN pnpm approve-builds && pnpm install --frozen-lockfile
+
+# Build the conversion worker and its dependencies
+RUN pnpm --filter @sea/conversion-worker... run build
+
+# Production stage
+FROM node:22-bookworm-slim
+
+# Install LibreOffice and dependencies
+RUN apt-get update && apt-get install -y \
+    libreoffice \
+    fonts-liberation \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+WORKDIR /app
+
+# Copy workspace config files
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+
+# Copy all workspace packages (source + built)
+COPY apps/conversion-worker/package.json ./apps/conversion-worker/
+COPY libs ./libs
+
+# Copy built output from builder
+COPY --from=builder /app/apps/conversion-worker/dist ./apps/conversion-worker/dist
+COPY --from=builder /app/libs/*/dist ./libs/
+
+# Set CI environment for pnpm
+ENV CI=true
+
+# Install production dependencies only
+RUN pnpm approve-builds && pnpm install --frozen-lockfile --prod
+
+# Start the application
+WORKDIR /app/apps/conversion-worker
+CMD ["node", "dist/main.js"]

package/apps/conversion-worker/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@sea/conversion-worker",
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "dev": "tsx src/main.ts",
+        "build": "vite build",
+        "start": "node dist/main.js",
+        "check": "tsc --noEmit"
+    },
+    "dependencies": {
+        "@hatchet-dev/typescript-sdk": "^1.9.2",
+        "@sea/clients": "workspace:*",
+        "@sea/config": "workspace:*",
+        "@sea/db": "workspace:*",
+        "@sea/util": "workspace:*",
+        "drizzle-orm": "^0.43.1",
+        "nanoid": "^5.1.5"
+    },
+    "devDependencies": {
+        "@types/node": "^22.13.10",
+        "tsx": "^4.19.3",
+        "typescript": "^5.7.3",
+        "vite": "^7.1.2",
+        "vite-tsconfig-paths": "^5.1.4"
+    },
+    "engines": {
+        "node": ">=22.0.0 <23.0.0",
+        "pnpm": ">=10.13.0 <11.0.0"
+    }
+}

package/apps/conversion-worker/src/lib/config.ts

@@ -0,0 +1,7 @@
+import { type Config, ConfigFactory } from "@sea/config";
+
+export type WorkerConfig = Config;
+
+export function getWorkerConfig() {
+  return ConfigFactory.getConfig();
+}

package/apps/conversion-worker/src/main.ts

@@ -0,0 +1,22 @@
+import { HatchetClientMgr } from "@sea/clients/hatchet";
+import { getWorkerConfig } from "./lib/config";
+import { convertPptxWorkflow } from "./workflows/convert-pptx";
+
+const config = getWorkerConfig();
+const hatchet = new HatchetClientMgr(config.hatchet).getHatchet();
+
+async function main() {
+    console.info("[Conversion Worker] Starting...");
+
+    const worker = await hatchet.worker("conversion-worker", {
+        workflows: [convertPptxWorkflow],
+    });
+
+    await worker.start();
+    console.info("[Conversion Worker] Started successfully");
+}
+
+main().catch((error) => {
+    console.error("[Conversion Worker] Failed:", error);
+    process.exit(1);
+});

package/apps/conversion-worker/src/workflows/convert-pptx.ts

@@ -0,0 +1,116 @@
+import { AzureClient, GCPClient } from "@sea/clients";
+import { HatchetClientMgr } from "@sea/clients/hatchet";
+import { getWorkerConfig } from "../lib/config";
+import { db, schema } from "@sea/db";
+import { eq } from "drizzle-orm";
+import { exec } from "child_process";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import util from "util";
+import { invariant } from "@sea/util/invariant";
+
+const execAsync = util.promisify(exec);
+const config = getWorkerConfig();
+const hatchet = new HatchetClientMgr(config.hatchet).getHatchet();
+
+async function convertPptxToPdf(fileBuffer: Buffer, fileName: string): Promise<Buffer> {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "pptx-conversion-"));
+  const inputPath = path.join(tempDir, fileName);
+  const outputFileName = path.parse(fileName).name + ".pdf";
+  const outputPath = path.join(tempDir, outputFileName);
+
+  try {
+    await fs.writeFile(inputPath, fileBuffer);
+
+    // Check if soffice is available
+    try {
+      await execAsync("soffice --version");
+    } catch (e) {
+      console.warn("LibreOffice (soffice) not found");
+      throw new Error("LibreOffice not found");
+    }
+
+    // Run conversion
+    await execAsync(`soffice --headless --convert-to pdf --outdir "${tempDir}" "${inputPath}"`);
+
+    // Check if output file exists
+    try {
+      await fs.access(outputPath);
+    } catch {
+      throw new Error("PDF conversion failed: Output file not found");
+    }
+
+    const pdfBuffer = await fs.readFile(outputPath);
+    return pdfBuffer;
+  } finally {
+    // Cleanup temp directory
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+// ============================================================================
+// Workflow
+// ============================================================================
+
+export const convertPptxWorkflow = hatchet.workflow<{ documentId: string }>({
+  name: "convert-pptx",
+  onEvents: ["doc:convert-pptx"],
+});
+
+// ============================================================================
+// Tasks
+// ============================================================================
+
+export const convertPptx = convertPptxWorkflow.task({
+  name: "convert",
+  timeout: "10m",
+  fn: async (data: { documentId: string }) => {
+    const { documentId } = data;
+    console.log(`Starting conversion for document ${documentId}`);
+
+    const document = await db.query.document.findFirst({
+      where: eq(schema.document.id, documentId),
+    });
+
+    invariant(document, `Document ${documentId} not found`);
+
+    const { blobKey, storageProvider, name } = document;
+    const client =
+      storageProvider === "azure" ? new AzureClient(config.azure) : new GCPClient(config.gcp);
+
+    // Download file
+    console.log(`Downloading ${blobKey}`);
+    const fileBuffer = await client.downloadFile(blobKey);
+    if (!fileBuffer) {
+      throw new Error(`Failed to download file ${blobKey}`);
+    }
+
+    // Convert
+    console.log(`Converting ${name}`);
+    const pdfBuffer = await convertPptxToPdf(fileBuffer, name);
+    const newName = path.parse(name).name + ".pdf";
+    const newBlobKey = blobKey.replace(/\.pptx$/i, ".pdf");
+
+    // Upload PDF
+    console.log(`Uploading PDF to ${newBlobKey}`);
+    await client.uploadFile(pdfBuffer, newBlobKey, "application/pdf");
+    const { url, expiry } = await client.getSignedUrl(newBlobKey);
+
+    // Update DB
+    await db
+      .update(schema.document)
+      .set({
+        name: newName,
+        contentType: "application/pdf",
+        blobKey: newBlobKey,
+        blobUrl: url,
+        blobUrlExpiry: expiry,
+      })
+      .where(eq(schema.document.id, documentId));
+
+    console.log(`Conversion complete for ${documentId}`);
+
+    return { success: true, newBlobKey };
+  },
+});

package/apps/conversion-worker/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/apps/conversion-worker/vite.config.ts

@@ -0,0 +1,33 @@
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL(".", import.meta.url));
+
+import { defineConfig } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  build: {
+    target: "node22",
+    ssr: true,
+    outDir: "dist",
+    rollupOptions: {
+      input: resolve(root, "src/main.ts"),
+      output: {
+        format: "es",
+        entryFileNames: "[name].js",
+      },
+      external: [
+        "@hatchet-dev/typescript-sdk",
+        "drizzle-orm",
+      ],
+    },
+    sourcemap: false,
+  },
+  resolve: {
+    alias: {
+      "@": resolve(root, "./src"),
+    },
+  },
+});

package/apps/main/.prettierignore

@@ -0,0 +1,6 @@
+dist
+*.gen.ts
+*.md
+.tanstack
+.nitro
+.output

package/apps/main/.prettierrc.js

@@ -0,0 +1,3 @@
+import config from "@sea/lint/prettier";
+
+export default config;