@scriptdb/client 1.0.0

package/README.md

@@ -0,0 +1,307 @@
+# ScriptDB Client
+
+Client module for connecting to and interacting with ScriptDB servers.
+
+## Installation
+
+```bash
+npm install @scriptdb/client
+# or
+yarn add @scriptdb/client
+# or
+bun add @scriptdb/client
+```
+
+## Quick Start
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+
+// Create a client instance
+const client = new ScriptDBClient('scriptdb://localhost:1234/mydatabase', {
+  username: 'admin',
+  password: 'password'
+});
+
+// Connect to the server
+await client.connect();
+
+// Execute a command
+const result = await client.execute('getUsers');
+console.log(result);
+
+// Close the connection when done
+client.close();
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new ScriptDBClient(uri, options?)
+```
+
+- `uri` (string): Connection URI in format `scriptdb://host:port/database`
+- `options` (ClientOptions, optional): Configuration options
+
+#### URI Format
+
+The URI follows the pattern: `scriptdb://[username:password@]host:port/database`
+
+Examples:
+- `scriptdb://localhost:1234/mydb`
+- `scriptdb://user:pass@localhost:1234/mydb`
+- `scriptdb://example.com:8080/production`
+
+### Options
+
+```typescript
+interface ClientOptions {
+  secure?: boolean;              // Use TLS (default: true)
+  logger?: Logger;               // Custom logger
+  requestTimeout?: number;       // Request timeout in ms (default: 0 = no timeout)
+  socketTimeout?: number;        // Socket timeout in ms (default: 0 = no timeout)
+  retries?: number;              // Reconnection retries (default: 3)
+  retryDelay?: number;           // Initial retry delay in ms (default: 1000)
+  tlsOptions?: tls.TlsOptions;   // TLS options when secure=true
+  frame?: 'ndjson' | 'length-prefix';  // Message framing (default: 'ndjson')
+  preferLengthPrefix?: boolean;  // Use length-prefixed framing (alias for frame)
+  maxPending?: number;           // Max concurrent requests (default: 100)
+  maxQueue?: number;             // Max queued requests (default: 1000)
+  maxMessageSize?: number;       // Max message size in bytes (default: 5MB)
+  signing?: {                    // Message signing options
+    secret: string;
+    algorithm?: string;          // Default: 'sha256'
+  };
+  stringify?: (obj: any) => string; // Custom stringify function
+  username?: string;             // Username (overrides URI)
+  password?: string;             // Password (overrides URI)
+  tokenRefresh?: () => Promise<{ token: string; expiresAt?: number }>; // Token refresh
+}
+```
+
+### Methods
+
+#### connect()
+
+Connects to the server and authenticates.
+
+```typescript
+await client.connect(): Promise<ScriptDBClient>
+```
+
+Returns a promise that resolves when authentication is successful.
+
+#### execute(command)
+
+Executes a command on the server.
+
+```typescript
+await client.execute(command: string): Promise<any>
+```
+
+- `command` (string): The command to execute
+
+Returns a promise that resolves with the response data.
+
+#### close()
+
+Closes the connection to the server.
+
+```typescript
+client.close(): void
+```
+
+#### destroy()
+
+Destroys the client and cleans up resources.
+
+```typescript
+client.destroy(): void
+```
+
+## Examples
+
+### Basic Usage
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+
+const client = new ScriptDBClient('scriptdb://localhost:1234/testdb', {
+  username: 'admin',
+  password: 'password123'
+});
+
+try {
+  await client.connect();
+  
+  // Execute database commands
+  const users = await client.execute('listUsers');
+  console.log('Users:', users);
+  
+  const result = await client.execute('createUser', { name: 'John', email: 'john@example.com' });
+  console.log('Created user:', result);
+  
+} catch (error) {
+  console.error('Error:', error.message);
+} finally {
+  client.close();
+}
+```
+
+### Secure Connection with TLS
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+import { readFileSync } from 'fs';
+
+const client = new ScriptDBClient('scriptdb://secure.example.com:443/production', {
+  secure: true,
+  tlsOptions: {
+    ca: readFileSync('./ca-cert.pem'),
+    cert: readFileSync('./client-cert.pem'),
+    key: readFileSync('./client-key.pem'),
+    rejectUnauthorized: true
+  },
+  username: 'admin',
+  password: 'secure-password'
+});
+
+await client.connect();
+```
+
+### Custom Logging
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+
+const client = new ScriptDBClient('scriptdb://localhost:1234/mydb', {
+  username: 'user',
+  password: 'pass',
+  logger: {
+    debug: (...args) => console.debug('[DEBUG]', ...args),
+    info: (...args) => console.info('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args)
+  }
+});
+```
+
+### Message Signing
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+
+const client = new ScriptDBClient('scriptdb://localhost:1234/mydb', {
+  username: 'user',
+  password: 'pass',
+  signing: {
+    secret: 'my-secret-key',
+    algorithm: 'sha256'
+  }
+});
+```
+
+### Token Refresh
+
+```typescript
+import { ScriptDBClient } from '@scriptdb/client';
+
+const client = new ScriptDBClient('scriptdb://localhost:1234/mydb', {
+  username: 'user',
+  password: 'pass',
+  tokenRefresh: async () => {
+    // Implement your token refresh logic here
+    const response = await fetch('https://api.example.com/refresh-token', {
+      method: 'POST',
+      headers: { 'Authorization': 'Bearer ' + oldToken }
+    });
+    const data = await response.json();
+    return {
+      token: data.token,
+      expiresAt: data.expiresAt
+    };
+  }
+});
+```
+
+## Error Handling
+
+The client uses promises and will reject with errors for various failure cases:
+
+```typescript
+try {
+  await client.connect();
+} catch (error) {
+  if (error.message.includes('Authentication failed')) {
+    console.error('Invalid credentials');
+  } else if (error.message.includes('ECONNREFUSED')) {
+    console.error('Server not reachable');
+  } else {
+    console.error('Connection error:', error.message);
+  }
+}
+```
+
+## Advanced Features
+
+### Connection Pooling
+
+For high-throughput applications, you can create multiple client instances:
+
+```typescript
+const clients = Array.from({ length: 5 }, () => 
+  new ScriptDBClient('scriptdb://localhost:1234/mydb', {
+    username: 'user',
+    password: 'pass'
+  })
+);
+
+// Connect all clients
+await Promise.all(clients.map(client => client.connect()));
+
+// Use round-robin or other strategy to distribute requests
+let currentClient = 0;
+function getClient() {
+  const client = clients[currentClient];
+  currentClient = (currentClient + 1) % clients.length;
+  return client;
+}
+```
+
+### Request Queueing
+
+The client automatically queues requests when the number of pending requests exceeds `maxPending`:
+
+```typescript
+const client = new ScriptDBClient('scriptdb://localhost:1234/mydb', {
+  username: 'user',
+  password: 'pass',
+  maxPending: 10,      // Max concurrent requests
+  maxQueue: 1000       // Max queued requests
+});
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build the package
+npm run build
+
+# Run type checking
+npm run typecheck
+
+# Lint code
+npm run lint
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,694 @@
+// src/index.ts
+import * as net from "net";
+import * as tls from "tls";
+import { URL } from "url";
+import * as crypto from "crypto";
+var noopLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+
+class ScriptDBClient {
+  options;
+  socketTimeout = 0;
+  maxMessageSize = 0;
+  _mask = () => {};
+  _maskArgs = () => [];
+  logger = {};
+  secure = true;
+  requestTimeout = 0;
+  retries = 0;
+  retryDelay = 0;
+  frame = "ndjson";
+  uri = "";
+  protocolName = "";
+  username = null;
+  password = null;
+  host = "";
+  port = 0;
+  database = null;
+  client = null;
+  buffer = Buffer.alloc(0);
+  _nextId = 1;
+  _pending = new Map;
+  _maxPending = 0;
+  _maxQueue = 0;
+  _pendingQueue = [];
+  _connected = false;
+  _authenticating = false;
+  token = null;
+  _currentRetries = 0;
+  tokenExpiry = null;
+  _destroyed = false;
+  _reconnectTimer = null;
+  signing = null;
+  _stringify = JSON.stringify;
+  ready = Promise.resolve();
+  _resolveReadyFn = null;
+  _rejectReadyFn = null;
+  _connecting = null;
+  _authPendingId = null;
+  constructor(uri, options = {}) {
+    if (!uri || typeof uri !== "string")
+      throw new Error("uri required");
+    this.options = Object.assign({}, options);
+    this.socketTimeout = Number.isFinite(this.options.socketTimeout) ? this.options.socketTimeout : 0;
+    this.maxMessageSize = Number.isFinite(this.options.maxMessageSize) ? this.options.maxMessageSize : 5 * 1024 * 1024;
+    this._mask = (obj) => {
+      try {
+        if (!obj || typeof obj !== "object")
+          return obj;
+        const copy = Array.isArray(obj) ? obj.slice() : Object.assign({}, obj);
+        if (copy.token)
+          copy.token = "****";
+        if (copy.password)
+          copy.password = "****";
+        if (copy.data && copy.data.password)
+          copy.data.password = "****";
+        return copy;
+      } catch (e) {
+        return obj;
+      }
+    };
+    const rawLogger = this.options.logger && typeof this.options.logger === "object" ? this.options.logger : noopLogger;
+    this._maskArgs = (args) => {
+      return args.map((a) => {
+        if (!a)
+          return a;
+        if (typeof a === "string")
+          return a;
+        return this._mask(a);
+      });
+    };
+    this.logger = {
+      debug: (...args) => rawLogger.debug && rawLogger.debug(...this._maskArgs(args)),
+      info: (...args) => rawLogger.info && rawLogger.info(...this._maskArgs(args)),
+      warn: (...args) => rawLogger.warn && rawLogger.warn(...this._maskArgs(args)),
+      error: (...args) => rawLogger.error && rawLogger.error(...this._maskArgs(args))
+    };
+    this.secure = typeof this.options.secure === "boolean" ? !!this.options.secure : true;
+    if (!this.secure)
+      this.logger.warn?.("Warning: connecting in insecure mode (secure=false). This is not recommended.");
+    this.requestTimeout = Number.isFinite(this.options.requestTimeout) ? this.options.requestTimeout : 0;
+    this.retries = Number.isFinite(this.options.retries) ? this.options.retries : 3;
+    this.retryDelay = Number.isFinite(this.options.retryDelay) ? this.options.retryDelay : 1000;
+    this.frame = this.options.frame === "length-prefix" || this.options.preferLengthPrefix ? "length-prefix" : "ndjson";
+    const normalized = uri.replace(/^https?:\/\//i, "scriptdb://");
+    let parsed;
+    try {
+      parsed = new URL(normalized);
+    } catch (e) {
+      throw new Error("Invalid uri");
+    }
+    this.uri = normalized;
+    this.protocolName = parsed.protocol ? parsed.protocol.replace(":", "") : "scriptdb";
+    this.username = (typeof this.options.username === "string" ? this.options.username : parsed.username) || null;
+    this.password = (typeof this.options.password === "string" ? this.options.password : parsed.password) || null;
+    if (parsed.username && !(typeof this.options.username === "string")) {
+      this.logger.warn?.("Credentials found in URI — consider passing credentials via options instead of embedding in URI");
+    }
+    try {
+      parsed.username = "";
+      parsed.password = "";
+      this.uri = parsed.toString();
+    } catch (e) {
+      this.uri = normalized;
+    }
+    this.host = parsed.hostname || "localhost";
+    this.port = parsed.port ? parseInt(parsed.port, 10) : 1234;
+    this.database = parsed.pathname && parsed.pathname.length > 1 ? parsed.pathname.slice(1) : null;
+    this.client = null;
+    this.buffer = Buffer.alloc(0);
+    this._nextId = 1;
+    this._pending = new Map;
+    this._maxPending = Number.isFinite(this.options.maxPending) ? this.options.maxPending : 100;
+    this._maxQueue = Number.isFinite(this.options.maxQueue) ? this.options.maxQueue : 1000;
+    this._pendingQueue = [];
+    this._connected = false;
+    this._authenticating = false;
+    this.token = null;
+    this._currentRetries = 0;
+    this.tokenExpiry = null;
+    this._destroyed = false;
+    this._reconnectTimer = null;
+    this.signing = this.options.signing && this.options.signing.secret ? this.options.signing : null;
+    this._stringify = typeof this.options.stringify === "function" ? this.options.stringify : JSON.stringify;
+    this._createReady();
+  }
+  _createReady() {
+    this.ready = new Promise((resolve, reject) => {
+      this._resolveReadyFn = resolve;
+      this._rejectReadyFn = reject;
+    });
+  }
+  _resolveReady(value) {
+    if (this._resolveReadyFn) {
+      try {
+        this._resolveReadyFn(value);
+      } catch (e) {}
+      this._resolveReadyFn = null;
+      this._rejectReadyFn = null;
+    }
+  }
+  _rejectReady(err) {
+    if (this._rejectReadyFn) {
+      const rejectFn = this._rejectReadyFn;
+      this._resolveReadyFn = null;
+      this._rejectReadyFn = null;
+      process.nextTick(() => {
+        try {
+          rejectFn(err);
+        } catch (e) {}
+      });
+    }
+  }
+  connect() {
+    if (this._connecting)
+      return this._connecting;
+    this._connecting = new Promise((resolve, reject) => {
+      const opts = { host: this.host, port: this.port };
+      const onConnect = () => {
+        console.log("ScriptDBClient: Connected to server at", opts.host, opts.port);
+        this.logger?.info?.("Connected to server");
+        this._connected = true;
+        this._currentRetries = 0;
+        console.log("ScriptDBClient: Setting up listeners...");
+        this._setupListeners();
+        console.log("ScriptDBClient: Authenticating...");
+        this.authenticate().then(() => {
+          this._processQueue();
+          resolve(this);
+        }).catch((err) => {
+          reject(err);
+        });
+      };
+      try {
+        if (this.secure) {
+          const connectionOpts = { host: opts.host, port: opts.port };
+          const tlsOptions = Object.assign({}, this.options.tlsOptions || {}, connectionOpts);
+          if (typeof tlsOptions.rejectUnauthorized === "undefined")
+            tlsOptions.rejectUnauthorized = true;
+          this.client = tls.connect(tlsOptions, onConnect);
+        } else {
+          this.client = net.createConnection(opts, onConnect);
+        }
+      } catch (e) {
+        const error = e;
+        this.logger?.error?.("Connection failed", error.message);
+        this._rejectReady(error);
+        this._createReady();
+        this._connecting = null;
+        return reject(error);
+      }
+      const onError = (err) => {
+        this.logger?.error?.("Client socket error:", err && err.message ? err.message : err);
+        this._handleDisconnect(err);
+      };
+      const onClose = (hadError) => {
+        this.logger?.info?.("Server closed connection");
+        this._handleDisconnect(null);
+      };
+      this.client.on("error", onError);
+      this.client.on("close", onClose);
+      if (this.socketTimeout > 0) {
+        this.client.setTimeout(this.socketTimeout);
+        this.client.on("timeout", () => {
+          this.logger?.warn?.("Socket timeout, destroying connection");
+          try {
+            this.client?.destroy();
+          } catch (e) {}
+        });
+      }
+    }).catch((err) => {
+      this._connecting = null;
+      throw err;
+    });
+    return this._connecting;
+  }
+  _setupListeners() {
+    if (!this.client)
+      return;
+    console.log("ScriptDBClient _setupListeners: called, client exists:", !!this.client);
+    this.client.removeAllListeners("data");
+    this.buffer = Buffer.alloc(0);
+    console.log("ScriptDBClient _setupListeners: frame mode:", this.frame);
+    if (this.frame === "length-prefix") {
+      this.client.on("data", (chunk) => {
+        if (!Buffer.isBuffer(chunk)) {
+          try {
+            chunk = Buffer.from(chunk);
+          } catch (e) {
+            return;
+          }
+        }
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 4) {
+          const len = this.buffer.readUInt32BE(0);
+          if (len > this.maxMessageSize) {
+            this.logger?.error?.("Incoming length-prefixed frame exceeds maxMessageSize — closing connection");
+            try {
+              this.client?.destroy();
+            } catch (e) {}
+            return;
+          }
+          if (this.buffer.length < 4 + len)
+            break;
+          const payload = this.buffer.slice(4, 4 + len);
+          this.buffer = this.buffer.slice(4 + len);
+          let msg;
+          try {
+            msg = JSON.parse(payload.toString("utf8"));
+          } catch (e) {
+            this.logger?.error?.("Invalid JSON frame", e && e.message ? e.message : e);
+            continue;
+          }
+          if (!msg || typeof msg !== "object")
+            continue;
+          const validSchema = (typeof msg.id === "undefined" || typeof msg.id === "number") && (typeof msg.action === "string" || typeof msg.action === "undefined") && (typeof msg.command === "string" || typeof msg.command === "undefined") && (typeof msg.message === "string" || typeof msg.message === "undefined") && (typeof msg.data === "object" || typeof msg.data === "undefined" || msg.data === null);
+          if (!validSchema) {
+            this.logger?.warn?.("Message failed schema validation — ignoring");
+            continue;
+          }
+          this._handleMessage(msg);
+        }
+      });
+    } else {
+      console.log("ScriptDBClient _setupListeners: Setting up NDJSON data listener");
+      this.client.on("data", (chunk) => {
+        console.log("ScriptDBClient: Received data chunk, length:", chunk.length);
+        if (!Buffer.isBuffer(chunk)) {
+          try {
+            chunk = Buffer.from(chunk);
+          } catch (e) {
+            return;
+          }
+        }
+        const idxLastNewline = chunk.indexOf(10);
+        if (this.buffer.length === 0 && idxLastNewline === chunk.length - 1) {
+          let start = 0;
+          let idx2;
+          while ((idx2 = chunk.indexOf(10, start)) !== -1) {
+            const lineBuf = chunk.slice(start, idx2);
+            start = idx2 + 1;
+            if (lineBuf.length === 0)
+              continue;
+            let msg;
+            try {
+              msg = JSON.parse(lineBuf.toString("utf8"));
+            } catch (e) {
+              this.logger?.error?.("Invalid JSON from server", e && e.message ? e.message : e);
+              continue;
+            }
+            if (!msg || typeof msg !== "object")
+              continue;
+            const validSchema = (typeof msg.id === "undefined" || typeof msg.id === "number") && (typeof msg.action === "string" || typeof msg.action === "undefined") && (typeof msg.command === "string" || typeof msg.command === "undefined") && (typeof msg.message === "string" || typeof msg.message === "undefined");
+            if (!validSchema)
+              continue;
+            this._handleMessage(msg);
+          }
+          return;
+        }
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        if (this.buffer.length > this.maxMessageSize) {
+          this.logger?.error?.("Incoming message exceeds maxMessageSize — closing connection");
+          try {
+            this.client?.destroy();
+          } catch (e) {}
+          return;
+        }
+        let idx;
+        while ((idx = this.buffer.indexOf(10)) !== -1) {
+          const lineBuf = this.buffer.slice(0, idx);
+          this.buffer = this.buffer.slice(idx + 1);
+          if (lineBuf.length === 0)
+            continue;
+          let msg;
+          try {
+            msg = JSON.parse(lineBuf.toString("utf8"));
+          } catch (e) {
+            this.logger?.error?.("Invalid JSON from server", e && e.message ? e.message : e);
+            continue;
+          }
+          const validSchema = (typeof msg.id === "undefined" || typeof msg.id === "number") && (typeof msg.action === "string" || typeof msg.action === "undefined") && (typeof msg.command === "string" || typeof msg.command === "undefined") && (typeof msg.message === "string" || typeof msg.message === "undefined");
+          if (!validSchema) {
+            this.logger?.warn?.("Message failed schema validation — ignoring");
+            continue;
+          }
+          this._handleMessage(msg);
+        }
+      });
+    }
+  }
+  _buildFinalBuffer(payloadBase, id) {
+    const payloadObj = Object.assign({ id, action: payloadBase.action }, payloadBase.data !== undefined ? { data: payloadBase.data } : {});
+    if (this.token)
+      payloadObj.token = this.token;
+    const payloadStr = this._stringify(payloadObj);
+    if (this.signing && this.signing.secret) {
+      const hmac = crypto.createHmac(this.signing.algorithm || "sha256", this.signing.secret);
+      hmac.update(payloadStr);
+      const sig = hmac.digest("hex");
+      const envelope = { id, signature: sig, payload: payloadObj };
+      const envelopeStr = this._stringify(envelope);
+      if (this.frame === "length-prefix") {
+        const body = Buffer.from(envelopeStr, "utf8");
+        const buf = Buffer.allocUnsafe(4 + body.length);
+        buf.writeUInt32BE(body.length, 0);
+        body.copy(buf, 4);
+        return buf;
+      }
+      return Buffer.from(envelopeStr + `
+`, "utf8");
+    }
+    if (this.frame === "length-prefix") {
+      const body = Buffer.from(payloadStr, "utf8");
+      const buf = Buffer.allocUnsafe(4 + body.length);
+      buf.writeUInt32BE(body.length, 0);
+      body.copy(buf, 4);
+      return buf;
+    }
+    return Buffer.from(payloadStr + `
+`, "utf8");
+  }
+  _handleMessage(msg) {
+    console.log("ScriptDBClient _handleMessage:", JSON.stringify(msg));
+    console.log("ScriptDBClient _handleMessage msg.id:", msg.id, "msg.action:", msg.action, "msg.command:", msg.command, "msg.message:", msg.message);
+    if (msg && typeof msg.id !== "undefined") {
+      console.log("Handling message with id:", msg.id, "action:", msg.action, "message:", msg.message);
+      const pending = this._pending.get(msg.id);
+      if (!pending) {
+        console.log("No pending request for id", msg.id, "pending map size:", this._pending.size);
+        this.logger?.debug?.("No pending request for id", msg.id);
+        return;
+      }
+      const { resolve, reject, timer } = pending;
+      if (timer)
+        clearTimeout(timer);
+      this._pending.delete(msg.id);
+      this._processQueue();
+      if (msg.action === "login" || msg.command === "login") {
+        console.log("Processing login response with id");
+        if (msg.message === "AUTH OK") {
+          console.log("AUTH OK - setting token and resolving");
+          this.token = msg.data && msg.data.token ? msg.data.token : null;
+          this._resolveReady(null);
+          return resolve(msg.data);
+        } else {
+          console.log("AUTH FAILED:", msg.data);
+          this._rejectReady(new Error("Authentication failed"));
+          const errorMsg = msg.data || "Authentication failed";
+          try {
+            this.client?.end();
+          } catch (e) {}
+          return reject(new Error(typeof errorMsg === "string" ? errorMsg : "Authentication failed"));
+        }
+      }
+      if ((msg.action === "script-code" || msg.command === "script-code") && msg.message === "OK")
+        return resolve(msg.data);
+      if ((msg.action === "script-code" || msg.command === "script-code") && msg.message === "ERROR")
+        return reject(new Error(typeof msg.data === "string" ? msg.data : "Server returned ERROR"));
+      if (msg.action === "create-db" && msg.message === "SUCCESS")
+        return resolve(msg.data);
+      if (msg.action === "create-db" && msg.message === "ERROR")
+        return reject(new Error(typeof msg.data === "string" ? msg.data : "Failed to create database"));
+      if (msg.message === "OK" || msg.message === "SUCCESS") {
+        return resolve(msg.data);
+      } else if (msg.message === "ERROR") {
+        return reject(new Error(typeof msg.data === "string" ? msg.data : "Request failed"));
+      }
+      return reject(new Error("Invalid response from server"));
+    }
+    console.log("Unhandled message:", msg);
+    this.logger?.debug?.("Unhandled message from server", this._mask(msg));
+  }
+  authenticate() {
+    if (this._authenticating)
+      return Promise.reject(new Error("Already authenticating"));
+    this._authenticating = true;
+    return new Promise((resolve, reject) => {
+      const id = this._nextId++;
+      const payload = {
+        id,
+        action: "login",
+        data: { username: this.username, password: this.password }
+      };
+      let timer = null;
+      if (this.requestTimeout > 0) {
+        timer = setTimeout(() => {
+          this._pending.delete(id);
+          this._authenticating = false;
+          reject(new Error("Auth timeout"));
+          this.close();
+        }, this.requestTimeout);
+      }
+      this._pending.set(id, {
+        resolve: (data) => {
+          if (timer)
+            clearTimeout(timer);
+          this._authenticating = false;
+          if (data && data.token)
+            this.token = data.token;
+          resolve(data);
+        },
+        reject: (err) => {
+          if (timer)
+            clearTimeout(timer);
+          this._authenticating = false;
+          reject(err);
+        },
+        timer
+      });
+      try {
+        const buf = Buffer.from(JSON.stringify(payload) + `
+`, "utf8");
+        this._write(buf).catch((err) => {
+          if (timer)
+            clearTimeout(timer);
+          this._pending.delete(id);
+          this._authenticating = false;
+          reject(err);
+        });
+      } catch (e) {
+        clearTimeout(timer);
+        this._pending.delete(id);
+        this._authenticating = false;
+        reject(e);
+      }
+    }).then((data) => {
+      if (data && data.token) {
+        this.token = data.token;
+        this._resolveReady(null);
+      }
+      return data;
+    }).catch((err) => {
+      this._rejectReady(err);
+      throw err;
+    });
+  }
+  _write(buf) {
+    return new Promise((resolve, reject) => {
+      if (!this.client || !this._connected)
+        return reject(new Error("Not connected"));
+      try {
+        const ok = this.client.write(buf, (err) => {
+          if (err)
+            return reject(err);
+          resolve(undefined);
+        });
+        if (!ok) {
+          this.client.once("drain", () => resolve(undefined));
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  async _processQueue() {
+    while (this._pending.size < this._maxPending && this._pendingQueue.length > 0) {
+      const item = this._pendingQueue.shift();
+      const { payloadBase, id, resolve, reject, timer } = item;
+      if (this.tokenExpiry && Date.now() >= this.tokenExpiry) {
+        const refreshed = await this._maybeRefreshToken();
+        if (!refreshed) {
+          clearTimeout(timer);
+          try {
+            reject(new Error("Token expired and refresh failed"));
+          } catch (e) {}
+          continue;
+        }
+      }
+      let buf;
+      try {
+        buf = this._buildFinalBuffer(payloadBase, id);
+      } catch (e) {
+        clearTimeout(timer);
+        try {
+          reject(e);
+        } catch (er) {}
+        continue;
+      }
+      this._pending.set(id, { resolve, reject, timer });
+      try {
+        await this._write(buf);
+      } catch (e) {
+        clearTimeout(timer);
+        this._pending.delete(id);
+        try {
+          reject(e);
+        } catch (er) {}
+      }
+    }
+  }
+  async execute(payload) {
+    try {
+      await this.ready;
+    } catch (err) {
+      throw new Error("Not authenticated: " + (err && err.message ? err.message : err));
+    }
+    if (!this.token)
+      throw new Error("Not authenticated");
+    const id = this._nextId++;
+    const payloadBase = { action: payload.action, data: payload.data };
+    if (this.tokenExpiry && Date.now() >= this.tokenExpiry) {
+      const refreshed = await this._maybeRefreshToken();
+      if (!refreshed)
+        throw new Error("Token expired");
+    }
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      if (this.requestTimeout > 0) {
+        timer = setTimeout(() => {
+          if (this._pending.has(id)) {
+            this._pending.delete(id);
+            reject(new Error("Request timeout"));
+          }
+        }, this.requestTimeout);
+      }
+      if (this._pending.size >= this._maxPending) {
+        if (this._pendingQueue.length >= this._maxQueue) {
+          if (timer)
+            clearTimeout(timer);
+          return reject(new Error("Pending queue full"));
+        }
+        this._pendingQueue.push({ payloadBase, id, resolve, reject, timer });
+        this._processQueue().catch(() => {});
+        return;
+      }
+      let finalBuf;
+      try {
+        finalBuf = this._buildFinalBuffer(payloadBase, id);
+      } catch (e) {
+        clearTimeout(timer);
+        return reject(e);
+      }
+      this._pending.set(id, { resolve, reject, timer });
+      this._write(finalBuf).catch((e) => {
+        if (timer)
+          clearTimeout(timer);
+        this._pending.delete(id);
+        reject(e);
+      });
+    });
+  }
+  async _maybeRefreshToken() {
+    if (!this.options.tokenRefresh || typeof this.options.tokenRefresh !== "function")
+      return false;
+    try {
+      const res = await this.options.tokenRefresh();
+      if (res && res.token) {
+        this.token = res.token;
+        if (res.expiresAt)
+          this.tokenExpiry = res.expiresAt;
+        return true;
+      }
+    } catch (e) {
+      this.logger?.error?.("Token refresh failed", e && e.message ? e.message : String(e));
+    }
+    return false;
+  }
+  destroy() {
+    this._destroyed = true;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    this._rejectReady(new Error("Client destroyed"));
+    this._pending.forEach((pending, id) => {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      try {
+        pending.reject(new Error("Client destroyed"));
+      } catch (e) {}
+      this._pending.delete(id);
+    });
+    this._pendingQueue = [];
+    try {
+      if (this.client)
+        this.client.destroy();
+    } catch (e) {}
+    this.client = null;
+  }
+  _handleDisconnect(err) {
+    if (!this._connected && !this._authenticating) {
+      return;
+    }
+    const wasAuthenticating = this._authenticating;
+    this._pending.forEach((pending, id) => {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      const errorMsg = wasAuthenticating ? "Authentication failed - credentials may be required" : err && err.message ? err.message : "Disconnected";
+      process.nextTick(() => {
+        try {
+          pending.reject(new Error(errorMsg));
+        } catch (e) {}
+      });
+      this._pending.delete(id);
+    });
+    this._connected = false;
+    this._connecting = null;
+    this._authenticating = false;
+    if (wasAuthenticating && this.retries === 0) {
+      const rejectErr = err || new Error("Authentication failed and no retries configured");
+      try {
+        this._rejectReady(rejectErr);
+      } catch (e) {}
+      return;
+    }
+    if (this._currentRetries < this.retries) {
+      this._createReady();
+      const base = Math.min(this.retryDelay * Math.pow(2, this._currentRetries), 30000);
+      const jitter = Math.floor(Math.random() * Math.min(1000, base));
+      const delay = base + jitter;
+      this._currentRetries += 1;
+      this.logger?.info?.("Attempting reconnect in " + delay + "ms (attempt " + this._currentRetries + ")");
+      this.token = null;
+      setTimeout(() => {
+        this.connect().catch((e) => {
+          this.logger?.error?.("Reconnect failed", e && e.message ? e.message : e);
+        });
+      }, delay);
+    } else {
+      try {
+        this._rejectReady(err || new Error("Disconnected and no retries left"));
+      } catch (e) {}
+    }
+  }
+  close() {
+    if (!this.client)
+      return;
+    try {
+      this.client.removeAllListeners("data");
+      this.client.removeAllListeners("error");
+      this.client.removeAllListeners("close");
+      this.client.end();
+    } catch (e) {}
+    this.client = null;
+  }
+}
+var src_default = ScriptDBClient;
+export {
+  src_default as default,
+  ScriptDBClient
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@scriptdb/client",
+  "version": "1.0.0",
+  "description": "Client module resolver for script database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --splitting --external bcryptjs --external bottleneck --external jsonwebtoken --external lru-cache",
+    "build:cjs": "bun build src/index.ts --outdir dist --target node --format cjs --outfile dist/index.js --external bcryptjs --external bottleneck --external jsonwebtoken --external lru-cache",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:all": "bun run build && bun run build:cjs && bun run build:types",
+    "test": "bun test",
+    "lint": "bun run lint:src",
+    "lint:src": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^3.0.0",
+    "@types/bun": "^1.3.2",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/lru-cache": "^7.10.10",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "bun-types": "latest",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "bottleneck": "^2.19.5",
+    "jsonwebtoken": "^9.0.2",
+    "lru-cache": "^11.2.2",
+    "node": "^25.2.0"
+  }
+}