hlquery-node-client 1.0.5 → 1.0.7

package/lib/Search.js

@@ -15,6 +15,7 @@ class Search {
     constructor(request, collections) {
         this.request = request;
         this.collections = collections;
+        this.searchableFieldsCache = new Map();
     }
     
     /**
@@ -96,13 +97,18 @@ class Search {
             queryParams.query_by = Array.isArray(params.query_by)
                 ? params.query_by.join(',')
                 : params.query_by;
-        } else if (params.q && params.q !== '') {
-            // Auto-detect searchable fields
-            const collection = await this.collections.get(collectionName);
-            if (collection.getStatusCode() === 200) {
-                const body = collection.getBody();
-                if (body.searchable_fields && body.searchable_fields.length > 0) {
-                    queryParams.query_by = body.searchable_fields.join(',');
+        } else if (params.q && params.q !== '' && params.auto_detect_query_by !== false) {
+            const cacheKey = collectionName;
+            if (this.searchableFieldsCache.has(cacheKey)) {
+                queryParams.query_by = this.searchableFieldsCache.get(cacheKey);
+            } else {
+                const collection = await this.collections.get(collectionName);
+                if (collection.getStatusCode() === 200) {
+                    const body = collection.getBody();
+                    if (body.searchable_fields && body.searchable_fields.length > 0) {
+                        queryParams.query_by = body.searchable_fields.join(',');
+                        this.searchableFieldsCache.set(cacheKey, queryParams.query_by);
+                    }
                 }
             }
         }
@@ -212,10 +218,16 @@ class Search {
      * Multi-search across multiple collections
      * 
      * @param {Array} searches Array of search requests
+     * @param {string} method GET or POST
      * @returns {Promise<Response>}
      */
-    async multiSearch(searches) {
-        return await this.request.execute('POST', '/multi_search', { searches: searches });
+    async multiSearch(searches, method = 'POST') {
+        method = String(method).toUpperCase();
+        if (method !== 'GET' && method !== 'POST') {
+            throw new Error('Multi-search method must be GET or POST');
+        }
+
+        return await this.request.execute(method, '/multi_search', { searches: searches });
     }
 
     /**

package/lib/System.js

@@ -30,6 +30,10 @@ class System {
         return await this.request.execute('GET', '/boot-status');
     }
 
+    async ready() {
+        return await this.request.execute('GET', '/ready');
+    }
+
     async info() {
         return await this.request.execute('GET', '/');
     }
@@ -46,6 +50,14 @@ class System {
         return await this.request.execute('GET', '/metrics.json');
     }
 
+    async metricsHistory() {
+        return await this.request.execute('GET', '/metrics/history');
+    }
+
+    async metricsHistoryAlias() {
+        return await this.request.execute('GET', '/metrics-history');
+    }
+
     async connections() {
         return await this.request.execute('GET', '/connections');
     }
@@ -105,6 +117,32 @@ class System {
     async storageStatus() {
         return await this.request.execute('GET', '/admin/storage_status');
     }
+
+    async searchConfig() {
+        return await this.request.execute('GET', '/search-config');
+    }
+
+    async updateCounters(params = {}, method = 'POST') {
+        method = this._getOrPostMethod(method, 'Update counters');
+        return await this.request.execute(method, '/update-counters', null, params);
+    }
+
+    async debugCounters() {
+        return await this.request.execute('GET', '/debug/counters');
+    }
+
+    async repair(params = {}, method = 'POST') {
+        method = this._getOrPostMethod(method, 'Repair');
+        return await this.request.execute(method, '/repair', null, params);
+    }
+
+    _getOrPostMethod(method, operation) {
+        method = String(method).toUpperCase();
+        if (method !== 'GET' && method !== 'POST') {
+            throw new Error(`${operation} method must be GET or POST`);
+        }
+        return method;
+    }
 }
 
 module.exports = System;

package/lib/Users.js

@@ -0,0 +1,51 @@
+/**
+ * hlquery Node.js Client - Users API
+ *
+ * Copyright (C) 2021-2026, Carlos F. Ferry <carlos.ferry@gmail.com>
+ *
+ * This file is part of hlquery, released under the BSD License version 3.
+ */
+
+class Users {
+    constructor(request) {
+        this.request = request;
+    }
+
+    _validateName(name) {
+        if (typeof name !== 'string' || name.trim() === '') {
+            throw new Error('User name is required');
+        }
+    }
+
+    async list() {
+        return await this.request.execute('GET', '/users');
+    }
+
+    async get(name) {
+        this._validateName(name);
+        return await this.request.execute('GET', `/users/${encodeURIComponent(name)}`);
+    }
+
+    async create(params) {
+        if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            throw new Error('User parameters must be an object');
+        }
+        this._validateName(params.name);
+        return await this.request.execute('POST', '/users', params);
+    }
+
+    async update(name, params) {
+        this._validateName(name);
+        if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            throw new Error('User parameters must be an object');
+        }
+        return await this.request.execute('PUT', `/users/${encodeURIComponent(name)}`, params);
+    }
+
+    async delete(name) {
+        this._validateName(name);
+        return await this.request.execute('DELETE', `/users/${encodeURIComponent(name)}`);
+    }
+}
+
+module.exports = Users;

