@jskit-ai/users-core 0.1.48 → 0.1.49

package/test/workspaceSettingsRepository.test.js

@@ -1,202 +0,0 @@
-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 "../src/shared/settings.js";
-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

@@ -1,169 +0,0 @@
-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 "../src/shared/settings.js";
-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

@@ -1,140 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import "../test-support/registerDefaultSettingsFields.js";
-import { resolveWorkspaceThemePalettes } from "../src/shared/settings.js";
-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
-  });
-});