@jskit-ai/workspaces-core 0.2.13 → 0.2.14

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- A workspace request's auth policy and its action context share one workspace context resolution: `resolveWorkspaceContextForUserBySlug` called with the same `request` (the auth policy resolver now passes it, as the action context contributor already did), user, slug and membership requirement reads the workspace, membership and workspace settings once instead of once per check, so a workspace action with a permission no longer repeats those reads before its handler. Calls without a request, or in a transaction, resolve on their own as before.
+- `workspaceMembershipsRepository.listActiveWorkspaceIdsByUserIds(userIds, options)` answers many users' active workspace ids as a `Map` in one query per 1,000 users, reading the memberships' `workspace_id` instead of including each workspace. The memberships resource gains the `users` filter (`user_id in [...]`) it uses. The realtime audience contributor (`workspaces.memberships`) answers realtime's bulk `resolveActorsScopes(actorIds)` with it, so a workspace event costs one memberships query, not one per online user.
+- A new workspace's slug (`base`, then `base-2` to `base-1000`) is chosen with one read of every taken candidate through `workspacesRepository.listSlugsIn(slugs, options)` and the workspace resource's new `slugs` filter (`in`), instead of one `findBySlug` per taken candidate, so a common name costs the same statements after 10 namesakes as after 200. The chosen slug and the error when all 1,000 are taken are unchanged.
 - `services.members.getMember(workspace, userId, options)` answers one active member's summary, the same as their `listMembers` entry, or `null` for a removed or unknown member. It reads that one membership through `workspaceMembershipsRepository.findActiveByWorkspaceIdAndUserId`, so a per-member lookup (a notification's recipient check, for example) costs the same few statements in a workspace of 10 or 1,000 members instead of listing them all.
 - The workspace, settings, member and invitation field messages are sent in the coded form `{ code, message, params }`, so their field errors translate. The English is unchanged.
 - The resources' save, delete and validation feedback names catalog keys under `jskit.workspaces.feedback.*` instead of plain English; JSKIT's forms render them with `text()`, so the English shown is unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "type": "module",
   "scripts": {
     "test": "jskit test"
@@ -22,11 +22,11 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.260",
-    "@jskit-ai/json-rest-api-core": "0.2.12",
-    "@jskit-ai/resource-core": "0.1.202",
-    "@jskit-ai/resource-crud-core": "0.1.202",
-    "@jskit-ai/users-core": "0.2.13",
+    "@jskit-ai/database-runtime": "0.1.261",
+    "@jskit-ai/json-rest-api-core": "0.2.13",
+    "@jskit-ai/resource-core": "0.1.203",
+    "@jskit-ai/resource-crud-core": "0.1.203",
+    "@jskit-ai/users-core": "0.2.14",
     "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.11",
-    "@jskit-ai/http-runtime": "0.2.11",
-    "@jskit-ai/kernel": "0.2.11"
+    "@jskit-ai/auth-core": "0.2.12",
+    "@jskit-ai/http-runtime": "0.2.12",
+    "@jskit-ai/kernel": "0.2.12"
   }
 }

package/src/server/WorkspacesIntegrationsProvider.js

