@jskit-ai/workspaces-core 0.1.13 → 0.1.15

package/test/workspaceSettingsRepository.test.js

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import "../test-support/registerDefaultSettingsFields.js";
+import { toIsoString } from "@jskit-ai/database-runtime/shared";
+import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
+import { createRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
+
+function createDefaultWorkspaceSettings() {
+  return true;
+}
+
+const DEFAULT_WORKSPACE_THEME = resolveWorkspaceThemePalettes({});
+const STUB_CREATED_AT = "2026-03-09 00:26:35.710";
+
+function createKnexStub(rowOverrides = {}) {
+  const state = {
+    insertedRow: null,
+    updatePayload: null,
+    row: {
+      workspace_id: 1,
+      light_primary_color: DEFAULT_WORKSPACE_THEME.light.color,
+      light_secondary_color: DEFAULT_WORKSPACE_THEME.light.secondaryColor,
+      light_surface_color: DEFAULT_WORKSPACE_THEME.light.surfaceColor,
+      light_surface_variant_color: DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor,
+      dark_primary_color: DEFAULT_WORKSPACE_THEME.dark.color,
+      dark_secondary_color: DEFAULT_WORKSPACE_THEME.dark.secondaryColor,
+      dark_surface_color: DEFAULT_WORKSPACE_THEME.dark.surfaceColor,
+      dark_surface_variant_color: DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor,
+      invites_enabled: 1,
+      created_at: STUB_CREATED_AT,
+      updated_at: STUB_CREATED_AT,
+      ...rowOverrides
+    }
+  };
+
+  function tableBuilder(tableName) {
+    assert.equal(tableName, "workspace_settings");
+
+    return {
+      insert(payload) {
+        state.insertedRow = { ...payload };
+        state.row = {
+          workspace_id: payload.workspace_id,
+          light_primary_color: payload.light_primary_color,
+          light_secondary_color: payload.light_secondary_color,
+          light_surface_color: payload.light_surface_color,
+          light_surface_variant_color: payload.light_surface_variant_color,
+          dark_primary_color: payload.dark_primary_color,
+          dark_secondary_color: payload.dark_secondary_color,
+          dark_surface_color: payload.dark_surface_color,
+          dark_surface_variant_color: payload.dark_surface_variant_color,
+          invites_enabled: payload.invites_enabled,
+          created_at: "2026-03-10 00:00:00.000",
+          updated_at: "2026-03-10 00:00:00.000"
+        };
+        return Promise.resolve([1]);
+      },
+      where(criteria) {
+        assert.equal(typeof criteria, "object");
+
+        return {
+          first() {
+            return Promise.resolve(state.row ? { ...state.row } : null);
+          },
+          update(payload) {
+            state.updatePayload = payload;
+            if (Object.hasOwn(payload, "invites_enabled")) {
+              state.row.invites_enabled = payload.invites_enabled;
+            }
+            if (Object.hasOwn(payload, "light_primary_color")) {
+              state.row.light_primary_color = payload.light_primary_color;
+            }
+            if (Object.hasOwn(payload, "light_secondary_color")) {
+              state.row.light_secondary_color = payload.light_secondary_color;
+            }
+            if (Object.hasOwn(payload, "light_surface_color")) {
+              state.row.light_surface_color = payload.light_surface_color;
+            }
+            if (Object.hasOwn(payload, "light_surface_variant_color")) {
+              state.row.light_surface_variant_color = payload.light_surface_variant_color;
+            }
+            if (Object.hasOwn(payload, "dark_primary_color")) {
+              state.row.dark_primary_color = payload.dark_primary_color;
+            }
+            if (Object.hasOwn(payload, "dark_secondary_color")) {
+              state.row.dark_secondary_color = payload.dark_secondary_color;
+            }
+            if (Object.hasOwn(payload, "dark_surface_color")) {
+              state.row.dark_surface_color = payload.dark_surface_color;
+            }
+            if (Object.hasOwn(payload, "dark_surface_variant_color")) {
+              state.row.dark_surface_variant_color = payload.dark_surface_variant_color;
+            }
+            if (Object.hasOwn(payload, "updated_at")) {
+              state.row.updated_at = payload.updated_at;
+            }
+            return Promise.resolve(1);
+          }
+        };
+      }
+    };
+  }
+
+  return { knexStub: tableBuilder, state };
+}
+
+test("workspaceSettingsRepository.findByWorkspaceId maps the stored row", async () => {
+  const { knexStub } = createKnexStub();
+  const repository = createRepository(knexStub, {
+    defaultInvitesEnabled: createDefaultWorkspaceSettings()
+  });
+
+  const record = await repository.findByWorkspaceId("1");
+
+  assert.deepEqual(record, {
+    workspaceId: "1",
+    lightPrimaryColor: DEFAULT_WORKSPACE_THEME.light.color,
+    lightSecondaryColor: DEFAULT_WORKSPACE_THEME.light.secondaryColor,
+    lightSurfaceColor: DEFAULT_WORKSPACE_THEME.light.surfaceColor,
+    lightSurfaceVariantColor: DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor,
+    darkPrimaryColor: DEFAULT_WORKSPACE_THEME.dark.color,
+    darkSecondaryColor: DEFAULT_WORKSPACE_THEME.dark.secondaryColor,
+    darkSurfaceColor: DEFAULT_WORKSPACE_THEME.dark.surfaceColor,
+    darkSurfaceVariantColor: DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor,
+    invitesEnabled: true,
+    createdAt: toIsoString(STUB_CREATED_AT),
+    updatedAt: toIsoString(STUB_CREATED_AT)
+  });
+});
+
+test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates invitesEnabled only", async () => {
+  const { knexStub, state } = createKnexStub();
+  const repository = createRepository(knexStub, {
+    defaultInvitesEnabled: createDefaultWorkspaceSettings()
+  });
+
+  const updated = await repository.updateSettingsByWorkspaceId("1", {
+    invitesEnabled: false
+  });
+
+  assert.equal(state.updatePayload.invites_enabled, false);
+  assert.equal(updated.invitesEnabled, false);
+});
+
+test("workspaceSettingsRepository.ensureForWorkspaceId inserts the injected defaults exactly", async () => {
+  const { knexStub, state } = createKnexStub();
+  state.row = null;
+  const repository = createRepository(knexStub, {
+    defaultInvitesEnabled: false
+  });
+
+  const record = await repository.ensureForWorkspaceId("5");
+
+  assert.equal(state.insertedRow.workspace_id, "5");
+  assert.equal(state.insertedRow.light_primary_color, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(state.insertedRow.light_secondary_color, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(state.insertedRow.light_surface_color, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(
+    state.insertedRow.light_surface_variant_color,
+    DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor
+  );
+  assert.equal(state.insertedRow.dark_primary_color, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(state.insertedRow.dark_secondary_color, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(state.insertedRow.dark_surface_color, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(
+    state.insertedRow.dark_surface_variant_color,
+    DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor
+  );
+  assert.equal(state.insertedRow.invites_enabled, false);
+  assert.equal(record.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(record.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(record.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(record.lightSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor);
+  assert.equal(record.darkPrimaryColor, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(record.darkSecondaryColor, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(record.darkSurfaceColor, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(record.darkSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor);
+  assert.equal(record.invitesEnabled, false);
+  assert.equal(record.workspaceId, "5");
+});
+
+test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates workspace settings columns", async () => {
+  const { knexStub, state } = createKnexStub();
+  const repository = createRepository(knexStub, {
+    defaultInvitesEnabled: true
+  });
+
+  const updated = await repository.updateSettingsByWorkspaceId("1", {
+    lightPrimaryColor: "#123abc"
+  });
+
+  assert.equal(state.updatePayload.light_primary_color, "#123ABC");
+  assert.equal(updated.lightPrimaryColor, "#123ABC");
+});
+
+test("workspaceSettingsRepository can be constructed without validating app config shape", () => {
+  const { knexStub } = createKnexStub();
+
+  const repository = createRepository(knexStub);
+
+  assert.ok(repository);
+});

package/test/workspaceSettingsResource.test.js

@@ -0,0 +1,169 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+import "../test-support/registerDefaultSettingsFields.js";
+import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
+import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
+import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
+
+function createRoleCatalog() {
+  return createWorkspaceRoleCatalog({
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "member"
+      },
+      roles: {
+        owner: {
+          assignable: false,
+          permissions: ["*"]
+        },
+        admin: {
+          assignable: true,
+          permissions: [
+            "workspace.roles.view",
+            "workspace.settings.view",
+            "workspace.settings.update",
+            "workspace.members.view",
+            "workspace.members.invite",
+            "workspace.members.manage",
+            "workspace.invites.revoke"
+          ]
+        },
+        member: {
+          assignable: true,
+          permissions: ["workspace.settings.view"]
+        }
+      }
+    }
+  });
+}
+
+function parseBody(operation, payload = {}) {
+  return validateOperationSection({
+    operation,
+    section: "bodyValidator",
+    value: payload
+  });
+}
+
+test("workspace settings patch body normalizes valid payload before validation", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+    lightPrimaryColor: "#0f6b54",
+    lightSecondaryColor: "#0b4d3c",
+    lightSurfaceColor: "#eef5f3",
+    lightSurfaceVariantColor: "#ddeae7",
+    darkPrimaryColor: "#123456",
+    darkSecondaryColor: "#234567",
+    darkSurfaceColor: "#345678",
+    darkSurfaceVariantColor: "#456789",
+    invitesEnabled: false
+  });
+
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.fieldErrors, {});
+  assert.deepEqual(parsed.value, {
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#0B4D3C",
+    lightSurfaceColor: "#EEF5F3",
+    lightSurfaceVariantColor: "#DDEAE7",
+    darkPrimaryColor: "#123456",
+    darkSecondaryColor: "#234567",
+    darkSurfaceColor: "#345678",
+    darkSurfaceVariantColor: "#456789",
+    invitesEnabled: false
+  });
+});
+
+test("workspace settings patch body ignores unknown fields after normalization", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+    avatarUrl: "https://example.com/avatar.png"
+  });
+
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.fieldErrors, {});
+  assert.deepEqual(parsed.value, {});
+});
+
+test("workspace settings create body requires full-write fields", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.create, {});
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.fieldErrors.lightPrimaryColor, "Light primary color is required.");
+  assert.equal(parsed.fieldErrors.lightSecondaryColor, "Light secondary color is required.");
+  assert.equal(parsed.fieldErrors.lightSurfaceColor, "Light surface color is required.");
+  assert.equal(parsed.fieldErrors.lightSurfaceVariantColor, "Light surface variant color is required.");
+  assert.equal(parsed.fieldErrors.darkPrimaryColor, "Dark primary color is required.");
+  assert.equal(parsed.fieldErrors.darkSecondaryColor, "Dark secondary color is required.");
+  assert.equal(parsed.fieldErrors.darkSurfaceColor, "Dark surface color is required.");
+  assert.equal(parsed.fieldErrors.darkSurfaceVariantColor, "Dark surface variant color is required.");
+  assert.equal(parsed.fieldErrors.invitesEnabled, "invitesEnabled is required.");
+});
+
+test("workspace settings output normalizes raw service payloads", () => {
+  const expectedTheme = resolveWorkspaceThemePalettes({
+    lightPrimaryColor: "#0F6B54"
+  });
+  const normalized = workspaceSettingsResource.operations.view.outputValidator.normalize({
+    workspace: {
+      id: "7",
+      slug: "  mercury  ",
+      ownerUserId: "9"
+    },
+    settings: {
+      lightPrimaryColor: "#0f6b54",
+      invitesEnabled: false
+    },
+    roleCatalog: createRoleCatalog()
+  });
+
+  assert.deepEqual(normalized, {
+    workspace: {
+      id: "7",
+      slug: "mercury",
+      ownerUserId: "9"
+    },
+    settings: {
+      lightPrimaryColor: "#0F6B54",
+      lightSecondaryColor: expectedTheme.light.secondaryColor,
+      lightSurfaceColor: expectedTheme.light.surfaceColor,
+      lightSurfaceVariantColor: expectedTheme.light.surfaceVariantColor,
+      darkPrimaryColor: expectedTheme.dark.color,
+      darkSecondaryColor: expectedTheme.dark.secondaryColor,
+      darkSurfaceColor: expectedTheme.dark.surfaceColor,
+      darkSurfaceVariantColor: expectedTheme.dark.surfaceVariantColor,
+      invitesEnabled: false,
+      invitesAvailable: true,
+      invitesEffective: false
+    },
+    roleCatalog: {
+      collaborationEnabled: true,
+      defaultInviteRole: "member",
+      roles: [
+        {
+          id: "owner",
+          assignable: false,
+          permissions: ["*"]
+        },
+        {
+          id: "admin",
+          assignable: true,
+          permissions: [
+            "workspace.roles.view",
+            "workspace.settings.view",
+            "workspace.settings.update",
+            "workspace.members.view",
+            "workspace.members.invite",
+            "workspace.members.manage",
+            "workspace.invites.revoke"
+          ]
+        },
+        {
+          id: "member",
+          assignable: true,
+          permissions: ["workspace.settings.view"]
+        }
+      ],
+      assignableRoleIds: ["admin", "member"]
+    }
+  });
+});

