sea-dev 1.0.0

package/libs/dal/src/tool.ts

@@ -0,0 +1,159 @@
+import { db, schema } from "@sea/db";
+import type { Member, Tool } from "@sea/db/types";
+import { and, eq } from "drizzle-orm";
+
+export async function getToolsForConversation({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}): Promise<Tool[]> {
+  // First verify the conversation belongs to the member's organization
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.organizationId, member.organizationId),
+    ),
+  });
+
+  if (!conversation) return [];
+
+  return await db.query.tool.findMany({
+    where: eq(schema.tool.conversationId, conversationId),
+  });
+}
+
+export async function getToolByName({
+  member,
+  conversationId,
+  toolName,
+}: {
+  member: Member;
+  conversationId: string;
+  toolName: string;
+}): Promise<Tool | null> {
+  // First verify the conversation belongs to the member's organization
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.organizationId, member.organizationId),
+    ),
+  });
+
+  if (!conversation) {
+    return null;
+  }
+
+  const tool = await db.query.tool.findFirst({
+    where: and(eq(schema.tool.conversationId, conversationId), eq(schema.tool.toolName, toolName)),
+  });
+
+  return tool ?? null;
+}
+
+export async function upsertToolConfig({
+  member,
+  conversationId,
+  toolName,
+  toolSchema,
+  description,
+}: {
+  member: Member;
+  conversationId: string;
+  toolName: string;
+  toolSchema: object;
+  description?: string | null;
+}): Promise<Tool> {
+  // First verify the conversation belongs to the member's organization
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.organizationId, member.organizationId),
+    ),
+  });
+
+  if (!conversation) {
+    throw new Error("Conversation not found");
+  }
+
+  // Check if tool already exists for this conversation
+  const existingTool = await db.query.tool.findFirst({
+    where: and(eq(schema.tool.conversationId, conversationId), eq(schema.tool.toolName, toolName)),
+  });
+
+  // Normalize description - convert empty string to undefined (which becomes null in DB)
+  const normalizedDescription = description && description.trim() !== "" ? description : null;
+
+  if (existingTool) {
+    // Update existing tool
+    const [updated] = await db
+      .update(schema.tool)
+      .set({
+        toolSchema,
+        description: normalizedDescription,
+        updatedAt: new Date(),
+      })
+      .where(eq(schema.tool.id, existingTool.id))
+      .returning();
+    return updated!;
+  }
+
+  // Insert new tool
+  const [inserted] = await db
+    .insert(schema.tool)
+    .values({
+      conversationId,
+      toolName,
+      toolSchema,
+      description: normalizedDescription,
+    })
+    .returning();
+  return inserted!;
+}
+
+export async function updateToolDescription({
+  member,
+  conversationId,
+  toolName,
+  description,
+}: {
+  member: Member;
+  conversationId: string;
+  toolName: string;
+  description: string;
+}): Promise<Tool | null> {
+  // Verify the conversation belongs to the member's organization
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.organizationId, member.organizationId),
+    ),
+  });
+
+  if (!conversation) {
+    return null;
+  }
+
+  // Get or create the tool
+  const existingTool = await db.query.tool.findFirst({
+    where: and(eq(schema.tool.conversationId, conversationId), eq(schema.tool.toolName, toolName)),
+  });
+
+  if (existingTool) {
+    // Update existing tool - convert empty string to null to use default description
+    const [updated] = await db
+      .update(schema.tool)
+      .set({
+        description: description.trim() === "" ? null : description,
+        updatedAt: new Date(),
+      })
+      .where(eq(schema.tool.id, existingTool.id))
+      .returning();
+    return updated ?? null;
+  }
+
+  // If tool doesn't exist yet, we can't update it
+  // The UI should handle this by creating it first
+  return null;
+}

package/libs/dal/src/user.ts

@@ -0,0 +1,16 @@
+import { isSiteAdmin } from "@/permission";
+import { db, schema } from "@sea/db";
+import { invariant } from "@sea/util/invariant";
+import { desc } from "drizzle-orm";
+import type { MemberHydrated } from "./member";
+
+export async function adminGetUsers({ member }: { member: MemberHydrated }) {
+  const siteAdmin = isSiteAdmin({ member });
+  invariant(siteAdmin);
+
+  const users = await db.query.user.findMany({
+    with: { members: { with: { organization: true } } },
+    orderBy: [desc(schema.user.name)],
+  });
+  return users;
+}

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

