@push.rocks/smartmongo 2.2.0 → 3.0.0

package/dist_ts/tsmdb/errors/TsmdbErrors.js

@@ -0,0 +1,155 @@
+/**
+ * Base error class for all TsmDB errors
+ * Mirrors MongoDB driver error hierarchy
+ */
+export class TsmdbError extends Error {
+    code;
+    codeName;
+    constructor(message, code, codeName) {
+        super(message);
+        this.name = 'TsmdbError';
+        this.code = code;
+        this.codeName = codeName;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Error thrown during connection issues
+ */
+export class TsmdbConnectionError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbConnectionError';
+    }
+}
+/**
+ * Error thrown when an operation times out
+ */
+export class TsmdbTimeoutError extends TsmdbError {
+    constructor(message) {
+        super(message, 50, 'MaxTimeMSExpired');
+        this.name = 'TsmdbTimeoutError';
+    }
+}
+/**
+ * Error thrown during write operations
+ */
+export class TsmdbWriteError extends TsmdbError {
+    writeErrors;
+    result;
+    constructor(message, code, writeErrors) {
+        super(message, code);
+        this.name = 'TsmdbWriteError';
+        this.writeErrors = writeErrors;
+    }
+}
+/**
+ * Error thrown for duplicate key violations
+ */
+export class TsmdbDuplicateKeyError extends TsmdbWriteError {
+    keyPattern;
+    keyValue;
+    constructor(message, keyPattern, keyValue) {
+        super(message, 11000);
+        this.name = 'TsmdbDuplicateKeyError';
+        this.codeName = 'DuplicateKey';
+        this.keyPattern = keyPattern;
+        this.keyValue = keyValue;
+    }
+}
+/**
+ * Error thrown for bulk write failures
+ */
+export class TsmdbBulkWriteError extends TsmdbError {
+    writeErrors;
+    result;
+    constructor(message, writeErrors, result) {
+        super(message, 65);
+        this.name = 'TsmdbBulkWriteError';
+        this.writeErrors = writeErrors;
+        this.result = result;
+    }
+}
+/**
+ * Error thrown during transaction operations
+ */
+export class TsmdbTransactionError extends TsmdbError {
+    constructor(message, code) {
+        super(message, code);
+        this.name = 'TsmdbTransactionError';
+    }
+}
+/**
+ * Error thrown when a transaction is aborted due to conflict
+ */
+export class TsmdbWriteConflictError extends TsmdbTransactionError {
+    constructor(message = 'Write conflict during transaction') {
+        super(message, 112);
+        this.name = 'TsmdbWriteConflictError';
+        this.codeName = 'WriteConflict';
+    }
+}
+/**
+ * Error thrown for invalid arguments
+ */
+export class TsmdbArgumentError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbArgumentError';
+    }
+}
+/**
+ * Error thrown when an operation is not supported
+ */
+export class TsmdbNotSupportedError extends TsmdbError {
+    constructor(message) {
+        super(message, 115);
+        this.name = 'TsmdbNotSupportedError';
+        this.codeName = 'CommandNotSupported';
+    }
+}
+/**
+ * Error thrown when cursor is exhausted or closed
+ */
+export class TsmdbCursorError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbCursorError';
+    }
+}
+/**
+ * Error thrown when a namespace (database.collection) is invalid
+ */
+export class TsmdbNamespaceError extends TsmdbError {
+    constructor(message) {
+        super(message, 73);
+        this.name = 'TsmdbNamespaceError';
+        this.codeName = 'InvalidNamespace';
+    }
+}
+/**
+ * Error thrown when an index operation fails
+ */
+export class TsmdbIndexError extends TsmdbError {
+    constructor(message, code) {
+        super(message, code || 86);
+        this.name = 'TsmdbIndexError';
+    }
+}
+/**
+ * Convert any error to a TsmdbError
+ */
+export function toTsmdbError(error) {
+    if (error instanceof TsmdbError) {
+        return error;
+    }
+    const tsmdbError = new TsmdbError(error.message || String(error));
+    if (error.code) {
+        tsmdbError.code = error.code;
+    }
+    if (error.codeName) {
+        tsmdbError.codeName = error.codeName;
+    }
+    return tsmdbError;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/{congodb → tsmdb}/index.d.ts

@@ -1,8 +1,8 @@
-import * as plugins from './congodb.plugins.js';
+import * as plugins from './tsmdb.plugins.js';
 export { plugins };
 export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
 export * from './types/interfaces.js';
-export * from './errors/CongoErrors.js';
+export * from './errors/TsmdbErrors.js';
 export type { IStorageAdapter } from './storage/IStorageAdapter.js';
 export { MemoryStorageAdapter } from './storage/MemoryStorageAdapter.js';
 export { FileStorageAdapter } from './storage/FileStorageAdapter.js';
@@ -12,8 +12,8 @@ export { UpdateEngine } from './engine/UpdateEngine.js';
 export { AggregationEngine } from './engine/AggregationEngine.js';
 export { IndexEngine } from './engine/IndexEngine.js';
 export { TransactionEngine } from './engine/TransactionEngine.js';
-export { CongoServer } from './server/CongoServer.js';
-export type { ICongoServerOptions } from './server/CongoServer.js';
+export { TsmdbServer } from './server/TsmdbServer.js';
+export type { ITsmdbServerOptions } from './server/TsmdbServer.js';
 export { WireProtocol } from './server/WireProtocol.js';
 export { CommandRouter } from './server/CommandRouter.js';
 export type { ICommandHandler, IHandlerContext, ICursorState } from './server/CommandRouter.js';

package/dist_ts/tsmdb/index.js

@@ -0,0 +1,26 @@
+// TsmDB - MongoDB Wire Protocol compatible in-memory database server
+// Use the official MongoDB driver to connect to TsmdbServer
+// Re-export plugins for external use
+import * as plugins from './tsmdb.plugins.js';
+export { plugins };
+// Export BSON types for convenience
+export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
+// Export all types
+export * from './types/interfaces.js';
+// Export errors
+export * from './errors/TsmdbErrors.js';
+export { MemoryStorageAdapter } from './storage/MemoryStorageAdapter.js';
+export { FileStorageAdapter } from './storage/FileStorageAdapter.js';
+export { OpLog } from './storage/OpLog.js';
+// Export engines
+export { QueryEngine } from './engine/QueryEngine.js';
+export { UpdateEngine } from './engine/UpdateEngine.js';
+export { AggregationEngine } from './engine/AggregationEngine.js';
+export { IndexEngine } from './engine/IndexEngine.js';
+export { TransactionEngine } from './engine/TransactionEngine.js';
+// Export server (the main entry point for using TsmDB)
+export { TsmdbServer } from './server/TsmdbServer.js';
+// Export wire protocol utilities (for advanced usage)
+export { WireProtocol } from './server/WireProtocol.js';
+export { CommandRouter } from './server/CommandRouter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c21kYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxRUFBcUU7QUFDckUsNERBQTREO0FBRTVELHFDQUFxQztBQUNyQyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQixvQ0FBb0M7QUFDcEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTNFLG1CQUFtQjtBQUNuQixjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGdCQUFnQjtBQUNoQixjQUFjLHlCQUF5QixDQUFDO0FBSXhDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzQyxpQkFBaUI7QUFDakIsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFbEUsdURBQXVEO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUd0RCxzREFBc0Q7QUFDdEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQyJ9

package/dist_ts/{congodb → tsmdb}/server/CommandRouter.d.ts

@@ -1,13 +1,13 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
 import type { IParsedCommand } from './WireProtocol.js';
-import type { CongoServer } from './CongoServer.js';
+import type { TsmdbServer } from './TsmdbServer.js';
 /**
  * Handler context passed to command handlers
  */
 export interface IHandlerContext {
     storage: IStorageAdapter;
-    server: CongoServer;
+    server: TsmdbServer;
     database: string;
     command: plugins.bson.Document;
     documentSequences?: Map<string, plugins.bson.Document[]>;
@@ -27,7 +27,7 @@ export declare class CommandRouter {
     private handlers;
     private cursors;
     private cursorIdCounter;
-    constructor(storage: IStorageAdapter, server: CongoServer);
+    constructor(storage: IStorageAdapter, server: TsmdbServer);
     /**
      * Register all command handlers
      */

package/dist_ts/tsmdb/server/CommandRouter.js

@@ -0,0 +1,132 @@
+import * as plugins from '../tsmdb.plugins.js';
+// Import handlers
+import { HelloHandler } from './handlers/HelloHandler.js';
+import { InsertHandler } from './handlers/InsertHandler.js';
+import { FindHandler } from './handlers/FindHandler.js';
+import { UpdateHandler } from './handlers/UpdateHandler.js';
+import { DeleteHandler } from './handlers/DeleteHandler.js';
+import { AggregateHandler } from './handlers/AggregateHandler.js';
+import { IndexHandler } from './handlers/IndexHandler.js';
+import { AdminHandler } from './handlers/AdminHandler.js';
+/**
+ * CommandRouter - Routes incoming commands to appropriate handlers
+ */
+export class CommandRouter {
+    storage;
+    server;
+    handlers = new Map();
+    // Cursor state for getMore operations
+    cursors = new Map();
+    cursorIdCounter = BigInt(1);
+    constructor(storage, server) {
+        this.storage = storage;
+        this.server = server;
+        this.registerHandlers();
+    }
+    /**
+     * Register all command handlers
+     */
+    registerHandlers() {
+        // Create handler instances with shared state
+        const helloHandler = new HelloHandler();
+        const findHandler = new FindHandler(this.cursors, () => this.cursorIdCounter++);
+        const insertHandler = new InsertHandler();
+        const updateHandler = new UpdateHandler();
+        const deleteHandler = new DeleteHandler();
+        const aggregateHandler = new AggregateHandler(this.cursors, () => this.cursorIdCounter++);
+        const indexHandler = new IndexHandler();
+        const adminHandler = new AdminHandler();
+        // Handshake commands
+        this.handlers.set('hello', helloHandler);
+        this.handlers.set('ismaster', helloHandler);
+        this.handlers.set('isMaster', helloHandler);
+        // CRUD commands
+        this.handlers.set('find', findHandler);
+        this.handlers.set('insert', insertHandler);
+        this.handlers.set('update', updateHandler);
+        this.handlers.set('delete', deleteHandler);
+        this.handlers.set('findAndModify', updateHandler);
+        this.handlers.set('getMore', findHandler);
+        this.handlers.set('killCursors', findHandler);
+        // Aggregation
+        this.handlers.set('aggregate', aggregateHandler);
+        this.handlers.set('count', findHandler);
+        this.handlers.set('distinct', findHandler);
+        // Index operations
+        this.handlers.set('createIndexes', indexHandler);
+        this.handlers.set('dropIndexes', indexHandler);
+        this.handlers.set('listIndexes', indexHandler);
+        // Admin/Database operations
+        this.handlers.set('ping', adminHandler);
+        this.handlers.set('listDatabases', adminHandler);
+        this.handlers.set('listCollections', adminHandler);
+        this.handlers.set('drop', adminHandler);
+        this.handlers.set('dropDatabase', adminHandler);
+        this.handlers.set('create', adminHandler);
+        this.handlers.set('serverStatus', adminHandler);
+        this.handlers.set('buildInfo', adminHandler);
+        this.handlers.set('whatsmyuri', adminHandler);
+        this.handlers.set('getLog', adminHandler);
+        this.handlers.set('hostInfo', adminHandler);
+        this.handlers.set('replSetGetStatus', adminHandler);
+        this.handlers.set('isMaster', helloHandler);
+        this.handlers.set('saslStart', adminHandler);
+        this.handlers.set('saslContinue', adminHandler);
+        this.handlers.set('endSessions', adminHandler);
+        this.handlers.set('abortTransaction', adminHandler);
+        this.handlers.set('commitTransaction', adminHandler);
+        this.handlers.set('collStats', adminHandler);
+        this.handlers.set('dbStats', adminHandler);
+        this.handlers.set('connectionStatus', adminHandler);
+        this.handlers.set('currentOp', adminHandler);
+        this.handlers.set('collMod', adminHandler);
+        this.handlers.set('renameCollection', adminHandler);
+    }
+    /**
+     * Route a command to its handler
+     */
+    async route(parsedCommand) {
+        const { commandName, command, database, documentSequences } = parsedCommand;
+        // Create handler context
+        const context = {
+            storage: this.storage,
+            server: this.server,
+            database,
+            command,
+            documentSequences,
+        };
+        // Find handler
+        const handler = this.handlers.get(commandName);
+        if (!handler) {
+            // Unknown command
+            return {
+                ok: 0,
+                errmsg: `no such command: '${commandName}'`,
+                code: 59,
+                codeName: 'CommandNotFound',
+            };
+        }
+        try {
+            return await handler.handle(context);
+        }
+        catch (error) {
+            // Handle known error types
+            if (error.code) {
+                return {
+                    ok: 0,
+                    errmsg: error.message,
+                    code: error.code,
+                    codeName: error.codeName || 'UnknownError',
+                };
+            }
+            // Generic error
+            return {
+                ok: 0,
+                errmsg: error.message || 'Internal error',
+                code: 1,
+                codeName: 'InternalError',
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/{congodb/server/CongoServer.d.ts → tsmdb/server/TsmdbServer.d.ts}

@@ -2,7 +2,7 @@ import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
 /**
  * Server configuration options
  */
-export interface ICongoServerOptions {
+export interface ITsmdbServerOptions {
     /** Port to listen on (default: 27017) */
     port?: number;
     /** Host to bind to (default: 127.0.0.1) */
@@ -17,24 +17,24 @@ export interface ICongoServerOptions {
     persistIntervalMs?: number;
 }
 /**
- * CongoServer - MongoDB Wire Protocol compatible server
+ * TsmdbServer - MongoDB Wire Protocol compatible server
  *
  * This server implements the MongoDB wire protocol (OP_MSG) to allow
  * official MongoDB drivers to connect and perform operations.
  *
  * @example
  * ```typescript
- * import { CongoServer } from '@push.rocks/smartmongo/congodb';
+ * import { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
  * import { MongoClient } from 'mongodb';
  *
- * const server = new CongoServer({ port: 27017 });
+ * const server = new TsmdbServer({ port: 27017 });
  * await server.start();
  *
  * const client = new MongoClient('mongodb://127.0.0.1:27017');
  * await client.connect();
  * ```
  */
-export declare class CongoServer {
+export declare class TsmdbServer {
     private options;
     private server;
     private storage;
@@ -43,7 +43,7 @@ export declare class CongoServer {
     private connectionIdCounter;
     private isRunning;
     private startTime;
-    constructor(options?: ICongoServerOptions);
+    constructor(options?: ITsmdbServerOptions);
     /**
      * Get the storage adapter (for testing/debugging)
      */

package/dist_ts/tsmdb/server/TsmdbServer.js

@@ -0,0 +1,227 @@
+import * as net from 'net';
+import * as plugins from '../tsmdb.plugins.js';
+import { WireProtocol, OP_QUERY } from './WireProtocol.js';
+import { CommandRouter } from './CommandRouter.js';
+import { MemoryStorageAdapter } from '../storage/MemoryStorageAdapter.js';
+import { FileStorageAdapter } from '../storage/FileStorageAdapter.js';
+/**
+ * TsmdbServer - MongoDB Wire Protocol compatible server
+ *
+ * This server implements the MongoDB wire protocol (OP_MSG) to allow
+ * official MongoDB drivers to connect and perform operations.
+ *
+ * @example
+ * ```typescript
+ * import { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new TsmdbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * await client.connect();
+ * ```
+ */
+export class TsmdbServer {
+    options;
+    server = null;
+    storage;
+    commandRouter;
+    connections = new Map();
+    connectionIdCounter = 0;
+    isRunning = false;
+    startTime = new Date();
+    constructor(options = {}) {
+        this.options = {
+            port: options.port ?? 27017,
+            host: options.host ?? '127.0.0.1',
+            storage: options.storage ?? 'memory',
+            storagePath: options.storagePath ?? './data',
+            persistPath: options.persistPath ?? '',
+            persistIntervalMs: options.persistIntervalMs ?? 60000,
+        };
+        // Create storage adapter
+        if (this.options.storage === 'file') {
+            this.storage = new FileStorageAdapter(this.options.storagePath);
+        }
+        else {
+            this.storage = new MemoryStorageAdapter({
+                persistPath: this.options.persistPath || undefined,
+                persistIntervalMs: this.options.persistPath ? this.options.persistIntervalMs : undefined,
+            });
+        }
+        // Create command router
+        this.commandRouter = new CommandRouter(this.storage, this);
+    }
+    /**
+     * Get the storage adapter (for testing/debugging)
+     */
+    getStorage() {
+        return this.storage;
+    }
+    /**
+     * Get server uptime in seconds
+     */
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+    }
+    /**
+     * Get current connection count
+     */
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Server is already running');
+        }
+        // Initialize storage
+        await this.storage.initialize();
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                if (!this.isRunning) {
+                    reject(err);
+                }
+                else {
+                    console.error('Server error:', err);
+                }
+            });
+            this.server.listen(this.options.port, this.options.host, () => {
+                this.isRunning = true;
+                this.startTime = new Date();
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        if (!this.isRunning || !this.server) {
+            return;
+        }
+        // Close all connections
+        for (const conn of this.connections.values()) {
+            conn.socket.destroy();
+        }
+        this.connections.clear();
+        // Close storage
+        await this.storage.close();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.isRunning = false;
+                this.server = null;
+                resolve();
+            });
+        });
+    }
+    /**
+     * Handle a new client connection
+     */
+    handleConnection(socket) {
+        const connectionId = ++this.connectionIdCounter;
+        const state = {
+            id: connectionId,
+            socket,
+            buffer: Buffer.alloc(0),
+            authenticated: true, // No auth required for now
+            database: 'test',
+        };
+        this.connections.set(connectionId, state);
+        socket.on('data', (data) => {
+            this.handleData(state, Buffer.isBuffer(data) ? data : Buffer.from(data));
+        });
+        socket.on('close', () => {
+            this.connections.delete(connectionId);
+        });
+        socket.on('error', (err) => {
+            // Connection errors are expected when clients disconnect
+            this.connections.delete(connectionId);
+        });
+    }
+    /**
+     * Handle incoming data from a client
+     */
+    handleData(state, data) {
+        // Append new data to buffer
+        state.buffer = Buffer.concat([state.buffer, data]);
+        // Process messages from buffer
+        this.processMessages(state);
+    }
+    /**
+     * Process complete messages from the buffer
+     */
+    async processMessages(state) {
+        while (state.buffer.length >= 16) {
+            try {
+                const result = WireProtocol.parseMessage(state.buffer);
+                if (!result) {
+                    // Not enough data for a complete message
+                    break;
+                }
+                const { command, bytesConsumed } = result;
+                // Remove processed bytes from buffer
+                state.buffer = state.buffer.subarray(bytesConsumed);
+                // Process the command
+                const response = await this.commandRouter.route(command);
+                // Encode and send response
+                let responseBuffer;
+                if (command.opCode === OP_QUERY) {
+                    // Legacy OP_QUERY gets OP_REPLY response
+                    responseBuffer = WireProtocol.encodeOpReplyResponse(command.requestID, [response]);
+                }
+                else {
+                    // OP_MSG gets OP_MSG response
+                    responseBuffer = WireProtocol.encodeOpMsgResponse(command.requestID, response);
+                }
+                if (!state.socket.destroyed) {
+                    state.socket.write(responseBuffer);
+                }
+            }
+            catch (error) {
+                // Send error response
+                const errorResponse = WireProtocol.encodeErrorResponse(0, // We don't have the requestID at this point
+                1, error.message || 'Internal error');
+                if (!state.socket.destroyed) {
+                    state.socket.write(errorResponse);
+                }
+                // Clear buffer on parse errors to avoid infinite loops
+                if (error.message?.includes('opCode') || error.message?.includes('section')) {
+                    state.buffer = Buffer.alloc(0);
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Get the connection URI for this server
+     */
+    getConnectionUri() {
+        return `mongodb://${this.options.host}:${this.options.port}`;
+    }
+    /**
+     * Check if the server is running
+     */
+    get running() {
+        return this.isRunning;
+    }
+    /**
+     * Get the port the server is listening on
+     */
+    get port() {
+        return this.options.port;
+    }
+    /**
+     * Get the host the server is bound to
+     */
+    get host() {
+        return this.options.host;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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