@jskit-ai/users-core 0.1.32 → 0.1.35

package/test/workspaceBootstrapContributor.test.js

@@ -1,10 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createWorkspaceBootstrapContributor } from "../src/server/workspaceBootstrapContributor.js";
-import {
-  TENANCY_MODE_PERSONAL,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-} from "../src/shared/tenancyProfile.js";
 
 function createAuthenticatedProfile(overrides = {}) {
   return {
@@ -39,27 +35,11 @@ test("workspace bootstrap contributor passes actor context to pending invites se
         return [];
       }
     },
-    userProfilesRepository: {
-      async findByIdentity() {
+    usersRepository: {
+      async findById() {
         return profile;
       }
     },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {
-          theme: "system",
-          locale: "en",
-          timeZone: "UTC",
-          dateFormat: "YYYY-MM-DD",
-          numberFormat: "1,234.56",
-          currencyCode: "USD",
-          avatarSize: 64,
-          productUpdates: true,
-          accountActivity: true,
-          securityAlerts: true
-        };
-      }
-    },
     workspaceInvitationsEnabled: true,
     appConfig: {
       tenancyMode: "workspaces"
@@ -67,15 +47,12 @@ test("workspace bootstrap contributor passes actor context to pending invites se
   });
 
   await contributor.contribute({
-    request: {
-      async executeAction() {
-        return {
-          authenticated: true,
-          profile
-        };
+    payload: {
+      session: {
+        authenticated: true,
+        userId: profile.id
       }
-    },
-    reply: {}
+    }
   });
 
   assert.equal(pendingServiceCalls.length, 1);
@@ -83,133 +60,6 @@ test("workspace bootstrap contributor passes actor context to pending invites se
   assert.equal(pendingServiceCalls[0].options?.context?.actor?.id, profile.id);
 });
 
-test("workspace bootstrap contributor seeds the initial console owner on authenticated bootstrap", async () => {
-  const profile = createAuthenticatedProfile({ id: 12 });
-  const consoleOwnerSeeds = [];
-
-  const contributor = createWorkspaceBootstrapContributor({
-    workspaceService: {
-      async listWorkspacesForUser() {
-        return [];
-      },
-      async resolveWorkspaceContextForUserBySlug() {
-        return null;
-      }
-    },
-    workspacePendingInvitationsService: {
-      async listPendingInvitesForUser() {
-        return [];
-      }
-    },
-    userProfilesRepository: {
-      async findByIdentity() {
-        return profile;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {
-          theme: "system",
-          locale: "en",
-          timeZone: "UTC",
-          dateFormat: "YYYY-MM-DD",
-          numberFormat: "1,234.56",
-          currencyCode: "USD",
-          avatarSize: 64,
-          productUpdates: true,
-          accountActivity: true,
-          securityAlerts: true
-        };
-      }
-    },
-    workspaceInvitationsEnabled: false,
-    consoleService: {
-      async ensureInitialConsoleMember(userId) {
-        consoleOwnerSeeds.push(Number(userId));
-        return Number(userId);
-      }
-    }
-  });
-
-  const payload = await contributor.contribute({
-    request: {
-      async executeAction() {
-        return {
-          authenticated: true,
-          profile
-        };
-      }
-    },
-    reply: {}
-  });
-
-  assert.deepEqual(consoleOwnerSeeds, [12]);
-  assert.equal(payload.surfaceAccess?.consoleowner, true);
-});
-
-test("workspace bootstrap contributor emits canonical tenancy profile from users-core", async () => {
-  const contributor = createWorkspaceBootstrapContributor({
-    workspaceService: {
-      async listWorkspacesForUser() {
-        return [];
-      },
-      async resolveWorkspaceContextForUserBySlug() {
-        return null;
-      }
-    },
-    workspacePendingInvitationsService: {
-      async listPendingInvitesForUser() {
-        return [];
-      }
-    },
-    userProfilesRepository: {
-      async findByIdentity() {
-        return null;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {};
-      }
-    },
-    workspaceInvitationsEnabled: false,
-    tenancyProfile: {
-      mode: TENANCY_MODE_PERSONAL,
-      workspace: {
-        enabled: true,
-        autoProvision: true,
-        allowSelfCreate: false,
-        slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-      }
-    },
-    appConfig: {
-      tenancyMode: "none"
-    }
-  });
-
-  const payload = await contributor.contribute({
-    request: {
-      async executeAction() {
-        return {
-          authenticated: false
-        };
-      }
-    },
-    reply: {}
-  });
-
-  assert.deepEqual(payload.tenancy, {
-    mode: TENANCY_MODE_PERSONAL,
-    workspace: {
-      enabled: true,
-      autoProvision: true,
-      allowSelfCreate: false,
-      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
-    }
-  });
-  assert.equal(payload.app.tenancyMode, undefined);
-});
-
 test("workspace bootstrap contributor resolves workspace slug from bootstrap query", async () => {
   const profile = createAuthenticatedProfile();
   const calls = [];
@@ -228,163 +78,57 @@ test("workspace bootstrap contributor resolves workspace slug from bootstrap que
         return [];
       }
     },
-    userProfilesRepository: {
-      async findByIdentity() {
+    usersRepository: {
+      async findById() {
         return profile;
       }
     },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {
-          theme: "system",
-          locale: "en",
-          timeZone: "UTC",
-          dateFormat: "YYYY-MM-DD",
-          numberFormat: "1,234.56",
-          currencyCode: "USD",
-          avatarSize: 64,
-          productUpdates: true,
-          accountActivity: true,
-          securityAlerts: true
-        };
-      }
-    },
     workspaceInvitationsEnabled: true,
     appConfig: {
       tenancyMode: "workspaces"
     }
   });
 
