jsql-neo 1.0.0

package/index.js

@@ -0,0 +1,25 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * JSQL — Pure JavaScript Embedded Database
+ *
+ * @example
+ * const jsql = require('jsql-neo');
+ * const db = new jsql.Database('mydb.json');
+ *
+ * db.createTable('users', {
+ *   id: { type: 'integer', primaryKey: true, autoIncrement: true },
+ *   name: { type: 'string', required: true },
+ *   age: { type: 'integer' }
+ * });
+ *
+ * db.users.insert({ name: 'Alice', age: 25 });
+ * db.users.insert({ name: 'Bob', age: 30 });
+ *
+ * const adults = db.users.find({ age: { $gte: 18 } });
+ * const sorted = db.users.where({ age: { $gte: 18 } }).orderBy('age', 'desc').limit(10).get();
+ */
+
+module.exports = {
+    Database: require('./lib/database'),
+    Table: require('./lib/table')
+};

package/lib/database.js

@@ -0,0 +1,212 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * JSQL Database — 数据库管理器
+ * 管理表集合、文件持久化、自动保存
+ */
+
+const fs = require('fs');
+const path = require('path');
+const Table = require('./table');
+
+class Database {
+    /**
+     * @param {string} filePath - 数据库文件路径，传 null 或 ':memory:' 使用内存模式
+     * @param {object} options
+     * @param {boolean} options.autoSave - 是否自动保存（默认 true）
+     * @param {number} options.autoSaveInterval - 自动保存间隔 ms（默认 0，即每次操作后保存）
+     * @param {boolean} options.pretty - JSON 是否格式化（默认 true）
+     */
+    constructor(filePath, options = {}) {
+        this._filePath = filePath;
+        this._memoryMode = !filePath || filePath === ':memory:';
+        this._options = {
+            autoSave: options.autoSave !== false,
+            autoSaveInterval: options.autoSaveInterval || 0,
+            pretty: options.pretty !== false
+        };
+        this._tables = {};       // 表名 -> Table 实例
+        this._dirty = false;
+        this._autoSaveTimer = null;
+        this._loading = false;     // 加载中，不触发自动保存
+
+        // 从文件加载
+        if (!this._memoryMode && fs.existsSync(this._filePath)) {
+            this._loading = true;
+            this._load();
+            this._loading = false;
+        }
+    }
+
+    // ============================================================
+    // 表管理
+    // ============================================================
+
+    /**
+     * 创建表
+     * @param {string} name - 表名
+     * @param {object} schema - 表结构定义
+     * @example
+     * db.createTable('users', {
+     *   id: { type: 'integer', primaryKey: true, autoIncrement: true },
+     *   name: { type: 'string', required: true },
+     *   email: { type: 'string', unique: true }
+     * })
+     */
+    createTable(name, schema) {
+        if (this._tables[name]) {
+            throw new Error(`Table '${name}' already exists`);
+        }
+        const table = new Table(name, schema, this);
+        this._tables[name] = table;
+
+        // 动态代理到 Database 实例上，方便 db.users.insert() 调用
+        Object.defineProperty(this, name, {
+            get: () => this._tables[name],
+            enumerable: true,
+            configurable: true
+        });
+
+        this._markDirty();
+        return table;
+    }
+
+    /**
+     * 删除表
+     */
+    dropTable(name) {
+        if (!this._tables[name]) {
+            throw new Error(`Table '${name}' does not exist`);
+        }
+        delete this._tables[name];
+        delete this[name];
+        this._markDirty();
+    }
+
+    /**
+     * 判断表是否存在
+     */
+    hasTable(name) {
+        return !!this._tables[name];
+    }
+
+    /**
+     * 获取所有表名
+     */
+    getTables() {
+        return Object.keys(this._tables);
+    }
+
+    // ============================================================
+    // 持久化
+    // ============================================================
+
+    /**
+     * 手动保存到文件
+     */
+    save() {
+        if (this._memoryMode) return;
+
+        const data = { __schema__: {} };
+        for (const [name, table] of Object.entries(this._tables)) {
+            data.__schema__[name] = table._schema;
+            data[name] = table.toJSON();
+        }
+
+        const dir = path.dirname(this._filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        const json = this._options.pretty
+            ? JSON.stringify(data, null, 2)
+            : JSON.stringify(data);
+        fs.writeFileSync(this._filePath, json, 'utf8');
+        this._dirty = false;
+    }
+
+    /**
+     * 从文件加载
+     */
+    _load() {
+        try {
+            const json = fs.readFileSync(this._filePath, 'utf8');
+            const data = JSON.parse(json);
+
+            // 先根据 schema 重建表
+            if (data.__schema__) {
+                for (const [name, schema] of Object.entries(data.__schema__)) {
+                    if (!this._tables[name]) {
+                        this.createTable(name, schema);
+                    }
+                }
+            }
+
+            // 加载数据
+            for (const [name, rows] of Object.entries(data)) {
+                if (name !== '__schema__' && this._tables[name]) {
+                    this._tables[name]._loadRows(rows);
+                }
+            }
+        } catch (e) {
+            throw new Error(`Failed to load database from '${this._filePath}': ${e.message}`);
+        }
+    }
+
+    /**
+     * 标记脏数据（触发自动保存）
+     */
+    _markDirty() {
+        this._dirty = true;
+        if (this._loading) return;  // 加载中不保存
+        if (this._options.autoSave && !this._autoSaveTimer) {
+            if (this._options.autoSaveInterval > 0) {
+                this._autoSaveTimer = setTimeout(() => {
+                    this._autoSaveTimer = null;
+                    if (this._dirty) this.save();
+                }, this._options.autoSaveInterval);
+            } else {
+                // 立即保存（同步）
+                this.save();
+            }
+        }
+    }
+
+    /**
+     * 关闭数据库（保存并清理）
+     */
+    close() {
+        if (this._autoSaveTimer) {
+            clearTimeout(this._autoSaveTimer);
+            this._autoSaveTimer = null;
+        }
+        if (this._dirty && !this._memoryMode) {
+            this.save();
+        }
+        this._tables = {};
+    }
+
+    /**
+     * 导出数据库为 JSON 对象
+     */
+    export() {
+        const data = {};
+        for (const [name, table] of Object.entries(this._tables)) {
+            data[name] = table.toJSON();
+        }
+        return data;
+    }
+
+    /**
+     * 从 JSON 对象导入数据
+     */
+    import(data) {
+        for (const [name, rows] of Object.entries(data)) {
+            if (this._tables[name]) {
+                this._tables[name]._loadRows(rows);
+            }
+        }
+        this._markDirty();
+    }
+}
+
+module.exports = Database;

package/lib/table.js

@@ -0,0 +1,468 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * JSQL Table — 表操作引擎
+ * 每张表是一个独立的数据集合，支持 CRUD、查询、索引
+ */
+
+class Table {
+    constructor(name, schema, db) {
+        this._name = name;
+        this._schema = schema;
+        this._db = db;
+        this._rows = [];          // 数据行
+        this._indexes = {};       // 字段名 -> Map<value, [rowIndex, ...]>
+        this._autoIncrement = 0;  // 自增计数器
+        this._dirty = false;      // 是否有未保存的修改
+
+        // 解析主键和自增字段
+        this._primaryKey = null;
+        this._autoIncrementField = null;
+        for (const [field, def] of Object.entries(schema)) {
+            if (def.primaryKey) this._primaryKey = field;
+            if (def.autoIncrement) {
+                this._autoIncrementField = field;
+                if (def.primaryKey) this._primaryKey = field;
+            }
+        }
+    }
+
+    // ============================================================
+    // 插入
+    // ============================================================
+
+    insert(data) {
+        // 校验必填字段
+        for (const [field, def] of Object.entries(this._schema)) {
+            if (def.required && (data[field] === undefined || data[field] === null)) {
+                throw new Error(`Field '${field}' is required in table '${this._name}'`);
+            }
+        }
+
+        // 唯一约束检查
+        for (const [field, def] of Object.entries(this._schema)) {
+            if (def.unique && data[field] !== undefined) {
+                for (const row of this._rows) {
+                    if (row[field] === data[field]) {
+                        throw new Error(`Duplicate value for unique field '${field}': ${data[field]}`);
+                    }
+                }
+            }
+        }
+
+        // 自增
+        if (this._autoIncrementField) {
+            if (data[this._autoIncrementField] === undefined) {
+                this._autoIncrement++;
+                data[this._autoIncrementField] = this._autoIncrement;
+            } else if (data[this._autoIncrementField] > this._autoIncrement) {
+                this._autoIncrement = data[this._autoIncrementField];
+            }
+        }
+
+        const rowIndex = this._rows.length;
+        this._rows.push({ ...data });
+
+        // 更新索引
+        this._updateIndexes(rowIndex, data);
+
+        this._dirty = true;
+        this._db._markDirty();
+        return data;
+    }
+
+    insertMany(items) {
+        return items.map(item => this.insert(item));
+    }
+
+    // ============================================================
+    // 查询
+    // ============================================================
+
+    /**
+     * 查找所有匹配的行
+     */
+    find(query = {}) {
+        let rows = this._rows;
+
+        if (Object.keys(query).length > 0) {
+            rows = this._applyFilter(rows, query);
+        }
+
+        return rows.map(r => ({ ...r }));
+    }
+
+    /**
+     * 查找第一条匹配的行
+     */
+    findOne(query = {}) {
+        const rows = this.find(query);
+        return rows.length > 0 ? rows[0] : null;
+    }
+
+    /**
+     * 按主键查找
+     */
+    findById(id) {
+        if (!this._primaryKey) {
+            throw new Error(`Table '${this._name}' has no primary key`);
+        }
+        return this.findOne({ [this._primaryKey]: id });
+    }
+
+    /**
+     * 获取所有行
+     */
+    findAll() {
+        return this._rows.map(r => ({ ...r }));
+    }
+
+    /**
+     * 计数
+     */
+    count(query = {}) {
+        if (Object.keys(query).length === 0) {
+            return this._rows.length;
+        }
+        return this._applyFilter(this._rows, query).length;
+    }
+
+    // ============================================================
+    // 链式查询
+    // ============================================================
+
+    where(conditions) {
+        return new Query(this, conditions);
+    }
+
+    // ============================================================
+    // 更新
+    // ============================================================
+
+    update(query, updates) {
+        const matched = this._applyFilter(this._rows, query);
+        let count = 0;
+
+        for (const row of matched) {
+            const index = this._rows.indexOf(row);
+            if (index === -1) continue;
+
+            const oldData = { ...this._rows[index] };
+
+            // 唯一约束检查
+            for (const [field, def] of Object.entries(this._schema)) {
+                if (def.unique && updates[field] !== undefined) {
+                    for (let i = 0; i < this._rows.length; i++) {
+                        if (i !== index && this._rows[i][field] === updates[field]) {
+                            throw new Error(`Duplicate value for unique field '${field}': ${updates[field]}`);
+                        }
+                    }
+                }
+            }
+
+            // 更新
+            Object.assign(this._rows[index], updates);
+
+            // 更新索引
+            this._removeFromIndexes(index, oldData);
+            this._updateIndexes(index, this._rows[index]);
+
+            count++;
+        }
+
+        if (count > 0) {
+            this._dirty = true;
+            this._db._markDirty();
+        }
+        return count;
+    }
+
+    updateById(id, updates) {
+        if (!this._primaryKey) {
+            throw new Error(`Table '${this._name}' has no primary key`);
+        }
+        return this.update({ [this._primaryKey]: id }, updates);
+    }
+
+    // ============================================================
+    // 删除
+    // ============================================================
+
+    remove(query = {}) {
+        if (Object.keys(query).length === 0) {
+            // 删除全部
+            const count = this._rows.length;
+            this._rows = [];
+            this._indexes = {};
+            this._autoIncrement = 0;
+            this._dirty = true;
+            this._db._markDirty();
+            return count;
+        }
+
+        const toRemove = this._applyFilter(this._rows, query);
+        for (const row of toRemove) {
+            const index = this._rows.indexOf(row);
+            if (index !== -1) {
+                this._removeFromIndexes(index, row);
+                this._rows.splice(index, 1);
+                // 调整后续索引
+                for (const idxName of Object.keys(this._indexes)) {
+                    const idx = this._indexes[idxName];
+                    for (const [key, positions] of idx) {
+                        const newPositions = positions
+                            .filter(p => p !== index)
+                            .map(p => p > index ? p - 1 : p);
+                        if (newPositions.length === 0) {
+                            idx.delete(key);
+                        } else {
+                            idx.set(key, newPositions);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (toRemove.length > 0) {
+            this._dirty = true;
+            this._db._markDirty();
+        }
+        return toRemove.length;
+    }
+
+    removeById(id) {
+        if (!this._primaryKey) {
+            throw new Error(`Table '${this._name}' has no primary key`);
+        }
+        return this.remove({ [this._primaryKey]: id });
+    }
+
+    // ============================================================
+    // 索引
+    // ============================================================
+
+    createIndex(field) {
+        this._indexes[field] = new Map();
+        for (let i = 0; i < this._rows.length; i++) {
+            const value = this._rows[i][field];
+            if (value !== undefined) {
+                if (!this._indexes[field].has(value)) {
+                    this._indexes[field].set(value, []);
+                }
+                this._indexes[field].get(value).push(i);
+            }
+        }
+        return this._indexes[field];
+    }
+
+    dropIndex(field) {
+        delete this._indexes[field];
+    }
+
+    // ============================================================
+    // 内部方法
+    // ============================================================
+
+    _applyFilter(rows, query) {
+        const result = [];
+        for (let i = 0; i < rows.length; i++) {
+            if (this._matchRow(rows[i], query)) {
+                result.push(rows[i]);
+            }
+        }
+        return result;
+    }
+
+    _matchRow(row, query) {
+        for (const [field, condition] of Object.entries(query)) {
+            const value = row[field];
+
+            // 操作符对象: { $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $like, $regex }
+            if (condition !== null && typeof condition === 'object' && !Array.isArray(condition)) {
+                for (const [op, target] of Object.entries(condition)) {
+                    if (!this._matchOperator(value, op, target)) {
+                        return false;
+                    }
+                }
+            } else {
+                // 简单等值匹配
+                if (value !== condition) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    _matchOperator(value, op, target) {
+        switch (op) {
+            case '$eq': return value === target;
+            case '$ne': return value !== target;
+            case '$gt': return value > target;
+            case '$gte': return value >= target;
+            case '$lt': return value < target;
+            case '$lte': return value <= target;
+            case '$in': return Array.isArray(target) && target.includes(value);
+            case '$nin': return Array.isArray(target) && !target.includes(value);
+            case '$like':
+                if (typeof value !== 'string' || typeof target !== 'string') return false;
+                const regex = new RegExp(target.replace(/%/g, '.*').replace(/_/g, '.'), 'i');
+                return regex.test(value);
+            case '$regex':
+                return new RegExp(target).test(String(value));
+            case '$exists':
+                return target ? value !== undefined : value === undefined;
+            case '$between':
+                return Array.isArray(target) && target.length === 2
+                    && value >= target[0] && value <= target[1];
+            case '$or':
+                return Array.isArray(target) && target.some(sub => this._matchRow({ [op]: value }, { [op]: sub }));
+            default:
+                return false;
+        }
+    }
+
+    _updateIndexes(rowIndex, data) {
+        for (const field of Object.keys(this._indexes)) {
+            const value = data[field];
+            if (value !== undefined) {
+                if (!this._indexes[field].has(value)) {
+                    this._indexes[field].set(value, []);
+                }
+                this._indexes[field].get(value).push(rowIndex);
+            }
+        }
+    }
+
+    _removeFromIndexes(rowIndex, data) {
+        for (const field of Object.keys(this._indexes)) {
+            const value = data[field];
+            if (value !== undefined && this._indexes[field].has(value)) {
+                const positions = this._indexes[field].get(value).filter(p => p !== rowIndex);
+                if (positions.length === 0) {
+                    this._indexes[field].delete(value);
+                } else {
+                    this._indexes[field].set(value, positions);
+                }
+            }
+        }
+    }
+
+    _loadRows(rows) {
+        this._rows = rows;
+        // 重建自增
+        if (this._autoIncrementField) {
+            for (const row of rows) {
+                const val = row[this._autoIncrementField];
+                if (typeof val === 'number' && val > this._autoIncrement) {
+                    this._autoIncrement = val;
+                }
+            }
+        }
+        // 重建所有索引
+        for (const field of Object.keys(this._indexes)) {
+            this.createIndex(field);
+        }
+    }
+
+    // ============================================================
+    // 导出
+    // ============================================================
+
+    toJSON() {
+        return this._rows;
+    }
+}
+
+// ============================================================
+// 链式查询构建器
+// ============================================================
+
+class Query {
+    constructor(table, conditions) {
+        this._table = table;
+        this._conditions = conditions;
+        this._orderBy = null;
+        this._orderDir = 'asc';
+        this._limitCount = null;
+        this._offsetCount = 0;
+        this._selectFields = null;
+    }
+
+    orderBy(field, dir = 'asc') {
+        this._orderBy = field;
+        this._orderDir = dir;
+        return this;
+    }
+
+    limit(n) {
+        this._limitCount = n;
+        return this;
+    }
+
+    offset(n) {
+        this._offsetCount = n;
+        return this;
+    }
+
+    select(fields) {
+        this._selectFields = Array.isArray(fields) ? fields : [fields];
+        return this;
+    }
+
+    get() {
+        let rows = this._table._applyFilter(this._table._rows, this._conditions);
+
+        // 排序
+        if (this._orderBy) {
+            rows = rows.sort((a, b) => {
+                const va = a[this._orderBy];
+                const vb = b[this._orderBy];
+                if (va < vb) return this._orderDir === 'asc' ? -1 : 1;
+                if (va > vb) return this._orderDir === 'asc' ? 1 : -1;
+                return 0;
+            });
+        }
+
+        // 分页
+        if (this._offsetCount > 0) {
+            rows = rows.slice(this._offsetCount);
+        }
+        if (this._limitCount !== null) {
+            rows = rows.slice(0, this._limitCount);
+        }
+
+        // 字段选择
+        rows = rows.map(r => ({ ...r }));
+        if (this._selectFields) {
+            rows = rows.map(r => {
+                const obj = {};
+                for (const f of this._selectFields) {
+                    obj[f] = r[f];
+                }
+                return obj;
+            });
+        }
+
+        return rows;
+    }
+
+    first() {
+        const rows = this.limit(1).get();
+        return rows.length > 0 ? rows[0] : null;
+    }
+
+    count() {
+        const rows = this._table._applyFilter(this._table._rows, this._conditions);
+        return rows.length;
+    }
+
+    update(updates) {
+        return this._table.update(this._conditions, updates);
+    }
+
+    remove() {
+        return this._table.remove(this._conditions);
+    }
+}
+
+module.exports = Table;

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "jsql-neo",
+    "version": "1.0.0",
+    "description": "JSQL — Pure JavaScript embedded database. SQL-like API, zero native dependencies, file-based or in-memory storage.",
+    "main": "index.js",
+    "files": [
+        "index.js",
+        "lib/",
+        "README.md",
+        "LICENSE"
+    ],
+    "keywords": [
+        "database",
+        "sql",
+        "embedded",
+        "json",
+        "javascript",
+        "jsql",
+        "nosql",
+        "sql-like",
+        "in-memory",
+        "file-based"
+    ],
+    "author": "Vexify",
+    "license": "Apache-2.0",
+    "engines": {
+        "node": ">=14.0.0"
+    }
+}