@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/test/workspaceBootstrapContributor.test.js

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createWorkspaceBootstrapContributor } from "../src/server/workspaceBootstrapContributor.js";
+
+function createAuthenticatedProfile(overrides = {}) {
+  return {
+    id: "7",
+    authProvider: "local",
+    authProviderUserSid: "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 [];
+      }
+    },
+    usersRepository: {
+      async findById() {
+        return profile;
+      }
+    },
+    workspaceInvitationsEnabled: true,
+    appConfig: {
+      tenancyMode: "workspaces"
+    }
+  });
+
+  await contributor.contribute({
+    payload: {
+      session: {
+        authenticated: true,
+        userId: profile.id
+      }
+    }
+  });
+
+  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 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 [];
+      }
+    },
+    usersRepository: {
+      async findById() {
+        return profile;
+      }
+    },
+    workspaceInvitationsEnabled: true,
+    appConfig: {
+      tenancyMode: "workspaces"
+    }
+  });
+
+  const payload = await contributor.contribute({
+    query: {
+      workspaceSlug: "  AcMe  "
+    },
+    payload: {
+      session: {
+        authenticated: true,
+        userId: profile.id
+      }
+    }
+  });
+
+  assert.deepEqual(calls, ["acme"]);
+  assert.deepEqual(payload.requestedWorkspace, {
+    slug: "acme",
+    status: "resolved"
+  });
+});
+
+test("workspace bootstrap contributor reports unauthenticated requested workspace without generic bootstrap work", async () => {
+  const contributor = createWorkspaceBootstrapContributor({
+    workspaceService: {
+      async listWorkspacesForUser() {
+        assert.fail("listWorkspacesForUser should not run for unauthenticated payloads");
+      },
+      async resolveWorkspaceContextForUserBySlug() {
+        assert.fail("resolveWorkspaceContextForUserBySlug should not run for unauthenticated payloads");
+      }
+    },
+    workspacePendingInvitationsService: {
+      async listPendingInvitesForUser() {
+        assert.fail("listPendingInvitesForUser should not run for unauthenticated payloads");
+      }
+    },
+    usersRepository: {
+      async findById() {
+        assert.fail("findById should not run for unauthenticated payloads");
+      }
+    },
+    workspaceInvitationsEnabled: true,
+    appConfig: {
+      tenancyMode: "workspaces"
+    }
+  });
+
+  const payload = await contributor.contribute({
+    query: {
+      workspaceSlug: "AcMe"
+    },
+    payload: {
+      session: {
+        authenticated: false
+      }
+    }
+  });
+
+  assert.deepEqual(payload, {
+    tenancy: {
+      mode: "workspaces",
+      workspace: {
+        enabled: true,
+        autoProvision: false,
+        allowSelfCreate: false,
+        slugPolicy: "user_selected"
+      }
+    },
+    app: {
+      features: {
+        workspaceSwitching: true,
+        workspaceInvites: true
+      }
+    },
+    requestedWorkspace: {
+      slug: "acme",
+      status: "unauthenticated"
+    }
+  });
+});

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_sid: "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",
+    roleSid: "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_sid: "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);
+});