@jskit-ai/workspaces-core 0.2.3 → 0.2.5

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

@@ -1,12 +1,11 @@
 import {
-  normalizeLowerText,
-  normalizeRecordId,
+  isLostDuplicateInsertRace,
   normalizeDbRecordId,
-  normalizeText,
-  isDuplicateEntryError,
-  toIsoString,
-  retryDeadlocks
-} from "./repositoryUtils.js";
+  resolveTransaction,
+  retryDeadlocks,
+  toIsoString
+} from "@jskit-ai/database-runtime/shared";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
   extractJsonRestCollectionRows
@@ -29,20 +28,6 @@ function normalizeMembershipRecord(payload) {
   };
 }
 
-function normalizeMembershipPatchPayload(payload = {}) {
-  const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  const normalized = {};
-
-  if (Object.hasOwn(source, "roleSid")) {
-    normalized.roleSid = normalizeLowerText(source.roleSid);
-  }
-  if (Object.hasOwn(source, "status")) {
-    normalized.status = normalizeLowerText(source.status);
-  }
-
-  return normalized;
-}
-
 function normalizeMemberSummaryRow(row) {
   if (!row) {
     return null;
@@ -57,11 +42,8 @@ function normalizeMemberSummaryRow(row) {
   };
 }
 
-function createRepository({ api } = {}) {
-  if (!api?.resources?.workspaceMemberships) {
-    throw new TypeError("workspaceMembershipsRepository requires json-rest-api workspaceMemberships resource.");
-  }
-
+/** @param {{ api: import("@jskit-ai/json-rest-api-core/server/types").RuntimeJsonRestApi }} dependencies */
+function createRepository({ api }) {
   const withTransaction = (work) => retryDeadlocks(() => api.transaction(work));
 
   async function queryMemberships(filters = {}, options = {}, { include = [] } = {}) {
@@ -79,10 +61,10 @@ function createRepository({ api } = {}) {
             filters,
             ...(normalizedInclude.length > 0 ? { include: normalizedInclude } : {})
           },
-          transaction: options?.trx || null,
+          transaction: resolveTransaction(options),
           format: "plain"
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       )
     );
   }
@@ -127,9 +109,9 @@ function createRepository({ api } = {}) {
             },
             format: "plain",
             returning: "full",
-            transaction: options?.trx || null
+            transaction: resolveTransaction(options)
           },
-          createJsonRestContext(options?.context || null)
+          createJsonRestContext(options.context)
         );
       }
       return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
@@ -149,12 +131,12 @@ function createRepository({ api } = {}) {
           },
           format: "plain",
           returning: "full",
-          transaction: options?.trx || null
+          transaction: resolveTransaction(options)
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       );
     } catch (error) {
-      if (options?.trx || error?.transactionOutcome !== "rolledBack" || !isDuplicateEntryError(error)) {
+      if (!isLostDuplicateInsertRace(error, options)) {
         throw error;
       }
     }
@@ -162,7 +144,7 @@ function createRepository({ api } = {}) {
     return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
   }
 
-  async function upsertMembership(workspaceId, userId, patch = {}, options = {}) {
+  async function upsertMembership(workspaceId, userId, patch, options = {}) {
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedWorkspaceId || !normalizedUserId) {
@@ -170,12 +152,8 @@ function createRepository({ api } = {}) {
     }
 
     const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
-    const normalizedPatch = normalizeMembershipPatchPayload({
-      roleSid: patch?.roleSid ?? existing?.roleSid ?? "member",
-      status: patch?.status ?? existing?.status ?? "active"
-    });
-    const roleSid = normalizeLowerText(normalizedPatch.roleSid || "member") || "member";
-    const status = normalizeLowerText(normalizedPatch.status || "active") || "active";
+    const roleSid = normalizeLowerText(patch?.roleSid ?? existing?.roleSid) || "member";
+    const status = normalizeLowerText(patch?.status ?? existing?.status) || "active";
 
     if (!existing) {
       try {
@@ -192,12 +170,12 @@ function createRepository({ api } = {}) {
             },
             format: "plain",
             returning: "full",
-            transaction: options?.trx || null
+            transaction: resolveTransaction(options)
           },
-          createJsonRestContext(options?.context || null)
+          createJsonRestContext(options.context)
         );
       } catch (error) {
-        if (options?.trx || error?.transactionOutcome !== "rolledBack" || !isDuplicateEntryError(error)) {
+        if (!isLostDuplicateInsertRace(error, options)) {
           throw error;
         }
       }
@@ -215,9 +193,9 @@ function createRepository({ api } = {}) {
         },
         format: "plain",
         returning: "full",
-        transaction: options?.trx || null
+        transaction: resolveTransaction(options)
       },
-      createJsonRestContext(options?.context || null)
+      createJsonRestContext(options.context)
     );
 
     return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);

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

