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

package/src/types.ts

@@ -1,117 +0,0 @@
-import type { Logger } from 'pino';
-import type { BeamableMicroserviceServices } from './services.js';
-import type { DependencyScope } from './dependency.js';
-
-export type ServiceAccess = 'public' | 'client' | 'server' | 'admin';
-
-export interface MicroserviceOptions {
-  /** When true, legacy serialization is enabled for every callable unless overridden per method. */
-  useLegacySerialization?: boolean;
-  /** When true the runtime will skip auto-registration for Beamable events. */
-  disableAllBeamableEvents?: boolean;
-}
-
-export interface CallableOptions {
-  /** Optional explicit route name. Defaults to the method name. */
-  route?: string;
-  /** Whether an authenticated user is required for invocation. */
-  requireAuth?: boolean;
-  /** Scopes required for the invocation. */
-  requiredScopes?: string[];
-  /** Override legacy serialization behaviour for this callable. */
-  useLegacySerialization?: boolean;
-  access?: ServiceAccess;
-  /** Optional OpenAPI/Swagger tags to apply to the callable. */
-  tags?: string[];
-}
-
-export interface EnvironmentConfig {
-  cid: string;
-  pid: string;
-  host: string;
-  secret?: string;
-  refreshToken?: string;
-  routingKey?: string; // undefined for deployed services (becomes None in Scala)
-  accountId?: number;
-  accountEmail?: string;
-  logLevel: string;
-  healthPort: number;
-  disableCustomInitializationHooks: boolean;
-  watchToken: boolean;
-  sdkVersionExecution: string;
-  beamInstanceCount: number;
-  logTruncateLimit: number;
-}
-
-export interface GatewayRequest {
-  id: number;
-  method: string;
-  path: string;
-  from?: number;
-  body?: unknown;
-  scopes?: string[];
-  headers?: Record<string, string>;
-}
-
-export interface GatewayResponse<T = unknown> {
-  id: number;
-  status: number;
-  body: T;
-}
-
-export interface WebsocketEventEnvelope {
-  id: number;
-  status: number;
-  path?: string;
-  method?: string;
-  body?: unknown;
-  from?: number;
-  scopes?: string[];
-  headers?: Record<string, string>;
-}
-
-export interface RequestContext {
-  id: number;
-  path: string;
-  method: string;
-  status: number;
-  userId: number;
-  payload?: unknown;
-  body?: Record<string, unknown>;
-  scopes: Set<string>;
-  headers: Record<string, string>;
-  cid: string;
-  pid: string;
-  services: BeamableMicroserviceServices;
-  throwIfCancelled(): void;
-  isCancelled(): boolean;
-  hasScopes(...scopes: string[]): boolean;
-  requireScopes(...scopes: string[]): void;
-  provider: DependencyScope;
-}
-
-export interface ServiceCallableMetadata {
-  route: string;
-  displayName: string;
-  requireAuth: boolean;
-  requiredScopes: string[];
-  useLegacySerialization: boolean;
-  parameterTypes: ReadonlyArray<unknown>;
-  access: ServiceAccess;
-  tags: string[];
-}
-
-export interface ServiceDefinition {
-  name: string;
-  qualifiedName: string;
-  ctor: new (...args: unknown[]) => unknown;
-  callables: Map<string, ServiceCallableMetadata>;
-  options?: MicroserviceOptions;
-}
-
-export interface RuntimeComponents {
-  env: EnvironmentConfig;
-  logger: Logger;
-}
-
-export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };

package/src/utils/urls.ts

@@ -1,53 +0,0 @@
-export function hostToHttpUrl(host: string): string {
-  const normalized = host.replace(/\/$/, '');
-  if (normalized.startsWith('wss://')) {
-    return `https://${normalized.substring('wss://'.length).replace(/\/socket$/, '')}`;
-  }
-  if (normalized.startsWith('ws://')) {
-    return `http://${normalized.substring('ws://'.length).replace(/\/socket$/, '')}`;
-  }
-  return normalized.replace(/\/socket$/, '');
-}
-
-function transformApiHostname(hostname: string, replacement: string): string {
-  let host = hostname;
-  if (host.startsWith('dev.')) {
-    host = host.replace('dev.', 'dev-');
-  }
-  if (host.startsWith('api.')) {
-    return host.replace('api.', `${replacement}.`);
-  }
-  if (host.startsWith('api-')) {
-    return host.replace('api-', `${replacement}-`);
-  }
-  const index = host.indexOf('api');
-  if (index >= 0) {
-    return `${host.slice(0, index)}${replacement}${host.slice(index + 3)}`;
-  }
-  return host;
-}
-
-function transformHost(httpHost: string, replacement: string): string {
-  try {
-    const url = new URL(httpHost);
-    url.hostname = transformApiHostname(url.hostname, replacement);
-    url.pathname = '/';
-    url.search = '';
-    url.hash = '';
-    return url.toString().replace(/\/$/, '');
-  } catch (error) {
-    return transformApiHostname(httpHost, replacement);
-  }
-}
-
-export function hostToPortalUrl(httpHost: string): string {
-  return transformHost(httpHost, 'portal');
-}
-
-export function hostToStorageUrl(httpHost: string): string {
-  return transformHost(httpHost, 'storage');
-}
-
-export function hostToMicroserviceRegistryUrl(httpHost: string): string {
-  return transformHost(httpHost, 'microservices');
-}

package/src/websocket.ts

