@jskit-ai/users-core 0.1.47 → 0.1.49

package/test/tenancyProfile.test.js

@@ -1,67 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
-} 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_WORKSPACES });
-  assert.deepEqual(workspaceProfile, {
-    mode: TENANCY_MODE_WORKSPACES,
-    workspace: {
-      enabled: true,
-      autoProvision: false,
-      allowSelfCreate: false,
-      slugPolicy: WORKSPACE_SLUG_POLICY_USER_SELECTED
-    }
-  });
-});
-
-test("isWorkspacesTenancyMode is true only for workspace mode", () => {
-  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_WORKSPACES), true);
-  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_PERSONAL), false);
-  assert.equal(isWorkspacesTenancyMode(TENANCY_MODE_NONE), false);
-});
-
-test("resolveTenancyProfile allows explicit workspace self-create policy override", () => {
-  const workspaceProfile = resolveTenancyProfile({
-    tenancyMode: TENANCY_MODE_WORKSPACES,
-    tenancyPolicy: {
-      workspace: {
-        allowSelfCreate: true
-      }
-    }
-  });
-
-  assert.equal(workspaceProfile.mode, TENANCY_MODE_WORKSPACES);
-  assert.equal(workspaceProfile.workspace.allowSelfCreate, true);
-});

package/test/usersApiPaths.test.js

@@ -1,49 +0,0 @@
-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/customers"
-  );
-
-  assert.equal(
-    resolveApiBasePath({
-      surfaceRequiresWorkspace: false,
-      relativePath: "/customers"
-    }),
-    "/api/customers"
-  );
-});
-
-test("resolveApiBasePath preserves query strings and hash fragments", () => {
-  assert.equal(
-    resolveApiBasePath({
-      surfaceRequiresWorkspace: true,
-      relativePath: "/customers?search=buddy#top"
-    }),
-    "/api/w/:workspaceSlug/customers?search=buddy#top"
-  );
-
-  assert.equal(
-    resolveApiBasePath({
-      surfaceRequiresWorkspace: false,
-      relativePath: "/?cursor=2"
-    }),
-    "/api?cursor=2"
-  );
-});

package/test/usersRouteValidators.test.js

@@ -1,49 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Type } from "@fastify/type-provider-typebox";
-import { compileRouteValidator } from "@jskit-ai/kernel/_testable";
-import { routeParamsValidator } from "../src/server/common/validators/routeParamsValidator.js";
-
-test("routeParamsValidator exposes a shared route params validator", () => {
-  assert.equal(typeof routeParamsValidator.schema, "object");
-  assert.equal(typeof routeParamsValidator.normalize, "function");
-});
-
-test("route validator pipeline uses the shared params validator and merges query arrays automatically", () => {
-  const paginationQueryValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        cursor: Type.Optional(Type.String({ minLength: 1 })),
-        limit: Type.Optional(Type.String({ pattern: "^[0-9]+$" }))
-      },
-      { additionalProperties: false }
-    )
-  });
-  const searchQueryValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        search: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    )
-  });
-
-  const compiled = compileRouteValidator({
-    paramsValidator: routeParamsValidator,
-    queryValidator: [paginationQueryValidator, searchQueryValidator]
-  });
-
-  assert.equal(compiled.schema.params.type, "object");
-  assert.equal(compiled.schema.params.additionalProperties, false);
-  assert.equal(typeof compiled.schema.params.properties.workspaceSlug, "object");
-  assert.equal(typeof compiled.schema.params.properties.memberUserId, "object");
-  assert.equal(typeof compiled.schema.params.properties.inviteId, "object");
-  assert.equal(typeof compiled.schema.params.properties.provider, "object");
-  assert.equal(compiled.input.params({ workspaceSlug: "  ACME  " }).workspaceSlug, "acme");
-
-  assert.equal(compiled.schema.querystring.type, "object");
-  assert.equal(compiled.schema.querystring.additionalProperties, false);
-  assert.equal(typeof compiled.schema.querystring.properties.cursor, "object");
-  assert.equal(typeof compiled.schema.querystring.properties.limit, "object");
-  assert.equal(typeof compiled.schema.querystring.properties.search, "object");
-});

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,105 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  materializeWorkspaceActionSurfacesFromAppConfig,
-  resolveConsoleSurfaceIdsFromAppConfig,
-  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 },
-        console: { id: "console", 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 },
-        console: { id: "console", 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 },
-      console: { id: "console", enabled: true, requiresWorkspace: false }
-    }
-  });
-
-  assert.equal(surfaceId, "home");
-});
-
-test("resolveConsoleSurfaceIdsFromAppConfig resolves all enabled console-owner surfaces", () => {
-  const surfaceIds = resolveConsoleSurfaceIdsFromAppConfig({
-    surfaceDefinitions: {
-      home: { id: "home", enabled: true, requiresWorkspace: false, accessPolicyId: "public" },
-      console: { id: "console", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
-      opsConsole: { id: "opsConsole", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
-      app: { id: "app", enabled: true, requiresWorkspace: true, accessPolicyId: "workspace_member" },
-      disabledConsole: {
-        id: "disabledConsole",
-        enabled: false,
-        requiresWorkspace: false,
-        accessPolicyId: "console_owner"
-      }
-    }
-  });
-
-  assert.deepEqual(surfaceIds, ["console", "opsconsole"]);
-});