@jskit-ai/users-core 0.1.4

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -0,0 +1,67 @@
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import {
+  WORKSPACE_SETTINGS_CHANGED_EVENT
+} from "../../shared/events/usersEvents.js";
+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 { USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN } from "../common/diTokens.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("workspaceSettingsRepository", (scope) => {
+    const knex = scope.make(KERNEL_TOKENS.Knex);
+    const appConfig = resolveAppConfig(scope);
+    return createWorkspaceSettingsRepository(knex, {
+      defaultInvitesEnabled: resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig)
+    });
+  });
+
+  app.service(
+    "users.workspace.settings.service",
+    (scope) =>
+      createWorkspaceSettingsService({
+        workspaceSettingsRepository: scope.make("workspaceSettingsRepository"),
+        workspaceInvitationsEnabled: scope.make(USERS_WORKSPACE_INVITATIONS_ENABLED_TOKEN),
+        roleCatalog: createWorkspaceRoleCatalog(resolveAppConfig(scope))
+      }),
+    {
+      events: deepFreeze({
+        updateWorkspaceSettings: createWorkspaceEntityAndBootstrapEvents({
+          workspaceEntity: "settings",
+          workspaceOperation: "updated",
+          workspaceRealtimeEvent: WORKSPACE_SETTINGS_CHANGED_EVENT
+        })
+      })
+    }
+  );
+
+  app.actions(
+    withActionDefaults(workspaceSettingsActions, {
+      domain: "workspace",
+      dependencies: {
+        workspaceSettingsService: "users.workspace.settings.service"
+      }
+    })
+  );
+}
+
+export { registerWorkspaceSettings };

package/src/server/workspaceSettings/workspaceSettingsActions.js

