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

package/src/federation.ts

@@ -1,559 +0,0 @@
-import type { Logger } from 'pino';
-import type { RequestContext } from './types.js';
-
-export interface FederationComponentDescriptor {
-  federationType: string;
-  federationNamespace: string;
-  localSettings?: unknown;
-}
-
-export interface FederationMetadata {
-  typeName: string;
-  identity: string;
-  localSettings?: unknown;
-}
-
-export interface FederationIdentity {
-  getUniqueName(): string;
-}
-
-export type FederationIdentityConstructor<T extends FederationIdentity = FederationIdentity> = new () => T;
-
-export interface FederatedAuthenticationRequest {
-  token?: string;
-  challenge?: string;
-  solution?: string;
-}
-
-export interface FederatedAuthenticationResponse {
-  user_id?: string;
-  challenge?: string;
-  challenge_ttl?: number;
-  [key: string]: unknown;
-}
-
-export interface FederatedItemProperty {
-  name: string;
-  value: string;
-}
-
-export interface FederatedItemProxy {
-  proxyId: string;
-  properties?: FederatedItemProperty[];
-}
-
-export interface FederatedInventoryProxyState {
-  currencies?: Record<string, number>;
-  items?: Record<string, FederatedItemProxy[]>;
-}
-
-export interface FederatedItemCreateRequest {
-  contentId: string;
-  properties?: Record<string, string>;
-  requestId?: string;
-}
-
-export interface FederatedItemDeleteRequest {
-  contentId: string;
-  proxyId: string;
-}
-
-export interface FederatedItemUpdateRequest {
-  contentId: string;
-  proxyId: string;
-  properties?: Record<string, string>;
-}
-
-export interface FederatedInventoryStateRequest {
-  id: string;
-}
-
-export interface FederatedInventoryTransactionRequest {
-  id: string;
-  transaction: string;
-  currencies?: Record<string, number>;
-  newItems?: FederatedItemCreateRequest[];
-  deleteItems?: FederatedItemDeleteRequest[];
-  updateItems?: FederatedItemUpdateRequest[];
-}
-
-export interface FederatedInventoryOptions<T extends FederationIdentity> {
-  identity: FederationIdentityConstructor<T>;
-  authenticate?: string;
-  getInventoryState?: string;
-  startInventoryTransaction?: string;
-}
-
-interface FederatedInventoryMetadata {
-  identityCtor: FederationIdentityConstructor;
-  identityName: string;
-  methods: {
-    authenticate: string;
-    getInventoryState: string;
-    startInventoryTransaction: string;
-  };
-}
-
-interface FederationRouteHandler {
-  identityName: string;
-  type: 'authenticate' | 'inventory-state' | 'inventory-transaction';
-  invoke(ctx: FederatedRequestContext): Promise<unknown>;
-}
-
-export interface FederatedRequestContext extends RequestContext {
-  federation: {
-    identity: string;
-  };
-}
-
-const FEDERATION_COMPONENTS = new Map<Function, FederationComponentDescriptor[]>();
-const FEDERATED_INVENTORY_MAP = new Map<Function, FederatedInventoryMetadata[]>();
-
-export function FederationComponent(descriptor: FederationComponentDescriptor): ClassDecorator {
-  validateDescriptor(descriptor);
-
-  return (target) => {
-    const existing = FEDERATION_COMPONENTS.get(target) ?? [];
-    existing.push({
-      federationNamespace: descriptor.federationNamespace,
-      federationType: descriptor.federationType,
-      localSettings: descriptor.localSettings,
-    });
-    FEDERATION_COMPONENTS.set(target, existing);
-  };
-}
-
-export function getFederationComponents(target: Function): FederationComponentDescriptor[] {
-  return FEDERATION_COMPONENTS.get(target) ?? [];
-}
-
-export function FederatedInventory<T extends FederationIdentity>(
-  options: FederatedInventoryOptions<T>,
-): ClassDecorator {
-  const authenticate = options.authenticate ?? 'Authenticate';
-  const getInventoryState = options.getInventoryState ?? 'GetInventoryState';
-  const startInventoryTransaction = options.startInventoryTransaction ?? 'StartInventoryTransaction';
-
-  return (target) => {
-    const identityInstance = new options.identity();
-    if (!identityInstance || typeof identityInstance.getUniqueName !== 'function') {
-      throw new Error('@FederatedInventory identity must implement getUniqueName().');
-    }
-    const identityName = identityInstance.getUniqueName();
-    if (!identityName || !identityName.trim()) {
-      throw new Error('@FederatedInventory identity must provide a non-empty unique name.');
-    }
-
-    const existing = FEDERATED_INVENTORY_MAP.get(target) ?? [];
-    existing.push({
-      identityCtor: options.identity,
-      identityName: identityName.trim(),
-      methods: {
-        authenticate,
-        getInventoryState,
-        startInventoryTransaction,
-      },
-    });
-    FEDERATED_INVENTORY_MAP.set(target, existing);
-  };
-}
-
-export function getFederatedInventoryMetadata(target: Function): FederatedInventoryMetadata[] {
-  return FEDERATED_INVENTORY_MAP.get(target) ?? [];
-}
-
-function validateDescriptor(descriptor: FederationComponentDescriptor): void {
-  if (!descriptor.federationNamespace || !descriptor.federationNamespace.trim()) {
-    throw new Error('@FederationComponent requires a non-empty federationNamespace.');
-  }
-  if (!descriptor.federationType || !descriptor.federationType.trim()) {
-    throw new Error('@FederationComponent requires a non-empty federationType.');
-  }
-}
-
-export class FederationRegistry {
-  private readonly logger: Logger;
-  private readonly manualComponents = new Map<string, Set<string>>();
-  private readonly autoComponents = new Map<string, Set<string>>();
-  private readonly routeHandlers = new Map<string, FederationRouteHandler>();
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'FederationRegistry' });
-  }
-
-  register(component: FederationComponentDescriptor): void {
-    validateDescriptor(component);
-    const namespace = component.federationNamespace.trim();
-    const type = component.federationType.trim();
-    const existing = this.manualComponents.get(namespace) ?? new Set<string>();
-    existing.add(type);
-    this.manualComponents.set(namespace, existing);
-    this.logger.debug({ component }, 'Registered federation component.');
-  }
-
-  registerInventoryHandlers(service: object, metadata: FederatedInventoryMetadata[]): void {
-    for (const entry of metadata) {
-      const identity = entry.identityName;
-      this.addAutoComponent(identity, 'IFederatedInventory');
-      this.addAutoComponent(identity, 'IFederatedLogin');
-
-      const authenticateHandler = this.createInventoryHandler(
-        service,
-        entry.methods.authenticate,
-        identity,
-        'authenticate',
-      );
-      const stateHandler = this.createInventoryHandler(
-        service,
-        entry.methods.getInventoryState,
-        identity,
-        'inventory-state',
-      );
-      const transactionHandler = this.createInventoryHandler(
-        service,
-        entry.methods.startInventoryTransaction,
-        identity,
-        'inventory-transaction',
-      );
-
-      this.routeHandlers.set(`${identity.toLowerCase()}/authenticate`, authenticateHandler);
-      this.routeHandlers.set(`${identity.toLowerCase()}/inventory/state`, stateHandler);
-      this.routeHandlers.set(`${identity.toLowerCase()}/inventory/put`, transactionHandler);
-    }
-  }
-
-  list(): FederationComponentDescriptor[] {
-    const components: FederationComponentDescriptor[] = [];
-    for (const [namespace, types] of this.manualComponents.entries()) {
-      for (const type of types) {
-        components.push({ federationNamespace: namespace, federationType: type });
-      }
-    }
-    for (const [namespace, types] of this.autoComponents.entries()) {
-      for (const type of types) {
-        components.push({ federationNamespace: namespace, federationType: type });
-      }
-    }
-    return components;
-  }
-
-  resolve(path: string): FederationRouteHandler | undefined {
-    return this.routeHandlers.get(path.toLowerCase());
-  }
-
-  private addAutoComponent(namespace: string, type: string): void {
-    const existing = this.autoComponents.get(namespace) ?? new Set<string>();
-    existing.add(type);
-    this.autoComponents.set(namespace, existing);
-  }
-
-  private createInventoryHandler(
-    service: object,
-    methodName: string,
-    identity: string,
-    type: FederationRouteHandler['type'],
-  ): FederationRouteHandler {
-    const method = (service as Record<string, unknown>)[methodName];
-    if (typeof method !== 'function') {
-      throw new Error(
-        `Federated inventory method "${methodName}" is not defined on service "${service.constructor.name}".`,
-      );
-    }
-    const paramTypes = getMethodParameterTypes(service, methodName);
-
-    return {
-      identityName: identity,
-      type,
-      invoke: async (ctx: FederatedRequestContext) => {
-        const federatedCtx: FederatedRequestContext = {
-          ...ctx,
-          federation: { identity },
-        };
-        switch (type) {
-          case 'authenticate':
-            return invokeFederatedAuthenticate(
-              method as (...args: unknown[]) => unknown,
-              service,
-              federatedCtx,
-              normalizeAuthenticationRequest(ctx.body),
-              paramTypes,
-            );
-          case 'inventory-state':
-            return invokeFederatedGetInventoryState(
-              method as (...args: unknown[]) => unknown,
-              service,
-              federatedCtx,
-              normalizeInventoryStateRequest(ctx.body),
-              paramTypes,
-            );
-          case 'inventory-transaction':
-            return invokeFederatedStartInventoryTransaction(
-              method as (...args: unknown[]) => unknown,
-              service,
-              federatedCtx,
-              normalizeInventoryTransactionRequest(ctx.body),
-              paramTypes,
-            );
-          default:
-            throw new Error(`Unsupported federated handler type: ${type as string}`);
-        }
-      },
-    };
-  }
-}
-
-function normalizeAuthenticationRequest(payload: unknown): FederatedAuthenticationRequest {
-  if (!payload || typeof payload !== 'object') {
-    return {};
-  }
-  const body = payload as Record<string, unknown>;
-  return {
-    token: typeof body.token === 'string' ? body.token : undefined,
-    challenge: typeof body.challenge === 'string' ? body.challenge : undefined,
-    solution: typeof body.solution === 'string' ? body.solution : undefined,
-  };
-}
-
-function normalizeInventoryStateRequest(payload: unknown): FederatedInventoryStateRequest {
-  if (!payload || typeof payload !== 'object' || typeof (payload as Record<string, unknown>).id !== 'string') {
-    throw new Error('Federated inventory state requests must include an "id" property.');
-  }
-  const body = payload as Record<string, unknown>;
-  return { id: String(body.id) };
-}
-
-function normalizeInventoryTransactionRequest(payload: unknown): FederatedInventoryTransactionRequest {
-  if (!payload || typeof payload !== 'object') {
-    throw new Error('Federated inventory transaction requests require a JSON body.');
-  }
-  const body = payload as Record<string, unknown>;
-  if (typeof body.id !== 'string') {
-    throw new Error('Federated inventory transaction requests must include an "id" property.');
-  }
-  if (typeof body.transaction !== 'string') {
-    throw new Error('Federated inventory transaction requests must include a "transaction" property.');
-  }
-
-  return {
-    id: body.id,
-    transaction: body.transaction,
-    currencies: normalizeRecordOfNumbers(body.currencies),
-    newItems: normalizeFederatedCreateRequests(body.newItems),
-    deleteItems: normalizeFederatedDeleteRequests(body.deleteItems),
-    updateItems: normalizeFederatedUpdateRequests(body.updateItems),
-  };
-}
-
-function normalizeRecordOfNumbers(value: unknown): Record<string, number> | undefined {
-  if (!value || typeof value !== 'object') {
-    return undefined;
-  }
-  const record: Record<string, number> = {};
-  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
-    const numeric = Number(raw);
-    if (Number.isFinite(numeric)) {
-      record[key] = numeric;
-    }
-  }
-  return Object.keys(record).length > 0 ? record : undefined;
-}
-
-function normalizeFederatedCreateRequests(value: unknown): FederatedItemCreateRequest[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  const normalized: FederatedItemCreateRequest[] = [];
-  for (const item of value) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    const record = item as Record<string, unknown>;
-    if (typeof record.contentId !== 'string') {
-      continue;
-    }
-    const properties = record.properties && typeof record.properties === 'object'
-      ? Object.fromEntries(
-          Object.entries(record.properties as Record<string, unknown>).map(([propKey, propVal]) => [
-            propKey,
-            String(propVal),
-          ]),
-        )
-      : undefined;
-    normalized.push({
-      contentId: record.contentId,
-      requestId: typeof record.requestId === 'string' ? record.requestId : undefined,
-      properties,
-    });
-  }
-  return normalized.length > 0 ? normalized : undefined;
-}
-
-function normalizeFederatedDeleteRequests(value: unknown): FederatedItemDeleteRequest[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  const normalized: FederatedItemDeleteRequest[] = [];
-  for (const item of value) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    const record = item as Record<string, unknown>;
-    if (typeof record.contentId !== 'string' || typeof record.proxyId !== 'string') {
-      continue;
-    }
-    normalized.push({
-      contentId: record.contentId,
-      proxyId: record.proxyId,
-    });
-  }
-  return normalized.length > 0 ? normalized : undefined;
-}
-
-function normalizeFederatedUpdateRequests(value: unknown): FederatedItemUpdateRequest[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  const normalized: FederatedItemUpdateRequest[] = [];
-  for (const item of value) {
-    if (!item || typeof item !== 'object') {
-      continue;
-    }
-    const record = item as Record<string, unknown>;
-    if (typeof record.contentId !== 'string' || typeof record.proxyId !== 'string') {
-      continue;
-    }
-    const properties = record.properties && typeof record.properties === 'object'
-      ? Object.fromEntries(
-          Object.entries(record.properties as Record<string, unknown>).map(([propKey, propVal]) => [
-            propKey,
-            String(propVal),
-          ]),
-        )
-      : undefined;
-    normalized.push({
-      contentId: record.contentId,
-      proxyId: record.proxyId,
-      properties,
-    });
-  }
-  return normalized.length > 0 ? normalized : undefined;
-}
-
-function getMethodParameterTypes(service: object, methodName: string): unknown[] {
-  const prototype = Object.getPrototypeOf(service);
-  if (!prototype || typeof Reflect.getMetadata !== 'function') {
-    return [];
-  }
-  return (Reflect.getMetadata('design:paramtypes', prototype, methodName) as unknown[]) ?? [];
-}
-
-function isStringType(type: unknown): boolean {
-  return type === String;
-}
-
-function invokeFederatedAuthenticate(
-  method: (...args: unknown[]) => unknown,
-  service: object,
-  ctx: FederatedRequestContext,
-  request: FederatedAuthenticationRequest,
-  paramTypes: unknown[],
-): unknown {
-  const argsWithoutContext = [request.token, request.challenge, request.solution];
-
-  if (method.length === argsWithoutContext.length) {
-    return method.call(service, ...argsWithoutContext);
-  }
-
-  if (method.length === argsWithoutContext.length + 1) {
-    return method.call(service, ctx, ...argsWithoutContext);
-  }
-
-  if (method.length === 1) {
-    const firstType = paramTypes[0];
-    if (isStringType(firstType)) {
-      return method.call(service, ...argsWithoutContext);
-    }
-    return method.call(service, request);
-  }
-
-  if (method.length === 2) {
-    const secondType = paramTypes[1];
-    if (isStringType(secondType)) {
-      return method.call(service, ctx, ...argsWithoutContext);
-    }
-    return method.call(service, ctx, request);
-  }
-
-  return method.call(service, ctx, request);
-}
-
-function invokeFederatedGetInventoryState(
-  method: (...args: unknown[]) => unknown,
-  service: object,
-  ctx: FederatedRequestContext,
-  request: FederatedInventoryStateRequest,
-  paramTypes: unknown[],
-): unknown {
-  const argsWithoutContext = [request.id];
-
-  if (method.length === argsWithoutContext.length) {
-    const firstType = paramTypes[0];
-    if (isStringType(firstType)) {
-      return method.call(service, ...argsWithoutContext);
-    }
-    return method.call(service, request);
-  }
-
-  if (method.length === argsWithoutContext.length + 1) {
-    const secondType = paramTypes[1];
-    if (isStringType(secondType)) {
-      return method.call(service, ctx, ...argsWithoutContext);
-    }
-    return method.call(service, ctx, request);
-  }
-
-  if (method.length === 1) {
-    return method.call(service, request);
-  }
-
-  if (method.length === 2) {
-    return method.call(service, ctx, request);
-  }
-
-  return method.call(service, ctx, request);
-}
-
-function invokeFederatedStartInventoryTransaction(
-  method: (...args: unknown[]) => unknown,
-  service: object,
-  ctx: FederatedRequestContext,
-  request: FederatedInventoryTransactionRequest,
-  _paramTypes: unknown[],
-): unknown {
-  const argsWithoutContext = [
-    request.id,
-    request.transaction,
-    request.currencies ?? {},
-    request.newItems ?? [],
-    request.deleteItems ?? [],
-    request.updateItems ?? [],
-  ];
-
-  if (method.length === argsWithoutContext.length) {
-    return method.call(service, ...argsWithoutContext);
-  }
-
-  if (method.length === argsWithoutContext.length + 1) {
-    return method.call(service, ctx, ...argsWithoutContext);
-  }
-
-  if (method.length === 1) {
-    return method.call(service, request);
-  }
-
-  if (method.length === 2) {
-    return method.call(service, ctx, request);
-  }
-
-  return method.call(service, ctx, request);
-}

