@jskit-ai/users-core 0.1.48 → 0.1.49

package/test/authProfileSyncService.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createService } from "../src/server/common/services/authProfileSyncService.js";
 
-test("authProfileSyncService.syncIdentityProfile uses shared transaction for profile upsert and provisioning", async () => {
+test("authProfileSyncService.syncIdentityProfile uses shared transaction for profile upsert and lifecycle contributors", async () => {
   const calls = [];
   const transaction = { trxId: "tx-1" };
 
@@ -33,11 +33,14 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
         return { userId: Number(userId) };
       }
     },
-    workspaceProvisioningService: {
-      async provisionWorkspaceForNewUser(_profile, options = {}) {
-        calls.push({ step: "provision", trx: options.trx || null });
+    lifecycleContributors: [
+      {
+        contributorId: "test.lifecycle",
+        async afterIdentityProfileSynced({ created, options = {} } = {}) {
+          calls.push({ step: "lifecycle", created, trx: options.trx || null });
+        }
       }
-    }
+    ]
   });
 
   const profile = await service.syncIdentityProfile({
@@ -52,7 +55,8 @@ test("authProfileSyncService.syncIdentityProfile uses shared transaction for pro
   assert.equal(calls[1].step, "find");
   assert.equal(calls[2].step, "upsert");
   assert.equal(calls[3].step, "ensureUserSettings");
-  assert.equal(calls[4].step, "provision");
+  assert.equal(calls[4].step, "lifecycle");
+  assert.equal(calls[4].created, true);
   assert.equal(calls[1].trx, transaction);
   assert.equal(calls[2].trx, transaction);
   assert.equal(calls[3].trx, transaction);
@@ -87,11 +91,16 @@ test("authProfileSyncService.syncIdentityProfile skips write path when profile i
         return { userId: "7" };
       }
     },
-    workspaceProvisioningService: {
-      async provisionWorkspaceForNewUser() {
-        provisionCalls += 1;
+    lifecycleContributors: [
+      {
+        contributorId: "test.lifecycle",
+        async afterIdentityProfileSynced({ created } = {}) {
+          if (created) {
+            provisionCalls += 1;
+          }
+        }
       }
-    }
+    ]
   });
 
   const profile = await service.syncIdentityProfile({

package/test/registerServiceRealtimeEvents.test.js

@@ -3,8 +3,6 @@ import test from "node:test";
 import { registerAccountProfile } from "../src/server/accountProfile/registerAccountProfile.js";
 import { registerAccountPreferences } from "../src/server/accountPreferences/registerAccountPreferences.js";
 import { registerAccountNotifications } from "../src/server/accountNotifications/registerAccountNotifications.js";
-import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
-import { registerWorkspacePendingInvitations } from "../src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js";
 
 function createAppDouble() {
   const serviceCalls = [];
@@ -57,87 +55,3 @@ test("account register functions publish account.settings.changed for update ope
   assert.equal(notifications?.metadata?.events?.updateNotifications?.[0]?.realtime?.event, "account.settings.changed");
   assert.equal(notifications?.metadata?.events?.updateNotifications?.[1]?.realtime?.event, "users.bootstrap.changed");
 });
-
-test("workspace register functions publish members/invites/workspace-list realtime events", async () => {
-  const membersApp = createAppDouble();
-  registerWorkspaceMembers(membersApp.app);
-  const members = findServiceCall(membersApp.serviceCalls, "users.workspace.members.service");
-  assert.equal(members?.metadata?.events?.updateMemberRole?.[0]?.realtime?.event, "workspace.members.changed");
-  assert.equal(members?.metadata?.events?.updateMemberRole?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.removeMember?.[0]?.realtime?.event, "workspace.members.changed");
-  assert.equal(members?.metadata?.events?.removeMember?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[0]?.realtime?.event, "workspace.invites.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.entityId?.({ result: { createdInviteId: "91" } }), "91");
-  assert.equal(members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.preset, "event_scope");
-  assert.equal(typeof members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery, "function");
-  const createInviteAudienceQueryResult = await members?.metadata?.events?.createInvite?.[1]?.realtime?.audience?.userQuery({
-    knex() {
-      return {
-        join() {
-          return this;
-        },
-        where(field, value) {
-          assert.equal(field, "wi.id");
-          assert.equal(value, "91");
-          return this;
-        },
-        async first() {
-          return {
-            user_id: 55
-          };
-        }
-      };
-    },
-    event: {
-      entityId: "91"
-    }
-  });
-  assert.deepEqual(createInviteAudienceQueryResult, [{ userId: "55" }]);
-  assert.equal(members?.metadata?.events?.revokeInvite?.[0]?.realtime?.event, "workspace.invites.changed");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.entityId?.({ result: { revokedInviteId: "19" } }), "19");
-  assert.equal(members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.preset, "event_scope");
-  assert.equal(typeof members?.metadata?.events?.revokeInvite?.[1]?.realtime?.audience?.userQuery, "function");
-
-  const pendingApp = createAppDouble();
-  registerWorkspacePendingInvitations(pendingApp.app);
-  const pending = findServiceCall(pendingApp.serviceCalls, "users.workspace.pending-invitations.service");
-  const acceptInviteEvents = Array.isArray(pending?.metadata?.events?.acceptInviteByToken)
-    ? pending.metadata.events.acceptInviteByToken
-    : [];
-  const acceptInviteRealtimeEvents = acceptInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.invitations.pending.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("users.bootstrap.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspaces.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.members.changed"));
-  assert.ok(acceptInviteRealtimeEvents.includes("workspace.invites.changed"));
-
-  const acceptedMembersChange = acceptInviteEvents.find(
-    (entry) => entry?.realtime?.event === "workspace.members.changed"
-  );
-  assert.equal(acceptedMembersChange?.entityId?.({ result: { workspaceId: "9" } }), "9");
-  assert.deepEqual(
-    acceptedMembersChange?.realtime?.audience?.({
-      event: {
-        entityId: "9"
-      }
-    }),
-    {
-      workspaceId: "9"
-    }
-  );
-
-  const acceptedInvitesChange = acceptInviteEvents.find(
-    (entry) => entry?.realtime?.event === "workspace.invites.changed"
-  );
-  assert.equal(acceptedInvitesChange?.entityId?.({ result: { workspaceId: "9" } }), "9");
-
-  const refuseInviteEvents = Array.isArray(pending?.metadata?.events?.refuseInviteByToken)
-    ? pending.metadata.events.refuseInviteByToken
-    : [];
-  const refuseInviteRealtimeEvents = refuseInviteEvents.map((entry) => entry?.realtime?.event).filter(Boolean);
-  assert.ok(refuseInviteRealtimeEvents.includes("workspace.invitations.pending.changed"));
-  assert.ok(refuseInviteRealtimeEvents.includes("users.bootstrap.changed"));
-  assert.ok(refuseInviteRealtimeEvents.includes("workspace.invites.changed"));
-});

package/test/registerUsersCore.test.js

@@ -2,28 +2,19 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { registerUsersCore } from "../src/server/registerUsersCore.js";
 
-test("registerUsersCore registers the workspace action surface alias when action runtime is available", () => {
-  const calls = [];
+test("registerUsersCore only binds users-core singletons", () => {
+  const singletonTokens = [];
   const app = {
-    singleton() {
-      return this;
-    },
-    actionSurfaceSource(sourceName, resolver) {
-      calls.push({
-        sourceName: String(sourceName || ""),
-        resolverType: typeof resolver
-      });
+    singleton(token) {
+      singletonTokens.push(String(token || ""));
       return this;
     }
   };
 
   registerUsersCore(app);
 
-  assert.deepEqual(calls, [
-    {
-      sourceName: "workspace",
-      resolverType: "function"
-    }
+  assert.deepEqual(singletonTokens.sort(), [
+    "users.profile.sync.service"
   ]);
 });
 

package/test/repositoryContracts.test.js

@@ -2,10 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createRepository as createUsersRepository } from "../src/server/common/repositories/usersRepository.js";
 import { createRepository as createUserSettingsRepository } from "../src/server/common/repositories/userSettingsRepository.js";
-import { createRepository as createWorkspaceInvitesRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
-import { createRepository as createWorkspaceMembershipsRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
-import { createRepository as createWorkspacesRepository } from "../src/server/common/repositories/workspacesRepository.js";
-import { createRepository as createWorkspaceSettingsRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
 
 function createKnexStub() {
   const knex = Object.assign(() => {
@@ -23,11 +19,7 @@ test("users-core repositories expose withTransaction", async () => {
   const knex = createKnexStub();
   const repositories = [
     createUsersRepository(knex),
-    createUserSettingsRepository(knex),
-    createWorkspaceInvitesRepository(knex),
-    createWorkspaceMembershipsRepository(knex),
-    createWorkspacesRepository(knex),
-    createWorkspaceSettingsRepository(knex)
+    createUserSettingsRepository(knex)
   ];
 
   for (const repository of repositories) {

package/test/resourcesCanonical.test.js

@@ -4,9 +4,6 @@ import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import "../test-support/registerDefaultSettingsFields.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";
 import { userProfileResource } from "../src/shared/resources/userProfileResource.js";
 import { userSettingsResource } from "../src/shared/resources/userSettingsResource.js";
 
@@ -30,8 +27,6 @@ function assertResourceOperationMessages(resource, operationName, label) {
 
 test("users-core resources expose messages for all operations", () => {
   const resources = {
-    workspace: workspaceResource,
-    workspaceSettings: workspaceSettingsResource,
     userProfile: userProfileResource,
     userSettings: userSettingsResource
   };
@@ -44,18 +39,7 @@ test("users-core resources expose messages for all operations", () => {
 });
 
 test("users-core specialized resource operations expose messages and 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/settingsFieldRegistriesSingleton.test.js

@@ -6,13 +6,8 @@ async function importWithIdentity(url, identity) {
 }
 
 test("settings field registries stay shared across module identities", async () => {
-  const workspaceModuleUrl = new URL("../src/shared/resources/workspaceSettingsFields.js", import.meta.url);
   const userModuleUrl = new URL("../src/shared/resources/userSettingsFields.js", import.meta.url);
 
-  const workspaceA = await importWithIdentity(workspaceModuleUrl, "workspace-a");
-  const workspaceB = await importWithIdentity(workspaceModuleUrl, "workspace-b");
-  assert.equal(workspaceA.workspaceSettingsFields, workspaceB.workspaceSettingsFields);
-
   const userA = await importWithIdentity(userModuleUrl, "user-a");
   const userB = await importWithIdentity(userModuleUrl, "user-b");
   assert.equal(userA.userSettingsFields, userB.userSettingsFields);

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 {
@@ -93,7 +89,7 @@ test("users bootstrap contributor exposes the generic authenticated bootstrap pa
   assert.deepEqual(payload.surfaceAccess, {
     consoleowner: true
   });
-  assert.equal(payload.app.features.workspaceSwitching, false);
+  assert.equal(payload.app.features.assistantEnabled, false);
   assert.deepEqual(payload.session.oauthProviders, [
     {
       id: "google",
@@ -101,12 +97,11 @@ test("users bootstrap contributor exposes the generic authenticated bootstrap pa
     }
   ]);
   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() {
@@ -118,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"
     },
@@ -156,21 +142,11 @@ test("users bootstrap contributor emits canonical tenancy profile for anonymous
     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.deepEqual(payload.surfaceAccess, {
     consoleowner: false
   });

package/test/usersRouteResources.test.js

@@ -7,9 +7,6 @@ import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
 import "../test-support/registerDefaultSettingsFields.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.`);
@@ -48,8 +45,6 @@ function assertResourceShape(resource, label) {
 
 test("workspace and account resources expose canonical validators", () => {
   const resourcesByLabel = {
-    workspace: workspaceResource,
-    workspaceSettings: workspaceSettingsResource,
     userProfile: userProfileResource,
     userSettings: userSettingsResource
   };
@@ -60,18 +55,7 @@ test("workspace and account 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/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 };