@@ -0,0 +1,89 @@
+import { resetTestDb } from "@/_tests/mock-db"; // Must always be the first import
+
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { beforeEach, describe, expect, it } from "vitest";
+import { getWorkflow, getWorkflows } from "./workflow";
+
+describe("dbtest: getWorkflow", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents access to workflow from other organizations", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create workflow for both organizations
+    const [workflow1, workflow2] = await db
+      .insert(schema.workflow)
+      .values([
+        { organizationId: org1!.id, name: "Workflow 1", slug: "workflow-1" },
+        { organizationId: org2!.id, name: "Workflow 2", slug: "workflow-2" },
+      ])
+      .returning();
+
+    // Create member for org1
+    const member: Member = {
+      id: "member-1",
+      organizationId: org1!.id,
+      userId: "user-1",
+      role: "member",
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    // Should be able to access workflow from same organization
+    const result = await getWorkflow({ member, workflowSlug: workflow1!.slug });
+    if (!result.ok) throw new Error();
+    expect(result).toBeDefined();
+    expect(result.data.id).toBe(workflow1!.id);
+    expect(result.data.organizationId).toBe(org1!.id);
+
+    // Should NOT be able to access workflow from different organization
+    const resFail = await getWorkflow({ member, workflowSlug: workflow2!.slug });
+    expect(resFail.ok).toEqual(false);
+  });
+});
+
+describe("dbtest: getWorkflows", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents access to workflow from other organizations", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create workflow for both organizations
+    await db.insert(schema.workflow).values([
+      { organizationId: org1!.id, name: "Workflow 1", slug: "workflow-1" },
+      { organizationId: org1!.id, name: "Workflow 2", slug: "workflow-2" },
+      { organizationId: org2!.id, name: "Workflow 3", slug: "workflow-3" },
+    ]);
+
+    // Create member for org1
+    const member: Member = {
+      id: "member-1",
+      organizationId: org1!.id,
+      userId: "user-1",
+      role: "member",
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    // Should only return workflow from the same organization
+    const result = await getWorkflows({ member });
+    expect(result).toHaveLength(2);
+    expect(result.every((wf) => wf.organizationId === org1!.id)).toBe(true);
+    expect(result.map((wf) => wf.name)).toEqual(
+      expect.arrayContaining(["Workflow 1", "Workflow 2"]),
+    );
+  });
+});

package/libs/dal/src/workflow.ts

