@liorandb/db 1.0.0

package/README.md

@@ -0,0 +1,172 @@
+# LioranDB Server
+
+LioranDB Server is a Node.js + TypeScript REST API server built on top of **LioranDB Core**, designed to manage databases, collections, and documents, while providing user authentication. It is intended as the backend for applications using the LioranDB database engine.
+
+---
+
+## Table of Contents
+
+* [Features](#features)
+* [Tech Stack](#tech-stack)
+* [Setup](#setup)
+* [Environment Variables](#environment-variables)
+* [Scripts](#scripts)
+* [API Endpoints](#api-endpoints)
+* [Project Structure](#project-structure)
+* [License](#license)
+
+---
+
+## Features
+
+* User authentication (register/login) with JWT tokens
+* CRUD operations for databases, collections, and documents
+* Health check endpoint
+* TypeScript support with strict typing
+* Middleware for authentication
+
+---
+
+## Tech Stack
+
+* Node.js
+* TypeScript
+* Express.js
+* LioranDB Core
+* bcryptjs
+* jsonwebtoken
+* dotenv
+
+---
+
+## Setup
+
+1. Clone the repository
+
+```bash
+git clone <repo_url>
+cd server
+```
+
+2. Install dependencies
+
+```bash
+npm install
+```
+
+3. Create a `.env` file at the root:
+
+```env
+PORT=4000
+JWT_SECRET=<your_jwt_secret>
+JWT_EXPIRES_IN=7d
+```
+
+4. Run the development server
+
+```bash
+npm run dev
+```
+
+The server will start on `http://localhost:4000` (or your configured PORT).
+
+---
+
+## Environment Variables
+
+* `PORT` – Port number for the server (default: 4000)
+* `JWT_SECRET` – Secret key used for signing JWT tokens **(required)**
+* `JWT_EXPIRES_IN` – JWT expiration time (default: `7d`)
+
+---
+
+## Scripts
+
+* `npm run dev` – Start the development server with hot reload
+* `npm run build` – Compile TypeScript to JavaScript (`dist/` folder)
+* `npm start` – Run the compiled server
+
+---
+
+## API Endpoints
+
+### Health Check
+
+* `GET /health` – Returns server status
+
+### Authentication
+
+* `POST /auth/register` – Register a new user
+* `POST /auth/login` – Login and receive JWT token
+
+### Databases
+
+* `GET /databases` – List all databases
+* `POST /databases` – Create a new database
+* `DELETE /databases/:db` – Delete a database
+
+### Collections
+
+* `GET /db/:db/collections` – List all collections in a database
+* `POST /db/:db/collections` – Create a new collection
+
+### Documents
+
+* `POST /db/:db/collections/:col` – Insert a document
+* `POST /db/:db/collections/:col/find` – Find documents by query
+* `GET /db/:db/collections/:col/:id` – Get a single document by ID
+* `PATCH /db/:db/collections/:col/:id` – Update a document by ID
+* `DELETE /db/:db/collections/:col/:id` – Delete a document by ID
+
+> All database, collection, and document endpoints require **Bearer JWT authentication**
+
+---
+
+## Project Structure
+
+```
+server/
+├─ src/
+│  ├─ config/
+│  │  └─ database.ts        # LioranDB manager and auth collection
+│  ├─ controllers/
+│  │  ├─ auth.controller.ts
+│  │  ├─ collection.controller.ts
+│  │  ├─ database.controller.ts
+│  │  └─ document.controller.ts
+│  ├─ middleware/
+│  │  └─ auth.middleware.ts
+│  ├─ routes/
+│  │  ├─ auth.routes.ts
+│  │  ├─ collection.routes.ts
+│  │  ├─ database.routes.ts
+│  │  └─ document.routes.ts
+│  ├─ types/
+│  │  ├─ auth-user.ts
+│  │  └─ express.d.ts
+│  ├─ utils/
+│  │  └─ token.ts
+│  ├─ app.ts
+│  └─ server.ts
+├─ package.json
+├─ tsconfig.json
+└─ .env
+```
+
+---
+
+## License
+
+This project is licensed under the **ISC License**.
+
+---
+
+## Notes
+
+* Make sure to set a strong `JWT_SECRET` in `.env`
+* The server is designed to work with **LioranDB Core**, which is a peer-to-peer database engine.
+* TypeScript strict mode is enabled for safer coding.
+
+---
+
+For further documentation on **LioranDB Core**, refer to its repository: [LioranDB Core](https://www.npmjs.com/package/@liorandb/core)

package/dist/app.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const auth_routes_1 = __importDefault(require("./routes/auth.routes"));
+const database_routes_1 = __importDefault(require("./routes/database.routes"));
+const collection_routes_1 = __importDefault(require("./routes/collection.routes"));
+const document_routes_1 = __importDefault(require("./routes/document.routes"));
+const requestLogger_middleware_1 = require("./middleware/requestLogger.middleware");
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+app.use((0, cors_1.default)());
+app.use(requestLogger_middleware_1.requestLogger);
+// health check
+app.get("/health", (req, res) => res.json({ ok: true, time: new Date().toISOString() }));
+app.get("/", (_, res) => {
+    res.json({
+        name: "LioranDB",
+        role: "Database Host",
+        status: "online"
+    });
+});
+// routes
+app.use("/auth", auth_routes_1.default);
+app.use("/databases", database_routes_1.default);
+app.use("/db/:db/collections", collection_routes_1.default);
+app.use("/db/:db/collections/:col", document_routes_1.default);
+exports.default = app;

package/dist/config/database.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manager = void 0;
+exports.getAuthCollection = getAuthCollection;
+// src/config/database.ts
+const core_1 = require("@liorandb/core");
+exports.manager = new core_1.LioranManager();
+async function getAuthCollection() {
+    const db = await exports.manager.db("_auth");
+    await db.createCollection("users").catch(() => { });
+    // explicitly type this collection as AuthUser so TS knows the fields
+    return db.collection("users");
+}

package/dist/controllers/auth.controller.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = exports.register = void 0;
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const database_1 = require("../config/database");
+const token_1 = require("../utils/token");
+const register = async (req, res) => {
+    try {
+        const { username, password } = req.body;
+        if (!username || !password)
+            return res.status(400).json({ error: "username and password required" });
+        if (typeof username !== "string" || typeof password !== "string")
+            return res.status(400).json({ error: "invalid types" });
+        if (password.length < 6)
+            return res.status(400).json({ error: "password must be at least 6 characters" });
+        const users = await (0, database_1.getAuthCollection)(); // typed as AuthUser collection
+        const existing = await users.findOne({ username });
+        if (existing)
+            return res.status(409).json({ error: "username already exists" });
+        const hashed = await bcryptjs_1.default.hash(password, 10);
+        const created = await users.insertOne({
+            username,
+            password: hashed,
+            createdAt: new Date().toISOString(),
+        });
+        const token = (0, token_1.signToken)({ id: created._id, username });
+        res.json({ user: { id: created._id, username }, token });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.register = register;
+const login = async (req, res) => {
+    try {
+        const { username, password } = req.body;
+        if (!username || !password)
+            return res.status(400).json({ error: "username and password required" });
+        const users = await (0, database_1.getAuthCollection)();
+        const user = await users.findOne({ username });
+        if (!user)
+            return res.status(401).json({ error: "invalid credentials" });
+        // user is typed as AuthUser so .password exists
+        const ok = await bcryptjs_1.default.compare(password, user.password);
+        if (!ok)
+            return res.status(401).json({ error: "invalid credentials" });
+        const token = (0, token_1.signToken)({ id: user._id, username });
+        res.json({ user: { id: user._id, username }, token });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.login = login;

package/dist/controllers/collection.controller.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectionStats = exports.renameCollection = exports.deleteCollection = exports.createCollection = exports.listCollections = void 0;
+const database_1 = require("../config/database");
+const listCollections = async (req, res) => {
+    try {
+        const database = await database_1.manager.db(req.params.db);
+        const collections = await database.listCollections();
+        res.json({ collections });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.listCollections = listCollections;
+const createCollection = async (req, res) => {
+    try {
+        const database = await database_1.manager.db(req.params.db);
+        await database.createCollection(req.body.name);
+        res.json({ ok: true });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.createCollection = createCollection;
+const deleteCollection = async (req, res) => {
+    try {
+        const database = await database_1.manager.db(req.params.db);
+        await database.deleteCollection(req.params.col);
+        res.json({ ok: true });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.deleteCollection = deleteCollection;
+const renameCollection = async (req, res) => {
+    try {
+        const { db, col } = req.params;
+        const { newName } = req.body;
+        const database = await database_1.manager.db(db);
+        await database.renameCollection(col, newName);
+        res.json({ ok: true, old: col, new: newName });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.renameCollection = renameCollection;
+const collectionStats = async (req, res) => {
+    try {
+        const { db, col } = req.params;
+        const database = await database_1.manager.db(db);
+        const collection = database.collection(col);
+        const count = await collection.countDocuments();
+        res.json({
+            name: col,
+            documents: count,
+        });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.collectionStats = collectionStats;

package/dist/controllers/database.controller.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseStats = exports.renameDatabase = exports.deleteDatabase = exports.createDatabase = exports.listDatabases = void 0;
+const database_1 = require("../config/database");
+const listDatabases = async (_, res) => {
+    try {
+        const list = await database_1.manager.listDatabases();
+        res.json({ databases: list });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.listDatabases = listDatabases;
+const createDatabase = async (req, res) => {
+    try {
+        const { name } = req.body;
+        if (!name)
+            return res.status(400).json({ error: "database name required" });
+        await database_1.manager.createDatabase(name);
+        res.json({ ok: true, db: name });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.createDatabase = createDatabase;
+const deleteDatabase = async (req, res) => {
+    try {
+        const { db } = req.params;
+        const ok = await database_1.manager.deleteDatabase(db);
+        res.json({ ok: !!ok });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.deleteDatabase = deleteDatabase;
+const renameDatabase = async (req, res) => {
+    try {
+        const { db } = req.params;
+        const { newName } = req.body;
+        if (!newName)
+            return res.status(400).json({ error: "newName required" });
+        await database_1.manager.renameDatabase(db, newName);
+        res.json({ ok: true, old: db, new: newName });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.renameDatabase = renameDatabase;
+const databaseStats = async (req, res) => {
+    try {
+        const { db } = req.params;
+        const database = await database_1.manager.db(db);
+        const cols = await database.listCollections();
+        let totalDocs = 0;
+        for (const colName of cols) {
+            const col = database.collection(colName);
+            totalDocs += await col.countDocuments();
+        }
+        res.json({
+            name: db,
+            collections: cols.length,
+            documents: totalDocs,
+        });
+    }
+    catch {
+        res.status(500).json({ error: "server error" });
+    }
+};
+exports.databaseStats = databaseStats;

package/dist/controllers/document.controller.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countDocuments = exports.deleteMany = exports.updateMany = exports.findDocuments = exports.insertMany = exports.insertDocument = void 0;
+const database_1 = require("../config/database");
+const insertDocument = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const doc = await collection.insertOne(req.body);
+    res.json({ ok: true, doc });
+};
+exports.insertDocument = insertDocument;
+const insertMany = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const docs = await collection.insertMany(req.body.docs || []);
+    res.json({ ok: true, docs });
+};
+exports.insertMany = insertMany;
+const findDocuments = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const results = await collection.find(req.body.query || {});
+    res.json({ results });
+};
+exports.findDocuments = findDocuments;
+const updateMany = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const docs = await collection.updateMany(req.body.filter, req.body.update);
+    res.json({ updated: docs });
+};
+exports.updateMany = updateMany;
+const deleteMany = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const count = await collection.deleteMany(req.body.filter || {});
+    res.json({ deleted: count });
+};
+exports.deleteMany = deleteMany;
+const countDocuments = async (req, res) => {
+    const collection = (await database_1.manager.db(req.params.db))
+        .collection(req.params.col);
+    const count = await collection.countDocuments(req.body.filter || {});
+    res.json({ count });
+};
+exports.countDocuments = countDocuments;

package/dist/middleware/auth.middleware.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authMiddleware = authMiddleware;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const token_1 = require("../utils/token");
+function authMiddleware(req, res, next) {
+    const auth = req.headers.authorization;
+    if (!auth || !auth.startsWith("Bearer ")) {
+        return res.status(401).json({ error: "Missing token" });
+    }
+    try {
+        const token = auth.split(" ")[1];
+        const decoded = jsonwebtoken_1.default.verify(token, token_1.JWT_SECRET);
+        req.user = decoded;
+        next();
+    }
+    catch {
+        return res.status(401).json({ error: "Invalid token" });
+    }
+}

package/dist/middleware/requestLogger.middleware.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogger = requestLogger;
+const hostLogger_1 = require("../utils/hostLogger");
+function formatResponse(body) {
+    if (!body)
+        return "null";
+    // If already an object
+    if (typeof body === "object") {
+        return JSON.stringify(body, null, 2);
+    }
+    // If string, try parsing JSON
+    if (typeof body === "string") {
+        try {
+            const parsed = JSON.parse(body);
+            return JSON.stringify(parsed, null, 2);
+        }
+        catch {
+            return body; // normal string (HTML, text, etc.)
+        }
+    }
+    return String(body);
+}
+function requestLogger(req, res, next) {
+    const start = Date.now();
+    const oldSend = res.send.bind(res);
+    let responseBody;
+    res.send = (body) => {
+        responseBody = body;
+        return oldSend(body);
+    };
+    res.on("finish", () => {
+        const duration = Date.now() - start;
+        const logData = `
+──────────────────────────────────────
+INCOMING REQUEST
+Method      : ${req.method}
+URL         : ${req.originalUrl}
+IP          : ${req.ip}
+Auth        : ${req.headers.authorization ? "Yes" : "No"}
+RequestBody :
+${JSON.stringify(req.body || {}, null, 2)}
+
+RESPONSE
+Status      : ${res.statusCode}
+Duration    : ${duration}ms
+Response    :
+${formatResponse(responseBody)}
+──────────────────────────────────────
+`;
+        (0, hostLogger_1.hostLog)(logData.trim());
+    });
+    next();
+}

package/dist/routes/auth.routes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const auth_controller_1 = require("../controllers/auth.controller");
+const router = (0, express_1.Router)();
+router.post("/register", auth_controller_1.register);
+router.post("/login", auth_controller_1.login);
+exports.default = router;

package/dist/routes/collection.routes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const collection_controller_1 = require("../controllers/collection.controller");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const router = (0, express_1.Router)({ mergeParams: true });
+router.get("/", auth_middleware_1.authMiddleware, collection_controller_1.listCollections);
+router.post("/", auth_middleware_1.authMiddleware, collection_controller_1.createCollection);
+router.delete("/:col", auth_middleware_1.authMiddleware, collection_controller_1.deleteCollection);
+router.patch("/:col/rename", auth_middleware_1.authMiddleware, collection_controller_1.renameCollection);
+router.get("/:col/stats", auth_middleware_1.authMiddleware, collection_controller_1.collectionStats);
+exports.default = router;

package/dist/routes/database.routes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const database_controller_1 = require("../controllers/database.controller");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const router = (0, express_1.Router)();
+router.get("/", auth_middleware_1.authMiddleware, database_controller_1.listDatabases);
+router.post("/", auth_middleware_1.authMiddleware, database_controller_1.createDatabase);
+router.delete("/:db", auth_middleware_1.authMiddleware, database_controller_1.deleteDatabase);
+router.patch("/:db/rename", auth_middleware_1.authMiddleware, database_controller_1.renameDatabase);
+router.get("/:db/stats", auth_middleware_1.authMiddleware, database_controller_1.databaseStats);
+exports.default = router;

package/dist/routes/document.routes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const document_controller_1 = require("../controllers/document.controller");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const router = (0, express_1.Router)({ mergeParams: true });
+router.post("/", auth_middleware_1.authMiddleware, document_controller_1.insertDocument);
+router.post("/bulk", auth_middleware_1.authMiddleware, document_controller_1.insertMany);
+router.post("/find", auth_middleware_1.authMiddleware, document_controller_1.findDocuments);
+router.patch("/updateMany", auth_middleware_1.authMiddleware, document_controller_1.updateMany);
+router.post("/deleteMany", auth_middleware_1.authMiddleware, document_controller_1.deleteMany);
+router.post("/count", auth_middleware_1.authMiddleware, document_controller_1.countDocuments);
+exports.default = router;

package/dist/server.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/server.ts
+const app_1 = __importDefault(require("./app"));
+const PORT = 4000;
+app_1.default.listen(PORT, "0.0.0.0", () => {
+    console.log("======================================");
+    console.log("🚀 LioranDB Host is LIVE");
+    console.log(`📡 Listening on port: ${PORT}`);
+    // print all running host IPs
+    console.log(`🌐 Host Address: localhost:4000`);
+    const os = require("os");
+    const networkInterfaces = os.networkInterfaces();
+    for (const interfaceName in networkInterfaces) {
+        const interfaceInfo = networkInterfaces[interfaceName];
+        for (const addressInfo of interfaceInfo) {
+            if (addressInfo.family === "IPv4" && !addressInfo.internal) {
+                console.log(`🌐 Host Address: ${addressInfo.address}:4000`);
+            }
+        }
+    }
+    // console.log(`🧠 Mode: ${process.env.NODE_ENV || "development"}`);
+    console.log("======================================");
+});

package/dist/types/auth-user.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/hostLogger.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostLog = hostLog;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LOG_DIR = path_1.default.join(process.cwd(), "logs");
+if (!fs_1.default.existsSync(LOG_DIR)) {
+    fs_1.default.mkdirSync(LOG_DIR, { recursive: true });
+}
+function getLogFilePath() {
+    const now = new Date();
+    const date = now.toISOString().split("T")[0]; // YYYY-MM-DD
+    const hour = String(now.getHours()).padStart(2, "0"); // HH
+    return path_1.default.join(LOG_DIR, `${date}_${hour}.log`);
+}
+function hostLog(message) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+    // Write to file
+    fs_1.default.appendFileSync(getLogFilePath(), logLine, "utf8");
+    // Print to console
+    console.log(logLine.trim());
+}

package/dist/utils/token.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWT_EXPIRES_IN = exports.JWT_SECRET = void 0;
+exports.signToken = signToken;
+exports.verifyToken = verifyToken;
+// src/utils/token.ts
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Derive a stable, machine-bound secret
+ */
+function getHardwareSecret() {
+    const fingerprint = [
+        os_1.default.hostname(),
+        os_1.default.platform(),
+        os_1.default.arch(),
+        os_1.default.cpus()?.[0]?.model || "unknown-cpu",
+        os_1.default.cpus()?.length.toString() || "0",
+        os_1.default.totalmem().toString()
+    ].join("|");
+    return crypto_1.default
+        .createHash("sha256")
+        .update(fingerprint)
+        .digest("hex"); // JWT expects string | Buffer
+}
+exports.JWT_SECRET = getHardwareSecret();
+// Safe default, still configurable if needed
+exports.JWT_EXPIRES_IN = "7d";
+function signToken(payload) {
+    return jsonwebtoken_1.default.sign(payload, exports.JWT_SECRET, {
+        expiresIn: exports.JWT_EXPIRES_IN,
+    });
+}
+function verifyToken(token) {
+    return jsonwebtoken_1.default.verify(token, exports.JWT_SECRET);
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@liorandb/db",
+  "version": "1.0.0",
+  "description": "LioranDB server and CLI",
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "bin": {
+    "dbi": "dist/cli.js",
+    "serve": "dist/server.js"
+  },
+  "scripts": {
+    "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "cli": "ts-node cli/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "database",
+    "liorandb",
+    "server",
+    "cli"
+  ],
+  "author": "Your Name",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/commander": "^2.12.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.0.1",
+    "commander": "^14.0.2",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@liorandb/core": "^1.0.9",
+    "bcryptjs": "^3.0.3",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3"
+  }
+}