@crombolo/api-management 0.0.0-stage → 0.9.1

package/src/ports-members.ts

@@ -0,0 +1,111 @@
+/**
+ * Members and the groups they belong to. The response types come from the
+ * generated contract, so an implementation that drifts from the wire shape is a
+ * compile error rather than a broken editor.
+ */
+import type { ResponseOf } from '@crombolo/contracts'
+import type { DocumentValidationError, DocumentValue, Page, SkipTake } from '@crombolo/core'
+import type { PortFailure } from './ports-content.ts'
+import type { Principal } from './router.ts'
+
+export type MemberGroupResponse = ResponseOf<'GetMemberGroupById'>
+export type MemberGroupItem = ResponseOf<'GetItemMemberGroup'>[number]
+export type MemberGroupTreeItem = ResponseOf<'GetTreeMemberGroupRoot'>['items'][number]
+
+/** A name already taken is Umbraco's only failure here besides a missing group. */
+export type MemberGroupStatus = 'ok' | 'not-found' | 'duplicate-name'
+
+export type MemberResponse = ResponseOf<'GetMemberById'>
+export type MemberItem = ResponseOf<'GetItemMember'>[number]
+
+/**
+ * What a create or a save carries. `password` is plaintext here and hashed by
+ * the adapter: hashing belongs to `@crombolo/auth`, and a handler should not be
+ * able to store one by accident.
+ */
+export interface SaveMember {
+  key: string
+  memberTypeKey: string
+  email: string
+  username: string
+  password?: string | null
+  oldPassword?: string | null
+  isApproved: boolean
+  isLockedOut: boolean
+  isTwoFactorEnabled: boolean
+  groupKeys: string[] | undefined
+  values: DocumentValue[]
+  variants: Array<{ culture: string | null; segment: string | null; name: string }>
+}
+
+export interface MemberFilterCriteria extends SkipTake {
+  memberTypeKey?: string | null
+  memberGroupName?: string | null
+  isApproved?: boolean
+  isLockedOut?: boolean
+  filter?: string
+  orderBy?: string
+  orderDirection?: 'Ascending' | 'Descending'
+}
+
+export interface MemberPort {
+  byKey(key: string, viewer: Principal): Promise<MemberResponse | undefined>
+  /** The rules the server would enforce on a save, for the editor to show first. */
+  validate(input: SaveMember): Promise<DocumentValidationError[]>
+  create(input: SaveMember, principal: Principal): Promise<{ ok: true; key: string } | PortFailure>
+  update(key: string, input: SaveMember, principal: Principal): Promise<{ ok: true } | PortFailure>
+  remove(key: string): Promise<boolean>
+  /** The Members collection. */
+  filter(criteria: MemberFilterCriteria, viewer: Principal): Promise<Page<MemberResponse>>
+  items(keys: readonly string[]): Promise<MemberItem[]>
+  search(
+    query: string,
+    options: { allowedMemberTypeKeys: readonly string[] } & SkipTake,
+  ): Promise<Page<MemberItem>>
+}
+
+export type PublicAccessResponse = ResponseOf<'GetDocumentByIdPublicAccess'>
+
+/**
+ * Why a public-access write was refused, in Umbraco's own vocabulary — the
+ * client keys its messages off these.
+ */
+export type PublicAccessStatus =
+  | 'ok'
+  | 'content-not-found'
+  | 'login-node-not-found'
+  | 'error-node-not-found'
+  | 'entry-not-found'
+
+export interface PublicAccessInput {
+  loginDocumentKey: string
+  errorDocumentKey: string
+  memberGroupNames: string[]
+  memberUserNames: string[]
+}
+
+export interface PublicAccessPort {
+  /**
+   * The entry protecting a document. `includeAncestors` follows the branch up,
+   * which is how the editor tells "protected here" from "protected above".
+   */
+  entry(
+    documentKey: string,
+    includeAncestors: boolean,
+  ): Promise<{ status: PublicAccessStatus; entry?: PublicAccessResponse }>
+  save(documentKey: string, input: PublicAccessInput): Promise<PublicAccessStatus>
+  remove(documentKey: string): Promise<PublicAccessStatus>
+}
+
+export interface MemberGroupPort {
+  list(paging: SkipTake): Promise<Page<MemberGroupResponse>>
+  byKey(key: string): Promise<MemberGroupResponse | undefined>
+  items(keys: readonly string[]): Promise<MemberGroupItem[]>
+  tree(paging: SkipTake): Promise<Page<MemberGroupTreeItem>>
+  create(input: {
+    key?: string
+    name: string
+  }): Promise<{ status: MemberGroupStatus; key?: string }>
+  rename(key: string, name: string): Promise<MemberGroupStatus>
+  remove(key: string): Promise<MemberGroupStatus>
+}

