@jskit-ai/users-core 0.1.4

package/test/workspaceBootstrapContributor.test.js

@@ -0,0 +1,466 @@
+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 {
+    id: 7,
+    authProvider: "local",
+    authProviderUserId: "user-7",
+    username: "tester",
+    displayName: "Test User",
+    email: "test@example.com",
+    ...overrides
+  };
+}
+
+test("workspace bootstrap contributor passes actor context to pending invites service", async () => {
+  const profile = createAuthenticatedProfile();
+  const pendingServiceCalls = [];
+  const contributor = createWorkspaceBootstrapContributor({
+    workspaceService: {
+      async listWorkspacesForUser() {
+        return [];
+      },
+      async resolveWorkspaceContextForUserBySlug() {
+        return null;
+      }
+    },
+    workspacePendingInvitationsService: {
+      async listPendingInvitesForUser(user, options = {}) {
+        pendingServiceCalls.push({
+          user,
+          options
+        });
+        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: "workspace"
+    }
+  });
+
+  await contributor.contribute({
+    request: {
+      async executeAction() {
+        return {
+          authenticated: true,
+          profile
+        };
+      }
+    },
+    reply: {}
+  });
+
+  assert.equal(pendingServiceCalls.length, 1);
+  assert.equal(pendingServiceCalls[0].user.id, profile.id);
+  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 = [];
+  const contributor = createWorkspaceBootstrapContributor({
+    workspaceService: {
+      async listWorkspacesForUser() {
+        return [];
+      },
+      async resolveWorkspaceContextForUserBySlug(_user, workspaceSlug) {
+        calls.push(workspaceSlug);
+        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: true,
+    appConfig: {
+      tenancyMode: "workspace"
+    }
+  });
+
+  await contributor.contribute({
+    query: {
+      workspaceSlug: "  AcMe  "
+    },
+    request: {
+      async executeAction() {
+        return {
+          authenticated: true,
+          profile
+        };
+      }
+    },
+    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: "workspace"
+    }
+  });
+
+  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(payload.requestedWorkspace, {
+    slug: "tonymobily",
+    status: "forbidden"
+  });
+  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();
+  const contributor = createWorkspaceBootstrapContributor({
+    workspaceService: {
+      async listWorkspacesForUser() {
+        return [{ id: 1, slug: "acme", name: "Acme Workspace" }];
+      },
+      async resolveWorkspaceContextForUserBySlug() {
+        const error = new Error("Workspace not found.");
+        error.status = 404;
+        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: false,
+    appConfig: {
+      tenancyMode: "workspace"
+    }
+  });
+
+  const payload = await contributor.contribute({
+    query: {
+      workspaceSlug: "missing-workspace"
+    },
+    request: {
+      async executeAction() {
+        return {
+          authenticated: true,
+          profile
+        };
+      }
+    },
+    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: "workspace"
+    }
+  });
+
+  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.workspaces, []);
+});

package/test/workspaceInvitationsPolicy.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveWorkspaceInvitationsPolicy } from "../src/server/support/workspaceInvitationsPolicy.js";
+
+test("workspace invitations policy enables invitations by default in personal mode", () => {
+  const policy = resolveWorkspaceInvitationsPolicy({
+    appConfig: {},
+    tenancyProfile: {
+      mode: "personal",
+      workspace: {
+        enabled: true
+      }
+    }
+  });
+
+  assert.equal(policy.enabled, true);
+  assert.equal(policy.allowInPersonalMode, true);
+});
+
+test("workspace invitations policy disables invitations in personal mode when explicitly configured", () => {
+  const policy = resolveWorkspaceInvitationsPolicy({
+    appConfig: {
+      workspaceInvitations: {
+        allowInPersonalMode: false
+      }
+    },
+    tenancyProfile: {
+      mode: "personal",
+      workspace: {
+        enabled: true
+      }
+    }
+  });
+
+  assert.equal(policy.enabled, false);
+  assert.equal(policy.allowInPersonalMode, false);
+});
+
+test("workspace invitations policy disables invitations when workspace mode is disabled", () => {
+  const policy = resolveWorkspaceInvitationsPolicy({
+    appConfig: {},
+    tenancyProfile: {
+      mode: "none",
+      workspace: {
+        enabled: false
+      }
+    }
+  });
+
+  assert.equal(policy.enabled, false);
+  assert.equal(policy.workspaceEnabled, false);
+});
+
+test("workspace invitations policy disables invitations when app config disables feature", () => {
+  const policy = resolveWorkspaceInvitationsPolicy({
+    appConfig: {
+      workspaceInvitations: {
+        enabled: false,
+        allowInPersonalMode: true
+      }
+    },
+    tenancyProfile: {
+      mode: "workspace",
+      workspace: {
+        enabled: true
+      }
+    }
+  });
+
+  assert.equal(policy.enabled, false);
+});

package/test/workspaceInvitesRepository.test.js

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
+
+function createKnexStub() {
+  const state = {
+    insertPayload: null
+  };
+
+  const row = {
+    id: 1,
+    workspace_id: 1,
+    email: "invitee@example.com",
+    role_id: "member",
+    status: "pending",
+    token_hash: "hash",
+    invited_by_user_id: 1,
+    expires_at: "2026-03-16 00:26:35.709",
+    accepted_at: null,
+    revoked_at: null,
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-09 00:26:35.710"
+  };
+
+  function tableBuilder(tableName) {
+    assert.equal(tableName, "workspace_invites");
+    return {
+      insert(payload) {
+        state.insertPayload = payload;
+        return Promise.resolve([1]);
+      },
+      where(criteria) {
+        assert.equal(typeof criteria, "object");
+        return {
+          first() {
+            return Promise.resolve({ ...row });
+          },
+          orderBy() {
+            return {
+              first() {
+                return Promise.resolve({ ...row });
+              }
+            };
+          }
+        };
+      }
+    };
+  }
+
+  return { knexStub: tableBuilder, state };
+}
+
+test("workspaceInvitesRepository.insert normalizes expiresAt ISO input to database datetime", async () => {
+  const { knexStub, state } = createKnexStub();
+  const repository = createRepository(knexStub);
+
+  await repository.insert({
+    workspaceId: 1,
+    email: "invitee@example.com",
+    roleId: "member",
+    status: "pending",
+    tokenHash: "hash",
+    invitedByUserId: 1,
+    expiresAt: "2026-03-16T00:26:35.709Z"
+  });
+
+  assert.equal(state.insertPayload.expires_at, "2026-03-16 00:26:35.709");
+});
+
+test("workspaceInvitesRepository.findPendingByTokenHash reads from invites table without workspace join", async () => {
+  const calls = {
+    tableName: "",
+    whereCriteria: null
+  };
+  const row = {
+    id: 44,
+    workspace_id: 9,
+    email: "invitee@example.com",
+    role_id: "member",
+    status: "pending",
+    token_hash: "hash-token",
+    invited_by_user_id: 1,
+    expires_at: "2030-01-01 00:00:00.000",
+    accepted_at: null,
+    revoked_at: null,
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-09 00:26:35.710"
+  };
+
+  const repository = createRepository((tableName) => {
+    calls.tableName = String(tableName || "");
+    return {
+      where(criteria) {
+        calls.whereCriteria = criteria;
+        return this;
+      },
+      first() {
+        return Promise.resolve({ ...row });
+      }
+    };
+  });
+
+  const invite = await repository.findPendingByTokenHash("hash-token");
+  assert.equal(calls.tableName, "workspace_invites");
+  assert.deepEqual(calls.whereCriteria, {
+    token_hash: "hash-token",
+    status: "pending"
+  });
+  assert.equal(invite?.workspaceId, 9);
+  assert.equal(invite?.workspaceSlug, undefined);
+});