sea-dev 1.0.0

package/libs/dal/src/invitation.ts

@@ -0,0 +1,207 @@
+import { db, schema } from "@sea/db";
+import type { Member } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import type { Session, User } from "better-auth";
+import { addDays } from "date-fns";
+import { and, desc, eq, gt } from "drizzle-orm";
+import type { MemberHydrated } from "./member";
+
+export async function getPendingInvites({ member }: { member: Member }) {
+  const invites = await db.query.invitation.findMany({
+    where: and(
+      eq(schema.invitation.status, "pending"),
+      eq(schema.invitation.organizationId, member.organizationId),
+    ),
+    orderBy: [desc(schema.invitation.createdAt)],
+  });
+  return invites;
+}
+
+export async function createInvite({
+  member,
+  email,
+  emailSender,
+}: {
+  member: MemberHydrated;
+  email: string;
+  emailSender: (args: {
+    email: string;
+    fromName: string;
+    fromOrg: string;
+    inviteId: string;
+  }) => Promise<void>;
+}): Promise<
+  { success: false; inviteId: undefined; message: string } | { success: true; inviteId: string }
+> {
+  const existingInvite = await db.query.invitation.findFirst({
+    where: and(
+      eq(schema.invitation.organizationId, member.organizationId),
+      eq(schema.invitation.email, email),
+      eq(schema.invitation.status, "pending"),
+    ),
+  });
+  if (existingInvite) {
+    return { success: false, inviteId: undefined, message: "Person already invited!" };
+  }
+
+  const [invite] = await db
+    .insert(schema.invitation)
+    .values({
+      organizationId: member.organizationId,
+      email,
+      status: "pending",
+      expiresAt: addDays(new Date(), 14),
+      inviterId: member.userId,
+    })
+    .returning();
+  invariant(invite);
+
+  await emailSender({
+    email,
+    fromName: member.user.name,
+    fromOrg: member.organization.name,
+    inviteId: invite.id,
+  });
+
+  return { success: true, inviteId: invite.id };
+}
+
+export async function resendInvite({
+  member,
+  inviteId,
+  emailSender,
+}: {
+  member: MemberHydrated;
+  inviteId: string;
+  emailSender: CallableFunction;
+}) {
+  const whereExisting = and(
+    eq(schema.invitation.organizationId, member.organizationId),
+    eq(schema.invitation.id, inviteId),
+  );
+  await db.transaction(async (tx) => {
+    const existingInvite = await tx.query.invitation.findFirst({
+      where: whereExisting,
+    });
+    invariant(existingInvite);
+    const { email } = existingInvite;
+
+    const [invite] = await db
+      .insert(schema.invitation)
+      .values({
+        organizationId: member.organizationId,
+        email,
+        status: "pending",
+        expiresAt: addDays(new Date(), 14),
+        inviterId: member.userId,
+      })
+      .returning();
+    invariant(invite);
+
+    await emailSender({
+      email,
+      fromName: member.user.name,
+      fromOrg: member.organization.name,
+      inviteId: invite.id,
+    });
+
+    await db.update(schema.invitation).set({ status: "canceled" }).where(whereExisting);
+  });
+}
+
+type InvitationWithOrg = NonNullable<
+  Awaited<
+    ReturnType<
+      typeof db.query.invitation.findFirst<{
+        with: { organization: true };
+      }>
+    >
+  >
+>;
+
+export async function getInvite({
+  inviteId,
+  user,
+}: {
+  inviteId: string;
+  user: User;
+}): Promise<
+  | { type: "valid"; invitation: InvitationWithOrg }
+  | { type: "email-mismatch" }
+  | { type: "not-found" }
+> {
+  const invitation = await db.query.invitation.findFirst({
+    where: and(
+      eq(schema.invitation.id, inviteId),
+      gt(schema.invitation.expiresAt, new Date()),
+      eq(schema.invitation.status, "pending"),
+    ),
+    with: { organization: true },
+  });
+
+  if (!invitation) {
+    return { type: "not-found" };
+  }
+
+  if (invitation.email !== user.email) {
+    return { type: "email-mismatch" };
+  }
+
+  return { type: "valid", invitation };
+}
+
+export async function rejectInvite({ inviteId, user }: { inviteId: string; user: User }) {
+  await db
+    .update(schema.invitation)
+    .set({
+      status: "rejected",
+    })
+    .where(eq(schema.invitation.id, inviteId));
+
+  const maybeExistingMember = await db.query.member.findFirst({
+    where: eq(schema.member.userId, user.id),
+  });
+  return maybeExistingMember;
+}
+
+export async function cancelInvite({ inviteId, member }: { inviteId: string; member: Member }) {
+  await db
+    .update(schema.invitation)
+    .set({ status: "canceled" })
+    .where(
+      and(
+        eq(schema.invitation.organizationId, member.organizationId),
+        eq(schema.invitation.id, inviteId),
+      ),
+    );
+}
+
+export async function acceptInvite({
+  inviteId,
+  session,
+  user,
+}: {
+  inviteId: string;
+  session: Session;
+  user: User;
+}) {
+  const inviteResult = await getInvite({ inviteId, user });
+  invariant(inviteResult.type === "valid");
+  const { invitation } = inviteResult;
+
+  await db.transaction(async (tx) => {
+    await tx.insert(schema.member).values({
+      organizationId: invitation.organizationId,
+      userId: user.id,
+      role: "member",
+    });
+    await tx
+      .update(schema.invitation)
+      .set({ status: "accepted" })
+      .where(eq(schema.invitation.id, inviteId));
+    await tx
+      .update(schema.session)
+      .set({ activeOrganizationId: invitation.organizationId })
+      .where(eq(schema.session.id, session.id));
+  });
+}

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

