ruggy 0.1.0

package/src/bindings.js

@@ -0,0 +1,34 @@
+const koffi = require('koffi');
+const path = require('path');
+
+// Load DLL
+const dllPath = path.join(__dirname, '..', 'lib', 'ruggy.dll');
+const lib = koffi.load(dllPath);
+
+// Database operations
+const ruggy_open = lib.func('ruggy_open', 'void *', ['string']);
+const ruggy_db_free = lib.func('ruggy_db_free', 'void', ['void *']);
+
+// Collection operations
+const ruggy_get_collection = lib.func('ruggy_get_collection', 'void *', ['void *', 'string']);
+const ruggy_col_free = lib.func('ruggy_col_free', 'void', ['void *']);
+
+// Data operations
+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']);
+
+// Memory management
+const ruggy_str_free = lib.func('ruggy_str_free', 'void', ['void *']);
+
+module.exports = {
+    koffi,
+    ruggy_open,
+    ruggy_db_free,
+    ruggy_get_collection,
+    ruggy_col_free,
+    ruggy_insert,
+    ruggy_find_all,
+    ruggy_find,
+    ruggy_str_free
+};

package/src/config.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Cached configuration to avoid repeated file system lookups
+ * @type {Object|null}
+ */
+let cachedConfig = null;
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    dataPath: './data'
+};
+
+/**
+ * Searches for ruggy.yaml starting from current directory up to root
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} - Path to ruggy.yaml or null if not found
+ */
+function findConfigFile(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+
+    while (true) {
+        const configPath = path.join(currentDir, 'ruggy.yaml');
+
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+
+        // Check for .yml variant
+        const altConfigPath = path.join(currentDir, 'ruggy.yml');
+        if (fs.existsSync(altConfigPath)) {
+            return altConfigPath;
+        }
+
+        // Reached root without finding config
+        if (currentDir === root) {
+            return null;
+        }
+
+        // Move up one directory
+        currentDir = path.dirname(currentDir);
+    }
+}
+
+/**
+ * Loads and parses ruggy.yaml configuration file
+ * @param {string} configPath - Path to configuration file
+ * @returns {Object} - Parsed configuration
+ * @throws {Error} If file cannot be read or parsed
+ */
+function parseConfigFile(configPath) {
+    try {
+        const fileContents = fs.readFileSync(configPath, 'utf8');
+        const config = yaml.load(fileContents);
+
+        if (!config || typeof config !== 'object') {
+            throw new Error('Configuration must be a valid YAML object');
+        }
+
+        return config;
+    } catch (error) {
+        throw new Error(`Failed to parse configuration file at '${configPath}': ${error.message}`);
+    }
+}
+
+/**
+ * Loads Ruggy configuration from ruggy.yaml or returns defaults
+ * Configuration is cached after first load
+ * @param {Object} options - Options
+ * @param {boolean} options.reload - Force reload configuration (bypass cache)
+ * @param {string} options.searchFrom - Directory to start searching from (default: process.cwd())
+ * @returns {Object} - Configuration object
+ */
+function loadConfig(options = {}) {
+    const { reload = false, searchFrom = process.cwd() } = options;
+
+    // Return cached config if available and not forcing reload
+    if (cachedConfig && !reload) {
+        return cachedConfig;
+    }
+
+    const configPath = findConfigFile(searchFrom);
+
+    if (!configPath) {
+        // No config file found, use defaults
+        cachedConfig = { ...DEFAULT_CONFIG };
+        return cachedConfig;
+    }
+
+    const userConfig = parseConfigFile(configPath);
+
+    // Merge with defaults
+    cachedConfig = {
+        ...DEFAULT_CONFIG,
+        ...userConfig
+    };
+
+    // Resolve relative paths to absolute based on config file location
+    if (cachedConfig.dataPath && !path.isAbsolute(cachedConfig.dataPath)) {
+        const configDir = path.dirname(configPath);
+        cachedConfig.dataPath = path.resolve(configDir, cachedConfig.dataPath);
+    }
+
+    return cachedConfig;
+}
+
+/**
+ * Clears the cached configuration
+ * Useful for testing or when configuration changes at runtime
+ */
+function clearCache() {
+    cachedConfig = null;
+}
+
+module.exports = {
+    loadConfig,
+    clearCache,
+    DEFAULT_CONFIG
+};

