@omen.foundation/node-microservice-runtime 0.1.64 → 0.1.67

package/src/decorators.ts

@@ -1,207 +0,0 @@
-import 'reflect-metadata';
-import type { ServiceCallableMetadata, ServiceDefinition, MicroserviceOptions, CallableOptions, ServiceAccess } from './types.js';
-import type { DependencyBuilder, DependencyScope } from './dependency.js';
-
-type ConfigureServicesHandler = (builder: DependencyBuilder) => void | Promise<void>;
-type InitializeServicesHandler = (provider: DependencyScope) => void | Promise<void>;
-
-export type { ConfigureServicesHandler, InitializeServicesHandler };
-
-const SERVICE_METADATA = new Map<Function, MutableServiceDefinition>();
-const PENDING_REGISTRATIONS = new Map<Function, Array<(meta: MutableServiceDefinition) => void>>();
-const SWAGGER_TAGS_METADATA_KEY = Symbol('beamable:swaggerTags');
-const CONFIGURE_SERVICES_METADATA = new Map<Function, ConfigureServicesHandler[]>();
-const INITIALIZE_SERVICES_METADATA = new Map<Function, InitializeServicesHandler[]>();
-
-interface MutableServiceDefinition {
-  name: string;
-  qualifiedName: string;
-  ctor: new (...args: unknown[]) => unknown;
-  callables: Map<string, ServiceCallableMetadata>;
-  options: MicroserviceOptions;
-}
-
-export function Microservice(name: string, options: MicroserviceOptions = {}) {
-  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<T extends new (...args: unknown[]) => unknown>(ctor: T): void {
-    const qualifiedName = `micro_${name}`;
-    const entry: MutableServiceDefinition = {
-      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);
-    }
-  };
-}
-
-export function Callable(options: CallableOptions = {}) {
-  return function decorator(
-    target: unknown,
-    propertyKey: string,
-    _descriptor: PropertyDescriptor,
-  ): void {
-    let ctorCandidate: unknown;
-    if (typeof target === 'function') {
-      ctorCandidate = target;
-    } else if (target !== null && typeof target === 'object') {
-      const obj = target as { constructor?: Function };
-      ctorCandidate = obj.constructor;
-    }
-
-    if (typeof ctorCandidate !== 'function') {
-      throw new Error('@Callable can only be applied to methods on a class.');
-    }
-    const ctor = ctorCandidate as new (...args: unknown[]) => unknown;
-    const metadataTarget =
-      typeof target === 'function'
-        ? (target as object)
-        : target !== null && typeof target === 'object'
-        ? (target as object)
-        : undefined;
-
-    if (!metadataTarget) {
-      throw new Error('@Callable decorator received an invalid target.');
-    }
-
-    const meta = SERVICE_METADATA.get(ctor);
-    if (!meta) {
-      const queue = PENDING_REGISTRATIONS.get(ctor) ?? [];
-      queue.push((lateMeta) => registerCallable(lateMeta, propertyKey, options, metadataTarget));
-      PENDING_REGISTRATIONS.set(ctor, queue);
-      return;
-    }
-
-    registerCallable(meta, propertyKey, options, metadataTarget);
-  };
-}
-
-function registerCallable(
-  meta: MutableServiceDefinition,
-  propertyKey: string,
-  options: CallableOptions,
-  metadataTarget: object,
-): void {
-  const access: ServiceAccess = options.access ?? 'public';
-  const paramTypes = Reflect.getMetadata('design:paramtypes', metadataTarget, propertyKey) as ReadonlyArray<unknown> | undefined;
-  const route = options.route ?? propertyKey;
-  const decoratorTags = (Reflect.getMetadata(SWAGGER_TAGS_METADATA_KEY, metadataTarget, propertyKey) as string[] | undefined) ?? [];
-  const combinedTags = options.tags ?? decoratorTags;
-  const tags = Array.from(new Set(combinedTags ?? []));
-  const metadata: ServiceCallableMetadata = {
-    route,
-    displayName: propertyKey,
-    requireAuth: options.requireAuth ?? access !== 'public',
-    requiredScopes: options.requiredScopes ?? defaultScopesForAccess(access),
-    useLegacySerialization: options.useLegacySerialization ?? meta.options.useLegacySerialization ?? false,
-    parameterTypes: 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: ServiceAccess): string[] {
-  switch (access) {
-    case 'admin':
-      return ['admin'];
-    case 'server':
-      return ['server'];
-    default:
-      return [];
-  }
-}
-
-export function listRegisteredServices(): ServiceDefinition[] {
-  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,
-  }));
-}
-
-export function getServiceOptions(ctor: Function): MicroserviceOptions | undefined {
-  return SERVICE_METADATA.get(ctor)?.options;
-}
-
-export type { MicroserviceOptions, CallableOptions };
-
-export function ClientCallable(options: CallableOptions = {}) {
-  return Callable({ ...options, access: 'client', requireAuth: true });
-}
-
-export function ServerCallable(options: CallableOptions = {}) {
-  return Callable({ ...options, access: 'server', requireAuth: true });
-}
-
-export function AdminCallable(options: CallableOptions = {}) {
-  return Callable({ ...options, access: 'admin', requireAuth: true });
-}
-
-export function SwaggerCategory(category: string) {
-  return SwaggerTags(category);
-}
-
-export function SwaggerTags(...tags: string[]) {
-  return function decorator(
-    target: object,
-    propertyKey: string,
-    _descriptor: PropertyDescriptor,
-  ): void {
-    if (tags.length === 0) {
-      return;
-    }
-    const current = (Reflect.getMetadata(SWAGGER_TAGS_METADATA_KEY, target, propertyKey) as string[] | undefined) ?? [];
-    const merged = Array.from(new Set([...current, ...tags]));
-    Reflect.defineMetadata(SWAGGER_TAGS_METADATA_KEY, merged, target, propertyKey);
-  };
-}
-
-export function configureServices(target: Function): ConfigureServicesHandler[] {
-  return CONFIGURE_SERVICES_METADATA.get(target) ?? [];
-}
-
-export function initializeServices(target: Function): InitializeServicesHandler[] {
-  return INITIALIZE_SERVICES_METADATA.get(target) ?? [];
-}
-
-export function ConfigureServices(target: Function, _propertyKey: string, descriptor: PropertyDescriptor): void {
-  if (typeof descriptor.value !== 'function') {
-    throw new Error('@ConfigureServices can only decorate static methods.');
-  }
-  const handlers = CONFIGURE_SERVICES_METADATA.get(target) ?? [];
-  handlers.push(descriptor.value.bind(target));
-  CONFIGURE_SERVICES_METADATA.set(target, handlers);
-}
-
-export function InitializeServices(target: Function, _propertyKey: string, descriptor: PropertyDescriptor): void {
-  if (typeof descriptor.value !== 'function') {
-    throw new Error('@InitializeServices can only decorate static methods.');
-  }
-  const handlers = INITIALIZE_SERVICES_METADATA.get(target) ?? [];
-  handlers.push(descriptor.value.bind(target));
-  INITIALIZE_SERVICES_METADATA.set(target, handlers);
-}
-
-export function getConfigureServicesHandlers(target: Function): ConfigureServicesHandler[] {
-  return CONFIGURE_SERVICES_METADATA.get(target) ?? [];
-}
-
-export function getInitializeServicesHandlers(target: Function): InitializeServicesHandler[] {
-  return INITIALIZE_SERVICES_METADATA.get(target) ?? [];
-}

