@jskit-ai/workspaces-core 0.1.137 → 0.1.138

package/src/server/WorkspacesCoreServiceProvider.js

@@ -1,64 +0,0 @@
-import {
-  INTERNAL_JSON_REST_API,
-  addResourceIfMissing,
-  createJsonRestResourceScopeOptions
-} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
-import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
-import { bootWorkspaceDirectoryRoutes } from "./workspaceDirectory/bootWorkspaceDirectoryRoutes.js";
-import { registerWorkspaceDirectory } from "./workspaceDirectory/registerWorkspaceDirectory.js";
-import {
-  registerWorkspacePendingInvitations
-} from "./workspacePendingInvitations/registerWorkspacePendingInvitations.js";
-import { bootWorkspacePendingInvitations } from "./workspacePendingInvitations/bootWorkspacePendingInvitations.js";
-import { registerWorkspaceMembers } from "./workspaceMembers/registerWorkspaceMembers.js";
-import { bootWorkspaceMembers } from "./workspaceMembers/bootWorkspaceMembers.js";
-import { registerWorkspaceSettings } from "./workspaceSettings/registerWorkspaceSettings.js";
-import { bootWorkspaceSettings } from "./workspaceSettings/bootWorkspaceSettings.js";
-import { registerWorkspaceRepositories } from "./registerWorkspaceRepositories.js";
-import { registerWorkspaceCore } from "./registerWorkspaceCore.js";
-import { registerWorkspaceBootstrap } from "./registerWorkspaceBootstrap.js";
-import { workspaceResource } from "../shared/resources/workspaceResource.js";
-import { workspaceMembershipsResource } from "../shared/resources/workspaceMembershipsResource.js";
-import { workspaceInvitesResource } from "../shared/resources/workspaceInvitesResource.js";
-import { workspaceSettingsResource } from "../shared/resources/workspaceSettingsResource.js";
-
-class WorkspacesCoreServiceProvider {
-  static id = "workspaces.core";
-
-  static startsAfter = ["runtime.actions", "users.core"];
-
-  async register(app) {
-    registerWorkspaceRepositories(app);
-    registerWorkspaceCore(app);
-    registerWorkspaceBootstrap(app);
-    registerWorkspaceDirectory(app);
-    registerWorkspaceMembers(app);
-    registerWorkspaceSettings(app);
-    registerWorkspacePendingInvitations(app);
-  }
-
-  async boot(app) {
-    const api = app.make(INTERNAL_JSON_REST_API);
-    const scopeOptions = {
-      writeSerializers: {
-        "datetime-utc": toDatabaseDateTimeUtc
-      }
-    };
-    await addResourceIfMissing(api, "workspaces", createJsonRestResourceScopeOptions(workspaceResource, scopeOptions));
-    await addResourceIfMissing(api, "workspaceMemberships", createJsonRestResourceScopeOptions(workspaceMembershipsResource, scopeOptions));
-    await addResourceIfMissing(api, "workspaceInvites", createJsonRestResourceScopeOptions(workspaceInvitesResource, scopeOptions));
-    await addResourceIfMissing(api, "workspaceSettings", createJsonRestResourceScopeOptions(workspaceSettingsResource, scopeOptions));
-    if (app.make("workspaces.enabled") !== true) {
-      return;
-    }
-
-    bootWorkspaceDirectoryRoutes(app);
-    if (app.make("workspaces.invitations.enabled") === true) {
-      bootWorkspacePendingInvitations(app);
-    }
-    bootWorkspaceSettings(app);
-    bootWorkspaceMembers(app);
-  }
-}
-
-export { WorkspacesCoreServiceProvider };

package/src/server/registerWorkspaceBootstrap.js

