@jskit-ai/workspaces-core 0.1.31 → 0.1.33

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

@@ -1,62 +1,72 @@
-import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
+  createWithTransaction,
   normalizeRecordId,
+  isDuplicateEntryError,
   normalizeText,
-  normalizeLowerText,
-  isDuplicateEntryError
+  toIsoString
 } from "./repositoryUtils.js";
-import { workspacesResource } from "../resources/workspacesResource.js";
+import {
+  createJsonApiInputRecord,
+  createJsonApiRelationship,
+  createJsonRestContext,
+  simplifyJsonApiDocument
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 
-const REPOSITORY_CONFIG = Object.freeze({
-  context: "internal.repository.workspaces"
-});
+const RESOURCE_TYPE = "workspaces";
 
-function normalizeWorkspaceRecord(payload) {
-  if (!payload) {
+function normalizeWorkspaceRecord(payload = null) {
+  if (!payload || typeof payload !== "object") {
     return null;
   }
-  return workspacesResource.operations.view.outputValidator.normalize(payload);
-}
 
-function normalizeCreatePayload(payload = {}) {
-  return workspacesResource.operations.create.bodyValidator.normalize(payload);
+  return {
+    id: normalizeRecordId(payload.id, { fallback: null }),
+    slug: normalizeText(payload.slug),
+    name: normalizeText(payload.name),
+    ownerUserId: normalizeRecordId(payload.ownerUserId || payload?.owner?.id, { fallback: null }),
+    isPersonal: payload.isPersonal === true,
+    avatarUrl: normalizeText(payload.avatarUrl),
+    createdAt: payload.createdAt ? toIsoString(payload.createdAt) : null,
+    updatedAt: payload.updatedAt ? toIsoString(payload.updatedAt) : null,
+    deletedAt: payload.deletedAt ? toIsoString(payload.deletedAt) : null
+  };
 }
 
-function normalizeMembershipWorkspaceRow(row) {
-  if (!row) {
-    return null;
+function createWorkspaceRelationships(source = {}) {
+  const relationships = {};
+  const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
+
+  if (ownerUserId) {
+    relationships.owner = createJsonApiRelationship("userProfiles", ownerUserId);
   }
 
-  return {
-    ...normalizeWorkspaceRecord(row),
-    roleSid: normalizeLowerText(row.role_sid || "member"),
-    membershipStatus: normalizeLowerText(row.membership_status || "active") || "active"
-  };
+  return relationships;
 }
 
-function createRepository(knex) {
+function createRepository({ api, knex } = {}) {
+  if (!api?.resources?.workspaces || !api?.resources?.workspaceMemberships) {
+    throw new TypeError("workspacesRepository requires json-rest-api workspaces and workspaceMemberships resources.");
+  }
   if (typeof knex !== "function") {
     throw new TypeError("workspacesRepository requires knex.");
   }
-  const resourceRuntime = createCrudResourceRuntime(workspacesResource, knex, REPOSITORY_CONFIG);
-  const withTransaction = resourceRuntime.withTransaction;
-
-  function workspaceSelectColumns({ includeMembership = false } = {}) {
-    const columns = [
-      "w.id",
-      "w.slug",
-      "w.name",
-      "w.owner_user_id",
-      "w.is_personal",
-      "w.avatar_url",
-      "w.created_at",
-      "w.updated_at",
-      "w.deleted_at"
-    ];
-    if (includeMembership) {
-      columns.push("wm.role_sid", "wm.status as membership_status");
-    }
-    return columns;
+
+  const withTransaction = createWithTransaction(knex);
+
+  async function queryFirst(filters = {}, options = {}) {
+    const result = await api.resources.workspaces.query(
+      {
+        queryParams: {
+          filters
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    const rows = simplifyJsonApiDocument(result);
+    return normalizeWorkspaceRecord(Array.isArray(rows) ? rows[0] || null : null);
   }
 
   async function findById(workspaceId, options = {}) {
@@ -65,24 +75,16 @@ function createRepository(knex) {
       return null;
     }
 
-    return resourceRuntime.findById(normalizedWorkspaceId, {
-      ...options,
-      include: "none"
-    });
+    return queryFirst({ id: normalizedWorkspaceId }, options);
   }
 
   async function findBySlug(slug, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedSlug = normalizeLowerText(slug);
+    const normalizedSlug = typeof slug === "string" ? slug.trim().toLowerCase() : "";
     if (!normalizedSlug) {
       return null;
     }
 
-    const row = await client("workspaces as w")
-      .where({ "w.slug": normalizedSlug })
-      .select(workspaceSelectColumns())
-      .first();
-    return normalizeWorkspaceRecord(row);
+    return queryFirst({ slug: normalizedSlug }, options);
   }
 
   async function findPersonalByOwnerUserId(userId, options = {}) {
@@ -91,41 +93,78 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    const row = await client("workspaces as w")
-      .where({ "w.owner_user_id": normalizedUserId, "w.is_personal": 1 })
-      .orderBy("w.id", "asc")
-      .select(workspaceSelectColumns())
-      .first();
-    return normalizeWorkspaceRecord(row);
+    const result = await api.resources.workspaces.query(
+      {
+        queryParams: {
+          filters: {
+            owner: normalizedUserId,
+            isPersonal: true
+          }
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    const rows = Array.isArray(simplifyJsonApiDocument(result))
+      ? simplifyJsonApiDocument(result).map((row) => normalizeWorkspaceRecord(row)).filter(Boolean)
+      : [];
+    rows.sort((left, right) => {
+      const leftId = Number(left?.id);
+      const rightId = Number(right?.id);
+      if (Number.isFinite(leftId) && Number.isFinite(rightId)) {
+        return leftId - rightId;
+      }
+      return String(left?.id || "").localeCompare(String(right?.id || ""));
+    });
+    return rows[0] || null;
   }
 
   async function insert(payload = {}, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedPayload = normalizeCreatePayload(payload);
-    const ownerUserId = normalizeRecordId(normalizedPayload.ownerUserId, { fallback: null });
+    const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
     if (!ownerUserId) {
       throw new TypeError("workspacesRepository.insert requires ownerUserId.");
     }
 
     const createPayload = {
-      ...normalizedPayload,
-      ownerUserId,
-      isPersonal: normalizedPayload.isPersonal === true,
-      avatarUrl: normalizeText(normalizedPayload.avatarUrl)
+      ...(Object.hasOwn(source, "slug") ? { slug: source.slug } : {}),
+      ...(Object.hasOwn(source, "name") ? { name: source.name } : {}),
+      ...(Object.hasOwn(source, "isPersonal") ? { isPersonal: source.isPersonal } : {}),
+      ...(Object.hasOwn(source, "avatarUrl") ? { avatarUrl: source.avatarUrl } : {})
     };
 
     try {
-      return await resourceRuntime.create(createPayload, {
-        ...options,
-        trx: client,
-        include: "none"
-      });
+      const created = await api.resources.workspaces.post(
+        {
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            {
+              ...createPayload,
+              createdAt: new Date(),
+              updatedAt: new Date()
+            },
+            {
+              relationships: createWorkspaceRelationships({ ownerUserId })
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
+
+      return normalizeWorkspaceRecord(simplifyJsonApiDocument(created));
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
       }
-      const bySlug = await findBySlug(createPayload.slug, { trx: client });
+      if (!Object.hasOwn(createPayload, "slug")) {
+        throw error;
+      }
+
+      const bySlug = await findBySlug(createPayload.slug, options);
       if (bySlug) {
         return bySlug;
       }
@@ -139,10 +178,30 @@ function createRepository(knex) {
       return null;
     }
 
-    return resourceRuntime.updateById(normalizedWorkspaceId, patch, {
-      ...options,
-      include: "none"
-    });
+    const sourcePatch = patch && typeof patch === "object" && !Array.isArray(patch) ? patch : {};
+    const workspacePatch = {
+      ...sourcePatch,
+      updatedAt: new Date()
+    };
+    const relationships = createWorkspaceRelationships(sourcePatch);
+
+    const updated = await api.resources.workspaces.patch(
+      {
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          workspacePatch,
+          {
+            id: normalizedWorkspaceId,
+            relationships
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    return normalizeWorkspaceRecord(simplifyJsonApiDocument(updated));
   }
 
   async function listForUserId(userId, options = {}) {
@@ -151,16 +210,50 @@ function createRepository(knex) {
       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": normalizedUserId })
-      .whereNull("w.deleted_at")
-      .orderBy("w.is_personal", "desc")
-      .orderBy("w.id", "asc")
-      .select(workspaceSelectColumns({ includeMembership: true }));
+    const result = await api.resources.workspaceMemberships.query(
+      {
+        queryParams: {
+          filters: {
+            user: normalizedUserId,
+            status: "active"
+          },
+          include: ["workspace"]
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    const rows = Array.isArray(simplifyJsonApiDocument(result)) ? simplifyJsonApiDocument(result) : [];
+    const workspaces = rows
+      .map((row) => {
+        const workspace = normalizeWorkspaceRecord(row?.workspace);
+        if (!workspace || workspace.deletedAt != null) {
+          return null;
+        }
+
+        return {
+          ...workspace,
+          roleSid: row?.roleSid,
+          membershipStatus: row?.status
+        };
+      })
+      .filter(Boolean);
+
+    workspaces.sort((left, right) => {
+      if (left.isPersonal !== right.isPersonal) {
+        return left.isPersonal ? -1 : 1;
+      }
+      const leftId = Number(left?.id);
+      const rightId = Number(right?.id);
+      if (Number.isFinite(leftId) && Number.isFinite(rightId)) {
+        return leftId - rightId;
+      }
+      return String(left?.id || "").localeCompare(String(right?.id || ""));
+    });
 
-    return rows.map(normalizeMembershipWorkspaceRow).filter(Boolean);
+    return workspaces;
   }
 
   return Object.freeze({
@@ -174,4 +267,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, normalizeWorkspaceRecord, normalizeMembershipWorkspaceRow };
+export { createRepository };

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

@@ -12,7 +12,6 @@ import {
 } 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) {
   const normalized = normalizeLowerText(value)
@@ -105,38 +104,38 @@ function createService({
   }
 
   async function ensurePersonalWorkspaceForUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+    const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
+    if (!normalizedUserId) {
       throw new AppError(400, "Invalid authenticated user payload.");
     }
 
-    const existing = await workspacesRepository.findPersonalByOwnerUserId(normalizedUser.id, options);
+    const existing = await workspacesRepository.findPersonalByOwnerUserId(normalizedUserId, options);
     if (existing) {
-      await workspaceMembershipsRepository.ensureOwnerMembership(existing.id, normalizedUser.id, options);
+      await workspaceMembershipsRepository.ensureOwnerMembership(existing.id, normalizedUserId, options);
       await ensureWorkspaceSettingsForWorkspace(existing, options);
       return existing;
     }
 
-    const slug = await ensureUniqueWorkspaceSlug(buildWorkspaceBaseSlug(normalizedUser), options);
+    const slug = await ensureUniqueWorkspaceSlug(buildWorkspaceBaseSlug(user), options);
     const inserted = await workspacesRepository.insert(
       {
         slug,
-        name: buildWorkspaceName(normalizedUser),
-        ownerUserId: normalizedUser.id,
+        name: buildWorkspaceName(user),
+        ownerUserId: normalizedUserId,
         isPersonal: true,
         avatarUrl: ""
       },
       options
     );
 
-    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUser.id, options);
+    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUserId, options);
     await ensureWorkspaceSettingsForWorkspace(inserted, options);
     return inserted;
   }
 
   async function listWorkspacesForUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+    const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
+    if (!normalizedUserId) {
       return [];
     }
 
@@ -144,7 +143,7 @@ function createService({
       return [];
     }
 
-    const list = await workspacesRepository.listForUserId(normalizedUser.id, options);
+    const list = await workspacesRepository.listForUserId(normalizedUserId, options);
     const accessible = list
       .map((entry) => mapWorkspaceSummary(entry, { roleSid: entry.roleSid, status: entry.membershipStatus }))
       .filter((entry) => entry.isAccessible);
@@ -156,9 +155,9 @@ function createService({
     return listWorkspacesForUser(user, options);
   }
 
-  async function provisionWorkspaceForNewUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+  async function ensureProvisionedWorkspaceForAuthenticatedUser(user, options = {}) {
+    const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
+    if (!normalizedUserId) {
       throw new AppError(400, "Invalid authenticated user payload.");
     }
 
@@ -166,12 +165,15 @@ function createService({
       return null;
     }
 
-    return ensurePersonalWorkspaceForUser(normalizedUser, options);
+    return ensurePersonalWorkspaceForUser({
+      ...user,
+      id: normalizedUserId
+    }, options);
   }
 
   async function createWorkspaceForAuthenticatedUser(user, payload = {}, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+    const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
+    if (!normalizedUserId) {
       throw new AppError(401, "Authentication required.");
     }
 
@@ -190,14 +192,14 @@ function createService({
       {
         slug,
         name: createInput.name,
-        ownerUserId: normalizedUser.id,
+        ownerUserId: normalizedUserId,
         isPersonal: false,
         avatarUrl: ""
       },
       options
     );
 
-    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUser.id, options);
+    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUserId, options);
     await ensureWorkspaceSettingsForWorkspace(inserted, options);
     return inserted;
   }
@@ -213,8 +215,8 @@ function createService({
   }
 
   async function resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
+    const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
+    if (!normalizedUserId) {
       throw new AppError(401, "Authentication required.");
     }
 
@@ -235,16 +237,16 @@ function createService({
 
     let membership = await workspaceMembershipsRepository.findByWorkspaceIdAndUserId(
       workspace.id,
-      normalizedUser.id,
+      normalizedUserId,
       options
     );
     const actorOwnsWorkspace =
       normalizeRecordId(workspace.ownerUserId, { fallback: null }) ===
-      normalizeRecordId(normalizedUser.id, { fallback: null });
+      normalizedUserId;
     const membershipIsActive = normalizeLowerText(membership?.status) === "active";
 
     if (!membershipIsActive && actorOwnsWorkspace) {
-      membership = await workspaceMembershipsRepository.ensureOwnerMembership(workspace.id, normalizedUser.id, options);
+      membership = await workspaceMembershipsRepository.ensureOwnerMembership(workspace.id, normalizedUserId, options);
     }
 
     if (!membership || normalizeLowerText(membership.status) !== "active") {
@@ -268,7 +270,7 @@ function createService({
     buildWorkspaceBaseSlug,
     hashInviteToken,
     ensurePersonalWorkspaceForUser,
-    provisionWorkspaceForNewUser,
+    ensureProvisionedWorkspaceForAuthenticatedUser,
     createWorkspaceForAuthenticatedUser,
     getWorkspaceForAuthenticatedUser,
     updateWorkspaceForAuthenticatedUser,

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

@@ -1,62 +1,45 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function normalizeRouteParams(input = {}) {
-  const source = normalizeObjectInput(input);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "workspaceSlug")) {
-    normalized.workspaceSlug = normalizeText(source.workspaceSlug).toLowerCase();
-  }
-
-  if (Object.hasOwn(source, "memberUserId")) {
-    normalized.memberUserId = normalizeText(source.memberUserId);
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+
+const routeParamsSchema = createSchema({
+  workspaceSlug: {
+    type: "string",
+    required: false,
+    lowercase: true,
+    minLength: 1
+  },
+  memberUserId: {
+    type: "id",
+    required: false
+  },
+  inviteId: {
+    type: "id",
+    required: false
+  },
+  provider: {
+    type: "string",
+    required: false,
+    minLength: 1
   }
+});
 
-  if (Object.hasOwn(source, "inviteId")) {
-    normalized.inviteId = normalizeText(source.inviteId);
-  }
-
-  if (Object.hasOwn(source, "provider")) {
-    normalized.provider = normalizeText(source.provider);
-  }
-
-  return normalized;
-}
-
-function normalizeWorkspaceSlugParams(input = {}) {
-  const source = normalizeObjectInput(input);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "workspaceSlug")) {
-    normalized.workspaceSlug = normalizeText(source.workspaceSlug).toLowerCase();
+const workspaceSlugParamsSchema = createSchema({
+  workspaceSlug: {
+    type: "string",
+    required: false,
+    lowercase: true,
+    minLength: 1
   }
+});
 
-  return normalized;
-}
-
-const routeParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspaceSlug: Type.Optional(Type.String({ minLength: 1 })),
-      memberUserId: Type.Optional(Type.String({ minLength: 1 })),
-      inviteId: Type.Optional(Type.String({ minLength: 1 })),
-      provider: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeRouteParams
+const routeParamsValidator = deepFreeze({
+  schema: routeParamsSchema,
+  mode: "patch"
 });
 
-const workspaceSlugParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspaceSlug: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceSlugParams
+const workspaceSlugParamsValidator = deepFreeze({
+  schema: workspaceSlugParamsSchema,
+  mode: "patch"
 });
 
 export { routeParamsValidator, workspaceSlugParamsValidator };

package/src/server/registerWorkspaceCore.js

@@ -2,6 +2,7 @@ import {
   registerActionContextContributor
 } from "@jskit-ai/kernel/server/actions";
 import { registerRouteVisibilityResolver } from "@jskit-ai/kernel/server/http";
+import { registerAuthPolicyContextResolver } from "@jskit-ai/auth-core/server/authPolicyContextResolverRegistry";
 import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
 import { registerProfileSyncLifecycleContributor } from "@jskit-ai/users-core/server/profileSyncLifecycleContributorRegistry";
 import { createService as createWorkspaceService } from "./common/services/workspaceContextService.js";
@@ -66,12 +67,12 @@ function registerWorkspaceCore(app) {
     return Object.freeze({
       contributorId: "workspaces.core.profileSync",
       order: 100,
-      async afterIdentityProfileSynced({ profile, created, options } = {}) {
-        if (!created || !profile || typeof workspaceService?.provisionWorkspaceForNewUser !== "function") {
+      async afterIdentityProfileSynced({ profile, options } = {}) {
+        if (!profile || typeof workspaceService?.ensureProvisionedWorkspaceForAuthenticatedUser !== "function") {
           return;
         }
 
-        await workspaceService.provisionWorkspaceForNewUser(profile, options);
+        await workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser(profile, options);
       }
     });
   });
@@ -84,13 +85,11 @@ function registerWorkspaceCore(app) {
     });
   });
 
-  if (typeof app.has !== "function" || !app.has("auth.policy.contextResolver")) {
-    app.singleton("auth.policy.contextResolver", (scope) =>
-      createWorkspaceAuthPolicyContextResolver({
-        workspaceService: scope.make("workspaces.service")
-      })
-    );
-  }
+  registerAuthPolicyContextResolver(app, "workspaces.core.authPolicyContextResolver", (scope) =>
+    createWorkspaceAuthPolicyContextResolver({
+      workspaceService: scope.make("workspaces.service")
+    })
+  );
 
   registerRouteVisibilityResolver(app, "users.core.workspace.routeVisibilityResolver", (scope) =>
     createWorkspaceRouteVisibilityResolver({

package/src/server/registerWorkspaceRepositories.js

@@ -1,3 +1,4 @@
+import { INTERNAL_JSON_REST_API } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 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";
@@ -8,18 +9,21 @@ function registerWorkspaceRepositories(app) {
   }
 
   app.singleton("internal.repository.workspaces", (scope) => {
+    const api = scope.make(INTERNAL_JSON_REST_API);
     const knex = scope.make("jskit.database.knex");
-    return createWorkspacesRepository(knex);
+    return createWorkspacesRepository({ api, knex });
   });
 
   app.singleton("internal.repository.workspace-memberships", (scope) => {
+    const api = scope.make(INTERNAL_JSON_REST_API);
     const knex = scope.make("jskit.database.knex");
-    return createWorkspaceMembershipsRepository(knex);
+    return createWorkspaceMembershipsRepository({ api, knex });
   });
 
   app.singleton("internal.repository.workspace-invites", (scope) => {
+    const api = scope.make(INTERNAL_JSON_REST_API);
     const knex = scope.make("jskit.database.knex");
-    return createWorkspaceInvitesRepository(knex);
+    return createWorkspaceInvitesRepository({ api, knex });
   });
 }
 

package/src/server/support/workspaceServerScopeSupport.js

@@ -5,7 +5,7 @@ import { resolveWorkspace } from "./resolveWorkspace.js";
 function createWorkspaceServerScopeSupport() {
   return Object.freeze({
     available: true,
-    paramsValidator: workspaceSlugParamsValidator,
+    params: workspaceSlugParamsValidator,
     buildInputFromRouteParams(params = {}) {
       return buildWorkspaceInputFromRouteParams(params);
     },