@jskit-ai/users-core 0.1.47 → 0.1.49

package/src/shared/index.js

@@ -1,107 +1,10 @@
-import {
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission
-} from "./roles.js";
-
-import {
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
-  DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  normalizeWorkspaceHexColor,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  WORKSPACE_THEME_MODE_DARK,
-  WORKSPACE_THEME_MODE_LIGHT,
-  resolveWorkspaceThemePalette
-} from "./settings.js";
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
-} from "./tenancyProfile.js";
+import { DEFAULT_USER_SETTINGS } from "./settings.js";
 
 const USERS_SHARED_API = Object.freeze({
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
-  DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  WORKSPACE_THEME_MODE_LIGHT,
-  WORKSPACE_THEME_MODE_DARK,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  normalizeWorkspaceHexColor,
-  resolveWorkspaceThemePalette,
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
+  DEFAULT_USER_SETTINGS
 });
 
 export {
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  WORKSPACE_THEME_MODE_LIGHT,
-  WORKSPACE_THEME_MODE_DARK,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  normalizeWorkspaceHexColor,
-  resolveWorkspaceThemePalette,
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode,
   USERS_SHARED_API
 };

package/src/shared/settings.js

@@ -1,23 +1,3 @@
-const WORKSPACE_THEME_MODE_LIGHT = "light";
-const WORKSPACE_THEME_MODE_DARK = "dark";
-const HEX_COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
-
-const DEFAULT_WORKSPACE_LIGHT_PALETTE = Object.freeze({
-  color: "#1867C0",
-  secondaryColor: "#48A9A6",
-  surfaceColor: "#FFFFFF",
-  surfaceVariantColor: "#424242"
-});
-
-const DEFAULT_WORKSPACE_DARK_PALETTE = Object.freeze({
-  color: "#2196F3",
-  secondaryColor: "#54B6B2",
-  surfaceColor: "#212121",
-  surfaceVariantColor: "#C8C8C8"
-});
-
-const DEFAULT_WORKSPACE_COLOR = DEFAULT_WORKSPACE_LIGHT_PALETTE.color;
-
 const DEFAULT_USER_SETTINGS = Object.freeze({
   theme: "system",
   locale: "en",
@@ -32,104 +12,6 @@ const DEFAULT_USER_SETTINGS = Object.freeze({
   passwordSignInEnabled: true,
   passwordSetupRequired: false
 });
-
-function normalizeWorkspaceHexColor(value) {
-  const normalized = String(value || "").trim();
-  if (!HEX_COLOR_PATTERN.test(normalized)) {
-    return "";
-  }
-  return normalized.toUpperCase();
-}
-
-function coerceWorkspaceColor(value) {
-  return normalizeWorkspaceHexColor(value) || DEFAULT_WORKSPACE_COLOR;
-}
-
-function normalizeWorkspaceThemeMode(value = "") {
-  const normalized = String(value || "").trim().toLowerCase();
-  if (normalized === WORKSPACE_THEME_MODE_DARK) {
-    return WORKSPACE_THEME_MODE_DARK;
-  }
-  return WORKSPACE_THEME_MODE_LIGHT;
-}
-
-function resolveWorkspaceThemeDefaultPalette(mode = WORKSPACE_THEME_MODE_LIGHT) {
-  const normalizedMode = normalizeWorkspaceThemeMode(mode);
-  return normalizedMode === WORKSPACE_THEME_MODE_DARK
-    ? DEFAULT_WORKSPACE_DARK_PALETTE
-    : DEFAULT_WORKSPACE_LIGHT_PALETTE;
-}
-
-function coerceWorkspaceThemeColor(value, fallbackColor = DEFAULT_WORKSPACE_COLOR) {
-  return normalizeWorkspaceHexColor(value) || normalizeWorkspaceHexColor(fallbackColor) || DEFAULT_WORKSPACE_COLOR;
-}
-
-function coerceWorkspaceSecondaryColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).secondaryColor);
-}
-
-function coerceWorkspaceSurfaceColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceColor);
-}
-
-function coerceWorkspaceSurfaceVariantColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceVariantColor);
-}
-
-function resolveWorkspaceThemePalette(input = {}, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  const source = input && typeof input === "object" ? input : {};
-  const normalizedMode = normalizeWorkspaceThemeMode(mode);
-  const paletteDefaults = resolveWorkspaceThemeDefaultPalette(normalizedMode);
-
-  if (normalizedMode === WORKSPACE_THEME_MODE_DARK) {
-    return Object.freeze({
-      color: coerceWorkspaceThemeColor(source.darkPrimaryColor, paletteDefaults.color),
-      secondaryColor: coerceWorkspaceThemeColor(source.darkSecondaryColor, paletteDefaults.secondaryColor),
-      surfaceColor: coerceWorkspaceThemeColor(source.darkSurfaceColor, paletteDefaults.surfaceColor),
-      surfaceVariantColor: coerceWorkspaceThemeColor(
-        source.darkSurfaceVariantColor,
-        paletteDefaults.surfaceVariantColor
-      )
-    });
-  }
-
-  return Object.freeze({
-    color: coerceWorkspaceThemeColor(source.lightPrimaryColor, paletteDefaults.color),
-    secondaryColor: coerceWorkspaceThemeColor(source.lightSecondaryColor, paletteDefaults.secondaryColor),
-    surfaceColor: coerceWorkspaceThemeColor(source.lightSurfaceColor, paletteDefaults.surfaceColor),
-    surfaceVariantColor: coerceWorkspaceThemeColor(
-      source.lightSurfaceVariantColor,
-      paletteDefaults.surfaceVariantColor
-    )
-  });
-}
-
-function resolveWorkspaceThemePalettes(input = {}) {
-  return Object.freeze({
-    light: resolveWorkspaceThemePalette(input, {
-      mode: WORKSPACE_THEME_MODE_LIGHT
-    }),
-    dark: resolveWorkspaceThemePalette(input, {
-      mode: WORKSPACE_THEME_MODE_DARK
-    })
-  });
-}
-
 export {
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
-  DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  normalizeWorkspaceHexColor,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  WORKSPACE_THEME_MODE_DARK,
-  WORKSPACE_THEME_MODE_LIGHT,
-  resolveWorkspaceThemePalette
+  DEFAULT_USER_SETTINGS
 };

