@jskit-ai/users-core 0.1.64 → 0.1.66

package/src/server/common/repositories/userSettingsRepository.js

@@ -1,156 +1,164 @@
 import {
-  normalizeDbRecordId,
   normalizeRecordId,
-  toIsoString,
   nowDb,
   isDuplicateEntryError,
   createWithTransaction
 } from "./repositoryUtils.js";
-import { DEFAULT_USER_SETTINGS } from "../../../shared/settings.js";
 import {
-  userSettingsFields
-} from "../../../shared/resources/userSettingsFields.js";
-
-function mapRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  const mapped = {
-    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
-    passwordSignInEnabled: row.password_sign_in_enabled == null ? true : Boolean(row.password_sign_in_enabled),
-    passwordSetupRequired: row.password_setup_required == null ? false : Boolean(row.password_setup_required),
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at)
-  };
+  createJsonApiInputRecord,
+  createJsonRestContext,
+  simplifyJsonApiDocument
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { DEFAULT_USER_SETTINGS } from "../../../shared/settings.js";
 
-  for (const field of userSettingsFields) {
-    const column = field.repository.column;
-    const value = Object.hasOwn(row, column)
-      ? row[column]
-      : field.resolveDefault({
-          settings: mapped,
-          row
-        });
-    mapped[field.key] = field.normalizeOutput(value, {
-      settings: mapped,
-      row
-    });
+const RESOURCE_TYPE = "userSettings";
+const USER_SETTINGS_PATCH_FIELDS = Object.freeze([
+  "theme",
+  "locale",
+  "timeZone",
+  "dateFormat",
+  "numberFormat",
+  "currencyCode",
+  "avatarSize",
+  "productUpdates",
+  "accountActivity",
+  "securityAlerts",
+  "passwordSignInEnabled",
+  "passwordSetupRequired"
+]);
+
+function pickPatchFields(source = {}) {
+  const patch = {};
+
+  for (const fieldName of USER_SETTINGS_PATCH_FIELDS) {
+    if (Object.hasOwn(source, fieldName)) {
+      patch[fieldName] = source[fieldName];
+    }
   }
 
-  return mapped;
+  return patch;
 }
 
-function normalizeBoolean(value, fallback = false) {
-  if (value === undefined) {
-    return fallback;
-  }
-  return value === true;
-}
-
-function createInsertPayload(userId) {
-  const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-  if (!normalizedUserId) {
-    throw new TypeError("userSettingsRepository requires a valid user id.");
-  }
-
-  const payload = {
-    user_id: normalizedUserId,
-    password_sign_in_enabled: DEFAULT_USER_SETTINGS.passwordSignInEnabled,
-    password_setup_required: DEFAULT_USER_SETTINGS.passwordSetupRequired,
-    created_at: nowDb(),
-    updated_at: nowDb()
+function createDefaultUserSettingsCreatePayload(userId) {
+  return {
+    id: userId,
+    theme: DEFAULT_USER_SETTINGS.theme,
+    locale: DEFAULT_USER_SETTINGS.locale,
+    timeZone: DEFAULT_USER_SETTINGS.timeZone,
+    dateFormat: DEFAULT_USER_SETTINGS.dateFormat,
+    numberFormat: DEFAULT_USER_SETTINGS.numberFormat,
+    currencyCode: DEFAULT_USER_SETTINGS.currencyCode,
+    avatarSize: DEFAULT_USER_SETTINGS.avatarSize,
+    productUpdates: DEFAULT_USER_SETTINGS.productUpdates,
+    accountActivity: DEFAULT_USER_SETTINGS.accountActivity,
+    securityAlerts: DEFAULT_USER_SETTINGS.securityAlerts,
+    passwordSignInEnabled: DEFAULT_USER_SETTINGS.passwordSignInEnabled,
+    passwordSetupRequired: DEFAULT_USER_SETTINGS.passwordSetupRequired
   };
-
-  const resolvedDefaults = {};
-  for (const field of userSettingsFields) {
-    const defaultValue = field.resolveDefault({
-      settings: resolvedDefaults
-    });
-    payload[field.repository.column] = field.normalizeInput(defaultValue, {
-      payload: resolvedDefaults,
-      settings: resolvedDefaults
-    });
-    resolvedDefaults[field.key] = field.normalizeOutput(defaultValue, {
-      settings: resolvedDefaults
-    });
-  }
-
-  return payload;
 }
 
-function createRepository(knex) {
+function createRepository({ api, knex } = {}) {
+  if (!api?.resources?.userSettings) {
+    throw new TypeError("userSettingsRepository requires json-rest-api userSettings resource.");
+  }
   if (typeof knex !== "function") {
     throw new TypeError("userSettingsRepository requires knex.");
   }
   const withTransaction = createWithTransaction(knex);
 
+  async function queryFirst(filters = {}, options = {}) {
+    const result = await api.resources.userSettings.query(
+      {
+        queryParams: {
+          filters
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    const rows = simplifyJsonApiDocument(result);
+    return Array.isArray(rows) ? rows[0] || null : null;
+  }
+
   async function findByUserId(userId, options = {}) {
-    const client = options?.trx || knex;
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedUserId) {
       return null;
     }
 
-    const row = await client("user_settings").where({ user_id: normalizedUserId }).first();
-    return mapRow(row);
+    return queryFirst({ id: normalizedUserId }, options);
   }
 
   async function ensureForUserId(userId, options = {}) {
-    const client = options?.trx || knex;
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedUserId) {
       throw new TypeError("userSettingsRepository.ensureForUserId requires a valid user id.");
     }
 
-    const existing = await findByUserId(normalizedUserId, { trx: client });
+    const existing = await findByUserId(normalizedUserId, options);
     if (existing) {
       return existing;
     }
 
     try {
-      await client("user_settings").insert(createInsertPayload(normalizedUserId));
+      await api.resources.userSettings.post(
+        {
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            createDefaultUserSettingsCreatePayload(normalizedUserId),
+            {
+              id: normalizedUserId
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
       }
     }
 
-    return findByUserId(normalizedUserId, { trx: client });
+    return findByUserId(normalizedUserId, options);
   }
 
   async function patchUserSettings(userId, patch = {}, options = {}) {
-    const client = options?.trx || knex;
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedUserId) {
       throw new TypeError("userSettingsRepository.patchUserSettings requires a valid user id.");
     }
 
-    const ensured = await ensureForUserId(normalizedUserId, { trx: client });
+    await ensureForUserId(normalizedUserId, options);
     const source = patch && typeof patch === "object" ? patch : {};
+    const updatePayload = pickPatchFields(source);
 
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-  for (const field of userSettingsFields) {
-    if (!Object.hasOwn(source, field.key)) {
-      continue;
-    }
-    dbPatch[field.repository.column] = field.normalizeInput(source[field.key], {
-      payload: source,
-      settings: ensured
-    });
+    if (Object.keys(updatePayload).length < 1) {
+      return findByUserId(normalizedUserId, options);
     }
 
-    if (Object.hasOwn(source, "passwordSignInEnabled")) {
-      dbPatch.password_sign_in_enabled = normalizeBoolean(source.passwordSignInEnabled, ensured.passwordSignInEnabled);
-    }
-    if (Object.hasOwn(source, "passwordSetupRequired")) {
-      dbPatch.password_setup_required = normalizeBoolean(source.passwordSetupRequired, ensured.passwordSetupRequired);
-    }
-    await client("user_settings").where({ user_id: normalizedUserId }).update(dbPatch);
-    return findByUserId(normalizedUserId, { trx: client });
+    await api.resources.userSettings.patch(
+      {
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          {
+            ...updatePayload,
+            updatedAt: nowDb()
+          },
+          {
+            id: normalizedUserId
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    return findByUserId(normalizedUserId, options);
   }
 
   async function updatePreferences(userId, patch = {}, options = {}) {
@@ -166,9 +174,9 @@ function createRepository(knex) {
       userId,
       {
         passwordSignInEnabled: enabled,
-        passwordSetupRequired: Object.hasOwn(options, "passwordSetupRequired")
-          ? options.passwordSetupRequired
-          : undefined
+        ...(Object.hasOwn(options, "passwordSetupRequired")
+          ? { passwordSetupRequired: options.passwordSetupRequired }
+          : {})
       },
       options
     );
@@ -190,4 +198,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, mapRow };
+export { createRepository };

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

@@ -0,0 +1,10 @@
+function resolveAccountSettingsResourceId(_record, context = {}) {
+  const userId = context?.request?.user?.id;
+  if (userId == null || String(userId).trim() === "") {
+    throw new Error("JSON:API account settings response requires request.user.id.");
+  }
+
+  return userId;
+}
+
+export { resolveAccountSettingsResourceId };

package/src/server/usersBootstrapContributor.js

@@ -1,10 +1,9 @@
 import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeBoolean, normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
 import { accountAvatarFormatter } from "./common/formatters/accountAvatarFormatter.js";
-import { authenticatedUserValidator } from "./common/validators/authenticatedUserValidator.js";
-import { userSettingsFields } from "../shared/resources/userSettingsFields.js";
+import { USER_SETTINGS_BOOTSTRAP_KEYS } from "../shared/resources/userSettingsResource.js";
 
 function getOAuthProviderCatalogPayload(authService) {
   if (!authService || typeof authService.getOAuthProviderCatalog !== "function") {
@@ -31,28 +30,20 @@ function getOAuthProviderCatalogPayload(authService) {
   };
 }
 
-function normalizeBoolean(value, fallback) {
-  if (typeof value === "boolean") {
-    return value;
+function resolveBooleanConfigValue(value, fallback) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
   }
-  if (typeof value === "string") {
-    const normalized = normalizeLowerText(value);
-    if (normalized === "true") {
-      return true;
-    }
-    if (normalized === "false") {
-      return false;
-    }
-  }
-  return fallback;
+
+  return normalizeBoolean(value);
 }
 
 function resolveAppState(appConfig = {}) {
   const features = {
-    assistantEnabled: normalizeBoolean(appConfig.assistantEnabled, false),
+    assistantEnabled: resolveBooleanConfigValue(appConfig.assistantEnabled, false),
     assistantRequiredPermission: normalizeText(appConfig.assistantRequiredPermission),
-    socialEnabled: normalizeBoolean(appConfig.socialEnabled, false),
-    socialFederationEnabled: normalizeBoolean(appConfig.socialFederationEnabled, false)
+    socialEnabled: resolveBooleanConfigValue(appConfig.socialEnabled, false),
+    socialFederationEnabled: resolveBooleanConfigValue(appConfig.socialFederationEnabled, false)
   };
 
   return {
@@ -79,18 +70,8 @@ function mapUserSettingsBootstrap(settings = {}) {
   const source = settings && typeof settings === "object" ? settings : {};
   const mapped = {};
 
-  for (const field of userSettingsFields) {
-    if (field.includeInBootstrap === false) {
-      continue;
-    }
-    const rawValue = Object.hasOwn(source, field.key)
-      ? source[field.key]
-      : field.resolveDefault({
-          settings: source
-        });
-    mapped[field.key] = field.normalizeOutput(rawValue, {
-      settings: source
-    });
+  for (const fieldKey of USER_SETTINGS_BOOTSTRAP_KEYS) {
+    mapped[fieldKey] = source[fieldKey];
   }
 
   return mapped;
@@ -130,7 +111,7 @@ function createUsersBootstrapContributor({
         throw new AppError(503, "Authentication service temporarily unavailable. Please retry.");
       }
 
-      const normalizedUser = authenticatedUserValidator.normalize(authResult?.authenticated ? authResult?.profile : null);
+      const normalizedUser = authResult?.authenticated === true ? authResult?.profile || null : null;
       const inheritedSurfaceAccess = normalizeObject(existingPayload?.surfaceAccess);
       let payload = createAnonymousBootstrapPayload({
         appState,

package/src/shared/resources/accountSettingsSchemas.js

@@ -0,0 +1,83 @@
+import { createSchema } from "json-rest-schema";
+
+const accountAvatarOutputSchema = createSchema({
+  uploadedUrl: { type: "string", required: true, nullable: true },
+  gravatarUrl: { type: "string", required: true, minLength: 1 },
+  effectiveUrl: { type: "string", required: true, minLength: 1 },
+  hasUploadedAvatar: { type: "boolean", required: true },
+  size: { type: "number", required: true, min: 1 },
+  version: { type: "string", required: true, nullable: true }
+});
+
+const userProfileOutputSchema = createSchema({
+  displayName: { type: "string", required: true },
+  email: { type: "string", required: true },
+  emailManagedBy: { type: "string", required: true },
+  emailChangeFlow: { type: "string", required: true },
+  avatar: {
+    type: "object",
+    required: true,
+    schema: accountAvatarOutputSchema
+  }
+});
+
+const accountSecurityMfaSchema = createSchema({
+  status: { type: "string", required: true },
+  enrolled: { type: "boolean", required: true },
+  methods: {
+    type: "array",
+    required: true,
+    items: { type: "string", minLength: 1 }
+  }
+});
+
+const accountSecuritySessionsSchema = createSchema({
+  canSignOutOtherDevices: { type: "boolean", required: true }
+});
+
+const accountSecurityAuthPolicySchema = createSchema({
+  minimumEnabledMethods: { type: "integer", required: true, min: 1 },
+  enabledMethodsCount: { type: "integer", required: true, min: 0 }
+});
+
+const accountSecurityAuthMethodSchema = createSchema({
+  id: { type: "string", required: true },
+  kind: { type: "string", required: true },
+  provider: { type: "string", required: true, nullable: true },
+  label: { type: "string", required: true },
+  configured: { type: "boolean", required: true },
+  enabled: { type: "boolean", required: true },
+  canEnable: { type: "boolean", required: true },
+  canDisable: { type: "boolean", required: true },
+  supportsSecretUpdate: { type: "boolean", required: true },
+  requiresCurrentPassword: { type: "boolean", required: true }
+});
+
+const accountSecurityStatusSchema = createSchema({
+  mfa: {
+    type: "object",
+    required: true,
+    schema: accountSecurityMfaSchema
+  },
+  sessions: {
+    type: "object",
+    required: true,
+    schema: accountSecuritySessionsSchema
+  },
+  authPolicy: {
+    type: "object",
+    required: true,
+    schema: accountSecurityAuthPolicySchema
+  },
+  authMethods: {
+    type: "array",
+    required: true,
+    items: accountSecurityAuthMethodSchema
+  }
+});
+
+export {
+  accountAvatarOutputSchema,
+  userProfileOutputSchema,
+  accountSecurityStatusSchema
+};