@jskit-ai/users-core 0.1.48 → 0.1.50

package/src/shared/support/usersVisibility.js

@@ -1,42 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-const USERS_ROUTE_VISIBILITY_PUBLIC = "public";
-const USERS_ROUTE_VISIBILITY_USER = "user";
-const USERS_ROUTE_VISIBILITY_WORKSPACE = "workspace";
-const USERS_ROUTE_VISIBILITY_WORKSPACE_USER = "workspace_user";
-
-const USERS_ROUTE_VISIBILITY_LEVELS = Object.freeze([
-  USERS_ROUTE_VISIBILITY_PUBLIC,
-  USERS_ROUTE_VISIBILITY_USER,
-  USERS_ROUTE_VISIBILITY_WORKSPACE,
-  USERS_ROUTE_VISIBILITY_WORKSPACE_USER
-]);
-const USERS_ROUTE_VISIBILITY_LEVEL_SET = new Set(USERS_ROUTE_VISIBILITY_LEVELS);
-
-function checkRouteVisibility(value, { context = "checkRouteVisibility" } = {}) {
-  const normalized = normalizeText(value).toLowerCase();
-  if (USERS_ROUTE_VISIBILITY_LEVEL_SET.has(normalized)) {
-    return normalized;
-  }
-
-  throw new TypeError(
-    `${context} must be one of: ${USERS_ROUTE_VISIBILITY_LEVELS.join(", ")}.`
-  );
-}
-
-function isWorkspaceVisibility(visibility = "") {
-  const normalized = checkRouteVisibility(visibility, {
-    context: "isWorkspaceVisibility visibility"
-  });
-  return normalized === USERS_ROUTE_VISIBILITY_WORKSPACE || normalized === USERS_ROUTE_VISIBILITY_WORKSPACE_USER;
-}
-
-export {
-  USERS_ROUTE_VISIBILITY_PUBLIC,
-  USERS_ROUTE_VISIBILITY_USER,
-  USERS_ROUTE_VISIBILITY_WORKSPACE,
-  USERS_ROUTE_VISIBILITY_WORKSPACE_USER,
-  USERS_ROUTE_VISIBILITY_LEVELS,
-  checkRouteVisibility,
-  isWorkspaceVisibility
-};

package/src/shared/support/workspacePathModel.js

