s3db.js 11.2.6 → 11.3.2

package/mcp/tools/partitions.js

@@ -0,0 +1,223 @@
+/**
+ * Partition Management Tools
+ * Handles partition listing, inspection, and orphaned partition recovery
+ */
+
+export const partitionTools = [
+  {
+    name: 'resourceListPartitions',
+    description: 'List all partitions defined for a resource',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        }
+      },
+      required: ['resourceName']
+    }
+  },
+  {
+    name: 'resourceListPartitionValues',
+    description: 'List unique values for a specific partition field',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        partitionName: {
+          type: 'string',
+          description: 'Name of the partition'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of values to return',
+          default: 1000
+        }
+      },
+      required: ['resourceName', 'partitionName']
+    }
+  },
+  {
+    name: 'dbFindOrphanedPartitions',
+    description: 'Find partitions that reference fields no longer in the schema',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of specific resource to check (optional - checks all if not provided)'
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'dbRemoveOrphanedPartitions',
+    description: 'Remove orphaned partitions from resource configuration',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        dryRun: {
+          type: 'boolean',
+          description: 'Preview changes without applying them',
+          default: true
+        }
+      },
+      required: ['resourceName']
+    }
+  }
+];
+
+export function createPartitionHandlers(server) {
+  return {
+    async resourceListPartitions(args, database) {
+      server.ensureConnected(database);
+      const { resourceName } = args;
+      const resource = server.getResource(database, resourceName);
+
+      const partitions = resource.config.partitions || {};
+
+      return {
+        success: true,
+        resource: resourceName,
+        partitions: Object.keys(partitions),
+        count: Object.keys(partitions).length,
+        details: partitions
+      };
+    },
+
+    async resourceListPartitionValues(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, partitionName, limit = 1000 } = args;
+      const resource = server.getResource(database, resourceName);
+
+      if (!resource.config.partitions || !resource.config.partitions[partitionName]) {
+        throw new Error(`Partition '${partitionName}' not found in resource '${resourceName}'`);
+      }
+
+      try {
+        // List all objects with this partition prefix
+        const prefix = `${database.keyPrefix}resource=${resourceName}/partition=${partitionName}/`;
+
+        const response = await database.client.listObjectsV2({
+          Bucket: database.bucket,
+          Prefix: prefix,
+          MaxKeys: limit
+        });
+
+        // Extract unique partition values from keys
+        const partitionValues = new Set();
+
+        for (const obj of response.Contents || []) {
+          // Parse partition values from key
+          const keyParts = obj.Key.split('/');
+          const partitionPart = keyParts.find(part => part.startsWith('partition='));
+          if (partitionPart) {
+            const valuesPart = keyParts.slice(keyParts.indexOf(partitionPart) + 1).find(part => !part.startsWith('id='));
+            if (valuesPart) {
+              partitionValues.add(valuesPart);
+            }
+          }
+        }
+
+        return {
+          success: true,
+          resource: resourceName,
+          partition: partitionName,
+          values: Array.from(partitionValues),
+          count: partitionValues.size
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message,
+          resource: resourceName,
+          partition: partitionName
+        };
+      }
+    },
+
+    async dbFindOrphanedPartitions(args, database) {
+      server.ensureConnected(database);
+      const { resourceName } = args;
+
+      const orphanedByResource = {};
+      const resourcesToCheck = resourceName
+        ? [resourceName]
+        : Object.keys(database.resources || {});
+
+      for (const name of resourcesToCheck) {
+        const resource = database.resources[name];
+        if (resource && resource.findOrphanedPartitions) {
+          const orphaned = resource.findOrphanedPartitions();
+          if (Object.keys(orphaned).length > 0) {
+            orphanedByResource[name] = orphaned;
+          }
+        }
+      }
+
+      return {
+        success: true,
+        orphanedPartitions: orphanedByResource,
+        affectedResources: Object.keys(orphanedByResource),
+        count: Object.keys(orphanedByResource).length,
+        hasIssues: Object.keys(orphanedByResource).length > 0
+      };
+    },
+
+    async dbRemoveOrphanedPartitions(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, dryRun = true } = args;
+      const resource = server.getResource(database, resourceName);
+
+      if (!resource.removeOrphanedPartitions) {
+        throw new Error(`Resource '${resourceName}' does not support removeOrphanedPartitions method`);
+      }
+
+      // Find orphaned partitions first
+      const orphaned = resource.findOrphanedPartitions();
+
+      if (Object.keys(orphaned).length === 0) {
+        return {
+          success: true,
+          message: 'No orphaned partitions found',
+          resource: resourceName,
+          dryRun
+        };
+      }
+
+      if (dryRun) {
+        return {
+          success: true,
+          message: 'Dry run - no changes made',
+          resource: resourceName,
+          orphanedPartitions: orphaned,
+          wouldRemove: Object.keys(orphaned),
+          dryRun: true
+        };
+      }
+
+      // Actually remove
+      const removed = resource.removeOrphanedPartitions();
+
+      // Save metadata
+      await database.uploadMetadataFile();
+
+      return {
+        success: true,
+        message: `Removed ${Object.keys(removed).length} orphaned partition(s)`,
+        resource: resourceName,
+        removedPartitions: removed,
+        dryRun: false
+      };
+    }
+  };
+}

