s3db.js 12.4.0 → 13.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s3db.js",
-  "version": "12.4.0",
+  "version": "13.0.0",
   "description": "Use AWS S3, the world's most reliable document storage, as a database with this ORM.",
   "main": "dist/s3db.cjs.js",
   "module": "dist/s3db.es.js",
@@ -88,6 +88,7 @@
     "@google-cloud/bigquery": "^7.0.0",
     "@hono/node-server": "^1.0.0",
     "@hono/swagger-ui": "^0.5.0",
+    "@tensorflow/tfjs-node": "^4.0.0",
     "amqplib": "^0.10.8",
     "hono": "^4.0.0",
     "node-cron": "^4.0.0",
@@ -106,6 +107,9 @@
     "@hono/swagger-ui": {
       "optional": true
     },
+    "@tensorflow/tfjs-node": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     },

package/src/clients/memory-client.class.js

@@ -640,41 +640,58 @@ export class MemoryClient extends EventEmitter {
     for (const [resourceName, keys] of resourceMap.entries()) {
       const records = [];
 
-      for (const key of keys) {
-        const obj = await this.getObject(key);
+      // Get resource from database if available (for proper field decoding)
+      const resource = database && database.resources && database.resources[resourceName];
 
+      for (const key of keys) {
         // Extract id from key (e.g., resource=products/id=pr1 -> pr1)
         const idMatch = key.match(/\/id=([^/]+)/);
         const recordId = idMatch ? idMatch[1] : null;
 
-        // Reconstruct record from metadata and body
-        const record = { ...obj.Metadata };
+        let record;
 
-        // Include id in record if extracted from key
-        if (recordId && !record.id) {
-          record.id = recordId;
+        // If resource is available, use its get() method for proper field name decoding
+        if (resource && recordId) {
+          try {
+            record = await resource.get(recordId);
+          } catch (err) {
+            // Fallback to manual reconstruction if get() fails
+            console.warn(`Failed to get record ${recordId} from resource ${resourceName}, using fallback`);
+            record = null;
+          }
         }
 
-        // If body exists, parse it
-        if (obj.Body) {
-          const chunks = [];
-          for await (const chunk of obj.Body) {
-            chunks.push(chunk);
+        // Fallback: manually reconstruct from metadata and body
+        if (!record) {
+          const obj = await this.getObject(key);
+          record = { ...obj.Metadata };
+
+          // Include id in record if extracted from key
+          if (recordId && !record.id) {
+            record.id = recordId;
           }
-          const bodyBuffer = Buffer.concat(chunks);
-
-          // Try to parse as JSON if it looks like JSON
-          const bodyStr = bodyBuffer.toString('utf-8');
-          if (bodyStr.startsWith('{') || bodyStr.startsWith('[')) {
-            try {
-              const bodyData = JSON.parse(bodyStr);
-              Object.assign(record, bodyData);
-            } catch {
-              // If not JSON, store as _body field
+
+          // If body exists, parse it
+          if (obj.Body) {
+            const chunks = [];
+            for await (const chunk of obj.Body) {
+              chunks.push(chunk);
+            }
+            const bodyBuffer = Buffer.concat(chunks);
+
+            // Try to parse as JSON if it looks like JSON
+            const bodyStr = bodyBuffer.toString('utf-8');
+            if (bodyStr.startsWith('{') || bodyStr.startsWith('[')) {
+              try {
+                const bodyData = JSON.parse(bodyStr);
+                Object.assign(record, bodyData);
+              } catch {
+                // If not JSON, store as _body field
+                record._body = bodyStr;
+              }
+            } else if (bodyStr) {
               record._body = bodyStr;
             }
-          } else if (bodyStr) {
-            record._body = bodyStr;
           }
         }
 

package/src/database.class.js

@@ -14,7 +14,12 @@ export class Database extends EventEmitter {
   constructor(options) {
     super();
 
-    this.id = idGenerator(7)
+    // Generate database ID with fallback for reliability
+    this.id = (() => {
+      const [ok, err, id] = tryFn(() => idGenerator(7));
+      return ok && id ? id : `db-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    })();
+
     this.version = "1";
     // Version is injected during build, fallback to "latest" for development
     this.s3dbVersion = (() => {
@@ -64,6 +69,7 @@ export class Database extends EventEmitter {
     this.versioningEnabled = options.versioningEnabled || false;
     this.persistHooks = options.persistHooks || false; // New configuration for hook persistence
     this.strictValidation = options.strictValidation !== false; // Enable strict validation by default
+    this.strictHooks = options.strictHooks || false; // Throw on first hook error instead of continuing
 
     // Initialize hooks system
     this._initHooks();
@@ -110,21 +116,32 @@ export class Database extends EventEmitter {
     this.bucket = this.client.bucket;
     this.keyPrefix = this.client.keyPrefix;
 
-    // Add process exit listener for cleanup
-    if (!this._exitListenerRegistered) {
+    // Register exit listener for cleanup
+    this._registerExitListener();
+  }
+
+  /**
+   * Register process exit listener for automatic cleanup
+   * @private
+   */
+  _registerExitListener() {
+    if (!this._exitListenerRegistered && typeof process !== 'undefined') {
       this._exitListenerRegistered = true;
-      if (typeof process !== 'undefined') {
-        process.on('exit', async () => {
-          if (this.isConnected()) {
-            // Silently ignore errors on exit
-            await tryFn(() => this.disconnect());
-          }
-        });
-      }
+      // Store listener reference for cleanup
+      this._exitListener = async () => {
+        if (this.isConnected()) {
+          // Silently ignore errors on exit
+          await tryFn(() => this.disconnect());
+        }
+      };
+      process.on('exit', this._exitListener);
     }
   }
-  
+
   async connect() {
+    // Re-register exit listener if it was cleaned up
+    this._registerExitListener();
+
     await this.startPlugins();
 
     let metadata = null;
@@ -1271,15 +1288,24 @@ export class Database extends EventEmitter {
         this.client.removeAllListeners();
       }
 
-      // 4. Remove all listeners from the database itself
+      // 4. Emit disconnected event BEFORE removing database listeners (race condition fix)
+      // This ensures listeners can actually receive the event
+      await this.emit('disconnected', new Date());
+
+      // 5. Remove all listeners from the database itself
       this.removeAllListeners();
 
-      // 5. Clear saved metadata and plugin lists
+      // 6. Cleanup process exit listener (memory leak fix)
+      if (this._exitListener && typeof process !== 'undefined') {
+        process.off('exit', this._exitListener);
+        this._exitListener = null;
+        this._exitListenerRegistered = false;
+      }
+
+      // 7. Clear saved metadata and plugin lists
       this.savedMetadata = null;
       this.plugins = {};
       this.pluginList = [];
-
-      this.emit('disconnected', new Date());
     });
   }
 
@@ -1400,8 +1426,17 @@ export class Database extends EventEmitter {
     for (const hook of hooks) {
       const [ok, error] = await tryFn(() => hook({ database: this, ...context }));
       if (!ok) {
-        // Emit error but don't stop hook execution
+        // Emit error event
         this.emit('hookError', { event, error, context });
+
+        // In strict mode, throw on first error instead of continuing
+        if (this.strictHooks) {
+          throw new DatabaseError(`Hook execution failed for event '${event}': ${error.message}`, {
+            event,
+            originalError: error,
+            context
+          });
+        }
       }
     }
   }

package/src/plugins/api/index.js

@@ -437,15 +437,18 @@ export class ApiPlugin extends Plugin {
     return async (c, next) => {
       await next();
 
-      // Note: Actual compression would require proper streaming support
-      // For now, this is a placeholder
-      const acceptEncoding = c.req.header('accept-encoding') || '';
-
-      if (acceptEncoding.includes('gzip')) {
-        c.header('Content-Encoding', 'gzip');
-      } else if (acceptEncoding.includes('deflate')) {
-        c.header('Content-Encoding', 'deflate');
-      }
+      // TODO: Implement actual compression using zlib
+      // For now, this is a no-op placeholder to avoid ERR_CONTENT_DECODING_FAILED errors
+      //
+      // WARNING: Do NOT set Content-Encoding headers without actually compressing!
+      // Setting these headers without compression causes browsers to fail with:
+      // net::ERR_CONTENT_DECODING_FAILED 200 (OK)
+      //
+      // Real implementation would require:
+      // 1. Check Accept-Encoding header
+      // 2. Compress response body with zlib.gzip() or zlib.deflate()
+      // 3. Set Content-Encoding header
+      // 4. Update Content-Length header
     };
   }
 

package/src/plugins/api/routes/resource-routes.js

@@ -8,6 +8,44 @@ import { Hono } from 'hono';
 import { asyncHandler } from '../utils/error-handler.js';
 import * as formatter from '../utils/response-formatter.js';
 
+/**
+ * Parse custom route definition (e.g., "GET /healthcheck" or "async POST /custom")
+ * @param {string} routeDef - Route definition string
+ * @returns {Object} Parsed route { method, path, isAsync }
+ */
+function parseCustomRoute(routeDef) {
+  // Remove "async" prefix if present
+  let def = routeDef.trim();
+  const isAsync = def.startsWith('async ');
+
+  if (isAsync) {
+    def = def.substring(6).trim(); // Remove "async "
+  }
+
+  // Split by space (e.g., "GET /path" -> ["GET", "/path"])
+  const parts = def.split(/\s+/);
+
+  if (parts.length < 2) {
+    throw new Error(`Invalid route definition: "${routeDef}". Expected format: "METHOD /path" or "async METHOD /path"`);
+  }
+
+  const method = parts[0].toUpperCase();
+  const path = parts.slice(1).join(' ').trim(); // Join remaining parts in case path has spaces (unlikely but possible)
+
+  // Validate HTTP method
+  const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+  if (!validMethods.includes(method)) {
+    throw new Error(`Invalid HTTP method: "${method}". Must be one of: ${validMethods.join(', ')}`);
+  }
+
+  // Validate path starts with /
+  if (!path.startsWith('/')) {
+    throw new Error(`Invalid route path: "${path}". Path must start with "/"`);
+  }
+
+  return { method, path, isAsync };
+}
+
 /**
  * Create routes for a resource
  * @param {Object} resource - s3db.js Resource instance
@@ -31,6 +69,46 @@ export function createResourceRoutes(resource, version, config = {}) {
     app.use('*', middleware);
   });
 
+  // Register custom routes from resource.config.api (if defined)
+  if (resource.config?.api && typeof resource.config.api === 'object') {
+    for (const [routeDef, handler] of Object.entries(resource.config.api)) {
+      try {
+        const { method, path } = parseCustomRoute(routeDef);
+
+        if (typeof handler !== 'function') {
+          throw new Error(`Handler for route "${routeDef}" must be a function`);
+        }
+
+        // Register the custom route
+        // The handler receives the full Hono context
+        app.on(method, path, asyncHandler(async (c) => {
+          // Call user's handler with Hono context
+          const result = await handler(c, { resource, database: resource.database });
+
+          // If handler already returned a response, use it
+          if (result && result.constructor && result.constructor.name === 'Response') {
+            return result;
+          }
+
+          // If handler returned data, wrap in success formatter
+          if (result !== undefined && result !== null) {
+            return c.json(formatter.success(result));
+          }
+
+          // If no return value, return 204 No Content
+          return c.json(formatter.noContent(), 204);
+        }));
+
+        if (config.verbose || resource.database?.verbose) {
+          console.log(`[API Plugin] Registered custom route for ${resourceName}: ${method} ${path}`);
+        }
+      } catch (error) {
+        console.error(`[API Plugin] Error registering custom route "${routeDef}" for ${resourceName}:`, error.message);
+        throw error;
+      }
+    }
+  }
+
   // LIST - GET /{version}/{resource}
   if (methods.includes('GET')) {
     app.get('/', asyncHandler(async (c) => {

package/src/plugins/index.js

@@ -13,6 +13,7 @@ export * from './eventual-consistency/index.js'
 export * from './fulltext.plugin.js'
 export * from './geo.plugin.js'
 export * from './metrics.plugin.js'
+export * from './ml.plugin.js'
 export * from './queue-consumer.plugin.js'
 export * from './relation.plugin.js'
 export * from './replicator.plugin.js'