@jskit-ai/workspaces-web 0.1.14 → 0.1.15

package/test/exportsContract.test.js

@@ -15,7 +15,8 @@ test("workspaces-web exports are explicit and aligned with production usage", ()
     packageId: "@jskit-ai/workspaces-web",
     requiredExports: [
       "./client",
-      "./client/providers/WorkspacesWebClientProvider"
+      "./client/providers/WorkspacesWebClientProvider",
+      "./client/composables/useWorkspaceRouteContext"
     ]
   });
 

package/test/profileSurfaceMenuLinks.test.js

@@ -0,0 +1,208 @@
+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,
+  opsOwner = false
+} = {}) {
+  return {
+    auth: {
+      authenticated
+    },
+    workspace,
+    workspaces,
+    permissions: [],
+    surfaceAccess: {
+      opsowner: opsOwner
+    },
+    surfaceAccessPolicies: {
+      public: {},
+      workspace_member: {
+        requireAuth: true,
+        requireWorkspaceMembership: true
+      },
+      ops_owner: {
+        requireAuth: true,
+        requireFlagsAll: ["ops_owner"]
+      }
+    },
+    surfaceConfig: {
+      tenancyMode: "workspaces",
+      defaultSurfaceId: "app",
+      enabledSurfaceIds: ["home", "app", "admin", "ops"],
+      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"
+        },
+        ops: {
+          id: "ops",
+          enabled: true,
+          pagesRoot: "ops",
+          routeBase: "/ops",
+          requiresAuth: true,
+          requiresWorkspace: false,
+          accessPolicyId: "ops_owner",
+          icon: "mdi-cog-outline"
+        }
+      }
+    }
+  };
+}
+
+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 gated non-workspace switches only for matching access flags", () => {
+  const nonOwnerContext = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ],
+    opsOwner: false
+  });
+  const ownerContext = createPlacementContext({
+    workspace: {
+      id: 1,
+      slug: "acme"
+    },
+    workspaces: [
+      {
+        id: 1,
+        slug: "acme"
+      }
+    ],
+    opsOwner: true
+  });
+
+  const nonOwnerLinks = resolveProfileSurfaceMenuLinks({
+    context: nonOwnerContext,
+    surface: "app"
+  });
+  const ownerLinks = resolveProfileSurfaceMenuLinks({
+    context: ownerContext,
+    surface: "app"
+  });
+
+  assert.equal(nonOwnerLinks.some((entry) => entry.id === "surface-switch.ops"), false);
+  assert.equal(ownerLinks.some((entry) => entry.id === "surface-switch.ops"), true);
+});

package/test/settingsPlacementContract.test.js

@@ -62,7 +62,25 @@ test("workspaces-web descriptor metadata advertises admin settings outlets", ()
       }
     ]
   );