package/test/workspaceSettingsService.test.js

@@ -0,0 +1,140 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import "../test-support/registerDefaultSettingsFields.js";
+import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
+import { createService } from "../src/server/workspaceSettings/workspaceSettingsService.js";
+
+function authorizedOptions(permissions = []) {
+  return {
+    context: {
+      actor: {
+        id: 1
+      },
+      permissions
+    }
+  };
+}
+
+function createFixture({ workspaceInvitationsEnabled = true } = {}) {
+  const defaultTheme = resolveWorkspaceThemePalettes({
+    lightPrimaryColor: "#0F6B54"
+  });
+  const state = {
+    settingsPatch: null,
+    workspace: {
+      id: 7,
+      slug: "tonymobily3",
+      name: "TonyMobily3",
+      ownerUserId: 9
+    },
+    settings: {
+      lightPrimaryColor: defaultTheme.light.color,
+      lightSecondaryColor: defaultTheme.light.secondaryColor,
+      lightSurfaceColor: defaultTheme.light.surfaceColor,
+      lightSurfaceVariantColor: defaultTheme.light.surfaceVariantColor,
+      darkPrimaryColor: defaultTheme.dark.color,
+      darkSecondaryColor: defaultTheme.dark.secondaryColor,
+      darkSurfaceColor: defaultTheme.dark.surfaceColor,
+      darkSurfaceVariantColor: defaultTheme.dark.surfaceVariantColor,
+      invitesEnabled: true
+    }
+  };
+
+  const service = createService({
+    workspaceInvitationsEnabled,
+    workspaceSettingsRepository: {
+      async ensureForWorkspaceId(workspaceId) {
+        assert.equal(Number(workspaceId), 7);
+        return { ...state.settings };
+      },
+      async updateSettingsByWorkspaceId(workspaceId, patch) {
+        assert.equal(Number(workspaceId), 7);
+        state.settingsPatch = { ...patch };
+        state.settings = {
+          ...state.settings,
+          ...patch
+        };
+        return state.settings;
+      }
+    }
+  });
+
+  return { service, state };
+}
+
+test("workspaceSettingsService.getWorkspaceSettings returns the stored invitesEnabled flag", async () => {
+  const { service, state } = createFixture();
+
+  const response = await service.getWorkspaceSettings(
+    state.workspace,
+    authorizedOptions(["workspace.settings.view"])
+  );
+
+  assert.deepEqual(response.settings, {
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
+    invitesEnabled: true,
+    invitesAvailable: true,
+    invitesEffective: true
+  });
+});
+
+test("workspaceSettingsService.updateWorkspaceSettings writes editable fields through workspaceSettingsRepository only", async () => {
+  const { service, state } = createFixture();
+
+  const response = await service.updateWorkspaceSettings(
+    state.workspace,
+    {
+      invitesEnabled: false
+    },
+    authorizedOptions(["workspace.settings.update"])
+  );
+
+  assert.deepEqual(state.settingsPatch, {
+    invitesEnabled: false
+  });
+  assert.deepEqual(response.settings, {
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
+    invitesEnabled: false,
+    invitesAvailable: true,
+    invitesEffective: false
+  });
+});
+
+test("workspaceSettingsService disables invite settings in output when app policy disables invitations", async () => {
+  const { service, state } = createFixture({
+    workspaceInvitationsEnabled: false
+  });
+
+  const response = await service.getWorkspaceSettings(
+    state.workspace,
+    authorizedOptions(["workspace.settings.view"])
+  );
+
+  assert.deepEqual(response.settings, {
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
+    invitesEnabled: false,
+    invitesAvailable: false,
+    invitesEffective: false
+  });
+});

