@wopr-network/platform-core 0.1.0

package/src/tenancy/drizzle-org-repository.ts

@@ -0,0 +1,169 @@
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import type { PlatformDb } from "../db/index.js";
+import { tenants } from "../db/schema/index.js";
+
+// ---------------------------------------------------------------------------
+// Domain types (no Drizzle imports)
+// ---------------------------------------------------------------------------
+
+export interface Tenant {
+  id: string;
+  name: string;
+  slug: string | null;
+  type: "personal" | "org";
+  ownerId: string;
+  billingEmail: string | null;
+  createdAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Interface
+// ---------------------------------------------------------------------------
+
+export interface IOrgRepository {
+  createOrg(ownerId: string, name: string, slug?: string): Promise<Tenant>;
+  ensurePersonalTenant(userId: string, displayName: string): Promise<Tenant>;
+  getById(id: string): Promise<Tenant | null>;
+  getBySlug(slug: string): Promise<Tenant | null>;
+  listOrgsByOwner(ownerId: string): Promise<Tenant[]>;
+  updateOrg(orgId: string, data: { name?: string; slug?: string; billingEmail?: string | null }): Promise<Tenant>;
+  updateOwner(orgId: string, newOwnerId: string): Promise<void>;
+  deleteOrg(orgId: string): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+
+function isUniqueConstraintViolation(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const code = (err as { code?: string }).code;
+  const cause = (err as { cause?: unknown }).cause;
+  const causeCode = cause && typeof cause === "object" ? (cause as { code?: string }).code : undefined;
+  const causeMsg = cause instanceof Error ? cause.message : "";
+  return (
+    code === "23505" ||
+    causeCode === "23505" ||
+    err.message.includes("duplicate key") ||
+    err.message.includes("UNIQUE") ||
+    causeMsg.includes("duplicate key") ||
+    causeMsg.includes("UNIQUE")
+  );
+}
+
+/** Slugify a name: lowercase, replace whitespace with hyphens, strip non-alphanumeric. */
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function toTenant(row: typeof tenants.$inferSelect): Tenant {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    type: row.type as "personal" | "org",
+    ownerId: row.ownerId,
+    billingEmail: row.billingEmail,
+    createdAt: row.createdAt,
+  };
+}
+
+export class DrizzleOrgRepository implements IOrgRepository {
+  constructor(private readonly db: PlatformDb) {}
+
+  async createOrg(ownerId: string, name: string, slug?: string): Promise<Tenant> {
+    const id = crypto.randomUUID();
+    const finalSlug = slug || slugify(name);
+    if (!finalSlug) {
+      throw Object.assign(new Error("Org name produces an empty slug; use only letters, numbers, or hyphens"), {
+        status: 400,
+      });
+    }
+
+    let row: typeof tenants.$inferSelect;
+    try {
+      row = (
+        await this.db
+          .insert(tenants)
+          .values({
+            id,
+            name,
+            slug: finalSlug,
+            type: "org",
+            ownerId,
+            createdAt: Date.now(),
+          })
+          .returning()
+      )[0];
+    } catch (err) {
+      if (isUniqueConstraintViolation(err)) {
+        throw new TRPCError({ code: "CONFLICT", message: "Organization slug already taken" });
+      }
+      throw err;
+    }
+
+    return toTenant(row);
+  }
+
+  async ensurePersonalTenant(userId: string, displayName: string): Promise<Tenant> {
+    // Use userId as the tenant ID for backward compatibility
+    await this.db
+      .insert(tenants)
+      .values({
+        id: userId,
+        name: displayName,
+        slug: null,
+        type: "personal",
+        ownerId: userId,
+        createdAt: Date.now(),
+      })
+      .onConflictDoNothing({ target: tenants.id });
+
+    const tenant = await this.getById(userId);
+    if (!tenant) throw new Error(`Personal tenant not found for user ${userId}`);
+    return tenant;
+  }
+
+  async getById(id: string): Promise<Tenant | null> {
+    const row = (await this.db.select().from(tenants).where(eq(tenants.id, id)))[0];
+    return row ? toTenant(row) : null;
+  }
+
+  async getBySlug(slug: string): Promise<Tenant | null> {
+    const row = (await this.db.select().from(tenants).where(eq(tenants.slug, slug)))[0];
+    return row ? toTenant(row) : null;
+  }
+
+  async listOrgsByOwner(ownerId: string): Promise<Tenant[]> {
+    const rows = await this.db.select().from(tenants).where(eq(tenants.ownerId, ownerId));
+    return rows.filter((r) => r.type === "org").map(toTenant);
+  }
+
+  async updateOrg(
+    orgId: string,
+    data: { name?: string; slug?: string; billingEmail?: string | null },
+  ): Promise<Tenant> {
+    const updates: Partial<typeof tenants.$inferInsert> = {};
+    if (data.name !== undefined) updates.name = data.name;
+    if (data.slug !== undefined) updates.slug = data.slug;
+    if (data.billingEmail !== undefined) updates.billingEmail = data.billingEmail;
+    const row = (await this.db.update(tenants).set(updates).where(eq(tenants.id, orgId)).returning())[0];
+    if (!row) throw new Error(`Org not found: ${orgId}`);
+    return toTenant(row);
+  }
+
+  async updateOwner(orgId: string, newOwnerId: string): Promise<void> {
+    await this.db.update(tenants).set({ ownerId: newOwnerId }).where(eq(tenants.id, orgId));
+  }
+
+  async deleteOrg(orgId: string): Promise<void> {
+    await this.db.delete(tenants).where(eq(tenants.id, orgId));
+  }
+}

package/src/tenancy/index.ts

@@ -0,0 +1,6 @@
+export type { Tenant, IOrgRepository } from "./drizzle-org-repository.js";
+export { DrizzleOrgRepository } from "./drizzle-org-repository.js";
+export type { OrgMemberRow, OrgInviteRow, IOrgMemberRepository } from "./org-member-repository.js";
+export { DrizzleOrgMemberRepository } from "./org-member-repository.js";
+export type { OrgWithMembers, OrgMemberWithUser, OrgInvitePublic, OrgServiceOptions } from "./org-service.js";
+export { OrgService } from "./org-service.js";

package/src/tenancy/org-member-repository.ts

@@ -0,0 +1,159 @@
+/**
+ * Repository for organization members and invites.
+ *
+ * Follows the mandatory repository pattern: IOrgMemberRepository interface +
+ * DrizzleOrgMemberRepository implementation in the same file.
+ * See: src/fleet/bot-instance-repository.ts
+ */
+
+import { and, eq, gt, inArray } from "drizzle-orm";
+import type { PlatformDb } from "../db/index.js";
+import { organizationInvites, organizationMembers } from "../db/schema/organization-members.js";
+
+// ---------------------------------------------------------------------------
+// Domain types (no Drizzle imports)
+// ---------------------------------------------------------------------------
+
+export interface OrgMemberRow {
+  id: string;
+  orgId: string;
+  userId: string;
+  role: "owner" | "admin" | "member";
+  joinedAt: number;
+}
+
+export interface OrgInviteRow {
+  id: string;
+  orgId: string;
+  email: string;
+  role: "admin" | "member";
+  invitedBy: string;
+  token: string;
+  expiresAt: number;
+  createdAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Interface
+// ---------------------------------------------------------------------------
+
+export interface IOrgMemberRepository {
+  listMembers(orgId: string): Promise<OrgMemberRow[]>;
+  addMember(member: OrgMemberRow): Promise<void>;
+  updateMemberRole(orgId: string, userId: string, role: "owner" | "admin" | "member"): Promise<void>;
+  removeMember(orgId: string, userId: string): Promise<void>;
+  findMember(orgId: string, userId: string): Promise<OrgMemberRow | null>;
+  countAdminsAndOwners(orgId: string): Promise<number>;
+
+  listInvites(orgId: string): Promise<OrgInviteRow[]>;
+  createInvite(invite: OrgInviteRow): Promise<void>;
+  findInviteById(inviteId: string): Promise<OrgInviteRow | null>;
+  findInviteByToken(token: string): Promise<OrgInviteRow | null>;
+  deleteInvite(inviteId: string): Promise<void>;
+  deleteAllMembers(orgId: string): Promise<void>;
+  deleteAllInvites(orgId: string): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+
+function toMember(row: typeof organizationMembers.$inferSelect): OrgMemberRow {
+  return {
+    id: row.id,
+    orgId: row.orgId,
+    userId: row.userId,
+    role: row.role as "owner" | "admin" | "member",
+    joinedAt: row.joinedAt,
+  };
+}
+
+function toInvite(row: typeof organizationInvites.$inferSelect): OrgInviteRow {
+  return {
+    id: row.id,
+    orgId: row.orgId,
+    email: row.email,
+    role: row.role as "admin" | "member",
+    invitedBy: row.invitedBy,
+    token: row.token,
+    expiresAt: row.expiresAt,
+    createdAt: row.createdAt,
+  };
+}
+
+export class DrizzleOrgMemberRepository implements IOrgMemberRepository {
+  constructor(private readonly db: PlatformDb) {}
+
+  async listMembers(orgId: string): Promise<OrgMemberRow[]> {
+    const rows = await this.db.select().from(organizationMembers).where(eq(organizationMembers.orgId, orgId));
+    return rows.map(toMember);
+  }
+
+  async addMember(member: OrgMemberRow): Promise<void> {
+    await this.db.insert(organizationMembers).values(member).onConflictDoNothing();
+  }
+
+  async updateMemberRole(orgId: string, userId: string, role: "owner" | "admin" | "member"): Promise<void> {
+    await this.db
+      .update(organizationMembers)
+      .set({ role })
+      .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+  }
+
+  async removeMember(orgId: string, userId: string): Promise<void> {
+    await this.db
+      .delete(organizationMembers)
+      .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+  }
+
+  async findMember(orgId: string, userId: string): Promise<OrgMemberRow | null> {
+    const rows = await this.db
+      .select()
+      .from(organizationMembers)
+      .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+    return rows[0] ? toMember(rows[0]) : null;
+  }
+
+  async countAdminsAndOwners(orgId: string): Promise<number> {
+    const rows = await this.db
+      .select()
+      .from(organizationMembers)
+      .where(and(eq(organizationMembers.orgId, orgId), inArray(organizationMembers.role, ["admin", "owner"])));
+    return rows.length;
+  }
+
+  async listInvites(orgId: string): Promise<OrgInviteRow[]> {
+    const now = Date.now();
+    const rows = await this.db
+      .select()
+      .from(organizationInvites)
+      .where(and(eq(organizationInvites.orgId, orgId), gt(organizationInvites.expiresAt, now)));
+    return rows.map(toInvite);
+  }
+
+  async createInvite(invite: OrgInviteRow): Promise<void> {
+    await this.db.insert(organizationInvites).values(invite);
+  }
+
+  async findInviteById(inviteId: string): Promise<OrgInviteRow | null> {
+    const rows = await this.db.select().from(organizationInvites).where(eq(organizationInvites.id, inviteId));
+    return rows[0] ? toInvite(rows[0]) : null;
+  }
+
+  async findInviteByToken(token: string): Promise<OrgInviteRow | null> {
+    const rows = await this.db.select().from(organizationInvites).where(eq(organizationInvites.token, token));
+    return rows[0] ? toInvite(rows[0]) : null;
+  }
+
+  async deleteInvite(inviteId: string): Promise<void> {
+    await this.db.delete(organizationInvites).where(eq(organizationInvites.id, inviteId));
+  }
+
+  async deleteAllMembers(orgId: string): Promise<void> {
+    await this.db.delete(organizationMembers).where(eq(organizationMembers.orgId, orgId));
+  }
+
+  async deleteAllInvites(orgId: string): Promise<void> {
+    await this.db.delete(organizationInvites).where(eq(organizationInvites.orgId, orgId));
+  }
+}

package/src/tenancy/org-repository.test.ts

@@ -0,0 +1,172 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import type { PlatformDb } from "../db/index.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleOrgRepository, type IOrgRepository } from "./drizzle-org-repository.js";
+
+let db: PlatformDb;
+let pool: PGlite;
+
+beforeAll(async () => {
+  ({ db, pool } = await createTestDb());
+  await beginTestTransaction(pool);
+});
+
+afterAll(async () => {
+  await endTestTransaction(pool);
+  await pool.close();
+});
+
+describe("DrizzleOrgRepository", () => {
+  let repo: IOrgRepository;
+
+  beforeEach(async () => {
+    await rollbackTestTransaction(pool);
+    repo = new DrizzleOrgRepository(db);
+  });
+
+  describe("createOrg", () => {
+    it("creates an org tenant and returns it", async () => {
+      const org = await repo.createOrg("user-1", "My Org", "my-org");
+      expect(org.name).toBe("My Org");
+      expect(org.slug).toBe("my-org");
+      expect(org.type).toBe("org");
+      expect(org.ownerId).toBe("user-1");
+      expect(org.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+    });
+
+    it("throws on duplicate slug", async () => {
+      await repo.createOrg("user-1", "Org A", "same-slug");
+      await expect(repo.createOrg("user-2", "Org B", "same-slug")).rejects.toThrow();
+    });
+
+    it("auto-generates slug from name when slug is omitted", async () => {
+      const org = await repo.createOrg("user-1", "My Cool Org");
+      expect(org.slug).toBe("my-cool-org");
+    });
+  });
+
+  describe("ensurePersonalTenant", () => {
+    it("creates a personal tenant for a user", async () => {
+      const tenant = await repo.ensurePersonalTenant("user-1", "Alice");
+      expect(tenant.id).toBe("user-1");
+      expect(tenant.type).toBe("personal");
+      expect(tenant.name).toBe("Alice");
+    });
+
+    it("is idempotent — second call does not throw", async () => {
+      await repo.ensurePersonalTenant("user-1", "Alice");
+      const tenant = await repo.ensurePersonalTenant("user-1", "Alice");
+      expect(tenant.id).toBe("user-1");
+    });
+  });
+
+  describe("listByUser", () => {
+    it("returns orgs where user has a role (via userIds)", async () => {
+      const org = await repo.createOrg("user-1", "Org A", "org-a");
+      expect(await repo.getById(org.id)).toBeTruthy();
+    });
+  });
+
+  describe("getById", () => {
+    it("returns null for non-existent tenant", async () => {
+      expect(await repo.getById("nonexistent")).toBeNull();
+    });
+
+    it("returns a tenant by ID", async () => {
+      const org = await repo.createOrg("user-1", "Org A", "org-a");
+      const found = await repo.getById(org.id);
+      expect(found?.name).toBe("Org A");
+    });
+  });
+
+  describe("getBySlug", () => {
+    it("returns null for non-existent slug", async () => {
+      expect(await repo.getBySlug("nonexistent")).toBeNull();
+    });
+
+    it("finds a tenant by slug", async () => {
+      await repo.createOrg("user-1", "Org A", "org-a");
+      const found = await repo.getBySlug("org-a");
+      expect(found?.name).toBe("Org A");
+    });
+  });
+
+  describe("listOrgsByOwner", () => {
+    it("returns only org-type tenants for the owner", async () => {
+      await repo.ensurePersonalTenant("user-1", "Alice");
+      await repo.createOrg("user-1", "Org A", "org-a");
+      await repo.createOrg("user-1", "Org B", "org-b");
+      await repo.createOrg("user-2", "Other Org", "other");
+
+      const orgs = await repo.listOrgsByOwner("user-1");
+      expect(orgs).toHaveLength(2);
+      expect(orgs.map((o) => o.slug).sort()).toEqual(["org-a", "org-b"]);
+    });
+
+    it("returns empty array when owner has no orgs", async () => {
+      const orgs = await repo.listOrgsByOwner("nobody");
+      expect(orgs).toHaveLength(0);
+    });
+  });
+
+  describe("createOrg (edge cases)", () => {
+    it("throws when name produces an empty slug", async () => {
+      await expect(repo.createOrg("user-1", "---")).rejects.toThrow(/empty slug/);
+    });
+  });
+
+  describe("updateOrg", () => {
+    it("updates name and returns updated tenant", async () => {
+      const org = await repo.createOrg("user-1", "Original", "original");
+      const updated = await repo.updateOrg(org.id, { name: "Renamed" });
+      expect(updated.name).toBe("Renamed");
+      expect(updated.slug).toBe("original");
+    });
+
+    it("updates slug and returns updated tenant", async () => {
+      const org = await repo.createOrg("user-1", "Org", "old-slug");
+      const updated = await repo.updateOrg(org.id, { slug: "new-slug" });
+      expect(updated.slug).toBe("new-slug");
+    });
+
+    it("throws when org not found", async () => {
+      await expect(repo.updateOrg("nonexistent-id", { name: "X" })).rejects.toThrow(/not found/);
+    });
+
+    it("updates billingEmail and returns updated tenant", async () => {
+      const org = await repo.createOrg("user-1", "Org", "billing-test");
+      const updated = await repo.updateOrg(org.id, { billingEmail: "billing@example.com" });
+      expect(updated.billingEmail).toBe("billing@example.com");
+    });
+
+    it("clears billingEmail when set to null", async () => {
+      const org = await repo.createOrg("user-1", "Org", "billing-clear");
+      await repo.updateOrg(org.id, { billingEmail: "billing@example.com" });
+      const updated = await repo.updateOrg(org.id, { billingEmail: null });
+      expect(updated.billingEmail).toBeNull();
+    });
+  });
+
+  describe("updateOwner", () => {
+    it("persists the new ownerId", async () => {
+      const org = await repo.createOrg("user-1", "Org", "org-slug");
+      await repo.updateOwner(org.id, "user-2");
+      const updated = await repo.getById(org.id);
+      expect(updated?.ownerId).toBe("user-2");
+    });
+  });
+
+  describe("deleteOrg", () => {
+    it("deletes an existing org", async () => {
+      const org = await repo.createOrg("user-1", "Doomed Org", "doomed-org");
+      await repo.deleteOrg(org.id);
+      const found = await repo.getById(org.id);
+      expect(found).toBeNull();
+    });
+
+    it("silently succeeds when org does not exist", async () => {
+      await expect(repo.deleteOrg("nonexistent")).resolves.not.toThrow();
+    });
+  });
+});