s3db.js 9.2.1 → 9.3.0

package/mcp/server.js

@@ -628,7 +628,7 @@ class S3dbMCPServer {
 
   setupTransport() {
     const transport = process.argv.includes('--transport=sse') || process.env.MCP_TRANSPORT === 'sse'
-      ? new SSEServerTransport('/sse', process.env.MCP_SERVER_HOST || '0.0.0.0', parseInt(process.env.MCP_SERVER_PORT || '8000'))
+      ? new SSEServerTransport('/sse', process.env.MCP_SERVER_HOST || '0.0.0.0', parseInt(process.env.MCP_SERVER_PORT || '17500'))
       : new StdioServerTransport();
 
     this.server.connect(transport);
@@ -636,7 +636,7 @@ class S3dbMCPServer {
     // SSE specific setup
     if (transport instanceof SSEServerTransport) {
       const host = process.env.MCP_SERVER_HOST || '0.0.0.0';
-      const port = process.env.MCP_SERVER_PORT || '8000';
+      const port = process.env.MCP_SERVER_PORT || '17500';
       
       console.log(`S3DB MCP Server running on http://${host}:${port}/sse`);
       
@@ -723,12 +723,16 @@ class S3dbMCPServer {
 
     // Add CachePlugin (enabled by default, configurable)
     const cacheEnabled = enableCache !== false && process.env.S3DB_CACHE_ENABLED !== 'false';
+    
+    // Declare cache variables in outer scope to avoid reference errors
+    let cacheMaxSizeEnv, cacheTtlEnv, cacheDriverEnv, cacheDirectoryEnv, cachePrefixEnv;
+    
     if (cacheEnabled) {
-      const cacheMaxSizeEnv = process.env.S3DB_CACHE_MAX_SIZE ? parseInt(process.env.S3DB_CACHE_MAX_SIZE) : cacheMaxSize;
-      const cacheTtlEnv = process.env.S3DB_CACHE_TTL ? parseInt(process.env.S3DB_CACHE_TTL) : cacheTtl;
-      const cacheDriverEnv = process.env.S3DB_CACHE_DRIVER || cacheDriver;
-      const cacheDirectoryEnv = process.env.S3DB_CACHE_DIRECTORY || cacheDirectory;
-      const cachePrefixEnv = process.env.S3DB_CACHE_PREFIX || cachePrefix;
+      cacheMaxSizeEnv = process.env.S3DB_CACHE_MAX_SIZE ? parseInt(process.env.S3DB_CACHE_MAX_SIZE) : cacheMaxSize;
+      cacheTtlEnv = process.env.S3DB_CACHE_TTL ? parseInt(process.env.S3DB_CACHE_TTL) : cacheTtl;
+      cacheDriverEnv = process.env.S3DB_CACHE_DRIVER || cacheDriver;
+      cacheDirectoryEnv = process.env.S3DB_CACHE_DIRECTORY || cacheDirectory;
+      cachePrefixEnv = process.env.S3DB_CACHE_PREFIX || cachePrefix;
       
       let cacheConfig = {
         includePartitions: true
@@ -1358,7 +1362,7 @@ function parseArgs() {
   const args = {
     transport: 'stdio',
     host: '0.0.0.0',
-    port: 8000
+    port: 17500
   };
 
   process.argv.forEach((arg, index) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s3db.js",
-  "version": "9.2.1",
+  "version": "9.3.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",
@@ -58,8 +58,8 @@
     "UNLICENSE"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.864.0",
-    "@modelcontextprotocol/sdk": "^1.17.3",
+    "@aws-sdk/client-s3": "^3.873.0",
+    "@modelcontextprotocol/sdk": "^1.17.4",
     "@smithy/node-http-handler": "^4.1.1",
     "@supercharge/promise-pool": "^3.2.0",
     "dotenv": "^17.2.1",
@@ -112,7 +112,7 @@
     "node-loader": "^2.1.0",
     "ora": "^8.2.0",
     "pkg": "^5.8.1",
-    "rollup": "^4.46.4",
+    "rollup": "^4.48.0",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-polyfill-node": "^0.13.0",

package/src/concerns/async-event-emitter.js

@@ -17,10 +17,10 @@ class AsyncEventEmitter extends EventEmitter {
       return false;
     }
 
-    setImmediate(() => {
+    setImmediate(async () => {
       for (const listener of listeners) {
         try {
-          listener(...args);
+          await listener(...args);
         } catch (error) {
           if (event !== 'error') {
             this.emit('error', error);

package/src/resource.class.js

@@ -135,7 +135,8 @@ export class Resource extends AsyncEventEmitter {
       idSize = 22,
       versioningEnabled = false,
       events = {},
-      asyncEvents = true
+      asyncEvents = true,
+      asyncPartitions = true
     } = config;
 
     // Set instance properties
@@ -177,6 +178,7 @@ export class Resource extends AsyncEventEmitter {
       autoDecrypt,
       allNestedObjectsOptional,
       asyncEvents,
+      asyncPartitions,
     };
 
     // Initialize hooks system
@@ -817,14 +819,42 @@ export class Resource extends AsyncEventEmitter {
     // Get the inserted object
     const insertedObject = await this.get(finalId);
     
-    // Execute afterInsert hooks
-    const finalResult = await this.executeHooks('afterInsert', insertedObject);
-    
-    // Emit insert event
-    this.emit('insert', finalResult);
-    
-    // Return the final object
-    return finalResult;
+    // Handle partition indexing based on asyncPartitions config
+    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      // Async mode: create partition indexes in background
+      setImmediate(() => {
+        this.createPartitionReferences(insertedObject).catch(err => {
+          this.emit('partitionIndexError', {
+            operation: 'insert',
+            id: finalId,
+            error: err,
+            message: err.message
+          });
+        });
+      });
+      
+      // Execute other afterInsert hooks synchronously (excluding partition hook)
+      const nonPartitionHooks = this.hooks.afterInsert.filter(hook => 
+        !hook.toString().includes('createPartitionReferences')
+      );
+      let finalResult = insertedObject;
+      for (const hook of nonPartitionHooks) {
+        finalResult = await hook(finalResult);
+      }
+      
+      // Emit insert event
+      this.emit('insert', finalResult);
+      return finalResult;
+    } else {
+      // Sync mode: execute all hooks including partition creation
+      const finalResult = await this.executeHooks('afterInsert', insertedObject);
+      
+      // Emit insert event
+      this.emit('insert', finalResult);
+      
+      // Return the final object
+      return finalResult;
+    }
   }
 
   /**
@@ -1087,13 +1117,46 @@ export class Resource extends AsyncEventEmitter {
       body: finalBody,
       behavior: this.behavior
     });
-    const finalResult = await this.executeHooks('afterUpdate', updatedData);
-    this.emit('update', {
-      ...updatedData,
-      $before: { ...originalData },
-      $after: { ...finalResult }
-    });
-    return finalResult;
+    
+    // Handle partition updates based on asyncPartitions config
+    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      // Async mode: update partition indexes in background
+      setImmediate(() => {
+        this.handlePartitionReferenceUpdates(originalData, updatedData).catch(err => {
+          this.emit('partitionIndexError', {
+            operation: 'update',
+            id,
+            error: err,
+            message: err.message
+          });
+        });
+      });
+      
+      // Execute other afterUpdate hooks synchronously (excluding partition hook)
+      const nonPartitionHooks = this.hooks.afterUpdate.filter(hook => 
+        !hook.toString().includes('handlePartitionReferenceUpdates')
+      );
+      let finalResult = updatedData;
+      for (const hook of nonPartitionHooks) {
+        finalResult = await hook(finalResult);
+      }
+      
+      this.emit('update', {
+        ...updatedData,
+        $before: { ...originalData },
+        $after: { ...finalResult }
+      });
+      return finalResult;
+    } else {
+      // Sync mode: execute all hooks including partition updates
+      const finalResult = await this.executeHooks('afterUpdate', updatedData);
+      this.emit('update', {
+        ...updatedData,
+        $before: { ...originalData },
+        $after: { ...finalResult }
+      });
+      return finalResult;
+    }
   }
 
   /**
@@ -1149,8 +1212,34 @@ export class Resource extends AsyncEventEmitter {
       id
     });
     
-    const afterDeleteData = await this.executeHooks('afterDelete', objectData);
-    return response;
+    // Handle partition cleanup based on asyncPartitions config
+    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      // Async mode: delete partition indexes in background
+      setImmediate(() => {
+        this.deletePartitionReferences(objectData).catch(err => {
+          this.emit('partitionIndexError', {
+            operation: 'delete',
+            id,
+            error: err,
+            message: err.message
+          });
+        });
+      });
+      
+      // Execute other afterDelete hooks synchronously (excluding partition hook)
+      const nonPartitionHooks = this.hooks.afterDelete.filter(hook => 
+        !hook.toString().includes('deletePartitionReferences')
+      );
+      let afterDeleteData = objectData;
+      for (const hook of nonPartitionHooks) {
+        afterDeleteData = await hook(afterDeleteData);
+      }
+      return response;
+    } else {
+      // Sync mode: execute all hooks including partition deletion
+      const afterDeleteData = await this.executeHooks('afterDelete', objectData);
+      return response;
+    }
   }
 
   /**
@@ -1943,21 +2032,36 @@ export class Resource extends AsyncEventEmitter {
       return;
     }
 
-    // Create reference in each partition
-    for (const [partitionName, partition] of Object.entries(partitions)) {
+    // Create all partition references in parallel
+    const promises = Object.entries(partitions).map(async ([partitionName, partition]) => {
       const partitionKey = this.getPartitionKey({ partitionName, id: data.id, data });
       if (partitionKey) {
         // Save only version as metadata, never object attributes
         const partitionMetadata = {
           _v: String(this.version)
         };
-        await this.client.putObject({
+        return this.client.putObject({
           key: partitionKey,
           metadata: partitionMetadata,
           body: '',
           contentType: undefined,
         });
       }
+      return null;
+    });
+
+    // Wait for all partition references to be created
+    const results = await Promise.allSettled(promises);
+    
+    // Check for any failures
+    const failures = results.filter(r => r.status === 'rejected');
+    if (failures.length > 0) {
+      // Emit warning but don't throw - partitions are secondary indexes
+      this.emit('partitionIndexWarning', {
+        operation: 'create',
+        id: data.id,
+        failures: failures.map(f => f.reason)
+      });
     }
   }
 
@@ -2077,33 +2181,41 @@ export class Resource extends AsyncEventEmitter {
     if (!partitions || Object.keys(partitions).length === 0) {
       return;
     }
-    for (const [partitionName, partition] of Object.entries(partitions)) {
+    
+    // Update all partitions in parallel
+    const updatePromises = Object.entries(partitions).map(async ([partitionName, partition]) => {
       const [ok, err] = await tryFn(() => this.handlePartitionReferenceUpdate(partitionName, partition, oldData, newData));
       if (!ok) {
         // console.warn(`Failed to update partition references for ${partitionName}:`, err.message);
+        return { partitionName, error: err };
       }
-    }
+      return { partitionName, success: true };
+    });
+    
+    await Promise.allSettled(updatePromises);
+    
+    // Aggressive cleanup: remove stale partition keys in parallel
     const id = newData.id || oldData.id;
-    for (const [partitionName, partition] of Object.entries(partitions)) {
+    const cleanupPromises = Object.entries(partitions).map(async ([partitionName, partition]) => {
       const prefix = `resource=${this.name}/partition=${partitionName}`;
-      let allKeys = [];
       const [okKeys, errKeys, keys] = await tryFn(() => this.client.getAllKeys({ prefix }));
-      if (okKeys) {
-        allKeys = keys;
-      } else {
+      if (!okKeys) {
         // console.warn(`Aggressive cleanup: could not list keys for partition ${partitionName}:`, errKeys.message);
-        continue;
+        return;
       }
+      
       const validKey = this.getPartitionKey({ partitionName, id, data: newData });
-      for (const key of allKeys) {
-        if (key.endsWith(`/id=${id}`) && key !== validKey) {
-          const [okDel, errDel] = await tryFn(() => this.client.deleteObject(key));
-          if (!okDel) {
-            // console.warn(`Aggressive cleanup: could not delete stale partition key ${key}:`, errDel.message);
-          }
+      const staleKeys = keys.filter(key => key.endsWith(`/id=${id}`) && key !== validKey);
+      
+      if (staleKeys.length > 0) {
+        const [okDel, errDel] = await tryFn(() => this.client.deleteObjects(staleKeys));
+        if (!okDel) {
+          // console.warn(`Aggressive cleanup: could not delete stale partition keys:`, errDel.message);
         }
       }
-    }
+    });
+    
+    await Promise.allSettled(cleanupPromises);
   }
 
   /**