@jskit-ai/users-web 0.1.4

package/test/errorMessageHelpers.test.js

@@ -0,0 +1,28 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/errorMessageHelpers.js";
+
+test("toQueryErrorMessage returns empty when query has no error", () => {
+  assert.equal(toQueryErrorMessage(null, "Unable to load list."), "");
+});
+
+test("toQueryErrorMessage resolves specific runtime error messages before fallback", () => {
+  assert.equal(toQueryErrorMessage({ message: "Network timeout" }, "Unable to load list."), "Network timeout");
+  assert.equal(toQueryErrorMessage({}, "Unable to load list."), "Unable to load list.");
+});
+
+test("toQueryErrorMessage prefers fallback for generic transport messages", () => {
+  assert.equal(
+    toQueryErrorMessage({ status: 500, message: "Request failed with status 500." }, "Unable to load list."),
+    "Unable to load list."
+  );
+  assert.equal(
+    toQueryErrorMessage({ status: 0, message: "Network request failed." }, "Unable to load list."),
+    "Unable to load list."
+  );
+});
+
+test("toUiErrorMessage prefers fallback copy before runtime error text", () => {
+  assert.equal(toUiErrorMessage({ message: "Server exploded" }, "Unable to save."), "Unable to save.");
+  assert.equal(toUiErrorMessage({ message: "Server exploded" }, ""), "Server exploded");
+});

package/test/exportsContract.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { evaluatePackageExportsContract } from "../../../tooling/test-support/exportsContract.mjs";
+
+const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(TEST_DIRECTORY, "..", "..", "..");
+const PACKAGE_DIR = path.join(REPO_ROOT, "packages", "users-web");
+
+test("users-web exports are explicit and aligned with production/template usage", () => {
+  const result = evaluatePackageExportsContract({
+    repoRoot: REPO_ROOT,
+    packageDir: PACKAGE_DIR,
+    packageId: "@jskit-ai/users-web",
+    requiredExports: ["./client"]
+  });
+
+  assert.deepEqual(
+    result.wildcardExports,
+    [],
+    `users-web exports must be explicit. Remove wildcard keys: ${result.wildcardExports.join(", ")}`
+  );
+  assert.deepEqual(
+    result.missingRequiredExports,
+    [],
+    `users-web required exports missing: ${result.missingRequiredExports.join(", ")}`
+  );
+  assert.deepEqual(
+    result.missingExports,
+    [],
+    `users-web imports missing from package exports:\n${result.missingExports.join("\n")}`
+  );
+  assert.deepEqual(
+    result.staleExports,
+    [],
+    `Stale users-web exports found. Remove stale keys: ${result.staleExports.join(", ")}`
+  );
+});

package/test/menuIcons.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  mdiAccountCogOutline,
+  mdiConsoleNetworkOutline,
+  mdiCogOutline,
+  mdiFolderOutline,
+  mdiLogin,
+  mdiShieldCrownOutline,
+  mdiViewDashboardOutline,
+  mdiViewListOutline
+} from "@mdi/js";
+import {
+  resolveMenuLinkIcon,
+  resolveSurfaceSwitchIcon
+} from "../src/client/lib/menuIcons.js";
+
+test("resolveSurfaceSwitchIcon prefers explicit icon and maps known surfaces", () => {
+  assert.equal(resolveSurfaceSwitchIcon("admin"), mdiShieldCrownOutline);
+  assert.equal(resolveSurfaceSwitchIcon("console"), mdiConsoleNetworkOutline);
+  assert.equal(resolveSurfaceSwitchIcon("admin", "custom-icon"), "custom-icon");
+});
+
+test("resolveMenuLinkIcon resolves settings/login fallbacks and generic default", () => {
+  assert.equal(resolveMenuLinkIcon({ to: "/account" }), mdiAccountCogOutline);
+  assert.equal(resolveMenuLinkIcon({ label: "Sign in" }), mdiLogin);
+  assert.equal(resolveMenuLinkIcon({ label: "Go to admin" }), mdiShieldCrownOutline);
+  assert.equal(resolveMenuLinkIcon({ label: "Workspace", to: "/w/acme" }), mdiViewDashboardOutline);
+  assert.equal(resolveMenuLinkIcon({ to: "/projects" }), mdiFolderOutline);
+  assert.equal(resolveMenuLinkIcon({ label: "Settings", to: "/workspace/settings" }), mdiCogOutline);
+  assert.equal(resolveMenuLinkIcon({ label: "Anything else", to: "/foo" }), mdiFolderOutline);
+  assert.equal(resolveMenuLinkIcon({ label: "Anything else" }), mdiViewListOutline);
+});

