@jskit-ai/workspaces-core 0.2.4 → 0.2.6

package/test/support/invitationTransactions.js

@@ -11,8 +11,13 @@ import { createRepository as invitesRepository } from "../../src/server/common/r
 import { createRepository as membershipsRepository } from "../../src/server/common/repositories/workspaceMembershipsRepository.js";
 import { createRepository as workspacesRepository } from "../../src/server/common/repositories/workspacesRepository.js";
 import { createService as membersService } from "../../src/server/workspaceMembers/workspaceMembersService.js";
+import { createWorkspacesServerI18n } from "../../src/server/i18n.js";
 import { createService as pendingService } from "../../src/server/workspacePendingInvitations/workspacePendingInvitationsService.js";
-import { buildWorkspacePendingInvitationsActions } from "../../src/server/workspacePendingInvitations/workspacePendingInvitationsActions.js";
+import { noInviteAcceptanceParticipant } from "../../src/server/workspacePendingInvitations/noInviteAcceptanceParticipant.js";
+import { createWorkspacePendingInvitationsActions } from "../../src/server/workspacePendingInvitations/workspacePendingInvitationsActions.js";
+import { createWorkspaceInviteUrlBuilder } from "../../src/server/workspaceMembers/workspaceInviteUrls.js";
+import { renderDefaultWorkspaceInviteEmail } from "../../src/server/workspaceMembers/defaultWorkspaceInviteEmail.js";
+import { unconfiguredWorkspaceInviteMailer } from "../../src/server/workspaceMembers/unconfiguredWorkspaceInviteMailer.js";
 
 // The caller verifies an empty disposable database and runs package migrations.
 // These application fixtures demonstrate composition, not production policy.
@@ -77,6 +82,8 @@ export async function verifyInvitationTransactions(t, db) {
     const events = [];
     let failDelivery = false;
     const members = membersService({
+      workspaceInvitationsEnabled: true,
+      i18n: createWorkspacesServerI18n(),
       workspaceInvitesRepository: inviteRepository, workspaceMembershipsRepository: memberships,
       inviteExpiresInMs: 3600000, roleCatalog,
       workspaceInviteMailer: mailer ? { async sendWorkspaceInvite(message, options) {
@@ -89,13 +96,20 @@ export async function verifyInvitationTransactions(t, db) {
         if (failDelivery) throw new Error(`Controlled mail failure containing secret ${message.inviteUrl}`);
         delivered.push(String(saved.id));
         return { status: "sent", providerMessageId: "controlled-message" };
-      } } : null
+      } } : unconfiguredWorkspaceInviteMailer,
+      inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+      workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
+    });
+    // Each test chooses the application's acceptance participant.
+    let participant = noInviteAcceptanceParticipant;
+    const pending = pendingService({
+      workspaceInvitesRepository: inviteRepository, workspaceMembershipsRepository: memberships, roleCatalog: createWorkspaceRoleCatalog(),
+      acceptanceParticipant: (...args) => participant(...args)
     });
-    const pending = pendingService({ workspaceInvitesRepository: inviteRepository, workspaceMembershipsRepository: memberships });
     const options = { context: { actor: user, channel: "api", permissions: ["workspace.members.invite"] } };
     const payload = { email: user.email, roleSid: "member" };
     const actions = createActionCatalogue({ events: { async publish(event) { events.push(event); } } });