@@ -0,0 +1,72 @@
+import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
+import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
+import { resolveWorkspace } from "../support/resolveWorkspace.js";
+
+const workspaceSettingsActions = Object.freeze([
+  {
+    id: "workspace.settings.read",
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "any",
+      permissions: ["workspace.settings.view", "workspace.settings.update"]
+    },
+    inputValidator: workspaceSlugParamsValidator,
+    outputValidator: workspaceSettingsResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: "workspace.settings.read"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      const response = await deps.workspaceSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
+        context
+      });
+
+      return response;
+    }
+  },
+  {
+    id: "workspace.settings.update",
+    version: 1,
+    kind: "command",
+    channels: ["api", "assistant_tool", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "all",
+      permissions: ["workspace.settings.update"]
+    },
+    inputValidator: [
+      workspaceSlugParamsValidator,
+      {
+        patch: workspaceSettingsResource.operations.patch.bodyValidator
+      }
+    ],
+    outputValidator: workspaceSettingsResource.operations.patch.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: "workspace.settings.update"
+    },
+    observability: {},
+    extensions: {
+      assistant: {
+        description: "Update workspace settings."
+      }
+    },
+    async execute(input, context, deps) {
+      const response = await deps.workspaceSettingsService.updateWorkspaceSettings(
+        resolveWorkspace(context, input),
+        input.patch,
+        {
+          context
+        }
+      );
+
+      return response;
+    }
+  }
+]);
+
+export { workspaceSettingsActions };

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -0,0 +1,135 @@
+import {
+  toIsoString,
+  nowDb,
+  isDuplicateEntryError
+} from "../common/repositories/repositoryUtils.js";
+import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
+import {
+  workspaceSettingsFields,
+  resolveWorkspaceSettingsFieldKeys
+} from "../../shared/resources/workspaceSettingsFields.js";
+
+function resolveWorkspaceSettingsSeed(workspace = {}, { defaultInvitesEnabled = true } = {}) {
+  const source = normalizeObjectInput(workspace);
+  const seed = {};
+  for (const field of workspaceSettingsFields) {
+    const rawValue = Object.hasOwn(source, field.key)
+      ? source[field.key]
+      : field.resolveDefault({
+          workspace: source,
+          defaultInvitesEnabled
+        });
+    seed[field.key] = field.normalizeOutput(rawValue, {
+      workspace: source,
+      defaultInvitesEnabled
+    });
+  }
+  return seed;
+}
+
+function createRepository(knex, { defaultInvitesEnabled } = {}) {
+  if (typeof knex !== "function") {
+    throw new TypeError("workspaceSettingsRepository requires knex.");
+  }
+
+  function mapRow(row) {
+    if (!row) {
+      return null;
+    }
+
+    const settings = {
+      workspaceId: Number(row.workspace_id)
+    };
+    for (const field of workspaceSettingsFields) {
+      const rawValue = Object.hasOwn(row, field.dbColumn)
+        ? row[field.dbColumn]
+        : field.resolveDefault({
+            defaultInvitesEnabled
+          });
+      settings[field.key] = field.normalizeOutput(rawValue, {
+        defaultInvitesEnabled
+      });
+    }
+
+    settings.createdAt = toIsoString(row.created_at);
+    settings.updatedAt = toIsoString(row.updated_at);
+    return settings;
+  }
+
+  async function findByWorkspaceId(workspaceId, options = {}) {
+    const client = options?.trx || knex;
+    const row = await client("workspace_settings").where({ workspace_id: Number(workspaceId) }).first();
+    return mapRow(row);
+  }
+
+  async function ensureForWorkspaceId(workspaceId, options = {}) {
+    const client = options?.trx || knex;
+    const numericWorkspaceId = Number(workspaceId);
+    const seed = resolveWorkspaceSettingsSeed(options?.workspace, {
+      defaultInvitesEnabled
+    });
+    const existing = await findByWorkspaceId(numericWorkspaceId, { trx: client });
+    if (existing) {
+      return existing;
+    }
+
+    try {
+      const insertPayload = {
+        workspace_id: numericWorkspaceId,
+        created_at: nowDb(),
+        updated_at: nowDb()
+      };
+      for (const field of workspaceSettingsFields) {
+        insertPayload[field.dbColumn] = seed[field.key];
+      }
+      await client("workspace_settings").insert(insertPayload);
+    } catch (error) {
+      if (!isDuplicateEntryError(error)) {
+        throw error;
+      }
+    }
+
+    return findByWorkspaceId(numericWorkspaceId, { trx: client });
+  }
+
+  async function updateSettingsByWorkspaceId(workspaceId, patch = {}, options = {}) {
+    const client = options?.trx || knex;
+    const ensured = await ensureForWorkspaceId(workspaceId, {
+      trx: client,
+      workspace: options?.workspace
+    });
+    const source = normalizeObjectInput(patch);
+    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
+
+    if (Object.keys(settingsPatch).length === 0) {
+      return ensured;
+    }
+
+    const dbPatch = {
+      updated_at: nowDb()
+    };
+
+    for (const field of workspaceSettingsFields) {
+      if (!Object.hasOwn(settingsPatch, field.key)) {
+        continue;
+      }
+      dbPatch[field.dbColumn] = field.normalizeInput(settingsPatch[field.key], {
+        payload: source
+      });
+    }
+
+    await client("workspace_settings").where({ workspace_id: Number(workspaceId) }).update({
+      ...dbPatch
+    });
+    return findByWorkspaceId(workspaceId, { trx: client });
+  }
+
+  return Object.freeze({
+    findByWorkspaceId,
+    ensureForWorkspaceId,
+    updateSettingsByWorkspaceId
+  });
+}
+
+export { createRepository };

package/src/server/workspaceSettings/workspaceSettingsService.js