@@ -1,170 +0,0 @@
-import { setTimeout as sleep } from 'node:timers/promises';
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
-import type { Logger } from 'pino';
-
-export interface WebSocketOptions {
-  logger: Logger;
-  url: string;
-  maxRetries?: number;
-  retryDelayMs?: number;
-}
-
-export interface WebSocketEvents {
-  open: [];
-  close: [wasClean: boolean];
-  message: [payload: string];
-  error: [error: Error];
-}
-
-export class BeamableWebSocket {
-  private readonly logger: Logger;
-  private readonly url: string;
-  private readonly maxRetries: number;
-  private readonly retryDelayMs: number;
-  private readonly emitter = new EventEmitter();
-
-  private socket: WebSocket | null = null;
-  private isDisposed = false;
-
-  constructor(options: WebSocketOptions) {
-    this.logger = options.logger.child({ component: 'BeamableWebSocket' });
-    this.url = options.url;
-    this.maxRetries = options.maxRetries ?? 20;
-    this.retryDelayMs = options.retryDelayMs ?? 1000;
-  }
-
-  on(event: string, listener: (...args: unknown[]) => void): this {
-    this.emitter.on(event, listener);
-    return this;
-  }
-
-  off(event: string, listener: (...args: unknown[]) => void): this {
-    this.emitter.off(event, listener);
-    return this;
-  }
-
-  private emit<Event extends keyof WebSocketEvents>(event: Event, ...args: WebSocketEvents[Event]): void {
-    this.emitter.emit(event, ...args);
-  }
-
-  async connect(): Promise<void> {
-    let attempt = 0;
-    while (!this.isDisposed) {
-      try {
-        attempt += 1;
-        await this.createSocket();
-        return;
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        this.logger.warn({ err, attempt }, 'WebSocket connection attempt failed.');
-        if (attempt >= this.maxRetries) {
-          throw err;
-        }
-        await sleep(this.retryDelayMs * attempt);
-      }
-    }
-    throw new Error('WebSocket disposed before connection could be established.');
-  }
-
-  private async createSocket(): Promise<void> {
-    if (this.socket) {
-      this.socket.removeAllListeners();
-      this.socket.terminate();
-      this.socket = null;
-    }
-
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(this.url, {
-        perMessageDeflate: true,
-        handshakeTimeout: 30_000,
-      });
-
-      const handleOpen = () => {
-        this.logger.info({ url: this.url }, 'WebSocket connected.');
-        this.socket = ws;
-        ws.off('error', handleError);
-        ws.off('close', handlePrematureClose);
-        this.registerSocketHandlers(ws);
-        this.emit('open');
-        resolve();
-      };
-
-      const handleError = (error: Error) => {
-        ws.off('open', handleOpen);
-        ws.off('close', handlePrematureClose);
-        reject(error);
-      };
-
-      const handlePrematureClose = (code: number, reason: Buffer) => {
-        ws.off('open', handleOpen);
-        ws.off('error', handleError);
-        const err = new Error(`WebSocket closed before open handshake. code=${code} reason=${reason.toString()}`);
-        reject(err);
-      };
-
-      ws.on('open', handleOpen);
-      ws.on('error', handleError);
-      ws.on('close', handlePrematureClose);
-    });
-  }
-
-  private registerSocketHandlers(ws: WebSocket): void {
-    ws.on('message', (data) => {
-      const payload = typeof data === 'string' ? data : data.toString('utf8');
-      this.logger.debug({ payload }, 'WebSocket received frame.');
-      this.emit('message', payload);
-    });
-
-    ws.on('close', (code, reason) => {
-      this.logger.warn({ code, reason: reason.toString() }, 'WebSocket closed.');
-      this.emit('close', code === 1000);
-      if (!this.isDisposed) {
-        void this.reconnect();
-      }
-    });
-
-    ws.on('error', (error) => {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error({ err }, 'WebSocket error.');
-      this.emit('error', err);
-    });
-  }
-
-  private async reconnect(): Promise<void> {
-    this.logger.info('Attempting to reconnect websocket.');
-    let attempt = 0;
-    while (!this.isDisposed) {
-      try {
-        attempt += 1;
-        await this.createSocket();
-        this.emit('open');
-        return;
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        this.logger.warn({ err, attempt }, 'Retrying websocket connection.');
-        await sleep(this.retryDelayMs * Math.min(attempt, 10));
-      }
-    }
-  }
-
-  async send(text: string): Promise<void> {
-    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-      throw new Error('WebSocket is not connected.');
-    }
-    this.logger.debug({ message: text }, 'Sending websocket frame.');
-    this.socket.send(text);
-  }
-
-  async close(): Promise<void> {
-    this.isDisposed = true;
-    if (!this.socket) {
-      return;
-    }
-    const ws = this.socket;
-    if (ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
-      return;
-    }
-    ws.close(1000, 'shutdown');
-  }
-}

package/tsconfig.base.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": false,
-    "noImplicitOverride": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "resolveJsonModule": true,
-    "sourceMap": true,
-    "inlineSources": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "types": [
-      "node"
-    ],
-    "rootDir": "src"
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.d.ts"
-  ],
-  "exclude": [
-    "dist",
-    "node_modules"
-  ]
-}

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "declaration": true,
-    "declarationMap": true,
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext"
-  }
-}

package/tsconfig.cjs.json

@@ -1,16 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist-cjs",
-    "declaration": false,
-    "sourceMap": false,
-    "inlineSources": false,
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "target": "ES2019",
-    "removeComments": true
-  },
-  "exclude": [
-    "src/cli/**/*"
-  ]
-}

package/tsconfig.dev.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "ts-node": {
-    "esm": true,
-    "experimentalSpecifierResolution": "node"
-  },
-  "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "sourceMap": true,
-    "inlineSourceMap": false,
-    "outDir": "dist-dev"
-  }
-}