@fadlee/pocketbase-mcp 1.0.0

package/build/src/tools/handlers/migration.js

@@ -0,0 +1,219 @@
+import { handlePocketBaseError } from "../../utils/errors.js";
+import { createJsonResponse, createTextResponse } from "../../utils/response.js";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Migrate collection schema with data preservation
+ */
+export function createMigrateCollectionHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, fields, dataTransforms = {}, name, ...rules } = args;
+            // Prepare update data
+            const updateData = {
+                fields,
+                ...rules,
+            };
+            if (name)
+                updateData.name = name;
+            // Update collection schema
+            const updatedCollection = await pb.collections.update(collection, updateData);
+            // If there are data transforms, apply them
+            if (Object.keys(dataTransforms).length > 0) {
+                const records = await pb.collection(collection).getFullList();
+                for (const record of records) {
+                    const updates = {};
+                    let hasUpdates = false;
+                    for (const [oldField, newField] of Object.entries(dataTransforms)) {
+                        if (record[oldField] !== undefined) {
+                            updates[newField] = record[oldField];
+                            hasUpdates = true;
+                        }
+                    }
+                    if (hasUpdates) {
+                        await pb.collection(collection).update(record.id, updates);
+                    }
+                }
+            }
+            return createJsonResponse({
+                success: true,
+                collection: updatedCollection,
+                message: `Collection '${collection}' migrated successfully`,
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("migrate collection", error);
+        }
+    };
+}
+/**
+ * Create a backup of the PocketBase database
+ */
+export function createBackupDatabaseHandler(pb) {
+    return async (args = {}) => {
+        try {
+            const format = args.format || "json";
+            // Get all collections
+            const collections = await pb.collections.getFullList();
+            const backup = {
+                timestamp: new Date().toISOString(),
+                collections: {},
+            };
+            // Export each collection
+            for (const collection of collections) {
+                const records = await pb.collection(collection.name).getFullList();
+                backup.collections[collection.name] = {
+                    schema: collection,
+                    records,
+                };
+            }
+            if (format === "csv") {
+                // For CSV, we'll export each collection separately
+                const csvData = [];
+                for (const [collectionName, data] of Object.entries(backup.collections)) {
+                    const collectionData = data;
+                    if (collectionData.records.length > 0) {
+                        csvData.push(`\n--- Collection: ${collectionName} ---`);
+                        // Format records as CSV
+                        const records = collectionData.records;
+                        if (records.length > 0) {
+                            const headers = Object.keys(records[0]);
+                            csvData.push(headers.join(","));
+                            records.forEach((record) => {
+                                const values = headers.map((header) => {
+                                    const value = record[header];
+                                    return typeof value === "string" && value.includes(",")
+                                        ? `"${value.replace(/"/g, '""')}"`
+                                        : String(value || "");
+                                });
+                                csvData.push(values.join(","));
+                            });
+                        }
+                    }
+                }
+                return createTextResponse(csvData.join("\n"));
+            }
+            return createJsonResponse(backup);
+        }
+        catch (error) {
+            throw handlePocketBaseError("backup database", error);
+        }
+    };
+}
+/**
+ * Import data into a collection
+ */
+export function createImportDataHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, data, mode = "create" } = args;
+            const results = {
+                created: 0,
+                updated: 0,
+                errors: [],
+            };
+            for (const item of data) {
+                try {
+                    switch (mode) {
+                        case "create":
+                            await pb.collection(collection).create(item);
+                            results.created++;
+                            break;
+                        case "update":
+                            if (!item.id) {
+                                results.errors.push("Update mode requires 'id' field in each record");
+                                continue;
+                            }
+                            await pb.collection(collection).update(item.id, item);
+                            results.updated++;
+                            break;
+                        case "upsert":
+                            if (item.id) {
+                                try {
+                                    await pb.collection(collection).update(item.id, item);
+                                    results.updated++;
+                                }
+                                catch {
+                                    await pb.collection(collection).create(item);
+                                    results.created++;
+                                }
+                            }
+                            else {
+                                await pb.collection(collection).create(item);
+                                results.created++;
+                            }
+                            break;
+                        default:
+                            throw new McpError(ErrorCode.InvalidParams, `Unsupported import mode: ${mode}`);
+                    }
+                }
+                catch (error) {
+                    results.errors.push(`Failed to import record: ${error.message}`);
+                }
+            }
+            return createJsonResponse({
+                success: true,
+                results,
+                message: `Import completed: ${results.created} created, ${results.updated} updated, ${results.errors.length} errors`,
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("import data", error);
+        }
+    };
+}
+/**
+ * Manage collection indexes
+ */
+export function createManageIndexesHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, action, index } = args;
+            switch (action) {
+                case "list": {
+                    const collectionInfo = await pb.collections.getOne(collection);
+                    return createJsonResponse({
+                        collection,
+                        indexes: collectionInfo.indexes || [],
+                    });
+                }
+                case "create": {
+                    if (!index) {
+                        throw new McpError(ErrorCode.InvalidParams, "Index configuration required for create action");
+                    }
+                    const currentCollection = await pb.collections.getOne(collection);
+                    const currentIndexes = currentCollection.indexes || [];
+                    // Add new index
+                    const newIndexes = [...currentIndexes, index];
+                    await pb.collections.update(collection, {
+                        indexes: newIndexes,
+                    });
+                    return createJsonResponse({
+                        success: true,
+                        message: `Index '${index.name}' created successfully`,
+                        indexes: newIndexes,
+                    });
+                }
+                case "delete": {
+                    if (!index?.name) {
+                        throw new McpError(ErrorCode.InvalidParams, "Index name required for delete action");
+                    }
+                    const collectionToUpdate = await pb.collections.getOne(collection);
+                    const filteredIndexes = (collectionToUpdate.indexes || []).filter((idx) => idx.name !== index.name);
+                    await pb.collections.update(collection, {
+                        indexes: filteredIndexes,
+                    });
+                    return createJsonResponse({
+                        success: true,
+                        message: `Index '${index.name}' deleted successfully`,
+                        indexes: filteredIndexes,
+                    });
+                }
+                default:
+                    throw new McpError(ErrorCode.InvalidParams, `Unsupported index action: ${action}`);
+            }
+        }
+        catch (error) {
+            throw handlePocketBaseError("manage indexes", error);
+        }
+    };
+}

