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

package/dist/env-loader.cjs

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDeveloperEnvVarsSync = loadDeveloperEnvVarsSync;
+exports.loadAndInjectEnvironmentVariables = loadAndInjectEnvironmentVariables;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_url_1 = require("node:url");
+const urls_js_1 = require("./utils/urls.js");
+function calculateSignature(pid, secret, uriPathAndQuery, body = null, version = '1') {
+    let dataToSign = `${secret}${pid}${version}${uriPathAndQuery}`;
+    if (body) {
+        dataToSign += body;
+    }
+    const hash = (0, node_crypto_1.createHash)('md5').update(dataToSign, 'utf8').digest('base64');
+    return hash;
+}
+function loadDeveloperEnvVarsSync(beamEnvPath) {
+    const envVars = loadDeveloperEnvVars(beamEnvPath);
+    let injectedCount = 0;
+    for (const [key, value] of Object.entries(envVars)) {
+        if (!(key in process.env)) {
+            process.env[key] = value;
+            injectedCount++;
+        }
+    }
+    if (injectedCount > 0) {
+        console.log(`[EnvLoader] Synchronously injected ${injectedCount} developer-defined variables from beam.env`);
+    }
+}
+function loadDeveloperEnvVars(beamEnvPath) {
+    const envVars = {};
+    const possiblePaths = [
+        beamEnvPath,
+        (0, node_path_1.join)(process.cwd(), 'beam.env'),
+        (0, node_path_1.join)(process.cwd(), '.beam.env'),
+        '/beam/service/beam.env',
+        '/beam/service/.beam.env',
+    ].filter((path) => !!path && (0, node_fs_1.existsSync)(path));
+    if (possiblePaths.length === 0) {
+        return envVars;
+    }
+    const envFilePath = possiblePaths[0];
+    try {
+        const content = (0, node_fs_1.readFileSync)(envFilePath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const match = trimmed.match(/^([^=#]+)=(.*)$/);
+            if (match) {
+                const key = match[1].trim();
+                let value = match[2].trim();
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                if (key) {
+                    envVars[key] = value;
+                }
+            }
+        }
+        console.log(`[EnvLoader] Loaded ${Object.keys(envVars).length} variables from ${envFilePath}`);
+    }
+    catch (error) {
+        console.warn(`[EnvLoader] Failed to load beam.env from ${envFilePath}:`, error instanceof Error ? error.message : String(error));
+    }
+    return envVars;
+}
+async function fetchBeamableConfig(env) {
+    const configVars = {};
+    if (!env.secret || !env.cid || !env.pid) {
+        console.log('[EnvLoader] Skipping Beamable Config fetch - missing SECRET, CID, or PID');
+        return configVars;
+    }
+    try {
+        const apiUrl = (0, urls_js_1.hostToHttpUrl)(env.host);
+        const uriPath = process.env.BEAM_CONFIG_API_PATH || '/api/basic/realms/config';
+        const configUrl = new node_url_1.URL(uriPath, apiUrl).toString();
+        const pathAndQuery = uriPath;
+        const signature = calculateSignature(env.pid, env.secret, pathAndQuery, null, '1');
+        console.log(`[EnvLoader] Fetching Beamable Config from ${configUrl}...`);
+        const response = await fetch(configUrl, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'X-BEAM-SCOPE': `${env.cid}.${env.pid}`,
+                'X-BEAM-SIGNATURE': signature,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            console.warn(`[EnvLoader] Failed to fetch Beamable Config: ${response.status} ${response.statusText} - ${errorText.substring(0, 200)}`);
+            return configVars;
+        }
+        const data = (await response.json());
+        const currentEnvironment = process.env.BEAM_ENVIRONMENT || process.env.ENVIRONMENT || env.pid;
+        if (data.config) {
+            for (const [key, environments] of Object.entries(data.config)) {
+                let value;
+                if (environments && typeof environments === 'object') {
+                    value = environments[currentEnvironment];
+                    if (value === undefined) {
+                        value = environments['production'] ||
+                            environments['staging'] ||
+                            environments['development'] ||
+                            environments['dev'] ||
+                            Object.values(environments)[0];
+                    }
+                }
+                if (value !== undefined && value !== null) {
+                    const envKey = `BEAM_CONFIG_${key.toUpperCase()}`;
+                    configVars[envKey] = String(value);
+                }
+            }
+            console.log(`[EnvLoader] Loaded ${Object.keys(configVars).length} variables from Beamable Config`);
+        }
+        else {
+            console.log('[EnvLoader] Beamable Config response contains no config object');
+        }
+    }
+    catch (error) {
+        console.warn('[EnvLoader] Failed to fetch Beamable Config:', error instanceof Error ? error.message : String(error));
+    }
+    return configVars;
+}
+async function loadAndInjectEnvironmentVariables(env, beamEnvPath, waitForConfig = true, timeoutMs = 2000) {
+    console.log('[EnvLoader] Starting environment variable loading...');
+    const developerVars = loadDeveloperEnvVars(beamEnvPath);
+    let injectedCount = 0;
+    for (const [key, value] of Object.entries(developerVars)) {
+        if (!(key in process.env)) {
+            process.env[key] = value;
+            injectedCount++;
+        }
+    }
+    if (injectedCount > 0) {
+        console.log(`[EnvLoader] Injected ${injectedCount} developer-defined variables from beam.env`);
+    }
+    if (waitForConfig) {
+        try {
+            const configPromise = fetchBeamableConfig(env);
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => {
+                    console.warn(`[EnvLoader] Beamable Config fetch timed out after ${timeoutMs}ms, continuing without it`);
+                    resolve({});
+                }, timeoutMs);
+            });
+            const beamableConfigVars = await Promise.race([configPromise, timeoutPromise]);
+            let configInjectedCount = 0;
+            for (const [key, value] of Object.entries(beamableConfigVars)) {
+                if (!(key in process.env)) {
+                    process.env[key] = value;
+                    configInjectedCount++;
+                }
+            }
+            if (configInjectedCount > 0) {
+                console.log(`[EnvLoader] Injected ${configInjectedCount} variables from Beamable Config`);
+            }
+        }
+        catch (error) {
+            console.warn('[EnvLoader] Error loading Beamable Config (continuing anyway):', error instanceof Error ? error.message : String(error));
+        }
+    }
+    else {
+        fetchBeamableConfig(env)
+            .then((beamableConfigVars) => {
+            let configInjectedCount = 0;
+            for (const [key, value] of Object.entries(beamableConfigVars)) {
+                if (!(key in process.env)) {
+                    process.env[key] = value;
+                    configInjectedCount++;
+                }
+            }
+            if (configInjectedCount > 0) {
+                console.log(`[EnvLoader] Injected ${configInjectedCount} variables from Beamable Config (loaded asynchronously)`);
+            }
+        })
+            .catch((error) => {
+            console.warn('[EnvLoader] Failed to load Beamable Config in background:', error instanceof Error ? error.message : String(error));
+        });
+    }
+    console.log('[EnvLoader] Environment variable loading completed');
+}