package/src/index.js

@@ -0,0 +1,58 @@
+/**
+ * Ruggy - A simple, fast embedded database for Node.js
+ * 
+ * @module ruggy
+ * @example
+ * // Quick usage with auto-cleanup
+ * const { RuggyDatabase } = require('ruggy');
+ * 
+ * await RuggyDatabase.withDatabase('./data', async (db) => {
+ *   await db.withCollection('users', col => {
+ *     col.insert({ name: 'Alice', age: 30 });
+ *     console.log(col.findAll());
+ *   });
+ * });
+ * 
+ * @example
+ * // Manual connection management
+ * const { RuggyDatabase } = require('ruggy');
+ * 
+ * const db = new RuggyDatabase('./data');
+ * const users = db.collection('users');
+ * users.insert({ name: 'Bob' });
+ * users.close();
+ * db.close();
+ * 
+ * @example
+ * // Connection pooling for servers
+ * const { RuggyPool } = require('ruggy');
+ * 
+ * const pool = new RuggyPool('./data');
+ * 
+ * app.get('/users', async (req, res) => {
+ *   await pool.withCollection('users', col => {
+ *     res.json(col.findAll());
+ *   });
+ * });
+ * 
+ * process.on('SIGTERM', () => pool.close());
+ */
+
+const RuggyDatabase = require('./Database');
+// const RuggyCollection = require('./Collection');
+const RuggyPool = require('./Pool');
+
+// Export classes
+module.exports = {
+    RuggyDatabase,
+    // RuggyCollection,
+    RuggyPool,
+
+    // Aliases for convenience
+    Ruggy: RuggyDatabase,
+    Database: RuggyDatabase,
+    // Collection: RuggyCollection,
+    Pool: RuggyPool
+};
+
+// module.exports.default = RuggyDatabase;

package/src/utils.js

@@ -0,0 +1,73 @@
+const { koffi } = require('./bindings');
+
+/**
+ * Reads a null-terminated C string from a memory pointer
+ * Optimized to read in chunks instead of byte-by-byte
+ * @param {*} ptr - Memory pointer from Koffi
+ * @returns {string|null} - UTF-8 decoded string or null
+ */
+function readCString(ptr) {
+    if (!ptr || koffi.address(ptr) === 0n) return null;
+
+    const CHUNK_SIZE = 256;
+    const MAX_SIZE = 1024 * 1024; // 1MB safety limit
+    const chunks = [];
+    let offset = 0;
+
+    while (offset < MAX_SIZE) {
+        const buffer = koffi.decode(ptr, offset, koffi.types.uint8, CHUNK_SIZE);
+
+        // Find null terminator
+        let nullIndex = -1;
+        for (let i = 0; i < buffer.length; i++) {
+            if (buffer[i] === 0) {
+                nullIndex = i;
+                break;
+            }
+        }
+
+        if (nullIndex !== -1) {
+            // Found null terminator
+            chunks.push(buffer.slice(0, nullIndex));
+            break;
+        }
+
+        chunks.push(buffer);
+        offset += CHUNK_SIZE;
+    }
+
+    // Concatenate all chunks and decode UTF-8
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const fullBuffer = new Uint8Array(totalLength);
+    let pos = 0;
+    for (const chunk of chunks) {
+        fullBuffer.set(chunk, pos);
+        pos += chunk.length;
+    }
+
+    return Buffer.from(fullBuffer).toString('utf8');
+}
+
+/**
+ * Converts a JavaScript string to a null-terminated UTF-8 buffer
+ * @param {string} str - String to convert
+ * @returns {Buffer} - Buffer with null terminator
+ */
+function toCString(str) {
+    return Buffer.from(str + '\0', 'utf8');
+}
+
+/**
+ * Validates if a pointer is valid (not null)
+ * @param {*} ptr - Pointer to validate
+ * @returns {boolean}
+ */
+function isValidPointer(ptr) {
+    return ptr && koffi.address(ptr) !== 0n;
+}
+
+module.exports = {
+    readCString,
+    toCString,
+    isValidPointer
+};