@@ -0,0 +1,185 @@
+import { resetTestDb } from "./_tests/mock-db"; // Must always be the first import
+
+import { db, schema } from "@sea/db";
+import { beforeEach, describe, expect, it } from "vitest";
+import { getMembers, removeMember, setMemberRole } from "./member";
+
+describe("dbtest: getMembers", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents cross-organization access by returning only members from the same organization", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create users
+    const [user1, user2, user3] = await db
+      .insert(schema.user)
+      .values([
+        { name: "User 1", email: "user1-member@example.com", emailVerified: true },
+        { name: "User 2", email: "user2-member@example.com", emailVerified: true },
+        { name: "User 3", email: "user3-member@example.com", emailVerified: true },
+      ])
+      .returning();
+
+    // Create members: user1 and user2 in org1, user3 in org2
+    const [member1, member2, member3] = await db
+      .insert(schema.member)
+      .values([
+        { organizationId: org1!.id, userId: user1!.id, role: "admin" },
+        { organizationId: org1!.id, userId: user2!.id, role: "member" },
+        { organizationId: org2!.id, userId: user3!.id, role: "admin" },
+      ])
+      .returning();
+
+    // Test getting members for org1 - should only return members from org1
+    const membersOrg1 = await getMembers({ member: member1! });
+    expect(membersOrg1).toHaveLength(2);
+    expect(membersOrg1.every((m) => m.organizationId === org1!.id)).toBe(true);
+    expect(membersOrg1.find((m) => m.id === member1!.id)).toBeDefined();
+    expect(membersOrg1.find((m) => m.id === member2!.id)).toBeDefined();
+    expect(membersOrg1.find((m) => m.id === member3!.id)).toBeUndefined();
+
+    // Test getting members for org2 - should only return members from org2
+    const membersOrg2 = await getMembers({ member: member3! });
+    expect(membersOrg2).toHaveLength(1);
+    expect(membersOrg2.every((m) => m.organizationId === org2!.id)).toBe(true);
+    expect(membersOrg2.find((m) => m.id === member3!.id)).toBeDefined();
+    expect(membersOrg2.find((m) => m.id === member1!.id)).toBeUndefined();
+    expect(membersOrg2.find((m) => m.id === member2!.id)).toBeUndefined();
+
+    // Verify user data is included
+    expect(membersOrg1[0]!.user).toBeDefined();
+    expect(membersOrg1[0]!.user.name).toBeTruthy();
+    expect(membersOrg1[0]!.user.email).toBeTruthy();
+  });
+});
+
+describe("dbtest: setMemberRole", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents cross-organization access by only allowing role changes within the same organization", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create users
+    const [user1, user2, user3] = await db
+      .insert(schema.user)
+      .values([
+        { name: "User 1", email: "user1-setrole@example.com", emailVerified: true },
+        { name: "User 2", email: "user2-setrole@example.com", emailVerified: true },
+        { name: "User 3", email: "user3-setrole@example.com", emailVerified: true },
+      ])
+      .returning();
+
+    // Create members: user1 (admin) and user2 (member) in org1, user3 (admin) in org2
+    const [member1, member2, member3] = await db
+      .insert(schema.member)
+      .values([
+        { organizationId: org1!.id, userId: user1!.id, role: "admin" },
+        { organizationId: org1!.id, userId: user2!.id, role: "member" },
+        { organizationId: org2!.id, userId: user3!.id, role: "admin" },
+      ])
+      .returning();
+
+    // Admin from org1 tries to change role of member from org2 - should not work
+    await setMemberRole({
+      member: member1!,
+      memberId: member3!.id,
+      role: "member",
+    });
+
+    // Verify that member3's role was not changed
+    const unchangedMember = await db.query.member.findFirst({
+      where: (table, { eq }) => eq(table.id, member3!.id),
+    });
+    expect(unchangedMember!.role).toBe("admin");
+
+    // Admin from org1 changes role of member from org1 - should work
+    await setMemberRole({
+      member: member1!,
+      memberId: member2!.id,
+      role: "admin",
+    });
+
+    // Verify that member2's role was changed
+    const changedMember = await db.query.member.findFirst({
+      where: (table, { eq }) => eq(table.id, member2!.id),
+    });
+    expect(changedMember!.role).toBe("admin");
+  });
+});
+
+describe("dbtest: removeMember", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+  });
+
+  it("prevents cross-organization access by only allowing member removal within the same organization", async () => {
+    // Create two organizations
+    const [org1, org2] = await db
+      .insert(schema.organization)
+      .values([{ name: "Org 1" }, { name: "Org 2" }])
+      .returning();
+
+    // Create users
+    const [user1, user2, user3] = await db
+      .insert(schema.user)
+      .values([
+        { name: "User 1", email: "user1-remove@example.com", emailVerified: true },
+        { name: "User 2", email: "user2-remove@example.com", emailVerified: true },
+        { name: "User 3", email: "user3-remove@example.com", emailVerified: true },
+      ])
+      .returning();
+
+    // Create members: user1 (admin) and user2 (member) in org1, user3 (admin) in org2
+    const [member1, member2, member3] = await db
+      .insert(schema.member)
+      .values([
+        { organizationId: org1!.id, userId: user1!.id, role: "admin" },
+        { organizationId: org1!.id, userId: user2!.id, role: "member" },
+        { organizationId: org2!.id, userId: user3!.id, role: "admin" },
+      ])
+      .returning();
+
+    // Admin from org1 tries to remove member from org2 - should not work
+    await removeMember({
+      member: member1!,
+      memberId: member3!.id,
+    });
+
+    // Verify that member3 was not removed
+    const unchangedMember = await db.query.member.findFirst({
+      where: (table, { eq }) => eq(table.id, member3!.id),
+    });
+    expect(unchangedMember).toBeDefined();
+    expect(unchangedMember!.organizationId).toBe(org2!.id);
+
+    // Admin from org1 removes member from org1 - should work
+    await removeMember({
+      member: member1!,
+      memberId: member2!.id,
+    });
+
+    // Verify that member2 was removed
+    const removedMember = await db.query.member.findFirst({
+      where: (table, { eq }) => eq(table.id, member2!.id),
+    });
+    expect(removedMember).toBeUndefined();
+
+    // Verify that member1 still exists (can't delete self)
+    const selfMember = await db.query.member.findFirst({
+      where: (table, { eq }) => eq(table.id, member1!.id),
+    });
+    expect(selfMember).toBeDefined();
+  });
+});