@@ -0,0 +1,262 @@
+import { db, schema } from "@sea/db";
+import type {
+  Form,
+  InsertFormDerived,
+  InsertFormField,
+  InsertFormGroup,
+  InsertWorkflow,
+  Member,
+  Submission,
+  Workflow,
+} from "@sea/db/types";
+import { nanoid } from "@sea/util/id";
+import { invariant } from "@sea/util/invariant";
+import { and, asc, countDistinct, desc, eq, getTableColumns, isNull } from "drizzle-orm";
+import type { DalResult } from "./result";
+
+export async function getWorkflows({ member }: { member: Member }) {
+  const workflows = await db
+    .select({
+      ...getTableColumns(schema.workflow),
+      formCount: countDistinct(schema.form.id),
+      submissionCount: countDistinct(schema.submission.id),
+    })
+    .from(schema.workflow)
+    .leftJoin(
+      schema.form,
+      and(eq(schema.form.workflowId, schema.workflow.id), isNull(schema.form.deletedAt)),
+    )
+    .leftJoin(
+      schema.submission,
+      and(eq(schema.submission.formId, schema.form.id), isNull(schema.submission.deletedAt)),
+    )
+    .where(
+      and(
+        eq(schema.workflow.organizationId, member.organizationId),
+        isNull(schema.workflow.deletedAt),
+      ),
+    )
+    .groupBy(schema.workflow.id)
+    .orderBy(desc(schema.workflow.updatedAt));
+
+  return workflows;
+}
+
+export async function createWorkflow({
+  member,
+  name,
+  hint,
+}: {
+  member: Member;
+  name: string;
+  hint?: string;
+}) {
+  const [workflow] = await db
+    .insert(schema.workflow)
+    .values({
+      organizationId: member.organizationId,
+      name,
+      hint: hint ?? "",
+    })
+    .returning();
+
+  return workflow;
+}
+
+export async function updateWorkflow({
+  member,
+  workflowId,
+  name,
+  hint,
+}: {
+  member: Member;
+  workflowId: string;
+  name?: string;
+  hint?: string;
+}) {
+  const updateData: Partial<InsertWorkflow> = {};
+
+  if (name !== undefined) {
+    updateData.name = name;
+  }
+  if (hint !== undefined) {
+    updateData.hint = hint;
+  }
+  if (Object.keys(updateData).length === 0) {
+    return null;
+  }
+
+  const [workflow] = await db
+    .update(schema.workflow)
+    .set(updateData)
+    .where(
+      and(
+        eq(schema.workflow.id, workflowId),
+        eq(schema.workflow.organizationId, member.organizationId),
+      ),
+    )
+    .returning();
+
+  return workflow ?? null;
+}
+
+export async function getWorkflow({
+  member,
+  workflowSlug,
+}: {
+  member: Member;
+  workflowSlug: string;
+}): Promise<
+  DalResult<
+    Workflow & {
+      forms: Array<Form & { submissions: Submission[] }>;
+    }
+  >
+> {
+  const workflow = await db.query.workflow.findFirst({
+    where: and(
+      eq(schema.workflow.organizationId, member.organizationId),
+      eq(schema.workflow.slug, workflowSlug),
+      isNull(schema.workflow.deletedAt),
+    ),
+    with: {
+      forms: {
+        where: isNull(schema.form.deletedAt),
+        orderBy: desc(schema.form.updatedAt),
+        with: {
+          // TODO this query is going to become too big sooner or later
+          // (And a big request payload)
+          // Probably only using this to get a count.
+          submissions: {
+            where: isNull(schema.submission.deletedAt),
+            orderBy: desc(schema.submission.updatedAt),
+          },
+        },
+      },
+    },
+  });
+  if (!workflow) {
+    return { ok: false, error: "not-found" };
+  }
+  return { ok: true, data: workflow };
+}
+
+export async function duplicateWorkflow({
+  member,
+  workflowId,
+}: {
+  member: Member;
+  workflowId: string;
+}) {
+  const { organizationId } = member;
+
+  // Get the existing workflow with all its forms
+  const existingWorkflow = await db.query.workflow.findFirst({
+    where: and(
+      eq(schema.workflow.organizationId, organizationId),
+      eq(schema.workflow.id, workflowId),
+      isNull(schema.workflow.deletedAt),
+    ),
+    with: {
+      forms: {
+        where: isNull(schema.form.deletedAt),
+        with: {
+          groups: {
+            with: { fields: true, derived: true },
+            orderBy: asc(schema.formGroup.order),
+          },
+        },
+      },
+    },
+  });
+
+  if (!existingWorkflow) {
+    return { ok: false, error: "not-found" } as const;
+  }
+
+  const newWorkflow = await db.transaction(async (tx) => {
+    // Create new workflow
+    const [workflow] = await tx
+      .insert(schema.workflow)
+      .values({
+        organizationId,
+        name: `${existingWorkflow.name} (copy)`,
+        hint: existingWorkflow.hint,
+      })
+      .returning();
+    invariant(workflow);
+
+    // Copy all forms
+    for (const existingForm of existingWorkflow.forms) {
+      // Create conversation for the form
+      const [conversation] = await tx
+        .insert(schema.conversation)
+        .values({ organizationId })
+        .returning();
+      invariant(conversation);
+
+      // Create the form
+      const [newForm] = await tx
+        .insert(schema.form)
+        .values({
+          workflowId: workflow.id,
+          organizationId,
+          conversationId: conversation.id,
+          name: existingForm.name,
+          hint: existingForm.hint,
+        })
+        .returning();
+      invariant(newForm);
+
+      // Copy groups, fields, and derived fields
+      const groups: Array<InsertFormGroup> = [];
+      const fields: Array<InsertFormField> = [];
+      const derived: Array<InsertFormDerived> = [];
+
+      existingForm.groups.forEach((group) => {
+        const formGroupId = nanoid();
+        groups.push({
+          id: formGroupId,
+          formId: newForm.id,
+          name: group.name,
+          multi: group.multi,
+          hint: group.hint,
+          order: group.order,
+        });
+
+        group.fields.forEach((field) => {
+          fields.push({
+            formGroupId,
+            name: field.name,
+            type: field.type,
+            hint: field.hint,
+            order: field.order,
+          });
+        });
+
+        // Copy derived fields if any
+        group.derived?.forEach((derivedField) => {
+          derived.push({
+            formGroupId,
+            name: derivedField.name,
+            prompt: derivedField.prompt,
+          });
+        });
+      });
+
+      if (groups.length > 0) {
+        await tx.insert(schema.formGroup).values(groups);
+      }
+      if (fields.length > 0) {
+        await tx.insert(schema.formField).values(fields);
+      }
+      if (derived.length > 0) {
+        await tx.insert(schema.formDerived).values(derived);
+      }
+    }
+
+    return workflow;
+  });
+
+  return { ok: true, data: newWorkflow } as const;
+}