package/test/permissions.test.js

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { arePermissionListsEqual, hasPermission, normalizePermissionList } from "../src/client/lib/permissions.js";
+
+test("normalizePermissionList trims, removes duplicates, and ignores empty entries", () => {
+  assert.deepEqual(
+    normalizePermissionList([" workspace.settings.view ", "", null, "workspace.settings.view", "workspace.members.view"]),
+    ["workspace.settings.view", "workspace.members.view"]
+  );
+});
+
+test("arePermissionListsEqual compares permission sets regardless of order or duplicates", () => {
+  assert.equal(
+    arePermissionListsEqual(
+      ["workspace.settings.view", "workspace.members.view", "workspace.settings.view"],
+      ["workspace.members.view", "workspace.settings.view"]
+    ),
+    true
+  );
+});
+
+test("arePermissionListsEqual returns false for different permission sets", () => {
+  assert.equal(
+    arePermissionListsEqual(
+      ["workspace.settings.view"],
+      ["workspace.members.view"]
+    ),
+    false
+  );
+});
+
+test("hasPermission supports namespace wildcard matches", () => {
+  assert.equal(hasPermission(["crud_contacts.*"], "crud_contacts.update"), true);
+  assert.equal(hasPermission(["crud_contacts.*"], "crud_projects.update"), false);
+});

package/test/profileSurfaceMenuLinks.test.js

