@jskit-ai/users-core 0.1.4

package/src/shared/resources/userProfileResource.js

@@ -0,0 +1,148 @@
+import { Type } from "typebox";
+import {
+  createCursorListValidator,
+  normalizeObjectInput
+} from "@jskit-ai/kernel/shared/validators";
+import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { createOperationMessages } from "../operationMessages.js";
+
+function normalizeProfileInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "displayName")) {
+    normalized.displayName = normalizeText(source.displayName);
+  }
+
+  return normalized;
+}
+
+const userProfileOutputSchema = Type.Object(
+  {
+    displayName: Type.String(),
+    email: Type.String(),
+    emailManagedBy: Type.Optional(Type.String()),
+    emailChangeFlow: Type.Optional(Type.String()),
+    avatar: Type.Optional(Type.Object({}, { additionalProperties: true }))
+  },
+  { additionalProperties: true }
+);
+
+const userProfileOutputValidator = Object.freeze({
+  schema: userProfileOutputSchema,
+  normalize: normalizeObjectInput
+});
+
+const userProfileCreateBodySchema = Type.Object(
+  {
+    displayName: Type.String({ minLength: 1, maxLength: 120 })
+  },
+  { additionalProperties: false }
+);
+
+const userProfilePatchBodySchema = Type.Partial(userProfileCreateBodySchema, {
+  additionalProperties: false,
+  minProperties: 1
+});
+
+const avatarUploadBodyValidator = Object.freeze({
+  schema: Type.Object(
+    {
+      mimeType: Type.Optional(
+        Type.String({
+          minLength: 1,
+          messages: {
+            default: "Avatar mimeType is invalid."
+          }
+        })
+      ),
+      fileName: Type.Optional(
+        Type.String({
+          minLength: 1,
+          messages: {
+            default: "Avatar fileName is invalid."
+          }
+        })
+      ),
+      uploadDimension: Type.Optional(
+        Type.String({
+          minLength: 1,
+          messages: {
+            default: "Avatar uploadDimension is invalid."
+          }
+        })
+      )
+    },
+    { additionalProperties: true }
+  ),
+  normalize: normalizeObjectInput
+});
+
+const avatarDeleteBodyValidator = Object.freeze({
+  schema: Type.Object({}, { additionalProperties: false }),
+  normalize: normalizeObjectInput
+});
+
+const avatarOperationOutputValidator = Object.freeze({
+  schema: Type.Object({}, { additionalProperties: true }),
+  normalize: normalizeObjectInput
+});
+
+const USER_PROFILE_OPERATION_MESSAGES = createOperationMessages();
+
+const userProfileResource = Object.freeze({
+  resource: "userProfile",
+  operations: Object.freeze({
+    view: Object.freeze({
+      method: "GET",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      outputValidator: userProfileOutputValidator
+    }),
+    list: Object.freeze({
+      method: "GET",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      outputValidator: createCursorListValidator(userProfileOutputValidator)
+    }),
+    create: Object.freeze({
+      method: "POST",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        schema: userProfileCreateBodySchema,
+        normalize: normalizeProfileInput
+      }),
+      outputValidator: userProfileOutputValidator
+    }),
+    replace: Object.freeze({
+      method: "PUT",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        schema: userProfileCreateBodySchema,
+        normalize: normalizeProfileInput
+      }),
+      outputValidator: userProfileOutputValidator
+    }),
+    patch: Object.freeze({
+      method: "PATCH",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        schema: userProfilePatchBodySchema,
+        normalize: normalizeProfileInput
+      }),
+      outputValidator: userProfileOutputValidator
+    }),
+    avatarUpload: Object.freeze({
+      method: "POST",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      bodyValidator: avatarUploadBodyValidator,
+      outputValidator: avatarOperationOutputValidator
+    }),
+    avatarDelete: Object.freeze({
+      method: "DELETE",
+      messages: USER_PROFILE_OPERATION_MESSAGES,
+      bodyValidator: avatarDeleteBodyValidator,
+      outputValidator: avatarOperationOutputValidator
+    })
+  })
+});
+
+export { userProfileResource };

package/src/shared/resources/userSettingsFields.js

