@jskit-ai/workspaces-core 0.2.3 → 0.2.5

package/test/workspaceMembersService.test.js

@@ -3,9 +3,13 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { createWorkspacesServerI18n } from "../src/server/i18n.js";
 import { createService } from "../src/server/workspaceMembers/workspaceMembersService.js";
 import { createWorkspaceRoleCatalog } from "../src/shared/roles.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";
 
 function authorizedOptions(permissions = []) {
   return {
@@ -45,13 +49,15 @@ function createRoleCatalog() {
 function createFixture() {
   const workspace = {
     id: "7",
-    slug: "tonymobily3",
-    name: "TonyMobily3",
+    slug: "tony3",
+    name: "Tony3",
     ownerUserId: "9",
     avatarUrl: ""
   };
 
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId(workspaceId) {
         assert.equal(Number(workspaceId), 7);
@@ -97,7 +103,10 @@ function createFixture() {
       async revokeById() {}
     },
     inviteExpiresInMs: 7 * 24 * 60 * 60 * 1000,
-    roleCatalog: createRoleCatalog()
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
   return { service, workspace };
@@ -107,6 +116,8 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
   const expiresAtValues = [];
   let savedInvite;
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -132,11 +143,14 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
       async revokeById() {}
     },
     inviteExpiresInMs: 30 * 60 * 1000,
-    roleCatalog: createRoleCatalog()
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
   const before = Date.now();
-  const response = await service.createInvite(
+  const response = (await service.createInvite(
     {
       id: "7",
       ownerUserId: "9"
@@ -147,7 +161,7 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
       roleSid: "member"
     },
     authorizedOptions(["workspace.members.invite"])
-  );
+  )).value;
   const after = Date.now();
 
   assert.equal(expiresAtValues.length, 1);
@@ -165,11 +179,68 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
   });
 });
 
+test("workspaceMembersService.createInvite without a provided mailer neither looks up the recipient nor renders", async () => {
+  const lookups = [];
+  let savedInvite;
+  const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
+    workspaceMembershipsRepository: {
+      async listActiveByWorkspaceId() {
+        return [];
+      }
+    },
+    workspaceInvitesRepository: {
+      async withTransaction(work) {
+        return work({});
+      },
+      async lockWorkspaceForInvitations() {},
+      async expirePendingByWorkspaceIdAndEmail() {},
+      async insert(payload) {
+        savedInvite = { ...payload, id: "32" };
+        return savedInvite;
+      },
+      async listPendingByWorkspaceIdWithWorkspace() {
+        return [];
+      },
+      async findPendingByIdForWorkspace() {
+        return savedInvite;
+      }
+    },
+    userProfilesRepository: {
+      async findByEmail(email) {
+        lookups.push(email);
+        return null;
+      }
+    },
+    inviteExpiresInMs: 30 * 60 * 1000,
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate() {
+      throw new Error("No email is rendered without a mailer.");
+    }
+  });
+
+  const response = (await service.createInvite(
+    { id: "7", ownerUserId: "9" },
+    { id: "11" },
+    { email: "alice@example.com", roleSid: "member" },
+    authorizedOptions(["workspace.members.invite"])
+  )).value;
+
+  assert.deepEqual(lookups, []);
+  assert.equal(response.inviteDelivery.status, "mailer_unconfigured");
+  assert.equal(response.inviteDelivery.messageCode, "workspaces.invite.mailerUnconfigured");
+});
+
 test("workspaceMembersService.createInvite sends generated invite URLs through the configured mailer", async () => {
   const templateCalls = [];
   const mailerCalls = [];
   let savedInvite;
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -224,7 +295,7 @@ test("workspaceMembersService.createInvite sends generated invite URLs through t
     }
   });
 