package/src/dependency.ts

@@ -1,211 +0,0 @@
-import 'reflect-metadata';
-
-export type Constructor<T> = new (...args: any[]) => T;
-export type DependencyKey<T = unknown> = Constructor<T> | symbol | string;
-
-export enum ServiceLifetime {
-  Singleton = 'singleton',
-  Scoped = 'scoped',
-  Transient = 'transient',
-}
-
-export interface DependencyScope {
-  resolve<T>(key: DependencyKey<T>): T;
-}
-
-export interface MutableDependencyScope extends DependencyScope {
-  setInstance<T>(key: DependencyKey<T>, value: T): void;
-}
-
-type ServiceFactory<T> = (scope: DependencyScope) => T;
-
-interface ServiceDescriptor<T = unknown> {
-  key: DependencyKey<T>;
-  lifetime: ServiceLifetime;
-  factory: ServiceFactory<T>;
-}
-
-function isConstructor<T>(key: DependencyKey<T>): key is Constructor<T> {
-  return typeof key === 'function';
-}
-
-function instantiate<T>(ctor: Constructor<T>, scope: DependencyScope): T {
-  const paramTypes: Array<Constructor<unknown>> = Reflect.getMetadata('design:paramtypes', ctor) ?? [];
-  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 as Constructor<unknown>);
-  });
-  return new ctor(...dependencies);
-}
-
-export class DependencyBuilder {
-  private readonly descriptors = new Map<DependencyKey, ServiceDescriptor<unknown>>();
-
-  addSingleton<T>(key: DependencyKey<T>, factory: ServiceFactory<T>): this {
-    return this.addDescriptor(key, ServiceLifetime.Singleton, factory);
-  }
-
-  addSingletonClass<T>(ctor: Constructor<T>): this {
-    return this.addSingleton(ctor, (scope) => instantiate(ctor, scope));
-  }
-
-  addSingletonInstance<T>(key: DependencyKey<T>, instance: T): this {
-    return this.addSingleton(key, () => instance);
-  }
-
-  addScoped<T>(key: DependencyKey<T>, factory: ServiceFactory<T>): this {
-    return this.addDescriptor(key, ServiceLifetime.Scoped, factory);
-  }
-
-  addScopedClass<T>(ctor: Constructor<T>): this {
-    return this.addScoped(ctor, (scope) => instantiate(ctor, scope));
-  }
-
-  addTransient<T>(key: DependencyKey<T>, factory: ServiceFactory<T>): this {
-    return this.addDescriptor(key, ServiceLifetime.Transient, factory);
-  }
-
-  addTransientClass<T>(ctor: Constructor<T>): this {
-    return this.addTransient(ctor, (scope) => instantiate(ctor, scope));
-  }
-
-  tryAddSingleton<T>(key: DependencyKey<T>, factory: ServiceFactory<T>): this {
-    if (!this.descriptors.has(key)) {
-      this.addSingleton(key, factory);
-    }
-    return this;
-  }
-
-  tryAddSingletonInstance<T>(key: DependencyKey<T>, instance: T): this {
-    if (!this.descriptors.has(key)) {
-      this.addSingletonInstance(key, instance);
-    }
-    return this;
-  }
-
-  build(): ServiceProvider {
-    return new ServiceProvider(this.descriptors);
-  }
-
-  private addDescriptor<T>(key: DependencyKey<T>, lifetime: ServiceLifetime, factory: ServiceFactory<T>): this {
-    if (!key) {
-      throw new Error('Dependency registration requires a non-empty key.');
-    }
-    this.descriptors.set(key, { key, lifetime, factory } as ServiceDescriptor<unknown>);
-    return this;
-  }
-}
-
-export class ServiceProvider implements DependencyScope {
-  private readonly descriptors: Map<DependencyKey, ServiceDescriptor<unknown>>;
-  private readonly singletons = new Map<DependencyKey, unknown>();
-
-  constructor(descriptors: Map<DependencyKey, ServiceDescriptor<unknown>>) {
-    this.descriptors = new Map(descriptors);
-  }
-
-  resolve<T>(key: DependencyKey<T>): T {
-    const descriptor = this.descriptors.get(key) as ServiceDescriptor<T> | undefined;
-    if (!descriptor && isConstructor(key)) {
-      const implicitDescriptor: ServiceDescriptor<T> = {
-        key,
-        lifetime: ServiceLifetime.Transient,
-        factory: (scope) => instantiate(key, scope),
-      };
-      this.descriptors.set(key, implicitDescriptor as ServiceDescriptor<unknown>);
-      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) as T;
-      }
-      case ServiceLifetime.Scoped:
-        return descriptor.factory(this);
-      case ServiceLifetime.Transient:
-      default:
-        return descriptor.factory(this);
-    }
-  }
-
-  createScope(): ScopedServiceProvider {
-    return new ScopedServiceProvider(this.descriptors, this.singletons, this);
-  }
-}
-
-class ScopedServiceProvider implements MutableDependencyScope {
-  private readonly descriptors: Map<DependencyKey, ServiceDescriptor<unknown>>;
-  private readonly rootSingletons: Map<DependencyKey, unknown>;
-  private readonly scopedInstances = new Map<DependencyKey, unknown>();
-  private readonly rootProvider: ServiceProvider;
-
-  constructor(
-    descriptors: Map<DependencyKey, ServiceDescriptor<unknown>>,
-    rootSingletons: Map<DependencyKey, unknown>,
-    rootProvider: ServiceProvider,
-  ) {
-    this.descriptors = descriptors;
-    this.rootSingletons = rootSingletons;
-    this.rootProvider = rootProvider;
-  }
-
-  resolve<T>(key: DependencyKey<T>): T {
-    const descriptor = this.descriptors.get(key) as ServiceDescriptor<T> | undefined;
-    if (!descriptor && isConstructor(key)) {
-      const implicitDescriptor: ServiceDescriptor<T> = {
-        key,
-        lifetime: ServiceLifetime.Transient,
-        factory: (scope) => instantiate(key, scope),
-      };
-      this.descriptors.set(key, implicitDescriptor as ServiceDescriptor<unknown>);
-      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) as T;
-      }
-      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) as T;
-      }
-      case ServiceLifetime.Transient:
-      default:
-        return descriptor.factory(this);
-    }
-  }
-
-  setInstance<T>(key: DependencyKey<T>, value: T): void {
-    this.scopedInstances.set(key, value);
-  }
-}
-
-export const LOGGER_TOKEN = Symbol('beamable:logger');
-export const ENVIRONMENT_CONFIG_TOKEN = Symbol('beamable:environment');
-export const REQUEST_CONTEXT_TOKEN = Symbol('beamable:requestContext');
-export const BEAMABLE_SERVICES_TOKEN = Symbol('beamable:services');

