@jskit-ai/users-core 0.1.32 → 0.1.35

package/src/server/accountProfile/avatarService.js

@@ -21,9 +21,9 @@ async function readAvatarBuffer(stream, { maxBytes = DEFAULT_AVATAR_POLICY.maxUp
   });
 }
 
-function createService({ userProfilesRepository, avatarStorageService, avatarPolicy } = {}) {
-  if (!userProfilesRepository) {
-    throw new TypeError("avatarService requires userProfilesRepository.");
+function createService({ usersRepository, avatarStorageService, avatarPolicy } = {}) {
+  if (!usersRepository) {
+    throw new TypeError("avatarService requires usersRepository.");
   }
   if (!avatarStorageService) {
     throw new TypeError("avatarService requires avatarStorageService.");
@@ -32,21 +32,21 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
   const resolvedAvatarPolicy = resolveAvatarPolicy(avatarPolicy);
 
   async function resolveProfile(user) {
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }
     return profile;
   }
 
-  async function uploadForUser(user, payload = {}) {
+  async function uploadForUser(user, avatarUpload = {}) {
     const profile = await resolveProfile(user);
-    validateUploadMimeType(payload?.mimeType, resolvedAvatarPolicy, {
+    validateUploadMimeType(avatarUpload?.mimeType, resolvedAvatarPolicy, {
       fieldName: "avatar",
       label: "Avatar"
     });
 
-    const buffer = await readAvatarBuffer(payload.stream, {
+    const buffer = await readAvatarBuffer(avatarUpload?.stream, {
       maxBytes: resolvedAvatarPolicy.maxUploadBytes
     });
 
@@ -57,7 +57,7 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
       buffer
     });
 
-    const updatedProfile = await userProfilesRepository.updateAvatarById(profile.id, {
+    const updatedProfile = await usersRepository.updateAvatarById(profile.id, {
       avatarStorageKey: savedAvatar.storageKey,
       avatarVersion,
       avatarUpdatedAt: new Date(avatarVersionMs)
@@ -73,7 +73,7 @@ function createService({ userProfilesRepository, avatarStorageService, avatarPol
     if (profile.avatarStorageKey) {
       await avatarStorageService.deleteAvatar(profile.avatarStorageKey);
     }
-    return userProfilesRepository.clearAvatarById(profile.id);
+    return usersRepository.clearAvatarById(profile.id);
   }
 
   async function readForUser(user) {

package/src/server/accountProfile/bootAccountProfileRoutes.js

@@ -1,4 +1,5 @@
 import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
+import { DEFAULT_IMAGE_UPLOAD_MAX_BYTES } from "@jskit-ai/uploads-runtime/shared";
 import { readSingleMultipartFile } from "@jskit-ai/uploads-runtime/server/multipart/readSingleMultipartFile";
 import { userSettingsResource } from "../../shared/resources/userSettingsResource.js";
 import { userProfileResource } from "../../shared/resources/userProfileResource.js";
@@ -77,7 +78,7 @@ function bootAccountProfileRoutes(app) {
       }
     },
     async function (request, reply) {
-      const avatar = await accountProfileService.readAvatar(request, request.user, {}, {
+      const avatar = await accountProfileService.readAvatar(request, request.user, {
         context: {
           actor: request.user
         }
@@ -114,10 +115,11 @@ function bootAccountProfileRoutes(app) {
     },
     async function (request, reply) {
       const filePart = await readSingleMultipartFile(request, {
-        fieldNames: ["avatar"],
+        fieldName: "avatar",
         required: true,
         fieldErrorKey: "avatar",
-        label: "Avatar"
+        label: "Avatar",
+        maxBytes: DEFAULT_IMAGE_UPLOAD_MAX_BYTES
       });
 
       const uploadDimension = filePart.fields?.uploadDimension?.value;

package/src/server/accountProfile/registerAccountProfile.js

@@ -20,7 +20,7 @@ function registerAccountProfile(app) {
 
   app.singleton("users.avatar.service", (scope) =>
     createAvatarService({
-      userProfilesRepository: scope.make("userProfilesRepository"),
+      usersRepository: scope.make("usersRepository"),
       avatarStorageService: scope.make("users.avatar.storage.service")
     })
   );
@@ -30,7 +30,7 @@ function registerAccountProfile(app) {
     (scope) =>
       createAccountProfileService({
         userSettingsRepository: scope.make("userSettingsRepository"),
-        userProfilesRepository: scope.make("userProfilesRepository"),
+        usersRepository: scope.make("usersRepository"),
         authService: scope.make("authService"),
         avatarService: scope.make("users.avatar.service")
       }),

package/src/server/accountSecurity/accountSecurityService.js

@@ -10,10 +10,10 @@ import {
 
 function createService({
   userSettingsRepository,
-  userProfilesRepository,
+  usersRepository,
   authService
 } = {}) {
-  if (!userSettingsRepository || !userProfilesRepository) {
+  if (!userSettingsRepository || !usersRepository) {
     throw new Error("accountSecurityService requires repositories.");
   }
 
@@ -40,7 +40,7 @@ function createService({
       throw new AppError(501, "Password method toggle is not available.");
     }
 
-    const profile = await resolveUserProfile(userProfilesRepository, user);
+    const profile = await resolveUserProfile(usersRepository, user);
     if (!profile) {
       throw new AppError(404, "User profile was not found.");
     }

package/src/server/accountSecurity/registerAccountSecurity.js

@@ -11,7 +11,7 @@ function registerAccountSecurity(app) {
     const authService = scope.has("authService") ? scope.make("authService") : null;
     return createAccountSecurityService({
       userSettingsRepository: scope.make("userSettingsRepository"),
-      userProfilesRepository: scope.make("userProfilesRepository"),
+      usersRepository: scope.make("usersRepository"),
       authService
     });
   });

package/src/server/common/contributors/workspaceActionContextContributor.js

@@ -2,6 +2,7 @@ import {
   normalizeObject,
   requireServiceMethod
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 import {
   checkRouteVisibility,
   USERS_ROUTE_VISIBILITY_PUBLIC,
@@ -9,45 +10,51 @@ import {
   USERS_ROUTE_VISIBILITY_WORKSPACE_USER
 } from "../../../shared/support/usersVisibility.js";
 import { resolveActionUser } from "../support/resolveActionUser.js";
-
-const WORKSPACE_CONTEXT_ACTION_IDS = Object.freeze([
-  "workspace.roles.list",
-  "workspace.settings.read",
-  "workspace.settings.update",
-  "workspace.members.list",
-  "workspace.member.role.update",
-  "workspace.member.remove",
-  "workspace.invites.list",
-  "workspace.invite.create",
-  "workspace.invite.revoke"
-]);
 const WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET = new Set([
   USERS_ROUTE_VISIBILITY_WORKSPACE,
   USERS_ROUTE_VISIBILITY_WORKSPACE_USER
 ]);
 
-function createWorkspaceActionContextContributor({ workspaceService } = {}) {
+function normalizeWorkspaceSurfaceIds(surfaceIds = []) {
+  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
+  const normalized = new Set();
+
+  for (const entry of source) {
+    const surfaceId = normalizeSurfaceId(entry);
+    if (!surfaceId) {
+      continue;
+    }
+    normalized.add(surfaceId);
+  }
+
+  return normalized;
+}
+
+function createWorkspaceActionContextContributor({ workspaceService, workspaceSurfaceIds = [] } = {}) {
   const contributorId = "users.workspace.context";
+  const workspaceSurfaceIdSet = normalizeWorkspaceSurfaceIds(workspaceSurfaceIds);
 
   requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId);
 
   return Object.freeze({
     contributorId,
-    async contribute({ actionId, input, context, request } = {}) {
+    async contribute({ definition = null, input, context, request } = {}) {
       const payload = normalizeObject(input);
       if (!Object.hasOwn(payload, "workspaceSlug")) {
         return {};
       }
 
-      const actionName = String(actionId || "").trim();
-      const hasLegacyWorkspaceActionId = WORKSPACE_CONTEXT_ACTION_IDS.includes(actionName);
+      const actionSurfaces = Array.isArray(definition?.surfaces) ? definition.surfaces : [];
+      const hasWorkspaceActionSurface = actionSurfaces.some((surfaceId) => workspaceSurfaceIdSet.has(surfaceId));
+      const routeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
+      const hasWorkspaceSurface = workspaceSurfaceIdSet.has(routeSurfaceId);
       const routeVisibilityInput =
         request && request.routeOptions && request.routeOptions.config
           ? request.routeOptions.config.visibility
           : USERS_ROUTE_VISIBILITY_PUBLIC;
       const routeVisibility = checkRouteVisibility(routeVisibilityInput);
       const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
-      if (!hasLegacyWorkspaceActionId && !hasWorkspaceRouteVisibility) {
+      if (!hasWorkspaceActionSurface && !hasWorkspaceRouteVisibility && !hasWorkspaceSurface) {
         return {};
       }
 

package/src/server/common/registerCommonRepositories.js

@@ -1,8 +1,5 @@
-import { createRepository as createUserProfilesRepository } from "./repositories/userProfilesRepository.js";
+import { createRepository as createUsersRepository } from "./repositories/usersRepository.js";
 import { createRepository as createUserSettingsRepository } from "./repositories/userSettingsRepository.js";
-import { createRepository as createWorkspacesRepository } from "./repositories/workspacesRepository.js";
-import { createRepository as createWorkspaceMembershipsRepository } from "./repositories/workspaceMembershipsRepository.js";
-import { createRepository as createWorkspaceInvitesRepository } from "./repositories/workspaceInvitesRepository.js";
 import { createRepository as createConsoleSettingsRepository } from "../consoleSettings/consoleSettingsRepository.js";
 
 function registerCommonRepositories(app) {
@@ -10,31 +7,15 @@ function registerCommonRepositories(app) {
     throw new Error("registerCommonRepositories requires application singleton().");
   }
 
-  app.singleton("userProfilesRepository", (scope) => {
+  app.singleton("usersRepository", (scope) => {
     const knex = scope.make("jskit.database.knex");
-    return createUserProfilesRepository(knex);
+    return createUsersRepository(knex);
   });
 
   app.singleton("userSettingsRepository", (scope) => {
     const knex = scope.make("jskit.database.knex");
     return createUserSettingsRepository(knex);
   });
-
-  app.singleton("workspacesRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspacesRepository(knex);
-  });
-
-  app.singleton("workspaceMembershipsRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspaceMembershipsRepository(knex);
-  });
-
-  app.singleton("workspaceInvitesRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspaceInvitesRepository(knex);
-  });
-
   app.singleton("consoleSettingsRepository", (scope) => {
     const knex = scope.make("jskit.database.knex");
     return createConsoleSettingsRepository(knex);

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

@@ -15,7 +15,6 @@ function mapRow(row) {
 
   const mapped = {
     userId: Number(row.user_id),
-    lastActiveWorkspaceId: row.last_active_workspace_id == null ? null : Number(row.last_active_workspace_id),
     passwordSignInEnabled: row.password_sign_in_enabled == null ? true : Boolean(row.password_sign_in_enabled),
     passwordSetupRequired: row.password_setup_required == null ? false : Boolean(row.password_setup_required),
     createdAt: toIsoString(row.created_at),
@@ -48,7 +47,6 @@ function normalizeBoolean(value, fallback = false) {
 function createInsertPayload(userId) {
   const payload = {
     user_id: Number(userId),
-    last_active_workspace_id: null,
     password_sign_in_enabled: DEFAULT_USER_SETTINGS.passwordSignInEnabled,
     password_setup_required: DEFAULT_USER_SETTINGS.passwordSetupRequired,
     created_at: nowDb(),
@@ -127,10 +125,6 @@ function createRepository(knex) {
     if (Object.hasOwn(source, "passwordSetupRequired")) {
       dbPatch.password_setup_required = normalizeBoolean(source.passwordSetupRequired, ensured.passwordSetupRequired);
     }
-    if (Object.hasOwn(source, "lastActiveWorkspaceId")) {
-      dbPatch.last_active_workspace_id = source.lastActiveWorkspaceId == null ? null : Number(source.lastActiveWorkspaceId);
-    }
-
     await client("user_settings").where({ user_id: Number(userId) }).update(dbPatch);
     return findByUserId(userId, { trx: client });
   }
@@ -160,10 +154,6 @@ function createRepository(knex) {
     return patchUserSettings(userId, { passwordSetupRequired: required }, options);
   }
 
-  async function updateLastActiveWorkspaceId(userId, workspaceId, options = {}) {
-    return patchUserSettings(userId, { lastActiveWorkspaceId: workspaceId }, options);
-  }
-
   return Object.freeze({
     findByUserId,
     ensureForUserId,
@@ -171,8 +161,7 @@ function createRepository(knex) {
     updatePreferences,
     updateNotifications,
     updatePasswordSignInEnabled,
-    updatePasswordSetupRequired,
-    updateLastActiveWorkspaceId
+    updatePasswordSetupRequired
   });
 }
 

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

@@ -104,7 +104,7 @@ async function resolveUniqueUsername(client, baseUsername, { excludeUserId = 0 }
 
 function createRepository(knex) {
   if (typeof knex !== "function") {
-    throw new TypeError("userProfilesRepository requires knex.");
+    throw new TypeError("usersRepository requires knex.");
   }
 
   async function findById(userId, options = {}) {

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

@@ -1,9 +1,9 @@
-import { normalizeIdentity } from "../repositories/userProfilesRepository.js";
+import { normalizeIdentity } from "../repositories/usersRepository.js";
 
-async function resolveUserProfile(userProfilesRepository, user) {
+async function resolveUserProfile(usersRepository, user) {
   const identity = normalizeIdentity(user);
   if (identity) {
-    const profile = await userProfilesRepository.findByIdentity(identity);
+    const profile = await usersRepository.findByIdentity(identity);
     if (profile) {
       return profile;
     }
@@ -11,7 +11,7 @@ async function resolveUserProfile(userProfilesRepository, user) {
 
   const userId = Number(user?.id);
   if (Number.isInteger(userId) && userId > 0) {
-    const profileById = await userProfilesRepository.findById(userId);
+    const profileById = await usersRepository.findById(userId);
     if (profileById) {
       return profileById;
     }

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

@@ -1,5 +1,5 @@
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeIdentity } from "../repositories/userProfilesRepository.js";
+import { normalizeIdentity } from "../repositories/usersRepository.js";
 
 function buildNormalizedIdentityKey(identityLike) {
   const identity = normalizeIdentity(identityLike);
@@ -53,12 +53,12 @@ function requireSynchronizedProfile(profile) {
   throw new Error("Profile synchronization failed.");
 }
 
-function createService({ userProfilesRepository, workspaceProvisioningService = null, userSettingsRepository = null } = {}) {
-  if (!userProfilesRepository || typeof userProfilesRepository.findByIdentity !== "function") {
-    throw new Error("authProfileSyncService requires userProfilesRepository.findByIdentity().");
+function createService({ usersRepository, workspaceProvisioningService = null, userSettingsRepository = null } = {}) {
+  if (!usersRepository || typeof usersRepository.findByIdentity !== "function") {
+    throw new Error("authProfileSyncService requires usersRepository.findByIdentity().");
   }
-  if (typeof userProfilesRepository.upsert !== "function") {
-    throw new Error("authProfileSyncService requires userProfilesRepository.upsert().");
+  if (typeof usersRepository.upsert !== "function") {
+    throw new Error("authProfileSyncService requires usersRepository.upsert().");
   }
   if (!userSettingsRepository || typeof userSettingsRepository.ensureForUserId !== "function") {
     throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
@@ -66,7 +66,7 @@ function createService({ userProfilesRepository, workspaceProvisioningService =
 
   async function findByIdentity(identityLike, options = {}) {
     const normalized = buildNormalizedIdentityKey(identityLike);
-    return userProfilesRepository.findByIdentity(
+    return usersRepository.findByIdentity(
       {
         provider: normalized.authProvider,
         providerUserId: normalized.authProviderUserSid
@@ -77,7 +77,7 @@ function createService({ userProfilesRepository, workspaceProvisioningService =
 
   async function upsertByIdentity(profileLike, options = {}) {
     const normalized = buildNormalizedIdentityProfile(profileLike);
-    return userProfilesRepository.upsert(
+    return usersRepository.upsert(
       {
         authProvider: normalized.authProvider,
         authProviderUserSid: normalized.authProviderUserSid,
@@ -118,8 +118,8 @@ function createService({ userProfilesRepository, workspaceProvisioningService =
     if (options?.trx) {
       return runSync(options.trx);
     }
-    if (typeof userProfilesRepository.withTransaction === "function") {
-      return userProfilesRepository.withTransaction((trx) => runSync(trx));
+    if (typeof usersRepository.withTransaction === "function") {
+      return usersRepository.withTransaction((trx) => runSync(trx));
     }
     return runSync();
   }

package/src/server/registerUsersBootstrap.js

@@ -0,0 +1,22 @@
+import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { createUsersBootstrapContributor } from "./usersBootstrapContributor.js";
+
+function registerUsersBootstrap(app) {
+  if (!app || typeof app.singleton !== "function") {
+    throw new Error("registerUsersBootstrap requires application singleton().");
+  }
+
+  registerBootstrapPayloadContributor(app, "users.core.bootstrap.payloadContributor", (scope) => {
+    return createUsersBootstrapContributor({
+      usersRepository: scope.make("usersRepository"),
+      userSettingsRepository: scope.make("userSettingsRepository"),
+      appConfig: resolveAppConfig(scope),
+      tenancyProfile: scope.make("users.tenancy.profile"),
+      authService: scope.make("authService"),
+      consoleService: scope.has("consoleService") ? scope.make("consoleService") : null
+    });
+  });
+}
+
+export { registerUsersBootstrap };

package/src/server/registerUsersCore.js

@@ -0,0 +1,30 @@
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { resolveTenancyProfile } from "../shared/tenancyProfile.js";
+import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
+import { registerUsersCoreActionSurfaceSources } from "./support/workspaceActionSurfaces.js";
+
+function registerUsersCore(app) {
+  if (!app || typeof app.singleton !== "function") {
+    throw new Error("registerUsersCore requires application singleton().");
+  }
+
+  registerUsersCoreActionSurfaceSources(app);
+
+  app.singleton("users.profile.sync.service", (scope) => {
+    return createAuthProfileSyncService({
+      usersRepository: scope.make("usersRepository"),
+      userSettingsRepository: scope.make("userSettingsRepository"),
+      workspaceProvisioningService:
+        typeof scope.has === "function" && scope.has("users.workspace.service")
+          ? scope.make("users.workspace.service")
+          : null
+    });
+  });
+
+  app.singleton("users.tenancy.profile", (scope) => {
+    const appConfig = resolveAppConfig(scope);
+    return resolveTenancyProfile(appConfig);
+  });
+}
+
+export { registerUsersCore };

package/src/server/registerWorkspaceBootstrap.js

@@ -8,7 +8,7 @@ function registerWorkspaceBootstrap(app) {
     throw new Error("registerWorkspaceBootstrap requires application singleton().");
   }
 
-  registerBootstrapPayloadContributor(app, "users.core.workspace.bootstrap.payloadContributor", (scope) => {
+  registerBootstrapPayloadContributor(app, "workspaces.core.bootstrap.payloadContributor", (scope) => {
     const workspaceInvitationsEnabled = scope.make("users.workspace.invitations.enabled");
 
     return createWorkspaceBootstrapContributor({
@@ -17,12 +17,9 @@ function registerWorkspaceBootstrap(app) {
         ? scope.make("users.workspace.pending-invitations.service")
         : null,
       workspaceInvitationsEnabled,
-      userProfilesRepository: scope.make("userProfilesRepository"),
-      userSettingsRepository: scope.make("userSettingsRepository"),
+      usersRepository: scope.make("usersRepository"),
       appConfig: resolveAppConfig(scope),
-      tenancyProfile: scope.make("users.tenancy.profile"),
-      authService: scope.make("authService"),
-      consoleService: scope.has("consoleService") ? scope.make("consoleService") : null
+      tenancyProfile: scope.make("users.tenancy.profile")
     });
   });
 }

package/src/server/registerWorkspaceCore.js

@@ -3,13 +3,13 @@ import {
 } from "@jskit-ai/kernel/server/actions";
 import { registerRouteVisibilityResolver } from "@jskit-ai/kernel/server/http";
 import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { TENANCY_MODE_WORKSPACES, resolveTenancyProfile } from "../shared/tenancyProfile.js";
 import { createService as createWorkspaceService } from "./common/services/workspaceContextService.js";
-import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
 import { createWorkspaceActionContextContributor } from "./common/contributors/workspaceActionContextContributor.js";
 import { createWorkspaceRouteVisibilityResolver } from "./common/contributors/workspaceRouteVisibilityResolver.js";
 import { createWorkspaceAuthPolicyContextResolver } from "./common/contributors/workspaceAuthPolicyContextResolver.js";
+import { TENANCY_MODE_WORKSPACES } from "../shared/tenancyProfile.js";
 import { resolveWorkspaceInvitationsPolicy } from "./support/workspaceInvitationsPolicy.js";
+import { resolveWorkspaceSurfaceIdsFromAppConfig } from "./support/workspaceActionSurfaces.js";
 
 
 function registerWorkspaceCore(app) {
@@ -26,20 +26,6 @@ function registerWorkspaceCore(app) {
       workspaceSettingsRepository: scope.make("workspaceSettingsRepository")
     });
   });
-
-  app.singleton("users.profile.sync.service", (scope) => {
-    return createAuthProfileSyncService({
-      userProfilesRepository: scope.make("userProfilesRepository"),
-      userSettingsRepository: scope.make("userSettingsRepository"),
-      workspaceProvisioningService: scope.make("users.workspace.service")
-    });
-  });
-
-  app.singleton("users.tenancy.profile", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return resolveTenancyProfile(appConfig);
-  });
-
   app.singleton("users.workspace.enabled", (scope) => {
     return scope.make("users.tenancy.profile").workspace.enabled === true;
   });
@@ -62,8 +48,10 @@ function registerWorkspaceCore(app) {
   });
 
   registerActionContextContributor(app, "users.core.workspace.actionContextContributor", (scope) => {
+    const appConfig = resolveAppConfig(scope);
     return createWorkspaceActionContextContributor({
-      workspaceService: scope.make("users.workspace.service")
+      workspaceService: scope.make("users.workspace.service"),
+      workspaceSurfaceIds: resolveWorkspaceSurfaceIdsFromAppConfig(appConfig)
     });
   });
 

package/src/server/registerWorkspaceRepositories.js

@@ -0,0 +1,26 @@
+import { createRepository as createWorkspacesRepository } from "./common/repositories/workspacesRepository.js";
+import { createRepository as createWorkspaceMembershipsRepository } from "./common/repositories/workspaceMembershipsRepository.js";
+import { createRepository as createWorkspaceInvitesRepository } from "./common/repositories/workspaceInvitesRepository.js";
+
+function registerWorkspaceRepositories(app) {
+  if (!app || typeof app.singleton !== "function") {
+    throw new Error("registerWorkspaceRepositories requires application singleton().");
+  }
+
+  app.singleton("workspacesRepository", (scope) => {
+    const knex = scope.make("jskit.database.knex");
+    return createWorkspacesRepository(knex);
+  });
+
+  app.singleton("workspaceMembershipsRepository", (scope) => {
+    const knex = scope.make("jskit.database.knex");
+    return createWorkspaceMembershipsRepository(knex);
+  });
+
+  app.singleton("workspaceInvitesRepository", (scope) => {
+    const knex = scope.make("jskit.database.knex");
+    return createWorkspaceInvitesRepository(knex);
+  });
+}
+
+export { registerWorkspaceRepositories };