@jskit-ai/users-core 0.1.4

package/test/resourcesCanonical.test.js

@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+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];
+  assert.equal(typeof operation, "object", `${label}.operations.${operationName} must exist.`);
+
+  const operationMessages = operation?.messages;
+  const resourceMessages = resource?.messages || resource?.operationMessages;
+  const resolvedMessages =
+    operationMessages && typeof operationMessages === "object"
+      ? operationMessages
+      : resourceMessages;
+
+  assert.equal(
+    typeof resolvedMessages,
+    "object",
+    `${label}.operations.${operationName} must resolve operation messages from operation.messages or resource.messages.`
+  );
+}
+
+test("users-core resources expose messages for all operations", () => {
+  const resources = {
+    workspace: workspaceResource,
+    workspaceSettings: workspaceSettingsResource,
+    userProfile: userProfileResource,
+    userSettings: userSettingsResource,
+    consoleSettings: consoleSettingsResource
+  };
+
+  for (const [label, resource] of Object.entries(resources)) {
+    for (const operationName of ["view", "list", "create", "replace", "patch"]) {
+      assertResourceOperationMessages(resource, operationName, label);
+    }
+  }
+});
+
+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 },
+    { label: "userSettings.passwordMethodToggle", operation: userSettingsResource.operations.passwordMethodToggle },
+    { label: "userSettings.oauthLinkStart", operation: userSettingsResource.operations.oauthLinkStart },
+    { label: "userSettings.oauthUnlink", operation: userSettingsResource.operations.oauthUnlink },
+    { label: "userSettings.logoutOtherSessions", operation: userSettingsResource.operations.logoutOtherSessions }
+  ];
+
+  for (const { label, operation } of operationSpecs) {
+    assert.equal(typeof operation?.messages, "object", `${label}.messages must be an object.`);
+    assert.equal(typeof operation?.outputValidator?.schema, "object", `${label}.outputValidator.schema must exist.`);
+    if (operation?.bodyValidator) {
+      assert.equal(typeof operation.bodyValidator.schema, "object", `${label}.bodyValidator.schema must exist.`);
+    }
+    if (operation?.paramsValidator) {
+      assert.equal(typeof operation.paramsValidator.schema, "object", `${label}.paramsValidator.schema must exist.`);
+    }
+    if (operation?.queryValidator) {
+      assert.equal(typeof operation.queryValidator.schema, "object", `${label}.queryValidator.schema must exist.`);
+    }
+  }
+});
+
+test("users-core no longer contains legacy shared/schema directory", () => {
+  const testFilePath = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(testFilePath), "..");
+  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+});

package/test/roles.test.js

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  createWorkspaceRoleCatalog,
+  cloneWorkspaceRoleCatalog,
+  resolveRolePermissions,
+  hasPermission
+} from "../src/shared/roles.js";
+
+test("createWorkspaceRoleCatalog resolves role descriptors only from appConfig.workspaceRoles", () => {
+  const emptyCatalog = createWorkspaceRoleCatalog();
+  assert.deepEqual(emptyCatalog.roles, []);
+  assert.deepEqual(emptyCatalog.assignableRoleIds, []);
+  assert.equal(emptyCatalog.defaultInviteRole, "");
+  assert.equal(emptyCatalog.collaborationEnabled, false);
+
+  const appConfig = {
+    workspaceRoles: {
+      defaultInviteRole: "editor",
+      roles: {
+        owner: {
+          assignable: false,
+          permissions: ["workspace.settings.update"]
+        },
+        editor: {
+          assignable: true,
+          permissions: ["crud_contacts.*"]
+        }
+      }
+    }
+  };
+  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
+  const editorRole = roleCatalog.roles.find((role) => role.id === "editor");
+
+  assert.equal(roleCatalog.defaultInviteRole, "editor");
+  assert.equal(roleCatalog.assignableRoleIds.includes("editor"), true);
+  assert.deepEqual(resolveRolePermissions("owner", appConfig), ["workspace.settings.update"]);
+  assert.equal(hasPermission(editorRole?.permissions, "crud_contacts.update"), true);
+});
+
+test("cloneWorkspaceRoleCatalog normalizes role ids and returns detached arrays", () => {
+  const source = {
+    collaborationEnabled: true,
+    defaultInviteRole: "member",
+    roles: [
+      {
+        id: " MEMBER ",
+        assignable: true,
+        permissions: ["workspace.members.view"]
+      }
+    ],
+    assignableRoleIds: ["member"]
+  };
+
+  const cloned = cloneWorkspaceRoleCatalog(source);
+  assert.deepEqual(cloned, {
+    collaborationEnabled: true,
+    defaultInviteRole: "member",
+    roles: [
+      {
+        id: "member",
+        assignable: true,
+        permissions: ["workspace.members.view"]
+      }
+    ],
+    assignableRoleIds: ["member"]
+  });
+
+  cloned.roles[0].permissions.push("workspace.members.manage");
+  cloned.assignableRoleIds.push("admin");
+
+  assert.deepEqual(source.roles[0].permissions, ["workspace.members.view"]);
+  assert.deepEqual(source.assignableRoleIds, ["member"]);
+});

