@jskit-ai/workspaces-core 0.1.30 → 0.1.32

package/test/usersRouteResources.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
-import "../test-support/registerDefaultSettingsFields.js";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
 import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
 import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
@@ -28,15 +28,18 @@ function assertResourceShape(resource, label) {
       `${label}.operations.${operationName} must resolve messages from operation.messages or resource.messages.`
     );
     assert.equal(
-      typeof operation.outputValidator?.schema,
+      typeof resolveStructuredSchemaTransportSchema(operation.output, {
+        context: `${label}.operations.${operationName}.output`,
+        defaultMode: "replace"
+      }),
       "object",
       `${label}.operations.${operationName} payload schema is required.`
     );
   }
 
-  assert.equal(typeof resource.operations.create.bodyValidator?.schema, "object", `${label}.operations.create.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.replace.bodyValidator?.schema, "object", `${label}.operations.replace.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.patch.bodyValidator?.schema, "object", `${label}.operations.patch.bodyValidator.schema is required.`);
+  assert.equal(typeof resource.operations.create.body?.schema, "object", `${label}.operations.create.body.schema is required.`);
+  assert.equal(typeof resource.operations.replace.body?.schema, "object", `${label}.operations.replace.body.schema is required.`);
+  assert.equal(typeof resource.operations.patch.body?.schema, "object", `${label}.operations.patch.body.schema is required.`);
 
   const requiredMetadata = deriveResourceRequiredMetadata(resource);
   assert.ok(Array.isArray(requiredMetadata.create), `${label}.derivedRequired.create must be an array.`);
@@ -69,15 +72,22 @@ test("workspace settings and invite operations expose canonical validators", ()
 
   for (const { label, operation } of operationSpecs) {
     assert.equal(typeof operation?.method, "string", `${label}.method must exist.`);
-    assert.equal(typeof operation?.outputValidator?.schema, "object", `${label}.outputValidator.schema must exist.`);
-    if (operation?.bodyValidator) {
-      assert.equal(typeof operation.bodyValidator.schema, "object", `${label}.bodyValidator.schema must exist.`);
+    assert.equal(
+      typeof resolveStructuredSchemaTransportSchema(operation?.output, {
+        context: `${label}.output`,
+        defaultMode: "replace"
+      }),
+      "object",
+      `${label}.output transport schema must exist.`
+    );
+    if (operation?.body) {
+      assert.equal(typeof operation.body.schema, "object", `${label}.body.schema must exist.`);
     }
-    if (operation?.paramsValidator) {
-      assert.equal(typeof operation.paramsValidator.schema, "object", `${label}.paramsValidator.schema must exist.`);
+    if (operation?.params) {
+      assert.equal(typeof operation.params.schema, "object", `${label}.params.schema must exist.`);
     }
-    if (operation?.queryValidator) {
-      assert.equal(typeof operation.queryValidator.schema, "object", `${label}.queryValidator.schema must exist.`);
+    if (operation?.query) {
+      assert.equal(typeof operation.query.schema, "object", `${label}.query.schema must exist.`);
     }
   }
 });
@@ -85,13 +95,13 @@ test("workspace settings and invite operations expose canonical validators", ()
 test("workspaces-core no longer uses a workspace schema helper that exposes raw schema leaves", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacyWorkspaceRoutesFile = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
-  assert.equal(existsSync(legacyWorkspaceRoutesFile), false, "workspaceRoutes.js must not exist.");
+  const workspaceRoutesFilePath = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
+  assert.equal(existsSync(workspaceRoutesFilePath), false, "workspaceRoutes.js must not exist.");
 });
 
-test("workspaces-core route validators no longer live under a legacy shared/schema directory", () => {
+test("workspaces-core route validators do not live under src/shared/schema", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
-  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+  const sharedSchemaDirPath = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(sharedSchemaDirPath), false, "src/shared/schema must not exist.");
 });

package/test/workspaceActionContextContributor.test.js

@@ -181,7 +181,7 @@ test("workspace action context contributor always resolves and stores resolved c
   });
 });
 
