@jskit-ai/workspaces-core 0.1.137 → 0.1.138

package/test/registerServiceRealtimeEvents.test.js

@@ -1,116 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
-import { registerWorkspacePendingInvitations } from "../src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js";
-
-function createAppDouble() {
-  const serviceCalls = [];
-
-  return {
-    serviceCalls,
-    app: {
-      singleton() {
-        return this;
-      },
-      service(token, factory, metadata) {
-        serviceCalls.push({
-          token,
-          factory,
-          metadata
-        });
-        return this;
-      },
-      actions() {
-        return this;
-      }
-    }
-  };
-}
-
-function findServiceCall(serviceCalls, token) {
-  return serviceCalls.find((entry) => entry.token === token) || null;
-}
-
-test("workspace register functions publish members/invites/workspace-list realtime events", async () => {
-  const membersApp = createAppDouble();
-  registerWorkspaceMembers(membersApp.app);
-  const members = findServiceCall(membersApp.serviceCalls, "workspaces.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, "workspaces.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/registerWorkspaceBootstrap.test.js

@@ -1,86 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceBootstrap } from "../src/server/registerWorkspaceBootstrap.js";
-
-function createAppDouble() {
-  const singletons = new Map();
-  const tags = [];
-
-  return {
-    singletons,
-    tags,
-    app: {
-      singleton(token, factory) {
-        singletons.set(token, factory);
-        return this;
-      },
-      tag(token, name) {
-        tags.push({ token, name });
-        return this;
-      }
-    }
-  };
-}
-
-test("registerWorkspaceBootstrap resolves the canonical pending invitations service token when enabled", () => {
-  const { app, singletons, tags } = createAppDouble();
-  registerWorkspaceBootstrap(app);
-
-  assert.deepEqual(tags, [
-    {
-      token: "workspaces.core.bootstrap.payloadContributor",
-      name: "jskit.runtime.bootstrap.payloadContributors"
-    }
-  ]);
-
-  const factory = singletons.get("workspaces.core.bootstrap.payloadContributor");
-  assert.equal(typeof factory, "function");
-
-  const resolvedTokens = [];
-  factory({
-    make(token) {
-      resolvedTokens.push(token);
-
-      if (token === "workspaces.invitations.enabled") {
-        return true;
-      }
-      if (token === "workspaces.service") {
-        return {
-          listWorkspacesForUser() {},
-          resolveWorkspaceContextForUserBySlug() {}
-        };
-      }
-      if (token === "workspaces.pending-invitations.service") {
-        return {
-          listPendingInvitesForUser() {}
-        };
-      }
-      if (token === "internal.repository.user-profiles") {
-        return {
-          findById() {}
-        };
-      }
-      if (token === "config") {
-        return {
-          tenancyMode: "workspaces"
-        };
-      }
-      if (token === "workspaces.tenancy.profile") {
-        return {
-          mode: "workspaces",
-          workspace: {
-            enabled: true,
-            autoProvision: false,
-            allowSelfCreate: false,
-            slugPolicy: "user_selected"
-          }
-        };
-      }
-
-      throw new Error(`Unexpected token: ${token}`);
-    }
-  });
-
-  assert.ok(resolvedTokens.includes("workspaces.pending-invitations.service"));
-  assert.ok(!resolvedTokens.includes("users.workspace.pending-invitations.service"));
-});

package/test/registerWorkspaceDirectory.test.js

@@ -1,31 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceDirectory } from "../src/server/workspaceDirectory/registerWorkspaceDirectory.js";
-
-function createAppDouble() {
-  const actionBatches = [];
-
-  return {
-    actionBatches,
-    singleton() {},
-    actions(entries) {
-      actionBatches.push(Array.isArray(entries) ? entries : [entries]);
-    }
-  };
-}
-
-function listActionIds(app) {
-  return app.actionBatches.flat().map((entry) => String(entry?.id || ""));
-}
-
-test("registerWorkspaceDirectory registers workspace directory actions without resolving runtime tenancy tokens", () => {
-  const app = createAppDouble();
-
-  registerWorkspaceDirectory(app);
-  assert.deepEqual(listActionIds(app), [
-    "workspace.workspaces.create",
-    "workspace.workspaces.list",
-    "workspace.workspaces.read",
-    "workspace.workspaces.update"
-  ]);
-});

package/test/registerWorkspaceMembers.test.js

@@ -1,140 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceMembers } from "../src/server/workspaceMembers/registerWorkspaceMembers.js";
-
-function createAppDouble() {
-  const serviceCalls = [];
-
-  return {
-    serviceCalls,
-    app: {
-      singleton() {
-        return this;
-      },
-      service(token, factory, metadata) {
-        serviceCalls.push({
-          token,
-          factory,
-          metadata
-        });
-        return this;
-      },
-      actions() {
-        return this;
-      }
-    }
-  };
-}
-
-function createScopeDouble(bindings = {}) {
-  return {
-    has(token) {
-      return Object.hasOwn(bindings, token);
-    },
-    make(token) {
-      if (!Object.hasOwn(bindings, token)) {
-        throw new Error(`Missing test binding: ${token}`);
-      }
-      const binding = bindings[token];
-      return typeof binding === "function" && token !== "appConfig" ? binding(this) : binding;
-    }
-  };
-}
-
-test("registerWorkspaceMembers uses app-owned workspace invite email template from appConfig", async () => {
-  const templateCalls = [];
-  const mailerCalls = [];
-  const fixture = createAppDouble();
-  registerWorkspaceMembers(fixture.app);
-  const serviceCall = fixture.serviceCalls.find((entry) => entry.token === "workspaces.members.service");
-
-  const service = serviceCall.factory(createScopeDouble({
-    appConfig: {
-      workspaceMembers: {
-        defaults: {
-          inviteExpiresInMs: 60_000
-        }
-      },
-      roleCatalog: {
-        workspace: {
-          defaultInviteRole: "member"
-        },
-        roles: {
-          owner: {
-            assignable: false,
-            permissions: ["*"]
-          },
-          member: {
-            assignable: true,
-            permissions: ["workspace.members.view"]
-          }
-        }
-      },
-      workspaceInviteEmailTemplate(payload) {
-        templateCalls.push(payload);
-        return {
-          subject: "Custom invite",
-          text: payload.inviteUrl,
-          html: null
-        };
-      }
-    },
-    "jskit.env": {
-      APP_PUBLIC_URL: "https://app.example.test"
-    },
-    "workspaces.invitations.enabled": true,
-    "workspaces.invite.mailer": {
-      async sendWorkspaceInvite(payload) {
-        mailerCalls.push(payload);
-        return {
-          status: "sent",
-          message: "sent",
-          providerMessageId: "msg-custom"
-        };
-      }
-    },
-    "internal.repository.workspace-memberships": {
-      async listActiveByWorkspaceId() {
-        return [];
-      }
-    },
-    "internal.repository.workspace-invites": {
-      async listPendingByWorkspaceIdWithWorkspace() {
-        return [];
-      },
-      async expirePendingByWorkspaceIdAndEmail() {},
-      async insert(payload) {
-        return {
-          id: "91",
-          expiresAt: payload.expiresAt
-        };
-      },
-      async findPendingByIdForWorkspace() {
-        return null;
-      },
-      async revokeById() {}
-    }
-  }));
-
-  const result = await service.createInvite(
-    {
-      id: "7",
-      slug: "acme",
-      name: "Acme",
-      ownerUserId: "9",
-      avatarUrl: ""
-    },
-    { id: "9", email: "owner@example.com" },
-    {
-      email: "invitee@example.com",
-      roleSid: "member"
-    }
-  );
-
-  assert.equal(result.inviteDelivery.providerMessageId, "msg-custom");
-  assert.equal(templateCalls.length, 1);
-  assert.equal(templateCalls[0].workspace.name, "Acme");
-  assert.equal(mailerCalls.length, 1);
-  assert.equal(mailerCalls[0].message.subject, "Custom invite");
-  assert.match(mailerCalls[0].inviteUrl, /^https:\/\/app\.example\.test\/invite\//);
-});

package/test/registerWorkspaceSettings.test.js

@@ -1,40 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerWorkspaceSettings } from "../src/server/workspaceSettings/registerWorkspaceSettings.js";
-
-test("registerWorkspaceSettings registers workspace settings service realtime event metadata", () => {
-  const singletonBindings = new Map();
-  const actionCalls = [];
-  const serviceCalls = [];
-
-  const app = {
-    singleton(token, factory) {
-      singletonBindings.set(token, factory);
-      return this;
-    },
-    service(token, factory, metadata) {
-      serviceCalls.push({
-        token,
-        factory,
-        metadata
-      });
-      return this;
-    },
-    actions(definitions) {
-      actionCalls.push(definitions);
-      return this;
-    }
-  };
-
-  registerWorkspaceSettings(app);
-
-  assert.equal(singletonBindings.has("internal.repository.workspace-settings"), true);
-  assert.equal(serviceCalls.length, 1);
-  assert.equal(serviceCalls[0].token, "workspaces.settings.service");
-  assert.equal(typeof serviceCalls[0].factory, "function");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.event, "workspace.settings.changed");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[0]?.realtime?.audience, "event_scope");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(serviceCalls[0].metadata?.events?.updateWorkspaceSettings?.[1]?.realtime?.audience, "event_scope");
-  assert.equal(actionCalls.length, 1);
-});

