@jskit-ai/users-core 0.1.64 → 0.1.66

package/src/shared/resources/userSettingsResource.js

@@ -1,405 +1,428 @@
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
-  createCursorListValidator,
-  normalizeObjectInput,
-  normalizeSettingsFieldInput
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+  createSchemaDefinition
+} from "@jskit-ai/resource-core/shared/resource";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 import { createOperationMessages } from "../operationMessages.js";
-import { userProfileResource } from "./userProfileResource.js";
+import { DEFAULT_USER_SETTINGS } from "../settings.js";
 import {
-  USER_SETTINGS_SECTIONS,
-  userSettingsFields
-} from "./userSettingsFields.js";
-
-function pickPatchBody(schema, keys = []) {
-  const properties = {};
-  for (const key of keys) {
-    if (!Object.hasOwn(schema.properties, key)) {
-      throw new Error(`pickPatchBody requires patch field "${key}".`);
-    }
-
-    properties[key] = schema.properties[key];
-  }
-
-  return Type.Object(properties, {
-    additionalProperties: false,
-    minProperties: 1
-  });
-}
-
-function listFieldsBySection(section) {
-  return userSettingsFields.filter((field) => field.section === section);
-}
-
-function buildCreateBodySchema() {
-  const properties = {};
-  for (const field of userSettingsFields) {
-    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
-  }
-
-  return Type.Object(properties, { additionalProperties: false });
-}
-
-function buildSectionOutputSchema(section) {
-  const properties = {};
-  for (const field of listFieldsBySection(section)) {
-    properties[field.key] = field.outputSchema;
-  }
-
-  return Type.Object(properties, { additionalProperties: false });
-}
-
-function normalizeInput(payload = {}) {
-  return normalizeSettingsFieldInput(payload, userSettingsFields);
-}
-
-function normalizeSectionOutput(section, sectionSource = {}, settings = {}) {
-  const normalized = {};
-  for (const field of listFieldsBySection(section)) {
-    const rawValue = Object.hasOwn(sectionSource, field.key)
-      ? sectionSource[field.key]
-      : field.resolveDefault({
-          settings
-        });
-    normalized[field.key] = field.normalizeOutput(rawValue, {
-      settings
-    });
-  }
-  return normalized;
+  accountSecurityStatusSchema,
+  userProfileOutputSchema
+} from "./accountSettingsSchemas.js";
+
+const USER_SETTINGS_PREFERENCE_KEYS = deepFreeze([
+  "theme",
+  "locale",
+  "timeZone",
+  "dateFormat",
+  "numberFormat",
+  "currencyCode",
+  "avatarSize"
+]);
+
+const USER_SETTINGS_NOTIFICATION_KEYS = deepFreeze([
+  "productUpdates",
+  "accountActivity",
+  "securityAlerts"
+]);
+
+const USER_SETTINGS_ALL_KEYS = deepFreeze([
+  ...USER_SETTINGS_PREFERENCE_KEYS,
+  ...USER_SETTINGS_NOTIFICATION_KEYS
+]);
+
+const USER_SETTINGS_BOOTSTRAP_KEYS = USER_SETTINGS_ALL_KEYS;
+
+function normalizePositiveInteger(value) {
+  return Number(value);
 }
 
