@fadlee/pocketbase-mcp 1.0.0

package/build/src/utils/errors.js

@@ -0,0 +1,35 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Create a standardized MCP error with proper error message formatting
+ */
+export function createMcpError(code, message, error) {
+    const errorMessage = error
+        ? `${message}: ${error instanceof Error ? error.message : JSON.stringify(error)}`
+        : message;
+    return new McpError(code, errorMessage);
+}
+/**
+ * Handle and format errors from PocketBase operations
+ */
+export function handlePocketBaseError(operation, error) {
+    const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+    return new McpError(ErrorCode.InternalError, `Failed to ${operation}: ${errorMessage}`);
+}
+/**
+ * Validate required parameters and throw appropriate errors
+ */
+export function validateRequiredParams(params, requiredFields) {
+    for (const field of requiredFields) {
+        if (params[field] === undefined || params[field] === null) {
+            throw new McpError(ErrorCode.InvalidParams, `Required parameter '${field}' is missing`);
+        }
+    }
+}
+/**
+ * Validate enum values
+ */
+export function validateEnumValue(value, allowedValues, fieldName) {
+    if (value && !allowedValues.includes(value)) {
+        throw new McpError(ErrorCode.InvalidParams, `Invalid value for ${fieldName}. Allowed values: ${allowedValues.join(", ")}`);
+    }
+}

package/build/src/utils/response.d.ts

@@ -0,0 +1,23 @@
+import type { ToolResponse } from "../types/index.js";
+/**
+ * Create a standardized tool response with JSON content
+ */
+export declare function createJsonResponse(data: any): ToolResponse;
+/**
+ * Create a standardized tool response with plain text content
+ */
+export declare function createTextResponse(text: string): ToolResponse;
+/**
+ * Create a success response with a message and optional data
+ */
+export declare function createSuccessResponse(message: string, data?: any): ToolResponse;
+/**
+ * Format CSV data for export responses
+ */
+export declare function formatCsvData(collections: Array<[
+    string,
+    {
+        schema: any[];
+        records: Record<string, any>[];
+    }
+]>): ToolResponse;

package/build/src/utils/response.js

@@ -0,0 +1,62 @@
+/**
+ * Create a standardized tool response with JSON content
+ */
+export function createJsonResponse(data) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+/**
+ * Create a standardized tool response with plain text content
+ */
+export function createTextResponse(text) {
+    return {
+        content: [
+            {
+                type: "text",
+                text,
+            },
+        ],
+    };
+}
+/**
+ * Create a success response with a message and optional data
+ */
+export function createSuccessResponse(message, data) {
+    const response = { message };
+    if (data !== undefined) {
+        Object.assign(response, { data });
+    }
+    return createJsonResponse(response);
+}
+/**
+ * Format CSV data for export responses
+ */
+export function formatCsvData(collections) {
+    let csv = "";
+    for (const [collectionName, data] of collections) {
+        csv += `Collection: ${collectionName}\n`;
+        csv += `Schema:\n${JSON.stringify(data.schema, null, 2)}\n`;
+        csv += "Records:\n";
+        if (data.records.length > 0) {
+            const headers = Object.keys(data.records[0]);
+            csv += `${headers.join(",")}\n`;
+            data.records.forEach((record) => {
+                const values = headers.map((header) => {
+                    const value = record[header];
+                    return typeof value === "string" && value.includes(",")
+                        ? `"${value.replace(/"/g, '""')}"`
+                        : String(value || "");
+                });
+                csv += `${values.join(",")}\n`;
+            });
+        }
+        csv += "\n";
+    }
+    return createTextResponse(csv);
+}

package/build/src/utils/typescript.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Utility functions for TypeScript code parsing and generation
+ */
+/**
+ * Convert string to PascalCase
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Convert string to PascalCase (alias for backward compatibility)
+ */
+export declare function pascalCase(str: string): string;
+/**
+ * Map PocketBase field types to TypeScript types
+ */
+export declare function mapPbTypeToTsType(pbType: string, options?: any): string;
+/**
+ * Map PocketBase field types to TypeScript types (alias for backward compatibility)
+ */
+export declare function mapPocketBaseTypeToTypeScript(pbType: string, options?: any): string;
+/**
+ * Analyze TypeScript source code to extract interface definitions
+ * This is a simplified parser for basic interface extraction
+ */
+export declare function analyzeTypeScriptForSchema(sourceCode: string, options: any): any;

package/build/src/utils/typescript.js