@@ -0,0 +1,71 @@
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
+
+const USER_SETTINGS_SECTIONS = Object.freeze({
+  PREFERENCES: "preferences",
+  NOTIFICATIONS: "notifications"
+});
+
+const USER_SETTINGS_SECTION_VALUES = Object.freeze(Object.values(USER_SETTINGS_SECTIONS));
+
+const USER_SETTINGS_FIELDS_REGISTRY_KEY = Symbol.for("jskit.users-core.userSettingsFields");
+const userSettingsFields = resolveGlobalArrayRegistry(USER_SETTINGS_FIELDS_REGISTRY_KEY);
+
+function defineField(field = {}) {
+  const key = normalizeText(field.key);
+  if (!key) {
+    throw new TypeError("userSettingsFields.defineField requires field.key.");
+  }
+  if (userSettingsFields.some((entry) => entry.key === key)) {
+    throw new Error(`userSettingsFields.defineField duplicate key: ${key}`);
+  }
+  if (!field.inputSchema || typeof field.inputSchema !== "object") {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires inputSchema.`);
+  }
+  if (!field.outputSchema || typeof field.outputSchema !== "object") {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires outputSchema.`);
+  }
+  const dbColumn = normalizeText(field.dbColumn);
+  if (!dbColumn) {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires dbColumn.`);
+  }
+  const section = normalizeLowerText(field.section);
+  if (!USER_SETTINGS_SECTION_VALUES.includes(section)) {
+    throw new TypeError(
+      `userSettingsFields.defineField("${key}") requires section to be one of: ${USER_SETTINGS_SECTION_VALUES.join(", ")}.`
+    );
+  }
+  if (typeof field.normalizeInput !== "function") {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires normalizeInput.`);
+  }
+  if (typeof field.normalizeOutput !== "function") {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires normalizeOutput.`);
+  }
+  if (typeof field.resolveDefault !== "function") {
+    throw new TypeError(`userSettingsFields.defineField("${key}") requires resolveDefault.`);
+  }
+
+  userSettingsFields.push({
+    key,
+    section,
+    dbColumn,
+    required: field.required !== false,
+    includeInBootstrap: field.includeInBootstrap !== false,
+    inputSchema: field.inputSchema,
+    outputSchema: field.outputSchema,
+    normalizeInput: field.normalizeInput,
+    normalizeOutput: field.normalizeOutput,
+    resolveDefault: field.resolveDefault
+  });
+}
+
+function resetUserSettingsFields() {
+  userSettingsFields.splice(0, userSettingsFields.length);
+}
+
+export {
+  USER_SETTINGS_SECTIONS,
+  defineField,
+  resetUserSettingsFields,
+  userSettingsFields
+};

package/src/shared/resources/userSettingsResource.js

@@ -0,0 +1,416 @@
+import { Type } from "typebox";
+import {
+  createCursorListValidator,
+  normalizeObjectInput
+} from "@jskit-ai/kernel/shared/validators";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { createOperationMessages } from "../operationMessages.js";
+import { userProfileResource } from "./userProfileResource.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 normalizeUserSettingsInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  for (const field of userSettingsFields) {
+    if (!Object.hasOwn(source, field.key)) {
+      continue;
+    }
+    normalized[field.key] = field.normalizeInput(source[field.key], {
+      payload: source
+    });
+  }
+
+  return normalized;
+}
+
+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;
+}
+
+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();
+  },
+  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
+      )
+    };
+  }
+});
+
+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();
+  },
+  normalize: normalizeUserSettingsInput
+});
+
+const notificationsUpdateBodyValidator = Object.freeze({
+  get schema() {
+    return buildNotificationsUpdateBodySchema();
+  },
+  normalize: normalizeUserSettingsInput
+});
+
+function normalizeOAuthProviderParams(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  if (!Object.hasOwn(source, "provider")) {
+    return {};
+  }
+
+  return {
+    provider: normalizeText(source.provider)
+  };
+}
+
+function normalizeOAuthProviderQuery(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  if (!Object.hasOwn(source, "returnTo")) {
+    return {};
+  }
+
+  const returnTo = normalizeText(source.returnTo);
+  if (!returnTo) {
+    return {};
+  }
+
+  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 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 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."
+      }
+    }
+  ),
+  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."
+      }
+    }
+  ),
+  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."
+      }
+    }
+  ),
+  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 emptyBodyValidator = Object.freeze({
+  schema: Type.Object({}, { additionalProperties: false }),
+  normalize: normalizeObjectInput
+});
+
+const USER_SETTINGS_OPERATION_MESSAGES = createOperationMessages();
+
+const userSettingsResource = Object.freeze({
+  resource: "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: normalizeUserSettingsInput
+      }),
+      outputValidator: userSettingsOutputValidator
+    }),
+    replace: Object.freeze({
+      method: "PUT",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildUserSettingsCreateBodySchema();
+        },
+        normalize: normalizeUserSettingsInput
+      }),
+      outputValidator: userSettingsOutputValidator
+    }),
+    patch: Object.freeze({
+      method: "PATCH",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildUserSettingsPatchBodySchema();
+        },
+        normalize: normalizeUserSettingsInput
+      }),
+      outputValidator: userSettingsOutputValidator
+    }),
+    preferencesUpdate: Object.freeze({
+      method: "PATCH",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: preferencesUpdateBodyValidator,
+      outputValidator: userSettingsOutputValidator
+    }),
+    notificationsUpdate: Object.freeze({
+      method: "PATCH",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: notificationsUpdateBodyValidator,
+      outputValidator: userSettingsOutputValidator
+    }),
+    passwordChange: Object.freeze({
+      method: "POST",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: passwordChangeBodyValidator,
+      outputValidator: passwordChangeOutputValidator
+    }),
+    passwordMethodToggle: Object.freeze({
+      method: "PATCH",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: passwordMethodToggleBodyValidator,
+      outputValidator: settingsActionOutputValidator
+    }),
+    oauthLinkStart: Object.freeze({
+      method: "GET",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      paramsValidator: oauthProviderParamsValidator,
+      queryValidator: oauthProviderQueryValidator,
+      outputValidator: oauthLinkStartOutputValidator
+    }),
+    oauthUnlink: Object.freeze({
+      method: "DELETE",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      paramsValidator: oauthProviderParamsValidator,
+      outputValidator: settingsActionOutputValidator
+    }),
+    logoutOtherSessions: Object.freeze({
+      method: "POST",
+      messages: USER_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: emptyBodyValidator,
+      outputValidator: settingsActionOutputValidator
+    })
+  })
+});
+
+export { userSettingsResource };