-function buildUserSettingsOutputSchema() {
-  return Type.Object(
-    {
-      profile: userProfileResource.operations.view.outputValidator.schema,
-      security: Type.Object({}, { additionalProperties: true }),
-      preferences: buildSectionOutputSchema(USER_SETTINGS_SECTIONS.PREFERENCES),
-      notifications: buildSectionOutputSchema(USER_SETTINGS_SECTIONS.NOTIFICATIONS)
-    },
-    { additionalProperties: true }
-  );
-}
-
-const userSettingsOutputValidator = Object.freeze({
-  get schema() {
-    return buildUserSettingsOutputSchema();
+const userSettingsBodySchema = createSchema({
+  theme: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  locale: { type: "string", required: true, minLength: 1, maxLength: 24, lowercase: true },
+  timeZone: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  dateFormat: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  numberFormat: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  currencyCode: {
+    type: "string",
+    required: true,
+    minLength: 3,
+    maxLength: 3,
+    uppercase: true,
+    pattern: "^[A-Z]{3}$"
   },
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const preferencesSource = normalizeObjectInput(source.preferences);
-    const notificationsSource = normalizeObjectInput(source.notifications);
-
-    return {
-      profile: normalizeObjectInput(source.profile),
-      security: normalizeObjectInput(source.security),
-      preferences: normalizeSectionOutput(
-        USER_SETTINGS_SECTIONS.PREFERENCES,
-        preferencesSource,
-        preferencesSource
-      ),
-      notifications: normalizeSectionOutput(
-        USER_SETTINGS_SECTIONS.NOTIFICATIONS,
-        notificationsSource,
-        notificationsSource
-      )
-    };
+  avatarSize: { type: "number", required: true, min: 1 },
+  productUpdates: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "productUpdates must be a boolean."
+    }
+  },
+  accountActivity: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "accountActivity must be a boolean."
+    }
+  },
+  securityAlerts: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "securityAlerts must be a boolean."
+    }
   }
 });
 
-function buildUserSettingsCreateBodySchema() {
-  return buildCreateBodySchema();
-}
-
-function buildUserSettingsPatchBodySchema() {
-  return Type.Partial(buildUserSettingsCreateBodySchema(), {
-    additionalProperties: false,
-    minProperties: 1
-  });
-}
-
-function buildPreferencesUpdateBodySchema() {
-  return pickPatchBody(
-    buildUserSettingsPatchBodySchema(),
-    listFieldsBySection(USER_SETTINGS_SECTIONS.PREFERENCES).map((field) => field.key)
-  );
-}
-
-function buildNotificationsUpdateBodySchema() {
-  return pickPatchBody(
-    buildUserSettingsPatchBodySchema(),
-    listFieldsBySection(USER_SETTINGS_SECTIONS.NOTIFICATIONS).map((field) => field.key)
-  );
-}
-
-const preferencesUpdateBodyValidator = Object.freeze({
-  get schema() {
-    return buildPreferencesUpdateBodySchema();
+const userSettingsPreferencesSchema = createSchema({
+  theme: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  locale: { type: "string", required: true, minLength: 1, maxLength: 24, lowercase: true },
+  timeZone: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  dateFormat: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  numberFormat: { type: "string", required: true, minLength: 1, maxLength: 32 },
+  currencyCode: {
+    type: "string",
+    required: true,
+    minLength: 3,
+    maxLength: 3,
+    uppercase: true,
+    pattern: "^[A-Z]{3}$"
   },
-  normalize: normalizeInput
+  avatarSize: { type: "number", required: true, min: 1 }
 });
 
-const notificationsUpdateBodyValidator = Object.freeze({
-  get schema() {
-    return buildNotificationsUpdateBodySchema();
+const userSettingsNotificationsSchema = createSchema({
+  productUpdates: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "productUpdates must be a boolean."
+    }
+  },
+  accountActivity: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "accountActivity must be a boolean."
+    }
   },
-  normalize: normalizeInput
+  securityAlerts: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      default: "securityAlerts must be a boolean."
+    }
+  }
 });
 
