@jskit-ai/users-core 0.1.47 → 0.1.49

package/test/usersBootstrapContributor.test.js

@@ -1,10 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createUsersBootstrapContributor } from "../src/server/usersBootstrapContributor.js";
-import {
-  TENANCY_MODE_PERSONAL,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-} from "../src/shared/tenancyProfile.js";
 
 function createAuthenticatedProfile(overrides = {}) {
   return {
@@ -33,9 +29,8 @@ function createUserSettings() {
   };
 }
 
-test("users bootstrap contributor seeds the initial console owner and exposes generic app payload", async () => {
+test("users bootstrap contributor exposes the generic authenticated bootstrap payload", async () => {
   const profile = createAuthenticatedProfile({ id: "12" });
-  const consoleOwnerSeeds = [];
   const writtenSessions = [];
   const contributor = createUsersBootstrapContributor({
     usersRepository: {
@@ -60,12 +55,6 @@ test("users bootstrap contributor seeds the initial console owner and exposes ge
           defaultProvider: "google"
         };
       }
-    },
-    consoleService: {
-      async ensureInitialConsoleMember(userId) {
-        consoleOwnerSeeds.push(Number(userId));
-        return String(userId || "");
-      }
     }
   });
 
@@ -82,10 +71,14 @@ test("users bootstrap contributor seeds the initial console owner and exposes ge
         };
       }
     },
+    payload: {
+      surfaceAccess: {
+        consoleowner: true
+      }
+    },
     reply
   });
-
-  assert.deepEqual(consoleOwnerSeeds, [12]);
+  assert.equal(contributor.order, 100);
   assert.equal(writtenSessions.length, 1);
   assert.equal(writtenSessions[0].reply, reply);
   assert.deepEqual(writtenSessions[0].session, {
@@ -93,8 +86,10 @@ test("users bootstrap contributor seeds the initial console owner and exposes ge
   });
   assert.equal(payload.session.authenticated, true);
   assert.equal(payload.session.userId, "12");
-  assert.equal(payload.surfaceAccess.consoleowner, true);
-  assert.equal(payload.app.features.workspaceSwitching, false);
+  assert.deepEqual(payload.surfaceAccess, {
+    consoleowner: true
+  });
+  assert.equal(payload.app.features.assistantEnabled, false);
   assert.deepEqual(payload.session.oauthProviders, [
     {
       id: "google",
@@ -102,12 +97,11 @@ test("users bootstrap contributor seeds the initial console owner and exposes ge
     }
   ]);
   assert.equal(payload.session.oauthDefaultProvider, "google");
-  assert.deepEqual(payload.workspaces, []);
   assert.deepEqual(payload.userSettings, {});
   assert.equal(payload.requestMeta.hasRequest, true);
 });
 
