@omen.foundation/node-microservice-runtime 0.1.75 → 0.1.77

package/dist/decorators.cjs

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Microservice = Microservice;
+exports.Callable = Callable;
+exports.listRegisteredServices = listRegisteredServices;
+exports.getServiceOptions = getServiceOptions;
+exports.ClientCallable = ClientCallable;
+exports.ServerCallable = ServerCallable;
+exports.AdminCallable = AdminCallable;
+exports.SwaggerCategory = SwaggerCategory;
+exports.SwaggerTags = SwaggerTags;
+exports.configureServices = configureServices;
+exports.initializeServices = initializeServices;
+exports.ConfigureServices = ConfigureServices;
+exports.InitializeServices = InitializeServices;
+exports.getConfigureServicesHandlers = getConfigureServicesHandlers;
+exports.getInitializeServicesHandlers = getInitializeServicesHandlers;
+require("reflect-metadata");
+const SERVICE_METADATA = new Map();
+const PENDING_REGISTRATIONS = new Map();
+const SWAGGER_TAGS_METADATA_KEY = Symbol('beamable:swaggerTags');
+const CONFIGURE_SERVICES_METADATA = new Map();
+const INITIALIZE_SERVICES_METADATA = new Map();
+function Microservice(name, options = {}) {
+    if (!name || !/^[A-Za-z0-9_]+$/.test(name)) {
+        throw new Error(`Invalid microservice name "${name}". Only alphanumeric and underscore characters are allowed.`);
+    }
+    return function decorator(ctor) {
+        const qualifiedName = `micro_${name}`;
+        const entry = {
+            name,
+            qualifiedName,
+            ctor,
+            callables: new Map(),
+            options,
+        };
+        SERVICE_METADATA.set(ctor, entry);
+        const pending = PENDING_REGISTRATIONS.get(ctor);
+        if (pending) {
+            pending.forEach((fn) => fn(entry));
+            PENDING_REGISTRATIONS.delete(ctor);
+        }
+    };
+}
+function Callable(options = {}) {
+    return function decorator(target, propertyKey, _descriptor) {
+        var _a;
+        let ctorCandidate;
+        if (typeof target === 'function') {
+            ctorCandidate = target;
+        }
+        else if (target !== null && typeof target === 'object') {
+            const obj = target;
+            ctorCandidate = obj.constructor;
+        }
+        if (typeof ctorCandidate !== 'function') {
+            throw new Error('@Callable can only be applied to methods on a class.');
+        }
+        const ctor = ctorCandidate;
+        const metadataTarget = typeof target === 'function'
+            ? target
+            : target !== null && typeof target === 'object'
+                ? target
+                : undefined;
+        if (!metadataTarget) {
+            throw new Error('@Callable decorator received an invalid target.');
+        }
+        const meta = SERVICE_METADATA.get(ctor);
+        if (!meta) {
+            const queue = (_a = PENDING_REGISTRATIONS.get(ctor)) !== null && _a !== void 0 ? _a : [];
+            queue.push((lateMeta) => registerCallable(lateMeta, propertyKey, options, metadataTarget));
+            PENDING_REGISTRATIONS.set(ctor, queue);
+            return;
+        }
+        registerCallable(meta, propertyKey, options, metadataTarget);
+    };
+}
+function registerCallable(meta, propertyKey, options, metadataTarget) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const access = (_a = options.access) !== null && _a !== void 0 ? _a : 'public';
+    const paramTypes = Reflect.getMetadata('design:paramtypes', metadataTarget, propertyKey);
+    const route = (_b = options.route) !== null && _b !== void 0 ? _b : propertyKey;
+    const decoratorTags = (_c = Reflect.getMetadata(SWAGGER_TAGS_METADATA_KEY, metadataTarget, propertyKey)) !== null && _c !== void 0 ? _c : [];
+    const combinedTags = (_d = options.tags) !== null && _d !== void 0 ? _d : decoratorTags;
+    const tags = Array.from(new Set(combinedTags !== null && combinedTags !== void 0 ? combinedTags : []));
+    const metadata = {
+        route,
+        displayName: propertyKey,
+        requireAuth: (_e = options.requireAuth) !== null && _e !== void 0 ? _e : access !== 'public',
+        requiredScopes: (_f = options.requiredScopes) !== null && _f !== void 0 ? _f : defaultScopesForAccess(access),
+        useLegacySerialization: (_h = (_g = options.useLegacySerialization) !== null && _g !== void 0 ? _g : meta.options.useLegacySerialization) !== null && _h !== void 0 ? _h : false,
+        parameterTypes: paramTypes !== null && paramTypes !== void 0 ? paramTypes : [],
+        access,
+        tags,
+    };
+    const key = route.toLowerCase();
+    if (meta.callables.has(key)) {
+        throw new Error(`Duplicate callable route "${route}" on ${meta.ctor.name}.`);
+    }
+    meta.callables.set(key, metadata);
+}
+function defaultScopesForAccess(access) {
+    switch (access) {
+        case 'admin':
+            return ['admin'];
+        case 'server':
+            return ['server'];
+        default:
+            return [];
+    }
+}
+function listRegisteredServices() {
+    return Array.from(SERVICE_METADATA.values()).map((entry) => ({
+        name: entry.name,
+        qualifiedName: entry.qualifiedName,
+        ctor: entry.ctor,
+        callables: new Map(entry.callables),
+        options: entry.options,
+    }));
+}
+function getServiceOptions(ctor) {
+    var _a;
+    return (_a = SERVICE_METADATA.get(ctor)) === null || _a === void 0 ? void 0 : _a.options;
+}
+function ClientCallable(options = {}) {
+    return Callable({ ...options, access: 'client', requireAuth: true });
+}
+function ServerCallable(options = {}) {
+    return Callable({ ...options, access: 'server', requireAuth: true });
+}
+function AdminCallable(options = {}) {
+    return Callable({ ...options, access: 'admin', requireAuth: true });
+}
+function SwaggerCategory(category) {
+    return SwaggerTags(category);
+}
+function SwaggerTags(...tags) {
+    return function decorator(target, propertyKey, _descriptor) {
+        var _a;
+        if (tags.length === 0) {
+            return;
+        }
+        const current = (_a = Reflect.getMetadata(SWAGGER_TAGS_METADATA_KEY, target, propertyKey)) !== null && _a !== void 0 ? _a : [];
+        const merged = Array.from(new Set([...current, ...tags]));
+        Reflect.defineMetadata(SWAGGER_TAGS_METADATA_KEY, merged, target, propertyKey);
+    };
+}
+function configureServices(target) {
+    var _a;
+    return (_a = CONFIGURE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+}
+function initializeServices(target) {
+    var _a;
+    return (_a = INITIALIZE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+}
+function ConfigureServices(target, _propertyKey, descriptor) {
+    var _a;
+    if (typeof descriptor.value !== 'function') {
+        throw new Error('@ConfigureServices can only decorate static methods.');
+    }
+    const handlers = (_a = CONFIGURE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+    handlers.push(descriptor.value.bind(target));
+    CONFIGURE_SERVICES_METADATA.set(target, handlers);
+}
+function InitializeServices(target, _propertyKey, descriptor) {
+    var _a;
+    if (typeof descriptor.value !== 'function') {
+        throw new Error('@InitializeServices can only decorate static methods.');
+    }
+    const handlers = (_a = INITIALIZE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+    handlers.push(descriptor.value.bind(target));
+    INITIALIZE_SERVICES_METADATA.set(target, handlers);
+}
+function getConfigureServicesHandlers(target) {
+    var _a;
+    return (_a = CONFIGURE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+}
+function getInitializeServicesHandlers(target) {
+    var _a;
+    return (_a = INITIALIZE_SERVICES_METADATA.get(target)) !== null && _a !== void 0 ? _a : [];
+}

package/dist/dependency.cjs

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BEAMABLE_SERVICES_TOKEN = exports.REQUEST_CONTEXT_TOKEN = exports.ENVIRONMENT_CONFIG_TOKEN = exports.LOGGER_TOKEN = exports.ServiceProvider = exports.DependencyBuilder = exports.ServiceLifetime = void 0;
+require("reflect-metadata");
+var ServiceLifetime;
+(function (ServiceLifetime) {
+    ServiceLifetime["Singleton"] = "singleton";
+    ServiceLifetime["Scoped"] = "scoped";
+    ServiceLifetime["Transient"] = "transient";
+})(ServiceLifetime || (exports.ServiceLifetime = ServiceLifetime = {}));
+function isConstructor(key) {
+    return typeof key === 'function';
+}
+function instantiate(ctor, scope) {
+    var _a;
+    const paramTypes = (_a = Reflect.getMetadata('design:paramtypes', ctor)) !== null && _a !== void 0 ? _a : [];
+    if (paramTypes.length === 0) {
+        return new ctor();
+    }
+    const dependencies = paramTypes.map((param) => {
+        if (param === Object || param === Array || param === Promise) {
+            throw new Error(`Cannot resolve dependency '${param && param.name ? param.name : String(param)}' for ${ctor.name}. ` +
+                'Use ConfigureServices to register a factory explicitly.');
+        }
+        return scope.resolve(param);
+    });
+    return new ctor(...dependencies);
+}
+class DependencyBuilder {
+    constructor() {
+        this.descriptors = new Map();
+    }
+    addSingleton(key, factory) {
+        return this.addDescriptor(key, ServiceLifetime.Singleton, factory);
+    }
+    addSingletonClass(ctor) {
+        return this.addSingleton(ctor, (scope) => instantiate(ctor, scope));
+    }
+    addSingletonInstance(key, instance) {
+        return this.addSingleton(key, () => instance);
+    }
+    addScoped(key, factory) {
+        return this.addDescriptor(key, ServiceLifetime.Scoped, factory);
+    }
+    addScopedClass(ctor) {
+        return this.addScoped(ctor, (scope) => instantiate(ctor, scope));
+    }
+    addTransient(key, factory) {
+        return this.addDescriptor(key, ServiceLifetime.Transient, factory);
+    }
+    addTransientClass(ctor) {
+        return this.addTransient(ctor, (scope) => instantiate(ctor, scope));
+    }
+    tryAddSingleton(key, factory) {
+        if (!this.descriptors.has(key)) {
+            this.addSingleton(key, factory);
+        }
+        return this;
+    }
+    tryAddSingletonInstance(key, instance) {
+        if (!this.descriptors.has(key)) {
+            this.addSingletonInstance(key, instance);
+        }
+        return this;
+    }
+    build() {
+        return new ServiceProvider(this.descriptors);
+    }
+    addDescriptor(key, lifetime, factory) {
+        if (!key) {
+            throw new Error('Dependency registration requires a non-empty key.');
+        }
+        this.descriptors.set(key, { key, lifetime, factory });
+        return this;
+    }
+}
+exports.DependencyBuilder = DependencyBuilder;
+class ServiceProvider {
+    constructor(descriptors) {
+        this.singletons = new Map();
+        this.descriptors = new Map(descriptors);
+    }
+    resolve(key) {
+        const descriptor = this.descriptors.get(key);
+        if (!descriptor && isConstructor(key)) {
+            const implicitDescriptor = {
+                key,
+                lifetime: ServiceLifetime.Transient,
+                factory: (scope) => instantiate(key, scope),
+            };
+            this.descriptors.set(key, implicitDescriptor);
+            return this.resolve(key);
+        }
+        if (!descriptor) {
+            throw new Error(`No service registered for key '${typeof key === 'symbol' ? key.toString() : String(key)}'.`);
+        }
+        switch (descriptor.lifetime) {
+            case ServiceLifetime.Singleton: {
+                if (!this.singletons.has(descriptor.key)) {
+                    const value = descriptor.factory(this);
+                    this.singletons.set(descriptor.key, value);
+                }
+                return this.singletons.get(descriptor.key);
+            }
+            case ServiceLifetime.Scoped:
+                return descriptor.factory(this);
+            case ServiceLifetime.Transient:
+            default:
+                return descriptor.factory(this);
+        }
+    }
+    createScope() {
+        return new ScopedServiceProvider(this.descriptors, this.singletons, this);
+    }
+}
+exports.ServiceProvider = ServiceProvider;
+class ScopedServiceProvider {
+    constructor(descriptors, rootSingletons, rootProvider) {
+        this.scopedInstances = new Map();
+        this.descriptors = descriptors;
+        this.rootSingletons = rootSingletons;
+        this.rootProvider = rootProvider;
+    }
+    resolve(key) {
+        const descriptor = this.descriptors.get(key);
+        if (!descriptor && isConstructor(key)) {
+            const implicitDescriptor = {
+                key,
+                lifetime: ServiceLifetime.Transient,
+                factory: (scope) => instantiate(key, scope),
+            };
+            this.descriptors.set(key, implicitDescriptor);
+            return this.resolve(key);
+        }
+        if (!descriptor) {
+            throw new Error(`No service registered for key '${typeof key === 'symbol' ? key.toString() : String(key)}'.`);
+        }
+        switch (descriptor.lifetime) {
+            case ServiceLifetime.Singleton: {
+                if (!this.rootSingletons.has(descriptor.key)) {
+                    const value = descriptor.factory(this.rootProvider);
+                    this.rootSingletons.set(descriptor.key, value);
+                }
+                return this.rootSingletons.get(descriptor.key);
+            }
+            case ServiceLifetime.Scoped: {
+                if (!this.scopedInstances.has(descriptor.key)) {
+                    const value = descriptor.factory(this);
+                    this.scopedInstances.set(descriptor.key, value);
+                }
+                return this.scopedInstances.get(descriptor.key);
+            }
+            case ServiceLifetime.Transient:
+            default:
+                return descriptor.factory(this);
+        }
+    }
+    setInstance(key, value) {
+        this.scopedInstances.set(key, value);
+    }
+}
+exports.LOGGER_TOKEN = Symbol('beamable:logger');
+exports.ENVIRONMENT_CONFIG_TOKEN = Symbol('beamable:environment');
+exports.REQUEST_CONTEXT_TOKEN = Symbol('beamable:requestContext');
+exports.BEAMABLE_SERVICES_TOKEN = Symbol('beamable:services');

package/dist/dev.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExampleService = void 0;
+require("dotenv/config");
+const decorators_js_1 = require("./decorators.js");
+const runtime_js_1 = require("./runtime.js");
+let ExampleService = class ExampleService {
+    async echo(ctx, message) {
+        return {
+            message,
+            playerId: ctx.userId,
+        };
+    }
+};
+exports.ExampleService = ExampleService;
+__decorate([
+    (0, decorators_js_1.Callable)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ExampleService.prototype, "echo", null);
+exports.ExampleService = ExampleService = __decorate([
+    (0, decorators_js_1.Microservice)('ExampleNodeService')
+], ExampleService);
+void (0, runtime_js_1.runMicroservice)();

package/dist/discovery.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryBroadcaster = void 0;
+const node_dgram_1 = __importDefault(require("node:dgram"));
+const DISCOVERY_PORT = 8624;
+const BROADCAST_PERIOD_MS = 10;
+class DiscoveryBroadcaster {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.socket = node_dgram_1.default.createSocket('udp4');
+        this.disposed = false;
+        const message = {
+            processId: process.pid,
+            cid: options.env.cid,
+            pid: options.env.pid,
+            prefix: options.routingKey,
+            serviceName: options.serviceName,
+            healthPort: options.env.healthPort,
+            serviceType: 'service',
+            startedByAccountId: (_a = options.env.accountId) !== null && _a !== void 0 ? _a : 0,
+            isContainer: false,
+            dataPort: 0,
+            containerId: '',
+        };
+        this.payload = Buffer.from(JSON.stringify(message), 'utf8');
+        this.socket.on('error', (err) => {
+            options.logger.warn({ err }, 'Discovery broadcaster socket error.');
+        });
+    }
+    async start() {
+        if (this.disposed) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                this.socket.off('error', onError);
+                reject(error);
+            };
+            this.socket.once('error', onError);
+            this.socket.bind(0, undefined, () => {
+                try {
+                    this.socket.setBroadcast(true);
+                    this.socket.off('error', onError);
+                    resolve();
+                }
+                catch (error) {
+                    this.socket.off('error', onError);
+                    reject(error);
+                }
+            });
+        });
+        this.interval = setInterval(() => {
+            this.socket.send(this.payload, DISCOVERY_PORT, '255.255.255.255', (error) => {
+                if (error) {
+                    this.options.logger.debug({ err: error }, 'Discovery broadcast send failed.');
+                }
+            });
+        }, BROADCAST_PERIOD_MS);
+        this.interval.unref();
+    }
+    stop() {
+        this.disposed = true;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        try {
+            this.socket.close();
+        }
+        catch (error) {
+            this.options.logger.debug({ err: error }, 'Error closing discovery broadcaster socket.');
+        }
+    }
+}
+exports.DiscoveryBroadcaster = DiscoveryBroadcaster;

package/dist/docs.cjs

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOpenApiDocument = generateOpenApiDocument;
+const urls_js_1 = require("./utils/urls.js");
+const JSON_CONTENT_TYPE = 'application/json';
+const ADMIN_TAG = 'Administration';
+const SCOPE_SECURITY_SCHEME = {
+    type: 'apiKey',
+    name: 'X-DE-SCOPE',
+    in: 'header',
+    description: "Customer and project scope. This should contain the '<customer-id>.<project-id>'. Required for all microservice calls.",
+};
+const BEAM_SCOPE_SECURITY_SCHEME = {
+    type: 'apiKey',
+    name: 'X-BEAM-SCOPE',
+    in: 'header',
+    description: "Customer and project scope. This should contain the '<customer-id>.<project-id>'. Required for all microservice calls. Alternative to X-DE-SCOPE.",
+};
+const USER_SECURITY_SCHEME = {
+    type: 'http',
+    scheme: 'bearer',
+    bearerFormat: 'Bearer <Access Token>',
+    description: 'Bearer authentication with a player access token in the Authorization header.',
+};
+function generateOpenApiDocument(service, env, runtimeVersion) {
+    const serverBase = buildServiceBaseUrl(env, service);
+    const doc = {
+        openapi: '3.0.1',
+        info: {
+            title: service.name,
+            version: runtimeVersion || process.env.BEAMABLE_RUNTIME_VERSION || '0.0.0',
+        },
+        servers: serverBase ? [{ url: serverBase }] : [],
+        paths: {},
+        components: {
+            securitySchemes: {
+                scope: SCOPE_SECURITY_SCHEME,
+                beamScope: BEAM_SCOPE_SECURITY_SCHEME,
+                user: USER_SECURITY_SCHEME,
+            },
+            schemas: {},
+        },
+    };
+    for (const callable of service.callables) {
+        const normalizedRoute = normalizeRoute(callable.route);
+        const pathKey = `/${normalizedRoute}`;
+        const payload = buildRequestSchema(callable.handler);
+        const securityEntry = { scope: [], beamScope: [] };
+        if (callable.metadata.requireAuth) {
+            securityEntry.user = [];
+        }
+        const operation = {
+            operationId: callable.name,
+            summary: callable.name,
+            tags: callable.metadata.tags.length > 0 ? callable.metadata.tags : ['Callables'],
+            responses: {
+                '200': {
+                    description: 'Success',
+                    content: {
+                        [JSON_CONTENT_TYPE]: {
+                            schema: {
+                                oneOf: [{ type: 'object' }, { type: 'array' }, { type: 'string' }, { type: 'number' }, { type: 'boolean' }, { type: 'null' }],
+                            },
+                        },
+                    },
+                },
+            },
+            security: [securityEntry],
+            'x-beamable-access': callable.metadata.access,
+        };
+        if (callable.metadata.requiredScopes.length > 0) {
+            operation['x-beamable-required-scopes'] = callable.metadata.requiredScopes;
+        }
+        if (payload) {
+            operation.requestBody = {
+                required: payload.required,
+                content: {
+                    [JSON_CONTENT_TYPE]: {
+                        schema: payload.schema,
+                    },
+                },
+            };
+        }
+        doc.paths[pathKey] = {
+            post: operation,
+        };
+    }
+    addAdminOperations(doc);
+    return JSON.parse(JSON.stringify(doc));
+}
+function buildRequestSchema(handler) {
+    if (typeof handler !== 'function') {
+        return {
+            required: false,
+            schema: {
+                type: 'object',
+                properties: {
+                    payload: {
+                        type: 'array',
+                        description: 'Callable arguments in invocation order.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        };
+    }
+    const expectedParams = handler.length;
+    const payloadCount = Math.max(expectedParams - 1, 0);
+    if (payloadCount <= 0) {
+        return undefined;
+    }
+    return {
+        required: true,
+        schema: {
+            type: 'object',
+            properties: {
+                payload: {
+                    type: 'array',
+                    minItems: payloadCount,
+                    description: 'Callable arguments in invocation order.',
+                },
+            },
+            required: ['payload'],
+            additionalProperties: false,
+        },
+    };
+}
+function buildServiceBaseUrl(env, service) {
+    const host = (0, urls_js_1.hostToHttpUrl)(env.host).replace(/\/$/, '');
+    return `${host}/basic/${env.cid}.${env.pid}.${service.qualifiedName}/`;
+}
+function normalizeRoute(route) {
+    if (!route) {
+        return '';
+    }
+    return route.replace(/^\/+/, '');
+}
+function addAdminOperations(doc) {
+    const requiredScopeSecurity = { scope: [], beamScope: [] };
+    doc.paths['/admin/HealthCheck'] = {
+        post: {
+            operationId: 'adminHealthCheck',
+            summary: 'HealthCheck',
+            tags: [ADMIN_TAG],
+            responses: {
+                '200': {
+                    description: 'The word "responsive" if all is well.',
+                    content: {
+                        [JSON_CONTENT_TYPE]: {
+                            schema: {
+                                type: 'string',
+                                example: 'responsive',
+                            },
+                        },
+                    },
+                },
+            },
+            security: [requiredScopeSecurity],
+        },
+    };
+    const adminSecurity = { scope: ['admin'], beamScope: ['admin'] };
+    doc.paths['/admin/Docs'] = {
+        post: {
+            operationId: 'adminDocs',
+            summary: 'Docs',
+            description: 'Generates an OpenAPI/Swagger 3.0 document that describes the available service endpoints.',
+            tags: [ADMIN_TAG],
+            responses: {
+                '200': {
+                    description: 'Swagger JSON document.',
+                    content: {
+                        [JSON_CONTENT_TYPE]: {
+                            schema: {
+                                type: 'object',
+                            },
+                        },
+                    },
+                },
+            },
+            security: [adminSecurity],
+            'x-beamable-required-scopes': ['admin'],
+        },
+    };
+    doc.paths['/admin/Metadata'] = {
+        post: {
+            operationId: 'adminMetadata',
+            summary: 'Metadata',
+            description: 'Fetch various Beamable SDK metadata for the Microservice.',
+            tags: [ADMIN_TAG],
+            responses: {
+                '200': {
+                    description: 'Service metadata.',
+                    content: {
+                        [JSON_CONTENT_TYPE]: {
+                            schema: {
+                                type: 'object',
+                            },
+                        },
+                    },
+                },
+            },
+            security: [adminSecurity],
+            'x-beamable-required-scopes': ['admin'],
+        },
+    };
+}