@@ -1,145 +0,0 @@
-import {
-  deriveSurfaceRouteBaseFromPagesRoot,
-  normalizeSurfaceId
-} from "@jskit-ai/kernel/shared/surface/registry";
-import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
-
-function normalizeWorkspaceBasePath(workspaceBasePath = "/w") {
-  return normalizePathname(workspaceBasePath || "/w");
-}
-
-function normalizeSurfaceSegment(segmentLike = "") {
-  const normalizedPath = normalizePathname(segmentLike || "/");
-  if (normalizedPath === "/") {
-    return "";
-  }
-  return normalizedPath.replace(/^\/+/, "");
-}
-
-function normalizeSurfaceRouteBase(routeBaseLike = "") {
-  const rawRouteBase = String(routeBaseLike || "").trim();
-  if (!rawRouteBase || rawRouteBase === "/") {
-    return "/";
-  }
-  const withoutLeadingSlash = rawRouteBase.startsWith("/") ? rawRouteBase.slice(1) : rawRouteBase;
-  return deriveSurfaceRouteBaseFromPagesRoot(withoutLeadingSlash || "");
-}
-
-function normalizeSurfaceSegmentFromRouteBase(routeBase, { workspaceBasePath = "/w" } = {}) {
-  const normalizedRouteBase = normalizeSurfaceRouteBase(routeBase);
-  if (normalizedRouteBase === "/") {
-    return "";
-  }
-
-  const normalizedWorkspaceBasePath = normalizeWorkspaceBasePath(workspaceBasePath);
-  const workspacePlaceholderRoot = `${normalizedWorkspaceBasePath}/:workspaceSlug`;
-  if (normalizedRouteBase === workspacePlaceholderRoot) {
-    return "";
-  }
-  if (normalizedRouteBase.startsWith(`${workspacePlaceholderRoot}/`)) {
-    const remainder = normalizedRouteBase.slice(`${workspacePlaceholderRoot}/`.length);
-    const firstSegment = remainder.split("/").filter(Boolean)[0] || "";
-    return firstSegment.startsWith(":") ? "" : firstSegment;
-  }
-
-  const firstSegment = normalizedRouteBase.replace(/^\/+/, "").split("/").filter(Boolean)[0] || "";
-  if (!firstSegment || firstSegment.startsWith(":")) {
-    return "";
-  }
-  return firstSegment;
-}
-
-function parseWorkspacePathname(pathname = "", { workspaceBasePath = "/w" } = {}) {
-  const normalizedPathname = normalizePathname(pathname);
-  const normalizedWorkspaceBasePath = normalizeWorkspaceBasePath(workspaceBasePath);
-  if (!normalizedPathname.startsWith(`${normalizedWorkspaceBasePath}/`)) {
-    return null;
-  }
-
-  const trailingPath = normalizedPathname.slice(`${normalizedWorkspaceBasePath}/`.length);
-  const segments = trailingPath.split("/").filter(Boolean);
-  if (segments.length < 1) {
-    return null;
-  }
-
-  const [workspaceSlug, ...suffixSegments] = segments;
-  return {
-    workspaceSlug: String(workspaceSlug || "").trim(),
-    suffixSegments
-  };
-}
-
-function resolveDefaultWorkspaceSurfaceId({
-  defaultSurfaceId = "",
-  workspaceSurfaceIds = [],
-  surfaceRequiresWorkspace = null
-} = {}) {
-  const normalizedDefaultSurfaceId = normalizeSurfaceId(defaultSurfaceId);
-  if (
-    normalizedDefaultSurfaceId &&
-    typeof surfaceRequiresWorkspace === "function" &&
-    surfaceRequiresWorkspace(normalizedDefaultSurfaceId)
-  ) {
-    return normalizedDefaultSurfaceId;
-  }
-
-  for (const workspaceSurfaceId of Array.isArray(workspaceSurfaceIds) ? workspaceSurfaceIds : []) {
-    const normalizedWorkspaceSurfaceId = normalizeSurfaceId(workspaceSurfaceId);
-    if (normalizedWorkspaceSurfaceId) {
-      return normalizedWorkspaceSurfaceId;
-    }
-  }
-
-  return normalizedDefaultSurfaceId;
-}
-
-function resolveWorkspaceSurfaceIdFromSuffixSegments({
-  suffixSegments = [],
-  defaultWorkspaceSurfaceId = "",
-  workspaceSurfaces = []
-} = {}) {
-  const normalizedDefaultWorkspaceSurfaceId = normalizeSurfaceId(defaultWorkspaceSurfaceId);
-  if (!Array.isArray(suffixSegments) || suffixSegments.length < 1) {
-    return normalizedDefaultWorkspaceSurfaceId;
-  }
-
-  const suffixPath = suffixSegments.join("/");
-  const candidates = (Array.isArray(workspaceSurfaces) ? workspaceSurfaces : [])
-    .map((entry) => {
-      const surfaceId = normalizeSurfaceId(entry?.surfaceId || entry?.id);
-      if (!surfaceId || surfaceId === normalizedDefaultWorkspaceSurfaceId) {
-        return null;
-      }
-
-      const segment =
-        normalizeSurfaceSegment(entry?.segment) ||
-        normalizeSurfaceSegmentFromRouteBase(entry?.routeBase || entry?.pagesRoot) ||
-        surfaceId;
-      if (!segment) {
-        return null;
-      }
-
-      return {
-        surfaceId,
-        segment
-      };
-    })
-    .filter(Boolean)
-    .sort((left, right) => right.segment.length - left.segment.length);
-
-  for (const candidate of candidates) {
-    if (suffixPath === candidate.segment || suffixPath.startsWith(`${candidate.segment}/`)) {
-      return candidate.surfaceId;
-    }
-  }
-
-  return normalizedDefaultWorkspaceSurfaceId;
-}
-
-export {
-  normalizePathname,
-  normalizeSurfaceSegmentFromRouteBase,
-  parseWorkspacePathname,
-  resolveDefaultWorkspaceSurfaceId,
-  resolveWorkspaceSurfaceIdFromSuffixSegments
-};