@@ -0,0 +1,65 @@
+import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
+import {
+  workspaceSettingsFields,
+  resolveWorkspaceSettingsFieldKeys
+} from "../../shared/resources/workspaceSettingsFields.js";
+import { createWorkspaceRoleCatalog, cloneWorkspaceRoleCatalog } from "../../shared/roles.js";
+
+function createService({
+  workspaceSettingsRepository,
+  workspaceInvitationsEnabled = true,
+  roleCatalog = null
+} = {}) {
+  if (!workspaceSettingsRepository) {
+    throw new Error("workspaceSettingsService requires workspaceSettingsRepository.");
+  }
+  const resolvedRoleCatalog = roleCatalog && typeof roleCatalog === "object" ? roleCatalog : createWorkspaceRoleCatalog();
+  const invitesAvailable = workspaceInvitationsEnabled === true;
+
+  async function getWorkspaceSettings(workspace, options = {}) {
+    const settingsRecord = await workspaceSettingsRepository.ensureForWorkspaceId(workspace.id, {
+      ...options,
+      workspace
+    });
+    const settings = {};
+    for (const field of workspaceSettingsFields) {
+      settings[field.key] = settingsRecord[field.key];
+    }
+    const invitesEnabled = invitesAvailable && settings.invitesEnabled !== false;
+    settings.invitesEnabled = invitesEnabled;
+    settings.invitesAvailable = invitesAvailable;
+    settings.invitesEffective = invitesAvailable && invitesEnabled;
+
+    return {
+      workspace: {
+        id: Number(workspace.id),
+        slug: String(workspace.slug || ""),
+        ownerUserId: Number(workspace.ownerUserId)
+      },
+      settings,
+      roleCatalog: cloneWorkspaceRoleCatalog(resolvedRoleCatalog)
+    };
+  }
+
+  async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
+    const source = normalizeObjectInput(payload);
+    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
+
+    if (Object.keys(settingsPatch).length > 0) {
+      await workspaceSettingsRepository.updateSettingsByWorkspaceId(workspace.id, settingsPatch, {
+        ...options,
+        workspace
+      });
+    }
+
+    return getWorkspaceSettings(workspace, options);
+  }
+
+  return Object.freeze({
+    getWorkspaceSettings,
+    updateWorkspaceSettings
+  });
+}
+
+export { createService };

package/src/shared/events/usersEvents.js

@@ -0,0 +1,19 @@
+const ACCOUNT_SETTINGS_CHANGED_EVENT = "account.settings.changed";
+const CONSOLE_SETTINGS_CHANGED_EVENT = "console.settings.changed";
+const USERS_BOOTSTRAP_CHANGED_EVENT = "users.bootstrap.changed";
+const WORKSPACE_SETTINGS_CHANGED_EVENT = "workspace.settings.changed";
+const WORKSPACE_MEMBERS_CHANGED_EVENT = "workspace.members.changed";
+const WORKSPACE_INVITES_CHANGED_EVENT = "workspace.invites.changed";
+const WORKSPACES_CHANGED_EVENT = "workspaces.changed";
+const WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT = "workspace.invitations.pending.changed";
+
+export {
+  ACCOUNT_SETTINGS_CHANGED_EVENT,
+  CONSOLE_SETTINGS_CHANGED_EVENT,
+  USERS_BOOTSTRAP_CHANGED_EVENT,
+  WORKSPACE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_MEMBERS_CHANGED_EVENT,
+  WORKSPACE_INVITES_CHANGED_EVENT,
+  WORKSPACES_CHANGED_EVENT,
+  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT
+};

package/src/shared/index.js

