s3db.js 11.2.6 → 11.3.2

package/mcp/tools/bulk.js

@@ -0,0 +1,112 @@
+/**
+ * Bulk Operations Tools
+ * Handles bulk updates and upserts for efficient batch processing
+ */
+
+export const bulkTools = [
+  {
+    name: 'resourceUpdateMany',
+    description: 'Update multiple documents matching a query filter',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        filters: {
+          type: 'object',
+          description: 'Query filters to select documents'
+        },
+        updates: {
+          type: 'object',
+          description: 'Updates to apply to matching documents'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of documents to update',
+          default: 1000
+        }
+      },
+      required: ['resourceName', 'filters', 'updates']
+    }
+  },
+  {
+    name: 'resourceBulkUpsert',
+    description: 'Upsert multiple documents (insert if not exists, update if exists)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        data: {
+          type: 'array',
+          description: 'Array of documents to upsert (must include id field)'
+        }
+      },
+      required: ['resourceName', 'data']
+    }
+  }
+];
+
+export function createBulkHandlers(server) {
+  return {
+    async resourceUpdateMany(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, filters, updates, limit = 1000 } = args;
+      const resource = server.getResource(database, resourceName);
+
+      try {
+        // Query documents matching filters
+        const docs = await resource.query(filters, { limit });
+
+        // Update each document
+        const updatePromises = docs.map(doc =>
+          resource.update(doc.id, updates)
+        );
+
+        const results = await Promise.all(updatePromises);
+
+        return {
+          success: true,
+          updatedCount: results.length,
+          filters,
+          updates,
+          data: results
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message,
+          filters,
+          updates
+        };
+      }
+    },
+
+    async resourceBulkUpsert(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, data } = args;
+      const resource = server.getResource(database, resourceName);
+
+      try {
+        // Upsert each document
+        const upsertPromises = data.map(doc => resource.upsert(doc));
+        const results = await Promise.all(upsertPromises);
+
+        return {
+          success: true,
+          upsertedCount: results.length,
+          data: results
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  };
+}

package/mcp/tools/connection.js

@@ -0,0 +1,228 @@
+/**
+ * Connection Management Tools
+ * Handles database connection, disconnection, and status checks
+ */
+
+export const connectionTools = [
+  {
+    name: 'dbConnect',
+    description: 'Connect to an S3DB database with automatic costs tracking and configurable cache (memory or filesystem)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        connectionString: {
+          type: 'string',
+          description: 'S3DB connection string (e.g., s3://key:secret@bucket/path)'
+        },
+        verbose: {
+          type: 'boolean',
+          description: 'Enable verbose logging',
+          default: false
+        },
+        parallelism: {
+          type: 'number',
+          description: 'Number of parallel operations',
+          default: 10
+        },
+        passphrase: {
+          type: 'string',
+          description: 'Passphrase for encryption',
+          default: 'secret'
+        },
+        versioningEnabled: {
+          type: 'boolean',
+          description: 'Enable resource versioning',
+          default: false
+        },
+        enableCache: {
+          type: 'boolean',
+          description: 'Enable cache for improved performance',
+          default: true
+        },
+        enableCosts: {
+          type: 'boolean',
+          description: 'Enable costs tracking for S3 operations',
+          default: true
+        },
+        cacheDriver: {
+          type: 'string',
+          description: 'Cache driver type: "memory" or "filesystem"',
+          enum: ['memory', 'filesystem'],
+          default: 'memory'
+        },
+        cacheMaxSize: {
+          type: 'number',
+          description: 'Maximum number of items in memory cache (memory driver only)',
+          default: 1000
+        },
+        cacheTtl: {
+          type: 'number',
+          description: 'Cache time-to-live in milliseconds',
+          default: 300000
+        },
+        cacheDirectory: {
+          type: 'string',
+          description: 'Directory path for filesystem cache (filesystem driver only)',
+          default: './cache'
+        },
+        cachePrefix: {
+          type: 'string',
+          description: 'Prefix for cache files (filesystem driver only)',
+          default: 'cache'
+        }
+      },
+      required: ['connectionString']
+    }
+  },
+  {
+    name: 'dbDisconnect',
+    description: 'Disconnect from the S3DB database',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'dbStatus',
+    description: 'Get the current database connection status',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  }
+];
+
+export function createConnectionHandlers(server) {
+  return {
+    async dbConnect(args, database, { S3db, CachePlugin, CostsPlugin, FilesystemCache }) {
+      const {
+        connectionString,
+        verbose = false,
+        parallelism = 10,
+        passphrase = 'secret',
+        versioningEnabled = false,
+        enableCache = true,
+        enableCosts = true,
+        cacheDriver = 'memory',
+        cacheMaxSize = 1000,
+        cacheTtl = 300000,
+        cacheDirectory = './cache',
+        cachePrefix = 'cache'
+      } = args;
+
+      if (database && database.isConnected()) {
+        return { success: false, message: 'Database is already connected' };
+      }
+
+      const plugins = [];
+
+      // Costs plugin
+      const costsEnabled = enableCosts !== false && process.env.S3DB_COSTS_ENABLED !== 'false';
+      if (costsEnabled) {
+        plugins.push(CostsPlugin);
+      }
+
+      // Cache plugin
+      const cacheEnabled = enableCache !== false && process.env.S3DB_CACHE_ENABLED !== 'false';
+
+      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;
+
+        let cacheConfig = {
+          includePartitions: true
+        };
+
+        if (cacheDriverEnv === 'filesystem') {
+          cacheConfig.driver = new FilesystemCache({
+            directory: cacheDirectoryEnv,
+            prefix: cachePrefixEnv,
+            ttl: cacheTtlEnv,
+            enableCompression: true,
+            enableStats: verbose,
+            enableCleanup: true,
+            cleanupInterval: 300000,
+            createDirectory: true
+          });
+        } else {
+          cacheConfig.driver = 'memory';
+          cacheConfig.memoryOptions = {
+            maxSize: cacheMaxSizeEnv,
+            ttl: cacheTtlEnv,
+            enableStats: verbose
+          };
+        }
+
+        plugins.push(new CachePlugin(cacheConfig));
+      }
+
+      const newDatabase = new S3db({
+        connectionString,
+        verbose,
+        parallelism,
+        passphrase,
+        versioningEnabled,
+        plugins
+      });
+
+      await newDatabase.connect();
+
+      return {
+        success: true,
+        message: 'Connected to S3DB database',
+        database: newDatabase,
+        status: {
+          connected: newDatabase.isConnected(),
+          bucket: newDatabase.bucket,
+          keyPrefix: newDatabase.keyPrefix,
+          version: newDatabase.s3dbVersion,
+          plugins: {
+            costs: costsEnabled,
+            cache: cacheEnabled,
+            cacheDriver: cacheEnabled ? cacheDriverEnv : null,
+            cacheDirectory: cacheEnabled && cacheDriverEnv === 'filesystem' ? cacheDirectoryEnv : null,
+            cacheMaxSize: cacheEnabled && cacheDriverEnv === 'memory' ? cacheMaxSizeEnv : null,
+            cacheTtl: cacheEnabled ? cacheTtlEnv : null
+          }
+        }
+      };
+    },
+
+    async dbDisconnect(args, database) {
+      if (!database || !database.isConnected()) {
+        return { success: false, message: 'No database connection to disconnect' };
+      }
+
+      await database.disconnect();
+
+      return {
+        success: true,
+        message: 'Disconnected from S3DB database',
+        clearDatabase: true
+      };
+    },
+
+    async dbStatus(args, database) {
+      if (!database) {
+        return {
+          connected: false,
+          message: 'No database instance created'
+        };
+      }
+
+      return {
+        connected: database.isConnected(),
+        bucket: database.bucket,
+        keyPrefix: database.keyPrefix,
+        version: database.s3dbVersion,
+        resourceCount: Object.keys(database.resources || {}).length,
+        resources: Object.keys(database.resources || {})
+      };
+    }
+  };
+}