@jskit-ai/users-core 0.1.47 → 0.1.49

package/test/workspaceAuthPolicyContextResolver.test.js

@@ -1,119 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createWorkspaceAuthPolicyContextResolver } from "../src/server/common/contributors/workspaceAuthPolicyContextResolver.js";
-
-test("workspace auth policy context resolver returns empty context when policy does not require workspace context", async () => {
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug() {
-        throw new Error("must not be called");
-      }
-    }
-  });
-
-  const resolved = await resolver({
-    request: {
-      params: {
-        workspaceSlug: "acme"
-      }
-    },
-    actor: {
-      id: 7
-    },
-    meta: {
-      contextPolicy: "none",
-      permission: ""
-    }
-  });
-
-  assert.deepEqual(resolved, {});
-});
-
-test("workspace auth policy context resolver resolves workspace context from users workspace service", async () => {
-  const calls = [];
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, options) {
-        calls.push({
-          actor,
-          workspaceSlug,
-          options
-        });
-        return {
-          workspace: {
-            id: 11,
-            slug: workspaceSlug
-          },
-          membership: {
-            roleSid: "owner"
-          },
-          permissions: ["projects.read"]
-        };
-      }
-    }
-  });
-
-  const request = {
-    params: {
-      workspaceSlug: "ACME"
-    }
-  };
-  const actor = {
-    id: 7
-  };
-
-  const resolved = await resolver({
-    request,
-    actor,
-    meta: {
-      contextPolicy: "required"
-    }
-  });
-
-  assert.deepEqual(calls, [
-    {
-      actor,
-      workspaceSlug: "acme",
-      options: {
-        request
-      }
-    }
-  ]);
-  assert.deepEqual(resolved, {
-    workspace: {
-      id: 11,
-      slug: "acme"
-    },
-    membership: {
-      roleSid: "owner"
-    },
-    permissions: ["projects.read"]
-  });
-});
-
-test("workspace auth policy context resolver skips workspace lookup when workspace slug is absent", async () => {
-  let called = false;
-  const resolver = createWorkspaceAuthPolicyContextResolver({
-    workspaceService: {
-      async resolveWorkspaceContextForUserBySlug() {
-        called = true;
-        return {};
-      }
-    }
-  });
-
-  const resolved = await resolver({
-    request: {
-      params: {}
-    },
-    actor: {
-      id: 7
-    },
-    meta: {
-      contextPolicy: "required"
-    }
-  });
-
-  assert.equal(called, false);
-  assert.deepEqual(resolved, {});
-});

package/test/workspaceBootstrapContributor.test.js

@@ -1,154 +0,0 @@
-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, {
-    requestedWorkspace: {
-      slug: "acme",
-      status: "unauthenticated"
-    }
-  });
-});

package/test/workspaceInvitationsPolicy.test.js

@@ -1,71 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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);
-});