@daylight-labs/sharedb-mcp 0.1.0

package/dist/tools/auth.js

@@ -0,0 +1,126 @@
+import { api } from '../api-client.js';
+import { config } from '../config.js';
+async function getPostgRESTUrl(databaseId) {
+    const info = await api.databases.postgrest(databaseId);
+    return info.postgrestUrl;
+}
+export const authTools = [
+    {
+        name: 'get_api_endpoints',
+        description: 'Get all ShareDB API endpoints (Auth, PostgREST, Admin). Use this to get the correct URLs for implementing API calls in your app. Pass a database_id to see endpoints for specific tables.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                database_id: {
+                    type: 'string',
+                    description: 'Optional database ID to list specific table endpoints',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'get_auth_config',
+        description: 'Get authentication configuration including endpoints, JWT structure, and helper functions for integrating auth into your app',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+];
+export async function handleAuthTool(name, args) {
+    try {
+        switch (name) {
+            case 'get_api_endpoints': {
+                const databaseId = args.database_id;
+                let tableEndpoints = {};
+                let tableList = [];
+                let postgrestUrl = '<PostgREST URL - specify database_id to get actual URL>';
+                if (databaseId) {
+                    try {
+                        const [schema, url] = await Promise.all([
+                            api.databases.schema(databaseId),
+                            getPostgRESTUrl(databaseId),
+                        ]);
+                        tableList = schema.tables.map(t => t.table_name);
+                        postgrestUrl = url || '<PostgREST not running - use start_postgrest tool>';
+                        for (const tableName of tableList) {
+                            tableEndpoints[tableName] = {
+                                list: `GET ${postgrestUrl}/${tableName}`,
+                                getOne: `GET ${postgrestUrl}/${tableName}?id=eq.<uuid>`,
+                                create: `POST ${postgrestUrl}/${tableName}`,
+                                update: `PATCH ${postgrestUrl}/${tableName}?id=eq.<uuid>`,
+                                delete: `DELETE ${postgrestUrl}/${tableName}?id=eq.<uuid>`,
+                            };
+                        }
+                    }
+                    catch {
+                        // Database might not have tables yet
+                    }
+                }
+                const endpoints = {
+                    auth: {
+                        baseUrl: config.authApiUrl,
+                        endpoints: {
+                            register: `POST ${config.authApiUrl}/auth/register`,
+                            login: `POST ${config.authApiUrl}/auth/login`,
+                            refresh: `POST ${config.authApiUrl}/auth/refresh`,
+                            logout: `POST ${config.authApiUrl}/auth/logout`,
+                            me: `GET ${config.authApiUrl}/auth/me`,
+                        },
+                    },
+                    postgrest: {
+                        baseUrl: postgrestUrl,
+                        description: 'REST API auto-generated from your database schema (per-database)',
+                        authentication: 'Include JWT in Authorization header: Bearer <token>',
+                        tables: tableList.length > 0 ? tableEndpoints : {
+                            '<table_name>': {
+                                list: `GET ${postgrestUrl}/<table>`,
+                                getOne: `GET ${postgrestUrl}/<table>?id=eq.<uuid>`,
+                                create: `POST ${postgrestUrl}/<table>`,
+                                update: `PATCH ${postgrestUrl}/<table>?id=eq.<uuid>`,
+                                delete: `DELETE ${postgrestUrl}/<table>?id=eq.<uuid>`,
+                            },
+                        },
+                    },
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(endpoints, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_auth_config': {
+                const config = await api.auth.config();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(config, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown auth tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/data.d.ts

@@ -0,0 +1,127 @@
+export declare const dataTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database: {
+                type: string;
+                description: string;
+            };
+            table: {
+                type: string;
+                description: string;
+            };
+            rows: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            select?: undefined;
+            filter?: undefined;
+            order?: undefined;
+            limit?: undefined;
+            data?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database: {
+                type: string;
+                description: string;
+            };
+            table: {
+                type: string;
+                description: string;
+            };
+            select: {
+                type: string;
+                description: string;
+            };
+            filter: {
+                type: string;
+                description: string;
+            };
+            order: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            rows?: undefined;
+            data?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database: {
+                type: string;
+                description: string;
+            };
+            table: {
+                type: string;
+                description: string;
+            };
+            filter: {
+                type: string;
+                description: string;
+            };
+            data: {
+                type: string;
+                description: string;
+            };
+            rows?: undefined;
+            select?: undefined;
+            order?: undefined;
+            limit?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database: {
+                type: string;
+                description: string;
+            };
+            table: {
+                type: string;
+                description: string;
+            };
+            filter: {
+                type: string;
+                description: string;
+            };
+            rows?: undefined;
+            select?: undefined;
+            order?: undefined;
+            limit?: undefined;
+            data?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function handleDataTool(name: string, args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/data.js

@@ -0,0 +1,290 @@
+import { config } from '../config.js';
+import { api } from '../api-client.js';
+export const dataTools = [
+    {
+        name: 'insert_rows',
+        description: 'Insert one or more rows into a table via PostgREST. Use this to add seed data or default data to tables.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                database: {
+                    type: 'string',
+                    description: 'The database name or ID to operate on',
+                },
+                table: {
+                    type: 'string',
+                    description: 'The table name to insert into',
+                },
+                rows: {
+                    type: 'array',
+                    items: { type: 'object' },
+                    description: 'Array of row objects to insert. Each object should have column names as keys.',
+                },
+            },
+            required: ['database', 'table', 'rows'],
+        },
+    },
+    {
+        name: 'query_rows',
+        description: 'Query rows from a table via PostgREST. Supports filtering, ordering, and pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                database: {
+                    type: 'string',
+                    description: 'The database name or ID to operate on',
+                },
+                table: {
+                    type: 'string',
+                    description: 'The table name to query',
+                },
+                select: {
+                    type: 'string',
+                    description: 'Columns to select (default: *). Example: "id,name,created_at"',
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filter conditions as key-value pairs. Example: { "status": "eq.active", "price": "gt.100" }',
+                },
+                order: {
+                    type: 'string',
+                    description: 'Order by column(s). Example: "created_at.desc" or "name.asc,id.desc"',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of rows to return',
+                },
+            },
+            required: ['database', 'table'],
+        },
+    },
+    {
+        name: 'update_rows',
+        description: 'Update rows in a table via PostgREST. Requires a filter to identify which rows to update.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                database: {
+                    type: 'string',
+                    description: 'The database name or ID to operate on',
+                },
+                table: {
+                    type: 'string',
+                    description: 'The table name to update',
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filter conditions to identify rows to update. Example: { "id": "eq.uuid-here" }',
+                },
+                data: {
+                    type: 'object',
+                    description: 'Object with column names and new values to set',
+                },
+            },
+            required: ['database', 'table', 'filter', 'data'],
+        },
+    },
+    {
+        name: 'delete_rows',
+        description: 'Delete rows from a table via PostgREST. Requires a filter to identify which rows to delete.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                database: {
+                    type: 'string',
+                    description: 'The database name or ID to operate on',
+                },
+                table: {
+                    type: 'string',
+                    description: 'The table name to delete from',
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filter conditions to identify rows to delete. Example: { "id": "eq.uuid-here" }',
+                },
+            },
+            required: ['database', 'table', 'filter'],
+        },
+    },
+];
+async function getPostgRESTUrl(database) {
+    const info = await api.databases.postgrest(database);
+    if (!info.postgrestUrl) {
+        throw new Error(`PostgREST is not available for database "${database}". Status: ${info.status}`);
+    }
+    return info.postgrestUrl;
+}
+async function postgrestRequest(postgrestUrl, path, options = {}) {
+    try {
+        const response = await fetch(`${postgrestUrl}${path}`, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.token}`,
+                Prefer: 'return=representation',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            return { data: null, error: error.message || error.details || `HTTP ${response.status}` };
+        }
+        const data = await response.json().catch(() => null);
+        return { data };
+    }
+    catch (error) {
+        return { data: null, error: error instanceof Error ? error.message : 'Request failed' };
+    }
+}
+function buildFilterQuery(filter) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filter)) {
+        params.append(key, value);
+    }
+    return params.toString();
+}
+export async function handleDataTool(name, args) {
+    try {
+        const database = args.database;
+        if (!database) {
+            return {
+                content: [{ type: 'text', text: 'Error: database parameter is required' }],
+                isError: true,
+            };
+        }
+        const postgrestUrl = await getPostgRESTUrl(database);
+        switch (name) {
+            case 'insert_rows': {
+                const table = args.table;
+                const rows = args.rows;
+                const { data, error } = await postgrestRequest(postgrestUrl, `/${table}`, {
+                    method: 'POST',
+                    body: JSON.stringify(rows),
+                });
+                if (error) {
+                    return {
+                        content: [{ type: 'text', text: `Error inserting rows: ${error}` }],
+                        isError: true,
+                    };
+                }
+                const inserted = Array.isArray(data) ? data : [data];
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Successfully inserted ${inserted.length} row(s) into ${table}:\n\n${JSON.stringify(inserted, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            case 'query_rows': {
+                const table = args.table;
+                const select = args.select || '*';
+                const filter = args.filter || {};
+                const order = args.order;
+                const limit = args.limit;
+                const params = new URLSearchParams();
+                params.append('select', select);
+                for (const [key, value] of Object.entries(filter)) {
+                    params.append(key, value);
+                }
+                if (order)
+                    params.append('order', order);
+                if (limit)
+                    params.append('limit', limit.toString());
+                const { data, error } = await postgrestRequest(postgrestUrl, `/${table}?${params.toString()}`);
+                if (error) {
+                    return {
+                        content: [{ type: 'text', text: `Error querying rows: ${error}` }],
+                        isError: true,
+                    };
+                }
+                const rows = Array.isArray(data) ? data : [];
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Found ${rows.length} row(s) in ${table}:\n\n${JSON.stringify(rows, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            case 'update_rows': {
+                const table = args.table;
+                const filter = args.filter;
+                const updateData = args.data;
+                if (!filter || Object.keys(filter).length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'Error: filter is required to update rows (to prevent accidental mass updates)' }],
+                        isError: true,
+                    };
+                }
+                const query = buildFilterQuery(filter);
+                const { data, error } = await postgrestRequest(postgrestUrl, `/${table}?${query}`, {
+                    method: 'PATCH',
+                    body: JSON.stringify(updateData),
+                });
+                if (error) {
+                    return {
+                        content: [{ type: 'text', text: `Error updating rows: ${error}` }],
+                        isError: true,
+                    };
+                }
+                const updated = Array.isArray(data) ? data : [data];
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Successfully updated ${updated.length} row(s) in ${table}:\n\n${JSON.stringify(updated, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            case 'delete_rows': {
+                const table = args.table;
+                const filter = args.filter;
+                if (!filter || Object.keys(filter).length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'Error: filter is required to delete rows (to prevent accidental mass deletes)' }],
+                        isError: true,
+                    };
+                }
+                const query = buildFilterQuery(filter);
+                const { data, error } = await postgrestRequest(postgrestUrl, `/${table}?${query}`, {
+                    method: 'DELETE',
+                });
+                if (error) {
+                    return {
+                        content: [{ type: 'text', text: `Error deleting rows: ${error}` }],
+                        isError: true,
+                    };
+                }
+                const deleted = Array.isArray(data) ? data : data ? [data] : [];
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Successfully deleted ${deleted.length} row(s) from ${table}`,
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown data tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/migrations.d.ts

@@ -0,0 +1,114 @@
+export declare const migrationTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database_id: {
+                type: string;
+                description: string;
+            };
+            operation: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            params: {
+                type: string;
+                description: string;
+            };
+            description?: undefined;
+            change_id?: undefined;
+            migration_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database_id: {
+                type: string;
+                description: string;
+            };
+            operation?: undefined;
+            params?: undefined;
+            description?: undefined;
+            change_id?: undefined;
+            migration_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database_id: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            operation?: undefined;
+            params?: undefined;
+            change_id?: undefined;
+            migration_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database_id: {
+                type: string;
+                description: string;
+            };
+            change_id: {
+                type: string;
+                description: string;
+            };
+            operation?: undefined;
+            params?: undefined;
+            description?: undefined;
+            migration_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            database_id: {
+                type: string;
+                description: string;
+            };
+            migration_id: {
+                type: string;
+                description: string;
+            };
+            operation?: undefined;
+            params?: undefined;
+            description?: undefined;
+            change_id?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function handleMigrationTool(name: string, args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;