astradb 1.0.1

package/README.md

@@ -0,0 +1,46 @@
+# AstraDB
+
+Fast NoSQL database with MongoDB-compatible API.
+
+## Install
+
+```bash
+npm install astradb
+```
+
+## Quick Start
+
+```javascript
+const { AstraDB } = require('astradb');
+
+// Connect
+const client = new AstraDB('astradb://localhost:8080');
+await client.connect();
+
+// Use
+const users = client.db('myapp').collection('users');
+await users.insertOne({ name: 'Alice', age: 25 });
+const all = await users.find();
+console.log(all);
+```
+
+## Start Server
+
+```bash
+npx astradb start
+```
+
+Server runs on: http://localhost:8080
+
+## Features
+
+
+- ✅ LSM-tree storage engine
+- ✅ Hash & B-tree indexes
+- ✅ Write-Ahead Logging (WAL)
+- ✅ Auto-compaction
+- ✅ Authentication & rate limiting
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const { spawn } = require("child_process");
+
+function getBinaryName() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "win32") {
+    return "astradb-windows-x64.exe";
+  }
+  if (platform === "darwin") {
+    return arch === "arm64"
+      ? "astradb-darwin-arm64"
+      : "astradb-darwin-x64";
+  }
+  if (platform === "linux") {
+    return arch === "arm64"
+      ? "astradb-linux-arm64"
+      : "astradb-linux-x64";
+  }
+
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+
+const command = process.argv[2];
+
+if (!command || command === "start") {
+  const binaryName = getBinaryName();
+  const binaryPath = path.join(__dirname, binaryName);
+
+  console.log("Starting AstraDB...");
+
+  const child = spawn(binaryPath, {
+    stdio: "inherit",
+  });
+
+  child.on("error", (err) => {
+    console.error("Failed to start AstraDB:", err);
+  });
+
+} else if (command === "version") {
+  console.log("AstraDB CLI v1.0.0");
+} else {
+  console.log(`
+Usage:
+  astradb start
+  astradb version
+`);
+}

package/index.js

@@ -0,0 +1,2 @@
+const { AstraDB, Db, Collection } = require('./lib/client');
+module.exports = { AstraDB, Db, Collection };

package/lib/client.js