@@ -1,10 +1,5 @@
-import {
-  normalizeRecordId,
-  isDuplicateEntryError,
-  normalizeText,
-  toIsoString,
-  retryDeadlocks
-} from "./repositoryUtils.js";
+import { isLostDuplicateInsertRace, resolveTransaction, retryDeadlocks, toIsoString } from "@jskit-ai/database-runtime/shared";
+import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
   extractJsonRestCollectionRows
@@ -28,11 +23,8 @@ function normalizeWorkspaceRecord(payload = null) {
   };
 }
 
-function createRepository({ api } = {}) {
-  if (!api?.resources?.workspaces || !api?.resources?.workspaceMemberships) {
-    throw new TypeError("workspacesRepository requires json-rest-api workspaces and workspaceMemberships resources.");
-  }
-
+/** @param {{ api: import("@jskit-ai/json-rest-api-core/server/types").RuntimeJsonRestApi }} dependencies */
+function createRepository({ api }) {
   const withTransaction = (work) => retryDeadlocks(() => api.transaction(work));
 
   async function queryFirst(filters = {}, options = {}) {
@@ -42,10 +34,10 @@ function createRepository({ api } = {}) {
           queryParams: {
             filters
           },
-          transaction: options?.trx || null,
+          transaction: resolveTransaction(options),
           format: "plain"
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       )
     );
 
@@ -85,10 +77,10 @@ function createRepository({ api } = {}) {
               isPersonal: true
             }
           },
-          transaction: options?.trx || null,
+          transaction: resolveTransaction(options),
           format: "plain"
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       )
     );
 
@@ -104,7 +96,7 @@ function createRepository({ api } = {}) {
     return normalizedRows[0] || null;
   }
 