package/dist/env.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvironmentConfig = loadEnvironmentConfig;
+exports.ensureWritableTempDirectory = ensureWritableTempDirectory;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const routing_js_1 = require("./routing.js");
+function getBoolean(name, defaultValue = false) {
+    const raw = process.env[name];
+    if (!raw) {
+        return defaultValue;
+    }
+    return ['1', 'true', 'yes', 'on'].includes(raw.toLowerCase());
+}
+function getNumber(name, defaultValue) {
+    const raw = process.env[name];
+    if (!raw) {
+        return defaultValue;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : defaultValue;
+}
+function resolveHealthPort() {
+    const preferred = getNumber('HEALTH_PORT', 6565);
+    if (preferred > 0) {
+        return preferred;
+    }
+    const base = 45000;
+    const span = 2000;
+    const candidate = base + (process.pid % span);
+    return candidate;
+}
+function isInContainer() {
+    try {
+        const fs = require('fs');
+        if (fs.existsSync('/.dockerenv')) {
+            return true;
+        }
+    }
+    catch {
+    }
+    const hostname = process.env.HOSTNAME || '';
+    if (hostname && /^[a-f0-9]{12}$/i.test(hostname)) {
+        return true;
+    }
+    if (process.env.DOTNET_RUNNING_IN_CONTAINER === 'true' ||
+        process.env.CONTAINER === 'beamable' ||
+        !!process.env.ECS_CONTAINER_METADATA_URI ||
+        !!process.env.KUBERNETES_SERVICE_HOST) {
+        return true;
+    }
+    return false;
+}
+function resolveRoutingKey() {
+    var _a;
+    const raw = (_a = process.env.NAME_PREFIX) !== null && _a !== void 0 ? _a : process.env.ROUTING_KEY;
+    if (raw && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    if (isInContainer()) {
+        return undefined;
+    }
+    try {
+        return (0, routing_js_1.getDefaultRoutingKeyForMachine)();
+    }
+    catch (error) {
+        throw new Error(`Unable to determine routing key automatically. Set NAME_PREFIX environment variable. ${error.message}`);
+    }
+}
+function resolveSdkVersionExecution() {
+    var _a;
+    return (_a = process.env.BEAMABLE_SDK_VERSION_EXECUTION) !== null && _a !== void 0 ? _a : '';
+}
+function resolveLogLevel() {
+    var _a;
+    const candidate = (_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : 'info';
+    const allowed = new Set(['fatal', 'error', 'warn', 'info', 'debug', 'trace']);
+    return allowed.has(candidate.toLowerCase()) ? candidate.toLowerCase() : 'info';
+}
+function resolveWatchToken() {
+    const value = process.env.WATCH_TOKEN;
+    if (value === undefined) {
+        return false;
+    }
+    return getBoolean('WATCH_TOKEN', false);
+}
+function resolveBeamInstanceCount() {
+    return getNumber('BEAM_INSTANCE_COUNT', 1);
+}
+function loadEnvironmentConfig() {
+    var _a, _b, _c, _d, _e, _f;
+    const cid = (_a = process.env.CID) !== null && _a !== void 0 ? _a : '';
+    const pid = (_b = process.env.PID) !== null && _b !== void 0 ? _b : '';
+    const host = (_c = process.env.HOST) !== null && _c !== void 0 ? _c : '';
+    if (!cid || !pid || !host) {
+        throw new Error('Missing required Beamable environment variables (CID, PID, HOST).');
+    }
+    const config = {
+        cid,
+        pid,
+        host,
+        secret: (_d = process.env.SECRET) !== null && _d !== void 0 ? _d : undefined,
+        refreshToken: (_e = process.env.REFRESH_TOKEN) !== null && _e !== void 0 ? _e : undefined,
+        routingKey: resolveRoutingKey(),
+        accountId: getNumber('USER_ACCOUNT_ID', 0) || undefined,
+        accountEmail: (_f = process.env.USER_EMAIL) !== null && _f !== void 0 ? _f : undefined,
+        logLevel: resolveLogLevel(),
+        healthPort: resolveHealthPort(),
+        disableCustomInitializationHooks: getBoolean('DISABLE_CUSTOM_INITIALIZATION_HOOKS', false),
+        watchToken: resolveWatchToken(),
+        sdkVersionExecution: resolveSdkVersionExecution(),
+        beamInstanceCount: resolveBeamInstanceCount(),
+        logTruncateLimit: getNumber('LOG_TRUNCATE_LIMIT', 1000),
+    };
+    return config;
+}
+function ensureWritableTempDirectory() {
+    var _a;
+    const candidate = (_a = process.env.LOG_PATH) !== null && _a !== void 0 ? _a : (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'beamable-node-runtime');
+    if (!(0, node_fs_1.existsSync)(candidate)) {
+        return candidate;
+    }
+    return candidate;
+}

package/dist/errors.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidConfigurationError = exports.SerializationError = exports.UnknownRouteError = exports.UnauthorizedUserError = exports.MissingScopesError = exports.TimeoutError = exports.AuthenticationError = exports.BeamableRuntimeError = void 0;
+class BeamableRuntimeError extends Error {
+    constructor(code, message, cause) {
+        var _a;
+        super(message);
+        this.code = code;
+        if (cause !== undefined) {
+            this.cause = cause;
+        }
+        this.name = this.constructor.name;
+        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
+    }
+}
+exports.BeamableRuntimeError = BeamableRuntimeError;
+class AuthenticationError extends BeamableRuntimeError {
+    constructor(message, cause) {
+        super('AUTHENTICATION_FAILED', message, cause);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class TimeoutError extends BeamableRuntimeError {
+    constructor(message, cause) {
+        super('TIMEOUT', message, cause);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class MissingScopesError extends BeamableRuntimeError {
+    constructor(requiredScopes) {
+        super('MISSING_SCOPES', `Missing required scopes: ${Array.from(requiredScopes).join(', ')}`);
+    }
+}
+exports.MissingScopesError = MissingScopesError;
+class UnauthorizedUserError extends BeamableRuntimeError {
+    constructor(route) {
+        super('UNAUTHORIZED_USER', `Route "${route}" requires an authenticated user.`);
+    }
+}
+exports.UnauthorizedUserError = UnauthorizedUserError;
+class UnknownRouteError extends BeamableRuntimeError {
+    constructor(route) {
+        super('UNKNOWN_ROUTE', `No callable registered for route "${route}".`);
+    }
+}
+exports.UnknownRouteError = UnknownRouteError;
+class SerializationError extends BeamableRuntimeError {
+    constructor(message, cause) {
+        super('SERIALIZATION_ERROR', message, cause);
+    }
+}
+exports.SerializationError = SerializationError;
+class InvalidConfigurationError extends BeamableRuntimeError {
+    constructor(message, cause) {
+        super('INVALID_CONFIGURATION', message, cause);
+    }
+}
+exports.InvalidConfigurationError = InvalidConfigurationError;