package/build/src/tools/handlers/record.d.ts

@@ -0,0 +1,18 @@
+import type PocketBase from "pocketbase";
+import type { ToolHandler } from "../../types/index.js";
+/**
+ * Create a new record in a collection
+ */
+export declare function createCreateRecordHandler(pb: PocketBase): ToolHandler;
+/**
+ * List records from a collection with optional filters
+ */
+export declare function createListRecordsHandler(pb: PocketBase): ToolHandler;
+/**
+ * Update an existing record
+ */
+export declare function createUpdateRecordHandler(pb: PocketBase): ToolHandler;
+/**
+ * Delete a record
+ */
+export declare function createDeleteRecordHandler(pb: PocketBase): ToolHandler;

package/build/src/tools/handlers/record.js

@@ -0,0 +1,94 @@
+import { handlePocketBaseError } from "../../utils/errors.js";
+import { createJsonResponse } from "../../utils/response.js";
+/**
+ * Create a new record in a collection
+ */
+export function createCreateRecordHandler(pb) {
+    return async (args) => {
+        try {
+            const options = {};
+            // Add optional parameters
+            if (args.expand)
+                options.expand = args.expand;
+            if (args.fields)
+                options.fields = args.fields;
+            const result = await pb
+                .collection(args.collection)
+                .create(args.data, options);
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("create record", error);
+        }
+    };
+}
+/**
+ * List records from a collection with optional filters
+ */
+export function createListRecordsHandler(pb) {
+    return async (args) => {
+        try {
+            const options = {};
+            // Add optional parameters
+            if (args.filter)
+                options.filter = args.filter;
+            if (args.sort)
+                options.sort = args.sort;
+            if (args.expand)
+                options.expand = args.expand;
+            if (args.fields)
+                options.fields = args.fields;
+            if (args.skipTotal !== undefined)
+                options.skipTotal = args.skipTotal;
+            // Set pagination
+            const page = args.page || 1;
+            const perPage = args.perPage || 50;
+            const result = await pb
+                .collection(args.collection)
+                .getList(page, perPage, options);
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("list records", error);
+        }
+    };
+}
+/**
+ * Update an existing record
+ */
+export function createUpdateRecordHandler(pb) {
+    return async (args) => {
+        try {
+            const options = {};
+            // Add optional parameters
+            if (args.expand)
+                options.expand = args.expand;
+            if (args.fields)
+                options.fields = args.fields;
+            const result = await pb
+                .collection(args.collection)
+                .update(args.id, args.data, options);
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("update record", error);
+        }
+    };
+}
+/**
+ * Delete a record
+ */
+export function createDeleteRecordHandler(pb) {
+    return async (args) => {
+        try {
+            await pb.collection(args.collection).delete(args.id);
+            return createJsonResponse({
+                success: true,
+                message: `Record '${args.id}' deleted successfully from collection '${args.collection}'`
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("delete record", error);
+        }
+    };
+}

package/build/src/tools/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tools module - exports schemas and handlers
+ */
+export * from "./schemas/index.js";
+export * from "./handlers/index.js";

package/build/src/tools/index.js

@@ -0,0 +1,7 @@
+/**
+ * Tools module - exports schemas and handlers
+ */
+// Export all schemas
+export * from "./schemas/index.js";
+// Export all handlers
+export * from "./handlers/index.js";

package/build/src/tools/schemas/analysis.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Tool input schemas for analysis-related operations
+ */
+export declare const analyzeCollectionDataSchema: {
+    type: string;
+    properties: {
+        collection: {
+            type: string;
+            description: string;
+        };
+        options: {
+            type: string;
+            description: string;
+            properties: {
+                sampleSize: {
+                    type: string;
+                    description: string;
+                };
+                fields: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+            };
+        };
+    };
+    required: string[];
+};
+export declare const queryCollectionSchema: {
+    type: string;
+    properties: {
+        collection: {
+            type: string;
+            description: string;
+        };
+        filter: {
+            type: string;
+            description: string;
+        };
+        sort: {
+            type: string;
+            description: string;
+        };
+        aggregate: {
+            type: string;
+            description: string;
+        };
+        expand: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};

package/build/src/tools/schemas/analysis.js

@@ -0,0 +1,54 @@
+/**
+ * Tool input schemas for analysis-related operations
+ */
+export const analyzeCollectionDataSchema = {
+    type: "object",
+    properties: {
+        collection: {
+            type: "string",
+            description: "Collection name to analyze",
+        },
+        options: {
+            type: "object",
+            description: "Analysis options",
+            properties: {
+                sampleSize: {
+                    type: "number",
+                    description: "Number of records to sample for analysis (default: 100)",
+                },
+                fields: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Specific fields to analyze (if not provided, all fields will be analyzed)",
+                },
+            },
+        },
+    },
+    required: ["collection"],
+};
+export const queryCollectionSchema = {
+    type: "object",
+    properties: {
+        collection: {
+            type: "string",
+            description: "Collection name",
+        },
+        filter: {
+            type: "string",
+            description: "Filter expression",
+        },
+        sort: {
+            type: "string",
+            description: "Sort expression",
+        },
+        aggregate: {
+            type: "object",
+            description: "Aggregation settings",
+        },
+        expand: {
+            type: "string",
+            description: "Relations to expand",
+        },
+    },
+    required: ["collection"],
+};

package/build/src/tools/schemas/auth.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tool input schemas for authentication-related operations
+ */
+export declare const authenticateUserSchema: {
+    type: string;
+    properties: {
+        collection: {
+            type: string;
+            description: string;
+        };
+        email: {
+            type: string;
+            description: string;
+        };
+        password: {
+            type: string;
+            description: string;
+        };
+        autoRefreshThreshold: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare const createUserSchema: {
+    type: string;
+    properties: {
+        collection: {
+            type: string;
+            description: string;
+        };
+        email: {
+            type: string;
+            description: string;
+        };
+        password: {
+            type: string;
+            description: string;
+        };
+        passwordConfirm: {
+            type: string;
+            description: string;
+        };
+        verified: {
+            type: string;
+            description: string;
+        };
+        emailVisibility: {
+            type: string;
+            description: string;
+        };
+        additionalData: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};

package/build/src/tools/schemas/auth.js

@@ -0,0 +1,59 @@
+/**
+ * Tool input schemas for authentication-related operations
+ */
+export const authenticateUserSchema = {
+    type: "object",
+    properties: {
+        collection: {
+            type: "string",
+            description: "Auth collection name (default: 'users')",
+        },
+        email: {
+            type: "string",
+            description: "User email or identity field value",
+        },
+        password: {
+            type: "string",
+            description: "User password",
+        },
+        autoRefreshThreshold: {
+            type: "number",
+            description: "Time in seconds that will trigger token auto refresh before its expiration (default: 30 minutes)",
+        },
+    },
+    required: ["email", "password"],
+};
+export const createUserSchema = {
+    type: "object",
+    properties: {
+        collection: {
+            type: "string",
+            description: "Auth collection name (default: 'users')",
+        },
+        email: {
+            type: "string",
+            description: "User email",
+        },
+        password: {
+            type: "string",
+            description: "User password",
+        },
+        passwordConfirm: {
+            type: "string",
+            description: "Password confirmation (must match password)",
+        },
+        verified: {
+            type: "boolean",
+            description: "Whether the user is verified (default: false)",
+        },
+        emailVisibility: {
+            type: "boolean",
+            description: "Whether the user email is publicly visible (default: false)",
+        },
+        additionalData: {
+            type: "object",
+            description: "Additional user data fields specific to your auth collection",
+        },
+    },
+    required: ["email", "password", "passwordConfirm"],
+};