@@ -0,0 +1,207 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mdiShieldCrownOutline } from "@mdi/js";
+import {
+  hasWorkspaceMembership,
+  resolvePrimarySurfaceSwitchLink,
+  resolveProfileSurfaceMenuLinks
+} from "../src/client/lib/profileSurfaceMenuLinks.js";
+
+function createPlacementContext({
+  workspace = null,
+  workspaces = [],
+  authenticated = true,
+  consoleOwner = false
+} = {}) {
+  return {
+    auth: {
+      authenticated
+    },
+    workspace,
+    workspaces,
+    permissions: [],
+    surfaceAccess: {
+      consoleowner: consoleOwner
+    },
+    surfaceAccessPolicies: {
+      public: {},
+      workspace_member: {
+        requireAuth: true,
+        requireWorkspaceMembership: true
+      },
+      console_owner: {
+        requireAuth: true,
+        requireFlagsAll: ["console_owner"]
+      }
+    },
+    surfaceConfig: {
+      tenancyMode: "workspace",
+      defaultSurfaceId: "app",
+      enabledSurfaceIds: ["home", "app", "admin", "console"],
+      surfacesById: {
+        home: {
+          id: "home",
+          enabled: true,
+          pagesRoot: "",
+          routeBase: "/",
+          requiresAuth: false,
+          requiresWorkspace: false,
+          accessPolicyId: "public"
+        },
+        app: {
+          id: "app",
+          enabled: true,
+          pagesRoot: "w/[workspaceSlug]",
+          routeBase: "/w/:workspaceSlug",
+          requiresAuth: true,
+          requiresWorkspace: true,
+          accessPolicyId: "workspace_member"
+        },
+        admin: {
+          id: "admin",
+          enabled: true,
+          pagesRoot: "w/[workspaceSlug]/admin",
+          routeBase: "/w/:workspaceSlug/admin",
+          requiresAuth: true,
+          requiresWorkspace: true,
+          accessPolicyId: "workspace_member"
+        },
+        console: {
+          id: "console",
+          enabled: true,
+          pagesRoot: "console",
+          routeBase: "/console",
+          requiresAuth: true,
+          requiresWorkspace: false,
+          accessPolicyId: "console_owner"
+        }
+      }
+    }
+  };
+}
+
+const originalWindow = globalThis.window;
+
+test.afterEach(() => {
+  if (typeof originalWindow === "undefined") {
+    delete globalThis.window;
+    return;
+  }
+  globalThis.window = originalWindow;
+});
+
+test("hasWorkspaceMembership matches context.workspace slug", () => {
+  const context = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: []
+  });
+
+  assert.equal(hasWorkspaceMembership(context, "acme"), true);
+});
+
+test("hasWorkspaceMembership matches context.workspaces slug", () => {
+  const context = createPlacementContext({
+    workspace: null,
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ]
+  });
+
+  assert.equal(hasWorkspaceMembership(context, "acme"), true);
+});
+
+test("resolvePrimarySurfaceSwitchLink shows Go to admin only for member workspace", () => {
+  const context = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ]
+  });
+
+  const link = resolvePrimarySurfaceSwitchLink({
+    context,
+    surface: "app"
+  });
+
+  assert.deepEqual(link, {
+    id: "surface-switch.admin",
+    label: "Go to admin",
+    icon: mdiShieldCrownOutline,
+    to: "/w/acme/admin"
+  });
+});
+
+test("resolvePrimarySurfaceSwitchLink hides workspace switch when slug is only in URL and user is not member", () => {
+  globalThis.window = {
+    location: {
+      pathname: "/w/acme/admin",
+      search: "",
+      hash: ""
+    }
+  };
+
+  const context = createPlacementContext({
+    workspace: null,
+    workspaces: []
+  });
+
+  const link = resolvePrimarySurfaceSwitchLink({
+    context,
+    surface: "admin"
+  });
+
+  assert.equal(link, null);
+});
+
+test("resolveProfileSurfaceMenuLinks includes console switch only for console owners", () => {
+  const nonOwnerContext = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ],
+    consoleOwner: false
+  });
+  const ownerContext = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ],
+    consoleOwner: true
+  });
+
+  const nonOwnerLinks = resolveProfileSurfaceMenuLinks({
+    context: nonOwnerContext,
+    surface: "app"
+  });
+  const ownerLinks = resolveProfileSurfaceMenuLinks({
+    context: ownerContext,
+    surface: "app"
+  });
+
+  assert.equal(nonOwnerLinks.some((entry) => entry.id === "surface-switch.console"), false);
+  assert.equal(ownerLinks.some((entry) => entry.id === "surface-switch.console"), true);
+});

package/test/refValueHelpers.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { computed, ref } from "vue";
+import { resolveEnabledRef } from "../src/client/composables/refValueHelpers.js";
+
+test("resolveEnabledRef unwraps refs", () => {
+  assert.equal(resolveEnabledRef(ref(true)), true);
+  assert.equal(resolveEnabledRef(computed(() => false)), false);
+});
+
+test("resolveEnabledRef executes callable enabled values", () => {
+  assert.equal(resolveEnabledRef(() => true), true);
+  assert.equal(resolveEnabledRef(() => false), false);
+});

package/test/scopeHelpers.test.js

