@jskit-ai/users-core 0.1.4

package/src/server/accountNotifications/bootAccountNotificationsRoutes.js

@@ -0,0 +1,41 @@
+import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
+
+function bootAccountNotificationsRoutes(app) {
+  if (!app || typeof app.make !== "function") {
+    throw new Error("bootAccountNotificationsRoutes requires application make().");
+  }
+
+  const router = app.make(KERNEL_TOKENS.HttpRouter);
+
+  router.register(
+    "PATCH",
+    "/api/settings/notifications",
+    {
+      auth: "required",
+      meta: {
+        tags: ["settings"],
+        summary: "Update notification settings"
+      },
+      bodyValidator: userSettingsResource.operations.notificationsUpdate.bodyValidator,
+      responseValidators: withStandardErrorResponses(
+        {
+          200: userSettingsResource.operations.view.outputValidator
+        },
+        { includeValidation400: true }
+      )
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "settings.notifications.update",
+        input: {
+          payload: request.input.body
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+}
+
+export { bootAccountNotificationsRoutes };

package/src/server/accountNotifications/registerAccountNotifications.js

@@ -0,0 +1,39 @@
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { createService as createAccountNotificationsService } from "./accountNotificationsService.js";
+import { accountNotificationsActions } from "./accountNotificationsActions.js";
+import { deepFreeze } from "../common/support/deepFreeze.js";
+import { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS } from "../common/support/realtimeServiceEvents.js";
+
+const USERS_ACCOUNT_NOTIFICATIONS_SERVICE_TOKEN = "users.accountNotifications.service";
+
+function registerAccountNotifications(app) {
+  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
+    throw new Error("registerAccountNotifications requires application singleton()/service()/actions().");
+  }
+
+  app.service(
+    USERS_ACCOUNT_NOTIFICATIONS_SERVICE_TOKEN,
+    (scope) =>
+      createAccountNotificationsService({
+        userSettingsRepository: scope.make("userSettingsRepository"),
+        userProfilesRepository: scope.make("userProfilesRepository"),
+        authService: scope.make("authService")
+      }),
+    {
+      events: deepFreeze({
+        updateNotifications: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS
+      })
+    }
+  );
+
+  app.actions(
+    withActionDefaults(accountNotificationsActions, {
+      domain: "settings",
+      dependencies: {
+        accountNotificationsService: USERS_ACCOUNT_NOTIFICATIONS_SERVICE_TOKEN
+      }
+    })
+  );
+}
+
+export { registerAccountNotifications };

package/src/server/accountPreferences/accountPreferencesActions.js

@@ -0,0 +1,39 @@
+import {
+  resolveRequest
+} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
+import { resolveActionUser } from "../common/support/resolveActionUser.js";
+
+const accountPreferencesActions = Object.freeze([
+  {
+    id: "settings.preferences.update",
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: {
+      payload: userSettingsResource.operations.preferencesUpdate.bodyValidator
+    },
+    outputValidator: userSettingsResource.operations.view.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: "settings.preferences.update"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.accountPreferencesService.updatePreferences(
+        resolveRequest(context),
+        resolveActionUser(context, input),
+        input.payload,
+        {
+          context
+        }
+      );
+    }
+  }
+]);
+
+export { accountPreferencesActions };

package/src/server/accountPreferences/accountPreferencesService.js

@@ -0,0 +1,41 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import {
+  resolveUserProfile,
+  resolveSecurityStatus
+} from "../common/services/accountContextService.js";
+import {
+  accountSettingsResponseFormatter
+} from "../common/formatters/accountSettingsResponseFormatter.js";
+
+function createService({
+  userSettingsRepository,
+  userProfilesRepository,
+  authService
+} = {}) {
+  if (!userSettingsRepository || !userProfilesRepository) {
+    throw new Error("accountPreferencesService requires repositories.");
+  }
+
+  async function updatePreferences(request, user, payload = {}, options = {}) {
+    const profile = await resolveUserProfile(userProfilesRepository, user);
+    if (!profile) {
+      throw new AppError(404, "User profile was not found.");
+    }
+
+    const settings = await userSettingsRepository.updatePreferences(profile.id, payload);
+    const securityStatus = await resolveSecurityStatus(authService, request);
+
+    return accountSettingsResponseFormatter({
+      profile,
+      settings,
+      securityStatus,
+      authService
+    });
+  }
+
+  return Object.freeze({
+    updatePreferences
+  });
+}
+
+export { createService };

package/src/server/accountPreferences/bootAccountPreferencesRoutes.js

@@ -0,0 +1,41 @@
+import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
+
+function bootAccountPreferencesRoutes(app) {
+  if (!app || typeof app.make !== "function") {
+    throw new Error("bootAccountPreferencesRoutes requires application make().");
+  }
+
+  const router = app.make(KERNEL_TOKENS.HttpRouter);
+
+  router.register(
+    "PATCH",
+    "/api/settings/preferences",
+    {
+      auth: "required",
+      meta: {
+        tags: ["settings"],
+        summary: "Update user preferences"
+      },
+      bodyValidator: userSettingsResource.operations.preferencesUpdate.bodyValidator,
+      responseValidators: withStandardErrorResponses(
+        {
+          200: userSettingsResource.operations.view.outputValidator
+        },
+        { includeValidation400: true }
+      )
+    },
+    async function (request, reply) {
+      const response = await request.executeAction({
+        actionId: "settings.preferences.update",
+        input: {
+          payload: request.input.body
+        }
+      });
+      reply.code(200).send(response);
+    }
+  );
+}
+
+export { bootAccountPreferencesRoutes };

package/src/server/accountPreferences/registerAccountPreferences.js

@@ -0,0 +1,39 @@
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { createService as createAccountPreferencesService } from "./accountPreferencesService.js";
+import { accountPreferencesActions } from "./accountPreferencesActions.js";
+import { deepFreeze } from "../common/support/deepFreeze.js";
+import { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS } from "../common/support/realtimeServiceEvents.js";
+
+const USERS_ACCOUNT_PREFERENCES_SERVICE_TOKEN = "users.accountPreferences.service";
+
+function registerAccountPreferences(app) {
+  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
+    throw new Error("registerAccountPreferences requires application singleton()/service()/actions().");
+  }
+
+  app.service(
+    USERS_ACCOUNT_PREFERENCES_SERVICE_TOKEN,
+    (scope) =>
+      createAccountPreferencesService({
+        userSettingsRepository: scope.make("userSettingsRepository"),
+        userProfilesRepository: scope.make("userProfilesRepository"),
+        authService: scope.make("authService")
+      }),
+    {
+      events: deepFreeze({
+        updatePreferences: ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS
+      })
+    }
+  );
+
+  app.actions(
+    withActionDefaults(accountPreferencesActions, {
+      domain: "settings",
+      dependencies: {
+        accountPreferencesService: USERS_ACCOUNT_PREFERENCES_SERVICE_TOKEN
+      }
+    })
+  );
+}
+
+export { registerAccountPreferences };