-  const response = await service.createInvite(
+  const response = (await service.createInvite(
     {
       id: "7",
       slug: "acme",
@@ -238,7 +309,7 @@ test("workspaceMembersService.createInvite sends generated invite URLs through t
       roleSid: "admin"
     },
     authorizedOptions(["workspace.members.invite"])
-  );
+  )).value;
 
   assert.equal(response.createdInviteId, "88");
   assert.match(response.inviteUrl, /^https:\/\/app\.example\.test\/invite\//);
@@ -262,6 +333,8 @@ test("workspaceMembersService.createInvite sends generated invite URLs through t
 test("workspaceMembersService.revokeInvite returns the revoked invite id", async () => {
   let revokedInviteId = 0;
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -294,17 +367,20 @@ test("workspaceMembersService.revokeInvite returns the revoked invite id", async
       }
     },
     inviteExpiresInMs: 30 * 60 * 1000,
-    roleCatalog: createRoleCatalog()
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
-  const response = await service.revokeInvite(
+  const response = (await service.revokeInvite(
     {
       id: "7",
       ownerUserId: "9"
     },
     "47",
     authorizedOptions(["workspace.invites.revoke"])
-  );
+  )).value;
 
   assert.equal(revokedInviteId, 47);
   assert.equal(response.revokedInviteId, "47");
@@ -312,6 +388,7 @@ test("workspaceMembersService.revokeInvite returns the revoked invite id", async
 
 test("workspaceMembersService rejects invite operations when invitations are disabled", async () => {
   const service = createService({
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -336,12 +413,15 @@ test("workspaceMembersService rejects invite operations when invitations are dis
     },
     inviteExpiresInMs: 30 * 60 * 1000,
     roleCatalog: createRoleCatalog(),
-    workspaceInvitationsEnabled: false
+    workspaceInvitationsEnabled: false,
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
   await assert.rejects(
     () =>
-      service.listInvites(
+      service.listInvitesResponse(
         {
           id: "7",
           ownerUserId: "9"
@@ -380,6 +460,17 @@ test("workspaceMembersService rejects invite operations when invitations are dis
   );
 });
 
+test("workspaceMembersService answers the role and member list actions with JSON:API data", async () => {
+  const { service, workspace } = createFixture();
+  const options = authorizedOptions(["workspace.members.view"]);
+
+  assert.deepEqual(await service.listRolesResponse(options), returnJsonApiData(await service.listRoles(options)));
+  assert.deepEqual(
+    await service.listMembersResponse(workspace, options),
+    returnJsonApiData(await service.listMembers(workspace, options))
+  );
+});
+
 test("workspaceMembersService.listMembers uses the resolved workspace directly", async () => {
   const { service, workspace } = createFixture();
 
@@ -387,8 +478,8 @@ test("workspaceMembersService.listMembers uses the resolved workspace directly",
 
   assert.deepEqual(response.workspace, {
     id: "7",
-    slug: "tonymobily3",
-    name: "TonyMobily3",
+    slug: "tony3",
+    name: "Tony3",
     ownerUserId: "9",
     avatarUrl: ""
   });
@@ -399,14 +490,14 @@ test("workspaceMembersService.listMembers uses the resolved workspace directly",
 test("workspaceMembersService.updateMemberRole returns the refreshed member list without re-fetching the workspace", async () => {
   const { service, workspace } = createFixture();
 
-  const response = await service.updateMemberRole(
+  const response = (await service.updateMemberRole(
     workspace,
     {
       memberUserId: "11",
       roleSid: "admin"
     },
     authorizedOptions(["workspace.members.manage"])
-  );
+  )).value;
 
   assert.equal(response.members.length, 1);
   assert.equal(response.members[0].roleSid, "member");
@@ -416,12 +507,14 @@ test("workspaceMembersService.removeMember marks membership revoked and returns
   let removed = false;
   const workspace = {
     id: "7",
-    slug: "tonymobily3",
-    name: "TonyMobily3",
+    slug: "tony3",
+    name: "Tony3",
     ownerUserId: "9",
     avatarUrl: ""
   };
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId(workspaceId) {
         assert.equal(Number(workspaceId), 7);
@@ -469,16 +562,19 @@ test("workspaceMembersService.removeMember marks membership revoked and returns
       async revokeById() {}
     },
     inviteExpiresInMs: 7 * 24 * 60 * 60 * 1000,
-    roleCatalog: createRoleCatalog()
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
-  const response = await service.removeMember(
+  const response = (await service.removeMember(
     workspace,
     {
       memberUserId: "11"
     },
     authorizedOptions(["workspace.members.manage"])
-  );
+  )).value;
 
   assert.equal(response.members.length, 0);
 });
@@ -486,12 +582,14 @@ test("workspaceMembersService.removeMember marks membership revoked and returns
 test("workspaceMembersService.removeMember rejects removing the owner", async () => {
   const workspace = {
     id: "7",
-    slug: "tonymobily3",
-    name: "TonyMobily3",
+    slug: "tony3",
+    name: "Tony3",
     ownerUserId: "9",
     avatarUrl: ""
   };
   const service = createService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -522,7 +620,10 @@ test("workspaceMembersService.removeMember rejects removing the owner", async ()
       async revokeById() {}
     },
     inviteExpiresInMs: 7 * 24 * 60 * 60 * 1000,
-    roleCatalog: createRoleCatalog()
+    roleCatalog: createRoleCatalog(),
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 
   await assert.rejects(
@@ -541,6 +642,7 @@ test("workspaceMembersService.removeMember rejects removing the owner", async ()
 function createMailingService({ accounts = {}, appRoot = "", mailer } = {}) {
   let savedInvite;
   return createService({
+    workspaceInvitationsEnabled: true,
     workspaceMembershipsRepository: {
       async listActiveByWorkspaceId() {
         return [];
@@ -581,7 +683,8 @@ function createMailingService({ accounts = {}, appRoot = "", mailer } = {}) {
         }
         return account ? { locale: account.locale } : null;
       }
-    }
+    },
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
 }
 
@@ -644,12 +747,12 @@ test("workspaceMembersService reports a failed delivery with a message code", as
       }
     }
   });
-  const response = await service.createInvite(
+  const response = (await service.createInvite(
     { id: "7", slug: "acme", name: "Acme", ownerUserId: "9", avatarUrl: "" },
     { id: "9" },
     { email: "invitee@example.com", roleSid: "member" },
     authorizedOptions()
-  );
+  )).value;
   assert.deepEqual(response.inviteDelivery, {
     status: "failed",
     message: "Unable to send workspace invite email.",

package/test/workspacePendingInvitationsResource.test.js

@@ -13,8 +13,8 @@ test("workspacePendingInvitationsResource output schema accepts already-shaped i
       {
         id: "10",
         workspaceId: "3",
-        workspaceSlug: "tonymobily3",
-        workspaceName: "TonyMobily3",
+        workspaceSlug: "tony3",
+        workspaceName: "Tony3",
         workspaceAvatarUrl: "",
         roleSid: "member",
         status: "pending",

package/test/workspacePendingInvitationsService.test.js

@@ -1,7 +1,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
+import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { createService } from "../src/server/workspacePendingInvitations/workspacePendingInvitationsService.js";
+import { noInviteAcceptanceParticipant } from "../src/server/workspacePendingInvitations/noInviteAcceptanceParticipant.js";
+import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 
 function createFixture({
   pendingInvitesByEmail = [],
@@ -53,7 +56,9 @@ function createFixture({
           payload: payload && typeof payload === "object" ? { ...payload } : payload
         });
       }
-    }
+    },
+    roleCatalog: createWorkspaceRoleCatalog(),
+    acceptanceParticipant: noInviteAcceptanceParticipant
   });
 
   return {
@@ -68,15 +73,15 @@ function createFixture({
   };
 }
 
-test("listPendingInvitesForUser returns raw pending invite rows for the action layer to shape", async () => {
+test("listPendingInvitesForUser returns raw pending invite rows", async () => {
   const tokenHash = "a".repeat(64);
   const { service } = createFixture({
     pendingInvitesByEmail: [
       {
         id: "10",
         workspaceId: "1",
-        workspaceSlug: "tonymobily3",
-        workspaceName: "TonyMobily3",
+        workspaceSlug: "tony3",
+        workspaceName: "Tony3",
         workspaceAvatarUrl: "",
         roleSid: "member",
         status: "pending",
@@ -88,15 +93,39 @@ test("listPendingInvitesForUser returns raw pending invite rows for the action l
 
   const pendingInvites = await service.listPendingInvitesForUser({
     id: "7",
-    email: "chiaramobily@gmail.com"
+    email: "chiara@example.com"
   });
 
   assert.equal(pendingInvites.length, 1);
   assert.equal(pendingInvites[0].token, encodeInviteTokenHash(tokenHash));
-  assert.equal(pendingInvites[0].workspaceName, "TonyMobily3");
+  assert.equal(pendingInvites[0].workspaceName, "Tony3");
   assert.equal(pendingInvites[0].status, "pending");
 });
 
+test("listPendingInvitesResponse answers the pending list action with the rows as JSON:API data", async () => {
+  const { service } = createFixture({
+    pendingInvitesByEmail: [
+      {
+        id: "10",
+        workspaceId: "1",
+        workspaceSlug: "tony3",
+        workspaceName: "Tony3",
+        workspaceAvatarUrl: "",
+        roleSid: "member",
+        status: "pending",
+        expiresAt: "2030-01-01T00:00:00.000Z",
+        tokenHash: "b".repeat(64)
+      }
+    ]
+  });
+  const user = { id: "7", email: "chiara@example.com" };
+
+  assert.deepEqual(
+    await service.listPendingInvitesResponse(user),
+    returnJsonApiData({ pendingInvites: await service.listPendingInvitesForUser(user) })
+  );
+});
+
 test("resolveInviteByToken returns safe public invite metadata without mutating the invite", async () => {
   const tokenHash = "d".repeat(64);
   const encodedToken = encodeInviteTokenHash(tokenHash);
@@ -117,7 +146,7 @@ test("resolveInviteByToken returns safe public invite metadata without mutating
     }
   });
 
-  const resolved = await service.resolveInviteByToken(encodedToken);
+  const resolved = (await service.resolveInviteByToken(encodedToken)).value;
 
   assert.deepEqual(calls.resolveTokenHashCalls, [tokenHash]);
   assert.deepEqual(calls.revokeCalls, []);
@@ -157,8 +186,8 @@ test("resolveInviteByToken reports expired and missing invitations as terminal s
     }
   });
 
-  const expired = await service.resolveInviteByToken(expiredToken);
-  const missing = await service.resolveInviteByToken(missingToken);
+  const expired = (await service.resolveInviteByToken(expiredToken)).value;
+  const missing = (await service.resolveInviteByToken(missingToken)).value;
 
   assert.equal(expired.status, "expired");
   assert.equal(missing.status, "not_found");
@@ -219,7 +248,7 @@ test("acceptInviteByToken accepts opaque invite token and resolves invite by dec
       [tokenHash]: {
         id: "44",
         workspaceId: "1",
-        email: "chiaramobily@gmail.com",
+        email: "chiara@example.com",
         roleSid: "member",
         status: "pending",
         tokenHash,
@@ -231,7 +260,7 @@ test("acceptInviteByToken accepts opaque invite token and resolves invite by dec
   const response = await service.acceptInviteByToken({
     user: {
       id: "7",
-      email: "chiaramobily@gmail.com",
+      email: "chiara@example.com",
       displayName: "Chiara"
     },
     token: encodedToken
@@ -253,7 +282,7 @@ test("refuseInviteByToken revokes the invite and returns refused", async () => {
       [tokenHash]: {
         id: "45",
         workspaceId: "1",
-        email: "chiaramobily@gmail.com",
+        email: "chiara@example.com",
         roleSid: "member",
         status: "pending",
         tokenHash,
@@ -265,7 +294,7 @@ test("refuseInviteByToken revokes the invite and returns refused", async () => {
   const response = await service.refuseInviteByToken({
     user: {
       id: "7",
-      email: "chiaramobily@gmail.com",
+      email: "chiara@example.com",
       displayName: "Chiara"
     },
     token: encodedToken
@@ -279,14 +308,30 @@ test("refuseInviteByToken revokes the invite and returns refused", async () => {
   assert.equal(response.workspaceId, "1");
 });
 
-test("participant registration rejects invalid, duplicate and late registration", async () => {
-  const { service } = createFixture();
-  assert.throws(() => service.registerAcceptanceParticipant(null), /must be a function/);
-  service.registerAcceptanceParticipant(async () => {});
-  assert.throws(() => service.registerAcceptanceParticipant(async () => {}), /already registered/);
-  const { service: late } = createFixture();
-  await assert.rejects(late.acceptInviteByToken(), /Authentication required/);
-  assert.throws(() => late.registerAcceptanceParticipant(async () => {}), /registration is closed/);
+test("redeemInviteByToken accepts on an accept decision and refuses on any other", async () => {
+  const user = { id: "7", email: "chiara@example.com", displayName: "Chiara" };
+  for (const [decision, expected] of [["accept", "accepted"], ["refuse", "refused"]]) {
+    const tokenHash = "d".repeat(64);
+    const { service, calls } = createFixture({
+      inviteByTokenHash: {
+        [tokenHash]: {
+          id: "46",
+          workspaceId: "1",
+          email: user.email,
+          roleSid: "member",
+          status: "pending",
+          tokenHash,
+          expiresAt: "2030-01-01T00:00:00.000Z"
+        }
+      }
+    });
+
+    const response = (await service.redeemInviteByToken(user, { token: encodeInviteTokenHash(tokenHash), decision })).value;
+
+    assert.equal(response.decision, expected);
+    assert.deepEqual(calls.acceptCalls, decision === "accept" ? [46] : []);
+    assert.deepEqual(calls.revokeCalls, decision === "accept" ? [] : [46]);
+  }
 });
 
 for (const transactionOutcome of ["committed", "unknown", "rolledBack"]) {
@@ -302,7 +347,9 @@ for (const transactionOutcome of ["committed", "unknown", "rolledBack"]) {
           throw failure;
         }
       },
-      workspaceMembershipsRepository: {}
+      workspaceMembershipsRepository: {},
+      roleCatalog: createWorkspaceRoleCatalog(),
+      acceptanceParticipant: noInviteAcceptanceParticipant
     });
     await assert.rejects(service.acceptInviteByToken({ user: { id: "1", email: "a@example.test" }, token: "valid-token" }),
       (error) => error === failure && error.cause === cause);