@@ -0,0 +1,91 @@
+import {
+  OWNER_ROLE_ID,
+  ADMIN_ROLE_ID,
+  MEMBER_ROLE_ID,
+  resolveRolePermissions,
+  listRoleDescriptors,
+  hasPermission
+} from "./roles.js";
+
+import {
+  DEFAULT_WORKSPACE_COLOR,
+  DEFAULT_USER_SETTINGS,
+  coerceWorkspaceColor
+} from "./settings.js";
+import {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  normalizeTenancyMode,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspaceTenancyMode
+} from "./tenancyProfile.js";
+import {
+  ACCOUNT_SETTINGS_CHANGED_EVENT,
+  CONSOLE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_MEMBERS_CHANGED_EVENT,
+  WORKSPACE_INVITES_CHANGED_EVENT,
+  WORKSPACES_CHANGED_EVENT,
+  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT
+} from "./events/usersEvents.js";
+
+const USERS_SHARED_API = Object.freeze({
+  OWNER_ROLE_ID,
+  ADMIN_ROLE_ID,
+  MEMBER_ROLE_ID,
+  resolveRolePermissions,
+  listRoleDescriptors,
+  hasPermission,
+  DEFAULT_WORKSPACE_COLOR,
+  DEFAULT_USER_SETTINGS,
+  coerceWorkspaceColor,
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  normalizeTenancyMode,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspaceTenancyMode,
+  ACCOUNT_SETTINGS_CHANGED_EVENT,
+  CONSOLE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_MEMBERS_CHANGED_EVENT,
+  WORKSPACE_INVITES_CHANGED_EVENT,
+  WORKSPACES_CHANGED_EVENT,
+  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT
+});
+
+export {
+  OWNER_ROLE_ID,
+  ADMIN_ROLE_ID,
+  MEMBER_ROLE_ID,
+  resolveRolePermissions,
+  listRoleDescriptors,
+  hasPermission,
+  DEFAULT_WORKSPACE_COLOR,
+  DEFAULT_USER_SETTINGS,
+  coerceWorkspaceColor,
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  normalizeTenancyMode,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspaceTenancyMode,
+  ACCOUNT_SETTINGS_CHANGED_EVENT,
+  CONSOLE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_SETTINGS_CHANGED_EVENT,
+  WORKSPACE_MEMBERS_CHANGED_EVENT,
+  WORKSPACE_INVITES_CHANGED_EVENT,
+  WORKSPACES_CHANGED_EVENT,
+  WORKSPACE_PENDING_INVITATIONS_CHANGED_EVENT,
+  USERS_SHARED_API
+};

package/src/shared/operationMessages.js

@@ -0,0 +1,16 @@
+function createOperationMessages({
+  validationMessage = "Validation failed.",
+  apiValidationMessage = validationMessage
+} = {}) {
+  const validation = String(validationMessage || "Validation failed.");
+  const apiValidation = String(apiValidationMessage || validation || "Validation failed.");
+
+  return Object.freeze({
+    validation,
+    apiValidation
+  });
+}
+
+export {
+  createOperationMessages
+};

package/src/shared/resources/consoleSettingsFields.js

@@ -0,0 +1,55 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
+
+const CONSOLE_SETTINGS_FIELDS_REGISTRY_KEY = Symbol.for("jskit.users-core.consoleSettingsFields");
+const consoleSettingsFields = resolveGlobalArrayRegistry(CONSOLE_SETTINGS_FIELDS_REGISTRY_KEY);
+
+function defineField(field = {}) {
+  const key = normalizeText(field.key);
+  if (!key) {
+    throw new TypeError("consoleSettingsFields.defineField requires field.key.");
+  }
+  if (consoleSettingsFields.some((entry) => entry.key === key)) {
+    throw new Error(`consoleSettingsFields.defineField duplicate key: ${key}`);
+  }
+  if (!field.inputSchema || typeof field.inputSchema !== "object") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires inputSchema.`);
+  }
+  if (!field.outputSchema || typeof field.outputSchema !== "object") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires outputSchema.`);
+  }
+  const dbColumn = normalizeText(field.dbColumn);
+  if (!dbColumn) {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires dbColumn.`);
+  }
+  if (typeof field.normalizeInput !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeInput.`);
+  }
+  if (typeof field.normalizeOutput !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeOutput.`);
+  }
+  if (typeof field.resolveDefault !== "function") {
+    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires resolveDefault.`);
+  }
+
+  consoleSettingsFields.push({
+    key,
+    dbColumn,
+    required: field.required !== false,
+    inputSchema: field.inputSchema,
+    outputSchema: field.outputSchema,
+    normalizeInput: field.normalizeInput,
+    normalizeOutput: field.normalizeOutput,
+    resolveDefault: field.resolveDefault
+  });
+}
+
+function resetConsoleSettingsFields() {
+  consoleSettingsFields.splice(0, consoleSettingsFields.length);
+}
+
+export {
+  defineField,
+  resetConsoleSettingsFields,
+  consoleSettingsFields
+};