package/src/ports-models-builder.ts

@@ -0,0 +1,26 @@
+/**
+ * Umbraco's ModelsBuilder, which generates strongly-typed models from the
+ * content types. Crombolo's models are the TypeScript `crombolo generate`
+ * writes from the TOML schema, so the same three operations describe it.
+ */
+
+/** Umbraco's `OutOfDateType`: `Unknown` when staleness cannot be determined. */
+export type OutOfDateStatus = 'OutOfDate' | 'Current' | 'Unknown'
+
+export interface ModelsBuilderInfo {
+  /** One of Umbraco's `ModelsMode` strings; the client explains only those. */
+  mode: string
+  canGenerate: boolean
+  outOfDateModels: boolean
+  trackingOutOfDateModels: boolean
+  lastError: string | null
+  version: string | null
+  modelsNamespace: string | null
+}
+
+export interface ModelsBuilderPort {
+  info(): Promise<ModelsBuilderInfo>
+  status(): Promise<OutOfDateStatus>
+  /** Writes the models; the message of a failure is kept for `info().lastError`. */
+  build(): Promise<{ ok: true } | { ok: false; error: string }>
+}

package/src/ports-packages.ts

@@ -0,0 +1,58 @@
+/**
+ * Created packages: the definitions the Packages section builds, and the zip a
+ * download turns one into. `docs/17-bundles.md`.
+ *
+ * The port hands back built bytes rather than a path, because the artifact is
+ * never stored — it is serialized when it is asked for, so it cannot be stale.
+ */
+import type { Page, SkipTake } from '@crombolo/core'
+
+/** What a package would contain, in the aliases and keys the contract uses. */
+export interface PackageDefinitionInput {
+  name: string
+  /** The content subtree's root, by key, or null when none is picked. */
+  contentNodeId: string | null
+  contentLoadChildNodes: boolean
+  mediaIds: string[]
+  mediaLoadChildNodes: boolean
+  /** Null and empty mean the same thing; the contract allows both. */
+  elementIds: string[] | null
+  contentTypes: string[]
+  mediaTypes: string[]
+  dataTypes: string[]
+  templates: string[]
+  partialViews: string[]
+  stylesheets: string[]
+  scripts: string[]
+  languages: string[]
+  dictionaryItems: string[]
+}
+
+export interface PackageDefinition extends PackageDefinitionInput {
+  id: string
+}
+
+export type PackageWriteResult =
+  | { ok: true; id: string }
+  | { ok: false; status: PackageWriteStatus }
+
+export type PackageWriteStatus = 'NotFound' | 'DuplicateName' | 'InvalidName'
+
+/** A built package, ready to send. */
+export interface BuiltPackage {
+  fileName: string
+  /** Owns its buffer, so it can be a response body without a copy. */
+  bytes: Uint8Array<ArrayBuffer>
+}
+
+export interface PackagePort {
+  /** Where the Marketplace view points; from the site's configuration. */
+  marketplaceUrl(): string
+  list(paging: SkipTake): Promise<Page<PackageDefinition>>
+  byId(id: string): Promise<PackageDefinition | undefined>
+  create(input: PackageDefinitionInput, id: string | undefined): Promise<PackageWriteResult>
+  update(id: string, input: PackageDefinitionInput): Promise<PackageWriteResult>
+  remove(id: string): Promise<'deleted' | 'notFound'>
+  /** Serializes and zips the definition now; undefined when it is gone. */
+  build(id: string): Promise<BuiltPackage | undefined>
+}

package/src/ports-users.ts