@@ -1,27 +0,0 @@
-import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { createWorkspaceBootstrapContributor } from "./workspaceBootstrapContributor.js";
-
-
-function registerWorkspaceBootstrap(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceBootstrap requires application singleton().");
-  }
-
-  registerBootstrapPayloadContributor(app, "workspaces.core.bootstrap.payloadContributor", (scope) => {
-    const workspaceInvitationsEnabled = scope.make("workspaces.invitations.enabled");
-
-    return createWorkspaceBootstrapContributor({
-      workspaceService: scope.make("workspaces.service"),
-      workspacePendingInvitationsService: workspaceInvitationsEnabled
-        ? scope.make("workspaces.pending-invitations.service")
-        : null,
-      workspaceInvitationsEnabled,
-      userProfilesRepository: scope.make("internal.repository.user-profiles"),
-      appConfig: resolveAppConfig(scope),
-      tenancyProfile: scope.make("workspaces.tenancy.profile")
-    });
-  });
-}
-
-export { registerWorkspaceBootstrap };

package/src/server/registerWorkspaceCore.js

@@ -1,101 +0,0 @@
-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";
-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, resolveTenancyProfile } from "../shared/tenancyProfile.js";
-import { resolveWorkspaceInvitationsPolicy } from "./support/workspaceInvitationsPolicy.js";
-import {
-  registerWorkspaceActionSurfaceSources,
-  resolveWorkspaceSurfaceIdsFromAppConfig
-} from "./support/workspaceActionSurfaces.js";
-import { createWorkspaceServerScopeSupport } from "./support/workspaceServerScopeSupport.js";
-
-
-function registerWorkspaceCore(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceCore requires application singleton().");
-  }
-
-  registerWorkspaceActionSurfaceSources(app);
-
-  app.singleton("workspaces.tenancy.profile", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return resolveTenancyProfile(appConfig);
-  });
-
-  app.singleton("workspaces.service", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceService({
-      appConfig,
-      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) => {
-    return scope.make("workspaces.tenancy.profile").workspace.enabled === true;
-  });
-
-  app.singleton("workspaces.self-create.enabled", (scope) => {
-    return scope.make("workspaces.tenancy.profile").workspace.allowSelfCreate === true;
-  });
-
-  app.singleton("workspaces.tenancy.enabled", (scope) => {
-    return scope.make("workspaces.tenancy.profile").mode === TENANCY_MODE_WORKSPACES;
-  });
-
-  app.singleton("workspaces.invitations.enabled", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    const tenancyProfile = scope.make("workspaces.tenancy.profile");
-    return resolveWorkspaceInvitationsPolicy({
-      appConfig,
-      tenancyProfile
-    }).enabled;
-  });
-  app.singleton("workspaces.server.scope-support", () => createWorkspaceServerScopeSupport());
-
-  registerProfileSyncLifecycleContributor(app, "workspaces.core.profileSyncLifecycleContributor", (scope) => {
-    const workspaceService = scope.make("workspaces.service");
-
-    return Object.freeze({
-      contributorId: "workspaces.core.profileSync",
-      order: 100,
-      async afterIdentityProfileSynced({ profile, options } = {}) {
-        if (!profile || typeof workspaceService?.ensureProvisionedWorkspaceForAuthenticatedUser !== "function") {
-          return;
-        }
-
-        await workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser(profile, options);
-      }
-    });
-  });
-
-  registerActionContextContributor(app, "users.core.workspace.actionContextContributor", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceActionContextContributor({
-      workspaceService: scope.make("workspaces.service"),
-      workspaceSurfaceIds: resolveWorkspaceSurfaceIdsFromAppConfig(appConfig)
-    });
-  });
-
-  registerAuthPolicyContextResolver(app, "workspaces.core.authPolicyContextResolver", (scope) =>
-    createWorkspaceAuthPolicyContextResolver({
-      workspaceService: scope.make("workspaces.service")
-    })
-  );
-
-  registerRouteVisibilityResolver(app, "users.core.workspace.routeVisibilityResolver", (scope) =>
-    createWorkspaceRouteVisibilityResolver({
-      workspaceService: scope.make("workspaces.service")
-    })
-  );
-}
-
-export { registerWorkspaceCore };

