@jskit-ai/users-core 0.1.56 → 0.1.58

package/src/server/common/repositories/{usersRepository.js → userProfilesRepository.js}

@@ -1,37 +1,29 @@
+import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
   isDuplicateEntryError,
-  normalizeLowerText,
   normalizeDbRecordId,
+  normalizeLowerText,
   normalizeRecordId,
-  normalizeText,
-  toIsoString,
-  toNullableDateTime,
-  toNullableIso,
-  nowDb,
-  createWithTransaction
+  nowDb
 } from "./repositoryUtils.js";
+import { normalizeIdentity } from "../support/identity.js";
+import { resource } from "../resources/userProfilesResource.js";
 
 const USERNAME_MAX_LENGTH = 120;
+const REPOSITORY_CONFIG = Object.freeze({
+  context: "internal.repository.user-profiles"
+});
 
-function normalizeIdentity(identityLike) {
-  const source = identityLike && typeof identityLike === "object" ? identityLike : {};
-  const provider = normalizeLowerText(source.provider || source.authProvider);
-  const providerUserId = normalizeText(source.providerUserId || source.authProviderUserSid);
-  if (!provider || !providerUserId) {
-    return null;
-  }
-  return {
-    provider,
-    providerUserId
-  };
+function normalizeProfileRecord(payload = {}) {
+  return resource.operations.view.outputValidator.normalize(payload);
+}
+
+function normalizeCreatePayload(payload = {}) {
+  return resource.operations.create.bodyValidator.normalize(payload);
 }
 
 function normalizeUsername(value) {
-  const normalized = normalizeLowerText(value)
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, USERNAME_MAX_LENGTH);
-  return normalized || "";
+  return normalizeCreatePayload({ username: value }).username || "";
 }
 
 function usernameBaseFromEmail(email) {
@@ -53,28 +45,11 @@ function buildUsernameCandidate(baseUsername, suffix) {
   return `${trimmedBase}${suffixText}`;
 }
 
-function mapProfileRow(row) {
-  if (!row) {
-    return null;
-  }
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    authProvider: normalizeLowerText(row.auth_provider),
-    authProviderUserSid: normalizeText(row.auth_provider_user_sid),
-    email: normalizeLowerText(row.email),
-    username: normalizeLowerText(row.username),
-    displayName: normalizeText(row.display_name),
-    avatarStorageKey: row.avatar_storage_key ? normalizeText(row.avatar_storage_key) : null,
-    avatarVersion: row.avatar_version == null ? null : String(row.avatar_version),
-    avatarUpdatedAt: toNullableIso(row.avatar_updated_at),
-    createdAt: toIsoString(row.created_at)
-  };
-}
-
 function duplicateTargetsEmail(error) {
   if (!isDuplicateEntryError(error)) {
     return false;
   }
+
   const message = normalizeLowerText(error?.sqlMessage || error?.message);
   return message.includes("email");
 }
@@ -83,6 +58,7 @@ function duplicateTargetsUsername(error) {
   if (!isDuplicateEntryError(error)) {
     return false;
   }
+
   const message = normalizeLowerText(error?.sqlMessage || error?.message);
   return message.includes("username");
 }