@@ -9,16 +9,20 @@ import {
 
 /**
  * Every active membership puts the actor in the workspace audience and in its
- * own workspace-user audience.
+ * own workspace-user audience. All the actors' memberships are one bulk read.
  * @param {import("./types.js").WorkspaceMembershipsRepository} workspaceMemberships
- * @param {string} actorId
+ * @param {string[]} actorIds
  */
-async function resolveWorkspaceRealtimeScopes(workspaceMemberships, actorId) {
-  const workspaceIds = await workspaceMemberships.listActiveWorkspaceIdsByUserId(actorId);
-  return workspaceIds.flatMap((workspaceId) => [
-    { kind: "workspace", id: workspaceId },
-    { kind: "workspace_user", workspaceId, userId: actorId }
-  ]);
+async function resolveWorkspaceRealtimeScopes(workspaceMemberships, actorIds) {
+  const workspaceIdsByActorId = await workspaceMemberships.listActiveWorkspaceIdsByUserIds(actorIds);
+  const scopesByActorId = new Map();
+  for (const [actorId, workspaceIds] of workspaceIdsByActorId) {
+    scopesByActorId.set(actorId, workspaceIds.flatMap((workspaceId) => [
+      { kind: "workspace", id: workspaceId },
+      { kind: "workspace_user", workspaceId, userId: actorId }
+    ]));
+  }
+  return scopesByActorId;
 }
 
 const WorkspacesIntegrationsProvider = defineProvider({
@@ -88,9 +92,9 @@ const WorkspacesIntegrationsProvider = defineProvider({
     if (realtime) {
       realtime.registerAudienceContributor({
         id: "workspaces.memberships",
-        resolveActorScopes: (actorId) => resolveWorkspaceRealtimeScopes(
+        resolveActorsScopes: (actorIds) => resolveWorkspaceRealtimeScopes(
           workspaces.repositories.workspaceMemberships,
-          actorId
+          actorIds
         )
       });
     }

package/src/server/common/contributors/workspaceAuthPolicyContextResolver.js

@@ -30,7 +30,7 @@ function createWorkspaceAuthPolicyContextResolver({ workspaceService, workspaceM
     const { workspace, membership, permissions } = await workspaceService.resolveWorkspaceContextForUserBySlug(
       actor,
       workspaceSlug,
-      { requireMembership }
+      { requireMembership, request }
     );
 
     return { workspace, membership, permissions };

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

@@ -12,6 +12,9 @@ import {
 } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { OWNER_ROLE_ID } from "../../../shared/roles.js";
 
+// A bulk read's users per query, so its "in" list stays well inside every database's limits.
+const USER_IDS_PER_QUERY = 1000;
+
 function normalizeMembershipRecord(payload) {
   if (!payload) {
     return null;
@@ -278,6 +281,39 @@ function createRepository({ api }) {
       .filter(Boolean);
   }
 
+  /**
+   * Each user's active workspace ids, as listActiveWorkspaceIdsByUserId lists them, in one
+   * query per 1,000 users: its cost does not grow with the users asked about. It reads the
+   * memberships' workspace_id column instead of including each workspace.
+   * @param {Iterable<string | number>} userIds
+   * @param {object} [options]
+   * @returns {Promise<Map<string, string[]>>} Every asked user, with no workspaces when they have none.
+   */
+  async function listActiveWorkspaceIdsByUserIds(userIds, options = {}) {
+    const workspaceIdsByUserId = new Map();
+    for (const userId of userIds) {
+      const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+      if (normalizedUserId) workspaceIdsByUserId.set(normalizedUserId, []);
+    }
+
+    const normalizedUserIds = [...workspaceIdsByUserId.keys()];
+    for (let start = 0; start < normalizedUserIds.length; start += USER_IDS_PER_QUERY) {
+      const rows = await queryMemberships(
+        {
+          users: normalizedUserIds.slice(start, start + USER_IDS_PER_QUERY),
+          status: "active"
+        },
+        options
+      );
+      for (const row of rows) {
+        const userId = normalizeDbRecordId(row?.user?.id || row?.userId, { fallback: null });
+        const workspaceId = normalizeDbRecordId(row?.workspace?.id || row?.workspaceId, { fallback: null });
+        if (workspaceId) workspaceIdsByUserId.get(userId)?.push(workspaceId);
+      }
+    }
+    return workspaceIdsByUserId;
+  }
+
   return Object.freeze({
     withTransaction,
     findByWorkspaceIdAndUserId,
@@ -285,7 +321,8 @@ function createRepository({ api }) {
     upsertMembership,
     listActiveByWorkspaceId,
     findActiveByWorkspaceIdAndUserId,
-    listActiveWorkspaceIdsByUserId
+    listActiveWorkspaceIdsByUserId,
+    listActiveWorkspaceIdsByUserIds
   });
 }
 

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

@@ -1,5 +1,5 @@
 import { isLostDuplicateInsertRace, resolveTransaction, retryDeadlocks, toIsoString } from "@jskit-ai/database-runtime/shared";
-import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
   extractJsonRestCollectionRows,
@@ -63,6 +63,36 @@ function createRepository({ api }) {
     return queryFirst({ slug: normalizedSlug }, options);
   }
 
+  /**
+   * Which of these slugs workspaces already hold, in one read however many do.
+   * @param {string[]} slugs
+   * @param {object} [options]
+   * @returns {Promise<Set<string>>}
+   */
+  async function listSlugsIn(slugs, options = {}) {
+    const normalizedSlugs = [...new Set(
+      (Array.isArray(slugs) ? slugs : []).map((slug) => normalizeLowerText(slug)).filter(Boolean)
+    )];
+    if (normalizedSlugs.length < 1) {
+      return new Set();
+    }
+
+    const rows = await queryAllJsonRestCollectionRows(
+      api.resources.workspaces,
+      {
+        queryParams: {
+          filters: {
+            slugs: normalizedSlugs
+          }
+        },
+        transaction: resolveTransaction(options),
+        format: "plain"
+      },
+      options.context
+    );
+    return new Set(rows.map((row) => normalizeLowerText(row.slug)));
+  }
+
   async function findPersonalByOwnerUserId(userId, options = {}) {
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedUserId) {
@@ -231,6 +261,7 @@ function createRepository({ api }) {
     withTransaction,
     findById,
     findBySlug,
+    listSlugsIn,
     findPersonalByOwnerUserId,
     insert,
     updateById,

package/src/server/common/services/workspaceDirectoryService.js

@@ -7,6 +7,8 @@ import { listCatalogRolePermissions } from "../../../shared/roles.js";
 import { TENANCY_MODE_NONE } from "../../../shared/tenancyProfile.js";
 import { mapWorkspaceSummary } from "../formatters/workspaceFormatter.js";
 
+const WORKSPACE_SLUG_CANDIDATE_LIMIT = 1000;
+
 function toSlugPart(value) {
   const normalized = normalizeLowerText(value)
     .replace(/[^a-z0-9]+/g, "-")
@@ -69,14 +71,16 @@ function createService({
   const workspacePolicy = tenancyProfile.workspace;
 
   async function ensureUniqueWorkspaceSlug(baseSlug, options = {}) {
-    let suffix = 0;
-    while (suffix < 1000) {
-      suffix += 1;
-      const candidate = suffix === 1 ? toSlugPart(baseSlug) : `${toSlugPart(baseSlug)}-${suffix}`;
-      const existing = await workspacesRepository.findBySlug(candidate, options);
-      if (!existing) {
-        return candidate;
-      }
+    const slugPart = toSlugPart(baseSlug);
+    // The base, then base-2 to base-1000, read in one query however many are taken.
+    const candidates = Array.from(
+      { length: WORKSPACE_SLUG_CANDIDATE_LIMIT },
+      (_, index) => (index === 0 ? slugPart : `${slugPart}-${index + 1}`)
+    );
+    const takenSlugs = await workspacesRepository.listSlugsIn(candidates, options);
+    const candidate = candidates.find((slug) => !takenSlugs.has(slug));
+    if (candidate) {
+      return candidate;
     }
     throw new Error("Unable to generate unique workspace slug.");
   }
@@ -208,7 +212,40 @@ function createService({
     return returnJsonApiData(await workspacesRepository.updateById(workspaceContext.workspace.id, patch, options));
   }
 
-  async function resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
+  // The checks that run before a request's handler (its auth policy and its action context)
+  // each need the request's workspace context. They pass the request and share one resolution
+  // for the same user, slug and membership requirement, instead of reading the workspace, the
+  // membership and the settings again for each check. A call in a transaction, or without a
+  // request, resolves on its own.
+  const requestWorkspaceContexts = new WeakMap();
+
+  /**
+   * @param {{ id?: unknown } | null} user
+   * @param {string} workspaceSlug
+   * @param {{ request?: object, requireMembership?: boolean, trx?: unknown }} [options]
+   */
+  function resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
+    const request = options.request;
+    if (!request || typeof request !== "object" || options.trx) {
+      return readWorkspaceContextForUserBySlug(user, workspaceSlug, options);
+    }
+    const key = [
+      normalizeRecordId(user?.id, { fallback: "" }),
+      normalizeLowerText(workspaceSlug),
+      options.requireMembership !== false
+    ].join("\0");
+    let resolutions = requestWorkspaceContexts.get(request);
+    if (!resolutions) {
+      resolutions = new Map();
+      requestWorkspaceContexts.set(request, resolutions);
+    }
+    if (!resolutions.has(key)) {
+      resolutions.set(key, readWorkspaceContextForUserBySlug(user, workspaceSlug, options));
+    }
+    return resolutions.get(key);
+  }
+
+  async function readWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
     const requireMembership = options.requireMembership !== false;
     const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
     if (!normalizedUserId) {

package/src/shared/resources/workspaceMembershipsResource.js

@@ -1,4 +1,5 @@
 import { normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
+import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
 import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 
 const workspaceMembershipsResource = defineCrudResource({
@@ -8,6 +9,12 @@ const workspaceMembershipsResource = defineCrudResource({
     id: { type: "id", actualField: "id" },
     workspace: { type: "id", actualField: "workspace_id", filterOperator: "=" },
     user: { type: "id", actualField: "user_id", filterOperator: "=" },
+    users: {
+      type: "array",
+      actualField: "user_id",
+      filterOperator: "in",
+      items: { type: "string", pattern: RECORD_ID_PATTERN }
+    },
     status: { type: "string", actualField: "status", filterOperator: "=" }
   },
   schema: {

package/src/shared/resources/workspaceResource.js

@@ -77,6 +77,7 @@ const resource = defineCrudResource({
   searchSchema: {
     id: { type: "id", actualField: "id" },
     slug: { type: "string", actualField: "slug", filterOperator: "=" },
+    slugs: { type: "array", actualField: "slug", filterOperator: "in", items: { type: "string" } },
     owner: { type: "id", actualField: "owner_user_id", filterOperator: "=" },
     isPersonal: { type: "boolean", actualField: "is_personal", filterOperator: "=" }
   },

package/test/featureRuntime.test.js

@@ -141,21 +141,24 @@ test("workspace realtime audiences are the actor's active memberships", async ()
       services: { directory: { async resolveWorkspaceContextForUserBySlug() { return null; } } },
       repositories: {
         workspaceMemberships: {
-          async listActiveWorkspaceIdsByUserId(userId) {
-            assert.equal(userId, "9");
-            return ["11", "12"];
+          async listActiveWorkspaceIdsByUserIds(userIds) {
+            assert.deepEqual(userIds, ["9", "10"]);
+            return new Map([["9", ["11", "12"]], ["10", []]]);
           }
         }
       }
     }
   });
   assert.equal(audienceContributors.length, 1);
-  assert.deepEqual(await audienceContributors[0].resolveActorScopes("9"), [
-    { kind: "workspace", id: "11" },
-    { kind: "workspace_user", workspaceId: "11", userId: "9" },
-    { kind: "workspace", id: "12" },
-    { kind: "workspace_user", workspaceId: "12", userId: "9" }
-  ]);
+  assert.deepEqual(await audienceContributors[0].resolveActorsScopes(["9", "10"]), new Map([
+    ["9", [
+      { kind: "workspace", id: "11" },
+      { kind: "workspace_user", workspaceId: "11", userId: "9" },
+      { kind: "workspace", id: "12" },
+      { kind: "workspace_user", workspaceId: "12", userId: "9" }
+    ]],
+    ["10", []]
+  ]));
 });
 
 test("workspace settings color defaults must be hex colors", () => {

package/test/repositories.integration.test.js

@@ -21,6 +21,8 @@ import { renderDefaultWorkspaceInviteEmail } from "../src/server/workspaceMember
 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 { buildWorkspaceName, createService as createDirectoryService } from "../src/server/common/services/workspaceDirectoryService.js";
+import { resolveTenancyProfile } from "../src/shared/tenancyProfile.js";
 import { createWorkspacesServerI18n } from "../src/server/i18n.js";
 import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 import { verifyInvitationTransactions } from "./support/invitationTransactions.js";
@@ -84,6 +86,8 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
   let memberships;
   let invites;
   let settings;
+  let usersExtensions;
+  let profileProjector;
   let ownsTables = false;
 
   before(async () => {
@@ -109,11 +113,13 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
       await migration.up(knex);
     }
     api = await createJsonRestApiHost({ knex, logger: { error() {}, warn() {}, info() {}, debug() {} } });
-    const { identity } = await UsersIdentityProvider.setup({
+    usersExtensions = createUsersExtensions();
+    const { identity, profileProjector: projector } = await UsersIdentityProvider.setup({
       authExtensions: createAuthExtensions(),
-      extensions: createUsersExtensions(),
+      extensions: usersExtensions,
       jsonRestApi: api
     });
+    profileProjector = projector;
     ({ userProfiles: profiles, userSettings } = identity.repositories);
     await installWorkspaceResources(api);
     workspaces = createWorkspacesRepository({ api });
@@ -281,6 +287,19 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
     return (await knex("workspaces").orderBy("id").select("id")).map((row) => String(row.id));
   }
 
+  // The run's result and the SQL statements it issued.
+  async function statementsOf(run) {
+    let statements = 0;
+    const onQuery = () => { statements += 1; };
+    knex.on("query", onQuery);
+    try {
+      const result = await run();
+      return { result, statements };
+    } finally {
+      knex.removeListener("query", onQuery);
+    }
+  }
+
   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"));
@@ -336,17 +355,6 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
       ...usernames.slice(10, 210).map((username) => membership(large.id, username, username === "person-209" ? "revoked" : "active"))
     ]);
     const membersService = createMembers();
-    async function statementsOf(run) {
-      let statements = 0;
-      const onQuery = () => { statements += 1; };
-      knex.on("query", onQuery);
-      try {
-        const result = await run();
-        return { result, statements };
-      } finally {
-        knex.removeListener("query", onQuery);
-      }
-    }
 
     for (const [workspace, memberName, removedName] of [
       [small, "person-004", "person-009"],
@@ -377,6 +385,94 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
     });
   });
 
+  // `base`, then `base-2` to `base-<count>`: the names `count` earlier namesakes took.
+  const namesakes = (base, count) => [base, ...Array.from({ length: count - 1 }, (_, index) => `${base}-${index + 2}`)];
+
+  test("a new profile's username costs the same statements after 10 and after 200 namesakes", async () => {
+    await insertUsers([...namesakes("info", 10), ...namesakes("john", 200)]);
+    const signUp = (base) => statementsOf(() => profiles.upsert({
+      authProvider: "local",
+      authProviderUserSid: `newcomer-${base}`,
+      email: `${base}@newcomer.example`,
+      displayName: base
+    }));
+
+    const few = await signUp("info");
+    const many = await signUp("john");
+    assert.equal(few.result.username, "info-11");
+    assert.equal(many.result.username, "john-201");
+    // A read per taken candidate would add about 190 statements.
+    assert.equal(many.statements, few.statements, `${few.statements} statements after 10 namesakes, ${many.statements} after 200`);
+  });
+
+  test("a new workspace's slug costs the same statements after 10 and after 200 namesakes", async () => {
+    const users = await insertUsers(["founder"]);
+    const ownerUserId = users.get("founder");
+    await insertRows("workspaces", [...namesakes("acme", 10), ...namesakes("globex", 200)].map((slug) => ({
+      slug, name: slug, owner_user_id: ownerUserId, is_personal: false
+    })));
+    const directory = createDirectoryService({
+      tenancyProfile: resolveTenancyProfile({ tenancyMode: "workspaces", tenancyPolicy: { workspace: { allowSelfCreate: true } } }),
+      roleCatalog: createWorkspaceRoleCatalog(),
+      personalWorkspaceName: buildWorkspaceName,
+      workspacesRepository: workspaces,
+      workspaceMembershipsRepository: memberships,
+      workspaceSettingsRepository: settings
+    });
+    const create = (name) => statementsOf(() => directory.createWorkspaceForAuthenticatedUser({ id: ownerUserId }, { name }));
+
+    const few = await create("Acme");
+    const many = await create("Globex");
+    assert.equal(few.result.value.slug, "acme-11");
+    assert.equal(many.result.value.slug, "globex-201");
+    // A read per taken candidate would add about 190 statements.
+    assert.equal(many.statements, few.statements, `${few.statements} statements after 10 namesakes, ${many.statements} after 200`);
+  });
+
+  test("an ordinary request reads its matching profile in one statement; sign-in and a changed identity synchronize in full", async () => {
+    const directory = createDirectoryService({
+      tenancyProfile: resolveTenancyProfile({ tenancyMode: "personal" }),
+      roleCatalog: createWorkspaceRoleCatalog(),
+      personalWorkspaceName: buildWorkspaceName,
+      workspacesRepository: workspaces,
+      workspaceMembershipsRepository: memberships,
+      workspaceSettingsRepository: settings
+    });
+    // What WorkspacesIntegrationsProvider registers: a synchronization provisions the personal workspace.
+    usersExtensions.registerProfileSyncLifecycleContributor({
+      contributorId: "workspaces.provisioning",
+      order: 100,
+      afterIdentityProfileSynced: ({ profile, options }) => directory.ensureProvisionedWorkspaceForAuthenticatedUser(profile, options)
+    });
+    const identity = (displayName) => ({ authProvider: "local", authProviderUserSid: "identity-ada", email: "ada@example.com", displayName });
+    const personalWorkspaces = (userId) => knex("workspaces").where({ owner_user_id: userId, is_personal: true }).count({ count: "*" })
+      .first().then((row) => Number(row.count));
+
+    const signIn = await statementsOf(() => profileProjector.syncIdentityProfile(identity("Ada")));
+    const userId = signIn.result.id;
+    assert.equal(await personalWorkspaces(userId), 1);
+    const read = await statementsOf(() => profiles.findByIdentity({ provider: "local", providerUserId: "identity-ada" }));
+
+    const request = await statementsOf(() => profileProjector.syncIdentityProfile(identity("Ada"), { onlyWhenChanged: true }));
+    assert.equal(request.result.id, userId);
+    assert.equal(request.statements, read.statements, "An ordinary request reads the profile and nothing else");
+    assert.ok(signIn.statements > read.statements, `sign-in ${signIn.statements} statements, a profile read ${read.statements}`);
+
+    // A deleted personal workspace is not provisioned again by an ordinary request, only by the next full synchronization.
+    await knex("workspace_settings").delete();
+    await knex("workspace_memberships").delete();
+    await knex("workspaces").delete();
+    await profileProjector.syncIdentityProfile(identity("Ada"), { onlyWhenChanged: true });
+    assert.equal(await personalWorkspaces(userId), 0);
+    await profileProjector.syncIdentityProfile(identity("Ada"));
+    assert.equal(await personalWorkspaces(userId), 1);
+
+    // An identity whose name changed outside the app is synchronized by the request that carries it.
+    const renamed = await statementsOf(() => profileProjector.syncIdentityProfile(identity("Ada Lovelace"), { onlyWhenChanged: true }));
+    assert.equal(renamed.result.displayName, "Ada Lovelace");
+    assert.ok(renamed.statements > read.statements);
+  });
+
   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"));
@@ -393,6 +489,43 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
     assert.deepEqual((await workspaces.listForUserId(users.get("roaming"))).map(({ id }) => id), activeIds);
   });
 
+  test("the bulk read lists each user's active workspaces at the same cost for 10 and 200 users", async () => {
+    const usernames = Array.from({ length: 202 }, (_, index) => `person-${String(index).padStart(3, "0")}`);
+    const users = await insertUsers(usernames);
+    const [first, second, third] = await insertWorkspaces(3, users.get("person-000"));
+    // Each person is active in the first workspace; even persons are active in the second
+    // too, odd ones were invited to it, and every tenth was removed from the third.
+    await insertRows("workspace_memberships", usernames.flatMap((username, index) => [
+      { workspace_id: first, user_id: users.get(username), role_sid: "member", status: "active" },
+      {
+        workspace_id: second,
+        user_id: users.get(username),
+        role_sid: "member",
+        status: index % 2 === 0 ? "active" : "invited"
+      },
+      ...(index % 10 === 0
+        ? [{ workspace_id: third, user_id: users.get(username), role_sid: "member", status: "removed" }]
+        : [])
+    ]));
+    const expectedFor = (index) => (index % 2 === 0 ? [first, second] : [first]);
+    const idsOf = (names) => names.map((username) => users.get(username));
+
+    const small = await statementsOf(() => memberships.listActiveWorkspaceIdsByUserIds(idsOf(usernames.slice(0, 10))));
+    const large = await statementsOf(() => memberships.listActiveWorkspaceIdsByUserIds(idsOf(usernames.slice(0, 200))));
+    for (const [read, names] of [[small, usernames.slice(0, 10)], [large, usernames.slice(0, 200)]]) {
+      assert.deepEqual([...read.result.keys()].sort(), idsOf(names).sort());
+      names.forEach((username, index) => {
+        assert.deepEqual([...read.result.get(users.get(username))].sort(), expectedFor(index).sort());
+      });
+    }
+    assert.equal(large.statements, small.statements);
+
+    // A user with no active membership is still answered, with no workspaces.
+    const outsider = (await insertUsers(["outsider"])).get("outsider");
+    assert.deepEqual(await memberships.listActiveWorkspaceIdsByUserIds([outsider]), new Map([[outsider, []]]));
+    assert.deepEqual(await memberships.listActiveWorkspaceIdsByUserIds([]), new Map());
+  });
+
   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"));

package/test/resourcesCanonical.test.js

@@ -57,13 +57,17 @@ test("workspaces-core resources expose messages for all operations", () => {
 });
 
 test("workspaces-core repository filters are declared on canonical resources", () => {
-  assert.deepEqual(Object.keys(workspaceResource.searchSchema), ["id", "slug", "owner", "isPersonal"]);
+  assert.deepEqual(Object.keys(workspaceResource.searchSchema), ["id", "slug", "slugs", "owner", "isPersonal"]);
   assert.equal(workspaceResource.searchSchema.slug.actualField, "slug");
+  assert.equal(workspaceResource.searchSchema.slugs.actualField, "slug");
+  assert.equal(workspaceResource.searchSchema.slugs.filterOperator, "in");
   assert.equal(workspaceResource.searchSchema.owner.actualField, "owner_user_id");
 
-  assert.deepEqual(Object.keys(workspaceMembershipsResource.searchSchema), ["id", "workspace", "user", "status"]);
+  assert.deepEqual(Object.keys(workspaceMembershipsResource.searchSchema), ["id", "workspace", "user", "users", "status"]);
   assert.equal(workspaceMembershipsResource.searchSchema.workspace.actualField, "workspace_id");
   assert.equal(workspaceMembershipsResource.searchSchema.user.actualField, "user_id");
+  assert.equal(workspaceMembershipsResource.searchSchema.users.actualField, "user_id");
+  assert.equal(workspaceMembershipsResource.searchSchema.users.filterOperator, "in");
 
   assert.deepEqual(Object.keys(workspaceInvitesResource.searchSchema), ["id", "workspace", "email", "status", "tokenHash"]);
   assert.equal(workspaceInvitesResource.searchSchema.workspace.actualField, "workspace_id");

package/test/workspaceAuthPolicyContextResolver.test.js

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

package/test/workspaceMembershipsRepository.test.js

@@ -287,3 +287,43 @@ test("workspaceMembershipsRepository.listActiveWorkspaceIdsByUserId returns norm
     }
   ]);
 });
+
+test("workspaceMembershipsRepository.listActiveWorkspaceIdsByUserIds reads 1,000 users per query without including workspaces", async () => {
+  const queryCalls = [];
+  const api = {
+    resources: {
+      workspaceMemberships: {
+        vars: { queryMaxLimit: 100 },
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
+          queryCalls.push(queryParams);
+          // Every asked user is active in workspace 7, and user 1 in workspace 8 too.
+          const rows = queryParams.filters.users.flatMap((userId) => [
+            { id: `m${userId}`, workspace: { id: "7" }, user: { id: userId }, status: "active" },
+            ...(userId === "1" ? [{ id: "m1-8", workspace: { id: "8" }, user: { id: "1" }, status: "active" }] : [])
+          ]);
+          return asCollectionDocument(rows);
+        }
+      }
+    }
+  };
+  const repository = createRepository({ api });
+  const userIds = Array.from({ length: 1001 }, (_, index) => String(index + 1));
+
+  const workspaceIds = await repository.listActiveWorkspaceIdsByUserIds([...userIds, "1", "", null]);
+
+  assert.equal(workspaceIds.size, 1001);
+  assert.deepEqual(workspaceIds.get("1"), ["7", "8"]);
+  assert.deepEqual(workspaceIds.get("1001"), ["7"]);
+  assert.deepEqual(queryCalls.map(({ filters }) => filters.users.length), [1000, 1]);
+  assert.deepEqual(queryCalls[1], {
+    filters: {
+      users: ["1001"],
+      status: "active"
+    },
+    sort: ["id"],
+    page: { size: 1000 }
+  });
+  assert.deepEqual(await repository.listActiveWorkspaceIdsByUserIds([]), new Map());
+  assert.equal(queryCalls.length, 2, "No users need no query");
+});

package/test/workspaceService.test.js

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createWorkspaceActionContextContributor } from "../src/server/common/contributors/workspaceActionContextContributor.js";
+import { createWorkspaceAuthPolicyContextResolver } from "../src/server/common/contributors/workspaceAuthPolicyContextResolver.js";
 import { buildWorkspaceName, createService } from "../src/server/common/services/workspaceDirectoryService.js";
 import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 import { resolveTenancyProfile } from "../src/shared/tenancyProfile.js";
@@ -49,6 +51,8 @@ function createWorkspaceServiceFixture({
   }
 } = {}) {
   const calls = {
+    findBySlug: 0,
+    listSlugsIn: 0,
     findPersonalByOwnerUserId: 0,
     listForUserId: 0,
     insert: 0,
@@ -89,6 +93,7 @@ function createWorkspaceServiceFixture({
     }),
     workspacesRepository: {
       async findBySlug(slug) {
+        calls.findBySlug += 1;
         const normalizedSlug = String(slug || "").trim().toLowerCase();
         const workspace = workspaceBySlug.get(normalizedSlug);
         if (!workspace) {
@@ -96,6 +101,10 @@ function createWorkspaceServiceFixture({
         }
         return { ...workspace };
       },
+      async listSlugsIn(slugs) {
+        calls.listSlugsIn += 1;
+        return new Set(slugs.filter((slug) => workspaceBySlug.has(String(slug).trim().toLowerCase())));
+      },
       async findPersonalByOwnerUserId() {
         calls.findPersonalByOwnerUserId += 1;
         return personalWorkspaceState ? { ...personalWorkspaceState } : null;
@@ -412,6 +421,42 @@ test("workspaceService.createWorkspaceForAuthenticatedUser generates an omitted
   assert.equal(insertedPayloads[0].ownerUserId, "7");
 });
 
+// The slug a new workspace named `name` gets while `takenSlugs` are held, and how many reads chose it.
+async function chooseWorkspaceSlug(name, takenSlugs) {
+  const { service, calls } = createWorkspaceServiceFixture({
+    tenancyMode: "workspaces",
+    tenancyPolicy: { workspace: { allowSelfCreate: true } },
+    personalWorkspace: null,
+    additionalWorkspaces: takenSlugs.map((slug, index) => ({
+      id: String(1000 + index), slug, name: slug, ownerUserId: "8", isPersonal: false, avatarUrl: ""
+    }))
+  });
+  const workspace = (await service.createWorkspaceForAuthenticatedUser({ id: "7" }, { name })).value;
+  assert.equal(calls.listSlugsIn, 1);
+  return workspace.slug;
+}
+
+test("workspaceService chooses the first free slug of base, base-2 to base-1000 in one read", async () => {
+  assert.equal(await chooseWorkspaceSlug("Acme", []), "acme");
+  assert.equal(await chooseWorkspaceSlug("Acme", ["acme"]), "acme-2");
+  assert.equal(
+    await chooseWorkspaceSlug("Acme", ["acme", "acme-2", "acme-4", "acme-5"]),
+    "acme-3"
+  );
+  assert.equal(await chooseWorkspaceSlug("Acme", ["acme-2"]), "acme");
+
+  const longName = "a".repeat(60);
+  const trimmedBase = "a".repeat(48);
+  assert.equal(await chooseWorkspaceSlug(longName, []), trimmedBase);
+  assert.equal(await chooseWorkspaceSlug(longName, [trimmedBase]), `${trimmedBase}-2`);
+});
+
+test("workspaceService fails the same way when base to base-1000 are all taken", async () => {
+  const taken = ["acme", ...Array.from({ length: 999 }, (_, index) => `acme-${index + 2}`)];
+  await assert.rejects(chooseWorkspaceSlug("Acme", taken), /Unable to generate unique workspace slug\./);
+  assert.equal(await chooseWorkspaceSlug("Acme", taken.slice(0, -1)), "acme-1000");
+});
+
 test("workspaceService.createWorkspaceForAuthenticatedUser rejects creation when self-create policy is disabled", async () => {
   const { service } = createWorkspaceServiceFixture({
     tenancyMode: "workspaces"
@@ -650,6 +695,48 @@ test("workspaceService.resolveWorkspaceContextForUserBySlug resolves permissions
   assert.deepEqual(context.permissions, ["workspace.settings.update"]);
 });
 
+test("one request's auth policy and action context share one workspace context resolution", async () => {
+  const { service, calls } = createWorkspaceServiceFixture({
+    additionalWorkspaces: [{ id: "42", slug: "team-alpha", name: "Team Alpha", ownerUserId: "99", isPersonal: false, avatarUrl: "" }]
+  });
+  const resolvePolicy = createWorkspaceAuthPolicyContextResolver({ workspaceService: service, workspaceMembershipOptionalSurfaceIds: [] });
+  const contributor = createWorkspaceActionContextContributor({
+    workspaceService: service,
+    workspaceMembershipOptionalSurfaceIds: [],
+    workspaceSurfaceIds: ["admin"]
+  });
+  const user = { id: "7", email: "chiara@example.com", displayName: "Chiara" };
+  const handle = async () => {
+    const request = { user, params: { workspaceSlug: "team-alpha" } };
+    const policy = await resolvePolicy({ request, actor: user, meta: { permission: "workspace.settings.update" } });
+    const action = await contributor.contribute({
+      definition: { id: "workspace.settings.update", surfaces: ["admin"] },
+      input: { workspaceSlug: "Team-Alpha" },
+      context: { requestMeta: { request } }
+    });
+    return { policy, action };
+  };
+
+  const { policy, action } = await handle();
+  assert.equal(calls.findBySlug, 1, "The action context reuses the auth policy's resolution");
+  assert.equal(calls.ensureWorkspaceSettings, 1);
+  assert.equal(action.requestMeta.resolvedWorkspaceContext.workspace, policy.workspace);
+  assert.deepEqual(action.requestMeta.resolvedWorkspaceContext.workspaceSettings, { invitesEnabled: true });
+  assert.deepEqual(action.permissions, policy.permissions);
+
+  await handle();
+  assert.equal(calls.findBySlug, 2, "The next request resolves again");
+  await service.resolveWorkspaceContextForUserBySlug(user, "team-alpha");
+  await service.resolveWorkspaceContextForUserBySlug(user, "team-alpha");
+  assert.equal(calls.findBySlug, 4, "A call without a request resolves each time");
+  const request = {};
+  await service.resolveWorkspaceContextForUserBySlug(user, "team-alpha", { request });
+  await service.resolveWorkspaceContextForUserBySlug(user, "team-alpha", { request, requireMembership: false });
+  await service.resolveWorkspaceContextForUserBySlug({ ...user, id: "8" }, "team-alpha", { request });
+  await service.resolveWorkspaceContextForUserBySlug(user, "team-alpha", { request, trx: {} });
+  assert.equal(calls.findBySlug, 8, "Another membership requirement, user or a transaction resolves on its own");
+});
+
 test("workspaceService.getWorkspaceForAuthenticatedUser resolves workspace from slug context", async () => {
   const { service } = createWorkspaceServiceFixture({
     additionalWorkspaces: [

package/test/workspacesRepository.test.js

@@ -43,6 +43,7 @@ function createWorkspacesApiStub({
   insertError = null
 } = {}) {
   const state = {
+    queries: [],
     postPayload: null,
     patchPayload: null
   };
@@ -50,9 +51,16 @@ function createWorkspacesApiStub({
   const api = {
     resources: {
       workspaces: {
-        async query({ queryParams, format }) {
+        vars: { queryMaxLimit: 100 },
+        async query({ queryParams, transaction, format }) {
           assert.equal(format, "plain");
           const filters = queryParams?.filters || {};
+          state.queries.push({ filters, transaction });
+
+          if (Object.hasOwn(filters, "slugs")) {
+            const rows = filters.slugs.map((slug) => rowsBySlug.get(String(slug))).filter(Boolean);
+            return asCollectionDocument(rows.map((row) => toWorkspaceRow(row)));
+          }
 
           if (Object.hasOwn(filters, "id")) {
             const row = rowsById.get(String(filters.id)) || null;
@@ -179,6 +187,26 @@ test("workspacesRepository.findById reads a canonical workspace row through json
   });
 });
 
+test("workspacesRepository.listSlugsIn reads which slugs are taken in one query through the caller's transaction", async () => {
+  const trx = { trxId: "trx-slugs" };
+  const { api, state } = createWorkspacesApiStub({
+    rowsBySlug: new Map([
+      ["acme", { id: "7", slug: "acme", name: "Acme", ownerUserId: "9", isPersonal: false, avatarUrl: "" }],
+      ["acme-3", { id: "8", slug: "acme-3", name: "Acme 3", ownerUserId: "9", isPersonal: false, avatarUrl: "" }]
+    ])
+  });
+  const repository = createRepository({ api });
+
+  const taken = await repository.listSlugsIn([" ACME ", "acme-2", "acme-3", "acme"], { trx });
+
+  assert.deepEqual([...taken].sort(), ["acme", "acme-3"]);
+  assert.equal(state.queries.length, 1);
+  assert.deepEqual(state.queries[0].filters, { slugs: ["acme", "acme-2", "acme-3"] });
+  assert.equal(state.queries[0].transaction, trx);
+  assert.deepEqual([...await repository.listSlugsIn([])], []);
+  assert.equal(state.queries.length, 1);
+});
+
 test("workspacesRepository.findPersonalByOwnerUserId returns the first personal workspace by canonical id order", async () => {
   const { api } = createWorkspacesApiStub({
     personalRowsByOwnerId: new Map([