package/src/shared/resources/consoleSettingsResource.js

@@ -0,0 +1,139 @@
+import { Type } from "typebox";
+import { createOperationMessages } from "../operationMessages.js";
+import {
+  createCursorListValidator,
+  normalizeObjectInput
+} from "@jskit-ai/kernel/shared/validators";
+import { consoleSettingsFields } from "./consoleSettingsFields.js";
+
+function buildCreateSchema() {
+  const properties = {};
+  for (const field of consoleSettingsFields) {
+    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
+  }
+  return Type.Object(properties, { additionalProperties: false });
+}
+
+function buildOutputSchema() {
+  const properties = {};
+  for (const field of consoleSettingsFields) {
+    properties[field.key] = field.outputSchema;
+  }
+  return Type.Object(properties, { additionalProperties: false });
+}
+
+function buildConsoleSettingsRecordSchema() {
+  return Type.Object(
+    {
+      settings: buildOutputSchema()
+    },
+    { additionalProperties: false }
+  );
+}
+
+function buildConsoleSettingsCreateSchema() {
+  return buildCreateSchema();
+}
+
+function buildConsoleSettingsReplaceSchema() {
+  return buildConsoleSettingsCreateSchema();
+}
+
+function buildConsoleSettingsPatchSchema() {
+  return Type.Partial(buildConsoleSettingsCreateSchema(), {
+    additionalProperties: false
+  });
+}
+
+function normalizeConsoleSettingsInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+  for (const field of consoleSettingsFields) {
+    if (!Object.hasOwn(source, field.key)) {
+      continue;
+    }
+    normalized[field.key] = field.normalizeInput(source[field.key], {
+      payload: source
+    });
+  }
+  return normalized;
+}
+
+const consoleSettingsOutputValidator = Object.freeze({
+  get schema() {
+    return buildConsoleSettingsRecordSchema();
+  },
+  normalize(payload = {}) {
+    const source = normalizeObjectInput(payload);
+    const settingsSource = normalizeObjectInput(source.settings);
+    const settings = {};
+
+    for (const field of consoleSettingsFields) {
+      const rawValue = Object.hasOwn(settingsSource, field.key)
+        ? settingsSource[field.key]
+        : field.resolveDefault({
+            settings: settingsSource
+          });
+      settings[field.key] = field.normalizeOutput(rawValue, {
+        settings: settingsSource
+      });
+    }
+
+    return {
+      settings
+    };
+  }
+});
+
+const CONSOLE_SETTINGS_OPERATION_MESSAGES = createOperationMessages();
+
+const consoleSettingsResource = Object.freeze({
+  resource: "consoleSettings",
+  operations: Object.freeze({
+    view: Object.freeze({
+      method: "GET",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    list: Object.freeze({
+      method: "GET",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      outputValidator: createCursorListValidator(consoleSettingsOutputValidator)
+    }),
+    create: Object.freeze({
+      method: "POST",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsCreateSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    replace: Object.freeze({
+      method: "PUT",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsReplaceSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    }),
+    patch: Object.freeze({
+      method: "PATCH",
+      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
+      bodyValidator: Object.freeze({
+        get schema() {
+          return buildConsoleSettingsPatchSchema();
+        },
+        normalize: normalizeConsoleSettingsInput
+      }),
+      outputValidator: consoleSettingsOutputValidator
+    })
+  })
+});
+
+export { consoleSettingsResource };

package/src/shared/resources/resolveGlobalArrayRegistry.js

@@ -0,0 +1,6 @@
+function resolveGlobalArrayRegistry(symbolKey) {
+  globalThis[symbolKey] = Array.isArray(globalThis[symbolKey]) ? globalThis[symbolKey] : [];
+  return globalThis[symbolKey];
+}
+
+export { resolveGlobalArrayRegistry };