package/lib/conformance.js

@@ -14,6 +14,8 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/stats', methods: ['GET'], status: 'supported', client: 'system.stats' },
     { path: '/metrics', methods: ['GET'], status: 'supported', client: 'system.metrics' },
     { path: '/metrics.json', methods: ['GET'], status: 'supported', client: 'system.metricsJson' },
+    { path: '/metrics/history', methods: ['GET'], status: 'supported', client: 'system.metricsHistory' },
+    { path: '/metrics-history', methods: ['GET'], status: 'supported', client: 'system.metricsHistoryAlias' },
     { path: '/connections', methods: ['GET'], status: 'supported', client: 'system.connections' },
     { path: '/rocksdb', methods: ['GET'], status: 'supported', client: 'system.rocksdb' },
     { path: '/_rocksdb', methods: ['GET'], status: 'supported', client: 'system.rocksdbInternal' },
@@ -24,9 +26,6 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/consistency', methods: ['GET'], status: 'supported', client: 'system.consistency' },
     { path: '/self-check', methods: ['GET'], status: 'supported', client: 'system.selfCheck' },
     { path: '/admin/storage_status', methods: ['GET'], status: 'supported', client: 'system.storageStatus' },
-    { path: '/cluster/health', methods: ['GET'], status: 'supported', client: 'client.clusterHealth' },
-    { path: '/cluster/stats', methods: ['GET'], status: 'supported', client: 'client.clusterStats' },
-    { path: '/cluster/nodes', methods: ['GET'], status: 'supported', client: 'client.clusterNodes' },
     { path: '/links', methods: ['GET'], status: 'supported', client: 'client.links' },
     { path: '/links/ping', methods: ['GET'], status: 'supported', client: 'client.linksPing' },
     { path: '/links/connect', methods: ['POST'], status: 'supported', client: 'client.linksConnect' },
@@ -35,24 +34,22 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/collections/distributed', methods: ['GET'], status: 'supported', client: 'client.listCollectionsDistributed' },
     { path: '/collections', methods: ['GET', 'POST'], status: 'supported', client: 'collections.list/create' },
     { path: '/collections/{name}', methods: ['GET', 'DELETE'], status: 'supported', client: 'collections.get/delete' },
+    { path: '/collections/{name}/lang', methods: ['GET'], status: 'supported', client: 'collections.language' },
+    { path: '/collections/{name}/aliases', methods: ['GET'], status: 'supported', client: 'aliases.listCollection' },
     { path: '/collections/{name}/update', methods: ['POST'], status: 'supported', client: 'collections.update' },
     { path: '/collections/{name}/documents', methods: ['GET', 'POST', 'DELETE'], status: 'supported', client: 'documents.list/add/deleteByFilter' },
     { path: '/collections/{name}/documents/import', methods: ['POST'], status: 'supported', client: 'documents.import' },
     { path: '/collections/{name}/documents/{id}', methods: ['GET', 'PUT', 'DELETE'], status: 'supported', client: 'documents.get/update/delete' },