package/src/server/accountProfile/accountProfileActions.js

@@ -0,0 +1,137 @@
+import {
+  EMPTY_INPUT_VALIDATOR,
+  resolveRequest
+} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { Type } from "typebox";
+import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
+import { userProfileResource } from "../../shared/resources/userProfileResource.js";
+import { resolveActionUser } from "../common/support/resolveActionUser.js";
+
+const settingsProfileUpdateOutputValidator = Object.freeze({
+  schema: Type.Object(
+    {
+      settings: userSettingsResource.operations.view.outputValidator.schema,
+      session: Type.Union([Type.Object({}, { additionalProperties: true }), Type.Null()])
+    },
+    { additionalProperties: false }
+  ),
+  normalize(payload = {}) {
+    const source = normalizeObjectInput(payload);
+
+    return {
+      settings: userSettingsResource.operations.view.outputValidator.normalize(source.settings),
+      session: source.session && typeof source.session === "object" ? source.session : null
+    };
+  }
+});
+
+const accountProfileActions = Object.freeze([
+  {
+    id: "settings.read",
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: EMPTY_INPUT_VALIDATOR,
+    outputValidator: userSettingsResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: "settings.read"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.accountProfileService.getForUser(resolveRequest(context), resolveActionUser(context, input), {
+        context
+      });
+    }
+  },
+  {
+    id: "settings.profile.update",
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: {
+      payload: userProfileResource.operations.patch.bodyValidator
+    },
+    outputValidator: settingsProfileUpdateOutputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: "settings.profile.update"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.accountProfileService.updateProfile(
+        resolveRequest(context),
+        resolveActionUser(context, input),
+        input.payload,
+        {
+          context
+        }
+      );
+    }
+  },
+  {
+    id: "settings.profile.avatar.upload",
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: userProfileResource.operations.avatarUpload.bodyValidator,
+    outputValidator: userProfileResource.operations.avatarUpload.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: "settings.profile.avatar.upload"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.accountProfileService.uploadAvatar(
+        resolveRequest(context),
+        resolveActionUser(context, input),
+        input,
+        {
+          context
+        }
+      );
+    }
+  },
+  {
+    id: "settings.profile.avatar.delete",
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: userProfileResource.operations.avatarDelete.bodyValidator,
+    outputValidator: userProfileResource.operations.avatarDelete.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: "settings.profile.avatar.delete"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.accountProfileService.deleteAvatar(
+        resolveRequest(context),
+        resolveActionUser(context, input),
+        input,
+        {
+          context
+        }
+      );
+    }
+  }
+]);
+
+export { accountProfileActions };

