@fadlee/pocketbase-mcp 1.0.0

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

@@ -0,0 +1,51 @@
+import { handlePocketBaseError } from "../../utils/errors.js";
+import { createJsonResponse } from "../../utils/response.js";
+/**
+ * Authenticate a user and get auth token
+ */
+export function createAuthenticateUserHandler(pb) {
+    return async (args) => {
+        try {
+            const collection = args.collection || "users";
+            const autoRefreshThreshold = args.autoRefreshThreshold || 1800; // 30 minutes
+            const result = await pb
+                .collection(collection)
+                .authWithPassword(args.email, args.password, {
+                autoRefreshThreshold,
+            });
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("authenticate user", error);
+        }
+    };
+}
+/**
+ * Create a new user account
+ */
+export function createCreateUserHandler(pb) {
+    return async (args) => {
+        try {
+            const collection = args.collection || "users";
+            const userData = {
+                email: args.email,
+                password: args.password,
+                passwordConfirm: args.passwordConfirm,
+            };
+            // Add optional fields
+            if (args.verified !== undefined)
+                userData.verified = args.verified;
+            if (args.emailVisibility !== undefined)
+                userData.emailVisibility = args.emailVisibility;
+            // Add any additional data fields
+            if (args.additionalData) {
+                Object.assign(userData, args.additionalData);
+            }
+            const result = await pb.collection(collection).create(userData);
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("create user", error);
+        }
+    };
+}

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

@@ -0,0 +1,22 @@
+import type PocketBase from "pocketbase";
+import type { ToolHandler } from "../../types/index.js";
+/**
+ * Create a new collection in PocketBase
+ */
+export declare function createCreateCollectionHandler(pb: PocketBase): ToolHandler;
+/**
+ * Delete a collection from PocketBase
+ */
+export declare function createDeleteCollectionHandler(pb: PocketBase): ToolHandler;
+/**
+ * Get schema details for a collection
+ */
+export declare function createGetCollectionSchemaHandler(pb: PocketBase): ToolHandler;
+/**
+ * List all collections
+ */
+export declare function createListCollectionsHandler(pb: PocketBase): ToolHandler;
+/**
+ * Truncate all records from a collection
+ */
+export declare function createTruncateCollectionHandler(pb: PocketBase): ToolHandler;

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