package/mcp/tools/query.js

@@ -0,0 +1,150 @@
+/**
+ * Query & Filtering Tools
+ * Provides advanced query and search capabilities
+ */
+
+export const queryTools = [
+  {
+    name: 'resourceQuery',
+    description: 'Query documents with complex filters and conditions',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        filters: {
+          type: 'object',
+          description: 'Query filters (e.g., {status: "active", age: {$gt: 18}})'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of results',
+          default: 100
+        },
+        offset: {
+          type: 'number',
+          description: 'Number of results to skip',
+          default: 0
+        }
+      },
+      required: ['resourceName', 'filters']
+    }
+  },
+  {
+    name: 'resourceSearch',
+    description: 'Search for documents by text in specific fields',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        resourceName: {
+          type: 'string',
+          description: 'Name of the resource'
+        },
+        searchText: {
+          type: 'string',
+          description: 'Text to search for'
+        },
+        fields: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Fields to search in (if not specified, searches all string fields)'
+        },
+        caseSensitive: {
+          type: 'boolean',
+          description: 'Case-sensitive search',
+          default: false
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of results',
+          default: 100
+        }
+      },
+      required: ['resourceName', 'searchText']
+    }
+  }
+];
+
+export function createQueryHandlers(server) {
+  return {
+    async resourceQuery(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, filters, limit = 100, offset = 0 } = args;
+      const resource = server.getResource(database, resourceName);
+
+      try {
+        // Use the query method from resource
+        const results = await resource.query(filters, { limit, offset });
+
+        return {
+          success: true,
+          data: results,
+          count: results.length,
+          filters,
+          pagination: {
+            limit,
+            offset,
+            hasMore: results.length === limit
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message,
+          filters
+        };
+      }
+    },
+
+    async resourceSearch(args, database) {
+      server.ensureConnected(database);
+      const { resourceName, searchText, fields, caseSensitive = false, limit = 100 } = args;
+      const resource = server.getResource(database, resourceName);
+
+      try {
+        // Get all documents and filter in memory
+        const allDocs = await resource.list({ limit: limit * 2 }); // Fetch more to ensure we have enough after filtering
+
+        const searchString = caseSensitive ? searchText : searchText.toLowerCase();
+
+        // Determine fields to search
+        let searchFields = fields;
+        if (!searchFields || searchFields.length === 0) {
+          // Auto-detect string fields
+          searchFields = Object.keys(resource.attributes || {}).filter(key => {
+            const attr = resource.attributes[key];
+            const type = typeof attr === 'string' ? attr.split('|')[0] : attr.type;
+            return type === 'string';
+          });
+        }
+
+        // Filter documents
+        const results = allDocs.filter(doc => {
+          return searchFields.some(field => {
+            const value = doc[field];
+            if (!value) return false;
+            const valueString = caseSensitive ? String(value) : String(value).toLowerCase();
+            return valueString.includes(searchString);
+          });
+        }).slice(0, limit);
+
+        return {
+          success: true,
+          data: results,
+          count: results.length,
+          searchText,
+          searchFields,
+          caseSensitive
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message,
+          searchText
+        };
+      }
+    }
+  };
+}

package/mcp/tools/resources.js

@@ -0,0 +1,96 @@
+/**
+ * Resource Management Tools
+ * Handles resource creation and listing
+ */
+
+export const resourceManagementTools = [
+  {
+    name: 'dbCreateResource',
+    description: 'Create a new resource (collection/table) in the database',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Resource name'
+        },
+        attributes: {
+          type: 'object',
+          description: 'Schema attributes definition (e.g., {"name": "string|required", "age": "number"})'
+        },
+        behavior: {
+          type: 'string',
+          description: 'Resource behavior',
+          enum: ['user-managed', 'body-only', 'body-overflow', 'enforce-limits', 'truncate-data'],
+          default: 'user-managed'
+        },
+        timestamps: {
+          type: 'boolean',
+          description: 'Enable automatic timestamps',
+          default: false
+        },
+        partitions: {
+          type: 'object',
+          description: 'Partition configuration'
+        },
+        paranoid: {
+          type: 'boolean',
+          description: 'Enable paranoid mode (soft deletes)',
+          default: true
+        }
+      },
+      required: ['name', 'attributes']
+    }
+  },
+  {
+    name: 'dbListResources',
+    description: 'List all resources in the database',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  }
+];
+
+export function createResourceManagementHandlers(server) {
+  return {
+    async dbCreateResource(args, database) {
+      server.ensureConnected(database);
+
+      const { name, attributes, behavior = 'user-managed', timestamps = false, partitions, paranoid = true } = args;
+
+      const resource = await database.createResource({
+        name,
+        attributes,
+        behavior,
+        timestamps,
+        partitions,
+        paranoid
+      });
+
+      return {
+        success: true,
+        resource: {
+          name: resource.name,
+          behavior: resource.behavior,
+          attributes: resource.attributes,
+          partitions: resource.config.partitions,
+          timestamps: resource.config.timestamps
+        }
+      };
+    },
+
+    async dbListResources(args, database) {
+      server.ensureConnected(database);
+
+      const resourceList = await database.listResources();
+
+      return {
+        success: true,
+        resources: resourceList,
+        count: resourceList.length
+      };
+    }
+  };
+}