@jskit-ai/workspaces-core 0.1.31 → 0.1.33

package/test/workspaceMembershipsRepository.test.js

@@ -3,108 +3,146 @@ import test from "node:test";
 import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
 
-function createKnexStub({
-  rowById = new Map(),
+function createKnexStub() {
+  const knex = Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+
+  return knex;
+}
+
+function toWorkspaceMembershipResource(row = {}) {
+  return {
+    type: "workspaceMemberships",
+    id: String(row.id || ""),
+    attributes: {
+      roleSid: row.roleSid,
+      status: row.status,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    },
+    relationships: {
+      workspace: {
+        data: row?.workspace?.id == null ? null : { type: "workspaces", id: String(row.workspace.id) }
+      },
+      user: {
+        data: row?.user?.id == null
+          ? null
+          : {
+              type: "userProfiles",
+              id: String(row.user.id)
+            }
+      }
+    }
+  };
+}
+
+function createWorkspaceMembershipsApiStub({
   rowByComposite = new Map(),
-  memberSummaryRows = []
+  memberSummaryRows = [],
+  rowById = new Map()
 } = {}) {
   const state = {
-    insertPayload: null,
-    updatePayload: null
+    postPayload: null,
+    patchPayload: null
   };
 
-  function buildMembershipsQuery(tableName) {
-    if (tableName === "workspace_memberships as wm") {
-      return {
-        join() {
-          return this;
-        },
-        where() {
-          return this;
+  const api = {
+    resources: {
+      workspaceMemberships: {
+        async query({ queryParams }) {
+          const filters = queryParams?.filters || {};
+          const includeUser = Array.isArray(queryParams?.include) && queryParams.include.includes("user");
+
+          if (Object.hasOwn(filters, "workspace") && Object.hasOwn(filters, "user")) {
+            const row = rowByComposite.get(`${filters.workspace}:${filters.user}`) || null;
+            return { data: row ? [toWorkspaceMembershipResource(row)] : [] };
+          }
+
+          if (Object.hasOwn(filters, "workspace") && Object.hasOwn(filters, "status") && includeUser) {
+            return {
+              data: memberSummaryRows.map((row) => toWorkspaceMembershipResource(row)),
+              included: memberSummaryRows
+                .filter((row) => row?.user?.id != null)
+                .map((row) => ({
+                  type: "userProfiles",
+                  id: String(row.user.id),
+                  attributes: {
+                    displayName: row.user.displayName,
+                    email: row.user.email
+                  }
+                }))
+            };
+          }
+
+          if (Object.hasOwn(filters, "user") && Object.hasOwn(filters, "status")) {
+            const rows = [...rowByComposite.values()].filter((row) => (
+              String(row?.user?.id || "") === String(filters.user) &&
+              String(row?.status || "") === String(filters.status)
+            ));
+            return { data: rows.map((row) => toWorkspaceMembershipResource(row)) };
+          }
+
+          return { data: [] };
         },
-        orderBy() {
-          return this;
+        async post(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.postPayload = inputRecord;
+          const row = rowById.get("1") || {
+            id: "1",
+            workspace: { id: String(inputRecord.relationships?.workspace?.data?.id || "") },
+            user: { id: String(inputRecord.relationships?.user?.data?.id || "") },
+            roleSid: String(inputRecord.attributes?.roleSid || ""),
+            status: String(inputRecord.attributes?.status || ""),
+            createdAt: "2026-03-09 00:26:35.710",
+            updatedAt: "2026-03-09 00:26:35.710"
+          };
+          rowByComposite.set(`${row.workspace.id}:${row.user.id}`, row);
+          rowById.set(String(row.id), row);
+          return { data: toWorkspaceMembershipResource(row) };
         },
-        select() {
-          return Promise.resolve([...memberSummaryRows]);
-        }
-      };
-    }
-
-    const query = {
-      criteriaList: [],
-      select() {
-        return this;
-      },
-      insert(payload) {
-        state.insertPayload = payload;
-        const insertedRow = rowById.get("1");
-        if (insertedRow) {
-          rowByComposite.set(`${payload.workspace_id}:${payload.user_id}`, insertedRow);
-        }
-        return Promise.resolve([1]);
-      },
-      where(criteria) {
-        this.criteriaList.push(criteria);
-        return this;
-      },
-      update(payload) {
-        state.updatePayload = payload;
-        const criteria = Object.assign({}, ...this.criteriaList);
-        const existingRow = rowById.get(String(criteria.id));
-        if (existingRow) {
-          const updatedRow = {
-            ...existingRow,
-            ...payload
+        async patch(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.patchPayload = inputRecord;
+          const existing = rowById.get(String(inputRecord.id));
+          const updated = {
+            ...(existing || {}),
+            ...(inputRecord.attributes || {}),
+            id: String(inputRecord.id),
+            workspace: existing?.workspace || { id: "" },
+            user: existing?.user || { id: "" }
           };
-          rowById.set(String(criteria.id), updatedRow);
-          rowByComposite.set(`${updatedRow.workspace_id}:${updatedRow.user_id}`, updatedRow);
+          rowById.set(String(updated.id), updated);
+          rowByComposite.set(`${updated.workspace.id}:${updated.user.id}`, updated);
+          return { data: toWorkspaceMembershipResource(updated) };
         }
-        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);
-        }
-        if (Object.hasOwn(criteria, "workspace_id") && Object.hasOwn(criteria, "user_id")) {
-          return Promise.resolve(
-            rowByComposite.get(`${criteria.workspace_id}:${criteria.user_id}`) || null
-          );
-        }
-        return Promise.resolve(null);
       }
-    };
-
-    return query;
-  }
-
-  function knex(tableName) {
-    if (tableName === "workspace_memberships" || tableName === "workspace_memberships as wm") {
-      return buildMembershipsQuery(tableName);
     }
-    throw new Error(`Unexpected table ${tableName}`);
-  }
-
-  knex.transaction = async (work) => work(knex);
+  };
 
-  return { knex, state };
+  return { api, state };
 }
 
 test("workspaceMembershipsRepository.findByWorkspaceIdAndUserId normalizes canonical membership rows via the internal resource", async () => {
   const membershipRow = {
-    id: 11,
-    workspace_id: 7,
-    user_id: 9,
-    role_sid: "owner",
+    id: "11",
+    workspace: { id: "7" },
+    user: { id: "9" },
+    roleSid: "owner",
     status: "active",
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-10 00:26:35.710"
+    createdAt: "2026-03-09 00:26:35.710",
+    updatedAt: "2026-03-10 00:26:35.710"
   };
-  const { knex } = createKnexStub({
+  const { api } = createWorkspaceMembershipsApiStub({
     rowByComposite: new Map([["7:9", membershipRow]])
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const membership = await repository.findByWorkspaceIdAndUserId("7", "9");
 
@@ -121,31 +159,31 @@ test("workspaceMembershipsRepository.findByWorkspaceIdAndUserId normalizes canon
 
 test("workspaceMembershipsRepository.ensureOwnerMembership upgrades an existing membership through the runtime update path", async () => {
   const existingRow = {
-    id: 11,
-    workspace_id: 7,
-    user_id: 9,
-    role_sid: "member",
+    id: "11",
+    workspace: { id: "7" },
+    user: { id: "9" },
+    roleSid: "member",
     status: "pending",
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710"
+    createdAt: "2026-03-09 00:26:35.710",
+    updatedAt: "2026-03-09 00:26:35.710"
   };
   const refreshedRow = {
     ...existingRow,
-    role_sid: "owner",
+    roleSid: "owner",
     status: "active",
-    updated_at: "2026-03-10 00:26:35.710"
+    updatedAt: "2026-03-10 00:26:35.710"
   };
-  const { knex, state } = createKnexStub({
+  const { api, state } = createWorkspaceMembershipsApiStub({
     rowById: new Map([["11", refreshedRow]]),
     rowByComposite: new Map([["7:9", existingRow]])
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const membership = await repository.ensureOwnerMembership("7", "9");
 
-  assert.equal(state.updatePayload.role_sid, "owner");
-  assert.equal(state.updatePayload.status, "active");
-  assert.equal(typeof state.updatePayload.updated_at, "string");
+  assert.equal(state.patchPayload.attributes?.roleSid, "owner");
+  assert.equal(state.patchPayload.attributes?.status, "active");
+  assert.equal(typeof state.patchPayload.attributes?.updatedAt, "object");
   assert.deepEqual(membership, {
     id: "11",
     workspaceId: "7",
@@ -153,50 +191,52 @@ test("workspaceMembershipsRepository.ensureOwnerMembership upgrades an existing
     roleSid: "owner",
     status: "active",
     createdAt: toIsoString("2026-03-09 00:26:35.710"),
-    updatedAt: toIsoString(state.updatePayload.updated_at)
+    updatedAt: toIsoString(state.patchPayload.attributes.updatedAt)
   });
 });
 
 test("workspaceMembershipsRepository.upsertMembership creates normalized memberships through the runtime create path", async () => {
   const createdRow = {
-    id: 1,
-    workspace_id: 7,
-    user_id: 9,
-    role_sid: "admin",
+    id: "1",
+    workspace: { id: "7" },
+    user: { id: "9" },
+    roleSid: "admin",
     status: "active",
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710"
+    createdAt: "2026-03-09 00:26:35.710",
+    updatedAt: "2026-03-09 00:26:35.710"
   };
-  const { knex, state } = createKnexStub({
+  const { api, state } = createWorkspaceMembershipsApiStub({
     rowById: new Map([["1", createdRow]]),
     rowByComposite: new Map()
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   await repository.upsertMembership("7", "9", {
     roleSid: "ADMIN",
     status: "ACTIVE"
   });
 
-  assert.equal(state.insertPayload.workspace_id, "7");
-  assert.equal(state.insertPayload.user_id, "9");
-  assert.equal(state.insertPayload.role_sid, "admin");
-  assert.equal(state.insertPayload.status, "active");
+  assert.equal(state.postPayload.relationships?.workspace?.data?.id, "7");
+  assert.equal(state.postPayload.relationships?.user?.data?.id, "9");
+  assert.equal(state.postPayload.attributes?.roleSid, "admin");
+  assert.equal(state.postPayload.attributes?.status, "active");
 });
 
 test("workspaceMembershipsRepository.listActiveByWorkspaceId keeps summary rows separate from the canonical membership resource", async () => {
-  const { knex } = createKnexStub({
+  const { api } = createWorkspaceMembershipsApiStub({
     memberSummaryRows: [
       {
-        user_id: 9,
-        role_sid: "owner",
-        status: "active",
-        display_name: "Chiara",
-        email: "CHIARA@example.com"
+        user: {
+          id: "9",
+          displayName: "Chiara",
+          email: "CHIARA@example.com"
+        },
+        roleSid: "owner",
+        status: "active"
       }
     ]
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const members = await repository.listActiveByWorkspaceId("7");
 

package/test/workspacePendingInvitationsResource.test.js

@@ -1,38 +1,33 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { workspacePendingInvitationsResource } from "../src/shared/resources/workspacePendingInvitationsResource.js";
 
-test("workspacePendingInvitationsResource output normalizer shapes raw invite rows", () => {
-  const tokenHash = "a".repeat(64);
-
-  const result = workspacePendingInvitationsResource.operations.list.outputValidator.normalize({
+test("workspacePendingInvitationsResource output schema accepts already-shaped invite payloads", () => {
+  const outputSchema = resolveStructuredSchemaTransportSchema(workspacePendingInvitationsResource.operations.list.output, {
+    context: "workspacePendingInvitations.list.output",
+    defaultMode: "replace"
+  });
+  const result = {
     pendingInvites: [
       {
         id: "10",
         workspaceId: "3",
         workspaceSlug: "tonymobily3",
-        workspaceName: "",
+        workspaceName: "TonyMobily3",
         workspaceAvatarUrl: "",
-        roleSid: "Member",
-        status: "Pending",
+        roleSid: "member",
+        status: "pending",
         expiresAt: "2030-01-01T00:00:00.000Z",
-        tokenHash
+        token: "opaque-token"
       }
     ]
-  }).pendingInvites;
+  };
 
-  assert.deepEqual(result, [
-    {
-      id: "10",
-      workspaceId: "3",
-      workspaceSlug: "tonymobily3",
-      workspaceName: "tonymobily3",
-      workspaceAvatarUrl: "",
-      roleSid: "member",
-      status: "pending",
-      expiresAt: "2030-01-01T00:00:00.000Z",
-      token: encodeInviteTokenHash(tokenHash)
-    }
-  ]);
+  assert.equal(outputSchema.type, "object");
+  assert.equal(outputSchema.additionalProperties, false);
+  assert.equal(outputSchema.properties.pendingInvites.type, "array");
+  assert.equal(outputSchema.properties.pendingInvites.items["x-json-rest-schema"]?.castType, "object");
+  assert.equal(Array.isArray(outputSchema.properties.pendingInvites.items.allOf), true);
+  assert.equal(result.pendingInvites[0].roleSid, "member");
 });

package/test/workspacePendingInvitationsService.test.js

@@ -78,8 +78,9 @@ test("listPendingInvitesForUser returns raw pending invite rows for the action l
   });
 
   assert.equal(pendingInvites.length, 1);
-  assert.equal(pendingInvites[0].tokenHash, tokenHash);
+  assert.equal(pendingInvites[0].token, encodeInviteTokenHash(tokenHash));
   assert.equal(pendingInvites[0].workspaceName, "TonyMobily3");
+  assert.equal(pendingInvites[0].status, "pending");
 });
 
 test("acceptInviteByToken accepts opaque invite token and resolves invite by decoded hash", async () => {

package/test/workspaceServerScopeSupport.test.js

@@ -1,13 +1,26 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { AUTH_POLICY_CONTEXT_RESOLVER_TAG } from "@jskit-ai/auth-core/server/authPolicyContextResolverRegistry";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG } from "@jskit-ai/users-core/server/profileSyncLifecycleContributorRegistry";
 import { createWorkspaceServerScopeSupport } from "../src/server/support/workspaceServerScopeSupport.js";
 import { registerWorkspaceCore } from "../src/server/registerWorkspaceCore.js";
 
-test("workspace server scope support exposes the canonical workspace helper surface", () => {
+test("workspace server scope support exposes the canonical workspace helper surface", async () => {
   const support = createWorkspaceServerScopeSupport();
 
   assert.equal(support.available, true);
-  assert.equal(typeof support.paramsValidator?.normalize, "function");
+  assert.equal(typeof support.params?.schema, "object");
+  assert.equal(support.params?.mode, "patch");
+  assert.deepEqual(
+    await validateSchemaPayload(support.params, { workspaceSlug: "  ACME  " }, {
+      phase: "input",
+      context: "workspaceServerScopeSupport.params"
+    }),
+    {
+      workspaceSlug: "acme"
+    }
+  );
   assert.deepEqual(support.buildInputFromRouteParams({ workspaceSlug: "  ACME  " }), {
     workspaceSlug: "acme"
   });
@@ -34,12 +47,17 @@ test("workspace server scope support exposes the canonical workspace helper surf
 
 test("registerWorkspaceCore registers the workspace server scope support token", () => {
   const singletons = new Map();
+  const tags = new Map();
   const app = {
     singleton(token, factory) {
       singletons.set(token, factory);
       return this;
     },
-    tag() {
+    tag(token, tagName) {
+      const key = String(tagName || "");
+      const list = tags.get(key) || [];
+      list.push(String(token || ""));
+      tags.set(key, list);
       return this;
     },
     has() {
@@ -50,8 +68,64 @@ test("registerWorkspaceCore registers the workspace server scope support token",
   registerWorkspaceCore(app);
 
   assert.equal(singletons.has("workspaces.server.scope-support"), true);
+  assert.deepEqual(tags.get(AUTH_POLICY_CONTEXT_RESOLVER_TAG), ["workspaces.core.authPolicyContextResolver"]);
   const support = singletons.get("workspaces.server.scope-support")();
   assert.equal(support.available, true);
   assert.equal(typeof support.buildInputFromRouteParams, "function");
   assert.equal(typeof support.resolveWorkspace, "function");
 });
+
+test("registerWorkspaceCore ensures personal workspace provisioning on every authenticated profile sync", async () => {
+  const singletons = new Map();
+  const tags = new Map();
+  const app = {
+    singleton(token, factory) {
+      singletons.set(token, factory);
+      return this;
+    },
+    tag(token, tagName) {
+      const key = String(tagName || "");
+      const list = tags.get(key) || [];
+      list.push(String(token || ""));
+      tags.set(key, list);
+      return this;
+    },
+    has() {
+      return false;
+    }
+  };
+
+  registerWorkspaceCore(app);
+
+  assert.deepEqual(tags.get(PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG), ["workspaces.core.profileSyncLifecycleContributor"]);
+
+  const lifecycleFactory = singletons.get("workspaces.core.profileSyncLifecycleContributor");
+  assert.equal(typeof lifecycleFactory, "function");
+
+  const calls = [];
+  const contributor = lifecycleFactory({
+    make(token) {
+      if (token === "workspaces.service") {
+        return {
+          async ensureProvisionedWorkspaceForAuthenticatedUser(profile, options = {}) {
+            calls.push({ profile, options });
+          }
+        };
+      }
+      throw new Error(`Unexpected token: ${token}`);
+    }
+  });
+
+  await contributor.afterIdentityProfileSynced({
+    profile: { id: "7", username: "tonymobily" },
+    created: false,
+    options: { trx: { id: "tx-1" } }
+  });
+
+  assert.deepEqual(calls, [
+    {
+      profile: { id: "7", username: "tonymobily" },
+      options: { trx: { id: "tx-1" } }
+    }
+  ]);
+});

package/test/workspaceService.test.js

@@ -41,7 +41,8 @@ function createWorkspaceServiceFixture({
     listForUserId: 0,
     insert: 0,
     updateById: 0,
-    ensureOwnerMembership: 0
+    ensureOwnerMembership: 0,
+    ensureWorkspaceSettings: 0
   };
   let nextWorkspaceId = 10;
   const personalWorkspaceState =
@@ -167,6 +168,7 @@ function createWorkspaceServiceFixture({
     },
     workspaceSettingsRepository: {
       async ensureForWorkspaceId() {
+        calls.ensureWorkspaceSettings += 1;
         return {
           invitesEnabled: true
         };
@@ -258,13 +260,13 @@ test("workspaceService.listWorkspacesForUser returns all active memberships in p
   assert.equal(calls.listForUserId, 1);
 });
 
-test("workspaceService.provisionWorkspaceForNewUser provisions personal workspace only in personal tenancy", async () => {
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser provisions personal workspace only in personal tenancy", async () => {
   const { service, calls, insertedPayloads } = createWorkspaceServiceFixture({
     tenancyMode: "personal",
     personalWorkspace: null
   });
 
-  const workspace = await service.provisionWorkspaceForNewUser({
+  const workspace = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
     id: "7",
     email: "chiaramobily@gmail.com",
     displayName: "Chiara"
@@ -274,15 +276,34 @@ test("workspaceService.provisionWorkspaceForNewUser provisions personal workspac
   assert.equal(calls.findPersonalByOwnerUserId, 1);
   assert.equal(calls.insert, 1);
   assert.equal(calls.ensureOwnerMembership, 1);
+  assert.equal(calls.ensureWorkspaceSettings, 1);
   assert.equal(insertedPayloads[0].isPersonal, true);
 });
 
-test("workspaceService.provisionWorkspaceForNewUser is a no-op outside personal tenancy", async () => {
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser reuses the existing personal workspace in personal tenancy", async () => {
+  const { service, calls } = createWorkspaceServiceFixture({
+    tenancyMode: "personal"
+  });
+
+  const workspace = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
+    id: "7",
+    email: "chiaramobily@gmail.com",
+    displayName: "Chiara"
+  });
+
+  assert.equal(workspace.id, "1");
+  assert.equal(calls.findPersonalByOwnerUserId, 1);
+  assert.equal(calls.insert, 0);
+  assert.equal(calls.ensureOwnerMembership, 1);
+  assert.equal(calls.ensureWorkspaceSettings, 1);
+});
+
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser is a no-op outside personal tenancy", async () => {
   const { service, calls } = createWorkspaceServiceFixture({
     tenancyMode: "workspaces"
   });
 
-  const result = await service.provisionWorkspaceForNewUser({
+  const result = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
     id: "7",
     email: "chiaramobily@gmail.com",
     displayName: "Chiara"

package/test/workspaceSettingsActions.test.js

@@ -1,11 +1,9 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import "../test-support/registerDefaultSettingsFields.js";
 import { workspaceDirectoryActions } from "../src/server/workspaceDirectory/workspaceDirectoryActions.js";
 import { workspacePendingInvitationsActions } from "../src/server/workspacePendingInvitations/workspacePendingInvitationsActions.js";
 import { workspaceMembersActions } from "../src/server/workspaceMembers/workspaceMembersActions.js";
 import { workspaceSettingsActions } from "../src/server/workspaceSettings/workspaceSettingsActions.js";
-import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
 
 test("workspace settings actions live in their own action array", () => {
   assert.deepEqual(
@@ -35,18 +33,18 @@ test("workspace actions array no longer owns workspace settings actions", () =>
   );
 });
 
-test("workspace directory actions use the canonical workspace list resource output", () => {
+test("workspace directory actions stay thin and defer output validation to routes", () => {
   const listAction = workspaceDirectoryActions.find((action) => action.id === "workspace.workspaces.list");
   assert.ok(listAction);
-  assert.equal(listAction.outputValidator, workspaceResource.operations.list.outputValidator);
+  assert.equal(listAction.output, null);
 });
 
-test("workspace directory read/update actions use canonical workspace resource validators", () => {
+test("workspace directory read/update actions stay thin and defer output validation to routes", () => {
   const readAction = workspaceDirectoryActions.find((action) => action.id === "workspace.workspaces.read");
   const updateAction = workspaceDirectoryActions.find((action) => action.id === "workspace.workspaces.update");
 
   assert.ok(readAction);
   assert.ok(updateAction);
-  assert.equal(readAction.outputValidator, workspaceResource.operations.view.outputValidator);
-  assert.equal(updateAction.outputValidator, workspaceResource.operations.patch.outputValidator);
+  assert.equal(readAction.output, null);
+  assert.equal(updateAction.output, null);
 });

package/test/workspaceSettingsInternalResource.test.js

@@ -0,0 +1,8 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
+
+test("shared workspace settings resource declares workspace_id as the resource id column", () => {
+  assert.equal(workspaceSettingsResource.idProperty, "workspace_id");
+  assert.equal(workspaceSettingsResource.schema.id?.storage?.column, "workspace_id");
+});