feat: implement query interface and redirect docs

Author: mrdevrobot

docs/_data/navigation.yml

@@ -1,3 +1,5 @@
 v0.7.0:
   - title: Getting Started
     url: /v0.7.0/getting-started.html
+  - title: Querying
+    url: /v0.7.0/querying.html

docs/_layouts/default.html

@@ -112,7 +112,7 @@ <h2 class="project-tagline">{{ site.description }}</h2>
     {% assign version = page.url | split: '/' %}
     {% assign current_version = version[1] %}
 
-    {% if current_version == 'v0.7.0' %}
+    {% if current_version == 'v0.7.0' or current_version == 'v0.6.0' %}
     <nav class="sidebar">
       <h3>Docs {{ current_version }}</h3>
       <ul>
@@ -131,10 +131,11 @@ <h3>Docs {{ current_version }}</h3>
   </div>
 
   <footer class="site-footer" style="text-align: center; padding: 2rem; border-top: 1px solid #eee; margin-top: 2rem;">
-    <span class="site-footer-owner"><a href="https://github.com/EntglDb/EntglDb.NodeJs">EntglDb.NodeJs</a> is maintained by the EntglDb Team.</span>
+    <span class="site-footer-owner"><a href="https://github.com/EntglDb/EntglDb.NodeJs">EntglDb.NodeJs</a> is maintained
+      by the EntglDb Team.</span>
     <span class="site-footer-credits">This page was generated by <a href="https://pages.github.com">GitHub
         Pages</a>.</span>
   </footer>
 </body>
 
-</html>
+</html>

docs/index.md

@@ -8,7 +8,7 @@ Welcome to the documentation for **EntglDb Node.js**.
 
 ## Active Versions
 