package/test/settingsFieldRegistriesSingleton.test.js

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+async function importWithIdentity(url, identity) {
+  return import(`${url.href}?identity=${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);
+});

package/test/tenancyProfile.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspaceTenancyMode
+} from "../src/shared/tenancyProfile.js";
+
+test("resolveTenancyProfile returns mode-specific workspace policy matrix", () => {
+  const noneProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_NONE });
+  assert.deepEqual(noneProfile, {
+    mode: TENANCY_MODE_NONE,
+    workspace: {
+      enabled: false,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_NONE
+    }
+  });
+
+  const personalProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_PERSONAL });
+  assert.deepEqual(personalProfile, {
+    mode: TENANCY_MODE_PERSONAL,
+    workspace: {
+      enabled: true,
+      autoProvision: true,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
+    }
+  });
+
+  const workspaceProfile = resolveTenancyProfile({ tenancyMode: TENANCY_MODE_WORKSPACE });
+  assert.deepEqual(workspaceProfile, {
+    mode: TENANCY_MODE_WORKSPACE,
+    workspace: {
+      enabled: true,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_USER_SELECTED
+    }
+  });
+});
+
+test("isWorkspaceTenancyMode is true only for workspace mode", () => {
+  assert.equal(isWorkspaceTenancyMode(TENANCY_MODE_WORKSPACE), true);
+  assert.equal(isWorkspaceTenancyMode(TENANCY_MODE_PERSONAL), false);
+  assert.equal(isWorkspaceTenancyMode(TENANCY_MODE_NONE), false);
+});
+
+test("resolveTenancyProfile allows explicit workspace self-create policy override", () => {
+  const workspaceProfile = resolveTenancyProfile({
+    tenancyMode: TENANCY_MODE_WORKSPACE,
+    tenancyPolicy: {
+      workspace: {
+        allowSelfCreate: true
+      }
+    }
+  });
+
+  assert.equal(workspaceProfile.mode, TENANCY_MODE_WORKSPACE);
+  assert.equal(workspaceProfile.workspace.allowSelfCreate, true);
+});

package/test/userSettingsResource.test.js

@@ -0,0 +1,31 @@
+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 { userSettingsResource } from "../src/shared/resources/userSettingsResource.js";
+
+function parseBody(operation, payload = {}) {
+  return validateOperationSection({
+    operation,
+    section: "bodyValidator",
+    value: payload
+  });
+}
+
+test("user settings preferences update keeps required string validation after normalization", () => {
+  const parsed = parseBody(userSettingsResource.operations.preferencesUpdate, {
+    theme: "   "
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(typeof parsed.fieldErrors.theme, "string");
+});
+
+test("user settings notifications update rejects non-boolean values", () => {
+  const parsed = parseBody(userSettingsResource.operations.notificationsUpdate, {
+    productUpdates: "yes"
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(typeof parsed.fieldErrors.productUpdates, "string");
+});

package/test/usersApiPaths.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  normalizeSurfaceWorkspaceRequirement,
+  resolveApiBasePath
+} from "../src/shared/support/usersApiPaths.js";
+
+test("normalizeSurfaceWorkspaceRequirement only accepts explicit true", () => {
+  assert.equal(normalizeSurfaceWorkspaceRequirement(true), true);
+  assert.equal(normalizeSurfaceWorkspaceRequirement(false), false);
+  assert.equal(normalizeSurfaceWorkspaceRequirement("true"), false);
+  assert.equal(normalizeSurfaceWorkspaceRequirement(1), false);
+});
+
+test("resolveApiBasePath resolves workspace and non-workspace API base paths", () => {
+  assert.equal(
+    resolveApiBasePath({
+      surfaceRequiresWorkspace: true,
+      relativePath: "/customers"
+    }),
+    "/api/w/:workspaceSlug/workspace/customers"
+  );
+
+  assert.equal(
+    resolveApiBasePath({
+      surfaceRequiresWorkspace: false,
+      relativePath: "/customers"
+    }),
+    "/api/customers"
+  );
+});