@jskit-ai/users-core 0.1.172 → 0.1.173

package/src/server/UsersFeature.js

@@ -0,0 +1,119 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { USERS_SHARED_API } from "../shared/index.js";
+import { buildAccountNotificationsActions } from "./accountNotifications/accountNotificationsActions.js";
+import { createService as createAccountNotificationsService } from "./accountNotifications/accountNotificationsService.js";
+import { registerAccountNotificationsRoutes } from "./accountNotifications/bootAccountNotificationsRoutes.js";
+import { buildAccountPreferencesActions } from "./accountPreferences/accountPreferencesActions.js";
+import { createService as createAccountPreferencesService } from "./accountPreferences/accountPreferencesService.js";
+import { registerAccountPreferencesRoutes } from "./accountPreferences/bootAccountPreferencesRoutes.js";
+import { buildAccountProfileActions } from "./accountProfile/accountProfileActions.js";
+import { createService as createAccountProfileService } from "./accountProfile/accountProfileService.js";
+import { createService as createAvatarService } from "./accountProfile/avatarService.js";
+import { createService as createAvatarStorageService } from "./accountProfile/avatarStorageService.js";
+import { registerAccountProfileRoutes } from "./accountProfile/bootAccountProfileRoutes.js";
+import { buildAccountSecurityActions } from "./accountSecurity/accountSecurityActions.js";
+import { createService as createAccountSecurityService } from "./accountSecurity/accountSecurityService.js";
+import { registerAccountSecurityRoutes } from "./accountSecurity/bootAccountSecurityRoutes.js";
+import { createUsersBootstrapContributor } from "./usersBootstrapContributor.js";
+
+function createUsersRuntime({
+  authService,
+  identity,
+  storage
+} = {}) {
+  const userProfilesRepository = identity.repositories.userProfiles;
+  const userSettingsRepository = identity.repositories.userSettings;
+  const avatarStorageService = createAvatarStorageService({ storage });
+  const avatarService = createAvatarService({ userProfilesRepository, avatarStorageService });
+  const accountProfileService = createAccountProfileService({
+    authService,
+    avatarService,
+    userProfilesRepository,
+    userSettingsRepository
+  });
+  const accountPreferencesService = createAccountPreferencesService({
+    authService,
+    userProfilesRepository,
+    userSettingsRepository
+  });
+  const accountNotificationsService = createAccountNotificationsService({
+    authService,
+    userProfilesRepository,
+    userSettingsRepository
+  });
+  const accountSecurityService = createAccountSecurityService({
+    authService,
+    userProfilesRepository,
+    userSettingsRepository
+  });
+
+  return Object.freeze({
+    repositories: Object.freeze({
+      userProfiles: userProfilesRepository,
+      userSettings: userSettingsRepository
+    }),
+    services: Object.freeze({
+      accountNotifications: accountNotificationsService,
+      accountPreferences: accountPreferencesService,
+      accountProfile: accountProfileService,
+      accountSecurity: accountSecurityService,
+      avatar: avatarService,
+      profileProjector: identity.profileProjector
+    }),
+    shared: USERS_SHARED_API
+  });
+}
+
+const UsersFeature = defineFeature({
+  id: "users.core",
+  domain: "settings",
+  requires: {
+    authService: "auth.service",
+    bootstrap: "runtime.bootstrap",
+    http: "runtime.http",
+    identity: "users.identity",
+    storage: "runtime.storage",
+    uploads: "runtime.uploads"
+  },
+  provides: {
+    users: "users.core"
+  },
+  async setup({
+    authService,
+    bootstrap,
+    http,
+    identity,
+    storage,
+    uploads
+  }) {
+    const users = createUsersRuntime({ authService, identity, storage });
+    registerAccountProfileRoutes(http.router, {
+      accountProfileService: users.services.accountProfile,
+      authService,
+      uploads
+    });
+    registerAccountPreferencesRoutes(http.router);
+    registerAccountNotificationsRoutes(http.router);
+    registerAccountSecurityRoutes(http.router, { authService });
+    bootstrap.register({
+      id: "users.bootstrap",
+      order: 100,
+      contribute: createUsersBootstrapContributor({
+        authService,
+        userProfilesRepository: users.repositories.userProfiles,
+        userSettingsRepository: users.repositories.userSettings
+      }).contribute
+    });
+    return { users };
+  },
+  actions({ users }) {
+    return [
+      ...buildAccountProfileActions({ accountProfileService: users.services.accountProfile }),
+      ...buildAccountPreferencesActions({ accountPreferencesService: users.services.accountPreferences }),
+      ...buildAccountNotificationsActions({ accountNotificationsService: users.services.accountNotifications }),
+      ...buildAccountSecurityActions({ accountSecurityService: users.services.accountSecurity })
+    ];
+  }
+});
+
+export { UsersFeature, createUsersRuntime };

