@jskit-ai/users-core 0.1.48 → 0.1.50

package/test/usersVisibility.test.js

@@ -1,27 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  isWorkspaceVisibility,
-  checkRouteVisibility
-} from "../src/shared/support/usersVisibility.js";
-
-test("checkRouteVisibility normalizes valid users visibility levels and throws on invalid input", () => {
-  assert.equal(checkRouteVisibility("WORKSPACE"), "workspace");
-  assert.equal(checkRouteVisibility("workspace_user"), "workspace_user");
-  assert.equal(checkRouteVisibility("user"), "user");
-  assert.throws(
-    () => checkRouteVisibility(""),
-    /must be one of/
-  );
-  assert.throws(
-    () => checkRouteVisibility("unknown"),
-    /must be one of/
-  );
-});
-
-test("isWorkspaceVisibility recognizes workspace-only visibility levels", () => {
-  assert.equal(isWorkspaceVisibility("workspace"), true);
-  assert.equal(isWorkspaceVisibility("workspace_user"), true);
-  assert.equal(isWorkspaceVisibility("public"), false);
-  assert.equal(isWorkspaceVisibility("user"), false);
-});

package/test/workspaceActionContextContributor.test.js

@@ -1,344 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createWorkspaceActionContextContributor } from "../src/server/common/contributors/workspaceActionContextContributor.js";
-
-test("workspace action context contributor resolves workspace context for workspace actions", async () => {
-  const calls = [];
-  const contributor = createWorkspaceActionContextContributor({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options) {
-        calls.push({
-          user,
-          workspaceSlug,
-          options
-        });
-
-        return {
-          workspace: {
-            id: 10,
-            slug: "acme"
-          },
-          membership: {
-            roleSid: "owner"
-          },
-          permissions: ["workspace.settings.update"]
-        };
-      }
-    },
-    workspaceSurfaceIds: ["admin", "app"]
-  });
-
-  const request = {
-    user: {
-      id: 42,
-      email: "user@example.com"
-    }
-  };
-
-  const contribution = await contributor.contribute({
-    definition: {
-      id: "workspace.settings.update",
-      surfaces: ["admin", "app"]
-    },
-    input: {
-      workspaceSlug: "Acme"
-    },
-    context: {
-      requestMeta: {
-        request
-      }
-    },
-    request
-  });
-
-  assert.deepEqual(calls, [
-    {
-      user: request.user,
-      workspaceSlug: "Acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(contribution, {
-    requestMeta: {
-      resolvedWorkspaceContext: {
-        workspace: {
-          id: 10,
-          slug: "acme"
-        },
-        membership: {
-          roleSid: "owner"
-        },
-        permissions: ["workspace.settings.update"]
-      }
-    },
-    workspace: {
-      id: 10,
-      slug: "acme"
-    },
-    membership: {
-      roleSid: "owner"
-    },
-    permissions: ["workspace.settings.update"]
-  });
-});
-
-test("workspace action context contributor ignores actions that do not require workspace context", async () => {
-  const contributor = createWorkspaceActionContextContributor({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug() {
-        throw new Error("should not be called");
-      }
-    }
-  });
-
-  const contribution = await contributor.contribute({
-    actionId: "workspace.workspaces.list",
-    input: {
-      workspaceSlug: "acme"
-    },
-    context: {}
-  });
-
-  assert.deepEqual(contribution, {});
-});
-
-test("workspace action context contributor always resolves and stores resolved context", async () => {
-  const calls = [];
-  const contributor = createWorkspaceActionContextContributor({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options) {
-        calls.push({ user, workspaceSlug, options });
-        return {
-          workspace: {
-            id: 10,
-            slug: "acme",
-            ownerUserId: 77
-          },
-          membership: {
-            roleSid: "owner"
-          },
-          permissions: ["workspace.settings.update"]
-        };
-      }
-    },
-    workspaceSurfaceIds: ["admin", "app"]
-  });
-
-  const request = {
-    user: {
-      id: 42
-    }
-  };
-
-  const contribution = await contributor.contribute({
-    definition: {
-      id: "workspace.members.list",
-      surfaces: ["admin", "app"]
-    },
-    input: {
-      workspaceSlug: "acme"
-    },
-    context: {
-      workspace: {
-        id: 1
-      },
-      requestMeta: {
-        request
-      }
-    },
-    request
-  });
-
-  assert.deepEqual(calls, [
-    {
-      user: request.user,
-      workspaceSlug: "acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(contribution, {
-    requestMeta: {
-      resolvedWorkspaceContext: {
-        workspace: {
-          id: 10,
-          slug: "acme",
-          ownerUserId: 77
-        },
-        membership: {
-          roleSid: "owner"
-        },
-        permissions: ["workspace.settings.update"]
-      }
-    },
-    membership: {
-      roleSid: "owner"
-    },
-    permissions: ["workspace.settings.update"]
-  });
-});
-
-test("workspace action context contributor resolves context for workspace-visible routes outside legacy action list", async () => {
-  const calls = [];
-  const contributor = createWorkspaceActionContextContributor({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options) {
-        calls.push({ user, workspaceSlug, options });
-        return {
-          workspace: {
-            id: 33,
-            slug: "acme"
-          },
-          membership: {
-            roleSid: "admin"
-          },
-          permissions: ["assistant.chat.use"]
-        };
-      }
-    }
-  });
-
-  const request = {
-    user: {
-      id: 42
-    },
-    routeOptions: {
-      config: {
-        visibility: "workspace"
-      }
-    }
-  };
-
-  const contribution = await contributor.contribute({
-    definition: {
-      id: "assistant.conversations.list",
-      surfaces: ["admin"]
-    },
-    input: {
-      workspaceSlug: "acme"
-    },
-    context: {
-      requestMeta: {
-        request
-      }
-    },
-    request
-  });
-
-  assert.deepEqual(calls, [
-    {
-      user: request.user,
-      workspaceSlug: "acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(contribution, {
-    requestMeta: {
-      resolvedWorkspaceContext: {
-        workspace: {
-          id: 33,
-          slug: "acme"
-        },
-        membership: {
-          roleSid: "admin"
-        },
-        permissions: ["assistant.chat.use"]
-      }
-    },
-    workspace: {
-      id: 33,
-      slug: "acme"
-    },
-    membership: {
-      roleSid: "admin"
-    },
-    permissions: ["assistant.chat.use"]
-  });
-});
-
-test("workspace action context contributor resolves context for workspace surfaces even when route visibility is public", async () => {
-  const calls = [];
-  const contributor = createWorkspaceActionContextContributor({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options) {
-        calls.push({ user, workspaceSlug, options });
-        return {
-          workspace: {
-            id: 77,
-            slug: "acme"
-          },
-          membership: {
-            roleSid: "member"
-          },
-          permissions: ["crud.breeds.list"]
-        };
-      }
-    },
-    workspaceSurfaceIds: ["admin", "app"]
-  });
-
-  const request = {
-    user: {
-      id: 42
-    },
-    routeOptions: {
-      config: {
-        surface: "admin",
-        visibility: "public"
-      }
-    }
-  };
-
-  const contribution = await contributor.contribute({
-    definition: {
-      id: "crud.breeds.list",
-      surfaces: ["admin"]
-    },
-    input: {
-      workspaceSlug: "acme"
-    },
-    context: {
-      requestMeta: {
-        request
-      }
-    },
-    request
-  });
-
-  assert.deepEqual(calls, [
-    {
-      user: request.user,
-      workspaceSlug: "acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(contribution, {
-    requestMeta: {
-      resolvedWorkspaceContext: {
-        workspace: {
-          id: 77,
-          slug: "acme"
-        },
-        membership: {
-          roleSid: "member"
-        },
-        permissions: ["crud.breeds.list"]
-      }
-    },
-    workspace: {
-      id: 77,
-      slug: "acme"
-    },
-    membership: {
-      roleSid: "member"
-    },
-    permissions: ["crud.breeds.list"]
-  });
-});