-test("users bootstrap contributor emits canonical tenancy profile for anonymous bootstrap", async () => {
+test("users bootstrap contributor emits anonymous bootstrap payload without workspace fields", async () => {
   const contributor = createUsersBootstrapContributor({
     usersRepository: {
       async findById() {
@@ -119,15 +113,6 @@ test("users bootstrap contributor emits canonical tenancy profile for anonymous
         return createUserSettings();
       }
     },
-    tenancyProfile: {
-      mode: TENANCY_MODE_PERSONAL,
-      workspace: {
-        enabled: true,
-        autoProvision: true,
-        allowSelfCreate: false,
-        slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-      }
-    },
     appConfig: {
       tenancyMode: "none"
     },
@@ -149,24 +134,21 @@ test("users bootstrap contributor emits canonical tenancy profile for anonymous
         };
       }
     },
+    payload: {
+      surfaceAccess: {
+        consoleowner: false
+      }
+    },
     reply: {}
   });
 
-  assert.deepEqual(payload.tenancy, {
-    mode: TENANCY_MODE_PERSONAL,
-    workspace: {
-      enabled: true,
-      autoProvision: true,
-      allowSelfCreate: false,
-      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-    }
-  });
   assert.deepEqual(payload.session, {
     authenticated: false,
     oauthProviders: [],
     oauthDefaultProvider: null
   });
-  assert.deepEqual(payload.workspaces, []);
-  assert.equal(payload.surfaceAccess.consoleowner, false);
+  assert.deepEqual(payload.surfaceAccess, {
+    consoleowner: false
+  });
   assert.equal(payload.userSettings, null);
 });

package/test/usersRouteRequestInputValidator.test.js

@@ -27,8 +27,7 @@ function findRoute(routes, { method, path }) {
 }
 
 async function registerRoutes({
-  authService = {},
-  consoleService = null
+  authService = {}
 } = {}) {
   const registeredRoutes = [];
   const router = {
@@ -59,10 +58,6 @@ async function registerRoutes({
     ["actionExecutor", {}]
   ]);
 
-  if (consoleService) {
-    bindings.set("consoleService", consoleService);
-  }
-
   const app = {
     has(token) {
       return bindings.has(token);
@@ -92,13 +87,11 @@ function createActionRequest({ input = {}, executeAction, file = null }) {
   };
 }
 
-test("users-core boot mounts account and console routes without workspace routes", async () => {
+test("users-core boot mounts account routes without workspace routes", async () => {
   const routes = await registerRoutes();
 
   assert.equal(findRoute(routes, { method: "GET", path: "/api/settings" })?.path, "/api/settings");
   assert.equal(findRoute(routes, { method: "PATCH", path: "/api/settings/profile" })?.path, "/api/settings/profile");
-  assert.equal(findRoute(routes, { method: "GET", path: "/api/console/settings" })?.path, "/api/console/settings");
-  assert.equal(findRoute(routes, { method: "PATCH", path: "/api/console/settings" })?.path, "/api/console/settings");
   assert.equal(findRoute(routes, { method: "GET", path: "/api/workspaces" }), null);
   assert.equal(findRoute(routes, { method: "GET", path: "/api/w/:workspaceSlug/settings" }), null);
 });
@@ -206,37 +199,3 @@ test("account route handlers build action input from request.input", async () =>
   assert.deepEqual(calls[6].input, { provider: "github" });
   assert.equal(calls[7].actionId, "settings.security.sessions.logout_others");
 });
-
-test("console settings route handlers use request.input payloads", async () => {
-  const routes = await registerRoutes();
-  const calls = [];
-  const executeAction = async (payload) => {
-    calls.push(payload);
-    return {
-      settings: {}
-    };
-  };
-
-  await findRoute(routes, { method: "GET", path: "/api/console/settings" }).handler(
-    createActionRequest({ executeAction }),
-    createReplyDouble()
-  );
-
-  await findRoute(routes, { method: "PATCH", path: "/api/console/settings" }).handler(
-    createActionRequest({
-      input: {
-        body: {}
-      },
-      executeAction
-    }),
-    createReplyDouble()
-  );
-
-  assert.equal(calls[0].actionId, "console.settings.read");
-  assert.deepEqual(calls[1], {
-    actionId: "console.settings.update",
-    input: {
-      payload: {}
-    }
-  });
-});

package/test/usersRouteResources.test.js

@@ -5,12 +5,8 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
 import "../test-support/registerDefaultSettingsFields.js";
-import { consoleSettingsResource } from "../src/shared/resources/consoleSettingsResource.js";
 import { userProfileResource } from "../src/shared/resources/userProfileResource.js";
 import { userSettingsResource } from "../src/shared/resources/userSettingsResource.js";
-import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
-import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
-import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
 
 function assertResourceShape(resource, label) {
   assert.ok(resource, `${label} resource must exist.`);
@@ -47,13 +43,10 @@ function assertResourceShape(resource, label) {
   assert.ok(Array.isArray(requiredMetadata.patch), `${label}.derivedRequired.patch must be an array.`);
 }
 
-test("workspace/settings/console resources expose canonical validators", () => {
+test("workspace and account resources expose canonical validators", () => {
   const resourcesByLabel = {
-    workspace: workspaceResource,
-    workspaceSettings: workspaceSettingsResource,
     userProfile: userProfileResource,
-    userSettings: userSettingsResource,
-    consoleSettings: consoleSettingsResource
+    userSettings: userSettingsResource
   };
 
   for (const [label, resource] of Object.entries(resourcesByLabel)) {
@@ -62,18 +55,7 @@ test("workspace/settings/console resources expose canonical validators", () => {
 });
 
 test("specialized settings and invite operations expose canonical validators", () => {
-  const workspaceMembersOperationSpecs = [
-    { label: "workspaceMembers.rolesList", operation: workspaceMembersResource.operations.rolesList },
-    { label: "workspaceMembers.membersList", operation: workspaceMembersResource.operations.membersList },
-    { label: "workspaceMembers.updateMemberRole", operation: workspaceMembersResource.operations.updateMemberRole },
-    { label: "workspaceMembers.removeMember", operation: workspaceMembersResource.operations.removeMember },
-    { label: "workspaceMembers.invitesList", operation: workspaceMembersResource.operations.invitesList },
-    { label: "workspaceMembers.createInvite", operation: workspaceMembersResource.operations.createInvite },
-    { label: "workspaceMembers.revokeInvite", operation: workspaceMembersResource.operations.revokeInvite },
-    { label: "workspaceMembers.redeemInvite", operation: workspaceMembersResource.operations.redeemInvite }
-  ];
   const operationSpecs = [
-    ...workspaceMembersOperationSpecs,
     { label: "userProfile.avatarUpload", operation: userProfileResource.operations.avatarUpload },
     { label: "userProfile.avatarDelete", operation: userProfileResource.operations.avatarDelete },
     { label: "userSettings.passwordChange", operation: userSettingsResource.operations.passwordChange },

package/test-support/registerDefaultSettingsFields.js

@@ -1,3 +1,2 @@
 import "../../workspaces-core/templates/packages/main/src/shared/resources/workspaceSettingsFields.js";
-import "../templates/packages/main/src/shared/resources/consoleSettingsFields.js";
 import "../templates/packages/main/src/shared/resources/userSettingsFields.js";

package/src/server/UsersWorkspacesServiceProvider.js

@@ -1,44 +0,0 @@
-import { bootWorkspaceDirectoryRoutes } from "./workspaceDirectory/bootWorkspaceDirectoryRoutes.js";
-import { registerWorkspaceDirectory } from "./workspaceDirectory/registerWorkspaceDirectory.js";
-import {
-  registerWorkspacePendingInvitations
-} from "./workspacePendingInvitations/registerWorkspacePendingInvitations.js";
-import { bootWorkspacePendingInvitations } from "./workspacePendingInvitations/bootWorkspacePendingInvitations.js";
-import { registerWorkspaceMembers } from "./workspaceMembers/registerWorkspaceMembers.js";
-import { bootWorkspaceMembers } from "./workspaceMembers/bootWorkspaceMembers.js";
-import { registerWorkspaceSettings } from "./workspaceSettings/registerWorkspaceSettings.js";
-import { bootWorkspaceSettings } from "./workspaceSettings/bootWorkspaceSettings.js";
-import { registerWorkspaceRepositories } from "./registerWorkspaceRepositories.js";
-import { registerWorkspaceCore } from "./registerWorkspaceCore.js";
-import { registerWorkspaceBootstrap } from "./registerWorkspaceBootstrap.js";
-
-class UsersWorkspacesServiceProvider {
-  static id = "workspaces.core";
-
-  static dependsOn = ["users.core"];
-
-  register(app) {
-    registerWorkspaceRepositories(app);
-    registerWorkspaceCore(app);
-    registerWorkspaceBootstrap(app);
-    registerWorkspaceDirectory(app);
-    registerWorkspaceMembers(app);
-    registerWorkspaceSettings(app);
-    registerWorkspacePendingInvitations(app);
-  }
-
-  async boot(app) {
-    if (app.make("users.workspace.enabled") !== true) {
-      return;
-    }
-
-    bootWorkspaceDirectoryRoutes(app);
-    if (app.make("users.workspace.invitations.enabled") === true) {
-      bootWorkspacePendingInvitations(app);
-    }
-    bootWorkspaceSettings(app);
-    bootWorkspaceMembers(app);
-  }
-}
-
-export { UsersWorkspacesServiceProvider };

package/src/server/common/contributors/workspaceActionContextContributor.js

@@ -1,88 +0,0 @@
-import {
-  normalizeObject,
-  requireServiceMethod
-} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import {
-  checkRouteVisibility,
-  USERS_ROUTE_VISIBILITY_PUBLIC,
-  USERS_ROUTE_VISIBILITY_WORKSPACE,
-  USERS_ROUTE_VISIBILITY_WORKSPACE_USER
-} from "../../../shared/support/usersVisibility.js";
-import { resolveActionUser } from "../support/resolveActionUser.js";
-const WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET = new Set([
-  USERS_ROUTE_VISIBILITY_WORKSPACE,
-  USERS_ROUTE_VISIBILITY_WORKSPACE_USER
-]);
-
-function normalizeWorkspaceSurfaceIds(surfaceIds = []) {
-  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
-  const normalized = new Set();
-
-  for (const entry of source) {
-    const surfaceId = normalizeSurfaceId(entry);
-    if (!surfaceId) {
-      continue;
-    }
-    normalized.add(surfaceId);
-  }
-
-  return normalized;
-}
-
-function createWorkspaceActionContextContributor({ workspaceService, workspaceSurfaceIds = [] } = {}) {
-  const contributorId = "users.workspace.context";
-  const workspaceSurfaceIdSet = normalizeWorkspaceSurfaceIds(workspaceSurfaceIds);
-
-  requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId);
-
-  return Object.freeze({
-    contributorId,
-    async contribute({ definition = null, input, context, request } = {}) {
-      const payload = normalizeObject(input);
-      if (!Object.hasOwn(payload, "workspaceSlug")) {
-        return {};
-      }
-
-      const actionSurfaces = Array.isArray(definition?.surfaces) ? definition.surfaces : [];
-      const hasWorkspaceActionSurface = actionSurfaces.some((surfaceId) => workspaceSurfaceIdSet.has(surfaceId));
-      const routeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
-      const hasWorkspaceSurface = workspaceSurfaceIdSet.has(routeSurfaceId);
-      const routeVisibilityInput =
-        request && request.routeOptions && request.routeOptions.config
-          ? request.routeOptions.config.visibility
-          : USERS_ROUTE_VISIBILITY_PUBLIC;
-      const routeVisibility = checkRouteVisibility(routeVisibilityInput);
-      const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
-      if (!hasWorkspaceActionSurface && !hasWorkspaceRouteVisibility && !hasWorkspaceSurface) {
-        return {};
-      }
-
-      const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
-        resolveActionUser(context, payload),
-        payload.workspaceSlug,
-        { request }
-      );
-
-      const contribution = {
-        requestMeta: {
-          resolvedWorkspaceContext
-        }
-      };
-
-      if (!context?.workspace) {
-        contribution.workspace = resolvedWorkspaceContext.workspace;
-      }
-      if (!context?.membership) {
-        contribution.membership = resolvedWorkspaceContext.membership;
-      }
-      if (!Array.isArray(context?.permissions) || context.permissions.length < 1) {
-        contribution.permissions = resolvedWorkspaceContext.permissions;
-      }
-
-      return contribution;
-    }
-  });
-}
-
-export { createWorkspaceActionContextContributor };

package/src/server/common/contributors/workspaceAuthPolicyContextResolver.js

@@ -1,34 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function createWorkspaceAuthPolicyContextResolver({ workspaceService } = {}) {
-  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
-    throw new Error(
-      "workspace auth policy context resolver requires workspaceService.resolveWorkspaceContextForUserBySlug()."
-    );
-  }
-
-  return async function resolveWorkspaceAuthPolicyContext({ request, actor, meta } = {}) {
-    const contextPolicy = normalizeText(meta?.contextPolicy || "none").toLowerCase() || "none";
-    const permission = normalizeText(meta?.permission);
-    if (contextPolicy === "none" && !permission) {
-      return {};
-    }
-
-    const workspaceSlug = normalizeText(request?.params?.workspaceSlug).toLowerCase();
-    if (!workspaceSlug || !actor) {
-      return {};
-    }
-
-    const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, {
-      request
-    });
-
-    return {
-      workspace: resolvedWorkspaceContext?.workspace || null,
-      membership: resolvedWorkspaceContext?.membership || null,
-      permissions: Array.isArray(resolvedWorkspaceContext?.permissions) ? resolvedWorkspaceContext.permissions : []
-    };
-  };
-}
-
-export { createWorkspaceAuthPolicyContextResolver };

package/src/server/common/contributors/workspaceRouteVisibilityResolver.js

@@ -1,78 +0,0 @@
-import { normalizeOpaqueId, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function buildVisibilityContribution({ visibility, scopeOwnerId = null, userId = null } = {}) {
-  const requiresActorScope = visibility === "workspace_user";
-  const contribution = {
-    scopeKind: requiresActorScope ? "workspace_user" : "workspace",
-    requiresActorScope
-  };
-
-  if (scopeOwnerId) {
-    contribution.scopeOwnerId = scopeOwnerId;
-  }
-  if (requiresActorScope && userId != null) {
-    contribution.userId = userId;
-  }
-
-  return contribution;
-}
-
-function createWorkspaceRouteVisibilityResolver({ workspaceService } = {}) {
-  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
-    throw new Error("workspace route visibility resolver requires workspaceService.resolveWorkspaceContextForUserBySlug().");
-  }
-
-  return Object.freeze({
-    resolverId: "users.workspace.visibility",
-    async resolve({ visibility, context, request, input } = {}) {
-      if (visibility !== "workspace" && visibility !== "workspace_user") {
-        return {};
-      }
-
-      const actor = context?.actor || request?.user || null;
-      const userId = normalizeOpaqueId(actor?.id);
-      const workspace =
-        context?.workspace || context?.requestMeta?.resolvedWorkspaceContext?.workspace || request?.workspace || null;
-      const scopeOwnerId = normalizeRecordId(workspace?.id, { fallback: null });
-      if (!scopeOwnerId) {
-        const workspaceSlug = normalizeText(input?.workspaceSlug).toLowerCase();
-
-        if (!workspaceSlug || !actor) {
-          return visibility === "workspace_user"
-            ? buildVisibilityContribution({
-                visibility,
-                userId
-              })
-            : {};
-        }
-
-        const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, {
-          request
-        });
-        const resolvedWorkspaceOwnerId = normalizeRecordId(resolvedWorkspaceContext?.workspace?.id, { fallback: null });
-        if (!resolvedWorkspaceOwnerId) {
-          return visibility === "workspace_user"
-            ? buildVisibilityContribution({
-                visibility,
-                userId
-              })
-            : {};
-        }
-
-        return buildVisibilityContribution({
-          visibility,
-          scopeOwnerId: resolvedWorkspaceOwnerId,
-          userId
-        });
-      }
-
-      return buildVisibilityContribution({
-        visibility,
-        scopeOwnerId,
-        userId
-      });
-    }
-  });
-}
-
-export { createWorkspaceRouteVisibilityResolver };

package/src/server/common/formatters/workspaceFormatter.js

@@ -1,53 +0,0 @@
-import { resolveWorkspaceThemePalettes } from "../../../shared/settings.js";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-
-function mapWorkspaceSummary(workspace, membership) {
-  return {
-    id: normalizeRecordId(workspace.id, { fallback: "" }),
-    slug: normalizeText(workspace.slug),
-    name: normalizeText(workspace.name),
-    avatarUrl: normalizeText(workspace.avatarUrl),
-    roleSid: normalizeLowerText(membership?.roleSid || "member") || "member",
-    isAccessible: normalizeLowerText(membership?.status || "active") === "active"
-  };
-}
-
-function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEnabled = true } = {}) {
-  const source = workspaceSettings && typeof workspaceSettings === "object" ? workspaceSettings : {};
-  const invitesAvailable = workspaceInvitationsEnabled === true;
-  const invitesEnabled = invitesAvailable && source.invitesEnabled !== false;
-  const themePalettes = resolveWorkspaceThemePalettes(source);
-
-  return {
-    lightPrimaryColor: themePalettes.light.color,
-    lightSecondaryColor: themePalettes.light.secondaryColor,
-    lightSurfaceColor: themePalettes.light.surfaceColor,
-    lightSurfaceVariantColor: themePalettes.light.surfaceVariantColor,
-    darkPrimaryColor: themePalettes.dark.color,
-    darkSecondaryColor: themePalettes.dark.secondaryColor,
-    darkSurfaceColor: themePalettes.dark.surfaceColor,
-    darkSurfaceVariantColor: themePalettes.dark.surfaceVariantColor,
-    invitesEnabled,
-    invitesAvailable,
-    invitesEffective: invitesAvailable && invitesEnabled
-  };
-}
-
-function mapMembershipSummary(membership, workspace) {
-  if (!membership) {
-    return null;
-  }
-
-  return {
-    workspaceId: normalizeRecordId(workspace?.id || membership.workspaceId, { fallback: "" }),
-    roleSid: normalizeLowerText(membership.roleSid || "member") || "member",
-    status: normalizeLowerText(membership.status || "active") || "active"
-  };
-}
-
-export {
-  mapMembershipSummary,
-  mapWorkspaceSettingsPublic,
-  mapWorkspaceSummary
-};