-  assert.equal(findContribution("users.workspace.settings.general"), null);
+  assert.equal(findContribution("workspaces.workspace.settings.general"), null);
+  assert.deepEqual(findContribution("workspaces.profile.menu.surface-switch"), {
+    id: "workspaces.profile.menu.surface-switch",
+    target: "auth-profile-menu:primary-menu",
+    surfaces: ["*"],
+    order: 100,
+    componentToken: "workspaces.web.profile.menu.surface-switch-item",
+    when: "auth.authenticated === true",
+    source: "mutations.text#workspaces-web-profile-surface-switch-placement"
+  });
+  assert.deepEqual(findContribution("workspaces.workspace.selector"), {
+    id: "workspaces.workspace.selector",
+    target: "shell-layout:top-left",
+    surfaces: ["*"],
+    order: 200,
+    componentToken: "workspaces.web.workspace.selector",
+    when: "auth.authenticated === true",
+    source: "mutations.text#workspaces-web-placement-block"
+  });
   assert.deepEqual(findFileMutation("users-web-page-admin-workspace-settings"), {
     from: "templates/src/pages/admin/workspace/settings/index.vue",
     toSurface: "admin",

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: {
+      opsowner: false
+    },
+    surfaceAccessPolicies: {
+      public: {},
+      workspace_member: {
+        requireAuth: true,
+        requireWorkspaceMembership: true
+      },
+      ops_owner: {
+        requireAuth: true,
+        requireFlagsAll: ["ops_owner"]
+      }
+    },
+    surfaceConfig: {
+      defaultSurfaceId: "home",
+      enabledSurfaceIds: ["home", "app", "ops"],
+      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"
+        },
+        ops: {
+          id: "ops",
+          enabled: true,
+          routeBase: "/ops",
+          requiresWorkspace: false,
+          accessPolicyId: "ops_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: "ops"
+  });
+  assert.equal(deniedDecision.allowed, false);
+
+  const allowedDecision = evaluateSurfaceAccess({
+    context: createContext({
+      surfaceAccess: {
+        opsowner: true
+      }
+    }),
+    surfaceId: "ops"
+  });
+  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,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ThemeSymbol } from "vuetify/lib/composables/theme.js";
+import { resolveWorkspaceThemePalette } from "@jskit-ai/workspaces-core/shared/settings";
+import {
+  hexColorToRgb,
+  setVuetifyPrimaryColorOverride,
+  setVuetifyThemeName
+} from "../src/client/lib/theme.js";
+
+function createVuetifyThemeController(initialTheme = "light") {
+  return {
+    global: {
+      name: {
+        value: initialTheme
+      }
+    },
+    themes: {
+      value: {
+        light: {
+          dark: false,
+          colors: {
+            primary: "#0f6b54",
+            secondary: "#3f5150",
+            background: "#eef3ee",
+            surface: "#f7fbf6",
+            "surface-variant": "#dfe8df"
+          }
+        },
+        dark: {
+          dark: true,
+          colors: {
+            primary: "#6fd0b5",
+            secondary: "#9db2af",
+            background: "#0f1715",
+            surface: "#16211e",
+            "surface-variant": "#253430"
+          }
+        }
+      }
+    },
+    _context: {
+      provides: {
+        [ThemeSymbol]: null
+      }
+    }
+  };
+}
+
+test("hexColorToRgb returns Vuetify rgb tuple and rejects invalid values", () => {
+  assert.equal(hexColorToRgb("#0f6b54"), "15,107,84");
+  assert.equal(hexColorToRgb("#CC3344"), "204,51,68");
+  assert.equal(hexColorToRgb("invalid"), "");
+});
+
+test("setVuetifyPrimaryColorOverride mutates workspace themes and restores base theme names", () => {
+  const themeController = createVuetifyThemeController("light");
+  const themeInput = {
+    lightPrimaryColor: "#CC3344",
+    lightSecondaryColor: "#884455",
+    lightSurfaceColor: "#F4F4F4",
+    lightSurfaceVariantColor: "#444444",
+    darkPrimaryColor: "#BB2233",
+    darkSecondaryColor: "#557799",
+    darkSurfaceColor: "#202020",
+    darkSurfaceVariantColor: "#A0A0A0"
+  };
+  const expectedLightPalette = resolveWorkspaceThemePalette(themeInput, {
+    mode: "light"
+  });
+  const expectedDarkPalette = resolveWorkspaceThemePalette(themeInput, {
+    mode: "dark"
+  });
+
+  assert.equal(setVuetifyPrimaryColorOverride(themeController, themeInput), true);
+  assert.equal(themeController.global.name.value, "workspace-light");
+  assert.equal(themeController.themes.value["workspace-light"].colors.primary, expectedLightPalette.color);
+  assert.equal(themeController.themes.value["workspace-light"].colors.secondary, expectedLightPalette.secondaryColor);
+  assert.equal(themeController.themes.value["workspace-light"].colors.surface, expectedLightPalette.surfaceColor);
+  assert.equal(
+    themeController.themes.value["workspace-light"].colors["surface-variant"],
+    expectedLightPalette.surfaceVariantColor
+  );
+
+  assert.equal(setVuetifyPrimaryColorOverride(themeController, themeInput), false);
+
+  assert.equal(setVuetifyThemeName(themeController, "dark"), true);
+  assert.equal(setVuetifyPrimaryColorOverride(themeController, themeInput), true);
+  assert.equal(themeController.global.name.value, "workspace-dark");
+  assert.equal(themeController.themes.value["workspace-dark"].colors.primary, expectedDarkPalette.color);
+  assert.equal(themeController.themes.value["workspace-dark"].colors.secondary, expectedDarkPalette.secondaryColor);
+  assert.equal(themeController.themes.value["workspace-dark"].colors.surface, expectedDarkPalette.surfaceColor);
+  assert.equal(
+    themeController.themes.value["workspace-dark"].colors["surface-variant"],
+    expectedDarkPalette.surfaceVariantColor
+  );
+
+  assert.equal(setVuetifyPrimaryColorOverride(themeController, null), true);
+  assert.equal(themeController.global.name.value, "dark");
+  assert.equal(setVuetifyPrimaryColorOverride(themeController, null), false);
+});