package/libs/dal/src/member.ts

@@ -0,0 +1,80 @@
+import { isOrgAdmin } from "@/permission";
+import { db, schema } from "@sea/db";
+import { type MemberRole } from "@sea/db/schema";
+import type { User as DbUser, Member, Organization } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { and, desc, eq, ne } from "drizzle-orm";
+import type { DalResult } from "./result";
+
+export type MemberHydrated = Member & { user: DbUser; organization: Organization };
+
+export async function getMember({
+  userId,
+  activeOrganizationId,
+}: {
+  userId: string;
+  activeOrganizationId?: string | null;
+}): Promise<DalResult<MemberHydrated>> {
+  const member = await db.query.member.findFirst({
+    where: activeOrganizationId
+      ? and(
+          eq(schema.member.organizationId, activeOrganizationId),
+          eq(schema.member.userId, userId),
+        )
+      : eq(schema.member.userId, userId),
+    with: { organization: true, user: true },
+  });
+  if (!member) {
+    return { ok: false, error: "not-found" };
+  }
+
+  return { ok: true, data: member };
+}
+
+export async function getMembers({ member }: { member: Member }) {
+  const members = await db.query.member.findMany({
+    where: eq(schema.member.organizationId, member.organizationId),
+    with: { user: true },
+    orderBy: [desc(schema.member.id)],
+  });
+  return members;
+}
+
+export async function setMemberRole({
+  member,
+  role,
+  memberId,
+}: {
+  member: Member;
+  role: MemberRole;
+  memberId: string;
+}) {
+  const admin = isOrgAdmin({ member });
+  invariant(admin);
+
+  await db
+    .update(schema.member)
+    .set({ role })
+    .where(
+      and(
+        eq(schema.member.organizationId, member.organizationId),
+        eq(schema.member.id, memberId),
+        // Can't edit own role
+        ne(schema.member.id, member.id),
+      ),
+    );
+}
+
+export async function removeMember({ member, memberId }: { member: Member; memberId: string }) {
+  const admin = isOrgAdmin({ member });
+  invariant(admin);
+
+  await db.delete(schema.member).where(
+    and(
+      eq(schema.member.organizationId, member.organizationId),
+      eq(schema.member.id, memberId),
+      // Can't delete self
+      ne(schema.member.id, member.id),
+    ),
+  );
+}