package/src/server/accountProfile/accountProfileService.js

@@ -0,0 +1,124 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import {
+  resolveUserProfile,
+  resolveSecurityStatus
+} from "../common/services/accountContextService.js";
+import {
+  accountSettingsResponseFormatter
+} from "../common/formatters/accountSettingsResponseFormatter.js";
+
+function createService({
+  userSettingsRepository,
+  userProfilesRepository,
+  authService,
+  avatarService
+} = {}) {
+  if (!userSettingsRepository || !userProfilesRepository || !avatarService) {
+    throw new Error("accountProfileService requires repositories and avatarService.");
+  }
+
+  async function getForUser(request, user, options = {}) {
+    const profile = await resolveUserProfile(userProfilesRepository, user);
+    if (!profile) {
+      throw new AppError(404, "User profile was not found.");
+    }
+
+    const settings = await userSettingsRepository.ensureForUserId(profile.id);
+    const securityStatus = await resolveSecurityStatus(authService, request);
+
+    return accountSettingsResponseFormatter({
+      profile,
+      settings,
+      securityStatus,
+      authService
+    });
+  }
+
+  async function updateProfile(request, user, payload = {}, options = {}) {
+    const profile = await resolveUserProfile(userProfilesRepository, user);
+    if (!profile) {
+      throw new AppError(404, "User profile was not found.");
+    }
+
+    let session = null;
+    let updatedProfile = null;
+    if (authService && typeof authService.updateDisplayName === "function") {
+      const result = await authService.updateDisplayName(request, payload.displayName);
+      session = result?.session || null;
+      updatedProfile = result?.profile || null;
+    }
+
+    if (!updatedProfile) {
+      updatedProfile = await userProfilesRepository.updateDisplayNameById(profile.id, payload.displayName);
+    }
+
+    const settings = await userSettingsRepository.ensureForUserId(updatedProfile.id);
+    const securityStatus = await resolveSecurityStatus(authService, request);
+
+    return {
+      session,
+      settings: accountSettingsResponseFormatter({
+        profile: updatedProfile,
+        settings,
+        securityStatus,
+        authService
+      })
+    };
+  }
+
+  async function uploadAvatar(request, user, payload = {}, options = {}) {
+    void options;
+
+    const avatarUpload = await avatarService.uploadForUser(user, payload);
+    const profile = avatarUpload?.profile || null;
+    if (!profile) {
+      throw new AppError(500, "Avatar upload completed without a profile result.");
+    }
+
+    const settings = await userSettingsRepository.ensureForUserId(profile.id);
+    const securityStatus = await resolveSecurityStatus(authService, request);
+
+    return accountSettingsResponseFormatter({
+      profile,
+      settings,
+      securityStatus,
+      authService
+    });
+  }
+
+  async function deleteAvatar(request, user, _payload = {}, options = {}) {
+    void options;
+
+    const profile = await avatarService.clearForUser(user);
+    const settings = await userSettingsRepository.ensureForUserId(profile.id);
+    const securityStatus = await resolveSecurityStatus(authService, request);
+
+    return accountSettingsResponseFormatter({
+      profile,
+      settings,
+      securityStatus,
+      authService
+    });
+  }
+
+  async function readAvatar(_request, user, _payload = {}, options = {}) {
+    void options;
+
+    const avatar = await avatarService.readForUser(user);
+    if (!avatar) {
+      throw new AppError(404, "Avatar not found.");
+    }
+
+    return avatar;
+  }
+
+  return Object.freeze({
+    getForUser,
+    updateProfile,
+    uploadAvatar,
+    deleteAvatar,
+    readAvatar
+  });
+}
+
+export { createService };

