@jskit-ai/workspaces-core 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -22,11 +22,11 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.256",
-    "@jskit-ai/json-rest-api-core": "0.2.7",
-    "@jskit-ai/resource-core": "0.1.198",
-    "@jskit-ai/resource-crud-core": "0.1.198",
-    "@jskit-ai/users-core": "0.2.8",
+    "@jskit-ai/database-runtime": "0.1.257",
+    "@jskit-ai/json-rest-api-core": "0.2.9",
+    "@jskit-ai/resource-core": "0.1.199",
+    "@jskit-ai/resource-crud-core": "0.1.199",
+    "@jskit-ai/users-core": "0.2.10",
     "json-rest-schema": "^1.0.17"
   },
   "description": "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
@@ -198,8 +198,8 @@
     }
   },
   "peerDependencies": {
-    "@jskit-ai/auth-core": "0.2.7",
-    "@jskit-ai/http-runtime": "0.2.7",
-    "@jskit-ai/kernel": "0.2.7"
+    "@jskit-ai/auth-core": "0.2.8",
+    "@jskit-ai/http-runtime": "0.2.8",
+    "@jskit-ai/kernel": "0.2.8"
   }
 }

package/src/server/common/repositories/workspaceInvitesRepository.js

@@ -10,7 +10,7 @@ import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
-  extractJsonRestCollectionRows
+  queryAllJsonRestCollectionRows
 } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 
 function normalizeInviteRecord(payload) {
@@ -121,18 +121,17 @@ function createRepository({ api }) {
         updatedAt: dateColumn("updated_at")
       }).forUpdate();
     }
-    return extractJsonRestCollectionRows(
-      await api.resources.workspaceInvites.query(
-        {
-          queryParams: {
-            filters,
-            ...(includeWorkspace ? { include: ["workspace"] } : {})
-          },
-          transaction: resolveTransaction(options),
-          format: "plain"
+    return queryAllJsonRestCollectionRows(
+      api.resources.workspaceInvites,
+      {
+        queryParams: {
+          filters,
+          ...(includeWorkspace ? { include: ["workspace"] } : {})
         },
-        createJsonRestContext(options.context)
-      )
+        transaction: resolveTransaction(options),
+        format: "plain"
+      },
+      options.context
     );
   }
 
@@ -283,8 +282,8 @@ function createRepository({ api }) {
       options
     );
 
-    rows.sort((left, right) => String(right.id || "").localeCompare(String(left.id || "")));
-    return normalizeInviteRecord(rows[0] || null);
+    // queryInvites returns the rows in id order, compared by the database, so the newest is the last.
+    return normalizeInviteRecord(rows.at(-1) || null);
   }
 
   async function expirePendingByWorkspaceIdAndEmail(workspaceId, email, options = {}) {

package/src/server/common/repositories/workspaceMembershipsRepository.js

@@ -8,7 +8,7 @@ import {
 import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
-  extractJsonRestCollectionRows
+  queryAllJsonRestCollectionRows
 } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { OWNER_ROLE_ID } from "../../../shared/roles.js";
 
@@ -54,18 +54,17 @@ function createRepository({ api }) {
           .filter(Boolean)
       )
     );