@@ -0,0 +1,57 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { computed } from "vue";
+import {
+  isWorkspaceOwnershipFilter,
+  normalizeOwnershipFilter,
+  resolveApiSuffix,
+  resolveResourceMessages
+} from "../src/client/composables/scopeHelpers.js";
+
+test("resolveResourceMessages merges defaults with resource messages", () => {
+  const messages = resolveResourceMessages(
+    {
+      messages: {
+        saveError: "Unable to update workspace settings.",
+        saveSuccess: "Workspace settings updated."
+      }
+    },
+    {
+      validation: "Fix invalid values and try again.",
+      saveSuccess: "Saved.",
+      saveError: "Unable to save."
+    }
+  );
+
+  assert.deepEqual(messages, {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Workspace settings updated.",
+    saveError: "Unable to update workspace settings."
+  });
+});
+
+test("resolveApiSuffix unwraps computed refs", () => {
+  const suffix = computed(() => "/customers/42");
+
+  assert.equal(resolveApiSuffix(suffix), "/customers/42");
+});
+
+test("resolveApiSuffix unwraps function-returned computed refs", () => {
+  const suffix = computed(() => "/customers/42");
+
+  assert.equal(resolveApiSuffix(() => suffix), "/customers/42");
+});
+
+test("normalizeOwnershipFilter accepts users visibility levels", () => {
+  assert.equal(normalizeOwnershipFilter("public"), "public");
+  assert.equal(normalizeOwnershipFilter("workspace"), "workspace");
+  assert.equal(normalizeOwnershipFilter("user"), "user");
+  assert.equal(normalizeOwnershipFilter("workspace_user"), "workspace_user");
+});
+
+test("isWorkspaceOwnershipFilter only matches workspace-scoped ownership levels", () => {
+  assert.equal(isWorkspaceOwnershipFilter("workspace"), true);
+  assert.equal(isWorkspaceOwnershipFilter("workspace_user"), true);
+  assert.equal(isWorkspaceOwnershipFilter("public"), false);
+  assert.equal(isWorkspaceOwnershipFilter("user"), false);
+});

package/test/surfaceAccessPolicy.test.js

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { evaluateSurfaceAccess } from "../src/client/lib/surfaceAccessPolicy.js";
+
+function createContext(overrides = {}) {
+  return {
+    auth: {
+      authenticated: true
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ],
+    permissions: [],
+    surfaceAccess: {
+      consoleowner: false
+    },
+    surfaceAccessPolicies: {
+      public: {},
+      workspace_member: {
+        requireAuth: true,
+        requireWorkspaceMembership: true
+      },
+      console_owner: {
+        requireAuth: true,
+        requireFlagsAll: ["console_owner"]
+      }
+    },
+    surfaceConfig: {
+      defaultSurfaceId: "home",
+      enabledSurfaceIds: ["home", "app", "console"],
+      surfacesById: {
+        home: {
+          id: "home",
+          enabled: true,
+          routeBase: "/home",
+          requiresWorkspace: false,
+          accessPolicyId: "public"
+        },
+        app: {
+          id: "app",
+          enabled: true,
+          routeBase: "/w/:workspaceSlug",
+          requiresWorkspace: true,
+          accessPolicyId: "workspace_member"
+        },
+        console: {
+          id: "console",
+          enabled: true,
+          routeBase: "/console",
+          requiresWorkspace: false,
+          accessPolicyId: "console_owner"
+        }
+      }
+    },
+    ...overrides
+  };
+}
+
+test("evaluateSurfaceAccess allows workspace member surfaces for accessible workspace", () => {
+  const decision = evaluateSurfaceAccess({
+    context: createContext(),
+    surfaceId: "app",
+    workspaceSlug: "acme"
+  });
+
+  assert.equal(decision.allowed, true);
+});
+
+test("evaluateSurfaceAccess denies workspace member surfaces for inaccessible workspace", () => {
+  const decision = evaluateSurfaceAccess({
+    context: createContext(),
+    surfaceId: "app",
+    workspaceSlug: "missing"
+  });
+
+  assert.equal(decision.allowed, false);
+  assert.equal(decision.reason, "surface-access-workspace-membership-required");
+});
+
+test("evaluateSurfaceAccess allows unknown workspace membership when allowOnUnknown=true", () => {
+  const context = createContext();
+  delete context.workspaces;
+
+  const decision = evaluateSurfaceAccess({
+    context,
+    surfaceId: "app",
+    workspaceSlug: "acme",
+    allowOnUnknown: true
+  });
+
+  assert.equal(decision.allowed, true);
+  assert.equal(decision.pending, true);
+});
+
+test("evaluateSurfaceAccess enforces bootstrap surface access flags", () => {
+  const deniedDecision = evaluateSurfaceAccess({
+    context: createContext(),
+    surfaceId: "console"
+  });
+  assert.equal(deniedDecision.allowed, false);
+
+  const allowedDecision = evaluateSurfaceAccess({
+    context: createContext({
+      surfaceAccess: {
+        consoleowner: true
+      }
+    }),
+    surfaceId: "console"
+  });
+  assert.equal(allowedDecision.allowed, true);
+});
+
+test("evaluateSurfaceAccess denies workspace route with not_found status", () => {
+  const decision = evaluateSurfaceAccess({
+    context: createContext({
+      workspaceBootstrapStatuses: {
+        acme: "not_found"
+      }
+    }),
+    surfaceId: "app",
+    workspaceSlug: "acme"
+  });
+
+  assert.equal(decision.allowed, false);
+  assert.equal(decision.reason, "surface-access-workspace-not-found");
+});