-test("workspace action context contributor resolves context for workspace-visible routes outside legacy action list", async () => {
+test("workspace action context contributor resolves context for workspace-visible routes without an explicit action list", async () => {
   const calls = [];
   const contributor = createWorkspaceActionContextContributor({
     workspaceService: {

package/test/workspaceInternalCrudResources.test.js

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
+import { workspaceInvitesResource } from "../src/shared/resources/workspaceInvitesResource.js";
+import { workspaceMembershipsResource } from "../src/shared/resources/workspaceMembershipsResource.js";
+
+function parseBody(operation, payload = {}) {
+  return validateOperationSection({
+    operation,
+    section: "body",
+    value: payload
+  });
+}
+
+test("workspace internal CRUD resources expose canonical derived operation sets", () => {
+  const resources = {
+    workspaceMemberships: workspaceMembershipsResource,
+    workspaceInvites: workspaceInvitesResource
+  };
+
+  for (const [label, resource] of Object.entries(resources)) {
+    assert.deepEqual(Object.keys(resource.operations), ["list", "view", "create", "patch"]);
+    assert.equal(typeof resource.operations.create.body?.schema, "object", `${label}.operations.create.body.schema is required.`);
+    assert.equal(typeof resource.operations.patch.body?.schema, "object", `${label}.operations.patch.body.schema is required.`);
+    assert.equal(
+      typeof resolveStructuredSchemaTransportSchema(resource.operations.view.output, {
+        context: `${label}.operations.view.output`,
+        defaultMode: "replace"
+      }),
+      "object",
+      `${label}.operations.view.output transport schema is required.`
+    );
+  }
+});
+
+test("workspace memberships derived bodies accept normalized internal writes", async () => {
+  const create = await parseBody(workspaceMembershipsResource.operations.create, {
+    workspaceId: "7",
+    userId: "9",
+    roleSid: "OWNER",
+    status: "ACTIVE",
+    createdAt: "2026-05-02T10:11:12.000Z",
+    updatedAt: "2026-05-02T10:11:12.000Z"
+  });
+  assert.equal(create.ok, true);
+  assert.equal(String(create.value.workspaceId), "7");
+  assert.equal(String(create.value.userId), "9");
+  assert.equal(create.value.roleSid, "OWNER");
+  assert.equal(create.value.status, "ACTIVE");
+  assert.equal(typeof create.value.createdAt, "object");
+  assert.equal(typeof create.value.updatedAt, "object");
+
+  const patch = await parseBody(workspaceMembershipsResource.operations.patch, {
+    roleSid: "ADMIN",
+    status: "ACTIVE",
+    updatedAt: "2026-05-02T10:11:12.000Z"
+  });
+  assert.equal(patch.ok, true);
+  assert.equal(patch.value.roleSid, "ADMIN");
+  assert.equal(patch.value.status, "ACTIVE");
+  assert.equal(typeof patch.value.updatedAt, "object");
+});
+
+test("workspace invites derived bodies keep lifecycle fields available for internal writes", async () => {
+  const create = await parseBody(workspaceInvitesResource.operations.create, {
+    workspaceId: "7",
+    email: "Invitee@Example.com",
+    roleSid: "ADMIN",
+    status: "PENDING",
+    tokenHash: "  invite-token-hash  ",
+    invitedByUserId: "9",
+    expiresAt: "2026-05-10T00:00:00.000Z",
+    acceptedAt: null,
+    revokedAt: null,
+    createdAt: "2026-05-02T10:11:12.000Z",
+    updatedAt: "2026-05-02T10:11:12.000Z"
+  });
+  assert.equal(create.ok, true);
+  assert.equal(String(create.value.workspaceId), "7");
+  assert.equal(create.value.email, "Invitee@Example.com");
+  assert.equal(create.value.roleSid, "ADMIN");
+  assert.equal(create.value.status, "PENDING");
+  assert.equal(create.value.tokenHash, "invite-token-hash");
+  assert.equal(String(create.value.invitedByUserId), "9");
+  assert.equal(typeof create.value.createdAt, "object");
+  assert.equal(typeof create.value.updatedAt, "object");
+
+  const patch = await parseBody(workspaceInvitesResource.operations.patch, {
+    status: "ACCEPTED",
+    acceptedAt: "2026-05-11T00:00:00.000Z",
+    updatedAt: "2026-05-11T00:00:00.000Z"
+  });
+  assert.equal(patch.ok, true);
+  assert.equal(patch.value.status, "ACCEPTED");
+  assert.equal(typeof patch.value.acceptedAt, "object");
+  assert.equal(typeof patch.value.updatedAt, "object");
+});

package/test/workspaceInvitesRepository.test.js

@@ -1,90 +1,151 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
+import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
 
-function createKnexStub({
-  rowById = new Map(),
-  pendingRow = null,
-  joinedRows = []
+function createKnexStub() {
+  const knex = Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+
+  return knex;
+}
+
+function toWorkspaceInviteResource(row = {}, { includeWorkspace = false } = {}) {
+  return {
+    type: "workspaceInvites",
+    id: String(row.id || ""),
+    attributes: {
+      email: row.email,
+      roleSid: row.roleSid,
+      status: row.status,
+      tokenHash: row.tokenHash,
+      expiresAt: row.expiresAt,
+      acceptedAt: row.acceptedAt,
+      revokedAt: row.revokedAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    },
+    relationships: {
+      workspace: {
+        data: row?.workspace?.id == null
+          ? null
+          : {
+              type: "workspaces",
+              id: String(row.workspace.id)
+            }
+      },
+      invitedByUser: {
+        data: row?.invitedByUser?.id == null ? null : { type: "userProfiles", id: String(row.invitedByUser.id) }
+      }
+    }
+  };
+}
+
+function createWorkspaceInvitesApiStub({
+  rows = [],
+  rowById = new Map()
 } = {}) {
   const state = {
-    insertPayload: null,
-    updatePayload: null
+    postPayload: null,
+    patchPayloads: []
   };
 
-  const defaultRow = pendingRow || {
-    id: 1,
-    workspace_id: 1,
-    email: "invitee@example.com",
-    role_sid: "member",
-    status: "pending",
-    token_hash: "hash",
-    invited_by_user_id: 1,
-    expires_at: "2026-03-16 00:26:35.709",
-    accepted_at: null,
-    revoked_at: null,
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710"
-  };
+  const api = {
+    resources: {
+      workspaceInvites: {
+        async query({ queryParams }) {
+          const filters = queryParams?.filters || {};
+          const includeWorkspace = Array.isArray(queryParams?.include) && queryParams.include.includes("workspace");
+          const matching = rows.filter((row) => {
+            if (Object.hasOwn(filters, "id") && String(row.id) !== String(filters.id)) {
+              return false;
+            }
+            if (Object.hasOwn(filters, "workspace") && String(row?.workspace?.id || "") !== String(filters.workspace)) {
+              return false;
+            }
+            if (Object.hasOwn(filters, "email") && String(row.email || "") !== String(filters.email)) {
+              return false;
+            }
+            if (Object.hasOwn(filters, "status") && String(row.status || "") !== String(filters.status)) {
+              return false;
+            }
+            if (Object.hasOwn(filters, "tokenHash") && String(row.tokenHash || "") !== String(filters.tokenHash)) {
+              return false;
+            }
+            return true;
+          });
 
-  function tableBuilder(tableName) {
-    if (tableName === "workspace_invites as wi") {
-      return {
-        join() {
-          return this;
+          return {
+            data: matching.map((row) => toWorkspaceInviteResource(row, { includeWorkspace })),
+            included: includeWorkspace
+              ? matching
+                  .filter((row) => row?.workspace?.id != null)
+                  .map((row) => ({
+                    type: "workspaces",
+                    id: String(row.workspace.id),
+                    attributes: {
+                      slug: row.workspace.slug,
+                      name: row.workspace.name,
+                      avatarUrl: row.workspace.avatarUrl
+                    }
+                  }))
+              : []
+          };
         },
-        where() {
-          return this;
+        async post(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.postPayload = inputRecord;
+          const row = {
+            id: "1",
+            workspace: { id: String(inputRecord.relationships?.workspace?.data?.id || "") },
+            email: inputRecord.attributes?.email,
+            roleSid: inputRecord.attributes?.roleSid,
+            status: inputRecord.attributes?.status,
+            tokenHash: inputRecord.attributes?.tokenHash,
+            invitedByUser: inputRecord.relationships?.invitedByUser?.data
+              ? { id: String(inputRecord.relationships.invitedByUser.data.id) }
+              : null,
+            expiresAt: inputRecord.attributes?.expiresAt,
+            acceptedAt: inputRecord.attributes?.acceptedAt,
+            revokedAt: inputRecord.attributes?.revokedAt,
+            createdAt: "2026-03-09 00:26:35.710",
+            updatedAt: "2026-03-09 00:26:35.710"
+          };
+          rows.push(row);
+          rowById.set("1", row);
+          return { data: toWorkspaceInviteResource(row) };
         },
-        orderBy() {
-          return this;
-        },
-        select() {
-          return Promise.resolve([...joinedRows]);
+        async patch(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.patchPayloads.push(inputRecord);
+          const existing = rowById.get(String(inputRecord.id));
+          if (existing) {
+            const updated = {
+              ...existing,
+              ...(inputRecord.attributes || {})
+            };
+            rowById.set(String(inputRecord.id), updated);
+          }
+          const updatedRow = rowById.get(String(inputRecord.id)) || null;
+          return updatedRow ? { data: toWorkspaceInviteResource(updatedRow) } : null;
         }
-      };
-    }
-
-    assert.equal(tableName, "workspace_invites");
-    const query = {
-      criteriaList: [],
-      select() {
-        return this;
-      },
-      insert(payload) {
-        state.insertPayload = payload;
-        return Promise.resolve([1]);
-      },
-      where(criteria) {
-        this.criteriaList.push(criteria);
-        return this;
-      },
-      orderBy() {
-        return this;
-      },
-      update(payload) {
-        state.updatePayload = payload;
-        return Promise.resolve(1);
-      },
-      first() {
-        const criteria = Object.assign({}, ...this.criteriaList);
-        if (Object.hasOwn(criteria, "id")) {
-          return Promise.resolve(rowById.get(String(criteria.id)) || null);
-        }
-        return Promise.resolve({ ...defaultRow });
       }
-    };
-
-    return query;
-  }
+    }
+  };
 
-  return { knexStub: tableBuilder, state };
+  return { api, state };
 }
 
-test("workspaceInvitesRepository.insert normalizes expiresAt ISO input to database datetime", async () => {
-  const { knexStub, state } = createKnexStub();
-  const repository = createRepository(knexStub);
+test("workspaceInvitesRepository.insert preserves expiresAt and relationship fields through the resource write path", async () => {
+  const { api, state } = createWorkspaceInvitesApiStub();
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   await repository.insert({
     workspaceId: "1",
@@ -96,107 +157,94 @@ test("workspaceInvitesRepository.insert normalizes expiresAt ISO input to databa
     expiresAt: "2026-03-16T00:26:35.709Z"
   });
 
-  assert.equal(state.insertPayload.expires_at, toNullableDateTime("2026-03-16T00:26:35.709Z"));
+  assert.equal(state.postPayload.relationships?.workspace?.data?.id, "1");
+  assert.equal(state.postPayload.attributes?.email, "invitee@example.com");
+  assert.equal(state.postPayload.relationships?.invitedByUser?.data?.id, "1");
+  assert.equal(state.postPayload.attributes?.tokenHash, "hash");
+  assert.equal(typeof state.postPayload.attributes?.expiresAt, "string");
 });
 
-test("workspaceInvitesRepository.findPendingByTokenHash reads from invites table without workspace join", async () => {
-  const calls = {
-    tableName: "",
-    whereCriteria: null
-  };
-  const row = {
-    id: 44,
-    workspace_id: 9,
-    email: "invitee@example.com",
-    role_sid: "member",
-    status: "pending",
-    token_hash: "hash-token",
-    invited_by_user_id: 1,
-    expires_at: "2030-01-01 00:00:00.000",
-    accepted_at: null,
-    revoked_at: null,
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710"
-  };
-
-  const repository = createRepository((tableName) => {
-    calls.tableName = String(tableName || "");
-    return {
-      select() {
-        return this;
-      },
-      where(criteria) {
-        calls.whereCriteria = criteria;
-        return this;
-      },
-      first() {
-        return Promise.resolve({ ...row });
+test("workspaceInvitesRepository.findPendingByTokenHash reads from the canonical invite resource without workspace data", async () => {
+  const { api } = createWorkspaceInvitesApiStub({
+    rows: [
+      {
+        id: "44",
+        workspace: { id: "9" },
+        email: "invitee@example.com",
+        roleSid: "member",
+        status: "pending",
+        tokenHash: "hash-token",
+        invitedByUser: { id: "1" },
+        expiresAt: "2030-01-01 00:00:00.000",
+        acceptedAt: null,
+        revokedAt: null,
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-09 00:26:35.710"
       }
-    };
+    ]
   });
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const invite = await repository.findPendingByTokenHash("hash-token");
-  assert.equal(calls.tableName, "workspace_invites");
-  assert.deepEqual(calls.whereCriteria, {
-    token_hash: "hash-token",
-    status: "pending"
-  });
+
   assert.equal(invite?.workspaceId, "9");
   assert.equal(invite?.workspaceSlug, undefined);
 });
 
 test("workspaceInvitesRepository.markAcceptedById uses the internal invite resource for normalized patch writes", async () => {
-  const acceptedRow = {
-    id: 1,
-    workspace_id: 1,
-    email: "invitee@example.com",
-    role_sid: "member",
-    status: "accepted",
-    token_hash: "hash",
-    invited_by_user_id: 1,
-    expires_at: "2026-03-16 00:26:35.709",
-    accepted_at: "2026-03-10 00:26:35.710",
-    revoked_at: null,
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-10 00:26:35.710"
-  };
-  const { knexStub, state } = createKnexStub({
-    rowById: new Map([["1", acceptedRow]])
+  const { api, state } = createWorkspaceInvitesApiStub({
+    rowById: new Map([
+      ["1", {
+        id: "1",
+        workspace: { id: "1" },
+        email: "invitee@example.com",
+        roleSid: "member",
+        status: "accepted",
+        tokenHash: "hash",
+        invitedByUser: { id: "1" },
+        expiresAt: "2026-03-16 00:26:35.709",
+        acceptedAt: "2026-03-10 00:26:35.710",
+        revokedAt: null,
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-10 00:26:35.710"
+      }]
+    ])
   });
-  const repository = createRepository(knexStub);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   await repository.markAcceptedById("1");
 
-  assert.equal(state.updatePayload.status, "accepted");
-  assert.equal(typeof state.updatePayload.accepted_at, "string");
-  assert.match(state.updatePayload.accepted_at, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/);
-  assert.equal(typeof state.updatePayload.updated_at, "string");
-  assert.match(state.updatePayload.updated_at, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/);
+  const payload = state.patchPayloads[0];
+  assert.equal(payload.attributes?.status, "accepted");
+  assert.equal(typeof payload.attributes?.acceptedAt, "object");
+  assert.equal(typeof payload.attributes?.updatedAt, "object");
 });
 
 test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps workspace join fields outside the base resource contract", async () => {
-  const { knexStub } = createKnexStub({
-    joinedRows: [
+  const { api } = createWorkspaceInvitesApiStub({
+    rows: [
       {
-        id: 1,
-        workspace_id: 9,
+        id: "1",
+        workspace: {
+          id: "9",
+          slug: "tonymobily3",
+          name: "TonyMobily3",
+          avatarUrl: "https://example.com/avatar.png"
+        },
         email: "invitee@example.com",
-        role_sid: "member",
+        roleSid: "member",
         status: "pending",
-        token_hash: "hash-token",
-        invited_by_user_id: 1,
-        expires_at: "2030-01-01 00:00:00.000",
-        accepted_at: null,
-        revoked_at: null,
-        created_at: "2026-03-09 00:26:35.710",
-        updated_at: "2026-03-09 00:26:35.710",
-        workspace_slug: "tonymobily3",
-        workspace_name: "TonyMobily3",
-        workspace_avatar_url: "https://example.com/avatar.png"
+        tokenHash: "hash-token",
+        invitedByUser: { id: "1" },
+        expiresAt: "2030-01-01 00:00:00.000",
+        acceptedAt: null,
+        revokedAt: null,
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-09 00:26:35.710"
       }
     ]
   });
-  const repository = createRepository(knexStub);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const invites = await repository.listPendingByWorkspaceIdWithWorkspace("9");
 

package/test/workspaceMembersResource.test.js

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
+import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
+
+function resolveOutputSchema(operationName) {
+  return resolveStructuredSchemaTransportSchema(workspaceMembersResource.operations[operationName].output, {
+    context: `workspaceMembers.${operationName}.output`,
+    defaultMode: "replace"
+  });
+}
+
+test("workspace members role catalog output is explicit and nested", () => {
+  const outputSchema = resolveOutputSchema("rolesList");
+  const roleItemRef = outputSchema.properties.roles.items.allOf[0].$ref.replace(/^#\/definitions\//, "");
+  const roleItemSchema = outputSchema.definitions[roleItemRef];
+
+  assert.equal(outputSchema.type, "object");
+  assert.equal(outputSchema.additionalProperties, false);
+  assert.equal(outputSchema.properties.roles.type, "array");
+  assert.equal(outputSchema.properties.roles.items["x-json-rest-schema"]?.castType, "object");
+  assert.equal(roleItemSchema.type, "object");
+  assert.equal(roleItemSchema.properties.permissions.type, "array");
+});
+
+test("workspace members invite mutation outputs expose their tracking ids explicitly", () => {
+  const createOutputSchema = resolveOutputSchema("createInvite");
+  const revokeOutputSchema = resolveOutputSchema("revokeInvite");
+
+  assert.equal(createOutputSchema.properties.createdInviteId.type, "string");
+  assert.equal(createOutputSchema.properties.inviteTokenPreview.type, "string");
+  assert.equal(revokeOutputSchema.properties.revokedInviteId.type, "string");
+  assert.equal(revokeOutputSchema.properties.roleCatalog["x-json-rest-schema"]?.castType, "object");
+  assert.equal(Array.isArray(revokeOutputSchema.properties.roleCatalog.allOf), true);
+});