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

package/src/services.ts

@@ -1,459 +0,0 @@
-import type { Logger } from 'pino';
-import {
-  BeamServer,
-  BeamEnvironment,
-  defaultTokenStorage,
-  type HttpRequester,
-  AccountService,
-  AnnouncementsService,
-  AuthService,
-  ContentService,
-  LeaderboardsService,
-  StatsService,
-} from 'beamable-sdk';
-import type { EnvironmentConfig } from './types.js';
-import { hostToHttpUrl, hostToPortalUrl, hostToStorageUrl, hostToMicroserviceRegistryUrl } from './utils/urls.js';
-import { createInventoryService, type InventoryService } from './inventory.js';
-import { StorageService } from './storage.js';
-import type { FederationRegistry } from './federation.js';
-import { MissingScopesError } from './errors.js';
-
-const RUNTIME_ENVIRONMENT_NAME = 'node-runtime';
-
-export type BoundBeamApi = Record<string, (...args: unknown[]) => unknown>;
-
-let cachedBeamApiModule: Record<string, unknown> | null = null;
-
-async function resolveBeamApiModule(): Promise<Record<string, unknown>> {
-  if (!cachedBeamApiModule) {
-    const imported = await import('beamable-sdk/api');
-    cachedBeamApiModule =
-      imported && typeof imported === 'object' && 'default' in imported
-        ? (imported.default as Record<string, unknown>)
-        : (imported as Record<string, unknown>);
-  }
-  return cachedBeamApiModule;
-}
-
-async function bindBeamApi(requester: HttpRequester): Promise<BoundBeamApi> {
-  const module = await resolveBeamApiModule();
-  const bound: Record<string, (...args: unknown[]) => unknown> = {};
-  for (const key of Object.keys(module)) {
-    const value = module[key];
-    if (typeof value === 'function') {
-      bound[key] = (...args: unknown[]) => (value as (r: HttpRequester, ...params: unknown[]) => unknown)(requester, ...args);
-    }
-  }
-  return bound;
-}
-
-function createFailingApi(error: Error): BoundBeamApi {
-  return new Proxy(
-    {},
-    {
-      get() {
-        throw error;
-      },
-    },
-  ) as BoundBeamApi;
-}
-
-type ServiceMap = {
-  account: AccountService;
-  announcements: AnnouncementsService;
-  auth: AuthService;
-  content: ContentService;
-  leaderboards: LeaderboardsService;
-  stats: StatsService;
-};
-
-type ServiceKey = keyof ServiceMap;
-
-class UnavailableRequester implements HttpRequester {
-  constructor(private readonly error: Error) {}
-
-  async request(): Promise<never> {
-    throw this.error;
-  }
-
-  set baseUrl(_: string) {
-    // no-op
-  }
-
-  set defaultHeaders(_: Record<string, string>) {
-    // no-op
-  }
-}
-
-class UnavailableBeamableServices implements BeamableMicroserviceServices {
-  private readonly requesterImpl: HttpRequester;
-  private readonly apiBindings: BoundBeamApi;
-
-  constructor(private readonly error: Error) {
-    this.requesterImpl = new UnavailableRequester(this.error);
-    this.apiBindings = createFailingApi(this.error);
-  }
-
-  private fail(): never {
-    throw this.error;
-  }
-
-  get account(): AccountService {
-    return this.fail();
-  }
-
-  get announcements(): AnnouncementsService {
-    return this.fail();
-  }
-
-  get auth(): AuthService {
-    return this.fail();
-  }
-
-  get content(): ContentService {
-    return this.fail();
-  }
-
-  get leaderboards(): LeaderboardsService {
-    return this.fail();
-  }
-
-  get stats(): StatsService {
-    return this.fail();
-  }
-
-  get inventory(): InventoryService {
-    return this.fail();
-  }
-
-  get storage(): StorageService {
-    return this.fail();
-  }
-
-  get federation(): FederationRegistry {
-    return this.fail();
-  }
-
-  get api(): BoundBeamApi {
-    return this.apiBindings;
-  }
-
-  get requester(): HttpRequester {
-    return this.requesterImpl;
-  }
-
-  hasScopes(..._scopes: string[]): boolean {
-    return false;
-  }
-
-  requireScopes(...scopes: string[]): void {
-    throw new MissingScopesError(scopes);
-  }
-
-  assumeUser(): BeamableMicroserviceServices {
-    return this;
-  }
-}
-
-class BeamableServicesFacade implements BeamableMicroserviceServices {
-  private readonly cache: Partial<Record<ServiceKey, ServiceMap[ServiceKey]>> = {};
-  private readonly apiBindings: BoundBeamApi;
-  private readonly storageService: StorageService;
-  private readonly scopes: Set<string>;
-  private readonly logger: Logger;
-  private readonly serviceName?: string;
-  private readonly federationRegistry?: FederationRegistry;
-  private inventoryClient?: InventoryService;
-
-  constructor(
-    private readonly manager: BeamableServiceManager,
-    private readonly beamServer: BeamServer,
-    private readonly userId: string,
-    scopes: Set<string>,
-    serviceName?: string,
-  ) {
-    this.apiBindings = this.manager.getBoundApi();
-    this.storageService = this.manager.getStorageService();
-    this.scopes = scopes;
-    this.serviceName = serviceName;
-    this.federationRegistry = serviceName ? this.manager.getFederationRegistry(serviceName) : undefined;
-    this.logger = this.manager.getLogger().child({ component: 'BeamableServicesFacade', service: serviceName });
-  }
-
-  private getOrCreate<K extends ServiceKey>(key: K, factory: () => ServiceMap[K]): ServiceMap[K] {
-    if (!this.cache[key]) {
-      this.cache[key] = factory();
-    }
-    return this.cache[key] as ServiceMap[K];
-  }
-
-  get account(): AccountService {
-    return this.getOrCreate('account', () => this.beamServer.account(this.userId));
-  }
-
-  get announcements(): AnnouncementsService {
-    return this.getOrCreate('announcements', () => this.beamServer.announcements(this.userId));
-  }
-
-  get auth(): AuthService {
-    return this.getOrCreate('auth', () => this.beamServer.auth(this.userId));
-  }
-
-  get content(): ContentService {
-    return this.getOrCreate('content', () => this.beamServer.content(this.userId));
-  }
-
-  get leaderboards(): LeaderboardsService {
-    return this.getOrCreate('leaderboards', () => this.beamServer.leaderboards(this.userId));
-  }
-
-  get stats(): StatsService {
-    return this.getOrCreate('stats', () => this.beamServer.stats(this.userId));
-  }
-
-  get inventory(): InventoryService {
-    if (!this.inventoryClient) {
-      this.inventoryClient = createInventoryService(
-        this.apiBindings,
-        this.logger.child({ component: 'InventoryClient' }),
-        this.userId,
-        (requiredScopes) => this.hasScopes(...requiredScopes),
-      );
-    }
-    return this.inventoryClient;
-  }
-
-  get storage(): StorageService {
-    return this.storageService;
-  }
-
-  get federation(): FederationRegistry {
-    if (!this.federationRegistry) {
-      throw new Error(
-        this.serviceName
-          ? `Federation registry is not configured for service "${this.serviceName}".`
-          : 'Federation registry is not configured.',
-      );
-    }
-    return this.federationRegistry;
-  }
-
-  get api(): BoundBeamApi {
-    return this.apiBindings;
-  }
-
-  get requester(): HttpRequester {
-    return this.manager.getRequester();
-  }
-
-  hasScopes(...requiredScopes: string[]): boolean {
-    if (requiredScopes.length === 0) {
-      return true;
-    }
-    return requiredScopes.every((scope) => this.scopeSetHas(scope));
-  }
-
-  requireScopes(...requiredScopes: string[]): void {
-    if (!this.hasScopes(...requiredScopes)) {
-      throw new MissingScopesError(requiredScopes);
-    }
-  }
-
-  assumeUser(userId: string | number): BeamableMicroserviceServices {
-    return this.manager.createFacade(String(userId), new Set(this.scopes), this.serviceName);
-  }
-
-  private scopeSetHas(scope: string): boolean {
-    const normalized = scope.trim().toLowerCase();
-    if (!normalized) {
-      return false;
-    }
-    return this.scopes.has('*') || this.scopes.has(normalized);
-  }
-}
-
-export interface BeamableMicroserviceServices {
-  readonly account: AccountService;
-  readonly announcements: AnnouncementsService;
-  readonly auth: AuthService;
-  readonly content: ContentService;
-  readonly leaderboards: LeaderboardsService;
-  readonly stats: StatsService;
-  readonly inventory: InventoryService;
-  readonly storage: StorageService;
-  readonly federation: FederationRegistry;
-  readonly api: BoundBeamApi;
-  readonly requester: HttpRequester;
-  hasScopes(...scopes: string[]): boolean;
-  requireScopes(...scopes: string[]): void;
-  assumeUser(userId: string | number): BeamableMicroserviceServices;
-}
-
-export class BeamableServiceManager {
-  private readonly logger: Logger;
-  private readonly tokenStorage: ReturnType<typeof defaultTokenStorage>;
-  private readonly env: EnvironmentConfig;
-  private beamServer?: BeamServer;
-  private boundApi?: BoundBeamApi;
-  private storageService?: StorageService;
-  private initialized = false;
-  private readonly federationRegistries = new Map<string, FederationRegistry>();
-
-  constructor(env: EnvironmentConfig, logger: Logger) {
-    this.env = env;
-    this.logger = logger.child({ component: 'BeamableServiceManager' });
-    this.tokenStorage = defaultTokenStorage({ pid: env.pid, tag: env.routingKey ?? RUNTIME_ENVIRONMENT_NAME });
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.registerEnvironment();
-    this.configureSharedEnvironment();
-
-    if (this.env.refreshToken) {
-      await this.tokenStorage.setTokenData({ refreshToken: this.env.refreshToken });
-    }
-
-    const useSignedRequest = Boolean(this.env.secret);
-    if (!useSignedRequest && !this.env.refreshToken) {
-      this.logger.warn(
-        'Beamable realm secret and refresh token are both missing; Beamable SDK requests may fail due to missing credentials.',
-      );
-    }
-
-    try {
-      this.beamServer = await BeamServer.init({
-        cid: this.env.cid,
-        pid: this.env.pid,
-        environment: RUNTIME_ENVIRONMENT_NAME,
-        useSignedRequest,
-        tokenStorage: this.tokenStorage,
-        serverEvents: { enabled: false },
-      });
-    } catch (error) {
-      this.logger.error({ err: error }, 'Failed to initialize Beamable SDK. Services layer will be unavailable.');
-      this.beamServer = undefined;
-      this.initialized = false;
-      return;
-    }
-
-    this.boundApi = await bindBeamApi(this.beamServer.requester);
-    
-    // Configure the requester's default headers to include the routing key in the correct format
-    // The routing key format is: serviceName:routingKey
-    // We'll set this per-request in createFacade since we need the service name
-    this.storageService = new StorageService({
-      requester: this.beamServer.requester,
-      api: this.boundApi,
-      env: this.env,
-      logger: this.logger.child({ component: 'StorageService' }),
-    });
-
-    this.registerDefaultServices();
-    this.initialized = true;
-    this.logger.debug('Beamable SDK services initialized.');
-  }
-
-  createFacade(userId: string | number, scopes: Set<string>, serviceName?: string): BeamableMicroserviceServices {
-    if (!this.initialized || !this.beamServer || !this.boundApi || !this.storageService) {
-      return new UnavailableBeamableServices(new Error('Beamable services are not initialized.'));
-    }
-    
-    // Set the routing key in the format serviceName:routingKey for the SDK
-    // The SDK uses BEAM_ROUTING_KEY environment variable to construct the X-BEAM-SERVICE-ROUTING-KEY header
-    // We need to set it to the full format: serviceName:routingKey
-    if (serviceName && this.beamServer.requester) {
-      const fullRoutingKey = `micro_${serviceName}:${this.env.routingKey}`;
-      BeamServer.env.BEAM_ROUTING_KEY = fullRoutingKey;
-      
-      // Set default headers on the requester for all SDK requests
-      // These headers are required for signature validation and routing
-      const scopeHeader = `${this.env.cid}.${this.env.pid}`;
-      this.beamServer.requester.defaultHeaders = {
-        ...this.beamServer.requester.defaultHeaders,
-        'X-BEAM-SCOPE': scopeHeader,
-        'X-BEAM-SERVICE-ROUTING-KEY': fullRoutingKey,
-      };
-    }
-    
-    return new BeamableServicesFacade(this, this.beamServer, String(userId), new Set(scopes), serviceName);
-  }
-
-  getRequester(): HttpRequester {
-    if (!this.initialized || !this.beamServer) {
-      return new UnavailableRequester(new Error('Beamable services are not initialized.'));
-    }
-    return this.beamServer.requester;
-  }
-
-  getBoundApi(): BoundBeamApi {
-    if (!this.boundApi) {
-      throw new Error('Beamable bound API is not available.');
-    }
-    return this.boundApi;
-  }
-
-  getStorageService(): StorageService {
-    if (!this.storageService) {
-      throw new Error('Storage service is not initialized.');
-    }
-    return this.storageService;
-  }
-
-  getLogger(): Logger {
-    return this.logger;
-  }
-
-  registerFederationRegistry(serviceName: string, registry: FederationRegistry): void {
-    this.federationRegistries.set(serviceName, registry);
-  }
-
-  getFederationRegistry(serviceName: string): FederationRegistry | undefined {
-    return this.federationRegistries.get(serviceName);
-  }
-
-  private registerEnvironment(): void {
-    const apiUrl = hostToHttpUrl(this.env.host);
-    const portalUrl = hostToPortalUrl(apiUrl);
-    const storageUrl = hostToStorageUrl(apiUrl);
-    const registryUrl = hostToMicroserviceRegistryUrl(apiUrl);
-
-    try {
-      BeamEnvironment.register(RUNTIME_ENVIRONMENT_NAME, {
-        apiUrl,
-        portalUrl,
-        beamMongoExpressUrl: storageUrl,
-        dockerRegistryUrl: `${registryUrl}/v2/`,
-      });
-    } catch (error) {
-      this.logger.debug({ err: error }, 'Beamable environment was already registered. Reusing existing configuration.');
-    }
-  }
-
-  private configureSharedEnvironment(): void {
-    if (this.env.secret) {
-      BeamServer.env.BEAM_REALM_SECRET = this.env.secret;
-    }
-    // BEAM_ROUTING_KEY is used by the SDK to construct the X-BEAM-SERVICE-ROUTING-KEY header
-    // We set it to just the routing key value here, and will set the full format in createFacade
-    // BEAM_ROUTING_KEY is used by the SDK to construct the X-BEAM-SERVICE-ROUTING-KEY header
-    // For deployed services, routingKey is undefined, so we set it to empty string
-    // The SDK will handle this appropriately
-    BeamServer.env.BEAM_ROUTING_KEY = this.env.routingKey ?? '';
-  }
-
-  private registerDefaultServices(): void {
-    if (!this.beamServer) {
-      return;
-    }
-    this.beamServer.use(AccountService);
-    this.beamServer.use(AnnouncementsService);
-    this.beamServer.use(AuthService);
-    this.beamServer.use(ContentService);
-    this.beamServer.use(LeaderboardsService);
-    this.beamServer.use(StatsService);
-  }
-}