-function normalizeOAuthProviderParams(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  if (!Object.hasOwn(source, "provider")) {
-    return {};
+const userSettingsOutputSchema = createSchema({
+  profile: {
+    type: "object",
+    required: true,
+    schema: userProfileOutputSchema
+  },
+  security: {
+    type: "object",
+    required: true,
+    schema: accountSecurityStatusSchema
+  },
+  preferences: {
+    type: "object",
+    required: true,
+    schema: userSettingsPreferencesSchema
+  },
+  notifications: {
+    type: "object",
+    required: true,
+    schema: userSettingsNotificationsSchema
   }
+});
 
-  return {
-    provider: normalizeText(source.provider)
-  };
-}
+const userSettingsOutputValidator = createSchemaDefinition(userSettingsOutputSchema, "replace");
 
-function normalizeOAuthProviderQuery(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  if (!Object.hasOwn(source, "returnTo")) {
-    return {};
+const passwordMethodToggleOutputSchema = createSchema({
+  securityStatus: {
+    type: "object",
+    required: true,
+    schema: accountSecurityStatusSchema
+  },
+  settings: {
+    type: "object",
+    required: true,
+    schema: userSettingsOutputSchema
   }
+});
 
-  const returnTo = normalizeText(source.returnTo);
-  if (!returnTo) {
-    return {};
+const oauthUnlinkOutputSchema = createSchema({
+  securityStatus: {
+    type: "object",
+    required: true,
+    schema: accountSecurityStatusSchema
   }
-
-  return {
-    returnTo
-  };
-}
-
-const settingsActionOutputValidator = Object.freeze({
-  schema: Type.Object({}, { additionalProperties: true }),
-  normalize: normalizeObjectInput
 });
 
-const passwordChangeOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      ok: Type.Boolean(),
-      message: Type.String()
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeObjectInput
+const passwordChangeBodySchema = createSchema({
+  currentPassword: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    messages: {
+      default: "Current password is invalid."
+    }
+  },
+  newPassword: {
+    type: "string",
+    required: true,
+    minLength: 8,
+    messages: {
+      required: "New password is required.",
+      minLength: "New password must be at least 8 characters.",
+      default: "New password must be at least 8 characters."
+    }
+  },
+  confirmPassword: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    messages: {
+      required: "Confirm password is required.",
+      minLength: "Confirm password is required.",
+      default: "Confirm password is required."
+    }
+  }
 });
 
-const passwordChangeBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      currentPassword: Type.Optional(
-        Type.String({
-          minLength: 1,
-          messages: {
-            default: "Current password is invalid."
-          }
-        })
-      ),
-      newPassword: Type.String({
-        minLength: 8,
-        messages: {
-          required: "New password is required.",
-          minLength: "New password must be at least 8 characters.",
-          default: "New password must be at least 8 characters."
-        }
-      }),
-      confirmPassword: Type.String({
-        minLength: 1,
-        messages: {
-          required: "Confirm password is required.",
-          minLength: "Confirm password is required.",
-          default: "Confirm password is required."
-        }
-      })
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
-    }
-  ),
-  normalize: normalizeObjectInput
+const passwordChangeOutputSchema = createSchema({
+  ok: { type: "boolean", required: true },
+  message: { type: "string", required: true, minLength: 1 }
 });
 
-const passwordMethodToggleBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      enabled: Type.Boolean({
-        messages: {
-          required: "enabled is required.",
-          default: "enabled must be a boolean."
-        }
-      })
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
+const passwordMethodToggleBodySchema = createSchema({
+  enabled: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      required: "enabled is required.",
+      default: "enabled must be a boolean."
     }
-  ),
-  normalize: normalizeObjectInput
+  }
 });
 
-const oauthProviderParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      provider: Type.String({
-        minLength: 2,
-        maxLength: 64,
-        messages: {
-          required: "OAuth provider is required.",
-          default: "OAuth provider is invalid."
-        }
-      })
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
+const oauthProviderParamsSchema = createSchema({
+  provider: {
+    type: "string",
+    required: true,
+    minLength: 2,
+    maxLength: 64,
+    messages: {
+      required: "OAuth provider is required.",
+      default: "OAuth provider is invalid."
     }
-  ),
-  normalize: normalizeOAuthProviderParams
+  }
 });
 
-const oauthProviderQueryValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      returnTo: Type.Optional(
-        Type.String({
-          minLength: 1,
-          messages: {
-            default: "Return path is invalid."
-          }
-        })
-      )
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
+const oauthProviderQuerySchema = createSchema({
+  returnTo: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    messages: {
+      default: "Return path is invalid."
     }
-  ),
-  normalize: normalizeOAuthProviderQuery
+  }
 });
 