-*   [**v0.7.0 (Latest)**](v0.7.0/getting-started.html) - Brotli Compression, Protocol v4.
+*   [**v0.7.0 (Latest)**](https://www.entgldb.com/docs/v0.7.0) - *Hosted on EntglDb.com*
 
 ## Links
 

docs/v0.7.0/getting-started.md

@@ -52,3 +52,8 @@ EntglDb now supports Brotli compression for network synchronization. This is aut
 
 ### Security
 Secure Handshake using ECDH is available.
+
+## Next Steps
+
+- [Querying](querying.html)
+

docs/v0.7.0/index.md

@@ -0,0 +1,10 @@
+---
+layout: default
+title: Documentation Moved
+---
+
+# Documentation Moved
+
+The documentation for **EntglDb.NodeJs v0.7.0** is now hosted centrally.
+
+👉 [**View Documentation on EntglDb.com**](https://www.entgldb.com/docs/v0.7.0)

docs/v0.7.0/querying.md

@@ -0,0 +1,60 @@
+---
+layout: default
+title: Querying
+---
+
+# Querying
+
+EntglDb Node.js provides a MongoDB-like query syntax for local collections, allowing you to filter documents efficiently.
+
+## Basic Querying
+
+You can query documents using the `find` method on a `PeerCollection`.
+
+```typescript
+const users = await peerStore.getCollection('users');
+
+// Precise match
+const fabio = await users.find({ firstName: 'Fabio' });
+
+// Comparisons using operators
+const adults = await users.find({ age: { $gte: 18 } });
+
+// Logical Operators (Implicit AND)
+const activeAdmins = await users.find({ 
+    isActive: true, 
+    role: 'Admin' 
+});
+
+// Explicit Logical Operators
+const complex = await users.find({ 
+    $or: [
+        { role: 'Admin' },
+        { role: 'Moderator' }
+    ]
+});
+```
+
+## Serialization Consistency
+
+The query engine respects the `namingStrategy` configured for the `json-serialization` adapter.
+
+```typescript
+// If translation logic is enabled (e.g. camelToSnake)
+// The following query:
+await users.find({ firstName: 'Fabio' });
+
+// Will effectively query the underlying JSON field:
+// json_extract(data, '$.first_name')
+```
+
+## Supported Operators
+
+- `$eq` (Equal) - Default if value is direct
+- `$ne` (Not Equal)
+- `$gt` (Greater Than)
+- `$lt` (Less Than)
+- `$gte` (Greater Than or Equal)
+- `$lte` (Less Than or Equal)
+- `$and` (AND)
+- `$or` (OR)

packages/core/src/collection.ts

@@ -61,13 +61,24 @@ export class PeerCollection<T = any> {
      * Find documents matching a predicate
      * Note: This is a simple client-side filter. For production, implement server-side queries.
      */
-    async find(predicate: (doc: T) => boolean): Promise<T[]> {
-        // This is a naive implementation that loads all docs
-        // In production, implement proper query translation to SQL
-        const results: T[] = [];
+    /**
+     * Find documents matching a query object
+     * @param query The query object (e.g. { name: "Fabio" })
+     * @param options Query options including naming strategy
+     */
+    async find(query: any, options?: { namingStrategy?: (prop: string) => string }): Promise<T[]> {
+        const { ObjectToQueryNodeTranslator } = require('./query/translator');
+        const queryNode = ObjectToQueryNodeTranslator.translate(query, options);
+
+        // If no query, return all? or support empty query?
+        // If queryNode is null (empty query), we might want to scan all.
+        // For now let's pass null to store and let it decide (scan all).
 
-        // We'd need to add a method to IPeerStore to scan a collection
-        // For now, this is a placeholder
-        throw new Error('find() not yet implemented - needs store.scanCollection()');
+        const docs = await this.store.findDocuments(this.name, queryNode);
+
+        return docs.map(doc => {
+            const jsonData = new TextDecoder().decode(doc.data);
+            return JSON.parse(jsonData) as T;
+        });
     }
 }

packages/core/src/index.ts

@@ -11,5 +11,11 @@ export { IPeerStore } from './storage/interface';
 // Sync and conflict resolution
 export * from './sync';
 
+// Re-export protocol types for convenience
 // Re-export protocol types for convenience
 export type { HLCTimestamp, Document, OplogEntry } from '@entgldb/protocol';
+
+// Query exports
+export * from './query/query-node';
+export * from './query/translator';
+

packages/core/src/query/query-node.ts

@@ -0,0 +1,49 @@
+
+export abstract class QueryNode {
+    abstract type: string;
+}
+
+export class And extends QueryNode {
+    readonly type = 'And';
+    constructor(public left: QueryNode, public right: QueryNode) { super(); }
+}
+
+export class Or extends QueryNode {
+    readonly type = 'Or';
+    constructor(public left: QueryNode, public right: QueryNode) { super(); }
+}
+
+export class Eq extends QueryNode {
+    readonly type = 'Eq';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Neq extends QueryNode {
+    readonly type = 'Neq';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Gt extends QueryNode {
+    readonly type = 'Gt';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Gte extends QueryNode {
+    readonly type = 'Gte';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Lt extends QueryNode {
+    readonly type = 'Lt';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Lte extends QueryNode {
+    readonly type = 'Lte';
+    constructor(public field: string, public value: any) { super(); }
+}
+
+export class Contains extends QueryNode {
+    readonly type = 'Contains';
+    constructor(public field: string, public value: string) { super(); }
+}

packages/core/src/query/translator.ts

@@ -0,0 +1,85 @@
+import { QueryNode, And, Or, Eq, Gt, Gte, Lt, Lte, Neq, Contains } from './query-node';
+
+export interface QueryOptions {
+    /**
+     * Function to transform property names (e.g. camelCase to snake_case)
+     */
+    namingStrategy?: (prop: string) => string;
+}
+
+/**
+ * Translates a MongoDB-like query object to a QueryNode tree.
+ * Example: { name: "Fabio", age: { $gt: 18 } }
+ */
+export class ObjectToQueryNodeTranslator {
+
+    static translate(query: any, options?: QueryOptions): QueryNode | null {
+        if (!query || Object.keys(query).length === 0) return null;
+
+        const nodes: QueryNode[] = [];
+
+        for (const key of Object.keys(query)) {
+            const value = query[key];
+            const fieldName = options?.namingStrategy ? options.namingStrategy(key) : key;
+
+            if (key === '$or') {
+                if (Array.isArray(value)) {
+                    const subNodes = value.map(v => this.translate(v, options)).filter(n => n !== null) as QueryNode[];
+                    if (subNodes.length > 0) {
+                        let combined = subNodes[0];
+                        for (let i = 1; i < subNodes.length; i++) {
+                            combined = new Or(combined, subNodes[i]);
+                        }
+                        nodes.push(combined);
+                    }
+                }
+                continue;
+            }
+
+            if (key === '$and') {
+                if (Array.isArray(value)) {
+                    const subNodes = value.map(v => this.translate(v, options)).filter(n => n !== null) as QueryNode[];
+                    subNodes.forEach(n => nodes.push(n));
+                }
+                continue;
+            }
+
+            // Primitive value check (e.g. { field: "value" } -> implies Eq)
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                nodes.push(new Eq(fieldName, value));
+                continue;
+            }
+
+            // Operator check (e.g. { field: { $gt: 10 } })
+            for (const op of Object.keys(value)) {
+                const opVal = value[op];
+                switch (op) {
+                    case '$eq': nodes.push(new Eq(fieldName, opVal)); break;
+                    case '$neq': nodes.push(new Neq(fieldName, opVal)); break;
+                    case '$gt': nodes.push(new Gt(fieldName, opVal)); break;
+                    case '$gte': nodes.push(new Gte(fieldName, opVal)); break;
+                    case '$lt': nodes.push(new Lt(fieldName, opVal)); break;
+                    case '$lte': nodes.push(new Lte(fieldName, opVal)); break;
+                    case '$contains': nodes.push(new Contains(fieldName, opVal)); break;
+                    default:
+                        // If it's not a known operator, maybe it's just a nested object Eq?
+                        // For now let's assume valid operators or fallback to Eq? 
+                        // Actually in mongo {a: {b:1}} is exact match.
+                        // EntglDb is flat mostly. Let's throw or ignore.
+                        console.warn(`Unknown operator ${op} for field ${fieldName}`);
+                        break;
+                }
+            }
+        }
+
+        if (nodes.length === 0) return null;
+        if (nodes.length === 1) return nodes[0];
+
+        // Combine all implicit ANDs
+        let result = nodes[0];
+        for (let i = 1; i < nodes.length; i++) {
+            result = new And(result, nodes[i]);
+        }
+        return result;
+    }
+}