+    { path: '/collections/{name}/documents/{id}/context', methods: ['GET'], status: 'supported', client: 'documents.context' },
+    { path: '/collections/{name}/documents/maybe', methods: ['GET', 'POST'], status: 'supported', client: 'documents.maybe' },
+    { path: '/collections/{name}/documents/_update_by_query', methods: ['POST'], status: 'supported', client: 'documents.updateByQuery' },
+    { path: '/collections/{name}/documents/_delete_by_query', methods: ['POST'], status: 'supported', client: 'documents.deleteByQuery' },
     { path: '/collections/{name}/search', methods: ['GET', 'POST'], status: 'supported', client: 'search.search' },
     { path: '/collections/{name}/documents/search', methods: ['GET', 'POST'], status: 'supported', client: 'search.searchLegacy' },
     { path: '/collections/{name}/vector_search', methods: ['GET', 'POST'], status: 'supported', client: 'search.vectorSearch' },
     { path: '/multi_search', methods: ['GET', 'POST'], status: 'supported', client: 'search.multiSearch' },
     { path: '/search', methods: ['GET', 'POST'], status: 'supported', client: 'search.globalSearch' },
     { path: '/sql', methods: ['GET', 'POST'], status: 'supported', client: 'system.sql/execSql' },
-    { path: '/sam/rebuild', methods: ['POST'], status: 'supported', client: 'sam.rebuild' },
-    { path: '/sam/search', methods: ['GET'], status: 'supported', client: 'sam.search' },
-    { path: '/sam/status', methods: ['GET'], status: 'supported', client: 'sam.status' },
-    { path: '/sam/debug', methods: ['GET'], status: 'supported', client: 'sam.debug' },
-    { path: '/sam/history', methods: ['GET'], status: 'supported', client: 'sam.history' },
-    { path: '/sam/pause', methods: ['POST'], status: 'supported', client: 'sam.pause/clearPause' },
-    { path: '/sam/documents', methods: ['GET'], status: 'supported', client: 'sam.listDocuments' },
-    { path: '/sam/documents/{collection}/{id}', methods: ['GET'], status: 'supported', client: 'sam.getDocument/openDocument' },
     { path: '/collections/{name}/documents/facet_counts', methods: ['GET', 'POST'], status: 'supported', client: 'documents.facetCounts' },
     { path: '/collections/{name}/documents/export', methods: ['GET', 'POST'], status: 'supported', client: 'documents.export' },
     { path: '/collections/{name}/synonyms', methods: ['GET'], status: 'supported', client: 'synonyms.list' },