-  await contributor.contribute({
+  const payload = await contributor.contribute({
     query: {
       workspaceSlug: "  AcMe  "
     },
-    request: {
-      async executeAction() {
-        return {
-          authenticated: true,
-          profile
-        };
+    payload: {
+      session: {
+        authenticated: true,
+        userId: profile.id
       }
-    },
-    reply: {}
-  });
-
-  assert.deepEqual(calls, ["acme"]);
-});
-
-test("workspace bootstrap contributor returns global payload with requestedWorkspace=forbidden when slug access is denied", async () => {
-  const profile = createAuthenticatedProfile();
-  const contributor = createWorkspaceBootstrapContributor({
-    workspaceService: {
-      async listWorkspacesForUser() {
-        return [{ id: 3, slug: "chiara", name: "Chiara Workspace" }];
-      },
-      async resolveWorkspaceContextForUserBySlug() {
-        const error = new Error("Forbidden.");
-        error.status = 403;
-        throw error;
-      }
-    },
-    workspacePendingInvitationsService: {
-      async listPendingInvitesForUser() {
-        return [];
-      }
-    },
-    userProfilesRepository: {
-      async findByIdentity() {
-        return profile;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {
-          theme: "system",
-          locale: "en",
-          timeZone: "UTC",
-          dateFormat: "YYYY-MM-DD",
-          numberFormat: "1,234.56",
-          currencyCode: "USD",
-          avatarSize: 64,
-          productUpdates: true,
-          accountActivity: true,
-          securityAlerts: true
-        };
-      }
-    },
-    workspaceInvitationsEnabled: true,
-    appConfig: {
-      tenancyMode: "workspaces"
     }
   });
 
-  const payload = await contributor.contribute({
-    query: {
-      workspaceSlug: "tonymobily"
-    },
-    request: {
-      async executeAction() {
-        return {
-          authenticated: true,
-          profile
-        };
-      }
-    },
-    reply: {}
-  });
-
-  assert.equal(payload.session.authenticated, true);
-  assert.deepEqual(payload.workspaces, [{ id: 3, slug: "chiara", name: "Chiara Workspace" }]);
+  assert.deepEqual(calls, ["acme"]);
   assert.deepEqual(payload.requestedWorkspace, {
-    slug: "tonymobily",
-    status: "forbidden"
+    slug: "acme",
+    status: "resolved"
   });
-  assert.equal(payload.activeWorkspace, null);
-  assert.equal(payload.membership, null);
-  assert.deepEqual(payload.permissions, []);
-  assert.equal(payload.workspaceSettings, null);
 });
 
-test("workspace bootstrap contributor returns requestedWorkspace=not_found when slug does not exist", async () => {
-  const profile = createAuthenticatedProfile();
+test("workspace bootstrap contributor reports unauthenticated requested workspace without generic bootstrap work", async () => {
   const contributor = createWorkspaceBootstrapContributor({
     workspaceService: {
       async listWorkspacesForUser() {
-        return [{ id: 1, slug: "acme", name: "Acme Workspace" }];
+        assert.fail("listWorkspacesForUser should not run for unauthenticated payloads");
       },
       async resolveWorkspaceContextForUserBySlug() {
-        const error = new Error("Workspace not found.");
-        error.status = 404;
-        throw error;
+        assert.fail("resolveWorkspaceContextForUserBySlug should not run for unauthenticated payloads");
       }
     },
     workspacePendingInvitationsService: {
       async listPendingInvitesForUser() {
-        return [];
+        assert.fail("listPendingInvitesForUser should not run for unauthenticated payloads");
       }
     },
-    userProfilesRepository: {
-      async findByIdentity() {
-        return profile;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {
-          theme: "system",
-          locale: "en",
-          timeZone: "UTC",
-          dateFormat: "YYYY-MM-DD",
-          numberFormat: "1,234.56",
-          currencyCode: "USD",
-          avatarSize: 64,
-          productUpdates: true,
-          accountActivity: true,
-          securityAlerts: true
-        };
+    usersRepository: {
+      async findById() {
+        assert.fail("findById should not run for unauthenticated payloads");
       }
     },
-    workspaceInvitationsEnabled: false,
+    workspaceInvitationsEnabled: true,
     appConfig: {
       tenancyMode: "workspaces"
     }
@@ -392,75 +136,19 @@ test("workspace bootstrap contributor returns requestedWorkspace=not_found when
 
   const payload = await contributor.contribute({
     query: {
-      workspaceSlug: "missing-workspace"
+      workspaceSlug: "AcMe"
     },
-    request: {
-      async executeAction() {
-        return {
-          authenticated: true,
-          profile
-        };
+    payload: {
+      session: {
+        authenticated: false
       }
-    },
-    reply: {}
-  });
-
-  assert.deepEqual(payload.requestedWorkspace, {
-    slug: "missing-workspace",
-    status: "not_found"
-  });
-  assert.deepEqual(payload.workspaces, [{ id: 1, slug: "acme", name: "Acme Workspace" }]);
-});
-
-test("workspace bootstrap contributor returns requestedWorkspace=unauthenticated for anonymous workspace slug query", async () => {
-  const contributor = createWorkspaceBootstrapContributor({
-    workspaceService: {
-      async listWorkspacesForUser() {
-        return [];
-      },
-      async resolveWorkspaceContextForUserBySlug() {
-        return null;
-      }
-    },
-    workspacePendingInvitationsService: {
-      async listPendingInvitesForUser() {
-        return [];
-      }
-    },
-    userProfilesRepository: {
-      async findByIdentity() {
-        return null;
-      }
-    },
-    userSettingsRepository: {
-      async ensureForUserId() {
-        return {};
-      }
-    },
-    workspaceInvitationsEnabled: false,
-    appConfig: {
-      tenancyMode: "workspaces"
     }
   });
 
-  const payload = await contributor.contribute({
-    query: {
-      workspaceSlug: "tonymobily"
-    },
-    request: {
-      async executeAction() {
-        return {
-          authenticated: false
-        };
-      }
-    },
-    reply: {}
-  });
-
-  assert.equal(payload.session.authenticated, false);
-  assert.deepEqual(payload.requestedWorkspace, {
-    slug: "tonymobily",
-    status: "unauthenticated"
+  assert.deepEqual(payload, {
+    requestedWorkspace: {
+      slug: "acme",
+      status: "unauthenticated"
+    }
   });
-  assert.deepEqual(payload.workspaces, []);
 });

package/test/workspaceMembersService.test.js

@@ -16,8 +16,10 @@ function authorizedOptions(permissions = []) {
 
 function createRoleCatalog() {
   return createWorkspaceRoleCatalog({
-    workspaceRoles: {
-      defaultInviteRole: "member",
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "member"
+      },
       roles: {
         owner: {
           assignable: false,

package/test/workspaceService.test.js

@@ -2,9 +2,11 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { createService } from "../src/server/common/services/workspaceContextService.js";
 
-function createWorkspaceRoles() {
+function createRoleCatalog() {
   return {
-    defaultInviteRole: "member",
+    workspace: {
+      defaultInviteRole: "member"
+    },
     roles: {
       owner: {
         assignable: false,
@@ -21,7 +23,7 @@ function createWorkspaceRoles() {
 function createWorkspaceServiceFixture({
   tenancyMode = "workspaces",
   tenancyPolicy = {},
-  workspaceRoles = createWorkspaceRoles(),
+  roleCatalog = createRoleCatalog(),
   additionalWorkspaces = [],
   userWorkspaceRows = null,
   membershipResolver = null,
@@ -69,7 +71,7 @@ function createWorkspaceServiceFixture({
     appConfig: {
       tenancyMode,
       tenancyPolicy,
-      workspaceRoles: workspaceRoles && typeof workspaceRoles === "object" ? { ...workspaceRoles } : workspaceRoles
+      roleCatalog: roleCatalog && typeof roleCatalog === "object" ? { ...roleCatalog } : roleCatalog
     },
     workspacesRepository: {
       async findBySlug(slug) {
@@ -404,7 +406,7 @@ test("workspaceService.resolveWorkspaceContextForUserBySlug grants owner access
   const service = createService({
     appConfig: {
       tenancyMode: "personal",
-      workspaceRoles: createWorkspaceRoles()
+      roleCatalog: createRoleCatalog()
     },
     workspacesRepository: {
       async findBySlug(slug) {
@@ -468,10 +470,12 @@ test("workspaceService.resolveWorkspaceContextForUserBySlug grants owner access
   assert.deepEqual(context.permissions, ["*"]);
 });
 
-test("workspaceService.resolveWorkspaceContextForUserBySlug resolves permissions from appConfig.workspaceRoles", async () => {
+test("workspaceService.resolveWorkspaceContextForUserBySlug resolves permissions from appConfig.roleCatalog", async () => {
   const { service } = createWorkspaceServiceFixture({
-    workspaceRoles: {
-      defaultInviteRole: "member",
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "member"
+      },
       roles: {
         owner: {
           assignable: false,

package/test/workspaceSettingsResource.test.js

@@ -8,8 +8,10 @@ import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 
 function createRoleCatalog() {
   return createWorkspaceRoleCatalog({
-    workspaceRoles: {
-      defaultInviteRole: "member",
+    roleCatalog: {
+      workspace: {
+        defaultInviteRole: "member"
+      },
       roles: {
         owner: {
           assignable: false,

package/test-support/registerDefaultSettingsFields.js

@@ -1,3 +1,3 @@
-import "../templates/packages/main/src/shared/resources/workspaceSettingsFields.js";
+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/templates/config/workspaceRoles.js

@@ -1,30 +0,0 @@
-export const workspaceRoles = {};
-
-workspaceRoles.defaultInviteRole = "member";
-workspaceRoles.roles = {};
-
-workspaceRoles.roles.owner = {
-  assignable: false,
-  permissions: []
-};
-workspaceRoles.roles.owner.permissions.push("*");
-
-workspaceRoles.roles.admin = {
-  assignable: true,
-  permissions: []
-};
-workspaceRoles.roles.admin.permissions.push(
-  "workspace.roles.view",
-  "workspace.settings.view",
-  "workspace.settings.update",
-  "workspace.members.view",
-  "workspace.members.invite",
-  "workspace.members.manage",
-  "workspace.invites.revoke"
-);
-
-workspaceRoles.roles.member = {
-  assignable: true,
-  permissions: []
-};
-workspaceRoles.roles.member.permissions.push("workspace.settings.view");