package/test/theme.test.js

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ThemeSymbol } from "vuetify/lib/composables/theme.js";
+import {
+  normalizeThemePreference,
+  resolveThemeNameForPreference,
+  resolveBootstrapThemeName,
+  resolveVuetifyThemeController,
+  setVuetifyThemeName
+} from "../src/client/lib/theme.js";
+
+test("normalizeThemePreference accepts known preferences and falls back to system", () => {
+  assert.equal(normalizeThemePreference("light"), "light");
+  assert.equal(normalizeThemePreference(" DARK "), "dark");
+  assert.equal(normalizeThemePreference("system"), "system");
+  assert.equal(normalizeThemePreference("unknown"), "system");
+});
+
+test("resolveThemeNameForPreference resolves system using explicit prefersDark", () => {
+  assert.equal(resolveThemeNameForPreference("system", { prefersDark: true }), "dark");
+  assert.equal(resolveThemeNameForPreference("system", { prefersDark: false }), "light");
+  assert.equal(resolveThemeNameForPreference("dark", { prefersDark: false }), "dark");
+  assert.equal(resolveThemeNameForPreference("light", { prefersDark: true }), "light");
+});
+
+test("resolveBootstrapThemeName keeps unauthenticated payload in light theme", () => {
+  assert.equal(
+    resolveBootstrapThemeName(
+      {
+        session: { authenticated: false },
+        userSettings: { theme: "dark" }
+      },
+      { prefersDark: true }
+    ),
+    "light"
+  );
+});
+
+test("resolveBootstrapThemeName uses authenticated user preference", () => {
+  assert.equal(
+    resolveBootstrapThemeName(
+      {
+        session: { authenticated: true },
+        userSettings: { theme: "dark" }
+      },
+      { prefersDark: false }
+    ),
+    "dark"
+  );
+  assert.equal(
+    resolveBootstrapThemeName(
+      {
+        session: { authenticated: true },
+        userSettings: { theme: "system" }
+      },
+      { prefersDark: true }
+    ),
+    "dark"
+  );
+});
+
+test("resolveVuetifyThemeController reads theme controller from Vue app provides", () => {
+  const themeController = {
+    global: {
+      name: {
+        value: "light"
+      }
+    }
+  };
+  const vueApp = {
+    _context: {
+      provides: {
+        [ThemeSymbol]: themeController
+      }
+    }
+  };
+
+  assert.equal(resolveVuetifyThemeController(vueApp), themeController);
+  assert.equal(resolveVuetifyThemeController({ _context: { provides: {} } }), null);
+});
+
+test("setVuetifyThemeName updates only when the value changes", () => {
+  const themeController = {
+    global: {
+      name: {
+        value: "light"
+      }
+    }
+  };
+
+  assert.equal(setVuetifyThemeName(themeController, "light"), false);
+  assert.equal(setVuetifyThemeName(themeController, "dark"), true);
+  assert.equal(themeController.global.name.value, "dark");
+});
+