@@ -0,0 +1,82 @@
+import { handlePocketBaseError } from "../../utils/errors.js";
+import { createJsonResponse } from "../../utils/response.js";
+/**
+ * Create a new collection in PocketBase
+ */
+export function createCreateCollectionHandler(pb) {
+    return async (args) => {
+        try {
+            const result = await pb.collections.create({
+                ...args,
+            });
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("create collection", error);
+        }
+    };
+}
+/**
+ * Delete a collection from PocketBase
+ */
+export function createDeleteCollectionHandler(pb) {
+    return async (args) => {
+        try {
+            await pb.collections.delete(args.collection);
+            return createJsonResponse({
+                success: true,
+                message: `Collection '${args.collection}' deleted successfully`
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("delete collection", error);
+        }
+    };
+}
+/**
+ * Get schema details for a collection
+ */
+export function createGetCollectionSchemaHandler(pb) {
+    return async (args) => {
+        try {
+            const result = await pb.collections.getOne(args.collection);
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("get collection schema", error);
+        }
+    };
+}
+/**
+ * List all collections
+ */
+export function createListCollectionsHandler(pb) {
+    return async (args) => {
+        try {
+            const result = await pb.collections.getFullList({
+                sort: args.sort || "-created"
+            });
+            return createJsonResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("list collections", error);
+        }
+    };
+}
+/**
+ * Truncate all records from a collection
+ */
+export function createTruncateCollectionHandler(pb) {
+    return async (args) => {
+        try {
+            await pb.collections.truncate(args.collection);
+            return createJsonResponse({
+                success: true,
+                message: `All records in collection '${args.collection}' have been deleted`
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("truncate collection", error);
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import type PocketBase from 'pocketbase';
+import type { ToolHandler } from '../../types/index.js';
+export declare function createUploadFileHandler(pb: PocketBase): ToolHandler;
+export declare function createDownloadFileHandler(pb: PocketBase): ToolHandler;
+export declare function createUploadFileFromUrlHandler(pb: PocketBase): ToolHandler;

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

@@ -0,0 +1,124 @@
+import { createJsonResponse } from '../../utils/response.js';
+import { handlePocketBaseError } from '../../utils/errors.js';
+export function createUploadFileHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, recordId, fileField, fileContent, fileName } = args;
+            // Create a Blob from the file content string
+            const blob = new Blob([fileContent]);
+            // Create a FormData object and append the file
+            const formData = new FormData();
+            formData.append(fileField, blob, fileName);
+            // Update the record with the file
+            const record = await pb.collection(collection).update(recordId, formData);
+            return createJsonResponse({
+                success: true,
+                message: `File '${fileName}' uploaded successfully to record ${recordId}`,
+                record
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("upload file", error);
+        }
+    };
+}
+export function createDownloadFileHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, recordId, fileField } = args;
+            // Fetch the record to get the filename associated with the file field
+            const record = await pb.collection(collection).getOne(recordId);
+            // Ensure the file field exists and has a value
+            const fileName = record[fileField];
+            if (!fileName || typeof fileName !== 'string') {
+                throw new Error(`File field '${fileField}' not found or empty on record ${recordId}`);
+            }
+            // Get the file URL using the filename from the record
+            const fileUrl = pb.files.getUrl(record, fileName);
+            return createJsonResponse({
+                success: true,
+                fileName,
+                fileUrl,
+                message: `Download URL for ${fileName}: ${fileUrl}`
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("get download URL", error);
+        }
+    };
+}
+export function createUploadFileFromUrlHandler(pb) {
+    return async (args) => {
+        try {
+            const { collection, recordId, fileField, url, fileName } = args;
+            // Download the file from the URL
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to download file from URL: ${response.status} ${response.statusText}`);
+            }
+            // Get the file content as ArrayBuffer
+            const arrayBuffer = await response.arrayBuffer();
+            // Determine the filename
+            let finalFileName = fileName;
+            if (!finalFileName) {
+                // Extract filename from URL
+                const urlPath = new URL(url).pathname;
+                finalFileName = urlPath.split('/').pop() || 'downloaded-file';
+                // If no extension, try to get from Content-Type header
+                if (!finalFileName.includes('.')) {
+                    const contentType = response.headers.get('content-type');
+                    if (contentType) {
+                        const extension = getExtensionFromMimeType(contentType);
+                        if (extension) {
+                            finalFileName += `.${extension}`;
+                        }
+                    }
+                }
+            }
+            // Create a Blob from the downloaded content
+            const blob = new Blob([arrayBuffer]);
+            // Create a FormData object and append the file
+            const formData = new FormData();
+            formData.append(fileField, blob, finalFileName);
+            // Update the record with the file
+            const record = await pb.collection(collection).update(recordId, formData);
+            return createJsonResponse({
+                success: true,
+                message: `File '${finalFileName}' uploaded successfully from URL to record ${recordId}`,
+                fileName: finalFileName,
+                sourceUrl: url,
+                record
+            });
+        }
+        catch (error) {
+            throw handlePocketBaseError("upload file from URL", error);
+        }
+    };
+}
+// Helper function to get file extension from MIME type
+function getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+        'image/jpeg': 'jpg',
+        'image/png': 'png',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'image/svg+xml': 'svg',
+        'text/plain': 'txt',
+        'text/html': 'html',
+        'text/css': 'css',
+        'text/javascript': 'js',
+        'application/json': 'json',
+        'application/pdf': 'pdf',
+        'application/zip': 'zip',
+        'application/x-zip-compressed': 'zip',
+        'application/msword': 'doc',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+        'application/vnd.ms-excel': 'xls',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        'video/mp4': 'mp4',
+        'video/webm': 'webm',
+        'audio/mpeg': 'mp3',
+        'audio/wav': 'wav'
+    };
+    return mimeToExt[mimeType.toLowerCase()] || null;
+}

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

@@ -0,0 +1,10 @@
+import type PocketBase from "pocketbase";
+import type { ToolHandler } from "../../types/index.js";
+/**
+ * Generate a PocketBase schema based on TypeScript interfaces or database diagram
+ */
+export declare function createGeneratePbSchemaHandler(pb: PocketBase): ToolHandler;
+/**
+ * Generate TypeScript interfaces from PocketBase collections
+ */
+export declare function createGenerateTypescriptInterfacesHandler(pb: PocketBase): ToolHandler;

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

@@ -0,0 +1,201 @@
+import { handlePocketBaseError } from "../../utils/errors.js";
+import { createTextResponse, createJsonResponse } from "../../utils/response.js";
+import { analyzeTypeScriptForSchema, toPascalCase, mapPocketBaseTypeToTypeScript } from "../../utils/typescript.js";
+/**
+ * Generate a PocketBase schema based on TypeScript interfaces or database diagram
+ */
+export function createGeneratePbSchemaHandler(pb) {
+    return async (args) => {
+        try {
+            const { sourceCode, options = {} } = args;
+            const includeAuth = options.includeAuthentication ?? true;
+            const includeTimestamps = options.includeTimestamps ?? true;
+            // Analyze TypeScript source code
+            const interfaces = analyzeTypeScriptForSchema(sourceCode, options);
+            if (interfaces.length === 0) {
+                return createTextResponse("No TypeScript interfaces found in the provided source code.");
+            }
+            const collections = [];
+            // Generate collections from interfaces
+            for (const iface of interfaces) {
+                const fields = [];
+                // Add standard fields if requested
+                if (includeTimestamps) {
+                    fields.push({
+                        name: "created",
+                        type: "autodate",
+                        required: false,
+                        system: true,
+                        onCreate: true,
+                        onUpdate: false,
+                    }, {
+                        name: "updated",
+                        type: "autodate",
+                        required: false,
+                        system: true,
+                        onCreate: true,
+                        onUpdate: true,
+                    });
+                }
+                // Convert interface properties to PocketBase fields
+                for (const prop of iface.properties) {
+                    const field = {
+                        name: prop.name,
+                        type: mapTypeScriptToPocketBase(prop.type),
+                        required: !prop.optional,
+                    };
+                    // Add type-specific options
+                    if (field.type === "text" && prop.type.includes("email")) {
+                        field.type = "email";
+                    }
+                    else if (field.type === "text" && prop.type.includes("url")) {
+                        field.type = "url";
+                    }
+                    else if (field.type === "text" && prop.type.includes("Date")) {
+                        field.type = "date";
+                    }
+                    fields.push(field);
+                }
+                const collection = {
+                    name: iface.name.toLowerCase(),
+                    type: "base",
+                    fields,
+                    listRule: "",
+                    viewRule: "",
+                    createRule: "",
+                    updateRule: "",
+                    deleteRule: "",
+                };
+                collections.push(collection);
+            }
+            // Add authentication collection if requested
+            if (includeAuth) {
+                const authCollection = {
+                    name: "users",
+                    type: "auth",
+                    fields: [
+                        {
+                            name: "name",
+                            type: "text",
+                            required: false,
+                        },
+                        {
+                            name: "avatar",
+                            type: "file",
+                            required: false,
+                            options: {
+                                maxSelect: 1,
+                                maxSize: 5242880,
+                                mimeTypes: ["image/jpeg", "image/png", "image/svg+xml", "image/gif"],
+                            },
+                        },
+                    ],
+                    listRule: "id = @request.auth.id",
+                    viewRule: "id = @request.auth.id",
+                    createRule: "",
+                    updateRule: "id = @request.auth.id",
+                    deleteRule: "id = @request.auth.id",
+                };
+                collections.unshift(authCollection);
+            }
+            const schema = {
+                collections,
+                generatedAt: new Date().toISOString(),
+                source: "TypeScript interfaces",
+            };
+            return createJsonResponse(schema);
+        }
+        catch (error) {
+            throw handlePocketBaseError("generate PocketBase schema", error);
+        }
+    };
+}
+/**
+ * Generate TypeScript interfaces from PocketBase collections
+ */
+export function createGenerateTypescriptInterfacesHandler(pb) {
+    return async (args = {}) => {
+        try {
+            const { collections: targetCollections = [], options = {} } = args;
+            const includeRelations = options.includeRelations ?? true;
+            // Get all collections or specific ones
+            const allCollections = await pb.collections.getFullList();
+            const collectionsToProcess = targetCollections.length > 0
+                ? allCollections.filter(c => targetCollections.includes(c.name))
+                : allCollections;
+            const interfaces = [];
+            // Generate base record interface
+            interfaces.push("// Base record interface");
+            interfaces.push("export interface BaseRecord {");
+            interfaces.push("  id: string;");
+            interfaces.push("  created: string;");
+            interfaces.push("  updated: string;");
+            interfaces.push("}");
+            interfaces.push("");
+            // Generate interfaces for each collection
+            for (const collection of collectionsToProcess) {
+                const interfaceName = toPascalCase(collection.name);
+                const fields = collection.fields || [];
+                interfaces.push(`// ${collection.name} collection`);
+                interfaces.push(`export interface ${interfaceName} extends BaseRecord {`);
+                for (const field of fields) {
+                    if (field.system)
+                        continue; // Skip system fields
+                    const fieldType = mapPocketBaseTypeToTypeScript(field.type, field);
+                    const optional = !field.required ? "?" : "";
+                    if (includeRelations && field.type === "relation") {
+                        const relatedCollection = field.options?.collectionId;
+                        if (relatedCollection) {
+                            const relatedCollectionName = allCollections.find(c => c.id === relatedCollection)?.name;
+                            if (relatedCollectionName) {
+                                const relatedInterface = toPascalCase(relatedCollectionName);
+                                const isMultiple = field.options?.maxSelect !== 1;
+                                interfaces.push(`  ${field.name}${optional}: ${isMultiple ? `${relatedInterface}[]` : relatedInterface};`);
+                                continue;
+                            }
+                        }
+                    }
+                    interfaces.push(`  ${field.name}${optional}: ${fieldType};`);
+                }
+                interfaces.push("}");
+                interfaces.push("");
+            }
+            // Add utility types
+            interfaces.push("// Utility types");
+            interfaces.push("export type RecordId = string;");
+            interfaces.push("export type RecordTimestamp = string;");
+            interfaces.push("");
+            // Add collection names type
+            const collectionNames = collectionsToProcess.map(c => `"${c.name}"`).join(" | ");
+            interfaces.push(`export type CollectionName = ${collectionNames};`);
+            const result = interfaces.join("\n");
+            return createTextResponse(result);
+        }
+        catch (error) {
+            throw handlePocketBaseError("generate TypeScript interfaces", error);
+        }
+    };
+}
+/**
+ * Helper function to map TypeScript types to PocketBase field types
+ */
+function mapTypeScriptToPocketBase(tsType) {
+    const type = tsType.toLowerCase();
+    if (type.includes("string"))
+        return "text";
+    if (type.includes("number"))
+        return "number";
+    if (type.includes("boolean"))
+        return "bool";
+    if (type.includes("date"))
+        return "date";
+    if (type.includes("email"))
+        return "email";
+    if (type.includes("url"))
+        return "url";
+    if (type.includes("[]"))
+        return "json";
+    if (type.includes("object") || type.includes("{"))
+        return "json";
+    return "text"; // Default fallback
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Tool handlers registry - exports all handler creation functions
+ */
+export { createCreateCollectionHandler, createDeleteCollectionHandler, createGetCollectionSchemaHandler, createListCollectionsHandler, createTruncateCollectionHandler, } from "./collection.js";
+export { createCreateRecordHandler, createListRecordsHandler, createUpdateRecordHandler, createDeleteRecordHandler, } from "./record.js";
+export { createAuthenticateUserHandler, createCreateUserHandler, } from "./auth.js";
+export { createAnalyzeCollectionDataHandler, createQueryCollectionHandler, } from "./analysis.js";
+export { createMigrateCollectionHandler, createBackupDatabaseHandler, createImportDataHandler, createManageIndexesHandler, } from "./migration.js";
+export { createGeneratePbSchemaHandler, createGenerateTypescriptInterfacesHandler, } from "./generation.js";
+export { createUploadFileHandler, createDownloadFileHandler, createUploadFileFromUrlHandler } from './file.js';

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

@@ -0,0 +1,17 @@
+/**
+ * Tool handlers registry - exports all handler creation functions
+ */
+// Collection handlers
+export { createCreateCollectionHandler, createDeleteCollectionHandler, createGetCollectionSchemaHandler, createListCollectionsHandler, createTruncateCollectionHandler, } from "./collection.js";
+// Record handlers
+export { createCreateRecordHandler, createListRecordsHandler, createUpdateRecordHandler, createDeleteRecordHandler, } from "./record.js";
+// Auth handlers
+export { createAuthenticateUserHandler, createCreateUserHandler, } from "./auth.js";
+// Analysis handlers
+export { createAnalyzeCollectionDataHandler, createQueryCollectionHandler, } from "./analysis.js";
+// Migration handlers
+export { createMigrateCollectionHandler, createBackupDatabaseHandler, createImportDataHandler, createManageIndexesHandler, } from "./migration.js";
+// Generation handlers
+export { createGeneratePbSchemaHandler, createGenerateTypescriptInterfacesHandler, } from "./generation.js";
+// File handlers
+export { createUploadFileHandler, createDownloadFileHandler, createUploadFileFromUrlHandler } from './file.js';

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

@@ -0,0 +1,18 @@
+import type PocketBase from "pocketbase";
+import type { ToolHandler } from "../../types/index.js";
+/**
+ * Migrate collection schema with data preservation
+ */
+export declare function createMigrateCollectionHandler(pb: PocketBase): ToolHandler;
+/**
+ * Create a backup of the PocketBase database
+ */
+export declare function createBackupDatabaseHandler(pb: PocketBase): ToolHandler;
+/**
+ * Import data into a collection
+ */
+export declare function createImportDataHandler(pb: PocketBase): ToolHandler;
+/**
+ * Manage collection indexes
+ */
+export declare function createManageIndexesHandler(pb: PocketBase): ToolHandler;