package/test/workspacesRouteRequestInputValidator.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { UsersCoreServiceProvider } from "../../users-core/src/server/UsersCoreServiceProvider.js";
-import { resolveTenancyProfile } from "../../users-core/src/shared/tenancyProfile.js";
+import { resolveTenancyProfile } from "../src/shared/tenancyProfile.js";
 import { WorkspacesCoreServiceProvider } from "../src/server/WorkspacesCoreServiceProvider.js";
 
 function createReplyDouble() {
@@ -63,10 +63,10 @@ async function registerRoutes({
       }
     ],
     ["actionExecutor", {}],
-    ["users.workspace.enabled", workspaceEnabled],
-    ["users.workspace.tenancy.enabled", workspaceTenancyEnabled],
-    ["users.workspace.invitations.enabled", workspaceInvitationsEnabled],
-    ["users.workspace.self-create.enabled", workspaceSelfCreateEnabled]
+    ["workspaces.enabled", workspaceEnabled],
+    ["workspaces.tenancy.enabled", workspaceTenancyEnabled],
+    ["workspaces.invitations.enabled", workspaceInvitationsEnabled],
+    ["workspaces.self-create.enabled", workspaceSelfCreateEnabled]
   ]);
 
   if (consoleService) {

package/test-support/registerDefaultSettingsFields.js

@@ -0,0 +1 @@
+import "../templates/packages/main/src/shared/resources/workspaceSettingsFields.js";