@jskit-ai/workspaces-core 0.1.31 → 0.1.32

package/src/server/workspaceMembers/workspaceMembersService.js

@@ -1,4 +1,5 @@
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 import { buildInviteToken, hashInviteToken } from "@jskit-ai/auth-core/server/inviteTokens";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { OWNER_ROLE_ID, createWorkspaceRoleCatalog, cloneWorkspaceRoleCatalog } from "../../shared/roles.js";
@@ -41,6 +42,41 @@ function createService({
     };
   }
 
+  function mapWorkspaceSummary(workspace = {}) {
+    return {
+      id: normalizeRecordId(workspace.id, { fallback: "" }),
+      slug: normalizeText(workspace.slug),
+      name: normalizeText(workspace.name),
+      ownerUserId: normalizeRecordId(workspace.ownerUserId, { fallback: "" }),
+      avatarUrl: normalizeText(workspace.avatarUrl)
+    };
+  }
+
+  function mapMemberSummary(member = {}, workspace = {}) {
+    const userId = normalizeRecordId(member.userId, { fallback: "" });
+    const roleSid = normalizeLowerText(member.roleSid || "member") || "member";
+
+    return {
+      userId,
+      roleSid,
+      status: normalizeLowerText(member.status || "active") || "active",
+      displayName: normalizeText(member.displayName),
+      email: normalizeLowerText(member.email),
+      isOwner: userId === normalizeRecordId(workspace.ownerUserId, { fallback: "" }) || roleSid === OWNER_ROLE_ID
+    };
+  }
+
+  function mapInviteSummary(invite = {}) {
+    return {
+      id: normalizeRecordId(invite.id, { fallback: "" }),
+      email: normalizeLowerText(invite.email),
+      roleSid: normalizeLowerText(invite.roleSid || "member") || "member",
+      status: normalizeLowerText(invite.status || "pending") || "pending",
+      expiresAt: invite.expiresAt || null,
+      invitedByUserId: invite.invitedByUserId == null ? null : normalizeRecordId(invite.invitedByUserId, { fallback: null })
+    };
+  }
+
   async function listRoles(options = {}) {
     return cloneWorkspaceRoleCatalog({
       ...resolvedRoleCatalog,
@@ -52,8 +88,8 @@ function createService({
     const members = await workspaceMembershipsRepository.listActiveByWorkspaceId(workspace.id, options);
 
     return withRoleCatalog({
-      workspace,
-      members
+      workspace: mapWorkspaceSummary(workspace),
+      members: members.map((member) => mapMemberSummary(member, workspace))
     });
   }
 
@@ -63,7 +99,7 @@ function createService({
 
   async function updateMemberRole(workspace, payload = {}, options = {}) {
     const memberUserId = normalizeRecordId(payload.memberUserId, { fallback: null });
-    const roleSid = payload.roleSid;
+    const roleSid = normalizeLowerText(payload.roleSid || "");
     if (!memberUserId) {
       throw new AppError(400, "Validation failed.");
     }
@@ -130,8 +166,8 @@ function createService({
     const invites = await workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace(workspace.id, options);
 
     return withRoleCatalog({
-      workspace,
-      invites
+      workspace: mapWorkspaceSummary(workspace),
+      invites: invites.map((invite) => mapInviteSummary(invite))
     });
   }
 
@@ -140,8 +176,8 @@ function createService({
   }
 
   async function createInvite(workspace, user, payload = {}, options = {}) {
-    const email = payload.email;
-    const roleSid = payload.roleSid;
+    const email = normalizeLowerText(payload.email);
+    const roleSid = normalizeLowerText(payload.roleSid || "member") || "member";
     if (!assignableRoleIds.includes(roleSid)) {
       throw new AppError(400, "Validation failed.", {
         details: {

package/src/server/workspacePendingInvitations/bootWorkspacePendingInvitations.js

@@ -1,6 +1,19 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
 import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
 import { workspacePendingInvitationsResource } from "../../shared/resources/workspacePendingInvitationsResource.js";
+import {
+  WORKSPACE_INVITE_REDEEM_TRANSPORT,
+  WORKSPACE_PENDING_INVITATIONS_TRANSPORT
+} from "../../shared/jsonApiTransports.js";
+
+function resolveAuthenticatedUserRecordId(_record, context = {}) {
+  const userId = context?.request?.user?.id;
+  if (userId != null && String(userId).trim()) {
+    return userId;
+  }
+
+  throw new Error("JSON:API response requires request.user.id.");
+}
 
 function bootWorkspacePendingInvitations(app) {
   if (!app || typeof app.make !== "function") {
@@ -18,8 +31,11 @@ function bootWorkspacePendingInvitations(app) {
         tags: ["workspace"],
         summary: "List pending workspace invitations for authenticated user"
       },
-      responseValidators: withStandardErrorResponses({
-        200: workspacePendingInvitationsResource.operations.list.outputValidator
+      ...createJsonApiResourceRouteContract({
+        ...WORKSPACE_PENDING_INVITATIONS_TRANSPORT,
+        output: workspacePendingInvitationsResource.operations.list.output,
+        outputKind: "record",
+        getRecordId: resolveAuthenticatedUserRecordId
       })
     },
     async function (request, reply) {
@@ -39,20 +55,19 @@ function bootWorkspacePendingInvitations(app) {
         tags: ["workspace"],
         summary: "Accept or refuse a workspace invitation using an invite token"
       },
-      bodyValidator: workspaceMembersResource.operations.redeemInvite.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: workspaceMembersResource.operations.redeemInvite.outputValidator
-        },
-        { includeValidation400: true }
-      )
+      ...createJsonApiResourceRouteContract({
+        ...WORKSPACE_INVITE_REDEEM_TRANSPORT,
+        body: workspaceMembersResource.operations.redeemInvite.body,
+        output: workspaceMembersResource.operations.redeemInvite.output,
+        outputKind: "record",
+        getRecordId: resolveAuthenticatedUserRecordId,
+        includeValidation400: true
+      })
     },
     async function (request, reply) {
       const response = await request.executeAction({
         actionId: "workspace.invite.redeem",
-        input: {
-          payload: request.input.body
-        }
+        input: request.input.body
       });
       reply.code(200).send(response);
     }

package/src/server/workspacePendingInvitations/workspacePendingInvitationsActions.js

@@ -1,8 +1,8 @@
 import {
-  EMPTY_INPUT_VALIDATOR
+  emptyInputValidator
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
-import { workspacePendingInvitationsResource } from "../../shared/resources/workspacePendingInvitationsResource.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
 
 const workspacePendingInvitationsActions = Object.freeze([
@@ -15,19 +15,19 @@ const workspacePendingInvitationsActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: EMPTY_INPUT_VALIDATOR,
-    outputValidator: workspacePendingInvitationsResource.operations.list.outputValidator,
+    input: emptyInputValidator,
+    output: null,
     idempotency: "none",
     audit: {
       actionName: "workspace.invitations.pending.list"
     },
     observability: {},
     async execute(input, context, deps) {
-      return {
+      return returnJsonApiData({
         pendingInvites: await deps.workspacePendingInvitationsService.listPendingInvitesForUser(resolveActionUser(context, input), {
           context
         })
-      };
+      });
     }
   },
   {
@@ -39,34 +39,32 @@ const workspacePendingInvitationsActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: {
-      payload: workspaceMembersResource.operations.redeemInvite.bodyValidator
-    },
-    outputValidator: workspaceMembersResource.operations.redeemInvite.outputValidator,
+    input: workspaceMembersResource.operations.redeemInvite.body,
+    output: null,
     idempotency: "optional",
     audit: {
       actionName: "workspace.invite.redeem"
     },
     observability: {},
     async execute(input, context, deps) {
-      const payload = input.payload || {};
+      const payload = input || {};
       const user = resolveActionUser(context, input);
 
       if (payload.decision === "accept") {
-        return deps.workspacePendingInvitationsService.acceptInviteByToken({
+        return returnJsonApiData(await deps.workspacePendingInvitationsService.acceptInviteByToken({
           user,
           token: payload.token
         }, {
           context
-        });
+        }));
       }
 
-      return deps.workspacePendingInvitationsService.refuseInviteByToken({
+      return returnJsonApiData(await deps.workspacePendingInvitationsService.refuseInviteByToken({
         user,
         token: payload.token
       }, {
         context
-      });
+      }));
     }
   }
 ]);

package/src/server/workspacePendingInvitations/workspacePendingInvitationsService.js

@@ -1,8 +1,8 @@
 import { resolveInviteTokenHash } from "@jskit-ai/auth-core/server/inviteTokens";
+import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { authenticatedUserValidator } from "../common/validators/authenticatedUserValidator.js";
 
 function createService({
   workspaceInvitesRepository,
@@ -13,12 +13,11 @@ function createService({
   }
 
   function requireAuthenticatedInviteUser(user) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+    if (!normalizeRecordId(user?.id, { fallback: null })) {
       throw new AppError(401, "Authentication required.");
     }
 
-    return normalizedUser;
+    return user;
   }
 
   function requireInviteTokenHash(token) {
@@ -35,8 +34,30 @@ function createService({
     return tokenHash;
   }
 
+  function mapPendingInvite(invite = {}) {
+    const id = normalizeRecordId(invite.id, { fallback: null });
+    const workspaceId = normalizeRecordId(invite.workspaceId, { fallback: null });
+    const tokenHash = normalizeText(invite.tokenHash);
+
+    if (!id || !workspaceId || !tokenHash) {
+      return null;
+    }
+
+    return {
+      id,
+      workspaceId,
+      workspaceSlug: normalizeText(invite.workspaceSlug),
+      workspaceName: normalizeText(invite.workspaceName || invite.workspaceSlug),
+      workspaceAvatarUrl: normalizeText(invite.workspaceAvatarUrl),
+      roleSid: normalizeLowerText(invite.roleSid || "member") || "member",
+      status: normalizeLowerText(invite.status || "pending") || "pending",
+      expiresAt: invite.expiresAt || null,
+      token: encodeInviteTokenHash(tokenHash)
+    };
+  }
+
   async function requirePendingInviteForUserByToken(user, token, options = {}) {
-    const normalizedUser = requireAuthenticatedInviteUser(user);
+    const actor = requireAuthenticatedInviteUser(user);
     const tokenHash = requireInviteTokenHash(token);
 
     const invite = await workspaceInvitesRepository.findPendingByTokenHash(tokenHash, options);
@@ -44,12 +65,12 @@ function createService({
       throw new AppError(404, "Invitation not found or already handled.");
     }
 
-    if (normalizeLowerText(invite.email) !== normalizedUser.email) {
+    if (normalizeLowerText(invite.email) !== normalizeLowerText(actor?.email)) {
       throw new AppError(403, "Invitation email does not match authenticated user.");
     }
 
     return {
-      user: normalizedUser,
+      user: actor,
       invite
     };
   }
@@ -62,12 +83,14 @@ function createService({
   }
 
   async function listPendingInvitesForUser(user, options = {}) {
-    const normalizedUser = requireAuthenticatedInviteUser(user);
-    if (!normalizedUser.email) {
+    const actor = requireAuthenticatedInviteUser(user);
+    const actorEmail = normalizeLowerText(actor?.email);
+    if (!actorEmail) {
       return [];
     }
 
-    return workspaceInvitesRepository.listPendingByEmail(normalizedUser.email, options);
+    const invites = await workspaceInvitesRepository.listPendingByEmail(actorEmail, options);
+    return invites.map((invite) => mapPendingInvite(invite)).filter(Boolean);
   }
 
   function requireWorkspaceIdFromInvite(invite, methodName = "workspacePendingInvitationsService") {

package/src/server/workspaceSettings/bootWorkspaceSettings.js

@@ -1,9 +1,24 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
+import { WORKSPACE_SETTINGS_TRANSPORT } from "../../shared/jsonApiTransports.js";
 import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
 import { resolveWorkspaceRoutePath } from "../common/support/workspaceRoutePaths.js";
 import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
 import { resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig } from "../support/workspaceActionSurfaces.js";
 
+function resolveWorkspaceSettingsRecordId(record = {}, context = {}) {
+  const workspaceId = record?.workspace?.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 settings JSON:API response requires workspace id.");
+}
+
 function bootWorkspaceSettings(app) {
   if (!app || typeof app.make !== "function") {
     throw new Error("bootWorkspaceSettings requires application make().");
@@ -24,9 +39,12 @@ function bootWorkspaceSettings(app) {
         tags: ["workspace"],
         summary: "Get workspace settings and role catalog by workspace slug"
       },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: workspaceSettingsResource.operations.view.outputValidator
+      params: workspaceSlugParamsValidator,
+      ...createJsonApiResourceRouteContract({
+        ...WORKSPACE_SETTINGS_TRANSPORT,
+        output: workspaceSettingsResource.operations.view.output,
+        outputKind: "record",
+        getRecordId: resolveWorkspaceSettingsRecordId
       })
     },
     async function (request, reply) {
@@ -51,21 +69,22 @@ function bootWorkspaceSettings(app) {
         tags: ["workspace"],
         summary: "Update workspace settings by workspace slug"
       },
-      paramsValidator: workspaceSlugParamsValidator,
-      bodyValidator: workspaceSettingsResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: workspaceSettingsResource.operations.patch.outputValidator
-        },
-        { includeValidation400: true }
-      )
+      params: workspaceSlugParamsValidator,
+      ...createJsonApiResourceRouteContract({
+        ...WORKSPACE_SETTINGS_TRANSPORT,
+        body: workspaceSettingsResource.operations.patch.body,
+        output: workspaceSettingsResource.operations.patch.output,
+        outputKind: "record",
+        getRecordId: resolveWorkspaceSettingsRecordId,
+        includeValidation400: true
+      })
     },
     async function (request, reply) {
       const response = await request.executeAction({
         actionId: "workspace.settings.update",
         input: {
           workspaceSlug: request.input.params.workspaceSlug,
-          patch: request.input.body
+          ...(request.input.body || {})
         }
       });
       reply.code(200).send(response);

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -1,5 +1,6 @@
 import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
 import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { INTERNAL_JSON_REST_API } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { deepFreeze } from "../common/support/deepFreeze.js";
 import { createRepository as createWorkspaceSettingsRepository } from "./workspaceSettingsRepository.js";
 import { createService as createWorkspaceSettingsService } from "./workspaceSettingsService.js";
@@ -23,9 +24,12 @@ function registerWorkspaceSettings(app) {
   }
 
   app.singleton("internal.repository.workspace-settings", (scope) => {
+    const api = scope.make(INTERNAL_JSON_REST_API);
     const knex = scope.make("jskit.database.knex");
     const appConfig = resolveAppConfig(scope);
-    return createWorkspaceSettingsRepository(knex, {
+    return createWorkspaceSettingsRepository({
+      api,
+      knex,
       defaultInvitesEnabled: resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig)
     });
   });

package/src/server/workspaceSettings/workspaceSettingsActions.js

@@ -1,7 +1,17 @@
+import { composeSchemaDefinitions } from "@jskit-ai/kernel/shared/validators";
+import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
 import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
 import { resolveWorkspace } from "../support/resolveWorkspace.js";
 
+const workspaceSettingsUpdateInputValidator = composeSchemaDefinitions([
+  workspaceSlugParamsValidator,
+  workspaceSettingsResource.operations.patch.body
+], {
+  mode: "patch",
+  context: "workspaceSettingsActions.workspaceSettingsUpdateInputValidator"
+});
+
 const workspaceSettingsActions = Object.freeze([
   {
     id: "workspace.settings.read",
@@ -13,8 +23,8 @@ const workspaceSettingsActions = Object.freeze([
       require: "any",
       permissions: ["workspace.settings.view", "workspace.settings.update"]
     },
-    inputValidator: workspaceSlugParamsValidator,
-    outputValidator: workspaceSettingsResource.operations.view.outputValidator,
+    input: workspaceSlugParamsValidator,
+    output: null,
     idempotency: "none",
     audit: {
       actionName: "workspace.settings.read"
@@ -25,7 +35,7 @@ const workspaceSettingsActions = Object.freeze([
         context
       });
 
-      return response;
+      return returnJsonApiData(response);
     }
   },
   {
@@ -38,13 +48,8 @@ const workspaceSettingsActions = Object.freeze([
       require: "all",
       permissions: ["workspace.settings.update"]
     },
-    inputValidator: [
-      workspaceSlugParamsValidator,
-      {
-        patch: workspaceSettingsResource.operations.patch.bodyValidator
-      }
-    ],
-    outputValidator: workspaceSettingsResource.operations.patch.outputValidator,
+    input: workspaceSettingsUpdateInputValidator,
+    output: null,
     idempotency: "optional",
     audit: {
       actionName: "workspace.settings.update"
@@ -56,15 +61,16 @@ const workspaceSettingsActions = Object.freeze([
       }
     },
     async execute(input, context, deps) {
+      const { workspaceSlug, ...patch } = input;
       const response = await deps.workspaceSettingsService.updateWorkspaceSettings(
         resolveWorkspace(context, input),
-        input.patch,
+        patch,
         {
           context
         }
       );
 
-      return response;
+      return returnJsonApiData(response);
     }
   }
 ]);