axiodb
Version:
The Pure JavaScript Alternative to SQLite. Embedded NoSQL database for Node.js with MongoDB-style queries, zero native dependencies, built-in InMemoryCache, and web GUI. Perfect for desktop apps, CLI tools, and embedded systems. No compilation, no platfor
156 lines • 6.8 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = createAxioDBTCPServer;
exports.shutdownTCPServer = shutdownTCPServer;
const net_1 = require("net");
const ConnectionManager_1 = require("../connection/ConnectionManager");
const CommandHandler_1 = require("../handler/CommandHandler");
const RequestContext_1 = require("../connection/RequestContext");
const protocol_1 = require("./protocol");
const keys_1 = require("./keys");
const command_types_1 = require("../types/command.types");
/**
* TCP Server for AxioDB
* Provides remote access to AxioDB via TCP protocol
*/
function createAxioDBTCPServer(axioDB_1) {
return __awaiter(this, arguments, void 0, function* (axioDB, port = keys_1.DEFAULT_TCP_PORT) {
const connectionManager = new ConnectionManager_1.ConnectionManager();
const commandHandler = new CommandHandler_1.CommandHandler(axioDB);
let server;
// Setup connection manager event handlers
setupConnectionManagerHandlers(connectionManager);
// Create TCP server
server = (0, net_1.createServer)((socket) => {
handleNewConnection(socket, connectionManager, commandHandler);
});
// Setup server error handling
server.on('error', (error) => {
console.error('[AxioDB TCP Server] Server error:', error);
});
server.on('listening', () => {
const address = server.address();
console.log(`[AxioDB TCP Server] Listening on port ${typeof address === 'object' ? address === null || address === void 0 ? void 0 : address.port : port}`);
});
// Start listening
server.listen(port, () => {
console.log(`[AxioDB TCP Server] Started successfully on port ${port}`);
});
return server;
});
}
/**
* Setup connection manager event handlers
*/
function setupConnectionManagerHandlers(connectionManager) {
connectionManager.on('connection:added', (connectionId, remoteAddress) => {
console.log(`[AxioDB TCP] Client connected: ${connectionId} from ${remoteAddress}`);
});
connectionManager.on('connection:removed', (connectionId) => {
console.log(`[AxioDB TCP] Client disconnected: ${connectionId}`);
});
connectionManager.on('message', (connectionId, message, socket) => __awaiter(this, void 0, void 0, function* () {
// This is handled in handleMessage function
}));
connectionManager.on('error', (error, connectionId) => {
console.error(`[AxioDB TCP] Error on connection ${connectionId}:`, error);
});
connectionManager.on('socket:error', (error, connectionId) => {
console.error(`[AxioDB TCP] Socket error on connection ${connectionId}:`, error);
});
connectionManager.on('socket:closed', (connectionId, hadError) => {
if (hadError) {
console.log(`[AxioDB TCP] Connection ${connectionId} closed with error`);
}
});
connectionManager.on('socket:timeout', (connectionId) => {
console.log(`[AxioDB TCP] Connection ${connectionId} timed out`);
});
}
/**
* Handle new client connection
*/
function handleNewConnection(socket, connectionManager, commandHandler) {
const connectionId = connectionManager.addConnection(socket);
if (!connectionId) {
// Server overload - reject connection
const errorResponse = {
id: 'server_overload',
statusCode: keys_1.StatusCode.SERVICE_UNAVAILABLE,
message: keys_1.ErrorMessage.SERVER_OVERLOAD,
error: keys_1.ErrorMessage.SERVER_OVERLOAD,
};
try {
socket.write(protocol_1.MessageFramer.encode(errorResponse));
}
catch (error) {
console.error('[AxioDB TCP] Error sending overload response:', error);
}
socket.end();
return;
}
// Setup message handler
connectionManager.on('message', (connId, message, clientSocket) => __awaiter(this, void 0, void 0, function* () {
if (connId !== connectionId)
return; // Only handle messages for this connection
yield handleMessage(connId, message, clientSocket, commandHandler, connectionManager);
}));
}
/**
* Handle incoming message
*/
function handleMessage(connectionId, message, socket, commandHandler, connectionManager) {
return __awaiter(this, void 0, void 0, function* () {
try {
// Create request context
const context = new RequestContext_1.RequestContext(message, socket);
// Handle the request
const response = yield commandHandler.handleRequest(context);
// Send response
const sent = connectionManager.sendResponse(connectionId, response);
if (!sent) {
console.error(`[AxioDB TCP] Failed to send response for request ${message.id}`);
}
// Handle DISCONNECT command
if (message.command === command_types_1.CommandType.DISCONNECT) {
connectionManager.removeConnection(connectionId);
}
}
catch (error) {
console.error('[AxioDB TCP] Error handling message:', error);
// Send error response
const errorResponse = {
id: message.id || 'error',
statusCode: keys_1.StatusCode.INTERNAL_SERVER_ERROR,
message: keys_1.ErrorMessage.INTERNAL_ERROR,
error: error instanceof Error ? error.message : String(error),
};
connectionManager.sendResponse(connectionId, errorResponse);
}
});
}
/**
* Gracefully shutdown TCP server
*/
function shutdownTCPServer(server, connectionManager) {
return new Promise((resolve) => {
console.log('[AxioDB TCP Server] Shutting down...');
// Close all connections
connectionManager.closeAll();
// Close server
server.close(() => {
console.log('[AxioDB TCP Server] Shutdown complete');
resolve();
});
});
}
//# sourceMappingURL=server.js.map