package/src/server/UsersIdentityProvider.js

@@ -0,0 +1,57 @@
+import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
+import {
+  addResourceIfMissing,
+  createJsonRestResourceScopeOptions
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { userProfileResource } from "../shared/resources/userProfileResource.js";
+import { userSettingsResource } from "../shared/resources/userSettingsResource.js";
+import { createRepository as createUserProfilesRepository } from "./common/repositories/userProfilesRepository.js";
+import { createRepository as createUserSettingsRepository } from "./common/repositories/userSettingsRepository.js";
+import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
+
+const UsersIdentityProvider = defineProvider({
+  id: "users.identity",
+  requires: {
+    authExtensions: "auth.extensions",
+    database: "runtime.database",
+    extensions: "users.extensions",
+    jsonRestApi: "runtime.json-rest-api"
+  },
+  provides: {
+    identity: "users.identity"
+  },
+  async setup({ authExtensions, database, extensions, jsonRestApi }) {
+    const scopeOptions = {
+      writeSerializers: { "datetime-utc": toDatabaseDateTimeUtc }
+    };
+    await addResourceIfMissing(
+      jsonRestApi,
+      "userProfiles",
+      createJsonRestResourceScopeOptions(userProfileResource, scopeOptions)
+    );
+    await addResourceIfMissing(
+      jsonRestApi,
+      "userSettings",
+      createJsonRestResourceScopeOptions(userSettingsResource, scopeOptions)
+    );
+    const repositories = Object.freeze({
+      userProfiles: createUserProfilesRepository({ api: jsonRestApi, knex: database.knex }),
+      userSettings: createUserSettingsRepository({ api: jsonRestApi, knex: database.knex })
+    });
+    const profileProjector = createAuthProfileSyncService({
+      userProfilesRepository: repositories.userProfiles,
+      userSettingsRepository: repositories.userSettings,
+      resolveLifecycleContributors: extensions.profileSyncLifecycleContributors
+    });
+    authExtensions.registerProfileProjector({
+      projectorId: "users.profile",
+      ...profileProjector
+    });
+    return {
+      identity: Object.freeze({ repositories, profileProjector })
+    };
+  }
+});
+
+export { UsersIdentityProvider };

package/src/server/accountNotifications/accountNotificationsActions.js

@@ -3,14 +3,15 @@ import {
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
+import { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS } from "../common/support/realtimeServiceEvents.js";
 
-const accountNotificationsActions = Object.freeze([
+const accountNotificationsActionSpecifications = Object.freeze([
   {
     id: "settings.notifications.update",
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -21,8 +22,9 @@ const accountNotificationsActions = Object.freeze([
       actionName: "settings.notifications.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountNotificationsService.updateNotifications(
+    events: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS,
+    async run(accountNotificationsService, input, context) {
+      return accountNotificationsService.updateNotifications(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -34,4 +36,14 @@ const accountNotificationsActions = Object.freeze([
   }
 ]);
 
-export { accountNotificationsActions };
+function buildAccountNotificationsActions({ accountNotificationsService } = {}) {
+  if (!accountNotificationsService) throw new TypeError("buildAccountNotificationsActions requires accountNotificationsService.");
+  return accountNotificationsActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(accountNotificationsService, input, context);
+    }
+  }));
+}
+
+export { accountNotificationsActionSpecifications, buildAccountNotificationsActions };

package/src/server/accountNotifications/bootAccountNotificationsRoutes.js

@@ -2,13 +2,11 @@ import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/share
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { resolveAccountSettingsResourceId } from "../common/support/accountSettingsJsonApiTransport.js";
 
-function bootAccountNotificationsRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootAccountNotificationsRoutes requires application make().");
+function registerAccountNotificationsRoutes(router) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerAccountNotificationsRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "PATCH",
     "/api/settings/notifications",
@@ -38,4 +36,4 @@ function bootAccountNotificationsRoutes(app) {
   );
 }
 
-export { bootAccountNotificationsRoutes };
+export { registerAccountNotificationsRoutes };

package/src/server/accountPreferences/accountPreferencesActions.js

@@ -3,14 +3,15 @@ import {
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
+import { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS } from "../common/support/realtimeServiceEvents.js";
 
-const accountPreferencesActions = Object.freeze([
+const accountPreferencesActionSpecifications = Object.freeze([
   {
     id: "settings.preferences.update",
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -21,8 +22,9 @@ const accountPreferencesActions = Object.freeze([
       actionName: "settings.preferences.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountPreferencesService.updatePreferences(
+    events: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS,
+    async run(accountPreferencesService, input, context) {
+      return accountPreferencesService.updatePreferences(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -34,4 +36,14 @@ const accountPreferencesActions = Object.freeze([
   }
 ]);
 
-export { accountPreferencesActions };
+function buildAccountPreferencesActions({ accountPreferencesService } = {}) {
+  if (!accountPreferencesService) throw new TypeError("buildAccountPreferencesActions requires accountPreferencesService.");
+  return accountPreferencesActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(accountPreferencesService, input, context);
+    }
+  }));
+}
+
+export { accountPreferencesActionSpecifications, buildAccountPreferencesActions };

package/src/server/accountPreferences/bootAccountPreferencesRoutes.js

@@ -2,13 +2,11 @@ import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/share
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { resolveAccountSettingsResourceId } from "../common/support/accountSettingsJsonApiTransport.js";
 
-function bootAccountPreferencesRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootAccountPreferencesRoutes requires application make().");
+function registerAccountPreferencesRoutes(router) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerAccountPreferencesRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "PATCH",
     "/api/settings/preferences",
@@ -38,4 +36,4 @@ function bootAccountPreferencesRoutes(app) {
   );
 }
 
-export { bootAccountPreferencesRoutes };
+export { registerAccountPreferencesRoutes };

package/src/server/accountProfile/accountProfileActions.js

@@ -5,19 +5,20 @@ import {
 import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import { userProfileResource } from "../../shared/resources/userProfileResource.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
+import { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS } from "../common/support/realtimeServiceEvents.js";
 
 const settingsProfileUpdateInputValidator = deepFreeze({
   schema: userProfileResource.operations.patch.body.schema,
   mode: userProfileResource.operations.patch.body.mode
 });
 
-const accountProfileActions = deepFreeze([
+const accountProfileActionSpecifications = deepFreeze([
   {
     id: "settings.read",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -28,8 +29,8 @@ const accountProfileActions = deepFreeze([
       actionName: "settings.read"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountProfileService.getForUser(resolveRequest(context), resolveActionUser(context, input), {
+    async run(accountProfileService, input, context) {
+      return accountProfileService.getForUser(resolveRequest(context), resolveActionUser(context, input), {
         context
       });
     }
@@ -39,7 +40,7 @@ const accountProfileActions = deepFreeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -50,8 +51,9 @@ const accountProfileActions = deepFreeze([
       actionName: "settings.profile.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountProfileService.updateProfile(
+    events: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS,
+    async run(accountProfileService, input, context) {
+      return accountProfileService.updateProfile(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -66,7 +68,7 @@ const accountProfileActions = deepFreeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -77,7 +79,8 @@ const accountProfileActions = deepFreeze([
       actionName: "settings.profile.avatar.upload"
     },
     observability: {},
-    async execute(input, context, deps) {
+    events: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS,
+    async run(accountProfileService, input, context) {
       const avatarUpload = {
         stream: input.stream,
         mimeType: input.mimeType,
@@ -85,7 +88,7 @@ const accountProfileActions = deepFreeze([
         uploadDimension: input.uploadDimension
       };
 
-      return deps.accountProfileService.uploadAvatar(
+      return accountProfileService.uploadAvatar(
         resolveRequest(context),
         resolveActionUser(context, input),
         avatarUpload,
@@ -100,7 +103,7 @@ const accountProfileActions = deepFreeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -111,8 +114,9 @@ const accountProfileActions = deepFreeze([
       actionName: "settings.profile.avatar.delete"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountProfileService.deleteAvatar(
+    events: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS,
+    async run(accountProfileService, input, context) {
+      return accountProfileService.deleteAvatar(
         resolveRequest(context),
         resolveActionUser(context, input),
         {
@@ -123,4 +127,14 @@ const accountProfileActions = deepFreeze([
   }
 ]);
 
-export { accountProfileActions };
+function buildAccountProfileActions({ accountProfileService } = {}) {
+  if (!accountProfileService) throw new TypeError("buildAccountProfileActions requires accountProfileService.");
+  return accountProfileActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(accountProfileService, input, context);
+    }
+  }));
+}
+
+export { accountProfileActionSpecifications, buildAccountProfileActions };

package/src/server/accountProfile/bootAccountProfileRoutes.js

@@ -1,7 +1,6 @@
 import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
 import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
 import { DEFAULT_IMAGE_UPLOAD_MAX_BYTES } from "@jskit-ai/uploads-runtime/shared";
-import { readSingleMultipartFile } from "@jskit-ai/uploads-runtime/server/multipart/readSingleMultipartFile";
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { userProfileResource } from "../../shared/resources/userProfileResource.js";
 import { resolveAccountSettingsResourceId } from "../common/support/accountSettingsJsonApiTransport.js";
@@ -13,12 +12,16 @@ const USER_SETTINGS_RESOURCE_TRANSPORT = Object.freeze({
   getRecordId: resolveAccountSettingsResourceId
 });
 
-function bootAccountProfileRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootAccountProfileRoutes requires application make().");
+function registerAccountProfileRoutes(router, { accountProfileService, authService, uploads } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerAccountProfileRoutes requires router.register().");
+  }
+  if (!accountProfileService || typeof accountProfileService.readAvatar !== "function") {
+    throw new TypeError("registerAccountProfileRoutes requires accountProfileService.");
+  }
+  if (!uploads || typeof uploads.readSingleMultipartFile !== "function") {
+    throw new TypeError("registerAccountProfileRoutes requires runtime.uploads.");
   }
-
-  const router = app.make("jskit.http.router");
 
   router.register(
     "GET",
@@ -63,7 +66,6 @@ function bootAccountProfileRoutes(app) {
         input: request.input.body
       });
 
-      const authService = app.make("authService");
       if (result?.session && typeof authService.writeSessionCookies === "function") {
         authService.writeSessionCookies(reply, result.session);
       }
@@ -83,7 +85,6 @@ function bootAccountProfileRoutes(app) {
       }
     },
     async function (request, reply) {
-      const accountProfileService = app.make("users.accountProfile.service");
       const avatar = await accountProfileService.readAvatar(request, request.user, {
         context: {
           actor: request.user
@@ -120,7 +121,7 @@ function bootAccountProfileRoutes(app) {
       )
     },
     async function (request, reply) {
-      const filePart = await readSingleMultipartFile(request, {
+      const filePart = await uploads.readSingleMultipartFile(request, {
         fieldName: "avatar",
         required: true,
         fieldErrorKey: "avatar",
@@ -165,4 +166,4 @@ function bootAccountProfileRoutes(app) {
   );
 }
 
-export { bootAccountProfileRoutes };
+export { registerAccountProfileRoutes };

package/src/server/accountSecurity/accountSecurityActions.js

@@ -13,13 +13,13 @@ const oauthLinkStartInputValidator = composeSchemaDefinitions([
   context: "accountSecurityActions.oauthLinkStartInputValidator"
 });
 
-const accountSecurityActions = Object.freeze([
+const accountSecurityActionSpecifications = Object.freeze([
   {
     id: "settings.security.password.change",
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -30,8 +30,8 @@ const accountSecurityActions = Object.freeze([
       actionName: "settings.security.password.change"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountSecurityService.changePassword(
+    async run(accountSecurityService, input, context) {
+      return accountSecurityService.changePassword(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -46,7 +46,7 @@ const accountSecurityActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -57,8 +57,8 @@ const accountSecurityActions = Object.freeze([
       actionName: "settings.security.password_method.toggle"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountSecurityService.setPasswordMethodEnabled(
+    async run(accountSecurityService, input, context) {
+      return accountSecurityService.setPasswordMethodEnabled(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -73,7 +73,7 @@ const accountSecurityActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -84,8 +84,8 @@ const accountSecurityActions = Object.freeze([
       actionName: "settings.security.oauth.link.start"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountSecurityService.startOAuthProviderLink(
+    async run(accountSecurityService, input, context) {
+      return accountSecurityService.startOAuthProviderLink(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -100,7 +100,7 @@ const accountSecurityActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -111,8 +111,8 @@ const accountSecurityActions = Object.freeze([
       actionName: "settings.security.oauth.unlink"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountSecurityService.unlinkOAuthProvider(
+    async run(accountSecurityService, input, context) {
+      return accountSecurityService.unlinkOAuthProvider(
         resolveRequest(context),
         resolveActionUser(context, input),
         input,
@@ -127,7 +127,7 @@ const accountSecurityActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -138,12 +138,22 @@ const accountSecurityActions = Object.freeze([
       actionName: "settings.security.sessions.logout_others"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return deps.accountSecurityService.logoutOtherSessions(resolveRequest(context), resolveActionUser(context, input), {
+    async run(accountSecurityService, input, context) {
+      return accountSecurityService.logoutOtherSessions(resolveRequest(context), resolveActionUser(context, input), {
         context
       });
     }
   }
 ]);
 
-export { accountSecurityActions };
+function buildAccountSecurityActions({ accountSecurityService } = {}) {
+  if (!accountSecurityService) throw new TypeError("buildAccountSecurityActions requires accountSecurityService.");
+  return accountSecurityActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(accountSecurityService, input, context);
+    }
+  }));
+}
+
+export { accountSecurityActionSpecifications, buildAccountSecurityActions };

package/src/server/accountSecurity/bootAccountSecurityRoutes.js

@@ -16,13 +16,11 @@ const passwordChangeMetaOutputValidator = deepFreeze({
   mode: "replace"
 });
 
-function bootAccountSecurityRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootAccountSecurityRoutes requires application make().");
+function registerAccountSecurityRoutes(router, { authService } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerAccountSecurityRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "POST",
     "/api/settings/security/change-password",
@@ -50,7 +48,6 @@ function bootAccountSecurityRoutes(app) {
         input: request.input.body
       });
 
-      const authService = app.make("authService");
       if (result?.session && typeof authService.writeSessionCookies === "function") {
         authService.writeSessionCookies(reply, result.session);
       }
@@ -192,4 +189,4 @@ function bootAccountSecurityRoutes(app) {
   );
 }
 
-export { bootAccountSecurityRoutes };
+export { registerAccountSecurityRoutes };