package/libs/dal/src/organization.ts

@@ -0,0 +1,116 @@
+import { db, schema } from "@sea/db";
+import type {
+  InsertConversation,
+  InsertForm,
+  InsertFormField,
+  InsertFormGroup,
+  InsertWorkflow,
+  Organization,
+} from "@sea/db/types";
+import { nanoid } from "@sea/util/id";
+import { invariant } from "@sea/util/invariant";
+import { and, asc, eq } from "drizzle-orm";
+import { defaultDeals, defaultWorkflows } from "./defaults";
+import type { MemberHydrated } from "./member";
+
+export async function getAvailableOrganizations({
+  member,
+}: {
+  member: MemberHydrated;
+}): Promise<Organization[]> {
+  const members = await db.query.member.findMany({
+    where: and(eq(schema.member.userId, member.userId)),
+    with: {
+      organization: true,
+    },
+    orderBy: asc(schema.member.createdAt),
+  });
+  const organizations = members.map((m) => m.organization);
+
+  return organizations;
+}
+
+export async function insertOrganizationDefaults({ organization }: { organization: Organization }) {
+  const { id: organizationId } = organization;
+  const deals = defaultDeals.map((d) => ({ organizationId, ...d }));
+
+  const workflows: InsertWorkflow[] = [];
+  const conversations: InsertConversation[] = [];
+  const forms: InsertForm[] = [];
+  const groups: InsertFormGroup[] = [];
+  const fields: InsertFormField[] = [];
+
+  // Always use simple default workflows
+  defaultWorkflows.forEach((workflow) => {
+    const workflowId = nanoid();
+    workflows.push({ id: workflowId, organizationId, ...workflow });
+
+    workflow.forms?.forEach((form) => {
+      const formId = nanoid();
+      const conversationId = nanoid();
+      // prettier-ignore
+      forms.push({ id: formId, conversationId, workflowId, organizationId, ...form });
+      conversations.push({ id: conversationId, organizationId });
+
+      form.groups?.forEach((group) => {
+        const formGroupId = nanoid();
+        groups.push({ id: formGroupId, formId, ...group });
+
+        group.fields?.forEach((field) => {
+          fields.push({ formGroupId, ...field });
+        });
+      });
+    });
+  });
+
+  await db.transaction(async (tx) => {
+    await tx.insert(schema.deal).values(deals);
+    await tx.insert(schema.workflow).values(workflows);
+    await tx.insert(schema.conversation).values(conversations);
+    await tx.insert(schema.form).values(forms);
+    await tx.insert(schema.formGroup).values(groups);
+    await tx.insert(schema.formField).values(fields);
+  });
+}
+
+export async function createOrganization({
+  userId,
+  sessionId,
+  orgName,
+  userName,
+}: {
+  userId: string;
+  sessionId: string;
+  orgName: string;
+  userName?: string;
+}) {
+  const organization = await db.transaction(async (tx) => {
+    if (userName) {
+      await tx.update(schema.user).set({ name: userName }).where(eq(schema.user.id, userId));
+    }
+    const [organization] = await tx
+      .insert(schema.organization)
+      .values({ name: orgName })
+      .returning();
+    invariant(organization);
+    const { id: organizationId } = organization;
+
+    await tx.insert(schema.orgSettings).values({ organizationId });
+
+    await tx.insert(schema.member).values({
+      organizationId,
+      userId: userId,
+      role: "admin",
+    });
+
+    await tx
+      .update(schema.session)
+      .set({
+        activeOrganizationId: organizationId,
+      })
+      .where(eq(schema.session.id, sessionId));
+    return organization;
+  });
+
+  return organization;
+}

package/libs/dal/src/permission.ts

@@ -0,0 +1,25 @@
+import type { Member, User } from "@sea/db/types";
+import type { MemberHydrated } from "./member";
+
+export function isSiteAdmin({ member }: { member: MemberHydrated }): boolean {
+  const admin = member.user.role === "admin";
+  return admin;
+}
+
+export function isOrgAdmin({ member }: { member: Member }): boolean {
+  const admin = member.role === "admin";
+  return admin;
+}
+
+const EXPERIMENTAL_USERS = [
+  "chris@rdrn.me",
+  "matt@sea.dev",
+  "vladimirs@sea.dev",
+  "marya@sea.dev",
+  "claude-test@playwright.dev",
+];
+
+export function isExperimental({ member }: { member: { user: User } }): boolean {
+  const res = EXPERIMENTAL_USERS.includes(member.user.email);
+  return res;
+}