package/src/shared/tenancyMode.js

@@ -1,35 +0,0 @@
-const TENANCY_MODE_NONE = "none";
-const TENANCY_MODE_PERSONAL = "personal";
-const TENANCY_MODE_WORKSPACES = "workspaces";
-
-const TENANCY_MODES = Object.freeze([
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES
-]);
-
-function normalizeTenancyMode(value = "") {
-  const normalized = String(value || "")
-    .trim()
-    .toLowerCase();
-  if (!TENANCY_MODES.includes(normalized)) {
-    return TENANCY_MODE_NONE;
-  }
-  return normalized;
-}
-
-function isTenancyMode(value = "") {
-  const normalized = String(value || "")
-    .trim()
-    .toLowerCase();
-  return TENANCY_MODES.includes(normalized);
-}
-
-export {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  TENANCY_MODES,
-  normalizeTenancyMode,
-  isTenancyMode
-};

package/src/shared/tenancyProfile.js

@@ -1,73 +0,0 @@
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode
-} from "./tenancyMode.js";
-import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
-
-const WORKSPACE_SLUG_POLICY_NONE = "none";
-const WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME = "immutable_username";
-const WORKSPACE_SLUG_POLICY_USER_SELECTED = "user_selected";
-
-function resolveWorkspacePolicyOverrides(appConfig = {}) {
-  const tenancyPolicy = isRecord(appConfig?.tenancyPolicy) ? appConfig.tenancyPolicy : {};
-  const workspacePolicy = isRecord(tenancyPolicy.workspace) ? tenancyPolicy.workspace : {};
-
-  return Object.freeze({
-    allowSelfCreate: typeof workspacePolicy.allowSelfCreate === "boolean" ? workspacePolicy.allowSelfCreate : null
-  });
-}
-
-function resolveWorkspacePolicy(mode, overrides = {}) {
-  if (mode === TENANCY_MODE_NONE) {
-    return Object.freeze({
-      enabled: false,
-      autoProvision: false,
-      allowSelfCreate: false,
-      slugPolicy: WORKSPACE_SLUG_POLICY_NONE
-    });
-  }
-
-  if (mode === TENANCY_MODE_PERSONAL) {
-    return Object.freeze({
-      enabled: true,
-      autoProvision: true,
-      allowSelfCreate: false,
-      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-    });
-  }
-
-  return Object.freeze({
-    enabled: true,
-    autoProvision: false,
-    allowSelfCreate: overrides.allowSelfCreate === true,
-    slugPolicy: WORKSPACE_SLUG_POLICY_USER_SELECTED
-  });
-}
-
-function resolveTenancyProfile(appConfig = {}) {
-  const mode = normalizeTenancyMode(appConfig?.tenancyMode);
-  const workspacePolicyOverrides = resolveWorkspacePolicyOverrides(appConfig);
-
-  return Object.freeze({
-    mode,
-    workspace: resolveWorkspacePolicy(mode, workspacePolicyOverrides)
-  });
-}
-
-function isWorkspacesTenancyMode(value = "") {
-  return normalizeTenancyMode(value) === TENANCY_MODE_WORKSPACES;
-}
-
-export {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
-};

package/test/registerWorkspaceDirectory.test.js

@@ -1,31 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceDirectory } from "../src/server/workspaceDirectory/registerWorkspaceDirectory.js";
-
-function createAppDouble() {
-  const actionBatches = [];
-
-  return {
-    actionBatches,
-    singleton() {},
-    actions(entries) {
-      actionBatches.push(Array.isArray(entries) ? entries : [entries]);
-    }
-  };
-}
-
-function listActionIds(app) {
-  return app.actionBatches.flat().map((entry) => String(entry?.id || ""));
-}
-
-test("registerWorkspaceDirectory registers workspace directory actions without resolving runtime tenancy tokens", () => {
-  const app = createAppDouble();
-
-  registerWorkspaceDirectory(app);
-  assert.deepEqual(listActionIds(app), [
-    "workspace.workspaces.create",
-    "workspace.workspaces.list",
-    "workspace.workspaces.read",
-    "workspace.workspaces.update"
-  ]);
-});

