@jskit-ai/users-core 0.1.42 → 0.1.43

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

@@ -1,9 +1,12 @@
 import {
   normalizeLowerText,
+  normalizeRecordId,
+  normalizeDbRecordId,
   normalizeText,
   toIsoString,
   nowDb,
-  isDuplicateEntryError
+  isDuplicateEntryError,
+  createWithTransaction
 } from "./repositoryUtils.js";
 import { OWNER_ROLE_ID } from "../../../shared/roles.js";
 
@@ -13,9 +16,9 @@ function mapRow(row) {
   }
 
   return {
-    id: Number(row.id),
-    workspaceId: Number(row.workspace_id),
-    userId: Number(row.user_id),
+    id: normalizeDbRecordId(row.id, { fallback: "" }),
+    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
+    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
     roleSid: normalizeLowerText(row.role_sid || "member") || "member",
     status: normalizeLowerText(row.status || "active") || "active",
     createdAt: toIsoString(row.created_at),
@@ -29,7 +32,7 @@ function mapMemberSummaryRow(row) {
   }
 
   return {
-    userId: Number(row.user_id),
+    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
     roleSid: normalizeLowerText(row.role_sid || "member") || "member",
     status: normalizeLowerText(row.status || "active") || "active",
     displayName: normalizeText(row.display_name),
@@ -41,35 +44,48 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("workspaceMembershipsRepository requires knex.");
   }
+  const withTransaction = createWithTransaction(knex);
 
   async function findByWorkspaceIdAndUserId(workspaceId, userId, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedWorkspaceId || !normalizedUserId) {
+      return null;
+    }
+
     const client = options?.trx || knex;
     const row = await client("workspace_memberships")
-      .where({ workspace_id: Number(workspaceId), user_id: Number(userId) })
+      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
       .first();
     return mapRow(row);
   }
 
   async function ensureOwnerMembership(workspaceId, userId, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedWorkspaceId || !normalizedUserId) {
+      throw new TypeError("workspaceMembershipsRepository.ensureOwnerMembership requires workspaceId and userId.");
+    }
+
     const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     if (existing) {
       if (existing.roleSid !== OWNER_ROLE_ID || existing.status !== "active") {
         await client("workspace_memberships")
-          .where({ workspace_id: Number(workspaceId), user_id: Number(userId) })
+          .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
           .update({
             role_sid: OWNER_ROLE_ID,
             status: "active",
             updated_at: nowDb()
           });
       }
-      return findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     }
 
     try {
       await client("workspace_memberships").insert({
-        workspace_id: Number(workspaceId),
-        user_id: Number(userId),
+        workspace_id: normalizedWorkspaceId,
+        user_id: normalizedUserId,
         role_sid: OWNER_ROLE_ID,
         status: "active",
         created_at: nowDb(),
@@ -81,43 +97,54 @@ function createRepository(knex) {
       }
     }
 
-    return findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
   }
 
   async function upsertMembership(workspaceId, userId, patch = {}, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedWorkspaceId || !normalizedUserId) {
+      throw new TypeError("workspaceMembershipsRepository.upsertMembership requires workspaceId and userId.");
+    }
+
     const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     const roleSid = normalizeLowerText(patch.roleSid || existing?.roleSid || "member") || "member";
     const status = normalizeLowerText(patch.status || existing?.status || "active") || "active";
 
     if (!existing) {
       await client("workspace_memberships").insert({
-        workspace_id: Number(workspaceId),
-        user_id: Number(userId),
+        workspace_id: normalizedWorkspaceId,
+        user_id: normalizedUserId,
         role_sid: roleSid,
         status,
         created_at: nowDb(),
         updated_at: nowDb()
       });
-      return findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     }
 
     await client("workspace_memberships")
-      .where({ workspace_id: Number(workspaceId), user_id: Number(userId) })
+      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
       .update({
         role_sid: roleSid,
         status,
         updated_at: nowDb()
       });
 
-    return findByWorkspaceIdAndUserId(workspaceId, userId, { trx: client });
+    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
   }
 
   async function listActiveByWorkspaceId(workspaceId, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedWorkspaceId) {
+      return [];
+    }
+
     const client = options?.trx || knex;
     const rows = await client("workspace_memberships as wm")
       .join("users as up", "up.id", "wm.user_id")