@@ -0,0 +1,130 @@
+/**
+ * Utility functions for TypeScript code parsing and generation
+ */
+/**
+ * Convert string to PascalCase
+ */
+export function toPascalCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]/g, " ")
+        .split(" ")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+}
+/**
+ * Convert string to PascalCase (alias for backward compatibility)
+ */
+export function pascalCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]/g, " ")
+        .split(" ")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+}
+/**
+ * Map PocketBase field types to TypeScript types
+ */
+export function mapPbTypeToTsType(pbType, options) {
+    switch (pbType) {
+        case "text":
+        case "email":
+        case "url":
+        case "editor":
+        case "select":
+            return "string";
+        case "number":
+            return "number";
+        case "bool":
+            return "boolean";
+        case "date":
+        case "autodate":
+            return "string"; // ISO date string
+        case "json":
+            return "any";
+        case "file":
+            return options?.multiple ? "string[]" : "string";
+        case "relation":
+            return options?.multiple ? "string[]" : "string";
+        default:
+            return "any";
+    }
+}
+/**
+ * Map PocketBase field types to TypeScript types (alias for backward compatibility)
+ */
+export function mapPocketBaseTypeToTypeScript(pbType, options) {
+    return mapPbTypeToTsType(pbType, options);
+}
+/**
+ * Analyze TypeScript source code to extract interface definitions
+ * This is a simplified parser for basic interface extraction
+ */
+export function analyzeTypeScriptForSchema(sourceCode, options) {
+    const collections = [];
+    // Simple regex-based parsing for interface definitions
+    const interfaceRegex = /interface\s+(\w+)\s*{([^}]*)}/g;
+    let match;
+    match = interfaceRegex.exec(sourceCode);
+    while (match !== null) {
+        const interfaceName = match[1];
+        const interfaceBody = match[2];
+        // Skip if not a collection-like interface
+        if (!interfaceName.toLowerCase().includes("collection") &&
+            !interfaceName.toLowerCase().includes("record") &&
+            !interfaceName.toLowerCase().includes("model")) {
+            continue;
+        }
+        const fields = [];
+        // Parse fields from interface body
+        const fieldRegex = /(\w+)\??:\s*([^;\n]+)/g;
+        let fieldMatch;
+        fieldMatch = fieldRegex.exec(interfaceBody);
+        while (fieldMatch !== null) {
+            const fieldName = fieldMatch[1];
+            const fieldType = fieldMatch[2].trim();
+            // Skip common metadata fields
+            if (["id", "created", "updated", "collectionId", "collectionName"].includes(fieldName)) {
+                continue;
+            }
+            fields.push({
+                name: fieldName,
+                type: mapTsTypeToPbType(fieldType),
+                required: !fieldMatch[0].includes("?"),
+            });
+            fieldMatch = fieldRegex.exec(interfaceBody);
+        }
+        if (fields.length > 0) {
+            collections.push({
+                name: interfaceName.toLowerCase().replace(/collection|record|model/gi, ""),
+                type: "base",
+                fields,
+            });
+        }
+        match = interfaceRegex.exec(sourceCode);
+    }
+    return collections;
+}
+/**
+ * Map TypeScript types back to PocketBase field types
+ */
+function mapTsTypeToPbType(tsType) {
+    const cleanType = tsType.replace(/\[\]$/, "").trim();
+    switch (cleanType) {
+        case "string":
+            return "text";
+        case "number":
+            return "number";
+        case "boolean":
+            return "bool";
+        case "Date":
+            return "date";
+        case "any":
+        case "object":
+            return "json";
+        default:
+            if (tsType.includes("[]")) {
+                return "relation"; // Assume array types are relations
+            }
+            return "text";
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@fadlee/pocketbase-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "PocketBase MCP Server for integration with MCP-compatible applications",
+  "main": "build/src/index.js",
+  "bin": "build/src/index.js",
+  "files": [    "build/",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": {
+    "name": "fadlee",
+    "email": "fad.lee@hotmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fadlee/pocketbase-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fadlee/pocketbase-mcp/issues"
+  },
+  "homepage": "https://github.com/fadlee/pocketbase-mcp#readme",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('build/src/index.js', '755')\"",
+    "start": "node build/src/index.js",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build",
+    "release": "npm version patch --no-git-tag-version && npm publish",
+    "release:minor": "npm version minor --no-git-tag-version && npm publish",
+    "release:major": "npm version major --no-git-tag-version && npm publish"
+  },
+  "keywords": [
+    "pocketbase",
+    "mcp",
+    "model-context-protocol",
+    "database",
+    "api",
+    "server"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.15.1",
+    "dotenv": "^16.6.1",
+    "pocketbase": "^0.26.1",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/node": "^20.19.7",
+    "@types/yargs": "^17.0.33",
+    "typescript": "^5.8.3"
+  }
+}