ruggy 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-01-12
+
+### Added
+- Advanced search with query operators (`LIKE`, `starts_with`, `ends_with`, `contains`)
+- `RuggyCollection.findWithOperator()` method for advanced queries
+- `RuggyCollection.updateField(id, field, value)` method for editing specific document fields
+- `RuggyCollection.delete(id)` method for removing documents by ID
+- Updated TypeScript definitions for all new methods
+
+### Changed
+- **Refactored Rust backend architecture** (`db`, `collection`, `ffi` modules) for better maintainability.
+- Improved `persist()` logic to handle file truncation reliably on Windows.
+- Switched FFI return types to `i32` for better cross-platform consistency.
+
+### Fixed
+- Fixed "Access Denied" errors when updating/deleting files on Windows.
+- Fixed inconsistent boolean return values across the FFI boundary.
+
+### Platform Support
+- Windows x64 - Pre-built binaries included
+- Linux - Not supported at this time
+- macOS - Not supported at this time
+
+### Known Limitations
+- Single-platform binary distribution (Windows only)
+- No indexes (linear scan)
+- No transactions
+- No schema validation
+
+---
+
 ## [0.1.0] - 2026-01-04
 
 ### Added
@@ -15,51 +46,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Configuration loader with automatic file discovery
 - `Database.fromConfig()` and `Pool.fromConfig()` factory methods
 - Full TypeScript type definitions
-- Comprehensive README with examples
 - Support for Node.js 14+
 - Windows x64 pre-built binaries
 
 ### Features
 - Native Rust backend with FFI bindings
 - Embedded database (no external server required)
-- Simple and intuitive API
 - Persistent storage with append-only files
 - Flexible YAML configuration
-- TypeScript support with complete definitions
-
-### Platform Support
-- Windows x64 - Pre-built binaries included
-- Linux - Not supported at this time
-- macOS - Not supported at this time
-
-### Known Limitations
-- Single-platform binary distribution (Windows only)
-- No query operators (only exact match)
-- No indexes (linear scan)
-- No transactions
-- No schema validation
-
-### Dependencies
-- koffi ^2.8.0 - FFI bindings
-- js-yaml ^4.1.0 - YAML configuration parsing
 
 ---
 
 ## [Unreleased]
 
-### Planned for 0.2.0
+### Planned
 - Linux and macOS pre-built binaries
 - Configurable limits (maxCollectionSize, maxDocumentSize)
 - Logging configuration
 - Performance tuning options
 
 ### Future Enhancements
-- Backup automation
+- Basic indexing (B-Tree/Hash)
+- Write-Ahead Logging (WAL) for faster updates
+- $AND / $OR logical operators
 - Compression support
-- Query operators (range, comparison)
-- Basic indexing
 - Encryption at rest
 
 ---
 
+[0.2.0]: https://github.com/Mub1522/ruggy/releases/tag/v0.2.0
 [0.1.0]: https://github.com/Mub1522/ruggy/releases/tag/v0.1.0

package/README.md

@@ -161,6 +161,35 @@ Finds documents where field matches value.
 const adults = collection.find('age', '30');
 ```
 
+**`findWithOperator(field: string, value: any, operator: string): Array<Object>`**
+
+Finds documents using advanced operators.
+
+- **`=`**, **`==`**, **`eq`**: Exact match.
+- **`like`**, **`LIKE`**, **`contains`**: Partial match (case-sensitive).
+- **`starts_with`**: Matches the beginning of the string.
+- **`ends_with`**: Matches the end of the string.
+
+```javascript
+const results = collection.findWithOperator('name', 'App', 'like');
+```
+
+**`updateField(id: string, field: string, value: any): boolean`**
+
+Edits a specific field of a document identified by its `_id`.
+
+```javascript
+const success = collection.updateField('some-uuid-here', 'role', 'superadmin');
+```
+
+**`delete(id: string): boolean`**
+
+Deletes a document identified by its `_id`.
+
+```javascript
+const deleted = collection.delete('some-uuid-here');
+```
+
 **`close(): void`**
 
 Closes the collection and releases resources.
@@ -258,6 +287,25 @@ const electronics = products.find('category', 'electronics');
 db.close();
 ```
 