package/src/index.ts

@@ -1,84 +0,0 @@
-export {
-  Microservice,
-  Callable,
-  ClientCallable,
-  ServerCallable,
-  AdminCallable,
-  SwaggerCategory,
-  SwaggerTags,
-  ConfigureServices,
-  InitializeServices,
-} from './decorators.js';
-export type { MicroserviceOptions, CallableOptions, ServiceAccess } from './types.js';
-export type { EnvironmentConfig, RequestContext, ServiceDefinition } from './types.js';
-export type { BeamableMicroserviceServices, BoundBeamApi } from './services.js';
-export { BeamableServiceManager } from './services.js';
-export {
-  DependencyBuilder,
-  type DependencyScope,
-  ServiceLifetime,
-  LOGGER_TOKEN,
-  ENVIRONMENT_CONFIG_TOKEN,
-  REQUEST_CONTEXT_TOKEN,
-  BEAMABLE_SERVICES_TOKEN,
-} from './dependency.js';
-export { loadEnvironmentConfig } from './env.js';
-export { BeamableRuntimeError } from './errors.js';
-export { MicroserviceRuntime, runMicroservice } from './runtime.js';
-export {
-  InventoryUpdateBuilder,
-  createInventoryService,
-  type InventoryUpdatePayload,
-  type InventoryBuilderOptions,
-} from './inventory.js';
-export { StorageService, StorageObject, getStorageMetadata, listRegisteredStorageObjects } from './storage.js';
-export {
-  FederationComponent,
-  FederationRegistry,
-  getFederationComponents,
-  FederatedInventory,
-  type FederationIdentity,
-  type FederatedAuthenticationRequest,
-  type FederatedAuthenticationResponse,
-  type FederatedInventoryProxyState,
-  type FederatedInventoryStateRequest,
-  type FederatedInventoryTransactionRequest,
-  type FederatedItemCreateRequest,
-  type FederatedItemDeleteRequest,
-  type FederatedItemUpdateRequest,
-  type FederatedItemProperty,
-  type FederatedItemProxy,
-} from './federation.js';
-export {
-  isCollectorRunning,
-  getClickHouseCredentialsStatus,
-  fetchClickHouseCredentials,
-  addAuthEnvironmentVars,
-  getCollectorProcessStatus,
-  setupCollectorBeforeLogging,
-  startCollectorAsync,
-  startCollectorAndWaitForReady,
-  type CollectorStatus,
-} from './collector-manager.js';
-
-// Export runtime version - read from package.json dynamically
-import { readFileSync } from 'fs';
-import { createRequire } from 'module';
-
-function getPackageVersion(): string {
-  try {
-    // Use createRequire to get a require function that works in both ESM and CJS
-    // This allows us to resolve the package.json path relative to this module
-    // @ts-ignore - import.meta is ESM-only, TypeScript error in CJS is expected
-    const require = createRequire(import.meta.url);
-    const packageJsonPath = require.resolve('../package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    return packageJson.version || '0.0.0';
-  } catch (error) {
-    // Fallback if package.json can't be read
-    console.warn('[Runtime] Failed to read version from package.json, using fallback:', error instanceof Error ? error.message : String(error));
-    return '0.0.0';
-  }
-}
-
-export const VERSION = getPackageVersion();