@@ -109,9 +85,11 @@ async function resolveUniqueUsername(client, baseUsername, { excludeUserId = nul
 
 function createRepository(knex) {
   if (typeof knex !== "function") {
-    throw new TypeError("usersRepository requires knex.");
+    throw new TypeError("internal.repository.user-profiles requires knex.");
   }
-  const withTransaction = createWithTransaction(knex);
+
+  const resourceRuntime = createCrudResourceRuntime(resource, knex, REPOSITORY_CONFIG);
+  const withTransaction = resourceRuntime.withTransaction;
 
   async function findById(userId, options = {}) {
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
@@ -119,25 +97,38 @@ function createRepository(knex) {
       return null;
     }
 
+    return resourceRuntime.findById(normalizedUserId, {
+      ...options,
+      include: "none"
+    });
+  }
+
+  async function findByEmail(email, options = {}) {
+    const normalizedEmail = normalizeCreatePayload({ email }).email || "";
+    if (!normalizedEmail) {
+      return null;
+    }
+
     const client = options?.trx || knex;
-    const row = await client("users").where({ id: normalizedUserId }).first();
-    return mapProfileRow(row);
+    const row = await client("users").where({ email: normalizedEmail }).first();
+    return row ? normalizeProfileRecord(row) : null;
   }
 
   async function findByIdentity(identityLike, options = {}) {
-    const client = options?.trx || knex;
     const identity = normalizeIdentity(identityLike);
     if (!identity) {
       return null;
     }
 
+    const client = options?.trx || knex;
     const row = await client("users")
       .where({
         auth_provider: identity.provider,
         auth_provider_user_sid: identity.providerUserId
       })
       .first();
-    return mapProfileRow(row);
+
+    return row ? normalizeProfileRecord(row) : null;
   }
 
   async function updateDisplayNameById(userId, displayName, options = {}) {
@@ -146,13 +137,14 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    await client("users")
-      .where({ id: normalizedUserId })
-      .update({
-        display_name: normalizeText(displayName)
-      });
-    return findById(normalizedUserId, { trx: client });
+    return resourceRuntime.updateById(
+      normalizedUserId,
+      { displayName },
+      {
+        ...options,
+        include: "none"
+      }
+    );
   }
 
   async function updateAvatarById(userId, avatar = {}, options = {}) {
@@ -161,16 +153,18 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    await client("users")
-      .where({ id: normalizedUserId })
-      .update({
-        avatar_storage_key: avatar.avatarStorageKey || null,
-        avatar_version: avatar.avatarVersion == null ? null : String(avatar.avatarVersion),
-        avatar_updated_at: toNullableDateTime(avatar.avatarUpdatedAt) || nowDb()
-      });
-
-    return findById(normalizedUserId, { trx: client });
+    return resourceRuntime.updateById(
+      normalizedUserId,
+      {
+        avatarStorageKey: avatar.avatarStorageKey ?? null,
+        avatarVersion: avatar.avatarVersion ?? null,
+        avatarUpdatedAt: avatar.avatarUpdatedAt ?? nowDb()
+      },
+      {
+        ...options,
+        include: "none"
+      }
+    );
   }
 
   async function clearAvatarById(userId, options = {}) {
@@ -179,26 +173,33 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    await client("users")
-      .where({ id: normalizedUserId })
-      .update({
-        avatar_storage_key: null,
-        avatar_version: null,
-        avatar_updated_at: null
-      });
-    return findById(normalizedUserId, { trx: client });
+    return resourceRuntime.updateById(
+      normalizedUserId,
+      {
+        avatarStorageKey: null,
+        avatarVersion: null,
+        avatarUpdatedAt: null
+      },
+      {
+        ...options,
+        include: "none"
+      }
+    );
   }
 
   async function upsert(profileLike = {}, options = {}) {
-    const identity = normalizeIdentity(profileLike);
+    const normalizedPayload = normalizeCreatePayload(profileLike);
+    const identity = normalizeIdentity({
+      provider: normalizedPayload.authProvider,
+      providerUserId: normalizedPayload.authProviderUserSid
+    });
     if (!identity) {
       throw new TypeError("upsert requires provider/authProvider and providerUserId/authProviderUserSid.");
     }
 
-    const email = normalizeLowerText(profileLike.email);
-    const displayName = normalizeText(profileLike.displayName);
-    const requestedUsername = normalizeUsername(profileLike.username);
+    const email = normalizedPayload.email || "";
+    const displayName = normalizedPayload.displayName || "";
+    const requestedUsername = normalizeUsername(normalizedPayload.username);
     if (!email || !displayName) {
       throw new TypeError("upsert requires email and displayName.");
     }
@@ -213,24 +214,44 @@ function createRepository(knex) {
       try {
         if (existing) {
           const existingUsername = normalizeUsername(existing.username);
-          const username = existingUsername || (await resolveUniqueUsername(trx, requestedUsername || usernameBaseFromEmail(email), {
-            excludeUserId: existing.id
-          }));
-          await trx("users").where({ id: normalizeDbRecordId(existing.id, { fallback: null }) }).update({
-            email,
-            display_name: displayName,
-            username
-          });
-        } else {
-          const username = await resolveUniqueUsername(trx, requestedUsername || usernameBaseFromEmail(email));
-          await trx("users").insert({
-            auth_provider: identity.provider,
-            auth_provider_user_sid: identity.providerUserId,
+          const username = existingUsername || (
+            await resolveUniqueUsername(
+              trx,
+              requestedUsername || usernameBaseFromEmail(email),
+              { excludeUserId: existing.id }
+            )
+          );
+          return resourceRuntime.updateById(
+            normalizeDbRecordId(existing.id, { fallback: null }),
+            {
+              email,
+              displayName,
+              username
+            },
+            {
+              trx,
+              include: "none"
+            }
+          );
+        }
+
+        const username = await resolveUniqueUsername(
+          trx,
+          requestedUsername || usernameBaseFromEmail(email)
+        );
+        return resourceRuntime.create(
+          {
+            authProvider: identity.provider,
+            authProviderUserSid: identity.providerUserId,
             email,
-            display_name: displayName,
+            displayName,
             username
-          });
-        }
+          },
+          {
+            trx,
+            include: "none"
+          }
+        );
       } catch (error) {
         if (duplicateTargetsEmail(error)) {
           throw createDuplicateEmailConflictError();
@@ -244,7 +265,7 @@ function createRepository(knex) {
       }
 
       const resolved = await trx("users").where(where).first();
-      return mapProfileRow(resolved);
+      return resolved ? normalizeProfileRecord(resolved) : null;
     };
 
     if (options?.trx) {
@@ -257,6 +278,7 @@ function createRepository(knex) {
   return Object.freeze({
     withTransaction,
     findById,
+    findByEmail,
     findByIdentity,
     updateDisplayNameById,
     updateAvatarById,
@@ -265,4 +287,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, mapProfileRow, normalizeIdentity };
+export { createRepository };

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

@@ -25,8 +25,9 @@ function mapRow(row) {
   };
 
   for (const field of userSettingsFields) {
-    const value = Object.hasOwn(row, field.dbColumn)
-      ? row[field.dbColumn]
+    const column = field.repository.column;
+    const value = Object.hasOwn(row, column)
+      ? row[column]
       : field.resolveDefault({
           settings: mapped,
           row
@@ -66,7 +67,7 @@ function createInsertPayload(userId) {
     const defaultValue = field.resolveDefault({
       settings: resolvedDefaults
     });
-    payload[field.dbColumn] = field.normalizeInput(defaultValue, {
+    payload[field.repository.column] = field.normalizeInput(defaultValue, {
       payload: resolvedDefaults,
       settings: resolvedDefaults
     });
@@ -132,14 +133,14 @@ function createRepository(knex) {
       updated_at: nowDb()
     };
 
-    for (const field of userSettingsFields) {
-      if (!Object.hasOwn(source, field.key)) {
-        continue;
-      }
-      dbPatch[field.dbColumn] = field.normalizeInput(source[field.key], {
-        payload: source,
-        settings: ensured
-      });
+  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.hasOwn(source, "passwordSignInEnabled")) {

package/src/server/common/resources/userProfilesResource.js

@@ -0,0 +1,203 @@
+import { Type } from "typebox";
+import { normalizeDbRecordId, toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
+import {
+  createCursorListValidator,
+  normalizeObjectInput,
+  recordIdSchema
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeIfPresent,
+  normalizeLowerText,
+  normalizeText,
+  normalizeOrNull
+} from "@jskit-ai/kernel/shared/support/normalize";
+
+const USERNAME_MAX_LENGTH = 120;
+
+function normalizeUsername(value) {
+  const normalized = normalizeLowerText(value)
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, USERNAME_MAX_LENGTH);
+
+  return normalized || "";
+}
+
+function normalizeNullableString(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  return normalizeText(value);
+}
+
+function normalizeNullableVersion(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  return String(value);
+}
+
+function normalizeProfileRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const id = normalizeIfPresent(source.id, (value) => normalizeDbRecordId(value, { fallback: null }));
+  const displayName = normalizeText(source.displayName ?? source.display_name);
+  const email = normalizeLowerText(source.email);
+  const username = normalizeUsername(source.username);
+
+  return {
+    id,
+    authProvider: normalizeLowerText(source.authProvider ?? source.auth_provider),
+    authProviderUserSid: normalizeText(source.authProviderUserSid ?? source.auth_provider_user_sid),
+    email,
+    username,
+    displayName,
+    avatarStorageKey: normalizeOrNull(source.avatarStorageKey ?? source.avatar_storage_key, normalizeNullableString),
+    avatarVersion: normalizeNullableVersion(source.avatarVersion ?? source.avatar_version),
+    avatarUpdatedAt: normalizeOrNull(source.avatarUpdatedAt ?? source.avatar_updated_at, toIsoString),
+    createdAt: normalizeIfPresent(source.createdAt ?? source.created_at, toIsoString)
+  };
+}
+
+function normalizeCreatePayload(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "authProvider") || Object.hasOwn(source, "provider")) {
+    normalized.authProvider = normalizeLowerText(source.authProvider ?? source.provider);
+  }
+  if (Object.hasOwn(source, "authProviderUserSid") || Object.hasOwn(source, "providerUserId")) {
+    normalized.authProviderUserSid = normalizeText(source.authProviderUserSid ?? source.providerUserId);
+  }
+  if (Object.hasOwn(source, "email")) {
+    normalized.email = normalizeLowerText(source.email);
+  }
+  if (Object.hasOwn(source, "username")) {
+    normalized.username = normalizeUsername(source.username);
+  }
+  if (Object.hasOwn(source, "displayName")) {
+    normalized.displayName = normalizeText(source.displayName);
+  }
+  if (Object.hasOwn(source, "avatarStorageKey")) {
+    normalized.avatarStorageKey = normalizeNullableString(source.avatarStorageKey);
+  }
+  if (Object.hasOwn(source, "avatarVersion")) {
+    normalized.avatarVersion = normalizeNullableVersion(source.avatarVersion);
+  }
+  if (Object.hasOwn(source, "avatarUpdatedAt")) {
+    normalized.avatarUpdatedAt = toNullableDateTime(source.avatarUpdatedAt);
+  }
+
+  return normalized;
+}
+
+const recordOutputSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    authProvider: Type.String({ minLength: 1 }),
+    authProviderUserSid: Type.String({ minLength: 1 }),
+    email: Type.String({ minLength: 1 }),
+    username: Type.String({ minLength: 1 }),
+    displayName: Type.String({ minLength: 1 }),
+    avatarStorageKey: Type.Union([Type.String(), Type.Null()]),
+    avatarVersion: Type.Union([Type.String(), Type.Null()]),
+    avatarUpdatedAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]),
+    createdAt: Type.String({ format: "date-time", minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+
+const createBodySchema = Type.Object(
+  {
+    authProvider: Type.String({ minLength: 1, maxLength: 64 }),
+    authProviderUserSid: Type.String({ minLength: 1, maxLength: 191 }),
+    email: Type.String({ minLength: 1, maxLength: 255 }),
+    username: Type.Optional(Type.String({ minLength: 1, maxLength: USERNAME_MAX_LENGTH })),
+    displayName: Type.String({ minLength: 1, maxLength: 160 }),
+    avatarStorageKey: Type.Optional(Type.Union([Type.String({ maxLength: 512 }), Type.Null()])),
+    avatarVersion: Type.Optional(Type.Union([Type.String({ maxLength: 64 }), Type.Null()])),
+    avatarUpdatedAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]))
+  },
+  {
+    additionalProperties: false,
+    required: []
+  }
+);
+
+const patchBodySchema = Type.Partial(createBodySchema, {
+  additionalProperties: false
+});
+
+const recordOutputValidator = Object.freeze({
+  schema: recordOutputSchema,
+  normalize: normalizeProfileRecord
+});
+
+const createBodyValidator = Object.freeze({
+  schema: createBodySchema,
+  normalize: normalizeCreatePayload
+});
+
+const patchBodyValidator = Object.freeze({
+  schema: patchBodySchema,
+  normalize: normalizeCreatePayload
+});
+
+const resource = Object.freeze({
+  namespace: "userProfiles",
+  tableName: "users",
+  idColumn: "id",
+  operations: Object.freeze({
+    list: Object.freeze({
+      method: "GET",
+      outputValidator: createCursorListValidator(recordOutputValidator)
+    }),
+    view: Object.freeze({
+      method: "GET",
+      outputValidator: recordOutputValidator
+    }),
+    create: Object.freeze({
+      method: "POST",
+      bodyValidator: createBodyValidator,
+      outputValidator: recordOutputValidator
+    }),
+    patch: Object.freeze({
+      method: "PATCH",
+      bodyValidator: patchBodyValidator,
+      outputValidator: recordOutputValidator
+    })
+  }),
+  fieldMeta: Object.freeze([
+    Object.freeze({
+      key: "authProvider",
+      repository: { column: "auth_provider" }
+    }),
+    Object.freeze({
+      key: "authProviderUserSid",
+      repository: { column: "auth_provider_user_sid" }
+    }),
+    Object.freeze({
+      key: "displayName",
+      repository: { column: "display_name" }
+    }),
+    Object.freeze({
+      key: "avatarStorageKey",
+      repository: { column: "avatar_storage_key" }
+    }),
+    Object.freeze({
+      key: "avatarVersion",
+      repository: { column: "avatar_version" }
+    }),
+    Object.freeze({
+      key: "avatarUpdatedAt",
+      repository: { column: "avatar_updated_at" }
+    }),
+    Object.freeze({
+      key: "createdAt",
+      repository: { column: "created_at" }
+    })
+  ])
+});
+
+export { resource };

package/src/server/common/services/accountContextService.js

@@ -1,10 +1,10 @@
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeIdentity } from "../repositories/usersRepository.js";
+import { normalizeIdentity } from "../support/identity.js";
 
-async function resolveUserProfile(usersRepository, user) {
+async function resolveUserProfile(userProfilesRepository, user) {
   const identity = normalizeIdentity(user);
   if (identity) {
-    const profile = await usersRepository.findByIdentity(identity);
+    const profile = await userProfilesRepository.findByIdentity(identity);
     if (profile) {
       return profile;
     }
@@ -12,7 +12,7 @@ async function resolveUserProfile(usersRepository, user) {
 
   const userId = normalizeRecordId(user?.id, { fallback: null });
   if (userId) {
-    const profileById = await usersRepository.findById(userId);
+    const profileById = await userProfilesRepository.findById(userId);
     if (profileById) {
       return profileById;
     }

package/src/server/common/services/authProfileSyncService.js

@@ -1,6 +1,6 @@
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeIdentity } from "../repositories/usersRepository.js";
+import { normalizeIdentity } from "../support/identity.js";
 
 function buildNormalizedIdentityKey(identityLike) {
   const identity = normalizeIdentity(identityLike);
@@ -64,15 +64,15 @@ function normalizeLifecycleContributors(entries = []) {
   );
 }
 
-function createService({ usersRepository, lifecycleContributors = [], userSettingsRepository = null } = {}) {
-  if (!usersRepository || typeof usersRepository.findByIdentity !== "function") {
-    throw new Error("authProfileSyncService requires usersRepository.findByIdentity().");
+function createService({ userProfilesRepository, lifecycleContributors = [], userSettingsRepository = null } = {}) {
+  if (!userProfilesRepository || typeof userProfilesRepository.findByIdentity !== "function") {
+    throw new Error("authProfileSyncService requires userProfilesRepository.findByIdentity().");
   }
-  if (typeof usersRepository.upsert !== "function") {
-    throw new Error("authProfileSyncService requires usersRepository.upsert().");
+  if (typeof userProfilesRepository.upsert !== "function") {
+    throw new Error("authProfileSyncService requires userProfilesRepository.upsert().");
   }
-  if (typeof usersRepository.withTransaction !== "function") {
-    throw new Error("authProfileSyncService requires usersRepository.withTransaction().");
+  if (typeof userProfilesRepository.withTransaction !== "function") {
+    throw new Error("authProfileSyncService requires userProfilesRepository.withTransaction().");
   }
   if (!userSettingsRepository || typeof userSettingsRepository.ensureForUserId !== "function") {
     throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
@@ -82,7 +82,7 @@ function createService({ usersRepository, lifecycleContributors = [], userSettin
 
   async function findByIdentity(identityLike, options = {}) {
     const normalized = buildNormalizedIdentityKey(identityLike);
-    return usersRepository.findByIdentity(
+    return userProfilesRepository.findByIdentity(
       {
         provider: normalized.authProvider,
         providerUserId: normalized.authProviderUserSid
@@ -93,7 +93,7 @@ function createService({ usersRepository, lifecycleContributors = [], userSettin
 
   async function upsertByIdentity(profileLike, options = {}) {
     const normalized = buildNormalizedIdentityProfile(profileLike);
-    return usersRepository.upsert(
+    return userProfilesRepository.upsert(
       {
         authProvider: normalized.authProvider,
         authProviderUserSid: normalized.authProviderUserSid,
@@ -144,7 +144,7 @@ function createService({ usersRepository, lifecycleContributors = [], userSettin
       return runSync(options.trx);
     }
 
-    return usersRepository.withTransaction((trx) => runSync(trx));
+    return userProfilesRepository.withTransaction((trx) => runSync(trx));
   }
 
   return Object.freeze({

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

@@ -0,0 +1,17 @@
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizeIdentity(identityLike) {
+  const source = identityLike && typeof identityLike === "object" ? identityLike : {};
+  const provider = normalizeLowerText(source.provider || source.authProvider);
+  const providerUserId = normalizeText(source.providerUserId || source.authProviderUserSid);
+  if (!provider || !providerUserId) {
+    return null;
+  }
+
+  return {
+    provider,
+    providerUserId
+  };
+}
+
+export { normalizeIdentity };

package/src/server/registerUsersBootstrap.js

@@ -9,8 +9,8 @@ function registerUsersBootstrap(app) {
 
   registerBootstrapPayloadContributor(app, "users.core.bootstrap.payloadContributor", (scope) => {
     return createUsersBootstrapContributor({
-      usersRepository: scope.make("usersRepository"),
-      userSettingsRepository: scope.make("userSettingsRepository"),
+      userProfilesRepository: scope.make("internal.repository.user-profiles"),
+      userSettingsRepository: scope.make("internal.repository.user-settings"),
       appConfig: resolveAppConfig(scope),
       authService: scope.make("authService")
     });