+### Advanced Searching
+
+```javascript
+const { RuggyDatabase } = require('ruggy');
+const db = new RuggyDatabase('./data');
+const products = db.collection('products');
+
+// Partial search (LIKE)
+const electronics = products.findWithOperator('category', 'elect', 'like');
+
+// Prefix search
+const startsWithA = products.findWithOperator('name', 'A', 'starts_with');
+
+// Suffix search
+const endsWithS = products.findWithOperator('name', 's', 'ends_with');
+
+db.close();
+```
+
 ### Using Connection Pool
 
 ```javascript

package/index.d.ts

@@ -70,13 +70,32 @@ export class RuggyCollection {
      */
     findAll(): Array<Record<string, any>>;
 
+    find(field: string, value: any): Array<Record<string, any>>;
+
     /**
-     * Finds documents matching a field-value pair
+     * Finds documents using advanced operators
      * @param field - Field name to search
      * @param value - Value to match
+     * @param operator - Operator to use (=, ==, eq, like, LIKE, contains, starts_with, ends_with)
      * @returns Array of matching documents
      */
-    find(field: string, value: any): Array<Record<string, any>>;
+    findWithOperator(field: string, value: any, operator: string): Array<Record<string, any>>;
+
+    /**
+     * Updates a specific field of a document found by its _id
+     * @param id - The _id of the document to update
+     * @param field - The field name to update
+     * @param value - The new value for the field
+     * @returns True if updated, false if not found or error
+     */
+    updateField(id: string, field: string, value: any): boolean;
+
+    /**
+     * Deletes a document by its _id
+     * @param id - The _id of the document to delete
+     * @returns True if deleted, false if not found or error
+     */
+    delete(id: string): boolean;
 
     /**
      * Closes the collection and frees native resources

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ruggy",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "A simple, fast embedded database for Node.js backed by Rust",
     "main": "src/index.js",
     "types": "index.d.ts",

package/src/Collection.js

@@ -2,6 +2,9 @@ const {
     ruggy_insert,
     ruggy_find_all,
     ruggy_find,
+    ruggy_find_op,
+    ruggy_update_field,
+    ruggy_delete,
     ruggy_col_free,
     ruggy_str_free
 } = require('./bindings');
@@ -136,6 +139,91 @@ class RuggyCollection {
         }
     }
 
+    /**
+     * Finds documents using a specific operator
+     * @param {string} field - Field name to search
+     * @param {*} value - Value to match (converted to string)
+     * @param {string} operator - Operator to use (e.g., '=', 'like', 'starts_with', 'ends_with')
+     * @returns {Array<Object>} - Array of matching documents
+     * @throws {Error} If collection is closed
+     */
+    findWithOperator(field, value, operator) {
+        this.#ensureOpen();
+
+        if (typeof field !== 'string' || !field) {
+            throw new Error('Field must be a non-empty string');
+        }
+
+        if (typeof operator !== 'string' || !operator) {
+            throw new Error('Operator must be a non-empty string');
+        }
+
+        const fieldBuf = toCString(field);
+        const valueBuf = toCString(String(value));
+        const opBuf = toCString(operator);
+
+        const resPtr = ruggy_find_op(this.#colPtr, fieldBuf, valueBuf, opBuf);
+        if (!isValidPointer(resPtr)) {
+            return [];
+        }
+
+        const json = readCString(resPtr);
+        ruggy_str_free(resPtr);
+
+        try {
+            return JSON.parse(json);
+        } catch (error) {
+            console.error('Failed to parse JSON from Rust:', error);
+            return [];
+        }
+    }
+
+    /**
+     * Updates a specific field of a document found by its _id
+     * @param {string} id - The _id of the document to update
+     * @param {string} field - The field name to update
+     * @param {*} value - The new value for the field (will be JSON stringified)
+     * @returns {boolean} - True if updated, false if not found or error
+     * @throws {Error} If collection is closed or parameters are invalid
+     */
+    updateField(id, field, value) {
+        this.#ensureOpen();
+
+        if (typeof id !== 'string' || !id) {
+            throw new Error('ID must be a non-empty string');
+        }
+
+        if (typeof field !== 'string' || !field) {
+            throw new Error('Field must be a non-empty string');
+        }
+
+        const idBuf = toCString(id);
+        const fieldBuf = toCString(field);
+        const valueJson = JSON.stringify(value);
+        const valBuf = toCString(valueJson);
+
+        const result = ruggy_update_field(this.#colPtr, idBuf, fieldBuf, valBuf);
+        return result === 1;
+    }
+
+    /**
+     * Deletes a document by its _id
+     * @param {string} id - The _id of the document to delete
+     * @returns {boolean} - True if deleted, false if not found or error
+     * @throws {Error} If collection is closed or ID is invalid
+     */
+    delete(id) {
+        this.#ensureOpen();
+
+        if (typeof id !== 'string' || !id) {
+            throw new Error('ID must be a non-empty string');
+        }
+
+        const idBuf = toCString(id);
+        const result = ruggy_delete(this.#colPtr, idBuf);
+        return result === 1;
+    }
+
     /**
      * Closes the collection and frees native resources
      * Safe to call multiple times

package/src/bindings.js

@@ -17,6 +17,9 @@ const ruggy_col_free = lib.func('ruggy_col_free', 'void', ['void *']);
 const ruggy_insert = lib.func('ruggy_insert', 'void *', ['void *', 'string']);
 const ruggy_find_all = lib.func('ruggy_find_all', 'void *', ['void *']);
 const ruggy_find = lib.func('ruggy_find', 'void *', ['void *', 'string', 'string']);
+const ruggy_find_op = lib.func('ruggy_find_op', 'void *', ['void *', 'string', 'string', 'string']);
+const ruggy_update_field = lib.func('ruggy_update_field', 'int', ['void *', 'string', 'string', 'string']);
+const ruggy_delete = lib.func('ruggy_delete', 'int', ['void *', 'string']);
 
 // Memory management
 const ruggy_str_free = lib.func('ruggy_str_free', 'void', ['void *']);
@@ -30,5 +33,8 @@ module.exports = {
     ruggy_insert,
     ruggy_find_all,
     ruggy_find,
+    ruggy_find_op,
+    ruggy_update_field,
+    ruggy_delete,
     ruggy_str_free
 };