package/test/workspaceServerScopeSupport.test.js

@@ -1,131 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { AUTH_POLICY_CONTEXT_RESOLVER_TAG } from "@jskit-ai/auth-core/server/authPolicyContextResolverRegistry";
-import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
-import { PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG } from "@jskit-ai/users-core/server/profileSyncLifecycleContributorRegistry";
-import { createWorkspaceServerScopeSupport } from "../src/server/support/workspaceServerScopeSupport.js";
-import { registerWorkspaceCore } from "../src/server/registerWorkspaceCore.js";
-
-test("workspace server scope support exposes the canonical workspace helper surface", async () => {
-  const support = createWorkspaceServerScopeSupport();
-
-  assert.equal(support.available, true);
-  assert.equal(typeof support.params?.schema, "object");
-  assert.equal(support.params?.mode, "patch");
-  assert.deepEqual(
-    await validateSchemaPayload(support.params, { workspaceSlug: "  ACME  " }, {
-      phase: "input",
-      context: "workspaceServerScopeSupport.params"
-    }),
-    {
-      workspaceSlug: "acme"
-    }
-  );
-  assert.deepEqual(support.buildInputFromRouteParams({ workspaceSlug: "  ACME  " }), {
-    workspaceSlug: "acme"
-  });
-  assert.deepEqual(
-    support.resolveWorkspace(
-      {
-        requestMeta: {
-          resolvedWorkspaceContext: {
-            workspace: {
-              id: 7,
-              slug: "acme"
-            }
-          }
-        }
-      },
-      {}
-    ),
-    {
-      id: 7,
-      slug: "acme"
-    }
-  );
-});
-
-test("registerWorkspaceCore registers the workspace server scope support token", () => {
-  const singletons = new Map();
-  const tags = new Map();
-  const app = {
-    singleton(token, factory) {
-      singletons.set(token, factory);
-      return this;
-    },
-    tag(token, tagName) {
-      const key = String(tagName || "");
-      const list = tags.get(key) || [];
-      list.push(String(token || ""));
-      tags.set(key, list);
-      return this;
-    },
-    has() {
-      return false;
-    }
-  };
-
-  registerWorkspaceCore(app);
-
-  assert.equal(singletons.has("workspaces.server.scope-support"), true);
-  assert.deepEqual(tags.get(AUTH_POLICY_CONTEXT_RESOLVER_TAG), ["workspaces.core.authPolicyContextResolver"]);
-  const support = singletons.get("workspaces.server.scope-support")();
-  assert.equal(support.available, true);
-  assert.equal(typeof support.buildInputFromRouteParams, "function");
-  assert.equal(typeof support.resolveWorkspace, "function");
-});
-
-test("registerWorkspaceCore ensures personal workspace provisioning on every authenticated profile sync", async () => {
-  const singletons = new Map();
-  const tags = new Map();
-  const app = {
-    singleton(token, factory) {
-      singletons.set(token, factory);
-      return this;
-    },
-    tag(token, tagName) {
-      const key = String(tagName || "");
-      const list = tags.get(key) || [];
-      list.push(String(token || ""));
-      tags.set(key, list);
-      return this;
-    },
-    has() {
-      return false;
-    }
-  };
-
-  registerWorkspaceCore(app);
-
-  assert.deepEqual(tags.get(PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG), ["workspaces.core.profileSyncLifecycleContributor"]);
-
-  const lifecycleFactory = singletons.get("workspaces.core.profileSyncLifecycleContributor");
-  assert.equal(typeof lifecycleFactory, "function");
-
-  const calls = [];
-  const contributor = lifecycleFactory({
-    make(token) {
-      if (token === "workspaces.service") {
-        return {
-          async ensureProvisionedWorkspaceForAuthenticatedUser(profile, options = {}) {
-            calls.push({ profile, options });
-          }
-        };
-      }
-      throw new Error(`Unexpected token: ${token}`);
-    }
-  });
-
-  await contributor.afterIdentityProfileSynced({
-    profile: { id: "7", username: "tonymobily" },
-    created: false,
-    options: { trx: { id: "tx-1" } }
-  });
-
-  assert.deepEqual(calls, [
-    {
-      profile: { id: "7", username: "tonymobily" },
-      options: { trx: { id: "tx-1" } }
-    }
-  ]);
-});