@@ -0,0 +1,230 @@
+/** Ports for backoffice users, user groups and user data. */
+import type { ResponseOf } from '@crombolo/contracts'
+import type { Page } from '@crombolo/core'
+import type { Principal } from './router.ts'
+
+export type UserResponse = ResponseOf<'GetUserById'>
+export type UserGroupResponse = ResponseOf<'GetUserGroupById'>
+
+/** Umbraco's `UserOperationStatus` names, as its problem details report them. */
+export type UserStatus =
+  | 'Success'
+  | 'UserNotFound'
+  | 'MissingUserGroup'
+  | 'NoUserGroup'
+  | 'DuplicateUserName'
+  | 'DuplicateEmail'
+  | 'InvalidEmail'
+  | 'InvalidUserName'
+  | 'UserNameIsNotEmail'
+  | 'Unauthorized'
+  | 'Forbidden'
+  | 'CannotDeleteSelf'
+  | 'CannotDisableSelf'
+  | 'CannotDeleteUserWithLoginHistory'
+  | 'CannotDisableInvitedUser'
+  | 'CannotInvite'
+  | 'InvalidPassword'
+  | 'SelfOldPasswordRequired'
+  | 'InvalidIsoCode'
+  | 'ContentStartNodeNotFound'
+  | 'MediaStartNodeNotFound'
+  | 'ElementStartNodeNotFound'
+  | 'InvalidInviteToken'
+  | 'NotInInviteState'
+  | 'AvatarFileNotFound'
+  | 'InvalidAvatar'
+  | 'InvalidUserType'
+  | 'DuplicateClientId'
+  | 'InvalidClientId'
+  | 'InvalidResetCode'
+
+export type UserOrder =
+  | 'UserName'
+  | 'Language'
+  | 'Name'
+  | 'Email'
+  | 'Id'
+  | 'CreateDate'
+  | 'UpdateDate'
+  | 'IsApproved'
+  | 'IsLockedOut'
+  | 'LastLoginDate'
+
+export interface UserFilter {
+  filter?: string
+  groupKeys: string[]
+  states: string[]
+  orderBy: UserOrder
+  direction: 'Ascending' | 'Descending'
+  skip: number
+  take: number
+}
+
+export interface UserInput {
+  key?: string
+  kind: 'Default' | 'Api'
+  email: string
+  userName: string
+  name: string
+  groupKeys: string[]
+}
+
+export interface UserUpdateInput {
+  email: string
+  userName: string
+  name: string
+  languageIsoCode: string
+  groupKeys: string[]
+  documentStartNodeKeys: string[]
+  hasDocumentRootAccess: boolean
+  mediaStartNodeKeys: string[]
+  hasMediaRootAccess: boolean
+  elementStartNodeKeys: string[]
+  hasElementRootAccess: boolean
+}
+
+export type Result<T> = { status: 'Success'; value: T } | { status: Exclude<UserStatus, 'Success'> }
+
+export interface UserPort {
+  list(principal: Principal, skip: number, take: number): Promise<Page<UserResponse>>
+  filter(principal: Principal, query: UserFilter): Promise<Page<UserResponse>>
+  get(principal: Principal, key: string): Promise<Result<UserResponse>>
+  batch(principal: Principal, keys: readonly string[]): Promise<UserResponse[]>
+  create(principal: Principal, input: UserInput): Promise<Result<string>>
+  invite(principal: Principal, input: UserInput, message: string | null): Promise<Result<string>>
+  resendInvite(principal: Principal, key: string, message: string | null): Promise<UserStatus>
+  /** Anonymous: whether an invitation token is still good. */
+  verifyInvite(key: string, token: string): Promise<UserStatus>
+  /** Anonymous: accepts an invitation by setting the first password. */
+  createInitialPassword(key: string, token: string, password: string): Promise<UserStatus>
+  update(principal: Principal, key: string, input: UserUpdateInput): Promise<UserStatus>
+  delete(principal: Principal, keys: readonly string[]): Promise<UserStatus>
+  setApproved(principal: Principal, keys: readonly string[], approved: boolean): Promise<UserStatus>
+  unlock(principal: Principal, keys: readonly string[]): Promise<UserStatus>
+  setGroups(
+    principal: Principal,
+    userKeys: readonly string[],
+    groupKeys: readonly string[],
+  ): Promise<UserStatus>
+  changePassword(
+    principal: Principal,
+    key: string,
+    newPassword: string,
+    oldPassword: string | null,
+  ): Promise<UserStatus>
+  /** A generated password, which the backoffice shows once. */
+  resetPassword(principal: Principal, key: string): Promise<Result<string>>
+  setAvatar(principal: Principal, key: string, temporaryFileId: string): Promise<UserStatus>
+  removeAvatar(principal: Principal, key: string): Promise<UserStatus>
+  calculateStartNodes(
+    principal: Principal,
+    key: string,
+  ): Promise<Result<ResponseOf<'GetUserByIdCalculateStartNodes'>>>
+  clientCredentials(principal: Principal, key: string): Promise<Result<string[]>>
+  addClientCredential(
+    principal: Principal,
+    key: string,
+    clientId: string,
+    secret: string,
+  ): Promise<UserStatus>
+  removeClientCredential(principal: Principal, key: string, clientId: string): Promise<UserStatus>
+  setLanguage(principal: Principal, isoCode: string): Promise<UserStatus>
+  /** The caller's verbs on each node, as the permission rules calculate them. */
+  permissions(
+    principal: Principal,
+    tree: 'document' | 'media' | 'element',
+    keys: readonly string[],
+  ): Promise<Array<{ nodeKey: string; permissions: string[] }>>
+  configuration(): ResponseOf<'GetUserConfiguration'>
+  currentConfiguration(): ResponseOf<'GetUserCurrentConfiguration'>
+  passwordConfiguration(): ResponseOf<'GetSecurityConfiguration'>['passwordConfiguration']
+  /** Anonymous: sends a reset link when the address belongs to a user; says nothing either way. */
+  forgotPassword(email: string): Promise<void>
+  verifyResetCode(key: string, code: string): Promise<UserStatus>
+  resetWithCode(key: string, code: string, password: string): Promise<UserStatus>
+}
+
+export interface UserGroupInput {
+  key?: string
+  name: string
+  alias: string
+  description: string | null
+  icon: string | null
+  sections: string[]
+  languages: string[]
+  hasAccessToAllLanguages: boolean
+  documentStartNode: string | null
+  documentRootAccess: boolean
+  mediaStartNode: string | null
+  mediaRootAccess: boolean
+  elementStartNode: string | null
+  elementRootAccess: boolean
+  fallbackPermissions: string[]
+  permissions: UserGroupResponse['permissions']
+}
+
+/** Umbraco's `UserGroupOperationStatus` names. */
+export type UserGroupStatus =
+  | 'Success'
+  | 'NotFound'
+  | 'Unauthorized'
+  | 'Forbidden'
+  | 'DuplicateAlias'
+  | 'DuplicateName'
+  | 'MissingName'
+  | 'NameTooLong'
+  | 'AliasTooLong'
+  | 'IsSystemUserGroup'
+  | 'CanNotUpdateAliasIsSystemUserGroup'
+  | 'DocumentStartNodeKeyNotFound'
+  | 'MediaStartNodeKeyNotFound'
+  | 'ElementStartNodeKeyNotFound'
+  | 'LanguageNotFound'
+  | 'AdminGroupCannotBeEmpty'
+  | 'UserNotFound'
+
+export interface UserGroupPort {
+  list(skip: number, take: number): Promise<Page<UserGroupResponse>>
+  filter(
+    principal: Principal,
+    filter: string,
+    skip: number,
+    take: number,
+  ): Promise<Page<UserGroupResponse>>
+  get(principal: Principal, key: string): Promise<UserGroupResponse | 'NotFound' | 'Forbidden'>
+  items(keys: readonly string[]): Promise<ResponseOf<'GetItemUserGroup'>>
+  create(
+    principal: Principal,
+    input: UserGroupInput,
+  ): Promise<{ status: UserGroupStatus; key?: string }>
+  update(principal: Principal, key: string, input: UserGroupInput): Promise<UserGroupStatus>
+  delete(principal: Principal, keys: readonly string[]): Promise<UserGroupStatus>
+  addUsers(principal: Principal, key: string, userKeys: readonly string[]): Promise<UserGroupStatus>
+  removeUsers(
+    principal: Principal,
+    key: string,
+    userKeys: readonly string[],
+  ): Promise<UserGroupStatus>
+}
+
+export interface UserDataEntryModel {
+  key: string
+  group: string
+  identifier: string
+  value: string
+}
+
+/** The current user's key/value data. */
+export interface UserDataPort {
+  list(
+    principal: Principal,
+    filter: { groups: string[]; identifiers: string[] },
+    skip: number,
+    take: number,
+  ): Promise<Page<UserDataEntryModel>>
+  get(principal: Principal, key: string): Promise<UserDataEntryModel | undefined>
+  create(principal: Principal, entry: UserDataEntryModel): Promise<'Success' | 'AlreadyExists'>
+  update(principal: Principal, entry: UserDataEntryModel): Promise<'Success' | 'NotFound'>
+  delete(principal: Principal, key: string): Promise<'Success' | 'NotFound'>
+}