@@ -0,0 +1,274 @@
+/**
+ * AstraDB Client - Final Version
+ * Works with and without auth — exactly like MongoDB
+ */
+
+const axios = require('axios');
+
+class AstraDB {
+  /**
+   * @param {string} connectionString
+   *
+   * No auth:   'astradb://localhost:8080'
+   * With auth: 'astradb://admin:password@localhost:8080'
+   */
+  constructor(connectionString) {
+    const parsed = this._parse(connectionString);
+
+    this.host     = parsed.host;
+    this.port     = parsed.port;
+    this.username = parsed.username;  // null if no auth
+    this.password = parsed.password;  // null if no auth
+    this.baseURL  = `http://${parsed.host}:${parsed.port}`;
+    this._apiKey  = null;
+    this._ready   = false;
+
+    this._http = axios.create({
+      baseURL: this.baseURL,
+      timeout: 30000,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+
+  _parse(str) {
+    if (!str) throw new Error('Connection string required');
+
+    // Remove protocol
+    const s = str.replace(/^astradb:\/\//, '').replace(/^mongodb:\/\//, '');
+
+    const atIndex = s.lastIndexOf('@');
+
+    if (atIndex === -1) {
+      // No credentials: 'localhost:8080'
+      const parts = s.split(':');
+      return { host: parts[0], port: parseInt(parts[1] || 8080), username: null, password: null };
+    }
+
+    // Has credentials: 'admin:pass@localhost:8080'
+    const userInfo  = s.substring(0, atIndex);
+    const hostInfo  = s.substring(atIndex + 1);
+    const colonIdx  = userInfo.indexOf(':');
+    const username  = decodeURIComponent(userInfo.substring(0, colonIdx));
+    const password  = decodeURIComponent(userInfo.substring(colonIdx + 1));
+    const hostParts = hostInfo.split(':');
+
+    return {
+      host: hostParts[0],
+      port: parseInt(hostParts[1] || 8080),
+      username,
+      password
+    };
+  }
+
+  /**
+   * Connect to server
+   * - No credentials → just check server is alive
+   * - With credentials → login and get session
+   */
+  async connect() {
+    // Check server is alive
+    try {
+      await this._http.get('/health');
+    } catch {
+      throw new Error(`Cannot connect to AstraDB at ${this.baseURL}.\nIs the server running?\n  cd testDB && go run cmd/astradb/main.go`);
+    }
+
+    // Login if credentials provided
+    if (this.username && this.password) {
+      try {
+        const res = await this._http.post('/api/auth/login', {
+          username: this.username,
+          password: this.password
+        });
+        this._apiKey = res.data.apiKey;
+        this._http.defaults.headers['X-API-Key'] = this._apiKey;
+      } catch (err) {
+        if (err.response && err.response.status === 401) {
+          throw new Error(`Wrong username or password for "${this.username}"`);
+        }
+        throw err;
+      }
+    }
+
+    this._ready = true;
+    return this;
+  }
+
+  async close() {
+    this._apiKey = null;
+    this._ready  = false;
+  }
+
+  async ping() {
+    try {
+      const res = await this._http.get('/health');
+      return res.data.status === 'ok';
+    } catch { return false; }
+  }
+
+  db(dbName) {
+    if (!this._ready) throw new Error('Call await client.connect() first');
+    return new Db(this._http, dbName);
+  }
+
+  async listDatabases() {
+    const res = await this._http.get('/api/databases');
+    return (res.data.databases || []).map(name => ({ name }));
+  }
+}
+
+// ────────────────────────────────
+class Db {
+  constructor(http, dbName) {
+    this._http   = http;
+    this._dbName = dbName;
+  }
+
+  collection(name) { return new Collection(this._http, this._dbName, name); }
+
+  async listCollections() {
+    const res = await this._http.get(`/api/collections?db=${this._dbName}`);
+    return (res.data.collections || []).map(n => ({ name: n }));
+  }
+
+  async stats() {
+    const res = await this._http.get(`/api/stats?db=${this._dbName}`);
+    return res.data.stats;
+  }
+
+  async dropDatabase() {
+    const cols = await this.listCollections();
+    for (const { name } of cols) await this.collection(name).drop();
+    return { ok: 1 };
+  }
+}
+
+// ────────────────────────────────
+class Collection {
+  constructor(http, db, col) {
+    this._http = http;
+    this._db   = db;
+    this._col  = col;
+  }
+
+  // ── INSERT ──
+  async insertOne(doc) {
+    const r = await this._http.post('/api/insert', { db: this._db, collection: this._col, data: doc });
+    return { acknowledged: true, insertedId: r.data.id };
+  }
+
+  async insertMany(docs) {
+    const results = await Promise.all(docs.map(d => this.insertOne(d)));
+    return { acknowledged: true, insertedCount: results.length, insertedIds: results.map(r => r.insertedId) };
+  }
+
+  // ── FIND ──
+  async find(filter = {}, options = {}) {
+    const r = await this._http.post('/api/query', {
+      db: this._db, collection: this._col, filter,
+      sort: options.sort || null, limit: options.limit || null,
+      skip: options.skip || null, projection: options.projection || null
+    });
+    return r.data.data || [];
+  }
+
+  async findOne(filter = {}, options = {}) {
+    const docs = await this.find(filter, { ...options, limit: 1 });
+    return docs[0] || null;
+  }
+
+  async findById(id)               { return this.findOne({ _id: id }); }
+  async countDocuments(filter = {}) { return (await this.find(filter)).length; }
+  async estimatedDocumentCount()    { return this.countDocuments(); }
+  async exists(filter)              { return (await this.findOne(filter)) !== null; }
+
+  async distinct(field, filter = {}) {
+    const docs = await this.find(filter);
+    const seen = new Set();
+    return docs.reduce((acc, doc) => {
+      const v = this._get(doc, field);
+      if (v !== undefined) {
+        const k = JSON.stringify(v);
+        if (!seen.has(k)) { seen.add(k); acc.push(v); }
+      }
+      return acc;
+    }, []);
+  }
+
+  // ── UPDATE ──
+  async updateOne(filter, update) {
+    const r = await this._http.post('/api/update', { db: this._db, collection: this._col, filter, update, multi: false });
+    return { acknowledged: true, matchedCount: r.data.updated, modifiedCount: r.data.updated };
+  }
+
+  async updateMany(filter, update) {
+    const r = await this._http.post('/api/update', { db: this._db, collection: this._col, filter, update, multi: true });
+    return { acknowledged: true, matchedCount: r.data.updated, modifiedCount: r.data.updated };
+  }
+
+  async replaceOne(filter, doc)    { return this.updateOne(filter, { $set: doc }); }
+
+  async findOneAndUpdate(filter, update, opts = {}) {
+    const before = await this.findOne(filter);
+    if (!before) return { value: null };
+    await this.updateOne(filter, update);
+    const val = opts.returnDocument === 'after' ? await this.findOne(filter) : before;
+    return { value: val, ok: 1 };
+  }
+
+  // ── DELETE ──
+  async deleteOne(filter) {
+    const r = await this._http.post('/api/delete', { db: this._db, collection: this._col, filter, multi: false });
+    return { acknowledged: true, deletedCount: r.data.deleted };
+  }
+
+  async deleteMany(filter = {}) {
+    const r = await this._http.post('/api/delete', { db: this._db, collection: this._col, filter, multi: true });
+    return { acknowledged: true, deletedCount: r.data.deleted };
+  }
+
+  async findOneAndDelete(filter) {
+    const doc = await this.findOne(filter);
+    if (!doc) return { value: null };
+    await this.deleteOne(filter);
+    return { value: doc, ok: 1 };
+  }
+
+  async drop() { await this.deleteMany({}); return true; }
+
+  // ── INDEXES ──
+  async createIndex(fieldOrSpec, opts = {}) {
+    const fields = Array.isArray(fieldOrSpec) ? fieldOrSpec
+      : typeof fieldOrSpec === 'string' ? [fieldOrSpec]
+      : Object.keys(fieldOrSpec);
+    await this._http.post('/api/createIndex', {
+      db: this._db, collection: this._col, fields,
+      type: opts.btree ? 'btree' : (opts.type || 'hash'),
+      unique: opts.unique || false
+    });
+    return fields.join('_') + '_1';
+  }
+
+  async createIndexes(specs) {
+    return Promise.all(specs.map(s => this.createIndex(s.key, s)));
+  }
+
+  // ── BULK ──
+  async bulkWrite(ops) {
+    const results = [];
+    for (const op of ops) {
+      if (op.insertOne)   results.push(await this.insertOne(op.insertOne.document));
+      if (op.updateOne)   results.push(await this.updateOne(op.updateOne.filter, op.updateOne.update));
+      if (op.updateMany)  results.push(await this.updateMany(op.updateMany.filter, op.updateMany.update));
+      if (op.deleteOne)   results.push(await this.deleteOne(op.deleteOne.filter));
+      if (op.deleteMany)  results.push(await this.deleteMany(op.deleteMany.filter));
+    }
+    return { acknowledged: true, results };
+  }
+
+  _get(obj, path) {
+    return path.split('.').reduce((v, k) => v && typeof v === 'object' ? v[k] : undefined, obj);
+  }
+}
+
+module.exports = { AstraDB, Db, Collection };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "astradb",
+  "version": "1.0.1",
+  "description": "Fast NoSQL database with MongoDB-compatible API",
+  "main": "index.js",
+  "bin": {
+    "astradb": "bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "database",
+    "nosql",
+    "mongodb",
+    "astradb",
+    "lsm-tree"
+  ],
+  "author": "AnshulKhichi",
+  "license": "MIT",
+  "homepage": "https://github.com/AnshulKhichi11/astradb",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AnshulKhichi11/astradb.git"
+  },
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,56 @@
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+
+const BASE_URL = "https://github.com/AnshulKhichi11/AstraDB/releases/download/v1.0.0";
+
+function getBinaryName() {
+  const platform = process.platform;
+
+  if (platform === "win32") {
+    return "astradb-windows-x64.exe";
+  }
+  if (platform === "darwin") {
+    return "astradb-darwin-x64";
+  }
+  if (platform === "linux") {
+    return "astradb-linux-x64";
+  }
+
+  throw new Error("Unsupported platform");
+}
+
+async function downloadBinary() {
+  const binaryName = getBinaryName();
+  const url = `${BASE_URL}/${binaryName}`;
+
+  const binDir = path.join(__dirname, "..", "bin");
+  const binaryPath = path.join(binDir, binaryName);
+
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir);
+  }
+
+  console.log("Downloading AstraDB from:", url);
+
+  const response = await axios({
+    method: "GET",
+    url,
+    responseType: "stream",
+  });
+
+  const writer = fs.createWriteStream(binaryPath);
+
+  response.data.pipe(writer);
+
+  writer.on("finish", () => {
+    fs.chmodSync(binaryPath, 0o755);
+    console.log("AstraDB binary installed successfully");
+  });
+
+  writer.on("error", (err) => {
+    console.error("Download failed:", err);
+  });
+}
+
+downloadBinary();