-  async function insert(payload = {}, options = {}) {
+  async function insert(payload, options = {}) {
     const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
     const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
     if (!ownerUserId) {
@@ -130,14 +122,14 @@ function createRepository({ api } = {}) {
           },
           format: "plain",
           returning: "full",
-          transaction: options?.trx || null
+          transaction: resolveTransaction(options)
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       );
 
       return normalizeWorkspaceRecord(created);
     } catch (error) {
-      if (options?.trx || error?.transactionOutcome !== "rolledBack" || !isDuplicateEntryError(error)) {
+      if (!isLostDuplicateInsertRace(error, options)) {
         throw error;
       }
       if (!Object.hasOwn(createPayload, "slug")) {
@@ -152,7 +144,7 @@ function createRepository({ api } = {}) {
     }
   }
 
-  async function updateById(workspaceId, patch = {}, options = {}) {
+  async function updateById(workspaceId, patch, options = {}) {
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
     if (!normalizedWorkspaceId) {
       return null;
@@ -174,9 +166,9 @@ function createRepository({ api } = {}) {
         data: workspacePatch,
         format: "plain",
         returning: "full",
-        transaction: options?.trx || null
+        transaction: resolveTransaction(options)
       },
-      createJsonRestContext(options?.context || null)
+      createJsonRestContext(options.context)
     );
 
     return normalizeWorkspaceRecord(updated);
@@ -198,10 +190,10 @@ function createRepository({ api } = {}) {
             },
             include: ["workspace"]
           },
-          transaction: options?.trx || null,
+          transaction: resolveTransaction(options),
           format: "plain"
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       )
     );
 

package/src/server/common/services/{workspaceContextService.js → workspaceDirectoryService.js}

@@ -1,18 +1,11 @@
-import { createHash } from "node:crypto";
+import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
+import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import {
-  TENANCY_MODE_NONE,
-  resolveTenancyProfile
-} from "../../../shared/tenancyProfile.js";
-import {
-  resolveRolePermissions,
-  createWorkspaceRoleCatalog
-} from "../../../shared/roles.js";
-import {
-  mapWorkspaceSummary
-} from "../formatters/workspaceFormatter.js";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { WORKSPACE_PATCH_FIELD_KEYS } from "../../../shared/resources/workspaceResource.js";
+import { listCatalogRolePermissions } from "../../../shared/roles.js";
+import { TENANCY_MODE_NONE } from "../../../shared/tenancyProfile.js";
+import { mapWorkspaceSummary } from "../formatters/workspaceFormatter.js";
 
 function toSlugPart(value) {
   const normalized = normalizeLowerText(value)
@@ -22,7 +15,7 @@ function toSlugPart(value) {
   return normalized || "workspace";
 }
 
-function buildWorkspaceBaseSlug(user = {}) {
+function buildWorkspaceBaseSlug(user) {
   const username = normalizeLowerText(user.username);
   if (username) {
     return toSlugPart(username);
@@ -38,7 +31,12 @@ function buildWorkspaceBaseSlug(user = {}) {
   return "workspace";
 }
 
-function buildWorkspaceName(user = {}) {
+/**
+ * The `workspaces.personal-workspace-name` default: the user's display name or
+ * email, followed by "'s Workspace".
+ * @type {import("../../types.js").PersonalWorkspaceName}
+ */
+function buildWorkspaceName(user) {
   const displayName = normalizeText(user.displayName);
   if (displayName) {
     return `${displayName}'s Workspace`;
@@ -50,42 +48,26 @@ function buildWorkspaceName(user = {}) {
   return "Workspace";
 }
 
-function buildPermissionsFromMembership(membership, appConfig = {}) {
-  const roleSid = normalizeLowerText(membership?.roleSid || "member");
-  return resolveRolePermissions(roleSid, appConfig);
-}
-
-function hashInviteToken(token) {
-  return createHash("sha256").update(normalizeText(token)).digest("hex");
-}
-
-function normalizeWorkspaceCreationInput(payload = {}) {
-  const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  return {
-    name: normalizeText(source.name),
-    requestedSlug: normalizeLowerText(source.slug)
-  };
-}
-
+/**
+ * @param {object} dependencies
+ * @param {import("../../types.js").WorkspaceTenancyProfile} dependencies.tenancyProfile
+ * @param {import("../../types.js").WorkspaceRoleCatalog} dependencies.roleCatalog
+ * @param {import("../../types.js").PersonalWorkspaceName} dependencies.personalWorkspaceName
+ * @param {import("../../types.js").WorkspacesRepository} dependencies.workspacesRepository
+ * @param {import("../../types.js").WorkspaceMembershipsRepository} dependencies.workspaceMembershipsRepository
+ * @param {import("../../types.js").WorkspaceSettingsRepository} dependencies.workspaceSettingsRepository
+ */
 function createService({
-  appConfig = {},
+  tenancyProfile,
+  roleCatalog,
+  personalWorkspaceName,
   workspacesRepository,
   workspaceMembershipsRepository,
   workspaceSettingsRepository
-} = {}) {
-  if (
-    !workspacesRepository ||
-    !workspaceMembershipsRepository ||
-    !workspaceSettingsRepository
-  ) {
-    throw new Error("workspaceService requires repositories.");
-  }
+}) {
+  const resolvedTenancyMode = tenancyProfile.mode;
+  const workspacePolicy = tenancyProfile.workspace;
 
-  const resolvedTenancyProfile = resolveTenancyProfile(appConfig);
-  const resolvedTenancyMode = resolvedTenancyProfile.mode;
-  const workspacePolicy = resolvedTenancyProfile.workspace;
-  const personalWorkspaceName =
-    typeof appConfig.personalWorkspaceName === "function" ? appConfig.personalWorkspaceName : null;
   async function ensureUniqueWorkspaceSlug(baseSlug, options = {}) {
     let suffix = 0;
     while (suffix < 1000) {
@@ -96,11 +78,11 @@ function createService({
         return candidate;
       }
     }
-    throw new AppError(500, "Unable to generate unique workspace slug.", { code: "workspaces.workspace.slugUnavailable" });
+    throw new Error("Unable to generate unique workspace slug.");
   }
 
   async function ensureWorkspaceSettingsForWorkspace(workspace, options = {}) {
-    return workspaceSettingsRepository.ensureForWorkspaceId(workspace?.id, {
+    return workspaceSettingsRepository.ensureForWorkspaceId(workspace.id, {
       ...options,
       workspace
     });
@@ -123,7 +105,7 @@ function createService({
     const inserted = await workspacesRepository.insert(
       {
         slug,
-        name: normalizeText(personalWorkspaceName?.(user)) || buildWorkspaceName(user),
+        name: normalizeText(personalWorkspaceName(user)) || buildWorkspaceName(user),
         ownerUserId: normalizedUserId,
         isPersonal: true,
         avatarUrl: ""
@@ -147,7 +129,6 @@ function createService({
     }
 
     const list = await workspacesRepository.listForUserId(normalizedUserId, options);
-    const roleCatalog = createWorkspaceRoleCatalog(appConfig);
     const accessible = list
       .map((entry) => mapWorkspaceSummary(
         entry,
@@ -160,7 +141,7 @@ function createService({
   }
 
   async function listWorkspacesForAuthenticatedUser(user, options = {}) {
-    return listWorkspacesForUser(user, options);
+    return returnJsonApiData({ items: await listWorkspacesForUser(user, options), nextCursor: null });
   }
 
   async function ensureProvisionedWorkspaceForAuthenticatedUser(user, options = {}) {
@@ -179,7 +160,14 @@ function createService({
     }, options);
   }
 
-  async function createWorkspaceForAuthenticatedUser(user, payload = {}, options = {}) {
+  /**
+   * Creates a workspace the user owns. The action's input schema has already
+   * trimmed the name and slug and lowercased the slug.
+   * @param {{ id?: unknown } | null} user
+   * @param {{ name: string, slug?: string }} input
+   * @param {object} [options]
+   */
+  async function createWorkspaceForAuthenticatedUser(user, { name, slug: requestedSlug }, options = {}) {
     const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
     if (!normalizedUserId) {
       throw new AppError(401, "Authentication required.", { code: "workspaces.auth.required" });
@@ -191,17 +179,11 @@ function createService({
       });
     }
 
-    const createInput = normalizeWorkspaceCreationInput(payload);
-    if (!createInput.name) {
-      throw new AppError(400, "Workspace name is required.", { code: "workspaces.workspace.nameRequired" });
-    }
-
-    const slugBase = createInput.requestedSlug || toSlugPart(createInput.name);
-    const slug = await ensureUniqueWorkspaceSlug(slugBase, options);
+    const slug = await ensureUniqueWorkspaceSlug(requestedSlug || toSlugPart(name), options);
     const inserted = await workspacesRepository.insert(
       {
         slug,
-        name: createInput.name,
+        name,
         ownerUserId: normalizedUserId,
         isPersonal: false,
         avatarUrl: ""
@@ -211,21 +193,23 @@ function createService({
 
     await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUserId, options);
     await ensureWorkspaceSettingsForWorkspace(inserted, options);
-    return inserted;
+    return returnJsonApiData(inserted);
   }
 
   async function getWorkspaceForAuthenticatedUser(user, workspaceSlug, options = {}) {
     const workspaceContext = await resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options);
-    return workspaceContext.workspace;
+    return returnJsonApiData(workspaceContext.workspace);
   }
 
-  async function updateWorkspaceForAuthenticatedUser(user, workspaceSlug, patch = {}, options = {}) {
+  /** The repository writes every field it receives, so only the patchable fields go to it. */
+  async function updateWorkspaceForAuthenticatedUser(user, workspaceSlug, input, options = {}) {
     const workspaceContext = await resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options);
-    return workspacesRepository.updateById(workspaceContext.workspace.id, patch, options);
+    const patch = pickOwnProperties(input, WORKSPACE_PATCH_FIELD_KEYS);
+    return returnJsonApiData(await workspacesRepository.updateById(workspaceContext.workspace.id, patch, options));
   }
 
   async function resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
-    const requireMembership = options?.requireMembership !== false;
+    const requireMembership = options.requireMembership !== false;
     const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
     if (!normalizedUserId) {
       throw new AppError(401, "Authentication required.", { code: "workspaces.auth.required" });
@@ -269,7 +253,7 @@ function createService({
     }
 
     const workspaceSettings = await ensureWorkspaceSettingsForWorkspace(workspace, options);
-    const permissions = membership ? buildPermissionsFromMembership(membership, appConfig) : [];
+    const permissions = membership ? listCatalogRolePermissions(roleCatalog, membership.roleSid) : [];
 
     return {
       workspace,
@@ -280,10 +264,6 @@ function createService({
   }
 
   return Object.freeze({
-    toSlugPart,
-    buildWorkspaceName,
-    buildWorkspaceBaseSlug,
-    hashInviteToken,
     ensurePersonalWorkspaceForUser,
     ensureProvisionedWorkspaceForAuthenticatedUser,
     createWorkspaceForAuthenticatedUser,
@@ -295,4 +275,4 @@ function createService({
   });
 }
 
-export { createService };
+export { buildWorkspaceName, createService };

package/src/server/common/support/realtimeServiceEvents.js

@@ -1,18 +1,16 @@
 import { normalizeDbRecordId } from "@jskit-ai/database-runtime/shared";
+import { jsonApiResultValue } from "@jskit-ai/http-runtime/shared";
 import { createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
+import { resolveActorId } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveWorkspace } from "../../support/resolveWorkspace.js";
 
-function resultValue({ result } = {}) {
-  return result?.value ?? result ?? {};
-}
-
-function actorId({ context } = {}) {
-  return context?.actor?.id;
+function actorId({ context }) {
+  return resolveActorId(context);
 }
 
 function workspaceId(execution = {}) {
-  return resolveWorkspace(execution.context, execution.input)?.id || resultValue(execution)?.workspaceId;
+  return resolveWorkspace(execution.context, execution.input)?.id || jsonApiResultValue(execution.result)?.workspaceId;
 }
 
 function workspaceSlugPayload(execution = {}) {
@@ -25,8 +23,8 @@ function workspaceSlugPayload(execution = {}) {
 
 const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
   preset: "event_scope",
-  async userQuery({ knex, event } = {}) {
-    if (typeof knex !== "function") return [];
+  /** @param {{ knex: import("@jskit-ai/database-runtime/server/types").RuntimeKnex, event: { entityId?: unknown } }} input */
+  async userQuery({ knex, event }) {
     const inviteId = normalizeRecordId(event?.entityId, { fallback: null });
     if (!inviteId) return [];
     const row = await knex("workspace_invites as wi")
@@ -38,13 +36,21 @@ const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
   }
 });
 
+/**
+ * @param {object} event
+ * @param {string} event.workspaceEntity
+ * @param {string} event.workspaceOperation
+ * @param {string} event.workspaceRealtimeEvent
+ * @param {typeof workspaceId} [event.bootstrapEntityId]
+ * @param {string} [event.bootstrapAudience]
+ */
 function createWorkspaceEntityAndBootstrapEvents({
   workspaceEntity,
   workspaceOperation,
   workspaceRealtimeEvent,
   bootstrapEntityId = workspaceId,
   bootstrapAudience = "event_scope"
-} = {}) {
+}) {
   return Object.freeze([
     createEntityChangedActionEvent({
       source: "workspace",
@@ -70,6 +76,7 @@ function createWorkspaceEntityAndBootstrapEvents({
   ]);
 }
 
+/** @param {{ source: string, entity: string, realtimeEvent: string }} event */
 function createActorEvent({ source, entity, realtimeEvent }) {
   return createEntityChangedActionEvent({
     source,
@@ -80,15 +87,16 @@ function createActorEvent({ source, entity, realtimeEvent }) {
   });
 }
 
+/** @param {{ entity: string, realtimeEvent: string }} event */
 function createWorkspaceAudienceEvent({ entity, realtimeEvent }) {
   return createEntityChangedActionEvent({
     source: "workspace",
     entity,
     operation: "updated",
-    entityId: ({ result }) => result?.value?.workspaceId ?? result?.workspaceId,
+    entityId: ({ result }) => jsonApiResultValue(result).workspaceId,
     realtime: {
       event: realtimeEvent,
-      audience: ({ result }) => ({ workspaceId: result?.value?.workspaceId ?? result?.workspaceId })
+      audience: ({ result }) => ({ workspaceId: jsonApiResultValue(result).workspaceId })
     }
   });
 }

package/src/server/common/support/workspaceRecordId.js

@@ -0,0 +1,21 @@
+/**
+ * The JSON:API record id of a workspace response: the workspace's id, or the
+ * route's workspace slug.
+ * @param {{ id?: unknown, workspace?: { id?: unknown } }} record
+ * @param {{ request?: { params?: { workspaceSlug?: unknown } } }} context
+ */
+function resolveWorkspaceRecordId(record, context = {}) {
+  const workspaceId = record?.workspace?.id ?? record?.id;
+  if (workspaceId != null && String(workspaceId).trim()) {
+    return workspaceId;
+  }
+
+  const workspaceSlug = context.request?.params?.workspaceSlug;
+  if (workspaceSlug != null && String(workspaceSlug).trim()) {
+    return workspaceSlug;
+  }
+
+  throw new Error("Workspace JSON:API response requires workspace id.");
+}
+
+export { resolveWorkspaceRecordId };

package/src/server/common/validators/routeParamsValidator.js

@@ -37,9 +37,10 @@ const routeParamsValidator = deepFreeze({
   mode: "patch"
 });
 
+// No mode: an action takes it as create, a route or a composition as patch; with
+// no required field and no default, both validate it the same.
 const workspaceSlugParamsValidator = deepFreeze({
-  schema: workspaceSlugParamsSchema,
-  mode: "patch"
+  schema: workspaceSlugParamsSchema
 });
 
 export { routeParamsValidator, workspaceSlugParamsValidator };

package/src/server/i18n.js

@@ -1,8 +1,11 @@
 import { createServerI18n } from "@jskit-ai/kernel/server/i18n";
 import en from "../../locales/en.json" with { type: "json" };
 
-// Workspace texts rendered on the server (invitation emails) in the recipient's
-// language, from the app's translations under appRoot, or English.
+/**
+ * Workspace texts rendered on the server (invitation emails) in the recipient's
+ * language, from the app's translations under appRoot, or English.
+ * @param {{ appRoot?: import("@jskit-ai/kernel/server/types").RuntimeAppRoot }} [options]
+ */
 function createWorkspacesServerI18n({ appRoot = "" } = {}) {
   return createServerI18n({ appRoot, catalogs: [en] });
 }

package/src/server/support/resolveWorkspace.js

@@ -1,16 +1,19 @@
+import { resolveRequest } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
 import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
 
-function resolveRequest(context = {}) {
-  const requestMeta = normalizeObject(context?.requestMeta);
-  return normalizeObject(requestMeta.request);
-}
-
+/**
+ * The workspace an action runs in: the input's workspace, else the context's,
+ * else the one the workspace context contributor resolved, else the request's.
+ * This is json-rest-api-core's resolveWorkspaceScopeValue order.
+ * @param {object} context
+ * @param {unknown} [input]
+ */
 function resolveWorkspace(context = {}, input = {}) {
   const payload = normalizeObject(input);
-  const requestMeta = normalizeObject(context?.requestMeta);
+  const requestMeta = normalizeObject(context.requestMeta);
   const resolvedWorkspaceContext = normalizeObject(requestMeta.resolvedWorkspaceContext);
 
-  return payload.workspace || resolvedWorkspaceContext.workspace || context?.workspace || resolveRequest(context)?.workspace || null;
+  return payload.workspace || context.workspace || resolvedWorkspaceContext.workspace || resolveRequest(context)?.workspace || null;
 }
 
 export { resolveWorkspace };