@jskit-ai/workspaces-core 0.1.138-oldline.1 → 0.1.138

package/src/server/common/support/realtimeServiceEvents.js

@@ -1,91 +1,132 @@
+import { normalizeDbRecordId } from "@jskit-ai/database-runtime/shared";
+import { createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { deepFreeze } from "./deepFreeze.js";
+import { resolveWorkspace } from "../../support/resolveWorkspace.js";
 
-function resolveActorScopedEntityId({ options } = {}) {
-  return normalizeRecordId(options?.context?.actor?.id, { fallback: "" });
+function resultValue({ result } = {}) {
+  return result?.value ?? result ?? {};
 }
 
-function resolveWorkspaceSlugPayload({ args } = {}) {
+function actorId({ context } = {}) {
+  return context?.actor?.id;
+}
+
+function workspaceId(execution = {}) {
+  return resolveWorkspace(execution.context, execution.input)?.id || resultValue(execution)?.workspaceId;
+}
+
+function workspaceSlugPayload(execution = {}) {
   return {
-    workspaceSlug: String(args?.[0]?.slug || "").trim()
+    workspaceSlug: String(
+      resolveWorkspace(execution.context, execution.input)?.slug || execution.input?.workspaceSlug || ""
+    ).trim()
   };
 }
 
-const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
-  {
-    type: "entity.changed",
-    source: "account",
-    entity: "settings",
-    operation: "updated",
-    entityId: resolveActorScopedEntityId,
-    realtime: {
-      event: "account.settings.changed",
-      audience: "actor_user"
-    }
-  },
-  {
-    type: "entity.changed",
-    source: "users",
-    entity: "bootstrap",
-    operation: "updated",
-    entityId: resolveActorScopedEntityId,
-    realtime: {
-      event: "users.bootstrap.changed",
-      audience: "actor_user"
-    }
+const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
+  preset: "event_scope",
+  async userQuery({ knex, event } = {}) {
+    if (typeof knex !== "function") return [];
+    const inviteId = normalizeRecordId(event?.entityId, { fallback: null });
+    if (!inviteId) return [];
+    const row = await knex("workspace_invites as wi")
+      .join("users as up", "up.email", "wi.email")
+      .where("wi.id", inviteId)
+      .first("up.id as user_id");
+    const userId = normalizeDbRecordId(row?.user_id, { fallback: null });
+    return userId ? [{ userId }] : [];
   }
-]);
+});
 
 function createWorkspaceEntityAndBootstrapEvents({
   workspaceEntity,
   workspaceOperation,
   workspaceRealtimeEvent,
-  workspaceEntityId = ({ args }) => args?.[0]?.id,
-  bootstrapEntityId = ({ args }) => args?.[0]?.id,
+  bootstrapEntityId = workspaceId,
   bootstrapAudience = "event_scope"
 } = {}) {
-  const normalizedWorkspaceEntity = String(workspaceEntity || "").trim();
-  const normalizedWorkspaceOperation = String(workspaceOperation || "")
-    .trim()
-    .toLowerCase();
-  const normalizedWorkspaceRealtimeEvent = String(workspaceRealtimeEvent || "").trim();
-  if (!normalizedWorkspaceEntity || !normalizedWorkspaceOperation || !normalizedWorkspaceRealtimeEvent) {
-    throw new Error(
-      "createWorkspaceEntityAndBootstrapEvents requires workspaceEntity, workspaceOperation, and workspaceRealtimeEvent."
-    );
-  }
-  if (typeof workspaceEntityId !== "function") {
-    throw new Error("createWorkspaceEntityAndBootstrapEvents requires workspaceEntityId to be a function.");
-  }
-  if (typeof bootstrapEntityId !== "function") {
-    throw new Error("createWorkspaceEntityAndBootstrapEvents requires bootstrapEntityId to be a function.");
-  }
-
-  return deepFreeze([
-    {
-      type: "entity.changed",
+  return Object.freeze([
+    createEntityChangedActionEvent({
       source: "workspace",
-      entity: normalizedWorkspaceEntity,
-      operation: normalizedWorkspaceOperation,
-      entityId: (payload = {}) => normalizeRecordId(workspaceEntityId(payload), { fallback: "" }),
+      entity: workspaceEntity,
+      operation: workspaceOperation,
+      entityId: workspaceId,
       realtime: {
-        event: normalizedWorkspaceRealtimeEvent,
-        payload: resolveWorkspaceSlugPayload,
-        audience: "event_scope"
+        event: workspaceRealtimeEvent,
+        audience: "event_scope",
+        payload: workspaceSlugPayload
       }
-    },
-    {
-      type: "entity.changed",
+    }),
+    createEntityChangedActionEvent({
       source: "users",
       entity: "bootstrap",
       operation: "updated",
-      entityId: (payload = {}) => normalizeRecordId(bootstrapEntityId(payload), { fallback: "" }),
+      entityId: bootstrapEntityId,
       realtime: {
         event: "users.bootstrap.changed",
         audience: bootstrapAudience
       }
+    })
+  ]);
+}
+
+function createActorEvent({ source, entity, realtimeEvent }) {
+  return createEntityChangedActionEvent({
+    source,
+    entity,
+    operation: "updated",
+    entityId: actorId,
+    realtime: { event: realtimeEvent, audience: "actor_user" }
+  });
+}
+
+function createWorkspaceAudienceEvent({ entity, realtimeEvent }) {
+  return createEntityChangedActionEvent({
+    source: "workspace",
+    entity,
+    operation: "updated",
+    entityId: ({ result }) => result?.value?.workspaceId ?? result?.workspaceId,
+    realtime: {
+      event: realtimeEvent,
+      audience: ({ result }) => ({ workspaceId: result?.value?.workspaceId ?? result?.workspaceId })
     }
+  });
+}
+
+function onlyAccepted(builder) {
+  return (execution) => execution.input?.decision === "accept" ? builder(execution) : null;
+}
+
+function createInviteDecisionEvents() {
+  return Object.freeze([
+    createActorEvent({
+      source: "workspace",
+      entity: "invitation",
+      realtimeEvent: "workspace.invitations.pending.changed"
+    }),
+    createActorEvent({
+      source: "users",
+      entity: "bootstrap",
+      realtimeEvent: "users.bootstrap.changed"
+    }),
+    onlyAccepted(createActorEvent({
+      source: "workspace",
+      entity: "directory",
+      realtimeEvent: "workspaces.changed"
+    })),
+    onlyAccepted(createWorkspaceAudienceEvent({
+      entity: "member",
+      realtimeEvent: "workspace.members.changed"
+    })),
+    createWorkspaceAudienceEvent({
+      entity: "invite",
+      realtimeEvent: "workspace.invites.changed"
+    })
   ]);
 }
 
-export { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS, createWorkspaceEntityAndBootstrapEvents };
+export {
+  INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE,
+  createInviteDecisionEvents,
+  createWorkspaceEntityAndBootstrapEvents
+};

package/src/server/support/workspaceActionSurfaces.js

@@ -89,17 +89,6 @@ function materializeWorkspaceActionSurfaces(actions = [], { workspaceSurfaceIds
   return Object.freeze(materialized.map((entry) => Object.freeze({ ...entry })));
 }
 
-function registerWorkspaceActionSurfaceSources(app) {
-  if (!app || typeof app.actionSurfaceSource !== "function") {
-    return;
-  }
-
-  app.actionSurfaceSource("workspace", ({ scope }) => {
-    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
-    return resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
-  });
-}
-
 function materializeWorkspaceActionSurfacesFromAppConfig(actions = [], { appConfig = {} } = {}) {
   const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
   return materializeWorkspaceActionSurfaces(actions, { workspaceSurfaceIds });
@@ -130,6 +119,5 @@ export {
   resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig,
   resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
   materializeWorkspaceActionSurfaces,
-  materializeWorkspaceActionSurfacesFromAppConfig,
-  registerWorkspaceActionSurfaceSources
+  materializeWorkspaceActionSurfacesFromAppConfig
 };

package/src/server/workspaceDirectory/bootWorkspaceDirectoryRoutes.js

@@ -25,17 +25,11 @@ function resolveWorkspaceRecordId(record = {}, context = {}) {
   throw new Error("Workspace JSON:API response requires workspace id.");
 }
 
-function bootWorkspaceDirectoryRoutes(app) {
-  if (!app || typeof app.make !== "function" || typeof app.has !== "function") {
-    throw new Error("bootWorkspaceDirectoryRoutes requires application make()/has().");
+function registerWorkspaceDirectoryRoutes(router, { config = {}, workspaceSelfCreateEnabled = false } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerWorkspaceDirectoryRoutes requires router.register().");
   }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
-  const workspaceSelfCreateEnabled = app.has("workspaces.self-create.enabled")
-    ? app.make("workspaces.self-create.enabled") === true
-    : false;
+  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(config);
 
   if (workspaceSelfCreateEnabled) {
     router.register(
@@ -157,4 +151,4 @@ function bootWorkspaceDirectoryRoutes(app) {
   );
 }
 
-export { bootWorkspaceDirectoryRoutes };
+export { registerWorkspaceDirectoryRoutes };

package/src/server/workspaceDirectory/workspaceDirectoryActions.js

@@ -16,13 +16,13 @@ const workspaceUpdateInputValidator = composeSchemaDefinitions([
   context: "workspaceDirectoryActions.workspaceUpdateInputValidator"
 });
 
-const workspaceDirectoryActions = Object.freeze([
+const workspaceDirectoryActionSpecifications = Object.freeze([
   {
     id: "workspace.workspaces.create",
     version: 1,
     kind: "command",
     channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -38,8 +38,8 @@ const workspaceDirectoryActions = Object.freeze([
         description: "Create a workspace for the authenticated user."
       }
     },
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceService.createWorkspaceForAuthenticatedUser(resolveActionUser(context, input), input, {
+    async run(workspaceService, input, context) {
+      return returnJsonApiData(await workspaceService.createWorkspaceForAuthenticatedUser(resolveActionUser(context, input), input, {
         request: resolveRequest(context),
         context
       }));
@@ -50,7 +50,7 @@ const workspaceDirectoryActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -61,9 +61,9 @@ const workspaceDirectoryActions = Object.freeze([
       actionName: "workspace.workspaces.list"
     },
     observability: {},
-    async execute(input, context, deps) {
+    async run(workspaceService, input, context) {
       return returnJsonApiData({
-        items: await deps.workspaceService.listWorkspacesForAuthenticatedUser(resolveActionUser(context, input), {
+        items: await workspaceService.listWorkspacesForAuthenticatedUser(resolveActionUser(context, input), {
           request: resolveRequest(context),
           context
         }),
@@ -76,7 +76,7 @@ const workspaceDirectoryActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "any",
       permissions: ["workspace.settings.view", "workspace.settings.update"]
@@ -88,8 +88,8 @@ const workspaceDirectoryActions = Object.freeze([
       actionName: "workspace.workspaces.read"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceService.getWorkspaceForAuthenticatedUser(
+    async run(workspaceService, input, context) {
+      return returnJsonApiData(await workspaceService.getWorkspaceForAuthenticatedUser(
         resolveActionUser(context, input),
         input.workspaceSlug,
         {
@@ -104,7 +104,7 @@ const workspaceDirectoryActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.settings.update"]
@@ -121,9 +121,9 @@ const workspaceDirectoryActions = Object.freeze([
         description: "Update workspace profile fields."
       }
     },
-    async execute(input, context, deps) {
+    async run(workspaceService, input, context) {
       const { workspaceSlug, ...patch } = input;
-      return returnJsonApiData(await deps.workspaceService.updateWorkspaceForAuthenticatedUser(
+      return returnJsonApiData(await workspaceService.updateWorkspaceForAuthenticatedUser(
         resolveActionUser(context, input),
         workspaceSlug,
         patch,
@@ -136,4 +136,14 @@ const workspaceDirectoryActions = Object.freeze([
   }
 ]);
 
-export { workspaceDirectoryActions };
+function buildWorkspaceDirectoryActions({ workspaceService } = {}) {
+  if (!workspaceService) throw new TypeError("buildWorkspaceDirectoryActions requires workspaceService.");
+  return workspaceDirectoryActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(workspaceService, input, context);
+    }
+  }));
+}
+
+export { workspaceDirectoryActionSpecifications, buildWorkspaceDirectoryActions };

package/src/server/workspaceMembers/bootWorkspaceMembers.js

@@ -28,18 +28,11 @@ function resolveWorkspaceAggregateRecordId(record = {}, context = {}) {
   throw new Error("Workspace JSON:API response requires workspace id.");
 }
 
-function bootWorkspaceMembers(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspaceMembers requires application make().");
+function registerWorkspaceMembersRoutes(router, { config = {}, workspaceInvitationsEnabled = false } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerWorkspaceMembersRoutes requires router.register().");
   }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = typeof app.has === "function" && app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceInvitationsEnabled =
-    typeof app.has === "function" && app.has("workspaces.invitations.enabled")
-      ? app.make("workspaces.invitations.enabled") === true
-      : false;
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
+  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(config);
 
   router.register(
     "GET",
@@ -271,4 +264,4 @@ function bootWorkspaceMembers(app) {
   }
 }
 
-export { bootWorkspaceMembers };
+export { registerWorkspaceMembersRoutes };

package/src/server/workspaceMembers/workspaceMembersActions.js

@@ -3,8 +3,34 @@ import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { resolveWorkspace } from "../support/resolveWorkspace.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
 import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
+import {
+  INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE,
+  createWorkspaceEntityAndBootstrapEvents
+} from "../common/support/realtimeServiceEvents.js";
 import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
 
+const WORKSPACE_MEMBER_CHANGED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "member",
+  workspaceOperation: "updated",
+  workspaceRealtimeEvent: "workspace.members.changed"
+});
+
+const WORKSPACE_INVITE_CREATED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "invite",
+  workspaceOperation: "created",
+  workspaceRealtimeEvent: "workspace.invites.changed",
+  bootstrapEntityId: ({ result } = {}) => result?.value?.createdInviteId,
+  bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
+});
+
+const WORKSPACE_INVITE_REVOKED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "invite",
+  workspaceOperation: "updated",
+  workspaceRealtimeEvent: "workspace.invites.changed",
+  bootstrapEntityId: ({ result } = {}) => result?.value?.revokedInviteId,
+  bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
+});
+
 const updateMemberRoleActionInput = composeSchemaDefinitions([
   workspaceSlugParamsValidator,
   workspaceMembersResource.operations.updateMemberRole.input
@@ -37,13 +63,13 @@ const revokeInviteActionInput = composeSchemaDefinitions([
   context: "workspaceMembersActions.revokeInviteActionInput"
 });
 
-const workspaceMembersActions = Object.freeze([
+const workspaceMembersActionSpecifications = Object.freeze([
   {
     id: "workspace.roles.list",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.roles.view"]
@@ -55,8 +81,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.roles.list"
     },
     observability: {},
-    async execute(_input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listRoles({ context }));
+    async run(workspaceMembersService, _input, context) {
+      return returnJsonApiData(await workspaceMembersService.listRoles({ context }));
     }
   },
   {
@@ -64,7 +90,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.view"]
@@ -76,8 +102,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.members.list"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listMembers(resolveWorkspace(context, input), {
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.listMembers(resolveWorkspace(context, input), {
         context
       }));
     }
@@ -87,7 +113,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.manage"]
@@ -99,8 +125,9 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.member.role.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.updateMemberRole(resolveWorkspace(context, input), {
+    events: WORKSPACE_MEMBER_CHANGED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.updateMemberRole(resolveWorkspace(context, input), {
         memberUserId: input.memberUserId,
         roleSid: input.roleSid
       }, {
@@ -113,7 +140,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.manage"]
@@ -125,8 +152,9 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.member.remove"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.removeMember(resolveWorkspace(context, input), {
+    events: WORKSPACE_MEMBER_CHANGED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.removeMember(resolveWorkspace(context, input), {
         memberUserId: input.memberUserId
       }, {
         context
@@ -138,7 +166,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.view"]
@@ -150,8 +178,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invites.list"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listInvites(resolveWorkspace(context, input), {
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.listInvites(resolveWorkspace(context, input), {
         context
       }));
     }
@@ -161,7 +189,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.invite"]
@@ -173,13 +201,14 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invite.create"
     },
     observability: {},
+    events: WORKSPACE_INVITE_CREATED_EVENTS,
     extensions: {
       assistant: {
         description: "Invite a person to the workspace."
       }
     },
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.createInvite(
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.createInvite(
         resolveWorkspace(context, input),
         resolveActionUser(context, input),
         {
@@ -197,7 +226,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.invites.revoke"]
@@ -209,12 +238,23 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invite.revoke"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.revokeInvite(resolveWorkspace(context, input), input.inviteId, {
+    events: WORKSPACE_INVITE_REVOKED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.revokeInvite(resolveWorkspace(context, input), input.inviteId, {
         context
       }));
     }
   }
 ]);
 
-export { workspaceMembersActions };
+function buildWorkspaceMembersActions({ workspaceMembersService } = {}) {
+  if (!workspaceMembersService) throw new TypeError("buildWorkspaceMembersActions requires workspaceMembersService.");
+  return workspaceMembersActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(workspaceMembersService, input, context);
+    }
+  }));
+}
+
+export { workspaceMembersActionSpecifications, buildWorkspaceMembersActions };

package/src/server/workspacePendingInvitations/bootWorkspacePendingInvitations.js

@@ -24,13 +24,11 @@ function resolveInviteResolutionRecordId(record = {}) {
   return "workspace-invitation";
 }
 
-function bootWorkspacePendingInvitations(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspacePendingInvitations requires application make().");
+function registerWorkspacePendingInvitationsRoutes(router) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerWorkspacePendingInvitationsRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "GET",
     "/api/workspace/invitations/resolve",
@@ -110,4 +108,4 @@ function bootWorkspacePendingInvitations(app) {
   );
 }
 
-export { bootWorkspacePendingInvitations };
+export { registerWorkspacePendingInvitationsRoutes };