@archlast/server 0.0.1

package/dist/db/socket-client.js

@@ -0,0 +1,1092 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketDatabaseClient = void 0;
+exports.loadSocketConfig = loadSocketConfig;
+const net_1 = __importDefault(require("net"));
+const tls_1 = __importDefault(require("tls"));
+const logger_js_1 = require("../logging/logger.js");
+const builder_js_1 = require("../query/builder.js");
+const context_js_1 = require("../engine/context.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Loads configuration from environment variables
+ * Implements Secure Document Store Protocol (v4) with Dev Shim
+ */
+function loadSocketConfig() {
+    const config = {
+        useUnixSocket: process.env.ARCHLAST_STORE_UNIX_SOCKET === "true",
+        socketPath: process.env.ARCHLAST_STORE_SOCKET_PATH,
+        host: process.env.ARCHLAST_STORE_HOST || "127.0.0.1",
+        port: parseInt(process.env.ARCHLAST_STORE_PORT || "7001", 10),
+        secret: process.env.ARCHLAST_STORE_SECRET || "",
+        certFingerprint: process.env.ARCHLAST_STORE_FINGERPRINT,
+        caPath: process.env.ARCHLAST_STORE_CA_PATH,
+        useTls: process.env.ARCHLAST_STORE_NO_TLS !== "true",
+        authTimeoutMs: parseInt(process.env.ARCHLAST_STORE_AUTH_TIMEOUT || "2000", 10),
+    };
+    // Dev Shim: Fallback to lock file if secret is not provided
+    if (!config.secret && process.env.NODE_ENV === "development") {
+        // Try multiple potential lock file locations
+        const possiblePaths = [
+            // From packages/server -> packages/document-store
+            path.resolve(process.cwd(), "..", "document-store", ".archlast", "store.lock"),
+            // From monorepo root -> packages/document-store
+            path.resolve(process.cwd(), "packages", "document-store", ".archlast", "store.lock"),
+            // Direct CWD (if running from document-store)
+            path.resolve(process.cwd(), ".archlast", "store.lock"),
+        ];
+        for (const lockFilePath of possiblePaths) {
+            if (fs.existsSync(lockFilePath)) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "system",
+                    message: `[SocketClient] Loading config from dev lock file: ${lockFilePath}`,
+                });
+                Object.assign(config, loadConfigFromLockFile(lockFilePath));
+                break;
+            }
+        }
+    }
+    return config;
+}
+/**
+ * Loads configuration from a lock file (dev mode only)
+ */
+function loadConfigFromLockFile(lockFilePath) {
+    const content = fs.readFileSync(lockFilePath, "utf-8");
+    const lines = content.split("\n");
+    const config = {};
+    for (const line of lines) {
+        const parts = line.split("=", 2);
+        if (parts.length !== 2)
+            continue;
+        const key = parts[0].trim();
+        const value = parts[1].trim();
+        switch (key) {
+            case "HOST":
+                config.host = value;
+                break;
+            case "PORT":
+                config.port = parseInt(value, 10);
+                break;
+            case "SECRET":
+                config.secret = value;
+                break;
+            case "CERT_FINGERPRINT":
+                config.certFingerprint = value;
+                break;
+        }
+    }
+    return config;
+}
+/**
+ * Database client that connects to Archlast.Store via socket
+ * Supports Unix sockets, TCP, and TLS with PSK authentication
+ */
+class SocketDatabaseClient {
+    socket = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = Buffer.alloc(0);
+    options;
+    connected = false;
+    connecting = false;
+    connectPromise = null;
+    authenticated = false;
+    // Schema storage for relationship resolution
+    schemaRelationships = new Map();
+    constructor(options = {}) {
+        this.options = {
+            useUnixSocket: options.useUnixSocket ?? false,
+            socketPath: options.socketPath ?? "archlast-store.sock",
+            host: options.host ?? "127.0.0.1",
+            port: options.port ?? 7001,
+            secret: options.secret ?? "",
+            certFingerprint: options.certFingerprint,
+            caPath: options.caPath,
+            useTls: options.useTls ?? true,
+            authTimeoutMs: options.authTimeoutMs ?? 2000,
+        };
+        // Validate secret for TCP connections (required for authentication)
+        // Note: Unix socket mode (dev) does not require a secret
+        if (!this.options.useUnixSocket && !this.options.secret && this.options.useTls !== false) {
+            throw new Error("ARCHLAST_STORE_SECRET is required for TCP connections. " +
+                "In production, set via environment variable. " +
+                "In development, ensure .archlast/store.lock exists or set a secret.");
+        }
+    }
+    /**
+     * Ensures socket connection is established with retry logic
+     */
+    async ensureConnection() {
+        if (this.connected && (this.options.useUnixSocket || this.authenticated))
+            return;
+        if (this.connecting && this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connecting = true;
+        this.connectPromise = this.connectWithRetry();
+        try {
+            return await this.connectPromise;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const endpoint = this.options.useUnixSocket
+                ? this.options.socketPath
+                : `${this.options.host}:${this.options.port}`;
+            throw new Error(`Document Store unavailable at ${endpoint}. ` +
+                `Ensure Archlast.Store (C# service) is running. Original error: ${message}`);
+        }
+    }
+    /**
+     * Attempts to connect with exponential backoff retry
+     */
+    async connectWithRetry() {
+        const maxRetries = 10;
+        const baseDelayMs = 500;
+        const maxDelayMs = 5000;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.attemptConnection();
+                return; // Success!
+            }
+            catch (err) {
+                const isLastAttempt = attempt === maxRetries;
+                if (isLastAttempt) {
+                    this.connecting = false;
+                    throw err;
+                }
+                // Exponential backoff with jitter
+                const delayMs = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
+                const jitter = Math.random() * 200;
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "system",
+                    message: `[SocketClient] Connection attempt ${attempt}/${maxRetries} failed, retrying in ${Math.round(delayMs)}ms...`,
+                });
+                await this.sleep(delayMs + jitter);
+            }
+        }
+    }
+    /**
+     * Single connection attempt
+     */
+    attemptConnection() {
+        return new Promise((resolve, reject) => {
+            this.buffer = Buffer.alloc(0);
+            this.socket?.removeAllListeners("data");
+            const cleanup = () => {
+                this.socket?.removeListener("error", onError);
+                if (!this.options.useUnixSocket && this.options.useTls) {
+                    this.socket?.removeListener("secureConnect", onSecureConnect);
+                }
+            };
+            const onError = (err) => {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: `[SocketClient] Connection error: ${err.message}`,
+                });
+                cleanup();
+                this.connected = false;
+                this.authenticated = false;
+                this.socket = null;
+                reject(err);
+            };
+            // Unix socket connection (no TLS, no auth)
+            if (this.options.useUnixSocket) {
+                this.socket = net_1.default.createConnection({ path: this.options.socketPath }, () => {
+                    cleanup();
+                    this.connected = true;
+                    this.connecting = false;
+                    // CRITICAL: Clear the connection timeout
+                    this.socket?.setTimeout(0);
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "info",
+                        kind: "system",
+                        message: "[SocketClient] Connected via Unix socket",
+                    });
+                    this.setupSocketHandlers();
+                    resolve();
+                });
+                this.socket.once("error", onError);
+                this.socket.setTimeout(5000, () => {
+                    cleanup();
+                    this.socket?.destroy();
+                    this.socket = null;
+                    reject(new Error("Connection timeout"));
+                });
+                return;
+            }
+            // TCP connection with optional TLS
+            const onSecureConnect = async () => {
+                cleanup();
+                this.connected = true;
+                // CRITICAL: Clear the connection timeout after successful handshake
+                // to prevent idle timeout from closing the connection
+                this.socket?.setTimeout(0);
+                // Enable TCP keepalive for long-lived connections
+                if (this.socket && 'setKeepAlive' in this.socket) {
+                    this.socket.setKeepAlive(true, 30000);
+                }
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "system",
+                    message: `[SocketClient] TLS handshake complete: ${this.options.host}:${this.options.port}`,
+                });
+                // Send authentication packet immediately
+                try {
+                    await this.authenticate();
+                    this.connecting = false;
+                    this.setupSocketHandlers();
+                    resolve();
+                }
+                catch (authErr) {
+                    const error = authErr instanceof Error ? authErr : new Error(String(authErr));
+                    onError(error);
+                }
+            };
+            if (this.options.useTls) {
+                // TLS connection options - Strict validation per Secure Protocol
+                const tlsOptions = {
+                    host: this.options.host,
+                    port: this.options.port,
+                    // For self-signed certs (dev mode with fingerprint), we must disable default CA validation
+                    // and rely on fingerprint validation instead. For production with CA, we use strict validation.
+                    rejectUnauthorized: !this.options.certFingerprint,
+                    minVersion: "TLSv1.2", // Allow TLS 1.2+ (server supports both 1.2 and 1.3)
+                };
+                // Add CA if provided (Production mode)
+                if (this.options.caPath && fs.existsSync(this.options.caPath)) {
+                    tlsOptions.ca = fs.readFileSync(this.options.caPath);
+                    tlsOptions.rejectUnauthorized = true; // Enable strict validation with CA
+                }
+                // Add certificate fingerprint validation for self-signed certs (Dev mode)
+                if (this.options.certFingerprint) {
+                    tlsOptions.checkServerIdentity = (host, cert) => {
+                        // Node.js fingerprint format: XX:XX:XX:... (with colons, uppercase)
+                        // Our lock file format: xxxx... (no colons, lowercase)
+                        const normalizedCertFingerprint = cert.fingerprint256
+                            .replace(/:/g, "")
+                            .toLowerCase();
+                        const expectedFingerprint = this.options.certFingerprint.toLowerCase();
+                        if (normalizedCertFingerprint !== expectedFingerprint) {
+                            return new Error(`Security Alert: Server Fingerprint Mismatch! ` +
+                                `Expected: ${expectedFingerprint}, Got: ${normalizedCertFingerprint}`);
+                        }
+                        return undefined;
+                    };
+                }
+                this.socket = tls_1.default.connect(tlsOptions, () => {
+                    // Wait for secureConnect event
+                });
+                this.socket.once("secureConnect", onSecureConnect);
+            }
+            else {
+                // Plain TCP connection (not recommended for production)
+                this.socket = net_1.default.createConnection({ host: this.options.host, port: this.options.port }, () => {
+                    cleanup();
+                    this.connected = true;
+                    this.connecting = false;
+                    // CRITICAL: Clear the connection timeout
+                    this.socket?.setTimeout(0);
+                    this.socket?.setKeepAlive(true, 30000);
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "warn",
+                        kind: "system",
+                        message: `[SocketClient] Connected via PLAIN TCP (insecure): ${this.options.host}:${this.options.port}`,
+                    });
+                    // Still authenticate even without TLS
+                    this.authenticate()
+                        .then(() => {
+                        this.setupSocketHandlers();
+                        resolve();
+                    })
+                        .catch(onError);
+                });
+            }
+            this.socket?.once("error", onError);
+            // Connection timeout
+            this.socket?.setTimeout(5000, () => {
+                cleanup();
+                this.socket?.destroy();
+                this.socket = null;
+                reject(new Error("Connection timeout"));
+            });
+        });
+    }
+    /**
+     * Sends authentication packet (JSON with PSK) to server
+     * Implements Secure Protocol v4: JSON auth packet with length prefix
+     */
+    async authenticate() {
+        if (!this.socket) {
+            throw new Error("Socket not connected");
+        }
+        // Build auth request: { "op": "auth", "token": "<secret>" }
+        const authRequest = {
+            op: "auth",
+            token: this.options.secret,
+        };
+        // Serialize to JSON
+        const authJson = JSON.stringify(authRequest);
+        const authBytes = Buffer.from(authJson, "utf8");
+        // Add 4-byte length prefix (little-endian)
+        const lengthPrefix = Buffer.alloc(4);
+        lengthPrefix.writeInt32LE(authBytes.length, 0);
+        const authPacket = Buffer.concat([lengthPrefix, authBytes]);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error("Authentication timeout"));
+            }, this.options.authTimeoutMs);
+            this.socket.write(authPacket, (err) => {
+                clearTimeout(timeout);
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // Wait for auth response before marking as authenticated
+                    // The response will be handled by handleData()
+                    this.waitForAuthResponse()
+                        .then(() => {
+                        this.authenticated = true;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "system",
+                            message: "[SocketClient] TLS Authentication successful",
+                        });
+                        resolve();
+                    })
+                        .catch(reject);
+                }
+            });
+        });
+    }
+    /**
+     * Waits for auth response from server
+     */
+    async waitForAuthResponse() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.socket?.removeListener("data", dataHandler);
+                reject(new Error("Auth response timeout"));
+            }, this.options.authTimeoutMs);
+            const dataHandler = (chunk) => {
+                this.buffer = Buffer.concat([this.buffer, chunk]);
+                // Need at least 4 bytes for length prefix
+                if (this.buffer.length >= 4) {
+                    const length = this.buffer.readInt32LE(0);
+                    // Validate length is reasonable (prevent memory issues)
+                    if (length <= 0 || length > 10 * 1024 * 1024) {
+                        this.socket?.removeListener("data", dataHandler);
+                        clearTimeout(timeout);
+                        reject(new Error(`Invalid auth response length: ${length}`));
+                        return;
+                    }
+                    // Wait for complete message
+                    if (this.buffer.length >= 4 + length) {
+                        const messageBytes = this.buffer.slice(4, 4 + length);
+                        let message;
+                        try {
+                            message = JSON.parse(messageBytes.toString("utf8"));
+                        }
+                        catch (e) {
+                            this.socket?.removeListener("data", dataHandler);
+                            clearTimeout(timeout);
+                            reject(new Error(`Failed to parse auth response: ${e}`));
+                            return;
+                        }
+                        this.buffer = this.buffer.slice(4 + length);
+                        // Clean up handlers
+                        this.socket?.removeListener("data", dataHandler);
+                        clearTimeout(timeout);
+                        if (message.success) {
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(message.error || "Authentication failed"));
+                        }
+                    }
+                }
+            };
+            // Use .on() instead of .once() to handle fragmented responses
+            this.socket?.on("data", dataHandler);
+        });
+    }
+    /**
+     * Sets up socket event handlers after successful connection
+     */
+    setupSocketHandlers() {
+        if (!this.socket)
+            return;
+        this.socket.on("data", (chunk) => this.handleData(chunk));
+        this.socket.on("error", (err) => {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "error",
+                kind: "system",
+                message: "[SocketClient] Socket error:",
+                context: { data: [err.message] },
+            });
+            this.connected = false;
+            this.authenticated = false;
+        });
+        this.socket.on("close", () => {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: "[SocketClient] Connection closed",
+            });
+            this.connected = false;
+            this.authenticated = false;
+            this.socket = null;
+            this.connectPromise = null;
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Handles incoming data from socket
+     */
+    handleData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 4) {
+            const length = this.buffer.readInt32LE(0);
+            if (this.buffer.length < 4 + length) {
+                break; // Wait for more data
+            }
+            const messageBytes = this.buffer.slice(4, 4 + length);
+            const message = JSON.parse(messageBytes.toString("utf8"));
+            const pending = this.pendingRequests.get(message.reqId);
+            if (pending) {
+                this.pendingRequests.delete(message.reqId);
+                if (message.success) {
+                    pending.resolve(message.data);
+                }
+                else {
+                    pending.reject(new Error(message.error || "Unknown error"));
+                }
+            }
+            this.buffer = this.buffer.slice(4 + length);
+        }
+    }
+    /**
+     * Sends a request to the store and waits for response
+     */
+    async sendRequest(operation, spec) {
+        try {
+            await this.ensureConnection();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "error",
+                kind: "system",
+                message: "[SocketClient] Connection failed",
+                context: { error: message },
+            });
+            throw err;
+        }
+        return new Promise((resolve, reject) => {
+            const reqId = ++this.requestId;
+            const timeoutMs = 30000; // 30s timeout for requests
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(reqId);
+                reject(new Error(`Request timeout for operation '${operation}'. ` +
+                    `Document Store may be overloaded or unresponsive.`));
+            }, timeoutMs);
+            this.pendingRequests.set(reqId, {
+                resolve: (value) => {
+                    clearTimeout(timeout);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+            });
+            const request = {
+                id: reqId,
+                op: operation,
+                spec: spec,
+            };
+            const json = JSON.stringify(request);
+            const bytes = Buffer.from(json, "utf8");
+            const lengthBuffer = Buffer.allocUnsafe(4);
+            lengthBuffer.writeInt32LE(bytes.length, 0);
+            this.socket.write(lengthBuffer);
+            this.socket.write(bytes);
+        });
+    }
+    /**
+     * Normalizes a where clause for the Document Store.
+     * The C# Store now supports operator-based conditions.
+     * This method flattens 'and' conditions and preserves operator objects.
+     */
+    normalizeWhere(where) {
+        if (!where || typeof where !== "object")
+            return where;
+        const normalized = {};
+        for (const [key, value] of Object.entries(where)) {
+            // Handle 'and' operator - flatten conditions
+            if (key === "and" && Array.isArray(value)) {
+                for (const condition of value) {
+                    const normalizedCondition = this.normalizeWhere(condition);
+                    Object.assign(normalized, normalizedCondition);
+                }
+                continue;
+            }
+            // Handle 'or' operator - not fully supported, log warning
+            if (key === "or" && Array.isArray(value)) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "warn",
+                    kind: "system",
+                    message: "[SocketClient] 'or' operator not fully supported, using first condition only",
+                });
+                if (value.length > 0) {
+                    const normalizedCondition = this.normalizeWhere(value[0]);
+                    Object.assign(normalized, normalizedCondition);
+                }
+                continue;
+            }
+            // Handle 'not' operator - not fully supported
+            if (key === "not" && typeof value === "object") {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "warn",
+                    kind: "system",
+                    message: "[SocketClient] 'not' operator not fully supported",
+                });
+                continue;
+            }
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                // Check if it's an operator object - pass through to C# Store
+                const supportedOperators = [
+                    "eq",
+                    "ne",
+                    "gt",
+                    "gte",
+                    "lt",
+                    "lte",
+                    "in",
+                    "notIn",
+                    "contains",
+                    "startsWith",
+                    "endsWith",
+                    "isNull",
+                    "isNotNull",
+                ];
+                const hasOperator = supportedOperators.some((op) => op in value);
+                if (hasOperator) {
+                    // Pass operator object directly to C# Store
+                    normalized[key] = value;
+                }
+                else {
+                    // Nested object without operators - recurse
+                    normalized[key] = this.normalizeWhere(value);
+                }
+            }
+            else {
+                // Simple value (converts to equality in C# Store)
+                normalized[key] = value;
+            }
+        }
+        return normalized;
+    }
+    // ========== GenericDatabaseReader Methods ==========
+    async get(tableName, id) {
+        const result = await this.sendRequest("get", {
+            collection: tableName,
+            id,
+        });
+        return result || null;
+    }
+    async list(tableName) {
+        const result = await this.sendRequest("query", {
+            collection: tableName,
+        });
+        return result || [];
+    }
+    query(tableName) {
+        // Return a query builder that will use this client as executor
+        return new builder_js_1.QueryBuilderImpl(tableName, this);
+    }
+    async findMany(tableName, options) {
+        const result = await this.sendRequest("query", {
+            collection: tableName,
+            where: this.normalizeWhere(options?.where),
+            orderBy: options?.orderBy,
+            take: options?.take,
+            skip: options?.skip,
+            select: options?.select,
+        });
+        // Reactivity: Track read dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackRead(`collection:${String(tableName)}`);
+        }
+        return result || [];
+    }
+    async findFirst(tableName, options) {
+        const results = await this.findMany(tableName, { ...options, take: 1 });
+        return results[0] || null;
+    }
+    async findUnique(tableName, where) {
+        const results = await this.findMany(tableName, { where, take: 1 });
+        return results[0] || null;
+    }
+    async count(tableName, where) {
+        const result = await this.sendRequest("count", {
+            collection: tableName,
+            where: this.normalizeWhere(where),
+        });
+        // Reactivity: Track read dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackRead(`collection:${String(tableName)}`);
+        }
+        return result?.count || 0;
+    }
+    async loadRelation(tableName, record, relationName) {
+        const relationships = this.schemaRelationships.get(tableName);
+        if (!relationships || !relationships[relationName]) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "warn",
+                kind: "system",
+                message: `[SocketClient] No relationship '${relationName}' defined for '${String(tableName)}'`,
+            });
+            return [];
+        }
+        const rel = relationships[relationName];
+        const recordId = record._id;
+        if (rel.type === "hasMany") {
+            // hasMany: Find all records in target table where foreignKey = this record's _id
+            const foreignKey = rel.foreignKey || `${String(tableName).slice(0, -1)}_id`; // e.g., "tasks" -> "task_id"
+            const result = await this.sendRequest("query", {
+                collection: rel.target,
+                where: { [foreignKey]: recordId },
+            });
+            return (result || []);
+        }
+        if (rel.type === "hasOne") {
+            // hasOne: Find single record in target table where foreignKey = this record's _id
+            const foreignKey = rel.foreignKey || `${String(tableName).slice(0, -1)}_id`;
+            const result = await this.sendRequest("query", {
+                collection: rel.target,
+                where: { [foreignKey]: recordId },
+                take: 1,
+            });
+            return (result?.[0] || null);
+        }
+        if (rel.type === "belongsTo") {
+            // belongsTo: Find single record in target table by this record's foreignKey value
+            const foreignKey = rel.foreignKey || `${rel.target.slice(0, -1)}_id`; // e.g., target "tasks" -> "task_id"
+            const foreignId = record[foreignKey];
+            if (!foreignId)
+                return null;
+            const result = await this.sendRequest("get", {
+                collection: rel.target,
+                id: foreignId,
+            });
+            return (result || null);
+        }
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "warn",
+            kind: "system",
+            message: `[SocketClient] Unsupported relationship type: ${rel.type}`,
+        });
+        return [];
+    }
+    async loadRelations(tableName, records, relationName) {
+        const resultMap = new Map();
+        if (records.length === 0) {
+            return resultMap;
+        }
+        const relationships = this.schemaRelationships.get(tableName);
+        if (!relationships || !relationships[relationName]) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "warn",
+                kind: "system",
+                message: `[SocketClient] No relationship '${relationName}' defined for '${String(tableName)}'`,
+            });
+            return resultMap;
+        }
+        const rel = relationships[relationName];
+        const recordIds = records.map((r) => r._id);
+        if (rel.type === "hasMany") {
+            // Batch query: Find all records where foreignKey IN [ids]
+            const foreignKey = rel.foreignKey || `${String(tableName).slice(0, -1)}_id`;
+            const result = await this.sendRequest("query", {
+                collection: rel.target,
+                where: { [foreignKey]: { in: recordIds } },
+            });
+            // Group results by foreign key
+            const allRelated = result || [];
+            for (const related of allRelated) {
+                const fkValue = related[foreignKey];
+                if (!resultMap.has(fkValue)) {
+                    resultMap.set(fkValue, []);
+                }
+                resultMap.get(fkValue).push(related);
+            }
+            // Ensure all records have an entry (even if empty)
+            for (const id of recordIds) {
+                if (!resultMap.has(id)) {
+                    resultMap.set(id, []);
+                }
+            }
+        }
+        else if (rel.type === "belongsTo") {
+            // Batch query: Get all target records by IDs
+            const foreignKey = rel.foreignKey || `${rel.target.slice(0, -1)}_id`;
+            const foreignIds = records
+                .map((r) => r[foreignKey])
+                .filter((id) => id != null);
+            if (foreignIds.length > 0) {
+                const result = await this.sendRequest("query", {
+                    collection: rel.target,
+                    where: { _id: { in: foreignIds } },
+                });
+                // Create lookup by _id
+                const lookup = new Map();
+                for (const item of result || []) {
+                    lookup.set(item._id, item);
+                }
+                // Map back to original records
+                for (const record of records) {
+                    const fkValue = record[foreignKey];
+                    const recordId = record._id;
+                    resultMap.set(recordId, lookup.get(fkValue) || null);
+                }
+            }
+        }
+        return resultMap;
+    }
+    // ========== GenericDatabaseWriter Methods ==========
+    // Add stored schema metadata
+    schemaMetadata = new Map();
+    /**
+     * Apply schema definitions for validation and type generation
+     */
+    async applySchema(schema) {
+        if (!schema || !schema.tables) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: "[SocketClient] No schema to apply",
+            });
+            return;
+        }
+        // 1. Store field metadata for enforcement
+        for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+            const fieldMap = new Map();
+            for (const [fieldName, fieldDef] of Object.entries(tableDef.schema)) {
+                fieldMap.set(fieldName, fieldDef.metadata || {});
+            }
+            this.schemaMetadata.set(tableName, fieldMap);
+        }
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "info",
+            kind: "system",
+            message: "[SocketClient] Applying schema with indexes and relationships...",
+        });
+        const schemaPromises = [];
+        for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+            const table = tableDef;
+            // 2. Store relationships for runtime resolution
+            if (table.relationships) {
+                this.schemaRelationships.set(tableName, table.relationships);
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "system",
+                    message: `[SocketClient] Stored ${Object.keys(table.relationships).length} relationship(s) for ${tableName}`,
+                });
+            }
+            // 3. Extract indexes if defined
+            if (table.indexes && Array.isArray(table.indexes) && table.indexes.length > 0) {
+                const indexes = table.indexes.map((idx, i) => ({
+                    name: idx.name || `idx_${tableName}_${idx.fields.join("_")}`,
+                    fields: idx.fields,
+                    unique: idx.unique || false,
+                }));
+                // Send setSchema request to document store
+                const promise = this.sendRequest("setSchema", {
+                    collection: tableName,
+                    indexes,
+                })
+                    .then(() => {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "info",
+                        kind: "system",
+                        message: `[SocketClient] Indexes applied for ${tableName}: ${indexes.length} index(es)`,
+                    });
+                })
+                    .catch((err) => {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "system",
+                        message: `[SocketClient] Failed to apply indexes for ${tableName}:`,
+                        context: { data: [err.message] },
+                    });
+                });
+                schemaPromises.push(promise);
+            }
+        }
+        // Wait for all schema applications
+        if (schemaPromises.length > 0) {
+            await Promise.all(schemaPromises);
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: `[SocketClient] Schema applied successfully for ${schemaPromises.length} collection(s)`,
+            });
+        }
+        else {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: "[SocketClient] Schema applied (no indexes defined)",
+            });
+        }
+    }
+    // Schema enforcement helper
+    applySchemaEnforcement(tableName, data, operation) {
+        const fieldMetadata = this.schemaMetadata.get(tableName);
+        if (!fieldMetadata)
+            return data;
+        const result = { ...data };
+        const now = new Date();
+        for (const [fieldName, metadata] of fieldMetadata.entries()) {
+            // createdNow: Set on insert only
+            if (operation === "insert" && metadata.modifiers && (metadata.modifiers & (1 << 0))) { // CreatedNow
+                result[fieldName] = now;
+            }
+            // updateNow: Set on insert AND update
+            if (metadata.modifiers && (metadata.modifiers & (1 << 1))) { // UpdateNow
+                result[fieldName] = now;
+            }
+            // Apply defaults on insert if value not provided
+            if (operation === "insert" && metadata.default !== undefined && (metadata.modifiers && (metadata.modifiers & (1 << 4)))) { // HasDefault
+                if (result[fieldName] === undefined) {
+                    result[fieldName] = metadata.default;
+                }
+            }
+        }
+        return result;
+    }
+    async insert(tableName, data) {
+        const enrichedData = this.applySchemaEnforcement(tableName, data, "insert");
+        const result = await this.sendRequest("insert", {
+            collection: tableName,
+            data: enrichedData,
+        });
+        // Reactivity: Track write dependency (affects collection)
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+        }
+        return result.id;
+    }
+    async insertMany(tableName, data) {
+        const enrichedData = data.map(d => this.applySchemaEnforcement(tableName, d, "insert"));
+        const result = await this.sendRequest("insertMany", {
+            collection: tableName,
+            data: enrichedData,
+        });
+        // Reactivity: Track write dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+        }
+        return result.ids || [];
+    }
+    async update(tableName, id, data) {
+        const enrichedData = this.applySchemaEnforcement(tableName, data, "update");
+        await this.sendRequest("update", {
+            collection: tableName,
+            id,
+            data: enrichedData,
+        });
+        // Reactivity: Track write dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+            store.trackWrite(`document:${String(tableName)}:${id}`);
+        }
+    }
+    async updateMany(tableName, where, data) {
+        const enrichedData = this.applySchemaEnforcement(tableName, data, "update");
+        const result = await this.sendRequest("updateMany", {
+            collection: tableName,
+            where: this.normalizeWhere(where),
+            data: enrichedData,
+        });
+        // Reactivity: Track write dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+        }
+        return result.count || 0;
+    }
+    async patch(tableName, id, data) {
+        // Patch is the same as update for document store
+        await this.update(tableName, id, data);
+    }
+    async delete(tableName, id) {
+        await this.sendRequest("delete", {
+            collection: tableName,
+            id,
+        });
+        // Reactivity: Track write dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+            store.trackWrite(`document:${String(tableName)}:${id}`);
+        }
+    }
+    async deleteMany(tableName, where) {
+        const result = await this.sendRequest("deleteMany", {
+            collection: tableName,
+            where: this.normalizeWhere(where),
+        });
+        // Reactivity: Track write dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackWrite(`collection:${String(tableName)}`);
+        }
+        return result.count || 0;
+    }
+    // ========== IDatabaseClient Methods ==========
+    async runInTransaction(fn) {
+        // TODO: Implement transaction support
+        // For now, just execute without transaction
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "warn",
+            kind: "system",
+            message: "[SocketClient] Transactions not yet implemented, executing without transaction",
+        });
+        return await fn(this);
+    }
+    // ========== QueryExecutor Methods ==========
+    async executeQuery(spec) {
+        const whereClause = spec.where && spec.where.length > 0 ? spec.where[0] : undefined;
+        const result = await this.sendRequest("query", {
+            collection: spec.table,
+            where: this.normalizeWhere(whereClause),
+            orderBy: spec.orderBy && spec.orderBy.length > 0 ? spec.orderBy[0] : undefined,
+            select: spec.select,
+            take: spec.take,
+            skip: spec.skip,
+        });
+        // Reactivity: Track read dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackRead(`collection:${String(spec.table)}`);
+        }
+        return result || [];
+    }
+    async executeCount(spec) {
+        const whereClause = spec.where && spec.where.length > 0 ? spec.where[0] : undefined;
+        const result = await this.sendRequest("count", {
+            collection: spec.table,
+            where: this.normalizeWhere(whereClause),
+        });
+        // Reactivity: Track read dependency
+        const store = context_js_1.executionContext.getStore();
+        if (store) {
+            store.trackRead(`collection:${String(spec.table)}`);
+        }
+        return result?.count || 0;
+    }
+    async executeAggregate(spec) {
+        // TODO: Implement aggregate support
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "warn",
+            kind: "system",
+            message: "[SocketClient] Aggregate not yet implemented",
+        });
+        return { sum: 0, avg: 0, min: 0, max: 0 };
+    }
+    clearCache() {
+        // Cache is managed by the C# store, no-op here
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "info",
+            kind: "cache",
+            message: "[SocketClient] Cache cleared (managed by store)",
+        });
+    }
+    /**
+     * Closes the socket connection
+     */
+    disconnect() {
+        if (this.socket) {
+            this.socket.end();
+            this.socket = null;
+            this.connected = false;
+            this.authenticated = false;
+        }
+    }
+}
+exports.SocketDatabaseClient = SocketDatabaseClient;
+//# sourceMappingURL=socket-client.js.map