@kindgi/platform 0.1.3 → 0.1.4-rc.0

package/tests/org-binding.conformance.ts

@@ -14,7 +14,12 @@
  *   asserted at every reachable read op.
  * - Pagination via `Filter.cursor`.
  * - `nameContains` substring filter.
- * - `get`/`update`/`delete` behaviour on unknown orgIds.
+ * - `get`/`update`/`delete` behaviour on unknown orgIds: `update`
+ *   resolves to `org-not-found`.
+ * - Slug uniqueness within a tenant: `create` and `update` resolve to
+ *   `slug-conflict`; another tenant may reuse the slug.
+ * - `delete` (a tombstone in a durable binding): the org is unknown to
+ *   every read, its slug is free, and deleting again is a no-op.
  */
 
 import { describe, expect, it } from 'vitest';
@@ -22,10 +27,18 @@ import { describe, expect, it } from 'vitest';
 import type { OrgId, TenantId } from '@kindgi/types';
 
 import type { OrgBinding } from '../src/org-binding.js';
+import type { OrgSpec } from '../src/types.js';
 
 const T1 = 'tenant-1' as TenantId;
 const T2 = 'tenant-2' as TenantId;
 
+/** Create an org the test expects to succeed; its id. */
+async function createOrg(b: OrgBinding, tenantId: TenantId, spec: OrgSpec): Promise<OrgId> {
+  const outcome = await b.create(tenantId, spec);
+  if (outcome.kind !== 'ok') throw new Error(`expected the org to be created, got ${outcome.kind}`);
+  return outcome.orgId;
+}
+
 export function runOrgBindingConformance(
   makeBinding: () => OrgBinding,
   label = 'OrgBinding',
@@ -33,7 +46,7 @@ export function runOrgBindingConformance(
   describe(`${label} — CRUD happy paths`, () => {
     it('creates + gets an Org', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
       const got = await b.get(T1, id);
       expect(got).toBeDefined();
       expect(got?.id).toBe(id);
@@ -44,8 +57,8 @@ export function runOrgBindingConformance(
 
     it('updates an Org partially', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
-      await b.update(T1, id, { name: 'Acme Corp' });
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      expect(await b.update(T1, id, { name: 'Acme Corp' })).toEqual({ kind: 'ok' });
       const got = await b.get(T1, id);
       expect(got?.name).toBe('Acme Corp');
       expect(got?.slug).toBe('acme');
@@ -53,12 +66,38 @@ export function runOrgBindingConformance(
 
     it('deletes an Org', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
       await b.delete(T1, id);
       const got = await b.get(T1, id);
       expect(got).toBeUndefined();
     });
 
+    it('a deleted Org is unknown to list and update, and deleting it again is a no-op', async () => {
+      const b = makeBinding();
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      const kept = await createOrg(b, T1, { name: 'Kept', slug: 'kept' });
+      await b.delete(T1, id);
+      const page = await b.list(T1, {});
+      expect(page.items.map((o) => o.id)).toEqual([kept]);
+      expect(await b.update(T1, id, { name: 'Acme 2' })).toEqual({ kind: 'org-not-found' });
+      await b.delete(T1, id);
+      expect(await b.get(T1, kept)).toBeDefined();
+    });
+
+    it("a deleted Org's slug is free for a new Org", async () => {
+      const b = makeBinding();
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      await b.delete(T1, id);
+      const again = await createOrg(b, T1, { name: 'Acme again', slug: 'acme' });
+      expect(again).not.toBe(id);
+      expect((await b.get(T1, again))?.slug).toBe('acme');
+      const other = await createOrg(b, T1, { name: 'Other', slug: 'other' });
+      expect(await b.update(T1, other, { slug: 'acme' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'acme',
+      });
+    });
+
     it('lists orgs (empty tenant)', async () => {
       const b = makeBinding();
       const page = await b.list(T1, {});
@@ -70,27 +109,28 @@ export function runOrgBindingConformance(
   describe(`${label} — cross-tenant isolation`, () => {
     it('get on tenant B for tenant-A orgId returns undefined', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
       expect(await b.get(T2, id)).toBeUndefined();
     });
 
     it('list on tenant B does not surface tenant-A orgs', async () => {
       const b = makeBinding();
-      await b.create(T1, { name: 'Acme', slug: 'acme' });
-      await b.create(T1, { name: 'Globex', slug: 'globex' });
+      await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      await createOrg(b, T1, { name: 'Globex', slug: 'globex' });
       const t2Page = await b.list(T2, {});
       expect(t2Page.items).toEqual([]);
     });
 
-    it('update on tenant B for tenant-A orgId errors', async () => {
+    it('update on tenant B for tenant-A orgId → org-not-found', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
-      await expect(b.update(T2, id, { name: 'X' })).rejects.toThrow();
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      expect(await b.update(T2, id, { name: 'X' })).toEqual({ kind: 'org-not-found' });
+      expect((await b.get(T1, id))?.name).toBe('Acme');
     });
 
     it('delete on tenant B for tenant-A orgId is a no-op (does not mutate A)', async () => {
       const b = makeBinding();
-      const id = await b.create(T1, { name: 'Acme', slug: 'acme' });
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
       await b.delete(T2, id); // no-op
       const got = await b.get(T1, id);
       expect(got).toBeDefined();
@@ -102,7 +142,7 @@ export function runOrgBindingConformance(
       const b = makeBinding();
       const created: OrgId[] = [];
       for (let i = 0; i < 5; i += 1) {
-        created.push(await b.create(T1, { name: `Org${i}`, slug: `org-${i}` }));
+        created.push(await createOrg(b, T1, { name: `Org${i}`, slug: `org-${i}` }));
       }
       const page1 = await b.list(T1, { limit: 2 });
       expect(page1.items).toHaveLength(2);
@@ -133,9 +173,9 @@ export function runOrgBindingConformance(
   describe(`${label} — nameContains filter`, () => {
     it('narrows to orgs whose name contains the substring', async () => {
       const b = makeBinding();
-      await b.create(T1, { name: 'Litigation', slug: 'lit' });
-      await b.create(T1, { name: 'Corporate', slug: 'corp' });
-      await b.create(T1, { name: 'Litigation-Sub', slug: 'lit-sub' });
+      await createOrg(b, T1, { name: 'Litigation', slug: 'lit' });
+      await createOrg(b, T1, { name: 'Corporate', slug: 'corp' });
+      await createOrg(b, T1, { name: 'Litigation-Sub', slug: 'lit-sub' });
 
       const page = await b.list(T1, { nameContains: 'Litigation' });
       expect(page.items).toHaveLength(2);
@@ -152,9 +192,9 @@ export function runOrgBindingConformance(
       expect(await b.get(T1, unknown)).toBeUndefined();
     });
 
-    it('update on unknown orgId errors', async () => {
+    it('update on unknown orgId → org-not-found', async () => {
       const b = makeBinding();
-      await expect(b.update(T1, unknown, { name: 'X' })).rejects.toThrow();
+      expect(await b.update(T1, unknown, { name: 'X' })).toEqual({ kind: 'org-not-found' });
     });
 
     it('delete on unknown orgId is a no-op', async () => {
@@ -162,4 +202,39 @@ export function runOrgBindingConformance(
       await expect(b.delete(T1, unknown)).resolves.toBeUndefined();
     });
   });
+
+  describe(`${label} — slug uniqueness`, () => {
+    it('create with a slug the tenant already has → slug-conflict', async () => {
+      const b = makeBinding();
+      await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      expect(await b.create(T1, { name: 'Acme again', slug: 'acme' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'acme',
+      });
+      expect((await b.list(T1, {})).items).toHaveLength(1);
+    });
+
+    it('another tenant may use the same slug', async () => {
+      const b = makeBinding();
+      await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      expect((await b.create(T2, { name: 'Acme', slug: 'acme' })).kind).toBe('ok');
+    });
+
+    it("update to another org's slug → slug-conflict; the org is unchanged", async () => {
+      const b = makeBinding();
+      await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      const id = await createOrg(b, T1, { name: 'Globex', slug: 'globex' });
+      expect(await b.update(T1, id, { slug: 'acme' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'acme',
+      });
+      expect((await b.get(T1, id))?.slug).toBe('globex');
+    });
+
+    it('update to its own slug → ok', async () => {
+      const b = makeBinding();
+      const id = await createOrg(b, T1, { name: 'Acme', slug: 'acme' });
+      expect(await b.update(T1, id, { name: 'Acme Corp', slug: 'acme' })).toEqual({ kind: 'ok' });
+    });
+  });
 }

package/tests/project-binding.conformance.ts

@@ -10,8 +10,15 @@
  * - CRUD happy paths.
  * - `getDefault` returns the tenant's Default row when `isDefault=true`.
  * - `isDefault` uniqueness guardrail — creating a second Default in
- *   the same tenant rejects (in-memory adapter enforces at write
- *   time; Postgres impl enforces via partial-unique-index).
+ *   the same tenant resolves to `project-default-already-exists`
+ *   (in-memory adapter enforces at write time; Postgres impl enforces
+ *   via partial-unique-index).
+ * - Slug uniqueness within an org (and, for projects without an org,
+ *   among those): `create` and `update` (a new slug, or a move to
+ *   another org) resolve to `slug-conflict`; another org, or another
+ *   tenant, may reuse the slug.
+ * - `project-not-found` / `project-membership-not-found` outcomes from
+ *   writes on a missing row.
  * - `listForUser` aggregates memberships across projects.
  * - Cross-tenant isolation on every reachable read.
  */
@@ -22,6 +29,7 @@ import type { OrgId, ProjectId, TeamId, TenantId, UserId } from '@kindgi/types';
 
 import type { ProjectBinding, ProjectMembershipBinding } from '../src/project-binding.js';
 import type { TeamProjectGrantBinding } from '../src/team-project-grant-binding.js';
+import type { ProjectSpec } from '../src/types.js';
 
 const T1 = 'tenant-1' as TenantId;
 const T2 = 'tenant-2' as TenantId;
@@ -30,6 +38,20 @@ const U2 = 'user-2' as UserId;
 const TEAM_A = 'team-A' as TeamId;
 const TEAM_B = 'team-B' as TeamId;
 const ORG_A = 'org-A' as OrgId;
+const ORG_B = 'org-B' as OrgId;
+
+/** Create a project the test expects to succeed; its id. */
+async function createProject(
+  projects: ProjectBinding,
+  tenantId: TenantId,
+  spec: ProjectSpec,
+): Promise<ProjectId> {
+  const outcome = await projects.create(tenantId, spec);
+  if (outcome.kind !== 'ok') {
+    throw new Error(`expected the project to be created, got ${outcome.kind}`);
+  }
+  return outcome.projectId;
+}
 
 export function runProjectBindingConformance(
   makeBinding: () => {
@@ -42,7 +64,7 @@ export function runProjectBindingConformance(
   describe(`${label} — project CRUD`, () => {
     it('creates + gets a project', async () => {
       const { projects } = makeBinding();
-      const id = await projects.create(T1, { name: 'Matter #1', slug: 'm1' });
+      const id = await createProject(projects, T1, { name: 'Matter #1', slug: 'm1' });
       const got = await projects.get(T1, id);
       expect(got?.name).toBe('Matter #1');
       expect(got?.isDefault).toBe(false);
@@ -50,8 +72,8 @@ export function runProjectBindingConformance(
 
     it('lists projects filtered by orgId', async () => {
       const { projects } = makeBinding();
-      await projects.create(T1, { name: 'A', slug: 'a', orgId: ORG_A });
-      await projects.create(T1, { name: 'B', slug: 'b' });
+      await createProject(projects, T1, { name: 'A', slug: 'a', orgId: ORG_A });
+      await createProject(projects, T1, { name: 'B', slug: 'b' });
       const inOrg = await projects.list(T1, { orgId: ORG_A });
       expect(inOrg.items).toHaveLength(1);
       expect(inOrg.items[0]?.name).toBe('A');
@@ -59,15 +81,15 @@ export function runProjectBindingConformance(
 
     it('updates a project', async () => {
       const { projects } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
-      await projects.update(T1, id, { name: 'A-updated' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      expect(await projects.update(T1, id, { name: 'A-updated' })).toEqual({ kind: 'ok' });
       const got = await projects.get(T1, id);
       expect(got?.name).toBe('A-updated');
     });
 
     it('deletes a project + cascades memberships + grants', async () => {
       const { projects, memberships, grants } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       await memberships.add(T1, { projectId: id, userId: U1, role: 'editor' });
       await grants.add(T1, { teamId: TEAM_A, projectId: id, role: 'editor' });
       await projects.delete(T1, id);
@@ -86,7 +108,7 @@ export function runProjectBindingConformance(
 
     it('getDefault returns the isDefault=true row', async () => {
       const { projects } = makeBinding();
-      const id = await projects.create(T1, {
+      const id = await createProject(projects, T1, {
         name: 'Default',
         slug: 'default',
         isDefault: true,
@@ -97,18 +119,28 @@ export function runProjectBindingConformance(
       expect(got?.isDefault).toBe(true);
     });
 
-    it('isDefault uniqueness — a second Default in the same tenant errors', async () => {
+    it('isDefault uniqueness — a second Default in the same tenant → project-default-already-exists', async () => {
       const { projects } = makeBinding();
-      await projects.create(T1, { name: 'D1', slug: 'd1', isDefault: true });
-      await expect(
-        projects.create(T1, { name: 'D2', slug: 'd2', isDefault: true }),
-      ).rejects.toThrow();
+      await createProject(projects, T1, { name: 'D1', slug: 'd1', isDefault: true });
+      expect(await projects.create(T1, { name: 'D2', slug: 'd2', isDefault: true })).toEqual({
+        kind: 'project-default-already-exists',
+      });
+    });
+
+    it('isDefault with only the slug taken → slug-conflict', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'P', slug: 'p' });
+      expect(await projects.create(T1, { name: 'D', slug: 'p', isDefault: true })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'p',
+      });
+      expect(await projects.getDefault(T1)).toBeUndefined();
     });
 
     it('a Default in tenant A does NOT block a Default in tenant B', async () => {
       const { projects } = makeBinding();
-      await projects.create(T1, { name: 'D1', slug: 'd1', isDefault: true });
-      const d2 = await projects.create(T2, {
+      await createProject(projects, T1, { name: 'D1', slug: 'd1', isDefault: true });
+      const d2 = await createProject(projects, T2, {
         name: 'D2',
         slug: 'd2',
         isDefault: true,
@@ -121,28 +153,45 @@ export function runProjectBindingConformance(
   describe(`${label} — cross-tenant isolation`, () => {
     it('project get across tenants returns undefined', async () => {
       const { projects } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       expect(await projects.get(T2, id)).toBeUndefined();
     });
 
     it('project list across tenants does not leak', async () => {
       const { projects } = makeBinding();
-      await projects.create(T1, { name: 'A', slug: 'a' });
+      await createProject(projects, T1, { name: 'A', slug: 'a' });
       const page = await projects.list(T2, {});
       expect(page.items).toEqual([]);
     });
 
-    it('project-membership add under wrong tenant errors', async () => {
+    it('project-membership add under wrong tenant → project-not-found', async () => {
       const { projects, memberships } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
-      await expect(
-        memberships.add(T2, { projectId: id, userId: U1, role: 'editor' }),
-      ).rejects.toThrow();
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      expect(await memberships.add(T2, { projectId: id, userId: U1, role: 'editor' })).toEqual({
+        kind: 'project-not-found',
+      });
+      expect((await memberships.list(T1, id, {})).items).toEqual([]);
+    });
+
+    it('project update under wrong tenant → project-not-found', async () => {
+      const { projects } = makeBinding();
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      expect(await projects.update(T2, id, { name: 'B' })).toEqual({ kind: 'project-not-found' });
+      expect((await projects.get(T1, id))?.name).toBe('A');
+    });
+
+    it('membership updateRole under wrong tenant → project-not-found', async () => {
+      const { projects, memberships } = makeBinding();
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      await memberships.add(T1, { projectId: id, userId: U1, role: 'editor' });
+      expect(await memberships.updateRole(T2, id, U1, 'owner')).toEqual({
+        kind: 'project-not-found',
+      });
     });
 
     it('team-project grant add under wrong tenant errors', async () => {
       const { projects, grants } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       await expect(
         grants.add(T2, { teamId: TEAM_A, projectId: id, role: 'editor' }),
       ).rejects.toThrow();
@@ -150,8 +199,8 @@ export function runProjectBindingConformance(
 
     it('listForUser across tenants only returns tenant-scoped rows', async () => {
       const { projects, memberships } = makeBinding();
-      const p1 = await projects.create(T1, { name: 'A', slug: 'a' });
-      const p2 = await projects.create(T2, { name: 'B', slug: 'b' });
+      const p1 = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      const p2 = await createProject(projects, T2, { name: 'B', slug: 'b' });
       await memberships.add(T1, { projectId: p1, userId: U1, role: 'editor' });
       await memberships.add(T2, { projectId: p2, userId: U1, role: 'editor' });
       const t1Page = await memberships.listForUser(T1, U1, {});
@@ -163,17 +212,37 @@ export function runProjectBindingConformance(
   describe(`${label} — membership + grant idempotency`, () => {
     it('project-membership add is idempotent (does not overwrite role)', async () => {
       const { projects, memberships } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
-      await memberships.add(T1, { projectId: id, userId: U1, role: 'owner' });
-      await memberships.add(T1, { projectId: id, userId: U1, role: 'viewer' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      expect(await memberships.add(T1, { projectId: id, userId: U1, role: 'owner' })).toEqual({
+        kind: 'ok',
+      });
+      expect(await memberships.add(T1, { projectId: id, userId: U1, role: 'viewer' })).toEqual({
+        kind: 'ok',
+      });
       const page = await memberships.list(T1, id, {});
       expect(page.items).toHaveLength(1);
       expect(page.items[0]?.role).toBe('owner');
     });
 
+    it('project-membership updateRole mutates the role', async () => {
+      const { projects, memberships } = makeBinding();
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      await memberships.add(T1, { projectId: id, userId: U1, role: 'editor' });
+      expect(await memberships.updateRole(T1, id, U1, 'owner')).toEqual({ kind: 'ok' });
+      expect((await memberships.list(T1, id, {})).items[0]?.role).toBe('owner');
+    });
+
+    it('project-membership updateRole on a missing membership → project-membership-not-found', async () => {
+      const { projects, memberships } = makeBinding();
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      expect(await memberships.updateRole(T1, id, U1, 'owner')).toEqual({
+        kind: 'project-membership-not-found',
+      });
+    });
+
     it('grant add is idempotent', async () => {
       const { projects, grants } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       await grants.add(T1, { teamId: TEAM_A, projectId: id, role: 'owner' });
       await grants.add(T1, { teamId: TEAM_A, projectId: id, role: 'viewer' });
       const page = await grants.listForProject(T1, id, {});
@@ -183,7 +252,7 @@ export function runProjectBindingConformance(
 
     it('grant updateRole mutates the role', async () => {
       const { projects, grants } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       await grants.add(T1, { teamId: TEAM_A, projectId: id, role: 'editor' });
       await grants.updateRole(T1, TEAM_A, id, 'owner');
       const page = await grants.listForTeam(T1, TEAM_A, {});
@@ -194,9 +263,9 @@ export function runProjectBindingConformance(
   describe(`${label} — listForUser aggregates across projects`, () => {
     it('returns every direct-grant project the user has', async () => {
       const { projects, memberships } = makeBinding();
-      const a = await projects.create(T1, { name: 'A', slug: 'a' });
-      const b = await projects.create(T1, { name: 'B', slug: 'b' });
-      const c = await projects.create(T1, { name: 'C', slug: 'c' });
+      const a = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      const b = await createProject(projects, T1, { name: 'B', slug: 'b' });
+      const c = await createProject(projects, T1, { name: 'C', slug: 'c' });
       await memberships.add(T1, { projectId: a, userId: U1, role: 'editor' });
       await memberships.add(T1, { projectId: b, userId: U1, role: 'viewer' });
       await memberships.add(T1, { projectId: c, userId: U2, role: 'editor' });
@@ -211,7 +280,7 @@ export function runProjectBindingConformance(
   describe(`${label} — grant listForProject + listForTeam`, () => {
     it('listForProject returns every team-grant on the project', async () => {
       const { projects, grants } = makeBinding();
-      const id = await projects.create(T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'A', slug: 'a' });
       await grants.add(T1, { teamId: TEAM_A, projectId: id, role: 'editor' });
       await grants.add(T1, { teamId: TEAM_B, projectId: id, role: 'viewer' });
       const page = await grants.listForProject(T1, id, {});
@@ -220,12 +289,92 @@ export function runProjectBindingConformance(
 
     it('listForTeam returns every project the team has a grant on', async () => {
       const { projects, grants } = makeBinding();
-      const a = await projects.create(T1, { name: 'A', slug: 'a' });
-      const b = await projects.create(T1, { name: 'B', slug: 'b' });
+      const a = await createProject(projects, T1, { name: 'A', slug: 'a' });
+      const b = await createProject(projects, T1, { name: 'B', slug: 'b' });
       await grants.add(T1, { teamId: TEAM_A, projectId: a, role: 'editor' });
       await grants.add(T1, { teamId: TEAM_A, projectId: b, role: 'viewer' });
       const page = await grants.listForTeam(T1, TEAM_A, {});
       expect(page.items).toHaveLength(2);
     });
   });
+
+  describe(`${label} — slug uniqueness`, () => {
+    it('create with a slug a project without an org already has → slug-conflict', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'Matter', slug: 'm1' });
+      expect(await projects.create(T1, { name: 'Matter again', slug: 'm1' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'm1',
+      });
+      expect((await projects.list(T1, {})).items).toHaveLength(1);
+    });
+
+    it('another tenant may use the same slug', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'Matter', slug: 'm1' });
+      expect((await projects.create(T2, { name: 'Matter', slug: 'm1' })).kind).toBe('ok');
+    });
+
+    it("update to another project's slug → slug-conflict; the project is unchanged", async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'A', slug: 'a' });
+      const id = await createProject(projects, T1, { name: 'B', slug: 'b' });
+      expect(await projects.update(T1, id, { slug: 'a' })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'a',
+      });
+      expect((await projects.get(T1, id))?.slug).toBe('b');
+    });
+
+    it('two orgs may each have a project with the same slug', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'A', slug: 'shared', orgId: ORG_A });
+      await createProject(projects, T1, { name: 'B', slug: 'shared', orgId: ORG_B });
+      // And a project without an org may have it too.
+      await createProject(projects, T1, { name: 'C', slug: 'shared' });
+      expect((await projects.list(T1, {})).items.map((p) => p.slug)).toEqual([
+        'shared',
+        'shared',
+        'shared',
+      ]);
+    });
+
+    it("create with a slug the org's project already has → slug-conflict", async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'A', slug: 'a', orgId: ORG_A });
+      expect(await projects.create(T1, { name: 'A again', slug: 'a', orgId: ORG_A })).toEqual({
+        kind: 'slug-conflict',
+        slug: 'a',
+      });
+    });
+
+    it('a move to an org that has the slug → slug-conflict; the project stays where it was', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'In A', slug: 's', orgId: ORG_A });
+      const id = await createProject(projects, T1, { name: 'In B', slug: 's', orgId: ORG_B });
+      expect(await projects.update(T1, id, { orgId: ORG_A })).toEqual({
+        kind: 'slug-conflict',
+        slug: 's',
+      });
+      expect((await projects.get(T1, id))?.orgId).toBe(ORG_B);
+    });
+
+    it('a move out of its org, where a project without one has the slug → slug-conflict', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'Org-less', slug: 's' });
+      const id = await createProject(projects, T1, { name: 'In A', slug: 's', orgId: ORG_A });
+      expect(await projects.update(T1, id, { orgId: null })).toEqual({
+        kind: 'slug-conflict',
+        slug: 's',
+      });
+    });
+
+    it('a move to an org without the slug, and a rename to a slug only another org has: ok', async () => {
+      const { projects } = makeBinding();
+      await createProject(projects, T1, { name: 'In A', slug: 'a', orgId: ORG_A });
+      const id = await createProject(projects, T1, { name: 'In B', slug: 'b', orgId: ORG_B });
+      expect(await projects.update(T1, id, { slug: 'a' })).toEqual({ kind: 'ok' });
+      expect(await projects.update(T1, id, { slug: 'c', orgId: ORG_A })).toEqual({ kind: 'ok' });
+    });
+  });
 }