-    actions.register({ contributorId: suffix, domain: "workspace", actions: buildWorkspacePendingInvitationsActions({ workspacePendingInvitationsService: pending }) });
+    actions.register({ contributorId: suffix, domain: "workspace", actions: createWorkspacePendingInvitationsActions({ workspacePendingInvitationsService: pending }) });
     const redeem = (prepared, decision = "accept", actor = user, extraInput = {}) => actions.execute({
       actionId: "workspace.invite.redeem",
       input: { token: prepared.inviteTokenPreview, decision, ...extraInput },
@@ -146,12 +160,13 @@ export async function verifyInvitationTransactions(t, db) {
       assert.equal(events.length, 0);
     }
     return { user, owner, workspace, draftId, draft, invitation, assertUnlinked, members, pending, redeem, events,
-      delivered, options, payload, prepareOnce, applyAssociation, failDelivery() { failDelivery = true; } };
+      delivered, options, payload, prepareOnce, applyAssociation, failDelivery() { failDelivery = true; },
+      participate(fn) { participant = fn; } };
   }
 
   await t.test("ordinary creation commits before controlled delivery and built-in acceptance", async () => {
     const f = await fixture();
-    const created = await f.members.createInvite(f.workspace, f.owner, f.payload, f.options);
+    const created = (await f.members.createInvite(f.workspace, f.owner, f.payload, f.options)).value;
     assert.equal(created.inviteDelivery.status, "sent");
     assert.deepEqual(f.delivered, [created.createdInviteId]);
     await f.redeem(created);
@@ -162,9 +177,9 @@ export async function verifyInvitationTransactions(t, db) {
 
   await t.test("ordinary invitation works with an application participant and no association", async () => {
     const f = await fixture({ mailer: false });
-    const created = await f.members.createInvite(f.workspace, f.owner, f.payload);
+    const created = (await f.members.createInvite(f.workspace, f.owner, f.payload)).value;
     assert.equal(created.inviteDelivery.status, "mailer_unconfigured");
-    f.pending.registerAcceptanceParticipant(f.applyAssociation);
+    f.participate(f.applyAssociation);
     await f.redeem(created);
     assert.equal((await f.invitation(created)).status, "accepted");
     assert.equal((await f.draft()).user_id, null);
@@ -172,7 +187,7 @@ export async function verifyInvitationTransactions(t, db) {
 
   await t.test("association rollback restores earlier invitation state and sends nothing", async () => {
     const f = await fixture();
-    const previous = await f.members.createInvite(f.workspace, f.owner, f.payload);
+    const previous = (await f.members.createInvite(f.workspace, f.owner, f.payload)).value;
     await assert.rejects(f.prepareOnce({ fail: true }), (error) => error.transactionOutcome === "rolledBack");
     const rows = await db("workspace_invites").where({ workspace_id: f.workspace.id });
     assert.equal(rows.length, 1);
@@ -192,7 +207,7 @@ export async function verifyInvitationTransactions(t, db) {
       ...receipt, email: "other@example.test", roleSid: "owner", inviteUrl: "https://untrusted.example"
     });
     assert.equal(sent.createdInviteId, prepared.createdInviteId);
-    f.pending.registerAcceptanceParticipant(f.applyAssociation);
+    f.participate(f.applyAssociation);
     await f.redeem(sent);
     const linked = await f.draft();
     assert.equal(String(linked.user_id), f.user.id);
@@ -204,7 +219,7 @@ export async function verifyInvitationTransactions(t, db) {
   await t.test("participant failure rolls back membership, identity, training, scopes, audit and status", async () => {
     const f = await fixture();
     const prepared = await f.prepareOnce();
-    f.pending.registerAcceptanceParticipant(async (...args) => {
+    f.participate(async (...args) => {
       await f.applyAssociation(...args);
       throw new Error("Controlled audit failure");
     });
@@ -223,7 +238,7 @@ export async function verifyInvitationTransactions(t, db) {
     } } });
     const prepared = await f.prepareOnce();
     await memberships.upsertMembership(f.workspace.id, f.user.id, { roleSid: "existing-role", status: "revoked" });
-    f.pending.registerAcceptanceParticipant(f.applyAssociation);
+    f.participate(f.applyAssociation);
     await assert.rejects(f.redeem(prepared), /final status failure/);
     const previous = await memberships.findByWorkspaceIdAndUserId(f.workspace.id, f.user.id);
     assert.equal(previous.roleSid, "existing-role");
@@ -238,7 +253,7 @@ export async function verifyInvitationTransactions(t, db) {
   await t.test("acceptance completion failure reports committed and retains all accepted writes", async () => {
     const f = await fixture();
     const prepared = await f.prepareOnce();
-    f.pending.registerAcceptanceParticipant(f.applyAssociation);
+    f.participate(f.applyAssociation);
     failCompletionForMethod = "patch";
     try {
       await assert.rejects(f.redeem(prepared), (error) => error.transactionOutcome === "committed");
@@ -287,7 +302,7 @@ export async function verifyInvitationTransactions(t, db) {
           : { review_state: state };
       await db("test_invitation_drafts").where({ id: f.draftId }).update(patch);
       const before = await f.draft();
-      f.pending.registerAcceptanceParticipant(f.applyAssociation);
+      f.participate(f.applyAssociation);
       await assert.rejects(f.redeem(prepared), (error) => error.transactionOutcome === "rolledBack");
       assert.deepEqual(await f.draft(), before);
       assert.equal(await memberships.findByWorkspaceIdAndUserId(f.workspace.id, f.user.id), null);
@@ -304,9 +319,10 @@ export async function verifyInvitationTransactions(t, db) {
       if (state === "revoked") await f.members.revokeInvite(f.workspace, prepared.createdInviteId);
       if (state === "accepted") await f.redeem(prepared);
       let called = false;
-      // The earlier acceptance closed registration on the original service.
-      const pending = pendingService({ workspaceInvitesRepository: invites, workspaceMembershipsRepository: memberships });
-      pending.registerAcceptanceParticipant(async () => { called = true; });
+      const pending = pendingService({
+        workspaceInvitesRepository: invites, workspaceMembershipsRepository: memberships, roleCatalog: createWorkspaceRoleCatalog(),
+        acceptanceParticipant: async () => { called = true; }
+      });
       const membershipBefore = await memberships.findByWorkspaceIdAndUserId(f.workspace.id, f.user.id);
       await assert.rejects(pending.acceptInviteByToken({
         user: state === "unauthenticated" ? null : state === "wrong-email" ? f.owner : f.user,
@@ -322,7 +338,7 @@ export async function verifyInvitationTransactions(t, db) {
     const f = await fixture();
     const prepared = await f.prepareOnce();
     let called = false;
-    f.pending.registerAcceptanceParticipant(async () => { called = true; });
+    f.participate(async () => { called = true; });
     await assert.rejects(f.redeem(prepared, "accept", f.owner, { user: f.user, personId: f.draftId, roleSid: "owner" }));
     assert.equal(called, false);
     await f.assertUnlinked(prepared);
@@ -428,7 +444,7 @@ export async function verifyInvitationTransactions(t, db) {
         const f = await fixture({ inviteRepository: repository });
         const prepared = await f.prepareOnce();
         let participation = 0;
-        f.pending.registerAcceptanceParticipant(async (...args) => { participation++; await f.applyAssociation(...args); });
+        f.participate(async (...args) => { participation++; await f.applyAssociation(...args); });
         const compete = () => competitor === "accept" || competitor === "refuse" ? f.redeem(prepared, competitor)
           : competitor === "revoke" ? f.members.revokeInvite(f.workspace, prepared.createdInviteId)
             : f.members.createInvite(f.workspace, f.owner, f.payload);

package/test/workspaceActionSurfaces.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import {
-  materializeWorkspaceActionSurfacesFromAppConfig,
   resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
   resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig
 } from "../src/server/support/workspaceActionSurfaces.js";
@@ -40,60 +39,6 @@ test("resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig honors explicit
   assert.deepEqual(surfaceIds, ["app"]);
 });
 
-test("materializeWorkspaceActionSurfacesFromAppConfig resolves workspace surfaces from appConfig", () => {
-  const actionDefinitions = [
-    {
-      id: "workspace.settings.read",
-      surfacesFrom: "workspace"
-    },
-    {
-      id: "auth.session.read",
-      surfacesFrom: "enabled"
-    }
-  ];
-
-  const materialized = materializeWorkspaceActionSurfacesFromAppConfig(actionDefinitions, {
-    appConfig: {
-      surfaceDefinitions: {
-        app: { id: "app", enabled: true, requiresWorkspace: true },
-        admin: { id: "admin", enabled: true, requiresWorkspace: true },
-        ops: { id: "ops", enabled: true, requiresWorkspace: false }
-      }
-    }
-  });
-
-  assert.deepEqual(materialized, [
-    {
-      id: "workspace.settings.read",
-      surfaces: ["app", "admin"]
-    },
-    {
-      id: "auth.session.read",
-      surfacesFrom: "enabled"
-    }
-  ]);
-});
-
-test("materializeWorkspaceActionSurfacesFromAppConfig drops workspace actions when no workspace surfaces are enabled", () => {
-  const actionDefinitions = [
-    {
-      id: "workspace.settings.read",
-      surfacesFrom: "workspace"
-    }
-  ];
-
-  const materialized = materializeWorkspaceActionSurfacesFromAppConfig(actionDefinitions, {
-    appConfig: {
-      surfaceDefinitions: {
-        app: { id: "app", enabled: true, requiresWorkspace: false },
-        ops: { id: "ops", enabled: true, requiresWorkspace: false }
-      }
-    }
-  });
-
-  assert.deepEqual(materialized, []);
-});
-
 test("resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig picks a workspace surface when app default is non-workspace", () => {
   const surfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig({
     surfaceDefaultId: "home",

package/test/workspaceAuthPolicyContextResolver.test.js

@@ -75,7 +75,7 @@ test("workspace auth policy context resolver resolves workspace context from use
       actor,
       workspaceSlug: "acme",
       options: {
-        request
+        requireMembership: true
       }
     }
   ]);

package/test/workspaceBootstrapContributor.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createWorkspaceBootstrapContributor } from "../src/server/workspaceBootstrapContributor.js";
+import { resolveTenancyProfile } from "../src/shared/tenancyProfile.js";
 
 function createAuthenticatedProfile(overrides = {}) {
   return {
@@ -41,9 +42,9 @@ test("workspace bootstrap contributor passes actor context to pending invites se
       }
     },
     workspaceInvitationsEnabled: true,
-    appConfig: {
+    tenancyProfile: resolveTenancyProfile({
       tenancyMode: "workspaces"
-    }
+    })
   });
 
   await contributor.contribute({
@@ -84,9 +85,9 @@ test("workspace bootstrap contributor resolves workspace slug from bootstrap que
       }
     },
     workspaceInvitationsEnabled: true,
-    appConfig: {
+    tenancyProfile: resolveTenancyProfile({
       tenancyMode: "workspaces"
-    }
+    })
   });
 
   const payload = await contributor.contribute({
@@ -129,9 +130,9 @@ test("workspace bootstrap contributor reports unauthenticated requested workspac
       }
     },
     workspaceInvitationsEnabled: true,
-    appConfig: {
+    tenancyProfile: resolveTenancyProfile({
       tenancyMode: "workspaces"
-    }
+    })
   });
 
   const payload = await contributor.contribute({

package/test/workspaceCrud.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { WORKSPACE_CRUD_SCOPE } from "../src/server/support/workspaceCrud.js";
+import { WORKSPACE_ROUTE_BASE_PATH, resolveWorkspaceRoutePath } from "../src/server/support/workspaceRoutePaths.js";
+import { routeParamsValidator, workspaceSlugParamsValidator } from "../src/server/common/validators/routeParamsValidator.js";
+
+test("the workspace CRUD scope routes under the workspace slug and reads it from the route", () => {
+  assert.ok(Object.isFrozen(WORKSPACE_CRUD_SCOPE));
+  assert.ok(Object.isFrozen(WORKSPACE_CRUD_SCOPE.inputKeys));
+  assert.equal(WORKSPACE_CRUD_SCOPE.routeBase, "/w/:workspaceSlug");
+  assert.equal(WORKSPACE_CRUD_SCOPE.actionInputValidator, workspaceSlugParamsValidator);
+  assert.equal(WORKSPACE_CRUD_SCOPE.routeParamsValidator, routeParamsValidator);
+  assert.deepEqual(WORKSPACE_CRUD_SCOPE.inputKeys, ["workspaceSlug"]);
+  assert.deepEqual(WORKSPACE_CRUD_SCOPE.input({ input: { params: { workspaceSlug: " Acme " } } }), { workspaceSlug: "acme" });
+  assert.deepEqual(WORKSPACE_CRUD_SCOPE.input({ input: { params: {} } }), {});
+});
+
+test("workspace route paths live under /api/w/:workspaceSlug", () => {
+  assert.equal(WORKSPACE_ROUTE_BASE_PATH, "/api/w/:workspaceSlug");
+  assert.equal(resolveWorkspaceRoutePath("rewarded"), "/api/w/:workspaceSlug/rewarded");
+  assert.equal(resolveWorkspaceRoutePath("/members/"), "/api/w/:workspaceSlug/members");
+  assert.equal(resolveWorkspaceRoutePath(), "/api/w/:workspaceSlug");
+});

package/test/workspaceInvitesRepository.test.js

@@ -50,6 +50,7 @@ function createWorkspaceInvitesApiStub({
     forUpdate() { return this; },
     then(resolve) { return Promise.resolve([...rowById.values()].filter((row) => row.status === "pending")).then(resolve); }
   });
+  trx.isCompleted = () => false;
   const api = {
     async transaction(work) { return work(trx); },
     resources: {
@@ -185,8 +186,8 @@ test("workspaceInvitesRepository.findByTokenHashWithWorkspace preserves workspac
         id: "45",
         workspace: {
           id: "9",
-          slug: "tonymobily3",
-          name: "TonyMobily3",
+          slug: "tony3",
+          name: "Tony3",
           avatarUrl: "https://example.com/avatar.png"
         },
         email: "invitee@example.com",
@@ -208,8 +209,8 @@ test("workspaceInvitesRepository.findByTokenHashWithWorkspace preserves workspac
 
   assert.equal(invite?.id, "45");
   assert.equal(invite?.status, "accepted");
-  assert.equal(invite?.workspaceSlug, "tonymobily3");
-  assert.equal(invite?.workspaceName, "TonyMobily3");
+  assert.equal(invite?.workspaceSlug, "tony3");
+  assert.equal(invite?.workspaceName, "Tony3");
   assert.equal(invite?.workspaceAvatarUrl, "https://example.com/avatar.png");
 });
 
@@ -249,8 +250,8 @@ test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps wor
         id: "1",
         workspace: {
           id: "9",
-          slug: "tonymobily3",
-          name: "TonyMobily3",
+          slug: "tony3",
+          name: "Tony3",
           avatarUrl: "https://example.com/avatar.png"
         },
         email: "invitee@example.com",
@@ -284,8 +285,8 @@ test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps wor
       revokedAt: null,
       createdAt: toIsoString("2026-03-09 00:26:35.710"),
       updatedAt: toIsoString("2026-03-09 00:26:35.710"),
-      workspaceSlug: "tonymobily3",
-      workspaceName: "TonyMobily3",
+      workspaceSlug: "tony3",
+      workspaceName: "Tony3",
       workspaceAvatarUrl: "https://example.com/avatar.png"
     }
   ]);