package/src/server/accountProfile/avatarService.js

@@ -0,0 +1,141 @@
+import { AppError, createValidationError } from "@jskit-ai/kernel/server/runtime/errors";
+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
+});
+
+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
+  });
+}
+
+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();
+}
+
+function createService({ userProfilesRepository, avatarStorageService, avatarPolicy } = {}) {
+  if (!userProfilesRepository) {
+    throw new TypeError("avatarService requires userProfilesRepository.");
+  }
+  if (!avatarStorageService) {
+    throw new TypeError("avatarService requires avatarStorageService.");
+  }
+
+  const resolvedAvatarPolicy = resolveAvatarPolicy(avatarPolicy);
+
+  async function resolveProfile(user) {
+    const profile = await resolveUserProfile(userProfilesRepository, user);
+    if (!profile) {
+      throw new AppError(404, "User profile was not found.");
+    }
+    return profile;
+  }
+
+  async function uploadForUser(user, payload = {}) {
+    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(", ")}.`
+      });
+    }
+
+    const buffer = await readAvatarBuffer(payload.stream, {
+      maxBytes: resolvedAvatarPolicy.maxUploadBytes
+    });
+
+    const avatarVersionMs = Date.now();
+    const avatarVersion = String(avatarVersionMs);
+    const savedAvatar = await avatarStorageService.saveAvatar({
+      userId: profile.id,
+      buffer
+    });
+
+    const updatedProfile = await userProfilesRepository.updateAvatarById(profile.id, {
+      avatarStorageKey: savedAvatar.storageKey,
+      avatarVersion,
+      avatarUpdatedAt: new Date(avatarVersionMs)
+    });
+
+    return Object.freeze({
+      profile: updatedProfile
+    });
+  }
+
+  async function clearForUser(user) {
+    const profile = await resolveProfile(user);
+    if (profile.avatarStorageKey) {
+      await avatarStorageService.deleteAvatar(profile.avatarStorageKey);
+    }
+    return userProfilesRepository.clearAvatarById(profile.id);
+  }
+
+  async function readForUser(user) {
+    const profile = await resolveProfile(user);
+    if (!profile.avatarStorageKey) {
+      return null;
+    }
+
+    return avatarStorageService.readAvatar(profile.avatarStorageKey);
+  }
+
+  return Object.freeze({
+    uploadForUser,
+    clearForUser,
+    readForUser
+  });
+}
+
+const __testables = Object.freeze({
+  resolveAvatarPolicy,
+  readAvatarBuffer
+});
+
+export { createService, __testables };