package/src/storage.ts

@@ -1,206 +0,0 @@
-import type { Logger } from 'pino';
-import { MongoClient, type Db, type Collection, type Document } from 'mongodb';
-import type { BoundBeamApi } from './services.js';
-import type { EnvironmentConfig } from './types.js';
-import type { HttpRequester } from 'beamable-sdk';
-
-export interface StorageConnectionOptions {
-  useCache?: boolean;
-}
-
-export interface StorageCollectionOptions extends StorageConnectionOptions {
-  collectionName?: string;
-}
-
-export interface StorageMetadata {
-  storageName: string;
-}
-
-const STORAGE_OBJECT_METADATA = new Map<Function, StorageMetadata>();
-
-export function StorageObject(storageName: string): ClassDecorator {
-  if (!storageName || !storageName.trim()) {
-    throw new Error('@StorageObject requires a non-empty storage name.');
-  }
-  return (target) => {
-    STORAGE_OBJECT_METADATA.set(target, { storageName: storageName.trim() });
-  };
-}
-
-export function getStorageMetadata(target: Function): StorageMetadata | undefined {
-  return STORAGE_OBJECT_METADATA.get(target);
-}
-
-export function listRegisteredStorageObjects(): StorageMetadata[] {
-  return Array.from(STORAGE_OBJECT_METADATA.values());
-}
-
-interface StorageServiceDependencies {
-  requester: HttpRequester;
-  api: BoundBeamApi;
-  env: EnvironmentConfig;
-  logger: Logger;
-}
-
-interface ConnectionStringResponse {
-  connectionString: string;
-}
-
-const CONNECTION_STRING_ENV_PREFIX = 'STORAGE_CONNSTR_';
-
-export class StorageService {
-  private readonly requester: HttpRequester;
-  private readonly api: BoundBeamApi;
-  private readonly env: EnvironmentConfig;
-  private readonly logger: Logger;
-  private readonly databaseCache = new Map<string, Db>();
-  private readonly clientCache = new Map<string, MongoClient>();
-  private cachedConnectionString?: string;
-
-  constructor(dependencies: StorageServiceDependencies) {
-    this.requester = dependencies.requester;
-    this.api = dependencies.api;
-    this.env = dependencies.env;
-    this.logger = dependencies.logger.child({ component: 'StorageService' });
-  }
-
-  async getDatabase(storageName: string, options: StorageConnectionOptions = {}): Promise<Db> {
-    const normalized = this.normalizeStorageName(storageName);
-    if (!options.useCache) {
-      this.databaseCache.delete(normalized);
-    }
-    const cached = this.databaseCache.get(normalized);
-    if (cached) {
-      return cached;
-    }
-
-    const connectionString = await this.getConnectionString(normalized);
-    const client = await this.getMongoClient(connectionString);
-    const databaseName = this.buildDatabaseName(normalized);
-    const database = client.db(databaseName);
-    this.databaseCache.set(normalized, database);
-    return database;
-  }
-
-  async getDatabaseFor<T>(storageCtor: new () => T, options: StorageConnectionOptions = {}): Promise<Db> {
-    const metadata = getStorageMetadata(storageCtor);
-    if (!metadata) {
-      throw new Error(
-        `Storage metadata for ${storageCtor.name} not found. Did you decorate the class with @StorageObject('Name')?`,
-      );
-    }
-    return this.getDatabase(metadata.storageName, options);
-  }
-
-  async getCollection<TDocument extends Document>(
-    storageName: string,
-    options: StorageCollectionOptions = {},
-  ): Promise<Collection<TDocument>> {
-    const database = await this.getDatabase(storageName, options);
-    const collectionName = options.collectionName?.trim();
-    if (!collectionName) {
-      throw new Error('Collection name must be provided when using getCollection with raw storage name.');
-    }
-    return database.collection<TDocument>(collectionName);
-  }
-
-  async getCollectionFor<TStorage, TDocument extends Document>(
-    storageCtor: new () => TStorage,
-    collectionCtor: new () => TDocument,
-    options: StorageCollectionOptions = {},
-  ): Promise<Collection<TDocument>> {
-    const metadata = getStorageMetadata(storageCtor);
-    if (!metadata) {
-      throw new Error(
-        `Storage metadata for ${storageCtor.name} not found. Did you decorate the class with @StorageObject('Name')?`,
-      );
-    }
-    const collectionName = options.collectionName?.trim() ?? collectionCtor.name;
-    const database = await this.getDatabase(metadata.storageName, options);
-    return database.collection<TDocument>(collectionName);
-  }
-
-  private async getMongoClient(connectionString: string): Promise<MongoClient> {
-    if (this.clientCache.has(connectionString)) {
-      return this.clientCache.get(connectionString) as MongoClient;
-    }
-    const client = new MongoClient(connectionString, {
-      maxPoolSize: 20,
-    });
-    await client.connect();
-    this.clientCache.set(connectionString, client);
-    return client;
-  }
-
-  private async getConnectionString(storageName: string): Promise<string> {
-    const variableName = `${CONNECTION_STRING_ENV_PREFIX}${storageName}`;
-    const envValue = process.env[variableName];
-    if (envValue && envValue.trim()) {
-      return envValue.trim();
-    }
-
-    if (this.cachedConnectionString) {
-      return this.cachedConnectionString;
-    }
-
-    const response = await this.fetchConnectionString();
-    if (!response.connectionString || !response.connectionString.trim()) {
-      throw new Error(`Connection string for storage "${storageName}" is empty.`);
-    }
-    this.cachedConnectionString = response.connectionString.trim();
-    return this.cachedConnectionString;
-  }
-
-  private async fetchConnectionString(): Promise<ConnectionStringResponse> {
-    if (typeof this.api.beamoGetStorageConnectionBasic === 'function') {
-      const result = await this.api.beamoGetStorageConnectionBasic();
-      if (result && typeof result === 'object' && 'body' in result) {
-        return (result as { body: ConnectionStringResponse }).body;
-      }
-      return result as ConnectionStringResponse;
-    }
-
-    this.logger.warn(
-      'beamable-sdk does not expose beamoGetStorageConnectionBasic; falling back to manual requester call.',
-    );
-    const response = await this.requester.request({
-      method: 'GET',
-      url: '/basic/beamo/storage/connection',
-      withAuth: true,
-    });
-    const body = response.body as ConnectionStringResponse | undefined;
-    if (!body || typeof body.connectionString !== 'string') {
-      throw new Error('Failed to retrieve Beamable storage connection string.');
-    }
-    return body;
-  }
-
-  private buildDatabaseName(storageName: string): string {
-    const cid = this.sanitize(this.env.cid);
-    const pid = this.sanitize(this.env.pid);
-    const storage = this.sanitize(storageName);
-    return `${cid}${pid}_${storage}`;
-  }
-
-  private sanitize(value: string): string {
-    return value.replace(/[^A-Za-z0-9_]/g, '_');
-  }
-
-  private normalizeStorageName(storageName: string): string {
-    const normalized = storageName.trim();
-    if (!normalized) {
-      throw new Error('Storage name cannot be empty.');
-    }
-    return normalized;
-  }
-
-  async dispose(): Promise<void> {
-    for (const client of this.clientCache.values()) {
-      await client.close();
-    }
-    this.clientCache.clear();
-    this.databaseCache.clear();
-    this.cachedConnectionString = undefined;
-  }
-}
-

package/src/types/beamable-sdk-api.d.ts

@@ -1,5 +0,0 @@
-declare module 'beamable-sdk/api' {
-  const api: Record<string, unknown>;
-  export default api;
-}
-