package/src/dev.ts

@@ -1,17 +0,0 @@
-import 'dotenv/config';
-import { Microservice, Callable } from './decorators.js';
-import { runMicroservice } from './runtime.js';
-import type { RequestContext } from './types.js';
-
-@Microservice('ExampleNodeService')
-export class ExampleService {
-  @Callable()
-  async echo(ctx: RequestContext, message: string): Promise<{ message: string; playerId: number }> {
-    return {
-      message,
-      playerId: ctx.userId,
-    };
-  }
-}
-
-void runMicroservice();

package/src/discovery.ts

@@ -1,88 +0,0 @@
-import dgram from 'node:dgram';
-import type { Logger } from 'pino';
-import type { EnvironmentConfig } from './types.js';
-
-const DISCOVERY_PORT = 8624;
-const BROADCAST_PERIOD_MS = 10;
-
-interface DiscoveryOptions {
-  env: EnvironmentConfig;
-  serviceName: string;
-  routingKey: string | undefined; // undefined for deployed services
-  logger: Logger;
-}
-
-export class DiscoveryBroadcaster {
-  private readonly socket = dgram.createSocket('udp4');
-  private readonly payload: Buffer;
-  private interval?: NodeJS.Timeout;
-  private disposed = false;
-
-  constructor(private readonly options: DiscoveryOptions) {
-    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: options.env.accountId ?? 0,
-      isContainer: false,
-      dataPort: 0,
-      containerId: '',
-    } satisfies Record<string, unknown>;
-
-    this.payload = Buffer.from(JSON.stringify(message), 'utf8');
-
-    this.socket.on('error', (err) => {
-      options.logger.warn({ err }, 'Discovery broadcaster socket error.');
-    });
-  }
-
-  async start(): Promise<void> {
-    if (this.disposed) {
-      return;
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      const onError = (error: 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(): void {
-    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.');
-    }
-  }
-}