-    return extractJsonRestCollectionRows(
-      await api.resources.workspaceMemberships.query(
-        {
-          queryParams: {
-            filters,
-            ...(normalizedInclude.length > 0 ? { include: normalizedInclude } : {})
-          },
-          transaction: resolveTransaction(options),
-          format: "plain"
+    return queryAllJsonRestCollectionRows(
+      api.resources.workspaceMemberships,
+      {
+        queryParams: {
+          filters,
+          ...(normalizedInclude.length > 0 ? { include: normalizedInclude } : {})
         },
-        createJsonRestContext(options.context)
-      )
+        transaction: resolveTransaction(options),
+        format: "plain"
+      },
+      options.context
     );
   }
 

package/src/server/common/repositories/workspacesRepository.js

@@ -2,7 +2,8 @@ import { isLostDuplicateInsertRace, resolveTransaction, retryDeadlocks, toIsoStr
 import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
-  extractJsonRestCollectionRows
+  extractJsonRestCollectionRows,
+  queryAllJsonRestCollectionRows
 } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 
 function normalizeWorkspaceRecord(payload = null) {
@@ -180,21 +181,20 @@ function createRepository({ api }) {
       return [];
     }
 
-    const rows = extractJsonRestCollectionRows(
-      await api.resources.workspaceMemberships.query(
-        {
-          queryParams: {
-            filters: {
-              user: normalizedUserId,
-              status: "active"
-            },
-            include: ["workspace"]
+    const rows = await queryAllJsonRestCollectionRows(
+      api.resources.workspaceMemberships,
+      {
+        queryParams: {
+          filters: {
+            user: normalizedUserId,
+            status: "active"
           },
-          transaction: resolveTransaction(options),
-          format: "plain"
+          include: ["workspace"]
         },
-        createJsonRestContext(options.context)
-      )
+        transaction: resolveTransaction(options),
+        format: "plain"
+      },
+      options.context
     );
 
     const workspaces = rows

package/test/repositories.integration.test.js

@@ -17,6 +17,12 @@ import { createRepository as createWorkspacesRepository } from "../src/server/co
 import { createRepository as createMembershipsRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
 import { createRepository as createInvitesRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
 import { createRepository as createSettingsRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
+import { renderDefaultWorkspaceInviteEmail } from "../src/server/workspaceMembers/defaultWorkspaceInviteEmail.js";
+import { unconfiguredWorkspaceInviteMailer } from "../src/server/workspaceMembers/unconfiguredWorkspaceInviteMailer.js";
+import { createWorkspaceInviteUrlBuilder } from "../src/server/workspaceMembers/workspaceInviteUrls.js";
+import { createService as createMembersService } from "../src/server/workspaceMembers/workspaceMembersService.js";
+import { createWorkspacesServerI18n } from "../src/server/i18n.js";
+import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 import { verifyInvitationTransactions } from "./support/invitationTransactions.js";
 
 const TABLES = [
@@ -232,6 +238,125 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
     assert.deepEqual(await workspaces.listForUserId(member.id), []);
   });
 
+  // Lists of more rows than json-rest-api's default page (20) and maximum page (100), written in bulk.
+  async function insertRows(table, rows) {
+    for (let start = 0; start < rows.length; start += 100) {
+      await knex(table).insert(rows.slice(start, start + 100));
+    }
+  }
+
+  async function insertUsers(usernames, displayName = (username) => username) {
+    await insertRows("users", usernames.map((username) => ({
+      auth_provider: "local",
+      auth_provider_user_sid: `identity-${username}`,
+      email: `${username}@example.com`,
+      username,
+      display_name: displayName(username)
+    })));
+    const rows = await knex("users").select("id", "username");
+    return new Map(rows.map((row) => [row.username, String(row.id)]));
+  }
+
+  async function insertWorkspaces(count, ownerUserId) {
+    await insertRows("workspaces", Array.from({ length: count }, (_, index) => ({
+      slug: `team-${index}`,
+      name: `Team ${index}`,
+      owner_user_id: ownerUserId,
+      is_personal: false
+    })));
+    return (await knex("workspaces").orderBy("id").select("id")).map((row) => String(row.id));
+  }
+
+  test("a workspace's 1,050 active members are all listed, sorted by name, inside a transaction too", async () => {
+    // Inserted in an order unrelated to their names, so the pages' id order is not the name order.
+    const numbers = Array.from({ length: 1050 }, (_, index) => String((index * 7919) % 1050).padStart(4, "0"));
+    const users = await insertUsers(
+      [...numbers.map((number) => `member-${number}`), "member-left"],
+      (username) => username.replace("member-", "Member ")
+    );
+    const ownerId = users.get(`member-${numbers[0]}`);
+    const workspace = await workspaces.insert({ slug: "big-team", name: "Big Team", ownerUserId: ownerId });
+    await insertRows("workspace_memberships", [...users].map(([username, userId]) => ({
+      workspace_id: workspace.id,
+      user_id: userId,
+      role_sid: userId === ownerId ? "owner" : "member",
+      status: username === "member-left" ? "inactive" : "active"
+    })));
+    const expectedNames = numbers.map((number) => `Member ${number}`).sort();
+
+    const listed = await memberships.listActiveByWorkspaceId(workspace.id);
+    assert.equal(listed.length, 1050);
+    assert.deepEqual(listed.map(({ displayName }) => displayName), expectedNames);
+    assert.equal(new Set(listed.map(({ userId }) => userId)).size, 1050);
+
+    const membersService = createMembersService({
+      workspaceMembershipsRepository: memberships,
+      workspaceInvitesRepository: invites,
+      inviteExpiresInMs: 86400000,
+      roleCatalog: createWorkspaceRoleCatalog(),
+      workspaceInvitationsEnabled: false,
+      inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+      workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+      workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail,
+      i18n: createWorkspacesServerI18n(),
+      userProfilesRepository: profiles,
+      userSettingsRepository: userSettings
+    });
+    const { members } = await membersService.listMembers(workspace);
+    assert.deepEqual(members.map(({ userId }) => userId), listed.map(({ userId }) => userId));
+    assert.deepEqual(members.filter(({ isOwner }) => isOwner).map(({ userId }) => userId), [ownerId]);
+
+    await profiles.withTransaction(async (trx) => {
+      const joiner = await createProfile("Zara", { trx });
+      await memberships.upsertMembership(workspace.id, joiner.id, { roleSid: "member", status: "active" }, { trx });
+      const withJoiner = await memberships.listActiveByWorkspaceId(workspace.id, { trx });
+      assert.equal(withJoiner.length, 1051);
+      assert.equal(withJoiner.at(-1).displayName, "Zara");
+    });
+  });
+
+  test("a member of 130 workspaces has all of them listed", async () => {
+    const users = await insertUsers(["host", "roaming"]);
+    const workspaceIds = await insertWorkspaces(135, users.get("host"));
+    await insertRows("workspace_memberships", workspaceIds.map((workspaceId, index) => ({
+      workspace_id: workspaceId,
+      user_id: users.get("roaming"),
+      role_sid: "member",
+      status: index < 130 ? "active" : "inactive"
+    })));
+    const activeIds = workspaceIds.slice(0, 130);
+
+    const ids = await memberships.listActiveWorkspaceIdsByUserId(users.get("roaming"));
+    assert.deepEqual([...ids].sort(), [...activeIds].sort());
+    assert.deepEqual((await workspaces.listForUserId(users.get("roaming"))).map(({ id }) => id), activeIds);
+  });
+
+  test("a workspace's 120 pending invitations and an email's 110 are all listed", async () => {
+    const users = await insertUsers(["host"]);
+    const [crowdedId, ...otherIds] = await insertWorkspaces(111, users.get("host"));
+    await insertRows("workspace_invites", [
+      ...Array.from({ length: 123 }, (_, index) => ({
+        workspace_id: crowdedId,
+        email: `guest-${index}@example.com`,
+        status: index < 120 ? "pending" : "accepted",
+        token_hash: `crowded-${index}`
+      })),
+      ...otherIds.map((workspaceId) => ({
+        workspace_id: workspaceId,
+        email: "roaming@example.com",
+        status: "pending",
+        token_hash: `roaming-${workspaceId}`
+      }))
+    ]);
+
+    const crowded = await invites.listPendingByWorkspaceIdWithWorkspace(crowdedId);
+    assert.equal(crowded.length, 120);
+    assert.equal(new Set(crowded.map(({ email }) => email)).size, 120);
+    const roaming = await invites.listPendingByEmail("roaming@example.com");
+    assert.deepEqual(roaming.map(({ workspaceId }) => workspaceId).sort(), [...otherIds].sort());
+    assert.ok(roaming.every(({ workspaceSlug }) => workspaceSlug.startsWith("team-")));
+  });
+
   test("workspace settings and invitation lifecycle preserve logical IDs and included workspaces", async () => {
     const owner = await createProfile("Ada");
     const workspace = await workspaces.insert({ slug: "invitations", name: "Invitations", ownerUserId: owner.id });

package/test/repositoryContracts.test.js

@@ -55,6 +55,7 @@ for (const [name, createRepository, resourceName, write] of duplicateRecoveryCas
       });
       const api = createApiStub();
       api.resources[resourceName] = {
+        vars: { queryMaxLimit: 100 },
         async query() {
           assert.equal(writeStarted, false, "A failed transaction cannot support duplicate recovery");
           reads += 1;

package/test/workspaceInvitesRepository.test.js

@@ -55,6 +55,7 @@ function createWorkspaceInvitesApiStub({
     async transaction(work) { return work(trx); },
     resources: {
       workspaceInvites: {
+        vars: { queryMaxLimit: 100 },
         async query({ queryParams, format }) {
           assert.equal(format, "plain");
           const filters = queryParams?.filters || {};
@@ -152,6 +153,30 @@ test("workspaceInvitesRepository.insert preserves expiresAt and relationship fie
   assert.equal(typeof state.postPayload.data.expiresAt, "string");
 });
 
+test("workspaceInvitesRepository.insert recovers a lost duplicate race with the newest pending invite by id, 10 after 9", async () => {
+  const pendingInvite = (id) => ({
+    id,
+    workspace: { id: "7" },
+    email: "ada@example.com",
+    roleSid: "member",
+    status: "pending",
+    tokenHash: `token-${id}`
+  });
+  // In id order, as the resource returns them.
+  const { api } = createWorkspaceInvitesApiStub({ rows: [pendingInvite("9"), pendingInvite("10")] });
+  api.resources.workspaceInvites.post = async () => {
+    throw Object.assign(new Error("Duplicate invite"), {
+      transactionOutcome: "rolledBack",
+      cause: { code: "ER_DUP_ENTRY" }
+    });
+  };
+  const repository = createRepository({ api });
+
+  const invite = await repository.insert({ workspaceId: "7", email: "ada@example.com", tokenHash: "token-new" });
+
+  assert.equal(invite.id, "10");
+});
+
 test("workspaceInvitesRepository.findPendingByTokenHash reads from the canonical invite resource without workspace data", async () => {
   const { api } = createWorkspaceInvitesApiStub({
     rows: [

package/test/workspaceMembershipsRepository.test.js

@@ -43,6 +43,7 @@ function createWorkspaceMembershipsApiStub({
   const api = {
     resources: {
       workspaceMemberships: {
+        vars: { queryMaxLimit: 100 },
         async query({ queryParams, format }) {
           assert.equal(format, "plain");
           state.queryCalls.push(queryParams || {});
@@ -280,7 +281,9 @@ test("workspaceMembershipsRepository.listActiveWorkspaceIdsByUserId returns norm
         user: "9",
         status: "active"
       },
-      include: ["workspace"]
+      include: ["workspace"],
+      sort: ["id"],
+      page: { size: 100 }
     }
   ]);
 });

package/test/workspacesRepository.test.js

@@ -125,6 +125,7 @@ function createWorkspacesApiStub({
         }
       },
       workspaceMemberships: {
+        vars: { queryMaxLimit: 100 },
         async query({ queryParams, format }) {
           assert.equal(format, "plain");
           const filters = queryParams?.filters || {};