package/libs/dal/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["dist", "src/**/*.test.ts"]
+}

package/libs/dal/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "target": "ES2022",
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noUncheckedIndexedAccess": true,
+    "baseUrl": ".",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "lib": ["ES2022", "DOM"],
+    "types": ["vitest/globals"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist"]
+}

package/libs/dal/vite.config.ts

@@ -0,0 +1,34 @@
+import { globSync } from "glob";
+import { resolve } from "path";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+const entries = Object.fromEntries(
+  globSync("src/**/*.ts", { ignore: ["src/**/*.d.ts", "src/**/*.test.ts"] }).map((file) => [
+    // Remove src/ and .ts extension for the key
+    file.slice(4, -3),
+    resolve(__dirname, file),
+  ]),
+);
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  build: {
+    lib: {
+      entry: entries,
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: (id) => {
+        // Externalize all dependencies (anything from node_modules)
+        return !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("@/");
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src"),
+    },
+  },
+  plugins: [dts()],
+});

package/libs/db/.prettierignore

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

package/libs/db/.prettierrc.js

@@ -0,0 +1,12 @@
+/* eslint-env node */
+/** @type {import("prettier").Config} */
+const config = {
+  plugins: ["prettier-plugin-organize-imports", "prettier-plugin-tailwindcss"],
+  tailwindFunctions: ["cva", "clsx", "cn"],
+  printWidth: 100,
+  tabWidth: 2,
+  singleQuote: false,
+  quoteProps: "as-needed",
+};
+
+export default config;

package/libs/db/eslint.config.mjs

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

package/libs/db/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@sea/db",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./schema": {
+      "import": "./dist/schema.js",
+      "types": "./dist/schema.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "vite build",
+    "fmt": "prettier --log-level warn --write .",
+    "lint": "eslint --fix . --ext .js,.jsx,.ts,.tsx",
+    "check": "tsc --noEmit",
+    "ci:fmt": "prettier --check .",
+    "ci:lint": "eslint . --ext .js,.jsx,.ts,.tsx",
+    "ci:check": "pnpm run check",
+    "all": "pnpm run fmt && pnpm run lint && pnpm run check"
+  },
+  "dependencies": {
+    "@sea/util": "workspace:*",
+    "@sea/config": "workspace:*",
+    "drizzle-orm": "^0.43.1",
+    "nanoid": "^5.1.5",
+    "pg": "^8.15.6",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@sea/lint": "workspace:*",
+    "@types/pg": "^8.11.11",
+    "drizzle-kit": "^0.30.5",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0",
+    "pnpm": ">=10.13.0 <11.0.0"
+  },
+  "overrides": {}
+}

package/libs/db/src/index.ts

@@ -0,0 +1,24 @@
+import { getDbConfig } from "@sea/config/db";
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import * as schema from "./schema";
+
+const environment =
+  process.env.NODE_ENV === "production" ? ("production" as const) : ("staging" as const);
+
+const dbUrl = getDbConfig(environment).url;
+if (!dbUrl) {
+  throw new Error("Need DATABASE_URL set");
+}
+
+export const pool = new pg.Pool({
+  // this url needs sslmode=require
+  connectionString: dbUrl,
+  idleTimeoutMillis: 60000, // Release idle connections after 1 minute
+  connectionTimeoutMillis: 5000, // Fail fast if pool exhausted
+});
+
+export const db = drizzle({ schema, client: pool });
+
+export { PIPELINE_RUN_STATUS, PIPELINE_RUN_STEP_STATUS } from "./schemas/pipelines";
+export { schema };