package/test/registerWorkspaceSettings.test.js

@@ -1,40 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceSettings } from "../src/server/workspaceSettings/registerWorkspaceSettings.js";
-
-test("registerWorkspaceSettings registers workspace settings service realtime event metadata", () => {
-  const singletonBindings = new Map();
-  const actionCalls = [];
-  const serviceCalls = [];
-
-  const app = {
-    singleton(token, factory) {
-      singletonBindings.set(token, factory);
-      return this;
-    },
-    service(token, factory, metadata) {
-      serviceCalls.push({
-        token,
-        factory,
-        metadata
-      });
-      return this;
-    },
-    actions(definitions) {
-      actionCalls.push(definitions);
-      return this;
-    }
-  };
-
-  registerWorkspaceSettings(app);
-
-  assert.equal(singletonBindings.has("workspaceSettingsRepository"), true);
-  assert.equal(serviceCalls.length, 1);
-  assert.equal(serviceCalls[0].token, "users.workspace.settings.service");
-  assert.equal(typeof serviceCalls[0].factory, "function");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.event, "workspace.settings.changed");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.audience, "event_scope");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.audience, "event_scope");
-  assert.equal(actionCalls.length, 1);
-});

package/test/roles.test.js

@@ -1,159 +0,0 @@
-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.roleCatalog", () => {
-  const emptyCatalog = createWorkspaceRoleCatalog();
-  assert.deepEqual(emptyCatalog.roles, []);
-  assert.deepEqual(emptyCatalog.assignableRoleIds, []);
-  assert.equal(emptyCatalog.defaultInviteRole, "");
-  assert.equal(emptyCatalog.collaborationEnabled, false);
-
-  const appConfig = {
-    roleCatalog: {
-      workspace: {
-        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("createWorkspaceRoleCatalog resolves inherited role permissions with parent permissions first", () => {
-  const appConfig = {
-    roleCatalog: {
-      workspace: {
-        defaultInviteRole: "member"
-      },
-      roles: {
-        member: {
-          assignable: true,
-          permissions: [
-            "workspace.settings.view",
-            "crud.contacts.list"
-          ]
-        },
-        admin: {
-          assignable: true,
-          inherits: "member",
-          permissions: [
-            "workspace.settings.update",
-            "workspace.members.manage",
-            "workspace.settings.view"
-          ]
-        }
-      }
-    }
-  };
-
-  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
-  const adminRole = roleCatalog.roles.find((role) => role.id === "admin");
-
-  assert.deepEqual(adminRole, {
-    id: "admin",
-    assignable: true,
-    permissions: [
-      "workspace.settings.view",
-      "crud.contacts.list",
-      "workspace.settings.update",
-      "workspace.members.manage"
-    ]
-  });
-});
-
-test("createWorkspaceRoleCatalog rejects unknown inherited roles", () => {
-  assert.throws(
-    () =>
-      createWorkspaceRoleCatalog({
-        roleCatalog: {
-          roles: {
-            admin: {
-              assignable: true,
-              inherits: "member",
-              permissions: []
-            }
-          }
-        }
-      }),
-    /inherits unknown role "member"/
-  );
-});
-
-test("createWorkspaceRoleCatalog rejects circular inherited roles", () => {
-  assert.throws(
-    () =>
-      createWorkspaceRoleCatalog({
-        roleCatalog: {
-          roles: {
-            member: {
-              assignable: true,
-              inherits: "admin",
-              permissions: []
-            },
-            admin: {
-              assignable: true,
-              inherits: "member",
-              permissions: []
-            }
-          }
-        }
-      }),
-    /circular inheritance/
-  );
-});
-
-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/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");
-});