-      .where({ "wm.workspace_id": Number(workspaceId), "wm.status": "active" })
+      .where({ "wm.workspace_id": normalizedWorkspaceId, "wm.status": "active" })
       .orderBy("up.display_name", "asc")
       .select([
         "wm.user_id",
@@ -131,21 +158,27 @@ function createRepository(knex) {
   }
 
   async function listActiveWorkspaceIdsByUserId(userId, options = {}) {
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedUserId) {
+      return [];
+    }
+
     const client = options?.trx || knex;
     const rows = await client("workspace_memberships")
       .where({
-        user_id: Number(userId),
+        user_id: normalizedUserId,
         status: "active"
       })
       .select("workspace_id")
       .orderBy("workspace_id", "asc");
 
     return rows
-      .map((row) => Number(row.workspace_id))
-      .filter((workspaceId) => Number.isInteger(workspaceId) && workspaceId > 0);
+      .map((row) => normalizeDbRecordId(row.workspace_id, { fallback: null }))
+      .filter(Boolean);
   }
 
   return Object.freeze({
+    withTransaction,
     findByWorkspaceIdAndUserId,
     ensureOwnerMembership,
     upsertMembership,

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

@@ -1,10 +1,14 @@
+import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
 import {
+  normalizeDbRecordId,
+  normalizeRecordId,
   normalizeText,
   normalizeLowerText,
   toIsoString,
   toNullableIso,
   nowDb,
-  isDuplicateEntryError
+  isDuplicateEntryError,
+  createWithTransaction
 } from "./repositoryUtils.js";
 
 function mapRow(row) {
@@ -13,10 +17,10 @@ function mapRow(row) {
   }
 
   return {
-    id: Number(row.id),
+    id: normalizeDbRecordId(row.id, { fallback: "" }),
     slug: normalizeText(row.slug),
     name: normalizeText(row.name),
-    ownerUserId: Number(row.owner_user_id),
+    ownerUserId: normalizeDbRecordId(row.owner_user_id, { fallback: "" }),
     isPersonal: Boolean(row.is_personal),
     avatarUrl: row.avatar_url ? normalizeText(row.avatar_url) : "",
     createdAt: toIsoString(row.created_at),
@@ -41,6 +45,7 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("workspacesRepository requires knex.");
   }
+  const withTransaction = createWithTransaction(knex);
 
   function workspaceSelectColumns({ includeMembership = false } = {}) {
     const columns = [
@@ -61,9 +66,14 @@ function createRepository(knex) {
   }
 
   async function findById(workspaceId, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedWorkspaceId) {
+      return null;
+    }
+
     const client = options?.trx || knex;
     const row = await client("workspaces as w")
-      .where({ "w.id": Number(workspaceId) })
+      .where({ "w.id": normalizedWorkspaceId })
       .select(workspaceSelectColumns())
       .first();
     return mapRow(row);
@@ -84,9 +94,14 @@ function createRepository(knex) {
   }
 
   async function findPersonalByOwnerUserId(userId, options = {}) {
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedUserId) {
+      return null;
+    }
+
     const client = options?.trx || knex;
     const row = await client("workspaces as w")
-      .where({ "w.owner_user_id": Number(userId), "w.is_personal": 1 })
+      .where({ "w.owner_user_id": normalizedUserId, "w.is_personal": 1 })
       .orderBy("w.id", "asc")
       .select(workspaceSelectColumns())
       .first();
@@ -96,11 +111,15 @@ function createRepository(knex) {
   async function insert(payload = {}, options = {}) {
     const client = options?.trx || knex;
     const source = payload && typeof payload === "object" ? payload : {};
+    const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
+    if (!ownerUserId) {
+      throw new TypeError("workspacesRepository.insert requires ownerUserId.");
+    }
 
     const insertPayload = {
       slug: normalizeLowerText(source.slug),
       name: normalizeText(source.name),
-      owner_user_id: Number(source.ownerUserId),
+      owner_user_id: ownerUserId,
       is_personal: source.isPersonal ? 1 : 0,
       avatar_url: normalizeText(source.avatarUrl),
       created_at: nowDb(),
@@ -110,8 +129,8 @@ function createRepository(knex) {
 
     try {
       const result = await client("workspaces").insert(insertPayload);
-      const insertedId = Array.isArray(result) ? Number(result[0]) : Number(result);
-      if (Number.isInteger(insertedId) && insertedId > 0) {
+      const insertedId = resolveInsertedRecordId(result, { fallback: null });
+      if (insertedId) {
         return findById(insertedId, { trx: client });
       }
       const bySlug = await findBySlug(insertPayload.slug, { trx: client });
@@ -129,6 +148,11 @@ function createRepository(knex) {
   }
 
   async function updateById(workspaceId, patch = {}, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedWorkspaceId) {
+      return null;
+    }
+
     const client = options?.trx || knex;
     const source = patch && typeof patch === "object" ? patch : {};
     const dbPatch = {
@@ -142,15 +166,20 @@ function createRepository(knex) {
       dbPatch.avatar_url = normalizeText(source.avatarUrl);
     }
 
-    await client("workspaces").where({ id: Number(workspaceId) }).update(dbPatch);
-    return findById(workspaceId, { trx: client });
+    await client("workspaces").where({ id: normalizedWorkspaceId }).update(dbPatch);
+    return findById(normalizedWorkspaceId, { trx: client });
   }
 
   async function listForUserId(userId, options = {}) {
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedUserId) {
+      return [];
+    }
+
     const client = options?.trx || knex;
     const rows = await client("workspace_memberships as wm")
       .join("workspaces as w", "w.id", "wm.workspace_id")
-      .where({ "wm.user_id": Number(userId) })
+      .where({ "wm.user_id": normalizedUserId })
       .whereNull("w.deleted_at")
       .orderBy("w.is_personal", "desc")
       .orderBy("w.id", "asc")
@@ -160,6 +189,7 @@ function createRepository(knex) {
   }
 
   return Object.freeze({
+    withTransaction,
     findById,
     findBySlug,
     findPersonalByOwnerUserId,

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

@@ -1,3 +1,4 @@
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeIdentity } from "../repositories/usersRepository.js";
 
 async function resolveUserProfile(usersRepository, user) {
@@ -9,8 +10,8 @@ async function resolveUserProfile(usersRepository, user) {
     }
   }
 
-  const userId = Number(user?.id);
-  if (Number.isInteger(userId) && userId > 0) {
+  const userId = normalizeRecordId(user?.id, { fallback: null });
+  if (userId) {
     const profileById = await usersRepository.findById(userId);
     if (profileById) {
       return profileById;

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

@@ -1,3 +1,4 @@
+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";
 
@@ -46,7 +47,7 @@ function profileNeedsUpdate(existing, nextProfile) {
 }
 
 function requireSynchronizedProfile(profile) {
-  if (profile && Number.isFinite(Number(profile.id)) && String(profile.displayName || "").trim()) {
+  if (profile && normalizeRecordId(profile.id, { fallback: null }) && String(profile.displayName || "").trim()) {
     return profile;
   }
 
@@ -60,6 +61,9 @@ function createService({ usersRepository, workspaceProvisioningService = null, u
   if (typeof usersRepository.upsert !== "function") {
     throw new Error("authProfileSyncService requires usersRepository.upsert().");
   }
+  if (typeof usersRepository.withTransaction !== "function") {
+    throw new Error("authProfileSyncService requires usersRepository.withTransaction().");
+  }
   if (!userSettingsRepository || typeof userSettingsRepository.ensureForUserId !== "function") {
     throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
   }
@@ -118,10 +122,8 @@ function createService({ usersRepository, workspaceProvisioningService = null, u
     if (options?.trx) {
       return runSync(options.trx);
     }
-    if (typeof usersRepository.withTransaction === "function") {
-      return usersRepository.withTransaction((trx) => runSync(trx));
-    }
-    return runSync();
+
+    return usersRepository.withTransaction((trx) => runSync(trx));
   }
 
   return Object.freeze({

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

@@ -11,6 +11,7 @@ import {
   mapWorkspaceSummary
 } from "../formatters/workspaceFormatter.js";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { authenticatedUserValidator } from "../validators/authenticatedUserValidator.js";
 
 function toSlugPart(value) {
@@ -237,7 +238,9 @@ function createService({
       normalizedUser.id,
       options
     );
-    const actorOwnsWorkspace = Number(workspace.ownerUserId) === Number(normalizedUser.id);
+    const actorOwnsWorkspace =
+      normalizeRecordId(workspace.ownerUserId, { fallback: null }) ===
+      normalizeRecordId(normalizedUser.id, { fallback: null });
     const membershipIsActive = normalizeLowerText(membership?.status) === "active";
 
     if (!membershipIsActive && actorOwnsWorkspace) {

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

@@ -1,7 +1,8 @@
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { deepFreeze } from "./deepFreeze.js";
 
 function resolveActorScopedEntityId({ options } = {}) {
-  return Number(options?.context?.actor?.id || 0);
+  return normalizeRecordId(options?.context?.actor?.id, { fallback: "" });
 }
 
 function resolveWorkspaceSlugPayload({ args } = {}) {
@@ -66,7 +67,7 @@ function createWorkspaceEntityAndBootstrapEvents({
       source: "workspace",
       entity: normalizedWorkspaceEntity,
       operation: normalizedWorkspaceOperation,
-      entityId: workspaceEntityId,
+      entityId: (payload = {}) => normalizeRecordId(workspaceEntityId(payload), { fallback: "" }),
       realtime: {
         event: normalizedWorkspaceRealtimeEvent,
         payload: resolveWorkspaceSlugPayload,
@@ -78,7 +79,7 @@ function createWorkspaceEntityAndBootstrapEvents({
       source: "users",
       entity: "bootstrap",
       operation: "updated",
-      entityId: bootstrapEntityId,
+      entityId: (payload = {}) => normalizeRecordId(bootstrapEntityId(payload), { fallback: "" }),
       realtime: {
         event: "users.bootstrap.changed",
         audience: bootstrapAudience

package/src/server/common/validators/authenticatedUserValidator.js

@@ -1,11 +1,12 @@
 import { Type } from "@fastify/type-provider-typebox";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { normalizeObjectInput, recordIdInputSchema } from "@jskit-ai/kernel/shared/validators";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
 function normalizeAuthenticatedUser(input = {}) {
   const source = normalizeObjectInput(input);
-  const id = Number(source.id);
-  if (!Number.isInteger(id) || id < 1) {
+  const id = normalizeRecordId(source.id, { fallback: null });
+  if (!id) {
     return null;
   }
 
@@ -25,7 +26,7 @@ function normalizeAuthenticatedUser(input = {}) {
 const authenticatedUserValidator = Object.freeze({
   schema: Type.Object(
     {
-      id: Type.Integer({ minimum: 1 }),
+      id: recordIdInputSchema,
       email: Type.String({ minLength: 1 }),
       username: Type.Optional(Type.String()),
       displayName: Type.Optional(Type.String()),

package/src/server/consoleSettings/consoleService.js

@@ -1,5 +1,5 @@
 import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
 function createService({ consoleSettingsRepository } = {}) {
   if (!consoleSettingsRepository || typeof consoleSettingsRepository.ensureOwnerUserId !== "function") {
@@ -7,7 +7,7 @@ function createService({ consoleSettingsRepository } = {}) {
   }
 
   async function ensureInitialConsoleMember(userId, options = {}) {
-    const normalizedUserId = parsePositiveInteger(userId);
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
     if (!normalizedUserId) {
       throw new AppError(400, "Invalid console user.");
     }
@@ -16,7 +16,7 @@ function createService({ consoleSettingsRepository } = {}) {
   }
 
   async function requireConsoleOwner(context = {}, options = {}) {
-    const actorUserId = parsePositiveInteger(context?.actor?.id);
+    const actorUserId = normalizeRecordId(context?.actor?.id, { fallback: null });
     if (!actorUserId) {
       throw new AppError(401, "Authentication required.");
     }

package/src/server/consoleSettings/consoleSettingsRepository.js

@@ -1,8 +1,10 @@
 import {
+  normalizeDbRecordId,
+  normalizeRecordId,
   nowDb,
-  toIsoString
+  toIsoString,
+  createWithTransaction
 } from "../common/repositories/repositoryUtils.js";
-import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
 import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
 import { consoleSettingsFields } from "../../shared/resources/consoleSettingsFields.js";
 
@@ -26,10 +28,10 @@ function mapSingletonRow(row) {
     throw new Error("console_settings singleton row is missing.");
   }
 
-  const ownerUserId = parsePositiveInteger(row.owner_user_id);
+  const ownerUserId = normalizeDbRecordId(row.owner_user_id, { fallback: null });
   return {
-    id: Number(row.id),
-    ownerUserId: ownerUserId || null,
+    id: normalizeDbRecordId(row.id, { fallback: "1" }),
+    ownerUserId,
     settings: mapSettings(row),
     createdAt: toIsoString(row.created_at),
     updatedAt: toIsoString(row.updated_at)
@@ -40,6 +42,7 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("consoleSettingsRepository requires knex.");
   }
+  const withTransaction = createWithTransaction(knex);
 
   async function readSingleton(client) {
     return client("console_settings").where({ id: 1 }).first();
@@ -52,7 +55,7 @@ function createRepository(knex) {
 
   async function ensureOwnerUserId(userId, options = {}) {
     const client = options?.trx || knex;
-    const candidateOwnerUserId = parsePositiveInteger(userId);
+    const candidateOwnerUserId = normalizeRecordId(userId, { fallback: null });
     if (!candidateOwnerUserId) {
       throw new TypeError("consoleSettingsRepository.ensureOwnerUserId requires a positive user id.");
     }
@@ -102,6 +105,7 @@ function createRepository(knex) {
   }
 
   return Object.freeze({
+    withTransaction,
     getSingleton,
     ensureOwnerUserId,
     updateSingleton

package/src/server/usersBootstrapContributor.js

@@ -13,6 +13,7 @@ import {
 import { accountAvatarFormatter } from "./common/formatters/accountAvatarFormatter.js";
 import { authenticatedUserValidator } from "./common/validators/authenticatedUserValidator.js";
 import { userSettingsFields } from "../shared/resources/userSettingsFields.js";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
 function getOAuthProviderCatalogPayload(authService) {
   if (!authService || typeof authService.getOAuthProviderCatalog !== "function") {
@@ -194,12 +195,15 @@ function createUsersBootstrapContributor({
         const latestProfile = (await usersRepository.findById(normalizedUser.id)) || normalizedUser;
         const userSettings = await userSettingsRepository.ensureForUserId(latestProfile.id);
 
-        let seededConsoleOwnerUserId = 0;
+        let seededConsoleOwnerUserId = null;
         if (
           consoleService &&
           typeof consoleService.ensureInitialConsoleMember === "function"
         ) {
-          seededConsoleOwnerUserId = Number(await consoleService.ensureInitialConsoleMember(latestProfile.id));
+          seededConsoleOwnerUserId = normalizeRecordId(
+            await consoleService.ensureInitialConsoleMember(latestProfile.id),
+            { fallback: null }
+          );
         }
 
         payload = {
@@ -221,7 +225,7 @@ function createUsersBootstrapContributor({
           requestedWorkspace: null,
           permissions: [],
           surfaceAccess: {
-            consoleowner: seededConsoleOwnerUserId > 0 && seededConsoleOwnerUserId === Number(latestProfile.id)
+            consoleowner: Boolean(seededConsoleOwnerUserId) && seededConsoleOwnerUserId === String(latestProfile.id)
           },
           workspaceSettings: null,
           userSettings: mapUserSettingsBootstrap(userSettings),

package/src/server/workspaceBootstrapContributor.js

@@ -1,4 +1,5 @@
 import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeLowerText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 import {
   TENANCY_MODE_NONE,
@@ -129,7 +130,10 @@ function createWorkspaceBootstrapContributor({
   return Object.freeze({
     contributorId,
     async contribute({ request = null, query = {}, payload = {} } = {}) {
-      const normalizedUserId = Number(payload?.session?.authenticated === true ? payload?.session?.userId : 0);
+      const normalizedUserId = normalizeRecordId(
+        payload?.session?.authenticated === true ? payload?.session?.userId : null,
+        { fallback: null }
+      );
       const normalizedWorkspaceSlug = resolveBootstrapWorkspaceSlug({ query, request });
       if (!normalizedUserId) {
         if (!normalizedWorkspaceSlug || resolvedTenancyProfile.mode === TENANCY_MODE_NONE) {

package/src/server/workspaceMembers/registerWorkspaceMembers.js

@@ -1,4 +1,6 @@
 import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { normalizeDbRecordId } from "@jskit-ai/database-runtime/shared";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
 import { deepFreeze } from "../common/support/deepFreeze.js";
 import { createService as createWorkspaceMembersService } from "./workspaceMembersService.js";
@@ -23,8 +25,8 @@ const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
       return [];
     }
 
-    const inviteId = Number(event?.entityId);
-    if (!Number.isInteger(inviteId) || inviteId < 1) {
+    const inviteId = normalizeRecordId(event?.entityId, { fallback: null });
+    if (!inviteId) {
       return [];
     }
 
@@ -33,8 +35,8 @@ const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
       .where("wi.id", inviteId)
       .first("up.id as user_id");
 
-    const userId = Number(row?.user_id || 0);
-    if (!Number.isInteger(userId) || userId < 1) {
+    const userId = normalizeDbRecordId(row?.user_id, { fallback: null });
+    if (!userId) {
       return [];
     }