package/test/workspaceActionSurfaces.test.js

@@ -1,85 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  materializeWorkspaceActionSurfacesFromAppConfig,
-  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig
-} from "../src/server/support/workspaceActionSurfaces.js";
-
-test("materializeWorkspaceActionSurfacesFromAppConfig resolves workspace surfaces from appConfig", () => {
-  const actionDefinitions = [
-    {
-      id: "workspace.settings.read",
-      surfacesFrom: "workspace"
-    },
-    {
-      id: "auth.session.read",
-      surfacesFrom: "enabled"
-    }
-  ];
-
-  const materialized = materializeWorkspaceActionSurfacesFromAppConfig(actionDefinitions, {
-    appConfig: {
-      surfaceDefinitions: {
-        app: { id: "app", enabled: true, requiresWorkspace: true },
-        admin: { id: "admin", enabled: true, requiresWorkspace: true },
-        ops: { id: "ops", enabled: true, requiresWorkspace: false }
-      }
-    }
-  });
-
-  assert.deepEqual(materialized, [
-    {
-      id: "workspace.settings.read",
-      surfaces: ["app", "admin"]
-    },
-    {
-      id: "auth.session.read",
-      surfacesFrom: "enabled"
-    }
-  ]);
-});
-
-test("materializeWorkspaceActionSurfacesFromAppConfig drops workspace actions when no workspace surfaces are enabled", () => {
-  const actionDefinitions = [
-    {
-      id: "workspace.settings.read",
-      surfacesFrom: "workspace"
-    }
-  ];
-
-  const materialized = materializeWorkspaceActionSurfacesFromAppConfig(actionDefinitions, {
-    appConfig: {
-      surfaceDefinitions: {
-        app: { id: "app", enabled: true, requiresWorkspace: false },
-        ops: { id: "ops", enabled: true, requiresWorkspace: false }
-      }
-    }
-  });
-
-  assert.deepEqual(materialized, []);
-});
-
-test("resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig picks a workspace surface when app default is non-workspace", () => {
-  const surfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig({
-    surfaceDefaultId: "home",
-    surfaceDefinitions: {
-      home: { id: "home", enabled: true, requiresWorkspace: false },
-      app: { id: "app", enabled: true, requiresWorkspace: true },
-      admin: { id: "admin", enabled: true, requiresWorkspace: true }
-    }
-  });
-
-  assert.equal(surfaceId, "app");
-});
-
-test("resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig falls back to app default when no workspace surfaces exist", () => {
-  const surfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig({
-    surfaceDefaultId: "home",
-    surfaceDefinitions: {
-      home: { id: "home", enabled: true, requiresWorkspace: false },
-      ops: { id: "ops", enabled: true, requiresWorkspace: false }
-    }
-  });
-
-  assert.equal(surfaceId, "home");
-});