package/test/workspaceLinkResolver.test.js

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveWorkspaceShellLinkPath } from "../src/client/lib/workspaceLinkResolver.js";
+
+function createContext({ defaultSurfaceId = "dashboard", enabledSurfaceIds = ["dashboard"], surfacesById = {} } = {}) {
+  return {
+    surfaceConfig: {
+      defaultSurfaceId,
+      enabledSurfaceIds,
+      surfacesById
+    }
+  };
+}
+
+test("resolveWorkspaceShellLinkPath resolves workspace path for known workspace surfaces", () => {
+  const context = {
+    surfaceConfig: {
+      defaultSurfaceId: "dashboard",
+      enabledSurfaceIds: ["dashboard"],
+      surfacesById: {
+        dashboard: {
+          routeBase: "/dashboard",
+          requiresWorkspace: true
+        }
+      }
+    }
+  };
+
+  const path = resolveWorkspaceShellLinkPath({
+    context,
+    surface: "dashboard",
+    mode: "workspace",
+    workspaceSlug: "acme"
+  });
+
+  assert.equal(path, "/w/acme");
+});
+
+test("resolveWorkspaceShellLinkPath returns empty path for unknown non-default workspace surface", () => {
+  const context = createContext();
+  const path = resolveWorkspaceShellLinkPath({
+    context,
+    surface: "admin",
+    mode: "workspace",
+    workspaceSlug: "acme"
+  });
+
+  assert.equal(path, "");
+});
+
+test("resolveWorkspaceShellLinkPath returns empty path for unknown non-workspace surface ids", () => {
+  const context = createContext();
+  const path = resolveWorkspaceShellLinkPath({
+    context,
+    surface: "ops",
+    mode: "workspace",
+    workspaceSlug: "acme"
+  });
+
+  assert.equal(path, "");
+});

package/test/workspaceSurfacePaths.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  resolveAccountSettingsPathFromPlacementContext,
+  resolveSurfaceWorkspacePathFromPlacementContext
+} from "../src/client/lib/workspaceSurfacePaths.js";
+
+test("resolveSurfaceWorkspacePathFromPlacementContext returns empty path without workspace slug", () => {
+  const context = {
+    surfaceConfig: {
+      defaultSurfaceId: "home",
+      enabledSurfaceIds: ["home", "app", "admin", "ops"],
+      surfacesById: {
+        home: { id: "home", routeBase: "/home", requiresWorkspace: false },
+        app: { id: "app", routeBase: "/w/:workspaceSlug", requiresWorkspace: true },
+        admin: { id: "admin", routeBase: "/w/:workspaceSlug/admin", requiresWorkspace: true },
+        ops: { id: "ops", routeBase: "/ops", requiresWorkspace: false }
+      }
+    }
+  };
+
+  assert.equal(resolveSurfaceWorkspacePathFromPlacementContext(context, "app", "", "/"), "");
+});
+
+test("resolveAccountSettingsPathFromPlacementContext uses account surface route when available", () => {
+  const context = {
+    surfaceConfig: {
+      defaultSurfaceId: "home",
+      enabledSurfaceIds: ["home", "account"],
+      surfacesById: {
+        home: { id: "home", routeBase: "/home", requiresWorkspace: false },
+        account: { id: "account", routeBase: "/profile", requiresWorkspace: false }
+      }
+    }
+  };
+
+  assert.equal(resolveAccountSettingsPathFromPlacementContext(context), "/profile");
+});