@@ -71,15 +68,24 @@ const NODE_CLIENT_ROUTE_COVERAGE = [
     { path: '/aliases/{name}', methods: ['GET', 'POST', 'PUT', 'DELETE'], status: 'supported', client: 'aliases.get/create/update/delete' },
     { path: '/keys', methods: ['GET', 'POST'], status: 'supported', client: 'keys.list/create' },
     { path: '/keys/{id}', methods: ['GET', 'PUT', 'DELETE'], status: 'supported', client: 'keys.get/update/delete' },
-    { path: '/update-counters', methods: ['GET', 'POST'], status: 'omitted', reason: 'Internal maintenance endpoint; intentionally left off the public Node client.' },
+    { path: '/users', methods: ['GET', 'POST'], status: 'supported', client: 'users.list/create' },
+    { path: '/users/{name}', methods: ['GET', 'PUT', 'DELETE'], status: 'supported', client: 'users.get/update/delete' },
+    { path: '/analytics/click', methods: ['POST'], status: 'supported', client: 'analytics.click' },
+    { path: '/update-counters', methods: ['GET', 'POST'], status: 'supported', client: 'system.updateCounters' },
+    { path: '/debug/counters', methods: ['GET'], status: 'supported', client: 'system.debugCounters' },
     { path: '/query', methods: ['GET'], status: 'omitted', reason: 'Alias of /status; client exposes status() instead of duplicate naming.' },
-    { path: '/search-config', methods: ['GET'], status: 'omitted', reason: 'Diagnostic configuration endpoint; stable client exposes raw executeRequest() for this route.' },
-    { path: '/ready', methods: ['GET'], status: 'omitted', reason: 'Readiness alias; client exposes startup() and bootStatus() instead of duplicate naming.' },
-    { path: '/llm', methods: ['GET', 'POST'], status: 'omitted', reason: 'LLM runtime endpoint is module/config dependent and not part of the stable SDK surface yet.' },
-    { path: '/repair', methods: ['POST'], status: 'omitted', reason: 'Administrative repair endpoint; intentionally left off the public Node client.' },
-    { path: '/modules', methods: ['GET'], status: 'omitted', reason: 'Module APIs are intentionally omitted until the module surface is documented and stabilized for SDKs.' },
-    { path: '/modules/{name}', methods: ['ANY'], status: 'omitted', reason: 'Module-specific routes are dynamic and intentionally not wrapped in the stable Node client.' },
-    { path: '/modules/{name}/syntax', methods: ['GET'], status: 'omitted', reason: 'Module-specific routes are dynamic and intentionally not wrapped in the stable Node client.' }
+    { path: '/search-config', methods: ['GET'], status: 'supported', client: 'system.searchConfig' },
+    { path: '/ready', methods: ['GET'], status: 'supported', client: 'system.ready' },
+    { path: '/repair', methods: ['GET', 'POST'], status: 'supported', client: 'system.repair' },
+    { path: '/modules', methods: ['GET'], status: 'supported', client: 'modules.list' },
+    { path: '/modules/load', methods: ['POST'], status: 'omitted', reason: 'Prefix alias; modules.load(name) uses the explicit /loadmodule/{name} form.' },
+    { path: '/modules/unload', methods: ['POST'], status: 'omitted', reason: 'Prefix alias; modules.unload(name) uses the explicit /unloadmodule/{name} form.' },
+    { path: '/loadmodule', methods: ['POST'], status: 'omitted', reason: 'Body-based alias; modules.load(name) uses the explicit /loadmodule/{name} form.' },
+    { path: '/loadmodule/{name}', methods: ['POST'], status: 'supported', client: 'modules.load' },
+    { path: '/unloadmodule', methods: ['POST'], status: 'omitted', reason: 'Body-based alias; modules.unload(name) uses the explicit /unloadmodule/{name} form.' },
+    { path: '/unloadmodule/{name}', methods: ['POST'], status: 'supported', client: 'modules.unload' },
+    { path: '/modules/{name}', methods: ['ANY'], status: 'supported', client: 'modules.call' },
+    { path: '/modules/{name}/syntax', methods: ['GET'], status: 'supported', client: 'modules.syntax' }
 ];
 
 module.exports = {

package/package.json

@@ -1,34 +1,23 @@
 {
   "name": "hlquery-node-client",
-  "version": "1.0.5",
-  "description": "Node.js client library for hlquery search engine",
-  "main": "index.js",
-  "type": "commonjs",
+  "version": "1.0.7",
+  "description": "Node.js client for hlquery",
+  "main": "lib/Client.js",
   "scripts": {
-    "test": "node ../tests/test_node_client_conformance.js",
-    "test:conformance": "node ../tests/test_node_client_conformance.js",
-    "test:offline": "node test/offline-smoke.js",
-    "example": "node example.js",
-    "example:sql": "node examples/sql.js",
-    "example:pdf": "node examples/pdf.js",
-    "example:csv": "node examples/csv.js"
-  },
-  "dependencies": {
-    "pdf-parse": "^2.4.5"
+    "test": "node test/route-conformance.test.js",
+    "test:offline": "npm test"
   },
   "keywords": [
     "hlquery",
     "search",
-    "client",
-    "api"
+    "client"
   ],
   "author": "Carlos F. Ferry <carlos.ferry@gmail.com>",
   "license": "BSD-3-Clause",
+  "dependencies": {
+    "pdf-parse": "^2.4.5"
+  },
   "engines": {
     "node": ">=12.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/cferry/hlquery"
   }
 }

package/test/route-conformance.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const assert = require('assert');
+const Request = require('../lib/Request');
+const Search = require('../lib/Search');
+const System = require('../lib/System');
+const { NODE_CLIENT_ROUTE_COVERAGE } = require('../lib/conformance');
+
+class RecordingRequest {
+    constructor() {
+        this.calls = [];
+    }
+
+    async execute(method, path, body = null, query = {}) {
+        const call = { method, path, body, query };
+        this.calls.push(call);
+        return call;
+    }
+
+    last() {
+        return this.calls[this.calls.length - 1];
+    }
+}
+
+function route(path) {
+    const matches = NODE_CLIENT_ROUTE_COVERAGE.filter(entry => entry.path === path);
+    assert.strictEqual(matches.length, 1, `${path} must have exactly one conformance entry`);
+    return matches[0];
+}
+
+async function main() {
+    const routeKeys = new Set();
+    for (const entry of NODE_CLIENT_ROUTE_COVERAGE) {
+        assert.ok(entry.path.startsWith('/'), `route must be absolute-path scoped: ${entry.path}`);
+        assert.ok(Array.isArray(entry.methods) && entry.methods.length > 0, `route must declare methods: ${entry.path}`);
+        const key = `${entry.path}:${entry.methods.join(',')}`;
+        assert.ok(!routeKeys.has(key), `duplicate conformance route: ${key}`);
+        routeKeys.add(key);
+    }
+
+    const recorder = new RecordingRequest();
+    const search = new Search(recorder, null);
+    const system = new System(recorder);
+
+    assert.deepStrictEqual(route('/multi_search').methods, ['GET', 'POST']);
+    await search.multiSearch([], 'GET');
+    assert.deepStrictEqual(recorder.last(), {
+        method: 'GET', path: '/multi_search', body: { searches: [] }, query: {}
+    });
+    await search.multiSearch([], 'POST');
+    assert.strictEqual(recorder.last().method, 'POST');
+
+    for (const [path, invoke] of [
+        ['/update-counters', method => system.updateCounters({ force: 1 }, method)],
+        ['/repair', method => system.repair({ collection: 'books' }, method)]
+    ]) {
+        assert.deepStrictEqual(route(path).methods, ['GET', 'POST']);
+        await invoke('GET');
+        assert.strictEqual(recorder.last().method, 'GET');
+        assert.strictEqual(recorder.last().path, path);
+        await invoke('POST');
+        assert.strictEqual(recorder.last().method, 'POST');
+    }
+
+    const request = new Request('https://search.example.test', {
+        token: 'secret-token'
+    });
+    await assert.rejects(
+        request.execute('GET', 'https://attacker.example.test/collect'),
+        error => error && error.code === 'CROSS_ORIGIN_REQUEST'
+    );
+    await assert.rejects(
+        request.execute('GET', '//attacker.example.test/collect'),
+        error => error && error.code === 'CROSS_ORIGIN_REQUEST'
+    );
+
+    console.log(`route conformance passed (${NODE_CLIENT_ROUTE_COVERAGE.length} manifest entries)`);
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/utils/Config.js

@@ -23,6 +23,14 @@ class Config {
             timeout: options.timeout || 30000,
             token: options.token || null,
             auth_method: options.auth_method || 'bearer',
+            agent: options.agent || null,
+            http_agent: options.http_agent || null,
+            https_agent: options.https_agent || null,
+            headers: options.headers || {},
+            max_response_bytes: options.max_response_bytes || 0,
+            throw_on_error: options.throw_on_error || false,
+            query_array_format: options.query_array_format || 'comma',
+            signal: options.signal || null,
             ...options
         };
     }
@@ -34,11 +42,17 @@ class Config {
         if (!url) {
             return Config.getDefaultBaseUrl();
         }
+        if (url instanceof URL) {
+            url = url.toString();
+        }
+        if (typeof url !== 'string') {
+            url = String(url);
+        }
         url = url.trim();
         if (!url.startsWith('http://') && !url.startsWith('https://')) {
             url = 'http://' + url;
         }
-        return url.replace(/\/$/, '');
+        return url.replace(/\/+$/, '');
     }
     
     /**
@@ -47,7 +61,8 @@ class Config {
     static isValidUrl(url) {
         try {
             const urlObj = new URL(url);
-            return urlObj.protocol === 'http:' || urlObj.protocol === 'https:';
+            return (urlObj.protocol === 'http:' || urlObj.protocol === 'https:') &&
+                Boolean(urlObj.hostname);
         } catch (e) {
             return false;
         }

package/utils/Validator.js

@@ -56,12 +56,12 @@ class Validator {
             throw new ValidationException('Document ID must be between 1 and 64 characters');
         }
         
-        // Document IDs should be URL-safe: alphanumeric, underscores, and hyphens only
-        if (!/^[a-zA-Z0-9_-]+$/.test(idStr)) {
-            throw new ValidationException(
-                'Document ID contains invalid characters. ' +
-                'Use only letters, numbers, underscores, and hyphens'
-            );
+        if (idStr.trim() === '') {
+            throw new ValidationException('Document ID must be a non-empty string or number');
+        }
+
+        if (/[\x00-\x1F\x7F]/.test(idStr)) {
+            throw new ValidationException('Document ID contains control characters');
         }
     }
     
@@ -100,8 +100,7 @@ class Validator {
     }
     
     /**
-     * Validate document field values for invalid characters
-     * Commas are not allowed in string field values as they're reserved for internal parsing
+     * Validate document field values.
      * 
      * @param {object} document - Document object to validate
      * @throws {ValidationException} If document contains invalid characters
@@ -111,28 +110,12 @@ class Validator {
             return; // Skip validation for non-objects or arrays (will be validated per-item)
         }
         
-        for (const [key, value] of Object.entries(document)) {
-            // Skip the 'id' field as it has its own validation
-            if (key === 'id') continue;
-            
-            // Check string values for commas
-            if (typeof value === 'string' && value.includes(',')) {
-                throw new ValidationException(
-                    `Field '${key}' contains invalid character: comma (,). ` +
-                    `Commas are not allowed in field values. Use underscores (_) or spaces instead, or use arrays for multiple values.`
-                );
+        for (const key of Object.keys(document)) {
+            if (key === '') {
+                throw new ValidationException('Document field names must be non-empty strings');
             }
-            
-            // Check array values - ensure they don't contain strings with commas
-            if (Array.isArray(value)) {
-                for (const item of value) {
-                    if (typeof item === 'string' && item.includes(',')) {
-                        throw new ValidationException(
-                            `Field '${key}' contains invalid character: comma (,). ` +
-                            `Array items cannot contain commas. Use underscores (_) or spaces instead.`
-                        );
-                    }
-                }
+            if (/[\x00-\x1F\x7F]/.test(key)) {
+                throw new ValidationException(`Field '${key}' contains control characters`);
             }
         }
     }

package/examples/sam.js

@@ -1,39 +0,0 @@
-/**
- * Basic SAM example for the hlquery Node.js client.
- */
-
-const Client = require('../index');
-
-async function main() {
-    const baseUrl = process.env.HLQ_BASE_URL || process.env.HLQUERY_BASE_URL || 'http://localhost:9200';
-    const token = process.argv[2] || null;
-    const collection = process.argv[3] || 'music';
-    const query = process.argv[4] || 'queen of pop';
-
-    const client = new Client(baseUrl);
-
-    if (token) {
-        client.setAuthToken(token, 'bearer');
-    }
-
-    const sam = client.sam();
-
-    const status = await sam.status(collection);
-    console.log('=== SAM STATUS ===');
-    console.log(status.getBody());
-    console.log('');
-
-    const history = await sam.history(collection, 5);
-    console.log('=== SAM HISTORY ===');
-    console.log(history.getBody());
-    console.log('');
-
-    const results = await sam.search(collection, query, { limit: 10 });
-    console.log('=== SAM SEARCH ===');
-    console.log(results.getBody());
-}
-
-main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/index.js

@@ -1,40 +0,0 @@
-/**
- * hlquery Node.js Client - Main Entry Point
- * 
- * Copyright (C) 2021-2026, Carlos F. Ferry <carlos.ferry@gmail.com>
- * 
- * This file is part of hlquery, released under the BSD License version 3.
- */
-
-const Client = require('./lib/Client');
-
-// Export main client class
-module.exports = Client;
-
-// Export all classes for advanced usage
-module.exports.Client = Client;
-module.exports.Request = require('./lib/Request');
-module.exports.Response = require('./lib/Response');
-module.exports.Collections = require('./lib/Collections');
-module.exports.Documents = require('./lib/Documents');
-module.exports.Search = require('./lib/Search');
-module.exports.Keys = require('./lib/Keys');
-module.exports.Aliases = require('./lib/Aliases');
-module.exports.Overrides = require('./lib/Overrides');
-module.exports.Synonyms = require('./lib/Synonyms');
-module.exports.Stopwords = require('./lib/Stopwords');
-module.exports.System = require('./lib/System');
-module.exports.SAM = require('./lib/SAM');
-
-// Export exceptions
-module.exports.Exceptions = require('./lib/Exceptions');
-
-// Export utilities
-module.exports.Utils = {
-    Config: require('./utils/Config'),
-    Validator: require('./utils/Validator'),
-    Auth: require('./utils/Auth'),
-    Ranker: require('./utils/ranker'),
-    PDFParser: require('./utils/PDFParser'),
-    CSVParser: require('./utils/CSVParser')
-};