package/test/workspaceAuthPolicyContextResolver.test.js

@@ -1,119 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createWorkspaceAuthPolicyContextResolver } from "../src/server/common/contributors/workspaceAuthPolicyContextResolver.js";
-
-test("workspace auth policy context resolver returns empty context when policy does not require workspace context", async () => {
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug() {
-        throw new Error("must not be called");
-      }
-    }
-  });
-
-  const resolved = await resolver({
-    request: {
-      params: {
-        workspaceSlug: "acme"
-      }
-    },
-    actor: {
-      id: 7
-    },
-    meta: {
-      contextPolicy: "none",
-      permission: ""
-    }
-  });
-
-  assert.deepEqual(resolved, {});
-});
-
-test("workspace auth policy context resolver resolves workspace context from users workspace service", async () => {
-  const calls = [];
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, options) {
-        calls.push({
-          actor,
-          workspaceSlug,
-          options
-        });
-        return {
-          workspace: {
-            id: 11,
-            slug: workspaceSlug
-          },
-          membership: {
-            roleSid: "owner"
-          },
-          permissions: ["projects.read"]
-        };
-      }
-    }
-  });
-
-  const request = {
-    params: {
-      workspaceSlug: "ACME"
-    }
-  };
-  const actor = {
-    id: 7
-  };
-
-  const resolved = await resolver({
-    request,
-    actor,
-    meta: {
-      contextPolicy: "required"
-    }
-  });
-
-  assert.deepEqual(calls, [
-    {
-      actor,
-      workspaceSlug: "acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(resolved, {
-    workspace: {
-      id: 11,
-      slug: "acme"
-    },
-    membership: {
-      roleSid: "owner"
-    },
-    permissions: ["projects.read"]
-  });
-});
-
-test("workspace auth policy context resolver skips workspace lookup when workspace slug is absent", async () => {
-  let called = false;
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug() {
-        called = true;
-        return {};
-      }
-    }
-  });
-
-  const resolved = await resolver({
-    request: {
-      params: {}
-    },
-    actor: {
-      id: 7
-    },
-    meta: {
-      contextPolicy: "required"
-    }
-  });
-
-  assert.equal(called, false);
-  assert.deepEqual(resolved, {});
-});