-const oauthLinkStartOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      provider: Type.String({ minLength: 2, maxLength: 64 }),
-      returnTo: Type.String({ minLength: 1 }),
-      url: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeObjectInput
+const oauthLinkStartOutputSchema = createSchema({
+  provider: { type: "string", required: true, minLength: 2, maxLength: 64 },
+  returnTo: { type: "string", required: true, minLength: 1 },
+  url: { type: "string", required: true, minLength: 1 }
 });
 
-const emptyBodyValidator = Object.freeze({
-  schema: Type.Object({}, { additionalProperties: false }),
-  normalize: normalizeObjectInput
+const logoutOtherSessionsOutputSchema = createSchema({
+  ok: { type: "boolean", required: true }
 });
 
 const USER_SETTINGS_OPERATION_MESSAGES = createOperationMessages();
 
-const userSettingsResource = Object.freeze({
+const userSettingsResource = defineCrudResource({
   namespace: "userSettings",
-  operations: Object.freeze({
-    view: Object.freeze({
-      method: "GET",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      outputValidator: userSettingsOutputValidator
-    }),
-    list: Object.freeze({
-      method: "GET",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      outputValidator: createCursorListValidator(userSettingsOutputValidator)
-    }),
-    create: Object.freeze({
-      method: "POST",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildUserSettingsCreateBodySchema();
-        },
-        normalize: normalizeInput
-      }),
-      outputValidator: userSettingsOutputValidator
-    }),
-    replace: Object.freeze({
-      method: "PUT",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildUserSettingsCreateBodySchema();
-        },
-        normalize: normalizeInput
-      }),
-      outputValidator: userSettingsOutputValidator
-    }),
-    patch: Object.freeze({
-      method: "PATCH",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildUserSettingsPatchBodySchema();
-        },
-        normalize: normalizeInput
-      }),
-      outputValidator: userSettingsOutputValidator
-    }),
-    preferencesUpdate: Object.freeze({
+  tableName: "user_settings",
+  idProperty: "user_id",
+  searchSchema: {
+    id: { type: "id", actualField: "id" }
+  },
+  schema: {
+    id: {
+      type: "id",
+      primary: true,
+      required: true,
+      search: true,
+      storage: { column: "user_id" }
+    },
+    theme: {
+      type: "string",
+      required: true,
+      max: 32,
+      defaultTo: DEFAULT_USER_SETTINGS.theme,
+      setter: (value) => normalizeText(value)
+    },
+    locale: {
+      type: "string",
+      required: true,
+      max: 24,
+      defaultTo: DEFAULT_USER_SETTINGS.locale,
+      setter: (value) => normalizeLowerText(value)
+    },
+    timeZone: {
+      type: "string",
+      required: true,
+      max: 64,
+      defaultTo: DEFAULT_USER_SETTINGS.timeZone,
+      storage: { column: "time_zone" },
+      setter: (value) => normalizeText(value)
+    },
+    dateFormat: {
+      type: "string",
+      required: true,
+      max: 32,
+      defaultTo: DEFAULT_USER_SETTINGS.dateFormat,
+      storage: { column: "date_format" },
+      setter: (value) => normalizeText(value)
+    },
+    numberFormat: {
+      type: "string",
+      required: true,
+      max: 32,
+      defaultTo: DEFAULT_USER_SETTINGS.numberFormat,
+      storage: { column: "number_format" },
+      setter: (value) => normalizeText(value)
+    },
+    currencyCode: {
+      type: "string",
+      required: true,
+      minLength: 3,
+      maxLength: 3,
+      defaultTo: DEFAULT_USER_SETTINGS.currencyCode,
+      storage: { column: "currency_code" },
+      setter: (value) => normalizeText(value).toUpperCase()
+    },
+    avatarSize: {
+      type: "number",
+      required: true,
+      min: 1,
+      defaultTo: DEFAULT_USER_SETTINGS.avatarSize,
+      storage: { column: "avatar_size" },
+      setter: (value) => normalizePositiveInteger(value)
+    },
+    passwordSignInEnabled: {
+      type: "boolean",
+      required: true,
+      defaultTo: DEFAULT_USER_SETTINGS.passwordSignInEnabled,
+      storage: { column: "password_sign_in_enabled" }
+    },
+    passwordSetupRequired: {
+      type: "boolean",
+      required: true,
+      defaultTo: DEFAULT_USER_SETTINGS.passwordSetupRequired,
+      storage: { column: "password_setup_required" }
+    },
+    productUpdates: {
+      type: "boolean",
+      required: true,
+      defaultTo: DEFAULT_USER_SETTINGS.productUpdates,
+      storage: { column: "notify_product_updates" }
+    },
+    accountActivity: {
+      type: "boolean",
+      required: true,
+      defaultTo: DEFAULT_USER_SETTINGS.accountActivity,
+      storage: { column: "notify_account_activity" }
+    },
+    securityAlerts: {
+      type: "boolean",
+      required: true,
+      defaultTo: DEFAULT_USER_SETTINGS.securityAlerts,
+      storage: { column: "notify_security_alerts" }
+    },
+    createdAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "created_at",
+        writeSerializer: "datetime-utc"
+      }
+    },
+    updatedAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "updated_at",
+        writeSerializer: "datetime-utc"
+      }
+    }
+  },
+  messages: USER_SETTINGS_OPERATION_MESSAGES,
+  crudOperations: ["view", "list", "create", "replace", "patch"],
+  crud: {
+    output: userSettingsOutputValidator,
+    body: userSettingsBodySchema
+  },
+  operations: {
+    preferencesUpdate: {
       method: "PATCH",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: preferencesUpdateBodyValidator,
-      outputValidator: userSettingsOutputValidator
-    }),
-    notificationsUpdate: Object.freeze({
+      body: userSettingsPreferencesSchema,
+      output: userSettingsOutputValidator
+    },
+    notificationsUpdate: {
       method: "PATCH",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: notificationsUpdateBodyValidator,
-      outputValidator: userSettingsOutputValidator
-    }),
-    passwordChange: Object.freeze({
+      body: userSettingsNotificationsSchema,
+      output: userSettingsOutputValidator
+    },
+    passwordChange: {
       method: "POST",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: passwordChangeBodyValidator,
-      outputValidator: passwordChangeOutputValidator
-    }),
-    passwordMethodToggle: Object.freeze({
+      body: passwordChangeBodySchema,
+      output: passwordChangeOutputSchema
+    },
+    passwordMethodToggle: {
       method: "PATCH",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: passwordMethodToggleBodyValidator,
-      outputValidator: settingsActionOutputValidator
-    }),
-    oauthLinkStart: Object.freeze({
+      body: passwordMethodToggleBodySchema,
+      output: passwordMethodToggleOutputSchema
+    },
+    oauthLinkStart: {
       method: "GET",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      paramsValidator: oauthProviderParamsValidator,
-      queryValidator: oauthProviderQueryValidator,
-      outputValidator: oauthLinkStartOutputValidator
-    }),
-    oauthUnlink: Object.freeze({
+      params: oauthProviderParamsSchema,
+      query: oauthProviderQuerySchema,
+      output: oauthLinkStartOutputSchema
+    },
+    oauthUnlink: {
       method: "DELETE",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      paramsValidator: oauthProviderParamsValidator,
-      outputValidator: settingsActionOutputValidator
-    }),
-    logoutOtherSessions: Object.freeze({
+      params: oauthProviderParamsSchema,
+      output: oauthUnlinkOutputSchema
+    },
+    logoutOtherSessions: {
       method: "POST",
-      messages: USER_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: emptyBodyValidator,
-      outputValidator: settingsActionOutputValidator
-    })
-  })
+      body: createSchema({}),
+      output: logoutOtherSessionsOutputSchema
+    }
+  }
 });
 
-export { userSettingsResource };
+export {
+  USER_SETTINGS_ALL_KEYS,
+  USER_SETTINGS_BOOTSTRAP_KEYS,
+  USER_SETTINGS_NOTIFICATION_KEYS,
+  USER_SETTINGS_PREFERENCE_KEYS,
+  userSettingsOutputSchema,
+  userSettingsOutputValidator,
+  userSettingsResource
+};