package/src/ports.ts

@@ -0,0 +1,225 @@
+/**
+ * Ports the Management API needs from the rest of the application.
+ *
+ * Declared here as interfaces so this package depends only on @crombolo/core and
+ * @crombolo/contracts; the composition root supplies the implementations. The
+ * return types come from the generated contract, so an implementation that
+ * drifts from the wire shape fails to compile.
+ */
+
+import type { ResponseOf } from '@crombolo/contracts'
+import type { UploadSettings } from '@crombolo/core'
+import type {
+  BlueprintPort,
+  ContentTypePort,
+  DataTypePort,
+  DocumentPort,
+  ElementPort,
+  MediaPort,
+  RedirectPort,
+  ReferencePort,
+  TemplatePort,
+  TemplateQueryPort,
+} from './ports-content.ts'
+import type { FileSystemPort, Snippet } from './ports-files.ts'
+import type { LogViewerPort } from './ports-logs.ts'
+import type { MemberGroupPort, MemberPort, PublicAccessPort } from './ports-members.ts'
+import type { ModelsBuilderPort } from './ports-models-builder.ts'
+import type { PackagePort } from './ports-packages.ts'
+import type { UserDataPort, UserGroupPort, UserPort } from './ports-users.ts'
+import type { Principal } from './router.ts'
+
+export interface ServerPort {
+  status(): ResponseOf<'GetServerStatus'>
+  configuration(): ResponseOf<'GetServerConfiguration'>
+  information(): ResponseOf<'GetServerInformation'>
+  /** What may be uploaded; Umbraco's defaults when omitted. */
+  uploadSettings?(): UploadSettings
+}
+
+export type ManifestVisibility = 'all' | 'public' | 'private'
+
+export interface ManifestPort {
+  list(visibility: ManifestVisibility): ResponseOf<'GetManifestManifest'>
+}
+
+export interface LanguageInput {
+  isoCode: string
+  name: string
+  isDefault: boolean
+  isMandatory: boolean
+  fallbackIsoCode: string | null
+}
+
+export interface LocalizationPort {
+  /** Languages live in the database (and `schema/languages.toml`); cultures are the fixed list. */
+  allLanguages(): Promise<LanguageInput[]>
+  language(isoCode: string): Promise<LanguageInput | undefined>
+  saveLanguage(language: LanguageInput): Promise<void>
+  deleteLanguage(isoCode: string): Promise<'deleted' | 'default' | 'in-use' | 'not-found'>
+  cultures(): ResponseOf<'GetCulture'>['items']
+}
+
+export interface CurrentUserPort {
+  get(principal: Principal): ResponseOf<'GetUserCurrent'> | Promise<ResponseOf<'GetUserCurrent'>>
+}
+
+/** Backoffice users by key, for anything that names who did something. */
+export interface UserItemPort {
+  items(
+    keys: readonly string[],
+  ): Promise<Array<{ key: string; name: string; avatarUrls: string[]; kind?: 'Default' | 'Api' }>>
+}
+
+/** Uploads waiting to be saved into a value (Umbraco's temporary files). */
+export interface TemporaryFilePort {
+  save(
+    id: string,
+    file: File,
+  ): Promise<
+    | { ok: true; file: { id: string; fileName: string; availableUntil: Date } }
+    | { ok: false; reason: string }
+  >
+  get(id: string): Promise<{ id: string; fileName: string; availableUntil: Date } | undefined>
+  /** The upload's name and bytes, for files that are read rather than placed. */
+  read(id: string): Promise<{ fileName: string; bytes: Uint8Array } | undefined>
+  remove(id: string): Promise<boolean>
+}
+
+/** Tags in use, for the tags editor's suggestions. */
+export interface TagPort {
+  list(filter: {
+    query?: string
+    group?: string
+    culture?: string | null
+  }): Promise<Array<{ id: string; text: string; group: string; nodeCount: number }>>
+}
+
+/**
+ * The published content cache behind the Published Status dashboard.
+ *
+ * Umbraco distinguishes reloading the in-memory cache from rebuilding the
+ * database cache it reads (`cmsContentNu`). There is no such table here — the
+ * content tables are the source — so the difference is when the cost is paid:
+ * a reload drops the snapshot and lets the next request rebuild it, a rebuild
+ * builds it before answering.
+ */
+export interface PublishedCachePort {
+  reload(): void
+  rebuild(): Promise<void>
+  /** Ours completes within the request, so this is only ever false afterwards. */
+  isRebuilding(): boolean
+}
+
+/** Embed markup for a URL, from its oEmbed provider. */
+export interface OEmbedPort {
+  markup(
+    url: string,
+    maxWidth?: number,
+    maxHeight?: number,
+  ): Promise<
+    { ok: true; markup: string } | { ok: false; status: 'unsupported' | 'failed'; reason: string }
+  >
+}
+
+/** Preview mode is a cookie; the server owns its name and attributes. */
+export interface PreviewPort {
+  /** `Set-Cookie` values that enter preview for the signed-in editor. */
+  enter(): string[]
+  /** `Set-Cookie` values that leave it. */
+  exit(): string[]
+}
+
+export interface DictionaryItemModel {
+  key: string
+  name: string
+  parentKey: string | null
+  translations: Array<{ isoCode: string; translation: string }>
+}
+
+export type DictionaryWriteStatus =
+  | 'Success'
+  | 'DuplicateItemKey'
+  | 'DuplicateKey'
+  | 'ParentNotFound'
+  | 'NotFound'
+  | 'InvalidParent'
+  | 'InvalidLanguage'
+
+/** Dictionary items and their translations. */
+export interface DictionaryPort {
+  all(filter?: string): Promise<DictionaryItemModel[]>
+  get(key: string): Promise<DictionaryItemModel | undefined>
+  items(keys: readonly string[]): Promise<DictionaryItemModel[]>
+  children(
+    parentKey: string | null,
+  ): Promise<Array<{ key: string; name: string; parentKey: string | null; hasChildren: boolean }>>
+  /** The item and its ancestors, root first. */
+  ancestry(key: string): Promise<DictionaryItemModel[]>
+  create(item: DictionaryItemModel): Promise<DictionaryWriteStatus>
+  update(
+    key: string,
+    change: { name: string; translations: DictionaryItemModel['translations'] },
+  ): Promise<DictionaryWriteStatus>
+  move(key: string, parentKey: string | null): Promise<DictionaryWriteStatus>
+  delete(key: string): Promise<DictionaryWriteStatus>
+  /** The item, with its descendants when asked, as a `.udt` file. */
+  export(
+    key: string,
+    includeChildren: boolean,
+  ): Promise<{ fileName: string; content: string } | undefined>
+  /** Creates or updates the items in an uploaded `.udt` file, under `parentKey`. */
+  import(
+    temporaryFileId: string,
+    parentKey: string | null,
+  ): Promise<
+    | { ok: true; key: string }
+    | { ok: false; status: 'NotFound' | 'ParentNotFound' | 'Invalid'; reason: string }
+  >
+}
+
+export interface AuthPort {
+  /** Ends the caller's session. */
+  signOut(principal: Principal): Promise<void>
+}
+
+export interface ManagementApiDeps {
+  server: ServerPort
+  manifests: ManifestPort
+  localization: LocalizationPort
+  currentUser: CurrentUserPort
+  users?: UserItemPort
+  preview?: PreviewPort
+  temporaryFiles?: TemporaryFilePort
+  media?: MediaPort
+  tags?: TagPort
+  oembed?: OEmbedPort
+  blueprints?: BlueprintPort
+  contentTypes?: ContentTypePort
+  mediaTypes?: ContentTypePort
+  memberTypes?: ContentTypePort
+  dataTypes?: DataTypePort
+  templates?: TemplatePort
+  documents?: DocumentPort
+  dictionary?: DictionaryPort
+  userManagement?: UserPort
+  userGroups?: UserGroupPort
+  userData?: UserDataPort
+  /** The site's `components/` tree: one root, folders and all. */
+  components?: FileSystemPort
+  componentSnippets?: readonly Snippet[]
+  stylesheets?: FileSystemPort
+  scripts?: FileSystemPort
+  logViewer?: LogViewerPort
+  modelsBuilder?: ModelsBuilderPort
+  publishedCache?: PublishedCachePort
+  /** The template editor's query builder. */
+  templateQuery?: TemplateQueryPort
+  memberGroups?: MemberGroupPort
+  members?: MemberPort
+  publicAccess?: PublicAccessPort
+  elements?: ElementPort
+  references?: ReferencePort
+  redirects?: RedirectPort
+  packages?: PackagePort
+}