@jskit-ai/users-core 0.1.4

package/test/workspaceSettingsRepository.test.js

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import "../test-support/registerDefaultSettingsFields.js";
+import { createRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
+
+function createDefaultWorkspaceSettings() {
+  return true;
+}
+
+function createKnexStub(rowOverrides = {}) {
+  const state = {
+    insertedRow: null,
+    updatePayload: null,
+    row: {
+      workspace_id: 1,
+      name: "Workspace",
+      avatar_url: "",
+      color: "#0F6B54",
+      invites_enabled: 1,
+      created_at: "2026-03-09 00:26:35.710",
+      updated_at: "2026-03-09 00:26:35.710",
+      ...rowOverrides
+    }
+  };
+
+  function tableBuilder(tableName) {
+    assert.equal(tableName, "workspace_settings");
+
+    return {
+      insert(payload) {
+        state.insertedRow = { ...payload };
+        state.row = {
+          workspace_id: payload.workspace_id,
+          name: payload.name,
+          avatar_url: payload.avatar_url,
+          color: payload.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, "name")) {
+              state.row.name = payload.name;
+            }
+            if (Object.hasOwn(payload, "avatar_url")) {
+              state.row.avatar_url = payload.avatar_url;
+            }
+            if (Object.hasOwn(payload, "color")) {
+              state.row.color = payload.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,
+    name: "Workspace",
+    avatarUrl: "",
+    color: "#0F6B54",
+    invitesEnabled: true,
+    createdAt: "2026-03-08T16:26:35.710Z",
+    updatedAt: "2026-03-08T16:26:35.710Z"
+  });
+});
+
+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.name, "Workspace");
+  assert.equal(state.insertedRow.avatar_url, "");
+  assert.equal(state.insertedRow.color, "#0F6B54");
+  assert.equal(state.insertedRow.invites_enabled, false);
+  assert.equal(record.name, "Workspace");
+  assert.equal(record.avatarUrl, "");
+  assert.equal(record.color, "#0F6B54");
+  assert.equal(record.invitesEnabled, false);
+});
+
+test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates name/avatar/color columns", async () => {
+  const { knexStub, state } = createKnexStub();
+  const repository = createRepository(knexStub, {
+    defaultInvitesEnabled: true
+  });
+
+  const updated = await repository.updateSettingsByWorkspaceId(1, {
+    name: "New name",
+    avatarUrl: "https://example.com/avatar.png",
+    color: "#123abc"
+  });
+
+  assert.equal(state.updatePayload.name, "New name");
+  assert.equal(state.updatePayload.avatar_url, "https://example.com/avatar.png");
+  assert.equal(state.updatePayload.color, "#123ABC");
+  assert.equal(updated.name, "New name");
+  assert.equal(updated.avatarUrl, "https://example.com/avatar.png");
+  assert.equal(updated.color, "#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,156 @@
+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 { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
+import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
+
+function createRoleCatalog() {
+  return createWorkspaceRoleCatalog({
+    workspaceRoles: {
+      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, {
+    name: "  Team Mercury  ",
+    avatarUrl: "https://example.com/avatar.png",
+    color: "#0f6b54",
+    invitesEnabled: false
+  });
+
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.fieldErrors, {});
+  assert.deepEqual(parsed.value, {
+    name: "Team Mercury",
+    avatarUrl: "https://example.com/avatar.png",
+    color: "#0F6B54",
+    invitesEnabled: false
+  });
+});
+
+test("workspace settings patch body validates avatar URL protocol", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+    avatarUrl: "ftp://example.com/avatar.png"
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(
+    parsed.fieldErrors.avatarUrl,
+    "Workspace avatar URL must be a valid absolute URL (http:// or https://)."
+  );
+});
+
+test("workspace settings patch body keeps max-length name rule", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+    name: "x".repeat(161)
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.fieldErrors.name, "Workspace name must be at most 160 characters.");
+});
+
+test("workspace settings create body requires full-write fields", () => {
+  const parsed = parseBody(workspaceSettingsResource.operations.create, {
+    name: "Mercury Workspace"
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.fieldErrors.color, "Workspace color is required.");
+  assert.equal(parsed.fieldErrors.invitesEnabled, "invitesEnabled is required.");
+});
+
+test("workspace settings output normalizes raw service payloads", () => {
+  const normalized = workspaceSettingsResource.operations.view.outputValidator.normalize({
+    workspace: {
+      id: "7",
+      slug: "  mercury  ",
+      ownerUserId: "9"
+    },
+    settings: {
+      name: "  Mercury Workspace  ",
+      avatarUrl: "  https://example.com/avatar.png  ",
+      color: "#0f6b54",
+      invitesEnabled: false
+    },
+    roleCatalog: createRoleCatalog()
+  });
+
+  assert.deepEqual(normalized, {
+    workspace: {
+      id: 7,
+      slug: "mercury",
+      ownerUserId: 9
+    },
+    settings: {
+      name: "Mercury Workspace",
+      avatarUrl: "https://example.com/avatar.png",
+      color: "#0F6B54",
+      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,120 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import "../test-support/registerDefaultSettingsFields.js";
+import { createService } from "../src/server/workspaceSettings/workspaceSettingsService.js";
+
+function authorizedOptions(permissions = []) {
+  return {
+    context: {
+      actor: {
+        id: 1
+      },
+      permissions
+    }
+  };
+}
+
+function createFixture({ workspaceInvitationsEnabled = true } = {}) {
+  const state = {
+    settingsPatch: null,
+    workspace: {
+      id: 7,
+      slug: "tonymobily3",
+      name: "TonyMobily3",
+      ownerUserId: 9,
+      avatarUrl: "",
+      color: "#0F6B54"
+    },
+    settings: {
+      name: "TonyMobily3",
+      avatarUrl: "",
+      color: "#0F6B54",
+      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, {
+    name: "TonyMobily3",
+    avatarUrl: "",
+    color: "#0F6B54",
+    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,
+    {
+      name: "New Name",
+      invitesEnabled: false
+    },
+    authorizedOptions(["workspace.settings.update"])
+  );
+
+  assert.deepEqual(state.settingsPatch, {
+    name: "New Name",
+    invitesEnabled: false
+  });
+  assert.deepEqual(response.settings, {
+    name: "New Name",
+    avatarUrl: "",
+    color: "#0F6B54",
+    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, {
+    name: "TonyMobily3",
+    avatarUrl: "",
+    color: "#0F6B54",
+    invitesEnabled: false,
+    invitesAvailable: false,
+    invitesEffective: false
+  });
+});

package/test-support/registerDefaultSettingsFields.js

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