@jskit-ai/users-core 0.1.65 → 0.1.66

package/src/shared/resources/userProfileResource.js

@@ -1,148 +1,168 @@
-import { Type } from "typebox";
-import {
-  createCursorListValidator,
-  normalizeObjectInput
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { createSchema } from "json-rest-schema";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 import { createOperationMessages } from "../operationMessages.js";
+import { userProfileOutputSchema } from "./accountSettingsSchemas.js";
+import { userSettingsOutputSchema } from "./userSettingsResource.js";
 
-function normalizeProfileInput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
+const USERNAME_MAX_LENGTH = 120;
 
-  if (Object.hasOwn(source, "displayName")) {
-    normalized.displayName = normalizeText(source.displayName);
-  }
+function normalizeUsername(value) {
+  const normalized = normalizeLowerText(value)
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, USERNAME_MAX_LENGTH);
 
-  return normalized;
+  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
-});
+function normalizeNullableString(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
 
-const userProfileCreateBodySchema = Type.Object(
-  {
-    displayName: Type.String({ minLength: 1, maxLength: 120 })
-  },
-  { additionalProperties: false }
-);
+  return normalizeText(value);
+}
 
-const userProfilePatchBodySchema = Type.Partial(userProfileCreateBodySchema, {
-  additionalProperties: false,
-  minProperties: 1
-});
+function normalizeNullableVersion(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
 
-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
-});
+  return String(value);
+}
 
-const avatarDeleteBodyValidator = Object.freeze({
-  schema: Type.Object({}, { additionalProperties: false }),
-  normalize: normalizeObjectInput
+const userProfileBodySchema = createSchema({
+  displayName: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 120
+  }
 });
 
-const avatarOperationOutputValidator = Object.freeze({
-  schema: Type.Object({}, { additionalProperties: true }),
-  normalize: normalizeObjectInput
+const avatarUploadBodySchema = createSchema({
+  mimeType: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    messages: {
+      default: "Avatar mimeType is invalid."
+    }
+  },
+  fileName: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    messages: {
+      default: "Avatar fileName is invalid."
+    }
+  },
+  uploadDimension: {
+    type: "string",
+    required: false,
+    minLength: 1,
+    messages: {
+      default: "Avatar uploadDimension is invalid."
+    }
+  }
 });
 
 const USER_PROFILE_OPERATION_MESSAGES = createOperationMessages();
 
-const userProfileResource = Object.freeze({
+const userProfileResource = defineCrudResource({
   namespace: "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({
+  tableName: "users",
+  searchSchema: {
+    id: { type: "id", actualField: "id" }
+  },
+  schema: {
+    authProvider: {
+      type: "string",
+      required: true,
+      max: 64,
+      search: true,
+      storage: { column: "auth_provider" },
+      setter: (value) => normalizeLowerText(value)
+    },
+    authProviderUserSid: {
+      type: "string",
+      required: true,
+      max: 191,
+      search: true,
+      storage: { column: "auth_provider_user_sid" },
+      setter: (value) => normalizeText(value)
+    },
+    email: {
+      type: "string",
+      required: true,
+      max: 255,
+      search: true,
+      setter: (value) => normalizeLowerText(value)
+    },
+    username: {
+      type: "string",
+      required: true,
+      max: USERNAME_MAX_LENGTH,
+      search: true,
+      setter: (value) => normalizeUsername(value)
+    },
+    displayName: {
+      type: "string",
+      required: true,
+      max: 160,
+      storage: { column: "display_name" },
+      setter: (value) => normalizeText(value)
+    },
+    avatarStorageKey: {
+      type: "string",
+      nullable: true,
+      max: 512,
+      storage: { column: "avatar_storage_key" },
+      setter: (value) => normalizeNullableString(value)
+    },
+    avatarVersion: {
+      type: "string",
+      nullable: true,
+      max: 64,
+      storage: { column: "avatar_version" },
+      setter: (value) => normalizeNullableVersion(value)
+    },
+    avatarUpdatedAt: {
+      type: "dateTime",
+      nullable: true,
+      storage: {
+        column: "avatar_updated_at",
+        writeSerializer: "datetime-utc"
+      }
+    },
+    createdAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "created_at",
+        writeSerializer: "datetime-utc"
+      }
+    }
+  },
+  messages: USER_PROFILE_OPERATION_MESSAGES,
+  crudOperations: ["view", "list", "create", "replace", "patch"],
+  crud: {
+    output: userProfileOutputSchema,
+    body: userProfileBodySchema
+  },
+  operations: {
+    avatarUpload: {
       method: "POST",
-      messages: USER_PROFILE_OPERATION_MESSAGES,
-      bodyValidator: avatarUploadBodyValidator,
-      outputValidator: avatarOperationOutputValidator
-    }),
-    avatarDelete: Object.freeze({
+      body: avatarUploadBodySchema,
+      output: userSettingsOutputSchema
+    },
+    avatarDelete: {
       method: "DELETE",
-      messages: USER_PROFILE_OPERATION_MESSAGES,
-      bodyValidator: avatarDeleteBodyValidator,
-      outputValidator: avatarOperationOutputValidator
-    })
-  })
+      body: createSchema({}),
+      output: userSettingsOutputSchema
+    }
+  }
 });
 
 export { userProfileResource };