@yunsoft/yuncms-core 0.1.0

package/src/services/relations-service.js

@@ -0,0 +1,455 @@
+import { createHash } from 'node:crypto';
+
+import { withAdvisoryLock } from '../advisory-lock.js';
+import { compileFieldColumn } from '../field-types.js';
+import { assertIdentifier, quoteIdentifier } from '../identifier.js';
+import { SchemaMetadataRepository } from '../schema-metadata-repository.js';
+import { incrementSchemaVersion } from '../schema-version.js';
+import { withConnectionTransaction } from '../transaction.js';
+import { BaseService } from './base-service.js';
+import { assertSchemaManager } from './schema-access.js';
+
+const ON_DELETE_ACTIONS = new Set(['RESTRICT', 'CASCADE', 'SET NULL']);
+
+function constraintName(manyCollection, manyField, oneCollection) {
+  const digest = createHash('sha256')
+    .update(`${manyCollection}:${manyField}:${oneCollection}`)
+    .digest('hex')
+    .slice(0, 24);
+  return `yfk_${digest}`;
+}
+
+function assertOnDelete(value) {
+  const action = String(value ?? 'RESTRICT').toUpperCase();
+  if (!ON_DELETE_ACTIONS.has(action)) {
+    const error = new Error(`Unsupported ON DELETE action: ${action}`);
+    error.code = 'INVALID_ON_DELETE';
+    throw error;
+  }
+  return action;
+}
+
+function assertUserSchemaIdentifier(value, label) {
+  const identifier = assertIdentifier(value, label);
+  if (identifier.length > 64) {
+    const error = new Error(`${label} cannot exceed 64 characters`);
+    error.code = 'INVALID_SCHEMA_PAYLOAD';
+    throw error;
+  }
+  if (identifier.toLowerCase().startsWith('yuncms_')) {
+    const error = new Error(`The yuncms_ prefix is reserved: ${identifier}`);
+    error.code = 'RESERVED_COLLECTION_NAME';
+    throw error;
+  }
+  return identifier;
+}
+
+function parseRelationMetadata(value) {
+  if (value == null) return {};
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+
+function parseSchemaMetadata(value) {
+  if (value == null) return {};
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+
+function fieldDefinitionFromMetadata(field, { required = true } = {}) {
+  const schema = parseSchemaMetadata(field.schema_metadata);
+  const input = { type: field.type, required };
+  if (field.type === 'string' && schema.length !== undefined) input.length = schema.length;
+  if (field.type === 'decimal') {
+    if (schema.precision !== undefined) input.precision = schema.precision;
+    if (schema.scale !== undefined) input.scale = schema.scale;
+  }
+  return compileFieldColumn(input);
+}
+
+export class RelationsService extends BaseService {
+  async readMany() {
+    assertSchemaManager(this.accountability);
+    return new SchemaMetadataRepository(this.database).listRelations();
+  }
+
+  async readOne(manyCollection, manyField) {
+    assertSchemaManager(this.accountability);
+    assertIdentifier(manyCollection, 'collection name');
+    assertIdentifier(manyField, 'field name');
+    return new SchemaMetadataRepository(this.database).readRelation(manyCollection, manyField);
+  }
+
+  async readO2M(oneCollection) {
+    assertSchemaManager(this.accountability);
+    assertIdentifier(oneCollection, 'one collection');
+    return new SchemaMetadataRepository(this.database).listRelationsForOne(oneCollection);
+  }
+
+  async createM2O(input = {}) {
+    assertSchemaManager(this.accountability);
+    const manyCollection = assertIdentifier(input.manyCollection, 'many collection');
+    const manyField = assertIdentifier(input.manyField, 'many field');
+    const oneCollection = assertIdentifier(input.oneCollection, 'one collection');
+    const onDelete = assertOnDelete(input.onDelete);
+
+    return withAdvisoryLock(this.database, 'yuncms:schema', async (connection) => {
+      const metadata = new SchemaMetadataRepository(connection);
+      const [manyCollectionMetadata, oneCollectionMetadata] = await Promise.all([
+        metadata.readCollection(manyCollection),
+        metadata.readCollection(oneCollection),
+      ]);
+
+      if (!manyCollectionMetadata || !oneCollectionMetadata) {
+        const error = new Error('Both relation collections must exist');
+        error.code = 'COLLECTION_NOT_FOUND';
+        throw error;
+      }
+      if (manyCollectionMetadata.system || oneCollectionMetadata.system) {
+        const error = new Error('System collections cannot be changed through the dynamic relation API');
+        error.code = 'SYSTEM_SCHEMA_READ_ONLY';
+        throw error;
+      }
+
+      const oneField = input.oneField ?? oneCollectionMetadata.primary_key;
+      assertIdentifier(oneField, 'one field');
+      if (oneField !== oneCollectionMetadata.primary_key) {
+        const error = new Error('V1 M2O relations must reference the target collection primary key');
+        error.code = 'UNSUPPORTED_RELATION_TARGET';
+        throw error;
+      }
+
+      const [manyFieldMetadata, oneFieldMetadata, existingRelation] = await Promise.all([
+        metadata.readField(manyCollection, manyField),
+        metadata.readField(oneCollection, oneField),
+        metadata.readRelation(manyCollection, manyField),
+      ]);
+
+      if (!manyFieldMetadata || !oneFieldMetadata) {
+        const error = new Error('Both relation fields must exist in schema metadata');
+        error.code = 'FIELD_NOT_FOUND';
+        throw error;
+      }
+      if (existingRelation) {
+        const error = new Error(`Relation already exists for ${manyCollection}.${manyField}`);
+        error.code = 'RELATION_EXISTS';
+        throw error;
+      }
+      if (manyFieldMetadata.type !== oneFieldMetadata.type) {
+        const error = new Error(
+          `Relation field types do not match: ${manyFieldMetadata.type} -> ${oneFieldMetadata.type}`,
+        );
+        error.code = 'RELATION_TYPE_MISMATCH';
+        throw error;
+      }
+      if (onDelete === 'SET NULL' && Boolean(manyFieldMetadata.required)) {
+        const error = new Error('SET NULL cannot be used with a required relation field');
+        error.code = 'INVALID_ON_DELETE';
+        throw error;
+      }
+
+      const fkName = constraintName(manyCollection, manyField, oneCollection);
+      const manyTableSql = quoteIdentifier(manyCollection, 'many collection');
+      const manyFieldSql = quoteIdentifier(manyField, 'many field');
+      const oneTableSql = quoteIdentifier(oneCollection, 'one collection');
+      const oneFieldSql = quoteIdentifier(oneField, 'one field');
+      const constraintSql = quoteIdentifier(fkName, 'constraint name');
+      let physicalRelationCreated = false;
+
+      try {
+        await connection.query(
+          `ALTER TABLE ${manyTableSql}
+           ADD CONSTRAINT ${constraintSql}
+           FOREIGN KEY (${manyFieldSql}) REFERENCES ${oneTableSql} (${oneFieldSql})
+           ON DELETE ${onDelete}`,
+        );
+        physicalRelationCreated = true;
+
+        return await withConnectionTransaction(connection, async () => {
+          const created = await metadata.createRelation({
+            manyCollection,
+            manyField,
+            oneCollection,
+            oneField,
+            onDelete,
+            metadata: { constraintName: fkName, kind: 'm2o' },
+          });
+
+          const schemaVersion = await incrementSchemaVersion(connection);
+          return { ...created, schemaVersion };
+        });
+      } catch (error) {
+        const cleanupErrors = [];
+
+        try {
+          await metadata.deleteRelation(manyCollection, manyField);
+        } catch (cleanupError) {
+          cleanupErrors.push(cleanupError);
+        }
+
+        if (physicalRelationCreated) {
+          try {
+            await connection.query(
+              `ALTER TABLE ${manyTableSql} DROP FOREIGN KEY ${constraintSql}`,
+            );
+          } catch (cleanupError) {
+            cleanupErrors.push(cleanupError);
+          }
+        }
+
+        if (cleanupErrors.length > 0) {
+          error.cleanupErrors = cleanupErrors;
+          error.code ||= 'SCHEMA_PARTIAL_FAILURE';
+        }
+        throw error;
+      }
+    });
+  }
+
+  async createM2M(input = {}) {
+    assertSchemaManager(this.accountability);
+    const junctionCollection = assertUserSchemaIdentifier(input.junctionCollection, 'junction collection');
+    const leftCollection = assertIdentifier(input.leftCollection, 'left collection');
+    const rightCollection = assertIdentifier(input.rightCollection, 'right collection');
+    const leftField = assertUserSchemaIdentifier(input.leftField ?? `${leftCollection}_id`, 'left junction field');
+    const rightField = assertUserSchemaIdentifier(input.rightField ?? `${rightCollection}_id`, 'right junction field');
+    if (leftField === rightField) {
+      const error = new Error('M2M junction fields must be distinct; provide explicit leftField/rightField names');
+      error.code = 'INVALID_SCHEMA_PAYLOAD';
+      throw error;
+    }
+
+    const leftOnDelete = assertOnDelete(input.leftOnDelete ?? 'CASCADE');
+    const rightOnDelete = assertOnDelete(input.rightOnDelete ?? 'CASCADE');
+    if (leftOnDelete === 'SET NULL' || rightOnDelete === 'SET NULL') {
+      const error = new Error('M2M junction fields are required; SET NULL is not supported');
+      error.code = 'INVALID_ON_DELETE';
+      throw error;
+    }
+
+    return withAdvisoryLock(this.database, 'yuncms:schema', async (connection) => {
+      const metadata = new SchemaMetadataRepository(connection);
+      const [junctionExisting, leftMetadata, rightMetadata] = await Promise.all([
+        metadata.readCollection(junctionCollection),
+        metadata.readCollection(leftCollection),
+        metadata.readCollection(rightCollection),
+      ]);
+      if (junctionExisting) {
+        const error = new Error(`Junction collection already exists: ${junctionCollection}`);
+        error.code = 'COLLECTION_EXISTS';
+        throw error;
+      }
+      if (!leftMetadata || !rightMetadata) {
+        const error = new Error('Both M2M target collections must exist');
+        error.code = 'COLLECTION_NOT_FOUND';
+        throw error;
+      }
+      if (leftMetadata.system || rightMetadata.system) {
+        const error = new Error('System collections cannot participate in dynamic M2M creation');
+        error.code = 'SYSTEM_SCHEMA_READ_ONLY';
+        throw error;
+      }
+
+      const leftPrimaryKey = leftMetadata.primary_key;
+      const rightPrimaryKey = rightMetadata.primary_key;
+      const [leftPk, rightPk] = await Promise.all([
+        metadata.readField(leftCollection, leftPrimaryKey),
+        metadata.readField(rightCollection, rightPrimaryKey),
+      ]);
+      if (!leftPk || !rightPk) {
+        const error = new Error('M2M target primary-key metadata is missing');
+        error.code = 'SCHEMA_METADATA_DRIFT';
+        throw error;
+      }
+
+      const leftColumn = fieldDefinitionFromMetadata(leftPk, { required: true });
+      const rightColumn = fieldDefinitionFromMetadata(rightPk, { required: true });
+      const junctionSql = quoteIdentifier(junctionCollection, 'junction collection');
+      const leftFieldSql = quoteIdentifier(leftField, 'left junction field');
+      const rightFieldSql = quoteIdentifier(rightField, 'right junction field');
+      const leftCollectionSql = quoteIdentifier(leftCollection, 'left collection');
+      const rightCollectionSql = quoteIdentifier(rightCollection, 'right collection');
+      const leftPkSql = quoteIdentifier(leftPrimaryKey, 'left primary key');
+      const rightPkSql = quoteIdentifier(rightPrimaryKey, 'right primary key');
+      const leftFk = constraintName(junctionCollection, leftField, leftCollection);
+      const rightFk = constraintName(junctionCollection, rightField, rightCollection);
+      const leftFkSql = quoteIdentifier(leftFk, 'left foreign key');
+      const rightFkSql = quoteIdentifier(rightFk, 'right foreign key');
+      const uniqueName = quoteIdentifier(
+        `yuq_${createHash('sha256').update(`${junctionCollection}:${leftField}:${rightField}`).digest('hex').slice(0, 24)}`,
+        'junction unique index',
+      );
+      let tableCreated = false;
+
+      try {
+        await connection.query(
+          `CREATE TABLE ${junctionSql} (
+            id CHAR(36) NOT NULL PRIMARY KEY,
+            ${leftFieldSql} ${leftColumn.sql},
+            ${rightFieldSql} ${rightColumn.sql},
+            CONSTRAINT ${leftFkSql} FOREIGN KEY (${leftFieldSql})
+              REFERENCES ${leftCollectionSql} (${leftPkSql}) ON DELETE ${leftOnDelete},
+            CONSTRAINT ${rightFkSql} FOREIGN KEY (${rightFieldSql})
+              REFERENCES ${rightCollectionSql} (${rightPkSql}) ON DELETE ${rightOnDelete},
+            UNIQUE KEY ${uniqueName} (${leftFieldSql}, ${rightFieldSql})
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
+          [...leftColumn.params, ...rightColumn.params],
+        );
+        tableCreated = true;
+
+        return await withConnectionTransaction(connection, async () => {
+          await metadata.createCollection({
+            collection: junctionCollection,
+            primaryKey: 'id',
+            hidden: input.hidden !== false,
+            note: input.note ?? `M2M junction: ${leftCollection} <-> ${rightCollection}`,
+            metadata: {
+              junction: true,
+              leftCollection,
+              rightCollection,
+            },
+          });
+          await metadata.createField({
+            collection: junctionCollection,
+            field: 'id',
+            type: 'uuid',
+            required: true,
+            readonly: true,
+            interface: 'input',
+            schemaMetadata: { primaryKey: true, length: 36 },
+          });
+          await metadata.createField({
+            collection: junctionCollection,
+            field: leftField,
+            type: leftPk.type,
+            required: true,
+            interface: 'relation-m2o',
+            schemaMetadata: leftColumn.schemaMetadata,
+          });
+          await metadata.createField({
+            collection: junctionCollection,
+            field: rightField,
+            type: rightPk.type,
+            required: true,
+            interface: 'relation-m2o',
+            schemaMetadata: rightColumn.schemaMetadata,
+          });
+
+          const leftRelation = await metadata.createRelation({
+            manyCollection: junctionCollection,
+            manyField: leftField,
+            oneCollection: leftCollection,
+            oneField: leftPrimaryKey,
+            junctionCollection,
+            junctionField: rightField,
+            onDelete: leftOnDelete,
+            metadata: { constraintName: leftFk, kind: 'm2m', side: 'left' },
+          });
+          const rightRelation = await metadata.createRelation({
+            manyCollection: junctionCollection,
+            manyField: rightField,
+            oneCollection: rightCollection,
+            oneField: rightPrimaryKey,
+            junctionCollection,
+            junctionField: leftField,
+            onDelete: rightOnDelete,
+            metadata: { constraintName: rightFk, kind: 'm2m', side: 'right' },
+          });
+
+          const schemaVersion = await incrementSchemaVersion(connection);
+          return {
+            junctionCollection,
+            leftField,
+            rightField,
+            leftRelation,
+            rightRelation,
+            schemaVersion,
+          };
+        });
+      } catch (error) {
+        const cleanupErrors = [];
+        try {
+          await metadata.deleteRelation(junctionCollection, leftField);
+          await metadata.deleteRelation(junctionCollection, rightField);
+          await metadata.deleteCollection(junctionCollection);
+        } catch (cleanupError) {
+          cleanupErrors.push(cleanupError);
+        }
+        if (tableCreated) {
+          try {
+            await connection.query(`DROP TABLE IF EXISTS ${junctionSql}`);
+          } catch (cleanupError) {
+            cleanupErrors.push(cleanupError);
+          }
+        }
+        if (cleanupErrors.length > 0) {
+          error.cleanupErrors = cleanupErrors;
+          error.code ||= 'SCHEMA_PARTIAL_FAILURE';
+        }
+        throw error;
+      }
+    });
+  }
+
+  async deleteM2O(manyCollection, manyField) {
+    assertSchemaManager(this.accountability);
+    assertIdentifier(manyCollection, 'many collection');
+    assertIdentifier(manyField, 'many field');
+
+    return withAdvisoryLock(this.database, 'yuncms:schema', async (connection) => {
+      const metadata = new SchemaMetadataRepository(connection);
+      const relation = await metadata.readRelation(manyCollection, manyField);
+      if (!relation) {
+        const error = new Error(`Unknown relation: ${manyCollection}.${manyField}`);
+        error.code = 'RELATION_NOT_FOUND';
+        throw error;
+      }
+
+      const relationMetadata = parseRelationMetadata(relation.metadata);
+      const fkName = relationMetadata.constraintName
+        ?? constraintName(relation.many_collection, relation.many_field, relation.one_collection);
+      const manyTableSql = quoteIdentifier(relation.many_collection, 'many collection');
+      const manyFieldSql = quoteIdentifier(relation.many_field, 'many field');
+      const oneTableSql = quoteIdentifier(relation.one_collection, 'one collection');
+      const oneFieldSql = quoteIdentifier(relation.one_field, 'one field');
+      const constraintSql = quoteIdentifier(fkName, 'constraint name');
+      const onDelete = assertOnDelete(relation.on_delete);
+
+      await connection.query(`ALTER TABLE ${manyTableSql} DROP FOREIGN KEY ${constraintSql}`);
+
+      try {
+        return await withConnectionTransaction(connection, async () => {
+          const deleted = await metadata.deleteRelation(manyCollection, manyField);
+          if (deleted !== 1) {
+            const error = new Error(`Relation metadata disappeared during delete: ${manyCollection}.${manyField}`);
+            error.code = 'SCHEMA_METADATA_DRIFT';
+            throw error;
+          }
+          const schemaVersion = await incrementSchemaVersion(connection);
+          return { deleted: true, schemaVersion };
+        });
+      } catch (error) {
+        try {
+          await connection.query(
+            `ALTER TABLE ${manyTableSql}
+             ADD CONSTRAINT ${constraintSql}
+             FOREIGN KEY (${manyFieldSql}) REFERENCES ${oneTableSql} (${oneFieldSql})
+             ON DELETE ${onDelete}`,
+          );
+        } catch (restoreError) {
+          error.restoreError = restoreError;
+          error.code ||= 'SCHEMA_PARTIAL_FAILURE';
+        }
+        throw error;
+      }
+    });
+  }
+}

package/src/services/roles-service.js

@@ -0,0 +1,160 @@
+import { randomUUID } from 'node:crypto';
+
+import { BaseService } from './base-service.js';
+
+function assertRoleManager(accountability) {
+  if (accountability.admin === true || accountability.system === true) return;
+  const error = new Error('Role management requires administrator accountability');
+  error.code = 'FORBIDDEN';
+  throw error;
+}
+
+function normalizeRoleName(name) {
+  if (!name || typeof name !== 'string' || name.trim().length === 0) {
+    const error = new Error('Role name is required');
+    error.code = 'INVALID_PAYLOAD';
+    throw error;
+  }
+  const normalized = name.trim();
+  if (normalized.length > 100) {
+    const error = new Error('Role name cannot exceed 100 characters');
+    error.code = 'INVALID_PAYLOAD';
+    throw error;
+  }
+  return normalized;
+}
+
+export class RolesService extends BaseService {
+  async readMany() {
+    assertRoleManager(this.accountability);
+    const [rows] = await this.database.query(
+      `SELECT id, name, description, admin, public, created_at, updated_at
+       FROM yuncms_roles
+       ORDER BY name ASC`,
+    );
+    return rows;
+  }
+
+  async readOne(id) {
+    assertRoleManager(this.accountability);
+    const [rows] = await this.database.query(
+      `SELECT id, name, description, admin, public, created_at, updated_at
+       FROM yuncms_roles
+       WHERE id = ?
+       LIMIT 1`,
+      [id],
+    );
+    return rows[0] ?? null;
+  }
+
+  async createOne(input = {}) {
+    assertRoleManager(this.accountability);
+    const name = normalizeRoleName(input.name);
+
+    const admin = input.admin === true;
+    const publicRole = input.public === true;
+    if (admin && publicRole) {
+      const error = new Error('A role cannot be both administrator and public');
+      error.code = 'INVALID_ROLE';
+      throw error;
+    }
+
+    if (publicRole) {
+      const [rows] = await this.database.query(
+        'SELECT id FROM yuncms_roles WHERE public = 1 LIMIT 1',
+      );
+      if (rows[0]) {
+        const error = new Error('A public role already exists');
+        error.code = 'PUBLIC_ROLE_EXISTS';
+        throw error;
+      }
+    }
+
+    const id = randomUUID();
+    await this.database.query(
+      `INSERT INTO yuncms_roles (id, name, description, admin, public)
+       VALUES (?, ?, ?, ?, ?)`,
+      [
+        id,
+        name,
+        input.description ?? null,
+        admin ? 1 : 0,
+        publicRole ? 1 : 0,
+      ],
+    );
+    return this.readOne(id);
+  }
+
+  async updateOne(id, patch = {}) {
+    assertRoleManager(this.accountability);
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+      const error = new Error('Role patch must be an object');
+      error.code = 'INVALID_PAYLOAD';
+      throw error;
+    }
+    const keys = Object.keys(patch);
+    if (keys.length === 0 || keys.some((key) => !['name', 'description'].includes(key))) {
+      const error = new Error('Role update supports name and description only in V1');
+      error.code = 'INVALID_PAYLOAD';
+      throw error;
+    }
+
+    const existing = await this.readOne(id);
+    if (!existing) {
+      const error = new Error(`Unknown role: ${id}`);
+      error.code = 'ROLE_NOT_FOUND';
+      throw error;
+    }
+
+    const assignments = [];
+    const params = [];
+    if (Object.hasOwn(patch, 'name')) {
+      assignments.push('name = ?');
+      params.push(normalizeRoleName(patch.name));
+    }
+    if (Object.hasOwn(patch, 'description')) {
+      assignments.push('description = ?');
+      params.push(patch.description ?? null);
+    }
+    params.push(id);
+
+    await this.database.query(
+      `UPDATE yuncms_roles SET ${assignments.join(', ')} WHERE id = ?`,
+      params,
+    );
+    return this.readOne(id);
+  }
+
+  async deleteOne(id) {
+    assertRoleManager(this.accountability);
+    const role = await this.readOne(id);
+    if (!role) {
+      const error = new Error(`Unknown role: ${id}`);
+      error.code = 'ROLE_NOT_FOUND';
+      throw error;
+    }
+    if (Boolean(role.admin) || Boolean(role.public)) {
+      const error = new Error('Administrator and public roles cannot be deleted through the V1 role API');
+      error.code = 'PROTECTED_ROLE';
+      throw error;
+    }
+
+    const [users] = await this.database.query(
+      'SELECT id FROM yuncms_users WHERE role = ? LIMIT 1',
+      [id],
+    );
+    if (users[0]) {
+      const error = new Error('Role cannot be deleted while users are assigned to it');
+      error.code = 'ROLE_IN_USE';
+      throw error;
+    }
+
+    const [result] = await this.database.query('DELETE FROM yuncms_roles WHERE id = ?', [id]);
+    if (result.affectedRows !== 1) {
+      const error = new Error(`Unknown role: ${id}`);
+      error.code = 'ROLE_NOT_FOUND';
+      throw error;
+    }
+    return true;
+  }
+}

package/src/services/schema-access.js

@@ -0,0 +1,7 @@
+export function assertSchemaManager(accountability) {
+  if (accountability?.admin === true || accountability?.system === true) return;
+
+  const error = new Error('Schema management requires administrator accountability');
+  error.code = 'FORBIDDEN';
+  throw error;
+}

package/src/services/service-registry.js

@@ -0,0 +1,32 @@
+export function createServiceRegistry(initialServices = {}) {
+  const services = new Map();
+
+  for (const [name, Service] of Object.entries(initialServices)) {
+    register(name, Service);
+  }
+
+  function register(name, Service) {
+    if (!name || typeof name !== 'string') throw new Error('Service name is required');
+    if (typeof Service !== 'function') throw new Error(`Service ${name} must be a constructor`);
+    if (services.has(name)) throw new Error(`Service ${name} is already registered`);
+
+    services.set(name, Service);
+    return Service;
+  }
+
+  function get(name) {
+    const Service = services.get(name);
+    if (!Service) throw new Error(`Unknown service: ${name}`);
+    return Service;
+  }
+
+  function has(name) {
+    return services.has(name);
+  }
+
+  function toObject() {
+    return Object.freeze(Object.fromEntries(services.entries()));
+  }
+
+  return Object.freeze({ register, get, has, toObject });
+}