@mostajs/orm 1.0.0 → 1.2.0

package/dist/bridge/BridgeManager.js

@@ -0,0 +1,361 @@
+// BridgeManager — Singleton managing multiple JDBC bridge instances
+// Allows simultaneous connections to different SGBD via JDBC bridges on incrementing ports
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { JdbcNormalizer, parseUri } from './JdbcNormalizer.js';
+import { getJdbcDriverInfo } from './jdbc-registry.js';
+// ============================================================
+// BridgeManager singleton
+// ============================================================
+export class BridgeManager {
+    static instance = null;
+    bridges = new Map();
+    nextPort;
+    basePort;
+    portIncrement;
+    maxRetries;
+    retryResetMs;
+    startAttempts = new Map();
+    cleanupRegistered = false;
+    constructor() {
+        this.basePort = parseInt(process.env.MOSTA_BRIDGE_PORT_BASE || '8765');
+        this.nextPort = this.basePort;
+        this.portIncrement = (process.env.MOSTA_BRIDGE_PORT_INCREMENT ?? 'true') !== 'false';
+        this.maxRetries = parseInt(process.env.MOSTA_BRIDGE_MAX_RETRIES || '3');
+        this.retryResetMs = 60_000;
+        this.registerCleanupHandlers();
+        this.cleanupOrphans();
+    }
+    static getInstance() {
+        if (!BridgeManager.instance) {
+            BridgeManager.instance = new BridgeManager();
+        }
+        return BridgeManager.instance;
+    }
+    /** Reset singleton (for testing) */
+    static resetInstance() {
+        if (BridgeManager.instance) {
+            BridgeManager.instance.stopAllSync();
+            BridgeManager.instance = null;
+        }
+    }
+    // ============================================================
+    // Public API
+    // ============================================================
+    /**
+     * Get an existing bridge or create a new one for the given dialect/URI.
+     * If a bridge with the same key already exists and is alive, reuse it.
+     */
+    async getOrCreate(dialect, uri, options) {
+        const key = this.buildKey(dialect, uri);
+        // Check existing bridge
+        if (this.bridges.has(key)) {
+            const bridge = this.bridges.get(key);
+            if (await this.isAlive(bridge)) {
+                return bridge;
+            }
+            // Dead bridge — clean up and re-create
+            this.bridges.delete(key);
+            this.removePidFile(bridge.port);
+        }
+        // Anti-loop protection
+        this.checkStartAttempts(key);
+        // Autostart check
+        const autostart = process.env.MOSTA_BRIDGE_AUTOSTART ?? 'true';
+        if (autostart === 'false') {
+            // Try to detect an existing bridge on the expected port
+            const port = this.getNextPort();
+            if (await this.detectExistingBridge(port)) {
+                const parsed = parseUri(dialect, uri);
+                const jdbcUrl = JdbcNormalizer.composeJdbcUrl(dialect, parsed);
+                const normalizer = new JdbcNormalizer();
+                // Create a "virtual" bridge instance pointing to the manually started bridge
+                const bridge = {
+                    key,
+                    dialect,
+                    port,
+                    url: `http://localhost:${port}`,
+                    pid: 0, // Unknown — manually started
+                    jdbcUrl,
+                    startedAt: new Date(),
+                    normalizer,
+                };
+                // Set normalizer as active without starting a process
+                normalizer._active = true;
+                normalizer.bridgeUrl = bridge.url;
+                this.bridges.set(key, bridge);
+                console.log(`[BridgeManager] Reusing existing bridge on port ${port} for ${dialect}`);
+                return bridge;
+            }
+            const info = getJdbcDriverInfo(dialect);
+            throw new Error(`JDBC bridge disabled (MOSTA_BRIDGE_AUTOSTART=false).\n` +
+                `Start the bridge manually:\n` +
+                `  java --source 11 -cp ${info?.jarPrefix || 'driver'}*.jar \\\n` +
+                `    MostaJdbcBridge.java \\\n` +
+                `    --jdbc-url <jdbc-url> \\\n` +
+                `    --port ${this.basePort}\n` +
+                `Or set MOSTA_BRIDGE_AUTOSTART=true in .env`);
+        }
+        // Check detect mode — reuse existing if alive
+        if (autostart === 'detect') {
+            const port = this.getNextPort();
+            if (await this.detectExistingBridge(port)) {
+                const parsed = parseUri(dialect, uri);
+                const jdbcUrl = JdbcNormalizer.composeJdbcUrl(dialect, parsed);
+                const normalizer = new JdbcNormalizer();
+                const bridge = {
+                    key,
+                    dialect,
+                    port,
+                    url: `http://localhost:${port}`,
+                    pid: 0,
+                    jdbcUrl,
+                    startedAt: new Date(),
+                    normalizer,
+                };
+                normalizer._active = true;
+                normalizer.bridgeUrl = bridge.url;
+                this.bridges.set(key, bridge);
+                console.log(`[BridgeManager] Detected existing bridge on port ${port} for ${dialect}`);
+                return bridge;
+            }
+            // Not found — fall through to launch
+        }
+        // Launch a new bridge
+        try {
+            const bridge = await this.startBridge(dialect, uri, options);
+            this.startAttempts.delete(key); // Success — reset counter
+            return bridge;
+        }
+        catch (e) {
+            // Increment attempt counter
+            const current = this.startAttempts.get(key) || { count: 0, lastAttempt: new Date() };
+            current.count++;
+            current.lastAttempt = new Date();
+            this.startAttempts.set(key, current);
+            throw e;
+        }
+    }
+    /**
+     * Stop a specific bridge by key.
+     */
+    async stop(key) {
+        const bridge = this.bridges.get(key);
+        if (!bridge)
+            return;
+        bridge.normalizer.stop();
+        this.removePidFile(bridge.port);
+        this.bridges.delete(key);
+        console.log(`[BridgeManager] Stopped bridge ${key} on port ${bridge.port}`);
+    }
+    /**
+     * Stop ALL bridges (called on app exit).
+     */
+    async stopAll() {
+        for (const [key, bridge] of this.bridges) {
+            try {
+                bridge.normalizer.stop();
+                this.removePidFile(bridge.port);
+                console.log(`[BridgeManager] Stopped bridge ${key} on port ${bridge.port}`);
+            }
+            catch {
+                // Best effort
+            }
+        }
+        this.bridges.clear();
+    }
+    /**
+     * List all active bridges.
+     */
+    list() {
+        return Array.from(this.bridges.values());
+    }
+    /**
+     * Check if a bridge exists for the given key.
+     */
+    has(key) {
+        return this.bridges.has(key);
+    }
+    /**
+     * Build a bridge key from dialect and URI.
+     */
+    buildKey(dialect, uri) {
+        const parsed = parseUri(dialect, uri);
+        return `${dialect}:${parsed.host}:${parsed.port || ''}/${parsed.database || ''}`;
+    }
+    // ============================================================
+    // Internal
+    // ============================================================
+    async startBridge(dialect, uri, options) {
+        const port = this.getNextPort();
+        // Check port availability
+        if (await this.detectExistingBridge(port)) {
+            if (!this.portIncrement) {
+                throw new Error(`Port ${port} already in use.\n` +
+                    `Set MOSTA_BRIDGE_PORT_INCREMENT=true to auto-increment,\n` +
+                    `or change MOSTA_BRIDGE_PORT_BASE,\n` +
+                    `or stop the process using port ${port}: lsof -i :${port}`);
+            }
+            // Port taken — increment was already handled by getNextPort()
+            // but if we detect it's in use, try next
+            this.nextPort++;
+            return this.startBridge(dialect, uri, options);
+        }
+        const normalizer = new JdbcNormalizer();
+        await normalizer.start(dialect, uri, {
+            bridgePort: port,
+            jarDir: options?.jarDir,
+            bridgeJavaFile: options?.bridgeJavaFile,
+        });
+        const parsed = parseUri(dialect, uri);
+        const jdbcUrl = JdbcNormalizer.composeJdbcUrl(dialect, parsed);
+        const pid = normalizer.process?.pid ?? 0;
+        const key = this.buildKey(dialect, uri);
+        const bridge = {
+            key,
+            dialect,
+            port,
+            url: `http://localhost:${port}`,
+            pid,
+            jdbcUrl,
+            startedAt: new Date(),
+            normalizer,
+        };
+        this.bridges.set(key, bridge);
+        this.writePidFile(port, pid);
+        // Advance port for next bridge
+        if (this.portIncrement) {
+            this.nextPort = port + 1;
+        }
+        console.log(`[BridgeManager] Bridge started: ${key}\n` +
+            `  Port: ${port} | PID: ${pid} | JDBC: ${jdbcUrl}`);
+        return bridge;
+    }
+    getNextPort() {
+        return this.nextPort;
+    }
+    async isAlive(bridge) {
+        try {
+            const res = await fetch(`${bridge.url}/health`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async detectExistingBridge(port) {
+        try {
+            const res = await fetch(`http://localhost:${port}/health`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    checkStartAttempts(key) {
+        const attempts = this.startAttempts.get(key);
+        if (!attempts)
+            return;
+        const elapsed = Date.now() - attempts.lastAttempt.getTime();
+        if (elapsed < this.retryResetMs && attempts.count >= this.maxRetries) {
+            throw new Error(`JDBC bridge for "${key}" failed ${this.maxRetries} times in the last ${this.retryResetMs / 1000}s. Giving up.\n` +
+                `Diagnostic:\n` +
+                `  1. Java installed?  → java --version\n` +
+                `  2. JAR valid?       → ls jar_files/\n` +
+                `  3. SGBD running?    → check target port\n` +
+                `  4. Firewall?        → check bridge port\n` +
+                `Check Java installation, JAR file, and SGBD server.`);
+        }
+        if (elapsed >= this.retryResetMs) {
+            this.startAttempts.delete(key); // Reset after cooldown
+        }
+    }
+    // --- PID file management ---
+    getJarDir() {
+        return process.env.MOSTA_JAR_DIR || join(process.cwd(), 'jar_files');
+    }
+    writePidFile(port, pid) {
+        try {
+            const dir = this.getJarDir();
+            if (existsSync(dir)) {
+                writeFileSync(join(dir, `.bridge-${port}.pid`), String(pid));
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    removePidFile(port) {
+        try {
+            const pidFile = join(this.getJarDir(), `.bridge-${port}.pid`);
+            if (existsSync(pidFile)) {
+                unlinkSync(pidFile);
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    cleanupOrphans() {
+        try {
+            const dir = this.getJarDir();
+            if (!existsSync(dir))
+                return;
+            const pidFiles = readdirSync(dir).filter(f => f.startsWith('.bridge-') && f.endsWith('.pid'));
+            for (const file of pidFiles) {
+                try {
+                    const pidStr = readFileSync(join(dir, file), 'utf-8').trim();
+                    const pid = parseInt(pidStr);
+                    if (isNaN(pid) || pid <= 0) {
+                        unlinkSync(join(dir, file));
+                        continue;
+                    }
+                    // Check if process is still alive
+                    try {
+                        process.kill(pid, 0); // Signal 0 = check existence
+                        // Process alive — it's an orphan, kill it
+                        process.kill(pid, 'SIGTERM');
+                        console.log(`[BridgeManager] Killed orphan bridge process PID ${pid} (${file})`);
+                    }
+                    catch {
+                        // Process doesn't exist — just clean up the PID file
+                    }
+                    unlinkSync(join(dir, file));
+                }
+                catch {
+                    // Ignore individual file errors
+                }
+            }
+        }
+        catch {
+            // Non-critical — orphan cleanup is best-effort
+        }
+    }
+    // --- Cleanup handlers ---
+    registerCleanupHandlers() {
+        if (this.cleanupRegistered)
+            return;
+        this.cleanupRegistered = true;
+        const cleanup = () => this.stopAllSync();
+        process.on('exit', cleanup);
+        process.on('SIGINT', () => { cleanup(); process.exit(0); });
+        process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+    }
+    stopAllSync() {
+        for (const [, bridge] of this.bridges) {
+            try {
+                bridge.normalizer.stop();
+                this.removePidFile(bridge.port);
+            }
+            catch {
+                // Best effort
+            }
+        }
+        this.bridges.clear();
+    }
+}

package/dist/bridge/JdbcNormalizer.d.ts

@@ -0,0 +1,63 @@
+import type { DialectType } from '../core/types.js';
+export interface JdbcBridgeConfig {
+    dialect: DialectType;
+    host: string;
+    port?: number;
+    database: string;
+    user?: string;
+    password?: string;
+    bridgePort?: number;
+    jarDir?: string;
+    bridgeJavaFile?: string;
+}
+/**
+ * Parse a SGBD_URI into host/port/database/user/password components.
+ * Handles formats like:
+ *   hsqldb:hsql://localhost:9001/mydb
+ *   oracle://user:pass@host:1521/service
+ *   db2://user:pass@host:50000/mydb
+ */
+export declare function parseUri(dialect: DialectType, uri: string): Omit<JdbcBridgeConfig, 'dialect'>;
+export declare class JdbcNormalizer {
+    private process;
+    private bridgeUrl;
+    private _active;
+    /**
+     * Try to find a JAR for the given dialect.
+     * Returns the full path to the JAR, or null if not found.
+     */
+    static findJar(dialect: DialectType, jarDir?: string): string | null;
+    /**
+     * Check if a JDBC bridge is available for this dialect (JAR exists).
+     */
+    static isAvailable(dialect: DialectType, jarDir?: string): boolean;
+    /**
+     * Compose the JDBC URL from parsed URI components.
+     */
+    static composeJdbcUrl(dialect: DialectType, config: Omit<JdbcBridgeConfig, 'dialect'>): string;
+    /**
+     * Start the JDBC bridge for a given dialect and URI.
+     * Returns the HTTP base URL (e.g. http://localhost:8765).
+     */
+    start(dialect: DialectType, uri: string, options?: {
+        bridgePort?: number;
+        jarDir?: string;
+        bridgeJavaFile?: string;
+    }): Promise<string>;
+    /**
+     * Wait for the bridge health endpoint to respond.
+     */
+    private waitForReady;
+    /**
+     * Execute a query via the bridge HTTP endpoint.
+     */
+    query<T>(sql: string, params: unknown[]): Promise<T>;
+    /**
+     * Stop the bridge process.
+     */
+    stop(): void;
+    /** Whether the bridge is currently active */
+    get active(): boolean;
+    /** The HTTP base URL of the running bridge */
+    get url(): string;
+}

package/dist/bridge/JdbcNormalizer.js

@@ -0,0 +1,253 @@
+// JdbcNormalizer — Auto-detects JDBC JARs and manages the MostaJdbcBridge process
+// Sits between AbstractSqlDialect and MostaJdbcBridge.java
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { spawn } from 'child_process';
+import { readdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getJdbcDriverInfo } from './jdbc-registry.js';
+// Resolve paths relative to this file
+const __filename_resolved = typeof __filename !== 'undefined'
+    ? __filename
+    : fileURLToPath(import.meta.url);
+const __dirname_resolved = dirname(__filename_resolved);
+/** Default directory for JAR files — configurable via env MOSTA_JAR_DIR */
+function getDefaultJarDir() {
+    if (process.env.MOSTA_JAR_DIR)
+        return process.env.MOSTA_JAR_DIR;
+    // Look in mosta-orm/bridge/, then ../jar_files/ (monorepo layout)
+    const candidates = [
+        join(__dirname_resolved, '..', '..', 'bridge'),
+        join(__dirname_resolved, '..', '..', '..', 'jar_files'),
+        join(__dirname_resolved, '..', '..', 'jar_files'),
+    ];
+    for (const dir of candidates) {
+        if (existsSync(dir))
+            return dir;
+    }
+    return candidates[0];
+}
+/** Default path to MostaJdbcBridge.java */
+function getDefaultBridgeJavaPath() {
+    if (process.env.MOSTA_BRIDGE_JAVA)
+        return process.env.MOSTA_BRIDGE_JAVA;
+    const candidates = [
+        join(__dirname_resolved, '..', '..', 'bridge', 'MostaJdbcBridge.java'),
+        join(__dirname_resolved, '..', '..', '..', 'bridge', 'MostaJdbcBridge.java'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return candidates[0];
+}
+/**
+ * Parse a SGBD_URI into host/port/database/user/password components.
+ * Handles formats like:
+ *   hsqldb:hsql://localhost:9001/mydb
+ *   oracle://user:pass@host:1521/service
+ *   db2://user:pass@host:50000/mydb
+ */
+export function parseUri(dialect, uri) {
+    const info = getJdbcDriverInfo(dialect);
+    const defaultPort = info?.defaultPort ?? 9001;
+    const defaultUser = info?.defaultUser ?? 'SA';
+    const defaultPassword = info?.defaultPassword ?? '';
+    // Handle hsqldb:hsql://host:port/db
+    const hsqlMatch = uri.match(/^hsqldb:hsql:\/\/([^:/]+)(?::(\d+))?(?:\/(.*))?$/);
+    if (hsqlMatch) {
+        return {
+            host: hsqlMatch[1],
+            port: hsqlMatch[2] ? parseInt(hsqlMatch[2]) : defaultPort,
+            database: hsqlMatch[3] || '',
+            user: defaultUser,
+            password: defaultPassword,
+        };
+    }
+    // Handle dialect://user:pass@host:port/db
+    const standardMatch = uri.match(/^\w+:\/\/(?:([^:@]+)(?::([^@]*))?@)?([^:/]+)(?::(\d+))?(?:\/(.*))?$/);
+    if (standardMatch) {
+        return {
+            host: standardMatch[3],
+            port: standardMatch[4] ? parseInt(standardMatch[4]) : defaultPort,
+            database: standardMatch[5] || '',
+            user: standardMatch[1] ? decodeURIComponent(standardMatch[1]) : defaultUser,
+            password: standardMatch[2] ? decodeURIComponent(standardMatch[2]) : defaultPassword,
+        };
+    }
+    // Fallback
+    return {
+        host: 'localhost',
+        port: defaultPort,
+        database: '',
+        user: defaultUser,
+        password: defaultPassword,
+    };
+}
+// ============================================================
+// JdbcNormalizer class
+// ============================================================
+export class JdbcNormalizer {
+    process = null;
+    bridgeUrl = '';
+    _active = false;
+    /**
+     * Try to find a JAR for the given dialect.
+     * Returns the full path to the JAR, or null if not found.
+     */
+    static findJar(dialect, jarDir) {
+        const info = getJdbcDriverInfo(dialect);
+        if (!info)
+            return null;
+        const dir = jarDir || getDefaultJarDir();
+        if (!existsSync(dir))
+            return null;
+        try {
+            const files = readdirSync(dir)
+                .filter(f => f.startsWith(info.jarPrefix) && f.endsWith('.jar'))
+                .sort();
+            if (files.length === 0)
+                return null;
+            // Return the last (highest version) JAR
+            return join(dir, files[files.length - 1]);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if a JDBC bridge is available for this dialect (JAR exists).
+     */
+    static isAvailable(dialect, jarDir) {
+        return JdbcNormalizer.findJar(dialect, jarDir) !== null;
+    }
+    /**
+     * Compose the JDBC URL from parsed URI components.
+     */
+    static composeJdbcUrl(dialect, config) {
+        const info = getJdbcDriverInfo(dialect);
+        if (!info)
+            throw new Error(`No JDBC registry entry for dialect "${dialect}"`);
+        const port = config.port || info.defaultPort;
+        return info.jdbcUrlTemplate
+            .replace('{host}', config.host)
+            .replace('{port}', String(port))
+            .replace('{db}', config.database);
+    }
+    /**
+     * Start the JDBC bridge for a given dialect and URI.
+     * Returns the HTTP base URL (e.g. http://localhost:8765).
+     */
+    async start(dialect, uri, options) {
+        const jarDir = options?.jarDir || getDefaultJarDir();
+        const jarPath = JdbcNormalizer.findJar(dialect, jarDir);
+        if (!jarPath) {
+            const info = getJdbcDriverInfo(dialect);
+            throw new Error(`No JDBC JAR found for ${info?.label ?? dialect}.\n` +
+                `Expected: ${info?.jarPrefix}*.jar in ${jarDir}\n` +
+                `Download the JDBC driver and place it in the jar_files/ directory.`);
+        }
+        const parsed = parseUri(dialect, uri);
+        const jdbcUrl = JdbcNormalizer.composeJdbcUrl(dialect, parsed);
+        const bridgePort = options?.bridgePort || parseInt(process.env.MOSTA_BRIDGE_PORT || '8765');
+        const user = parsed.user || getJdbcDriverInfo(dialect).defaultUser;
+        const password = parsed.password ?? getJdbcDriverInfo(dialect).defaultPassword;
+        const bridgeJava = options?.bridgeJavaFile || getDefaultBridgeJavaPath();
+        if (!existsSync(bridgeJava)) {
+            throw new Error(`MostaJdbcBridge.java not found at ${bridgeJava}.\n` +
+                `Set MOSTA_BRIDGE_JAVA env or provide bridgeJavaFile option.`);
+        }
+        // Build classpath: JAR + bridge directory (for any companion JARs)
+        const classpath = jarPath;
+        this.process = spawn('java', [
+            '--source', '11',
+            '-cp', classpath,
+            bridgeJava,
+            '--jdbc-url', jdbcUrl,
+            '--user', user,
+            '--password', password,
+            '--port', String(bridgePort),
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Log bridge stderr for debugging
+        this.process.stderr?.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (msg)
+                console.error(`[JdbcBridge:${dialect}] ${msg}`);
+        });
+        this.process.on('exit', (code) => {
+            if (this._active) {
+                console.error(`[JdbcBridge:${dialect}] Process exited with code ${code}`);
+                this._active = false;
+            }
+        });
+        this.bridgeUrl = `http://localhost:${bridgePort}`;
+        // Wait for bridge to be ready
+        await this.waitForReady(bridgePort);
+        this._active = true;
+        console.log(`[JdbcNormalizer] Bridge started for ${dialect} → ${jdbcUrl} on port ${bridgePort}`);
+        return this.bridgeUrl;
+    }
+    /**
+     * Wait for the bridge health endpoint to respond.
+     */
+    async waitForReady(port, timeoutMs = 15000) {
+        const start = Date.now();
+        let lastError = '';
+        while (Date.now() - start < timeoutMs) {
+            try {
+                const res = await fetch(`http://localhost:${port}/health`);
+                if (res.ok)
+                    return;
+                lastError = `HTTP ${res.status}`;
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e.message : String(e);
+            }
+            await new Promise(r => setTimeout(r, 300));
+        }
+        // Kill the process if it didn't start
+        this.stop();
+        throw new Error(`JDBC bridge not ready after ${timeoutMs}ms on port ${port}.\n` +
+            `Last error: ${lastError}\n` +
+            `Ensure Java 11+ is installed: java --version`);
+    }
+    /**
+     * Execute a query via the bridge HTTP endpoint.
+     */
+    async query(sql, params) {
+        if (!this._active) {
+            throw new Error('JDBC bridge is not active. Call start() first.');
+        }
+        const response = await fetch(`${this.bridgeUrl}/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ sql, params }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`JDBC bridge query failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /**
+     * Stop the bridge process.
+     */
+    stop() {
+        this._active = false;
+        if (this.process) {
+            this.process.kill('SIGTERM');
+            this.process = null;
+        }
+        this.bridgeUrl = '';
+    }
+    /** Whether the bridge is currently active */
+    get active() {
+        return this._active;
+    }
+    /** The HTTP base URL of the running bridge */
+    get url() {
+        return this.bridgeUrl;
+    }
+}