package/templates/migrations/users_core_generic_initial.cjs

@@ -42,28 +42,12 @@ exports.up = async function up(knex) {
     });
   }
 
-  const hasConsoleSettingsTable = await knex.schema.hasTable("console_settings");
-  if (!hasConsoleSettingsTable) {
-    await knex.schema.createTable("console_settings", (table) => {
-      table.bigInteger("id").primary();
-      table.bigInteger("owner_user_id").unsigned().nullable().references("id").inTable("users").onDelete("SET NULL");
-      table.timestamp("created_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
-      table.timestamp("updated_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
-    });
-
-    await knex("console_settings").insert({
-      id: 1,
-      created_at: knex.fn.now(),
-      updated_at: knex.fn.now()
-    });
-  }
 };
 
 /**
  * @param {import('knex').Knex} knex
  */
 exports.down = async function down(knex) {
-  await knex.schema.dropTableIfExists("console_settings");
   await knex.schema.dropTableIfExists("user_settings");
   await knex.schema.dropTableIfExists("users");
 };

package/test/authProfileSyncService.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createService } from "../src/server/common/services/authProfileSyncService.js";
 
-test("authProfileSyncService.syncIdentityProfile uses shared transaction for profile upsert and provisioning", async () => {
+test("authProfileSyncService.syncIdentityProfile uses shared transaction for profile upsert and lifecycle contributors", async () => {
   const calls = [];
   const transaction = { trxId: "tx-1" };
 
@@ -33,11 +33,14 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
         return { userId: Number(userId) };
       }
     },
-    workspaceProvisioningService: {
-      async provisionWorkspaceForNewUser(_profile, options = {}) {
-        calls.push({ step: "provision", trx: options.trx || null });
+    lifecycleContributors: [
+      {
+        contributorId: "test.lifecycle",
+        async afterIdentityProfileSynced({ created, options = {} } = {}) {
+          calls.push({ step: "lifecycle", created, trx: options.trx || null });
+        }
       }
-    }
+    ]
   });
 
   const profile = await service.syncIdentityProfile({
@@ -52,7 +55,8 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
   assert.equal(calls[1].step, "find");
   assert.equal(calls[2].step, "upsert");
   assert.equal(calls[3].step, "ensureUserSettings");
-  assert.equal(calls[4].step, "provision");
+  assert.equal(calls[4].step, "lifecycle");
+  assert.equal(calls[4].created, true);
   assert.equal(calls[1].trx, transaction);
   assert.equal(calls[2].trx, transaction);
   assert.equal(calls[3].trx, transaction);
@@ -87,11 +91,16 @@ test("authProfileSyncService.syncIdentityProfile skips write path when profile i
         return { userId: "7" };
       }
     },
-    workspaceProvisioningService: {
-      async provisionWorkspaceForNewUser() {
-        provisionCalls += 1;
+    lifecycleContributors: [
+      {
+        contributorId: "test.lifecycle",
+        async afterIdentityProfileSynced({ created } = {}) {
+          if (created) {
+            provisionCalls += 1;
+          }
+        }
       }
-    }
+    ]
   });
 
   const profile = await service.syncIdentityProfile({

package/test/registerServiceRealtimeEvents.test.js

@@ -3,9 +3,6 @@ import test from "node:test";
 import { registerAccountProfile } from "../src/server/accountProfile/registerAccountProfile.js";
 import { registerAccountPreferences } from "../src/server/accountPreferences/registerAccountPreferences.js";
 import { registerAccountNotifications } from "../src/server/accountNotifications/registerAccountNotifications.js";
-import { registerConsoleSettings } from "../src/server/consoleSettings/registerConsoleSettings.js";
-import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
-import { registerWorkspacePendingInvitations } from "../src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js";
 
 function createAppDouble() {
   const serviceCalls = [];
@@ -58,94 +55,3 @@ test("account register functions publish account.settings.changed for update ope
   assert.equal(notifications?.metadata?.events?.updateNotifications?.[0]?.realtime?.event, "account.settings.changed");
   assert.equal(notifications?.metadata?.events?.updateNotifications?.[1]?.realtime?.event, "users.bootstrap.changed");
 });
-
-test("console settings register publishes console.settings.changed", () => {
-  const payload = createAppDouble();
-  registerConsoleSettings(payload.app);
-  const consoleSettings = findServiceCall(payload.serviceCalls, "users.console.settings.service");
-  assert.equal(consoleSettings?.metadata?.events?.updateSettings?.[0]?.realtime?.event, "console.settings.changed");
-});
-
-test("workspace register functions publish members/invites/workspace-list realtime events", async () => {
-  const membersApp = createAppDouble();
-  registerWorkspaceMembers(membersApp.app);
-  const members = findServiceCall(membersApp.serviceCalls, "users.workspace.members.service");
-  assert.equal(members?.metadata?.events?.updateMemberRole?.[0]?.realtime?.event, "workspace.members.changed");
-  assert.equal(members?.metadata?.events?.updateMemberRole?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.removeMember?.[0]?.realtime?.event, "workspace.members.changed");
-  assert.equal(members?.metadata?.events?.removeMember?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[0]?.realtime?.event, "workspace.invites.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.entityId?.({ result: { createdInviteId: "91" } }), "91");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.preset, "event_scope");
-  assert.equal(typeof members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery, "function");
-  const createInviteAudienceQueryResult = await members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery({
-    knex() {
-      return {
-        join() {
-          return this;
-        },
-        where(field, value) {
-          assert.equal(field, "wi.id");
-          assert.equal(value, "91");
-          return this;
-        },
-        async first() {
-          return {
-            user_id: 55
-          };
-        }
-      };
-    },
-    event: {
-      entityId: "91"
-    }
-  });
-  assert.deepEqual(createInviteAudienceQueryResult, [{ userId: "55" }]);
-  assert.equal(members?.metadata?.events?.revokeInvite?.[0]?.realtime?.event, "workspace.invites.changed");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.entityId?.({ result: { revokedInviteId: "19" } }), "19");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.preset, "event_scope");
-  assert.equal(typeof members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.userQuery, "function");
-
-  const pendingApp = createAppDouble();
-  registerWorkspacePendingInvitations(pendingApp.app);
-  const pending = findServiceCall(pendingApp.serviceCalls, "users.workspace.pending-invitations.service");
-  const acceptInviteEvents = Array.isArray(pending?.metadata?.events?.acceptInviteByToken)
-    ? pending.metadata.events.acceptInviteByToken
-    : [];
-  const acceptInviteRealtimeEvents = acceptInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.invitations.pending.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("users.bootstrap.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspaces.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.members.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.invites.changed"));
-
-  const acceptedMembersChange = acceptInviteEvents.find(
-    (entry) => entry?.realtime?.event === "workspace.members.changed"
-  );
-  assert.equal(acceptedMembersChange?.entityId?.({ result: { workspaceId: "9" } }), "9");
-  assert.deepEqual(
-    acceptedMembersChange?.realtime?.audience?.({
-      event: {
-        entityId: "9"
-      }
-    }),
-    {
-      workspaceId: "9"
-    }
-  );
-
-  const acceptedInvitesChange = acceptInviteEvents.find(
-    (entry) => entry?.realtime?.event === "workspace.invites.changed"
-  );
-  assert.equal(acceptedInvitesChange?.entityId?.({ result: { workspaceId: "9" } }), "9");
-
-  const refuseInviteEvents = Array.isArray(pending?.metadata?.events?.refuseInviteByToken)
-    ? pending.metadata.events.refuseInviteByToken
-    : [];
-  const refuseInviteRealtimeEvents = refuseInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
-  assert.ok(refuseInviteRealtimeEvents.includes("workspace.invitations.pending.changed"));
-  assert.ok(refuseInviteRealtimeEvents.includes("users.bootstrap.changed"));
-  assert.ok(refuseInviteRealtimeEvents.includes("workspace.invites.changed"));
-});

package/test/registerUsersCore.test.js

@@ -2,32 +2,19 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { registerUsersCore } from "../src/server/registerUsersCore.js";
 
-test("registerUsersCore registers console and workspace action surface aliases when action runtime is available", () => {
-  const calls = [];
+test("registerUsersCore only binds users-core singletons", () => {
+  const singletonTokens = [];
   const app = {
-    singleton() {
-      return this;
-    },
-    actionSurfaceSource(sourceName, resolver) {
-      calls.push({
-        sourceName: String(sourceName || ""),
-        resolverType: typeof resolver
-      });
+    singleton(token) {
+      singletonTokens.push(String(token || ""));
       return this;
     }
   };
 
   registerUsersCore(app);
 
-  assert.deepEqual(calls, [
-    {
-      sourceName: "workspace",
-      resolverType: "function"
-    },
-    {
-      sourceName: "console",
-      resolverType: "function"
-    }
+  assert.deepEqual(singletonTokens.sort(), [
+    "users.profile.sync.service"
   ]);
 });
 

package/test/repositoryContracts.test.js

@@ -2,11 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createRepository as createUsersRepository } from "../src/server/common/repositories/usersRepository.js";
 import { createRepository as createUserSettingsRepository } from "../src/server/common/repositories/userSettingsRepository.js";
-import { createRepository as createWorkspaceInvitesRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
-import { createRepository as createWorkspaceMembershipsRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
-import { createRepository as createWorkspacesRepository } from "../src/server/common/repositories/workspacesRepository.js";
-import { createRepository as createConsoleSettingsRepository } from "../src/server/consoleSettings/consoleSettingsRepository.js";
-import { createRepository as createWorkspaceSettingsRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
 
 function createKnexStub() {
   const knex = Object.assign(() => {
@@ -24,12 +19,7 @@ test("users-core repositories expose withTransaction", async () => {
   const knex = createKnexStub();
   const repositories = [
     createUsersRepository(knex),
-    createUserSettingsRepository(knex),
-    createWorkspaceInvitesRepository(knex),
-    createWorkspaceMembershipsRepository(knex),
-    createWorkspacesRepository(knex),
-    createConsoleSettingsRepository(knex),
-    createWorkspaceSettingsRepository(knex)
+    createUserSettingsRepository(knex)
   ];
 
   for (const repository of repositories) {

package/test/resourcesCanonical.test.js

@@ -4,12 +4,8 @@ import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import "../test-support/registerDefaultSettingsFields.js";
-import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
-import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
-import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
 import { userProfileResource } from "../src/shared/resources/userProfileResource.js";
 import { userSettingsResource } from "../src/shared/resources/userSettingsResource.js";
-import { consoleSettingsResource } from "../src/shared/resources/consoleSettingsResource.js";
 
 function assertResourceOperationMessages(resource, operationName, label) {
   const operation = resource?.operations?.[operationName];
@@ -31,11 +27,8 @@ function assertResourceOperationMessages(resource, operationName, label) {
 
 test("users-core resources expose messages for all operations", () => {
   const resources = {
-    workspace: workspaceResource,
-    workspaceSettings: workspaceSettingsResource,
     userProfile: userProfileResource,
-    userSettings: userSettingsResource,
-    consoleSettings: consoleSettingsResource
+    userSettings: userSettingsResource
   };
 
   for (const [label, resource] of Object.entries(resources)) {
@@ -46,18 +39,7 @@ test("users-core resources expose messages for all operations", () => {
 });
 
 test("users-core specialized resource operations expose messages and validators", () => {
-  const workspaceMembersOperationSpecs = [
-    { label: "workspaceMembers.rolesList", operation: workspaceMembersResource.operations.rolesList },
-    { label: "workspaceMembers.membersList", operation: workspaceMembersResource.operations.membersList },
-    { label: "workspaceMembers.updateMemberRole", operation: workspaceMembersResource.operations.updateMemberRole },
-    { label: "workspaceMembers.removeMember", operation: workspaceMembersResource.operations.removeMember },
-    { label: "workspaceMembers.invitesList", operation: workspaceMembersResource.operations.invitesList },
-    { label: "workspaceMembers.createInvite", operation: workspaceMembersResource.operations.createInvite },
-    { label: "workspaceMembers.revokeInvite", operation: workspaceMembersResource.operations.revokeInvite },
-    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite }
-  ];
   const operationSpecs = [
-    ...workspaceMembersOperationSpecs,
     { label: "userProfile.avatarUpload", operation: userProfileResource.operations.avatarUpload },
     { label: "userProfile.avatarDelete", operation: userProfileResource.operations.avatarDelete },
     { label: "userSettings.passwordChange", operation: userSettingsResource.operations.passwordChange },

package/test/settingsFieldRegistriesSingleton.test.js

@@ -6,19 +6,9 @@ async function importWithIdentity(url, identity) {
 }
 
 test("settings field registries stay shared across module identities", async () => {
-  const workspaceModuleUrl = new URL("../src/shared/resources/workspaceSettingsFields.js", import.meta.url);
   const userModuleUrl = new URL("../src/shared/resources/userSettingsFields.js", import.meta.url);
-  const consoleModuleUrl = new URL("../src/shared/resources/consoleSettingsFields.js", import.meta.url);
-
-  const workspaceA = await importWithIdentity(workspaceModuleUrl, "workspace-a");
-  const workspaceB = await importWithIdentity(workspaceModuleUrl, "workspace-b");
-  assert.equal(workspaceA.workspaceSettingsFields, workspaceB.workspaceSettingsFields);
 
   const userA = await importWithIdentity(userModuleUrl, "user-a");
   const userB = await importWithIdentity(userModuleUrl, "user-b");
   assert.equal(userA.userSettingsFields, userB.userSettingsFields);
-
-  const consoleA = await importWithIdentity(consoleModuleUrl, "console-a");
-  const consoleB = await importWithIdentity(consoleModuleUrl, "console-b");
-  assert.equal(consoleA.consoleSettingsFields, consoleB.consoleSettingsFields);
 });