@jskit-ai/users-core 0.1.31 → 0.1.33

package/package.descriptor.mjs

@@ -1,13 +1,14 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-core",
-  version: "0.1.31",
+  version: "0.1.33",
   kind: "runtime",
   description: "Users/workspace domain runtime plus HTTP routes for workspace, account, and console features.",
   dependsOn: [
     "@jskit-ai/auth-core",
     "@jskit-ai/database-runtime",
     "@jskit-ai/http-runtime",
+    "@jskit-ai/uploads-runtime",
     "@jskit-ai/storage-runtime"
   ],
   capabilities: {
@@ -19,6 +20,7 @@ export default Object.freeze({
       "runtime.actions",
       "runtime.database",
       "runtime.storage",
+      "runtime.uploads",
       "auth.provider",
       "auth.policy"
     ]
@@ -93,7 +95,7 @@ export default Object.freeze({
         {
           method: "GET",
           path: "/api/w/:workspaceSlug/roles",
-          summary: "Get workspace role catalog by workspace slug."
+          summary: "Get role catalog by workspace slug."
         },
         {
           method: "GET",
@@ -196,11 +198,11 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.21",
-        "@jskit-ai/database-runtime": "0.1.22",
-        "@jskit-ai/http-runtime": "0.1.21",
-        "@jskit-ai/kernel": "0.1.22",
-        "@fastify/multipart": "^9.4.0",
+        "@jskit-ai/auth-core": "0.1.23",
+        "@jskit-ai/database-runtime": "0.1.24",
+        "@jskit-ai/http-runtime": "0.1.23",
+        "@jskit-ai/kernel": "0.1.24",
+        "@jskit-ai/uploads-runtime": "0.1.2",
         "@fastify/type-provider-typebox": "^6.1.0",
         "typebox": "^1.0.81"
       },
@@ -288,12 +290,12 @@ export default Object.freeze({
         id: "users-core-app-owned-user-settings-fields"
       },
       {
-        from: "templates/config/workspaceRoles.js",
-        to: "config/workspaceRoles.js",
+        from: "templates/config/roles.js",
+        to: "config/roles.js",
         preserveOnRemove: true,
-        reason: "Install app-owned workspace role catalog in a dedicated config file.",
+        reason: "Install app-owned role catalog in a dedicated config file.",
         category: "users-core",
-        id: "users-core-app-owned-workspace-roles-config"
+        id: "users-core-app-owned-role-catalog-config"
       }
     ],
     text: [
@@ -360,11 +362,11 @@ export default Object.freeze({
         op: "append-text",
         file: "config/public.js",
         position: "top",
-        skipIfContains: "import { workspaceRoles } from \"./workspaceRoles.js\";",
-        value: "import { workspaceRoles } from \"./workspaceRoles.js\";\n",
-        reason: "Load app-owned workspace role catalog from dedicated config file.",
+        skipIfContains: "import { roleCatalog } from \"./roles.js\";",
+        value: "import { roleCatalog } from \"./roles.js\";\n",
+        reason: "Load app-owned role catalog from dedicated config file.",
         category: "users-core",
-        id: "users-core-workspace-roles-public-import"
+        id: "users-core-role-catalog-public-import"
       },
       {
         op: "append-text",
@@ -426,11 +428,11 @@ export default Object.freeze({
         op: "append-text",
         file: "config/public.js",
         position: "bottom",
-        skipIfContains: "config.workspaceRoles = workspaceRoles;",
-        value: "\nconfig.workspaceRoles = workspaceRoles;\n",
-        reason: "Bind app-owned workspace role catalog onto public config.",
+        skipIfContains: "config.roleCatalog = roleCatalog;",
+        value: "\nconfig.roleCatalog = roleCatalog;\n",
+        reason: "Bind app-owned role catalog onto public config.",
         category: "users-core",
-        id: "users-core-workspace-roles-public-config"
+        id: "users-core-role-catalog-public-config"
       },
       {
         op: "append-text",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-core",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -24,11 +24,11 @@
     "./shared/resources/consoleSettingsFields": "./src/shared/resources/consoleSettingsFields.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.21",
-    "@jskit-ai/database-runtime": "0.1.22",
-    "@jskit-ai/http-runtime": "0.1.21",
-    "@jskit-ai/kernel": "0.1.22",
-    "@fastify/multipart": "^9.4.0",
+    "@jskit-ai/auth-core": "0.1.23",
+    "@jskit-ai/database-runtime": "0.1.24",
+    "@jskit-ai/http-runtime": "0.1.23",
+    "@jskit-ai/kernel": "0.1.24",
+    "@jskit-ai/uploads-runtime": "0.1.2",
     "@fastify/type-provider-typebox": "^6.1.0",
     "typebox": "^1.0.81"
   }

package/src/server/UsersCoreServiceProvider.js

@@ -23,13 +23,12 @@ import { registerAccountNotifications } from "./accountNotifications/registerAcc
 import { registerAccountProfile } from "./accountProfile/registerAccountProfile.js";
 import { registerAccountSecurity } from "./accountSecurity/registerAccountSecurity.js";
 import { registerConsoleSettings } from "./consoleSettings/registerConsoleSettings.js";
-import { registerAvatarMultipartSupport } from "./accountProfile/registerAvatarMultipartSupport.js";
 import { registerUsersCoreActionSurfaceSources } from "./support/workspaceActionSurfaces.js";
 
 class UsersCoreServiceProvider {
   static id = "users.core";
 
-  static dependsOn = ["runtime.server", "runtime.actions", "runtime.database", "runtime.storage", "auth.provider"];
+  static dependsOn = ["runtime.server", "runtime.actions", "runtime.database", "runtime.storage", "auth.provider", "runtime.uploads"];
 
   register(app) {
     registerUsersCoreActionSurfaceSources(app);
@@ -58,7 +57,6 @@ class UsersCoreServiceProvider {
       bootWorkspaceSettings(app);
       bootWorkspaceMembers(app);
     }
-    await registerAvatarMultipartSupport(app);
     bootAccountProfileRoutes(app);
     bootAccountPreferencesRoutes(app);
     bootAccountNotificationsRoutes(app);

package/src/server/accountNotifications/accountNotificationsService.js

@@ -9,15 +9,15 @@ import {
 
 function createService({
   userSettingsRepository,
-  userProfilesRepository,
+  usersRepository,
   authService
 } = {}) {
-  if (!userSettingsRepository || !userProfilesRepository) {
+  if (!userSettingsRepository || !usersRepository) {
     throw new Error("accountNotificationsService requires repositories.");
   }
 
   async function updateNotifications(request, user, payload = {}, options = {}) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }

package/src/server/accountNotifications/registerAccountNotifications.js

@@ -14,7 +14,7 @@ function registerAccountNotifications(app) {
     (scope) =>
       createAccountNotificationsService({
         userSettingsRepository: scope.make("userSettingsRepository"),
-        userProfilesRepository: scope.make("userProfilesRepository"),
+        usersRepository: scope.make("usersRepository"),
         authService: scope.make("authService")
       }),
     {

package/src/server/accountPreferences/accountPreferencesService.js

@@ -9,15 +9,15 @@ import {
 
 function createService({
   userSettingsRepository,
-  userProfilesRepository,
+  usersRepository,
   authService
 } = {}) {
-  if (!userSettingsRepository || !userProfilesRepository) {
+  if (!userSettingsRepository || !usersRepository) {
     throw new Error("accountPreferencesService requires repositories.");
   }
 
   async function updatePreferences(request, user, payload = {}, options = {}) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }

package/src/server/accountPreferences/registerAccountPreferences.js

@@ -14,7 +14,7 @@ function registerAccountPreferences(app) {
     (scope) =>
       createAccountPreferencesService({
         userSettingsRepository: scope.make("userSettingsRepository"),
-        userProfilesRepository: scope.make("userProfilesRepository"),
+        usersRepository: scope.make("usersRepository"),
         authService: scope.make("authService")
       }),
     {

package/src/server/accountProfile/accountProfileActions.js

@@ -95,10 +95,17 @@ const accountProfileActions = Object.freeze([
     },
     observability: {},
     async execute(input, context, deps) {
+      const avatarUpload = {
+        stream: input.stream,
+        mimeType: input.mimeType,
+        fileName: input.fileName,
+        uploadDimension: input.uploadDimension
+      };
+
       return deps.accountProfileService.uploadAvatar(
         resolveRequest(context),
         resolveActionUser(context, input),
-        input,
+        avatarUpload,
         {
           context
         }
@@ -125,7 +132,6 @@ const accountProfileActions = Object.freeze([
       return deps.accountProfileService.deleteAvatar(
         resolveRequest(context),
         resolveActionUser(context, input),
-        input,
         {
           context
         }

package/src/server/accountProfile/accountProfileService.js

@@ -9,16 +9,16 @@ import {
 
 function createService({
   userSettingsRepository,
-  userProfilesRepository,
+  usersRepository,
   authService,
   avatarService
 } = {}) {
-  if (!userSettingsRepository || !userProfilesRepository || !avatarService) {
+  if (!userSettingsRepository || !usersRepository || !avatarService) {
     throw new Error("accountProfileService requires repositories and avatarService.");
   }
 
   async function getForUser(request, user, options = {}) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }
@@ -35,7 +35,7 @@ function createService({
   }
 
   async function updateProfile(request, user, payload = {}, options = {}) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }
@@ -49,7 +49,7 @@ function createService({
     }
 
     if (!updatedProfile) {
-      updatedProfile = await userProfilesRepository.updateDisplayNameById(profile.id, payload.displayName);
+      updatedProfile = await usersRepository.updateDisplayNameById(profile.id, payload.displayName);
     }
 
     const settings = await userSettingsRepository.ensureForUserId(updatedProfile.id);
@@ -66,11 +66,11 @@ function createService({
     };
   }
 
-  async function uploadAvatar(request, user, payload = {}, options = {}) {
+  async function uploadAvatar(request, user, avatarUpload = {}, options = {}) {
     void options;
 
-    const avatarUpload = await avatarService.uploadForUser(user, payload);
-    const profile = avatarUpload?.profile || null;
+    const result = await avatarService.uploadForUser(user, avatarUpload);
+    const profile = result?.profile || null;
     if (!profile) {
       throw new AppError(500, "Avatar upload completed without a profile result.");
     }
@@ -86,7 +86,7 @@ function createService({
     });
   }
 
-  async function deleteAvatar(request, user, _payload = {}, options = {}) {
+  async function deleteAvatar(request, user, options = {}) {
     void options;
 
     const profile = await avatarService.clearForUser(user);
@@ -101,7 +101,7 @@ function createService({
     });
   }
 
-  async function readAvatar(_request, user, _payload = {}, options = {}) {
+  async function readAvatar(_request, user, options = {}) {
     void options;
 
     const avatar = await avatarService.readForUser(user);

package/src/server/accountProfile/avatarService.js

@@ -1,68 +1,29 @@
-import { AppError, createValidationError } from "@jskit-ai/kernel/server/runtime/errors";
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import { DEFAULT_IMAGE_UPLOAD_POLICY } from "@jskit-ai/uploads-runtime/shared";
+import {
+  normalizeUploadPolicy,
+  readUploadBuffer,
+  validateUploadMimeType
+} from "@jskit-ai/uploads-runtime/server/policy/uploadPolicy";
 import { resolveUserProfile } from "../common/services/accountContextService.js";
 
-const DEFAULT_AVATAR_POLICY = Object.freeze({
-  allowedMimeTypes: Object.freeze(["image/jpeg", "image/png", "image/webp"]),
-  maxUploadBytes: 5 * 1024 * 1024
-});
+const DEFAULT_AVATAR_POLICY = DEFAULT_IMAGE_UPLOAD_POLICY;
 
 function resolveAvatarPolicy(policy = {}) {
-  const source = policy && typeof policy === "object" ? policy : {};
-  const allowedMimeTypes =
-    Array.isArray(source.allowedMimeTypes) && source.allowedMimeTypes.length > 0
-      ? source.allowedMimeTypes
-          .map((value) => String(value || "").trim().toLowerCase())
-          .filter((value) => value.length > 0)
-      : [...DEFAULT_AVATAR_POLICY.allowedMimeTypes];
-  const normalizedMaxUploadBytes = Number(source.maxUploadBytes);
-  const maxUploadBytes =
-    Number.isInteger(normalizedMaxUploadBytes) && normalizedMaxUploadBytes > 0
-      ? normalizedMaxUploadBytes
-      : DEFAULT_AVATAR_POLICY.maxUploadBytes;
-
-  return Object.freeze({
-    allowedMimeTypes: Object.freeze(allowedMimeTypes),
-    maxUploadBytes
-  });
+  return normalizeUploadPolicy(policy, DEFAULT_AVATAR_POLICY);
 }
 
 async function readAvatarBuffer(stream, { maxBytes = DEFAULT_AVATAR_POLICY.maxUploadBytes } = {}) {
-  if (!stream || typeof stream.on !== "function") {
-    throw new TypeError("Avatar upload stream is required.");
-  }
-
-  const chunks = [];
-  let total = 0;
-
-  for await (const chunk of stream) {
-    const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += bufferChunk.length;
-
-    if (total > maxBytes) {
-      throw createValidationError({
-        avatar: `Avatar file is too large. Maximum allowed size is ${Math.floor(maxBytes / (1024 * 1024))}MB.`
-      });
-    }
-
-    chunks.push(bufferChunk);
-  }
-
-  if (chunks.length === 0) {
-    throw createValidationError({
-      avatar: "Avatar file is empty."
-    });
-  }
-
-  return Buffer.concat(chunks);
-}
-
-function normalizeMimeType(value) {
-  return String(value || "").trim().toLowerCase();
+  return readUploadBuffer(stream, {
+    maxBytes,
+    fieldName: "avatar",
+    label: "Avatar"
+  });
 }
 
-function createService({ userProfilesRepository, avatarStorageService, avatarPolicy } = {}) {
-  if (!userProfilesRepository) {
-    throw new TypeError("avatarService requires userProfilesRepository.");
+function createService({ usersRepository, avatarStorageService, avatarPolicy } = {}) {
+  if (!usersRepository) {
+    throw new TypeError("avatarService requires usersRepository.");
   }
   if (!avatarStorageService) {
     throw new TypeError("avatarService requires avatarStorageService.");
@@ -71,23 +32,21 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
   const resolvedAvatarPolicy = resolveAvatarPolicy(avatarPolicy);
 
   async function resolveProfile(user) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }
     return profile;
   }
 
-  async function uploadForUser(user, payload = {}) {
+  async function uploadForUser(user, avatarUpload = {}) {
     const profile = await resolveProfile(user);
-    const mimeType = normalizeMimeType(payload?.mimeType);
-    if (!resolvedAvatarPolicy.allowedMimeTypes.includes(mimeType)) {
-      throw createValidationError({
-        avatar: `Avatar must be one of: ${resolvedAvatarPolicy.allowedMimeTypes.join(", ")}.`
-      });
-    }
+    validateUploadMimeType(avatarUpload?.mimeType, resolvedAvatarPolicy, {
+      fieldName: "avatar",
+      label: "Avatar"
+    });
 
-    const buffer = await readAvatarBuffer(payload.stream, {
+    const buffer = await readAvatarBuffer(avatarUpload?.stream, {
       maxBytes: resolvedAvatarPolicy.maxUploadBytes
     });
 
@@ -98,7 +57,7 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
       buffer
     });
 
-    const updatedProfile = await userProfilesRepository.updateAvatarById(profile.id, {
+    const updatedProfile = await usersRepository.updateAvatarById(profile.id, {
       avatarStorageKey: savedAvatar.storageKey,
       avatarVersion,
       avatarUpdatedAt: new Date(avatarVersionMs)
@@ -114,7 +73,7 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
     if (profile.avatarStorageKey) {
       await avatarStorageService.deleteAvatar(profile.avatarStorageKey);
     }
-    return userProfilesRepository.clearAvatarById(profile.id);
+    return usersRepository.clearAvatarById(profile.id);
   }
 
   async function readForUser(user) {

package/src/server/accountProfile/avatarStorageService.js

@@ -1,10 +1,10 @@
 import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import {
+  createUploadStorageService,
+  detectCommonMimeTypeFromBuffer
+} from "@jskit-ai/uploads-runtime/server/storage/createUploadStorageService";
 
 const AVATAR_STORAGE_PREFIX = "users/avatars";
-const AVATAR_MIME_TYPE_JPEG = "image/jpeg";
-const AVATAR_MIME_TYPE_PNG = "image/png";
-const AVATAR_MIME_TYPE_WEBP = "image/webp";
-const AVATAR_MIME_TYPE_FALLBACK = "application/octet-stream";
 
 function buildAvatarStorageKey(userId) {
   const normalizedUserId = parsePositiveInteger(userId);
@@ -15,106 +15,25 @@ function buildAvatarStorageKey(userId) {
   return `${AVATAR_STORAGE_PREFIX}/${normalizedUserId}/avatar`;
 }
 
-function normalizeStorageKey(value) {
-  const normalized = String(value || "").trim();
-  if (!normalized) {
-    return "";
-  }
-  if (normalized.startsWith("/") || normalized.includes("..")) {
-    return "";
-  }
-  return normalized;
-}
-
-function detectAvatarMimeTypeFromBuffer(buffer) {
-  if (!Buffer.isBuffer(buffer) || buffer.length < 4) {
-    return AVATAR_MIME_TYPE_FALLBACK;
-  }
-
-  if (
-    buffer.length >= 3 &&
-    buffer[0] === 0xff &&
-    buffer[1] === 0xd8 &&
-    buffer[2] === 0xff
-  ) {
-    return AVATAR_MIME_TYPE_JPEG;
-  }
-
-  if (
-    buffer.length >= 8 &&
-    buffer[0] === 0x89 &&
-    buffer[1] === 0x50 &&
-    buffer[2] === 0x4e &&
-    buffer[3] === 0x47 &&
-    buffer[4] === 0x0d &&
-    buffer[5] === 0x0a &&
-    buffer[6] === 0x1a &&
-    buffer[7] === 0x0a
-  ) {
-    return AVATAR_MIME_TYPE_PNG;
-  }
-
-  if (
-    buffer.length >= 12 &&
-    buffer[0] === 0x52 &&
-    buffer[1] === 0x49 &&
-    buffer[2] === 0x46 &&
-    buffer[3] === 0x46 &&
-    buffer[8] === 0x57 &&
-    buffer[9] === 0x45 &&
-    buffer[10] === 0x42 &&
-    buffer[11] === 0x50
-  ) {
-    return AVATAR_MIME_TYPE_WEBP;
-  }
-
-  return AVATAR_MIME_TYPE_FALLBACK;
-}
-
 function createService({ storage } = {}) {
-  if (!storage || typeof storage.getItemRaw !== "function" || typeof storage.setItemRaw !== "function") {
-    throw new TypeError("avatarStorageService requires a storage binding with getItemRaw()/setItemRaw().");
-  }
+  const uploadStorageService = createUploadStorageService({
+    storage,
+    mimeTypeDetector: detectCommonMimeTypeFromBuffer
+  });
 
   async function saveAvatar({ userId, buffer }) {
-    if (!Buffer.isBuffer(buffer)) {
-      throw new TypeError("Avatar buffer must be a Buffer instance.");
-    }
-
-    const storageKey = buildAvatarStorageKey(userId);
-    await storage.setItemRaw(storageKey, buffer);
-
-    return Object.freeze({
-      storageKey
+    return uploadStorageService.saveFile({
+      storageKey: buildAvatarStorageKey(userId),
+      buffer
     });
   }
 
   async function readAvatar(storageKey) {
-    const normalizedStorageKey = normalizeStorageKey(storageKey);
-    if (!normalizedStorageKey) {
-      return null;
-    }
-
-    const value = await storage.getItemRaw(normalizedStorageKey);
-    if (value == null) {
-      return null;
-    }
-
-    const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value);
-    return Object.freeze({
-      storageKey: normalizedStorageKey,
-      buffer,
-      mimeType: detectAvatarMimeTypeFromBuffer(buffer)
-    });
+    return uploadStorageService.readFile(storageKey);
   }
 
   async function deleteAvatar(storageKey) {
-    const normalizedStorageKey = normalizeStorageKey(storageKey);
-    if (!normalizedStorageKey || typeof storage.removeItem !== "function") {
-      return;
-    }
-
-    await storage.removeItem(normalizedStorageKey);
+    await uploadStorageService.deleteFile(storageKey);
   }
 
   return Object.freeze({
@@ -126,7 +45,7 @@ function createService({ storage } = {}) {
 
 const __testables = Object.freeze({
   buildAvatarStorageKey,
-  detectAvatarMimeTypeFromBuffer
+  detectAvatarMimeTypeFromBuffer: detectCommonMimeTypeFromBuffer
 });
 
 export { createService, __testables };

package/src/server/accountProfile/bootAccountProfileRoutes.js

@@ -1,5 +1,6 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+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";
 
@@ -77,7 +78,7 @@ function bootAccountProfileRoutes(app) {
       }
     },
     async function (request, reply) {
-      const avatar = await accountProfileService.readAvatar(request, request.user, {}, {
+      const avatar = await accountProfileService.readAvatar(request, request.user, {
         context: {
           actor: request.user
         }
@@ -113,24 +114,21 @@ function bootAccountProfileRoutes(app) {
       )
     },
     async function (request, reply) {
-      const filePart = await request.file();
-      if (!filePart) {
-        throw new AppError(400, "Validation failed.", {
-          details: {
-            fieldErrors: {
-              avatar: "Avatar file is required."
-            }
-          }
-        });
-      }
+      const filePart = await readSingleMultipartFile(request, {
+        fieldName: "avatar",
+        required: true,
+        fieldErrorKey: "avatar",
+        label: "Avatar",
+        maxBytes: DEFAULT_IMAGE_UPLOAD_MAX_BYTES
+      });
 
       const uploadDimension = filePart.fields?.uploadDimension?.value;
       const response = await request.executeAction({
         actionId: "settings.profile.avatar.upload",
         input: {
-          stream: filePart.file,
-          mimeType: filePart.mimetype,
-          fileName: filePart.filename,
+          stream: filePart.stream,
+          mimeType: filePart.mimeType,
+          fileName: filePart.fileName,
           uploadDimension
         }
       });

package/src/server/accountProfile/registerAccountProfile.js

@@ -20,7 +20,7 @@ function registerAccountProfile(app) {
 
   app.singleton("users.avatar.service", (scope) =>
     createAvatarService({
-      userProfilesRepository: scope.make("userProfilesRepository"),
+      usersRepository: scope.make("usersRepository"),
       avatarStorageService: scope.make("users.avatar.storage.service")
     })
   );
@@ -30,7 +30,7 @@ function registerAccountProfile(app) {
     (scope) =>
       createAccountProfileService({
         userSettingsRepository: scope.make("userSettingsRepository"),
-        userProfilesRepository: scope.make("userProfilesRepository"),
+        usersRepository: scope.make("usersRepository"),
         authService: scope.make("authService"),
         avatarService: scope.make("users.avatar.service")
       }),

package/src/server/accountSecurity/accountSecurityService.js

@@ -10,10 +10,10 @@ import {
 
 function createService({
   userSettingsRepository,
-  userProfilesRepository,
+  usersRepository,
   authService
 } = {}) {
-  if (!userSettingsRepository || !userProfilesRepository) {
+  if (!userSettingsRepository || !usersRepository) {
     throw new Error("accountSecurityService requires repositories.");
   }
 
@@ -40,7 +40,7 @@ function createService({
       throw new AppError(501, "Password method toggle is not available.");
     }
 
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }