@jskit-ai/workspaces-core 0.1.21 → 0.1.23

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

@@ -0,0 +1,207 @@
+import { Type } from "typebox";
+import {
+  createCursorListValidator,
+  normalizeObjectInput,
+  recordIdInputSchema,
+  recordIdSchema
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeIfPresent,
+  normalizeLowerText,
+  normalizeRecordId,
+  normalizeText,
+  normalizeOrNull
+} from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeDbRecordId, toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
+
+function normalizeInviteRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: normalizeIfPresent(source.id, (value) => normalizeDbRecordId(value, { fallback: null })),
+    workspaceId: normalizeIfPresent(
+      source.workspaceId ?? source.workspace_id,
+      (value) => normalizeDbRecordId(value, { fallback: null })
+    ),
+    email: normalizeLowerText(source.email),
+    roleSid: normalizeLowerText(source.roleSid ?? source.role_sid ?? "member") || "member",
+    status: normalizeLowerText(source.status ?? "pending") || "pending",
+    tokenHash: normalizeText(source.tokenHash ?? source.token_hash),
+    invitedByUserId: normalizeOrNull(
+      source.invitedByUserId ?? source.invited_by_user_id,
+      (value) => normalizeDbRecordId(value, { fallback: null })
+    ),
+    expiresAt: normalizeOrNull(source.expiresAt ?? source.expires_at, toIsoString),
+    acceptedAt: normalizeOrNull(source.acceptedAt ?? source.accepted_at, toIsoString),
+    revokedAt: normalizeOrNull(source.revokedAt ?? source.revoked_at, toIsoString),
+    createdAt: normalizeIfPresent(source.createdAt ?? source.created_at, toIsoString),
+    updatedAt: normalizeIfPresent(source.updatedAt ?? source.updated_at, toIsoString)
+  };
+}
+
+function normalizeInviteInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "workspaceId")) {
+    normalized.workspaceId = normalizeRecordId(source.workspaceId, { fallback: "" });
+  }
+  if (Object.hasOwn(source, "email")) {
+    normalized.email = normalizeLowerText(source.email);
+  }
+  if (Object.hasOwn(source, "roleSid")) {
+    normalized.roleSid = normalizeLowerText(source.roleSid);
+  }
+  if (Object.hasOwn(source, "status")) {
+    normalized.status = normalizeLowerText(source.status);
+  }
+  if (Object.hasOwn(source, "tokenHash")) {
+    normalized.tokenHash = normalizeText(source.tokenHash);
+  }
+  if (Object.hasOwn(source, "invitedByUserId")) {
+    normalized.invitedByUserId =
+      source.invitedByUserId == null
+        ? null
+        : normalizeRecordId(source.invitedByUserId, { fallback: null });
+  }
+  if (Object.hasOwn(source, "expiresAt")) {
+    normalized.expiresAt = toNullableDateTime(source.expiresAt);
+  }
+  if (Object.hasOwn(source, "acceptedAt")) {
+    normalized.acceptedAt = toNullableDateTime(source.acceptedAt);
+  }
+  if (Object.hasOwn(source, "revokedAt")) {
+    normalized.revokedAt = toNullableDateTime(source.revokedAt);
+  }
+
+  return normalized;
+}
+
+const recordOutputSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    workspaceId: recordIdSchema,
+    email: Type.String({ minLength: 1 }),
+    roleSid: Type.String({ minLength: 1 }),
+    status: Type.String({ minLength: 1 }),
+    tokenHash: Type.String({ minLength: 1 }),
+    invitedByUserId: Type.Union([recordIdSchema, Type.Null()]),
+    expiresAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]),
+    acceptedAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]),
+    revokedAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]),
+    createdAt: Type.String({ format: "date-time", minLength: 1 }),
+    updatedAt: Type.String({ format: "date-time", minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+
+const createBodySchema = Type.Object(
+  {
+    workspaceId: recordIdInputSchema,
+    email: Type.String({ minLength: 1, maxLength: 255 }),
+    tokenHash: Type.String({ minLength: 1, maxLength: 255 }),
+    roleSid: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    status: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    invitedByUserId: Type.Optional(Type.Union([recordIdInputSchema, Type.Null()])),
+    expiresAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]))
+  },
+  {
+    additionalProperties: false,
+    required: []
+  }
+);
+
+const patchBodySchema = Type.Object(
+  {
+    roleSid: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    status: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    invitedByUserId: Type.Optional(Type.Union([recordIdInputSchema, Type.Null()])),
+    expiresAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()])),
+    acceptedAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()])),
+    revokedAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]))
+  },
+  {
+    additionalProperties: false
+  }
+);
+
+const recordOutputValidator = Object.freeze({
+  schema: recordOutputSchema,
+  normalize: normalizeInviteRecord
+});
+
+const createBodyValidator = Object.freeze({
+  schema: createBodySchema,
+  normalize: normalizeInviteInput
+});
+
+const patchBodyValidator = Object.freeze({
+  schema: patchBodySchema,
+  normalize: normalizeInviteInput
+});
+
+const workspaceInvitesResource = Object.freeze({
+  namespace: "workspaceInvites",
+  tableName: "workspace_invites",
+  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: "workspaceId",
+      repository: { column: "workspace_id" }
+    }),
+    Object.freeze({
+      key: "roleSid",
+      repository: { column: "role_sid" }
+    }),
+    Object.freeze({
+      key: "tokenHash",
+      repository: { column: "token_hash" }
+    }),
+    Object.freeze({
+      key: "invitedByUserId",
+      repository: { column: "invited_by_user_id" }
+    }),
+    Object.freeze({
+      key: "expiresAt",
+      repository: { column: "expires_at" }
+    }),
+    Object.freeze({
+      key: "acceptedAt",
+      repository: { column: "accepted_at" }
+    }),
+    Object.freeze({
+      key: "revokedAt",
+      repository: { column: "revoked_at" }
+    }),
+    Object.freeze({
+      key: "createdAt",
+      repository: { column: "created_at" }
+    }),
+    Object.freeze({
+      key: "updatedAt",
+      repository: { column: "updated_at" }
+    })
+  ])
+});
+
+export { workspaceInvitesResource };

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

@@ -0,0 +1,154 @@
+import { Type } from "typebox";
+import {
+  createCursorListValidator,
+  normalizeObjectInput,
+  recordIdInputSchema,
+  recordIdSchema
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeIfPresent,
+  normalizeLowerText,
+  normalizeRecordId
+} from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeDbRecordId, toIsoString } from "@jskit-ai/database-runtime/shared";
+
+function normalizeMembershipRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: normalizeIfPresent(source.id, (value) => normalizeDbRecordId(value, { fallback: null })),
+    workspaceId: normalizeIfPresent(
+      source.workspaceId ?? source.workspace_id,
+      (value) => normalizeDbRecordId(value, { fallback: null })
+    ),
+    userId: normalizeIfPresent(
+      source.userId ?? source.user_id,
+      (value) => normalizeDbRecordId(value, { fallback: null })
+    ),
+    roleSid: normalizeLowerText(source.roleSid ?? source.role_sid ?? "member") || "member",
+    status: normalizeLowerText(source.status ?? "active") || "active",
+    createdAt: normalizeIfPresent(source.createdAt ?? source.created_at, toIsoString),
+    updatedAt: normalizeIfPresent(source.updatedAt ?? source.updated_at, toIsoString)
+  };
+}
+
+function normalizeMembershipInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "workspaceId")) {
+    normalized.workspaceId = normalizeRecordId(source.workspaceId, { fallback: "" });
+  }
+  if (Object.hasOwn(source, "userId")) {
+    normalized.userId = normalizeRecordId(source.userId, { fallback: "" });
+  }
+  if (Object.hasOwn(source, "roleSid")) {
+    normalized.roleSid = normalizeLowerText(source.roleSid);
+  }
+  if (Object.hasOwn(source, "status")) {
+    normalized.status = normalizeLowerText(source.status);
+  }
+
+  return normalized;
+}
+
+const recordOutputSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    workspaceId: recordIdSchema,
+    userId: recordIdSchema,
+    roleSid: Type.String({ minLength: 1 }),
+    status: Type.String({ minLength: 1 }),
+    createdAt: Type.String({ format: "date-time", minLength: 1 }),
+    updatedAt: Type.String({ format: "date-time", minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+
+const createBodySchema = Type.Object(
+  {
+    workspaceId: recordIdInputSchema,
+    userId: recordIdInputSchema,
+    roleSid: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    status: Type.Optional(Type.String({ minLength: 1, maxLength: 32 }))
+  },
+  {
+    additionalProperties: false,
+    required: []
+  }
+);
+
+const patchBodySchema = Type.Object(
+  {
+    roleSid: Type.Optional(Type.String({ minLength: 1, maxLength: 64 })),
+    status: Type.Optional(Type.String({ minLength: 1, maxLength: 32 }))
+  },
+  {
+    additionalProperties: false
+  }
+);
+
+const recordOutputValidator = Object.freeze({
+  schema: recordOutputSchema,
+  normalize: normalizeMembershipRecord
+});
+
+const createBodyValidator = Object.freeze({
+  schema: createBodySchema,
+  normalize: normalizeMembershipInput
+});
+
+const patchBodyValidator = Object.freeze({
+  schema: patchBodySchema,
+  normalize: normalizeMembershipInput
+});
+
+const workspaceMembershipsResource = Object.freeze({
+  namespace: "workspaceMemberships",
+  tableName: "workspace_memberships",
+  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: "workspaceId",
+      repository: { column: "workspace_id" }
+    }),
+    Object.freeze({
+      key: "userId",
+      repository: { column: "user_id" }
+    }),
+    Object.freeze({
+      key: "roleSid",
+      repository: { column: "role_sid" }
+    }),
+    Object.freeze({
+      key: "createdAt",
+      repository: { column: "created_at" }
+    }),
+    Object.freeze({
+      key: "updatedAt",
+      repository: { column: "updated_at" }
+    })
+  ])
+});
+
+export { workspaceMembershipsResource };

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

@@ -0,0 +1,170 @@
+import { Type } from "typebox";
+import {
+  createCursorListValidator,
+  normalizeObjectInput,
+  recordIdInputSchema,
+  recordIdSchema
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeBoolean,
+  normalizeIfPresent,
+  normalizeLowerText,
+  normalizeRecordId,
+  normalizeText,
+  normalizeOrNull
+} from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeDbRecordId, toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
+
+function normalizeWorkspaceRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: normalizeIfPresent(source.id, (value) => normalizeDbRecordId(value, { fallback: null })),
+    slug: normalizeLowerText(source.slug),
+    name: normalizeText(source.name),
+    ownerUserId: normalizeIfPresent(
+      source.ownerUserId ?? source.owner_user_id,
+      (value) => normalizeDbRecordId(value, { fallback: null })
+    ),
+    isPersonal: normalizeBoolean(source.isPersonal ?? source.is_personal),
+    avatarUrl: normalizeText(source.avatarUrl ?? source.avatar_url),
+    createdAt: normalizeIfPresent(source.createdAt ?? source.created_at, toIsoString),
+    updatedAt: normalizeIfPresent(source.updatedAt ?? source.updated_at, toIsoString),
+    deletedAt: normalizeOrNull(source.deletedAt ?? source.deleted_at, toIsoString)
+  };
+}
+
+function normalizeWorkspaceInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "slug")) {
+    normalized.slug = normalizeLowerText(source.slug);
+  }
+  if (Object.hasOwn(source, "name")) {
+    normalized.name = normalizeText(source.name);
+  }
+  if (Object.hasOwn(source, "ownerUserId")) {
+    normalized.ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: "" });
+  }
+  if (Object.hasOwn(source, "isPersonal")) {
+    normalized.isPersonal = normalizeBoolean(source.isPersonal);
+  }
+  if (Object.hasOwn(source, "avatarUrl")) {
+    normalized.avatarUrl = normalizeText(source.avatarUrl);
+  }
+  if (Object.hasOwn(source, "deletedAt")) {
+    normalized.deletedAt = toNullableDateTime(source.deletedAt);
+  }
+
+  return normalized;
+}
+
+const recordOutputSchema = Type.Object(
+  {
+    id: recordIdSchema,
+    slug: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1, maxLength: 160 }),
+    ownerUserId: recordIdSchema,
+    isPersonal: Type.Boolean(),
+    avatarUrl: Type.String(),
+    createdAt: Type.String({ format: "date-time", minLength: 1 }),
+    updatedAt: Type.String({ format: "date-time", minLength: 1 }),
+    deletedAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()])
+  },
+  { additionalProperties: false }
+);
+
+const createBodySchema = Type.Object(
+  {
+    slug: Type.String({ minLength: 1, maxLength: 120 }),
+    name: Type.String({ minLength: 1, maxLength: 160 }),
+    ownerUserId: recordIdInputSchema,
+    isPersonal: Type.Optional(Type.Boolean()),
+    avatarUrl: Type.Optional(Type.String({ maxLength: 512 }))
+  },
+  {
+    additionalProperties: false,
+    required: []
+  }
+);
+
+const patchBodySchema = Type.Object(
+  {
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
+    avatarUrl: Type.Optional(Type.String({ maxLength: 512 })),
+    deletedAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]))
+  },
+  {
+    additionalProperties: false
+  }
+);
+
+const recordOutputValidator = Object.freeze({
+  schema: recordOutputSchema,
+  normalize: normalizeWorkspaceRecord
+});
+
+const createBodyValidator = Object.freeze({
+  schema: createBodySchema,
+  normalize: normalizeWorkspaceInput
+});
+
+const patchBodyValidator = Object.freeze({
+  schema: patchBodySchema,
+  normalize: normalizeWorkspaceInput
+});
+
+const workspacesResource = Object.freeze({
+  namespace: "workspaces",
+  tableName: "workspaces",
+  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: "ownerUserId",
+      repository: { column: "owner_user_id" }
+    }),
+    Object.freeze({
+      key: "isPersonal",
+      repository: { column: "is_personal" }
+    }),
+    Object.freeze({
+      key: "avatarUrl",
+      repository: { column: "avatar_url" }
+    }),
+    Object.freeze({
+      key: "createdAt",
+      repository: { column: "created_at" }
+    }),
+    Object.freeze({
+      key: "updatedAt",
+      repository: { column: "updated_at" }
+    }),
+    Object.freeze({
+      key: "deletedAt",
+      repository: { column: "deleted_at" }
+    })
+  ])
+});
+
+export { workspacesResource };

package/src/server/registerWorkspaceBootstrap.js

@@ -17,7 +17,7 @@ function registerWorkspaceBootstrap(app) {
         ? scope.make("workspaces.pending-invitations.service")
         : null,
       workspaceInvitationsEnabled,
-      usersRepository: scope.make("usersRepository"),
+      userProfilesRepository: scope.make("internal.repository.user-profiles"),
       appConfig: resolveAppConfig(scope),
       tenancyProfile: scope.make("workspaces.tenancy.profile")
     });

package/src/server/registerWorkspaceCore.js

@@ -33,9 +33,9 @@ function registerWorkspaceCore(app) {
     const appConfig = resolveAppConfig(scope);
     return createWorkspaceService({
       appConfig,
-      workspacesRepository: scope.make("workspacesRepository"),
-      workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository"),
-      workspaceSettingsRepository: scope.make("workspaceSettingsRepository")
+      workspacesRepository: scope.make("internal.repository.workspaces"),
+      workspaceMembershipsRepository: scope.make("internal.repository.workspace-memberships"),
+      workspaceSettingsRepository: scope.make("internal.repository.workspace-settings")
     });
   });
   app.singleton("workspaces.enabled", (scope) => {

package/src/server/registerWorkspaceRepositories.js

@@ -7,17 +7,17 @@ function registerWorkspaceRepositories(app) {
     throw new Error("registerWorkspaceRepositories requires application singleton().");
   }
 
-  app.singleton("workspacesRepository", (scope) => {
+  app.singleton("internal.repository.workspaces", (scope) => {
     const knex = scope.make("jskit.database.knex");
     return createWorkspacesRepository(knex);
   });
 
-  app.singleton("workspaceMembershipsRepository", (scope) => {
+  app.singleton("internal.repository.workspace-memberships", (scope) => {
     const knex = scope.make("jskit.database.knex");
     return createWorkspaceMembershipsRepository(knex);
   });
 
-  app.singleton("workspaceInvitesRepository", (scope) => {
+  app.singleton("internal.repository.workspace-invites", (scope) => {
     const knex = scope.make("jskit.database.knex");
     return createWorkspaceInvitesRepository(knex);
   });

package/src/server/workspaceBootstrapContributor.js

@@ -104,7 +104,7 @@ function resolveBootstrapTenancyProfile(tenancyProfile = null, appConfig = {}) {
 function createWorkspaceBootstrapContributor({
   workspaceService,
   workspacePendingInvitationsService,
-  usersRepository,
+  userProfilesRepository,
   workspaceInvitationsEnabled = false,
   appConfig = {},
   tenancyProfile = null
@@ -123,8 +123,8 @@ function createWorkspaceBootstrapContributor({
       serviceLabel: "workspacePendingInvitationsService"
     });
   }
-  requireServiceMethod(usersRepository, "findById", contributorId, {
-    serviceLabel: "usersRepository"
+  requireServiceMethod(userProfilesRepository, "findById", contributorId, {
+    serviceLabel: "internal.repository.user-profiles"
   });
 
   return Object.freeze({
@@ -161,7 +161,7 @@ function createWorkspaceBootstrapContributor({
         };
       }
 
-      const latestProfile = await usersRepository.findById(normalizedUserId);
+      const latestProfile = await userProfilesRepository.findById(normalizedUserId);
       if (!latestProfile) {
         return {};
       }

package/src/server/workspaceMembers/registerWorkspaceMembers.js

@@ -58,8 +58,8 @@ function registerWorkspaceMembers(app) {
     (scope) => {
       const appConfig = resolveAppConfig(scope);
       return createWorkspaceMembersService({
-        workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository"),
-        workspaceInvitesRepository: scope.make("workspaceInvitesRepository"),
+        workspaceMembershipsRepository: scope.make("internal.repository.workspace-memberships"),
+        workspaceInvitesRepository: scope.make("internal.repository.workspace-invites"),
         inviteExpiresInMs: resolveWorkspaceMembersInviteExpiresInMs(appConfig),
         roleCatalog: createWorkspaceRoleCatalog(appConfig),
         workspaceInvitationsEnabled: scope.make("workspaces.invitations.enabled") === true

package/src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js

@@ -93,8 +93,8 @@ function registerWorkspacePendingInvitations(app) {
     "workspaces.pending-invitations.service",
     (scope) =>
       createService({
-        workspaceInvitesRepository: scope.make("workspaceInvitesRepository"),
-        workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository")
+        workspaceInvitesRepository: scope.make("internal.repository.workspace-invites"),
+        workspaceMembershipsRepository: scope.make("internal.repository.workspace-memberships")
       }),
     {
       events: deepFreeze({

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -22,7 +22,7 @@ function registerWorkspaceSettings(app) {
     throw new Error("registerWorkspaceSettings requires application singleton()/service()/actions().");
   }
 
-  app.singleton("workspaceSettingsRepository", (scope) => {
+  app.singleton("internal.repository.workspace-settings", (scope) => {
     const knex = scope.make("jskit.database.knex");
     const appConfig = resolveAppConfig(scope);
     return createWorkspaceSettingsRepository(knex, {
@@ -34,7 +34,7 @@ function registerWorkspaceSettings(app) {
     "workspaces.settings.service",
     (scope) =>
       createWorkspaceSettingsService({
-        workspaceSettingsRepository: scope.make("workspaceSettingsRepository"),
+        workspaceSettingsRepository: scope.make("internal.repository.workspace-settings"),
         workspaceInvitationsEnabled: scope.make("workspaces.invitations.enabled"),
         roleCatalog: createWorkspaceRoleCatalog(resolveAppConfig(scope))
       }),

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -46,8 +46,9 @@ function createRepository(knex, { defaultInvitesEnabled } = {}) {
       workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" })
     };
     for (const field of workspaceSettingsFields) {
-      const rawValue = Object.hasOwn(row, field.dbColumn)
-        ? row[field.dbColumn]
+      const column = field.repository.column;
+      const rawValue = Object.hasOwn(row, column)
+        ? row[column]
         : field.resolveDefault({
             defaultInvitesEnabled
           });
@@ -94,7 +95,7 @@ function createRepository(knex, { defaultInvitesEnabled } = {}) {
         updated_at: nowDb()
       };
       for (const field of workspaceSettingsFields) {
-        insertPayload[field.dbColumn] = seed[field.key];
+        insertPayload[field.repository.column] = seed[field.key];
       }
       await client("workspace_settings").insert(insertPayload);
     } catch (error) {
@@ -132,7 +133,7 @@ function createRepository(knex, { defaultInvitesEnabled } = {}) {
       if (!Object.hasOwn(settingsPatch, field.key)) {
         continue;
       }
-      dbPatch[field.dbColumn] = field.normalizeInput(settingsPatch[field.key], {
+      dbPatch[field.repository.column] = field.normalizeInput(settingsPatch[field.key], {
         payload: source
       });
     }

package/src/shared/resources/workspaceMembersResource.js

@@ -299,7 +299,7 @@ const redeemInviteOutputValidator = Object.freeze({
 const WORKSPACE_MEMBERS_MESSAGES = createOperationMessages();
 
 const workspaceMembersResource = Object.freeze({
-  resource: "workspaceMembers",
+  namespace: "workspaceMembers",
   messages: WORKSPACE_MEMBERS_MESSAGES,
   operations: Object.freeze({
     rolesList: Object.freeze({