package/src/server/registerWorkspaceRepositories.js

@@ -1,30 +0,0 @@
-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";
-
-function registerWorkspaceRepositories(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceRepositories requires application singleton().");
-  }
-
-  app.singleton("internal.repository.workspaces", (scope) => {
-    const api = scope.make(INTERNAL_JSON_REST_API);
-    const knex = scope.make("jskit.database.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({ 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({ api, knex });
-  });
-}
-
-export { registerWorkspaceRepositories };

package/src/server/support/workspaceServerScopeSupport.js

@@ -1,18 +0,0 @@
-import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
-import { buildWorkspaceInputFromRouteParams } from "./workspaceRouteInput.js";
-import { resolveWorkspace } from "./resolveWorkspace.js";
-
-function createWorkspaceServerScopeSupport() {
-  return Object.freeze({
-    available: true,
-    params: workspaceSlugParamsValidator,
-    buildInputFromRouteParams(params = {}) {
-      return buildWorkspaceInputFromRouteParams(params);
-    },
-    resolveWorkspace(context = {}, input = {}) {
-      return resolveWorkspace(context, input);
-    }
-  });
-}
-
-export { createWorkspaceServerScopeSupport };

package/src/server/workspaceDirectory/registerWorkspaceDirectory.js

@@ -1,19 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { workspaceDirectoryActions } from "./workspaceDirectoryActions.js";
-
-function registerWorkspaceDirectory(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerWorkspaceDirectory requires application singleton()/actions().");
-  }
-
-  app.actions(
-    withActionDefaults(workspaceDirectoryActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceService: "workspaces.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceDirectory };

package/src/server/workspaceMembers/registerWorkspaceMembers.js

@@ -1,137 +0,0 @@
-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";
-import { workspaceMembersActions } from "./workspaceMembersActions.js";
-import { createWorkspaceRoleCatalog } from "../../shared/roles.js";
-import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
-import { renderDefaultWorkspaceInviteEmail } from "./defaultWorkspaceInviteEmail.js";
-import { createWorkspaceInviteUrlBuilder } from "./workspaceInviteUrls.js";
-
-
-function resolveWorkspaceMembersInviteExpiresInMs(appConfig = {}) {
-  const inviteExpiresInMs = Number(appConfig?.workspaceMembers?.defaults?.inviteExpiresInMs);
-  if (!Number.isInteger(inviteExpiresInMs) || inviteExpiresInMs < 1) {
-    throw new TypeError("users.core requires appConfig.workspaceMembers.defaults.inviteExpiresInMs.");
-  }
-
-  return inviteExpiresInMs;
-}
-
-function resolveWorkspaceInviteEmailTemplate(scope, appConfig = {}) {
-  if (typeof scope.has === "function" && scope.has("workspaces.invite.emailTemplate")) {
-    return scope.make("workspaces.invite.emailTemplate");
-  }
-
-  const configuredTemplate =
-    appConfig.workspaceInviteEmailTemplate ||
-    appConfig.workspaceInviteEmailRenderer ||
-    appConfig.workspaceInvitations?.emailTemplate ||
-    appConfig.workspaceInvitations?.emailRenderer;
-  if (typeof configuredTemplate === "function") {
-    return configuredTemplate;
-  }
-
-  return renderDefaultWorkspaceInviteEmail;
-}
-
-const INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE = Object.freeze({
-  preset: "event_scope",
-  async userQuery({ knex, event } = {}) {
-    if (typeof knex !== "function") {
-      return [];
-    }
-
-    const inviteId = normalizeRecordId(event?.entityId, { fallback: null });
-    if (!inviteId) {
-      return [];
-    }
-
-    const row = await knex("workspace_invites as wi")
-      .join("users as up", "up.email", "wi.email")
-      .where("wi.id", inviteId)
-      .first("up.id as user_id");
-
-    const userId = normalizeDbRecordId(row?.user_id, { fallback: null });
-    if (!userId) {
-      return [];
-    }
-
-    return [
-      {
-        userId
-      }
-    ];
-  }
-});
-
-function registerWorkspaceMembers(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerWorkspaceMembers requires application singleton()/service()/actions().");
-  }
-
-  app.service(
-    "workspaces.members.service",
-    (scope) => {
-      const appConfig = resolveAppConfig(scope);
-      const env = typeof scope.has === "function" && scope.has("jskit.env") ? scope.make("jskit.env") : process.env;
-      return createWorkspaceMembersService({
-        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,
-        inviteUrlBuilder: createWorkspaceInviteUrlBuilder({
-          appConfig,
-          env
-        }),
-        workspaceInviteMailer:
-          typeof scope.has === "function" && scope.has("workspaces.invite.mailer")
-            ? scope.make("workspaces.invite.mailer")
-            : null,
-        workspaceInviteEmailTemplate: resolveWorkspaceInviteEmailTemplate(scope, appConfig)
-      });
-    },
-    {
-      events: deepFreeze({
-        updateMemberRole: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "member",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.members.changed"
-        }),
-        removeMember: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "member",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.members.changed"
-        }),
-        createInvite: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "invite",
-          workspaceOperation: "created",
-          workspaceRealtimeEvent: "workspace.invites.changed",
-          bootstrapEntityId: ({ result }) => result?.createdInviteId,
-          bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
-        }),
-        revokeInvite: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "invite",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.invites.changed",
-          bootstrapEntityId: ({ result }) => result?.revokedInviteId,
-          bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
-        })
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(workspaceMembersActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceMembersService: "workspaces.members.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceMembers };

package/src/server/workspacePendingInvitations/registerWorkspacePendingInvitations.js

@@ -1,130 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { createService } from "./workspacePendingInvitationsService.js";
-import { workspacePendingInvitationsActions } from "./workspacePendingInvitationsActions.js";
-import { deepFreeze } from "../common/support/deepFreeze.js";
-
-function workspaceAudienceFromEntityId({ event } = {}) {
-  const workspaceId = normalizeRecordId(event?.entityId, { fallback: null });
-  if (!workspaceId) {
-    return "none";
-  }
-  return {
-    workspaceId
-  };
-}
-
-function actorUserEntityId({ options } = {}) {
-  return normalizeRecordId(options?.context?.actor?.id, { fallback: "" });
-}
-
-function createActorUserEvent({ source, entity, realtimeEvent }) {
-  return {
-    type: "entity.changed",
-    source,
-    entity,
-    operation: "updated",
-    entityId: actorUserEntityId,
-    realtime: {
-      event: realtimeEvent,
-      audience: "actor_user"
-    }
-  };
-}
-
-function createWorkspaceAudienceEvent({ entity, realtimeEvent }) {
-  return {
-    type: "entity.changed",
-    source: "workspace",
-    entity,
-    operation: "updated",
-    entityId: ({ result }) => normalizeRecordId(result?.workspaceId, { fallback: "" }),
-    realtime: {
-      event: realtimeEvent,
-      audience: workspaceAudienceFromEntityId
-    }
-  };
-}
-
-function createInviteDecisionEvents({ includeDirectoryAndMembers = false } = {}) {
-  const events = [
-    createActorUserEvent({
-      source: "workspace",
-      entity: "invitation",
-      realtimeEvent: "workspace.invitations.pending.changed"
-    }),
-    createActorUserEvent({
-      source: "users",
-      entity: "bootstrap",
-      realtimeEvent: "users.bootstrap.changed"
-    })
-  ];
-
-  if (includeDirectoryAndMembers) {
-    events.push(
-      createActorUserEvent({
-        source: "workspace",
-        entity: "directory",
-        realtimeEvent: "workspaces.changed"
-      }),
-      createWorkspaceAudienceEvent({
-        entity: "member",
-        realtimeEvent: "workspace.members.changed"
-      })
-    );
-  }
-
-  events.push(
-    createWorkspaceAudienceEvent({
-      entity: "invite",
-      realtimeEvent: "workspace.invites.changed"
-    })
-  );
-
-  return events;
-}
-
-function registerWorkspacePendingInvitations(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerWorkspacePendingInvitations requires application singleton()/service()/actions().");
-  }
-
-  app.service(
-    "workspaces.pending-invitations.service",
-    (scope) =>
-      createService({
-        workspaceInvitesRepository: scope.make("internal.repository.workspace-invites"),
-        workspaceMembershipsRepository: scope.make("internal.repository.workspace-memberships")
-      }),
-    {
-      events: deepFreeze({
-        acceptInviteByToken: createInviteDecisionEvents({
-          includeDirectoryAndMembers: true
-        }),
-        refuseInviteByToken: createInviteDecisionEvents()
-      })
-    }
-  );
-
-  if (typeof app.has === "function" && !app.has("auth.invitationContextResolver")) {
-    app.singleton("auth.invitationContextResolver", (scope) => {
-      const service = scope.make("workspaces.pending-invitations.service");
-      return {
-        async resolveInvitationContext(invitation, options = {}) {
-          return service.resolveInviteContextForAuth(invitation, options);
-        }
-      };
-    });
-  }
-
-  app.actions(
-    withActionDefaults(workspacePendingInvitationsActions, {
-      domain: "workspace",
-      dependencies: {
-        workspacePendingInvitationsService: "workspaces.pending-invitations.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspacePendingInvitations };

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -1,66 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { INTERNAL_JSON_REST_API } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
-import { deepFreeze } from "../common/support/deepFreeze.js";
-import { createRepository as createWorkspaceSettingsRepository } from "./workspaceSettingsRepository.js";
-import { createService as createWorkspaceSettingsService } from "./workspaceSettingsService.js";
-import { workspaceSettingsActions } from "./workspaceSettingsActions.js";
-import { createWorkspaceRoleCatalog } from "../../shared/roles.js";
-import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
-
-function resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig = {}) {
-  const defaultInvitesEnabled = appConfig?.workspaceSettings?.defaults?.invitesEnabled;
-
-  if (typeof defaultInvitesEnabled !== "boolean") {
-    throw new TypeError("users.core requires appConfig.workspaceSettings.defaults.invitesEnabled.");
-  }
-
-  return defaultInvitesEnabled;
-}
-
-function registerWorkspaceSettings(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.actions !== "function" || typeof app.service !== "function") {
-    throw new Error("registerWorkspaceSettings requires application singleton()/service()/actions().");
-  }
-
-  app.singleton("internal.repository.workspace-settings", (scope) => {
-    const api = scope.make(INTERNAL_JSON_REST_API);
-    const knex = scope.make("jskit.database.knex");
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceSettingsRepository({
-      api,
-      knex,
-      defaultInvitesEnabled: resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig)
-    });
-  });
-
-  app.service(
-    "workspaces.settings.service",
-    (scope) =>
-      createWorkspaceSettingsService({
-        workspaceSettingsRepository: scope.make("internal.repository.workspace-settings"),
-        workspaceInvitationsEnabled: scope.make("workspaces.invitations.enabled"),
-        roleCatalog: createWorkspaceRoleCatalog(resolveAppConfig(scope))
-      }),
-    {
-      events: deepFreeze({
-        updateWorkspaceSettings: createWorkspaceEntityAndBootstrapEvents({
-          workspaceEntity: "settings",
-          workspaceOperation: "updated",
-          workspaceRealtimeEvent: "workspace.settings.changed"
-        })
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(workspaceSettingsActions, {
-      domain: "workspace",
-      dependencies: {
-        workspaceSettingsService: "workspaces.settings.service"
-      }
-    })
-  );
-}
-
-export { registerWorkspaceSettings };