@nexus-lab/create-mcp-server 0.1.1 → 0.3.0

package/templates/database/src/tools.ts

@@ -0,0 +1,304 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { eq, like, or, sql } from "drizzle-orm";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import { db as defaultDb } from "./db.js";
+import { notes } from "./schema.js";
+import type * as schema from "./schema.js";
+
+type Db = BetterSQLite3Database<typeof schema>;
+
+/**
+ * Register all CRUD tools on the given MCP server.
+ * Accepts an optional database override for testing.
+ */
+export function registerTools(server: McpServer, database?: Db): void {
+  const db = database ?? defaultDb;
+
+  // ── create-note ──────────────────────────────────────────────────────
+  server.tool(
+    "create-note",
+    "Create a new note with a title and optional content",
+    {
+      title: z.string().min(1).max(500).describe("Title of the note"),
+      content: z
+        .string()
+        .max(50_000)
+        .default("")
+        .describe("Body content of the note"),
+    },
+    async ({ title, content }) => {
+      try {
+        const result = db
+          .insert(notes)
+          .values({ title, content })
+          .returning()
+          .get();
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to create note: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  // ── list-notes ───────────────────────────────────────────────────────
+  server.tool(
+    "list-notes",
+    "List all notes, optionally filtered by a search query on title or content",
+    {
+      query: z
+        .string()
+        .optional()
+        .describe("Search term to filter notes by title or content"),
+    },
+    async ({ query }) => {
+      try {
+        let result;
+
+        if (query) {
+          const pattern = `%${query}%`;
+          result = db
+            .select()
+            .from(notes)
+            .where(
+              or(like(notes.title, pattern), like(notes.content, pattern)),
+            )
+            .all();
+        } else {
+          result = db.select().from(notes).all();
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to list notes: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  // ── get-note ─────────────────────────────────────────────────────────
+  server.tool(
+    "get-note",
+    "Retrieve a single note by its ID",
+    {
+      id: z.number().int().positive().describe("ID of the note to retrieve"),
+    },
+    async ({ id }) => {
+      try {
+        const result = db
+          .select()
+          .from(notes)
+          .where(eq(notes.id, id))
+          .get();
+
+        if (!result) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Note with ID ${id} not found`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to get note: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  // ── update-note ──────────────────────────────────────────────────────
+  server.tool(
+    "update-note",
+    "Update an existing note by ID. Provide at least one of title or content.",
+    {
+      id: z.number().int().positive().describe("ID of the note to update"),
+      title: z
+        .string()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("New title for the note"),
+      content: z
+        .string()
+        .max(50_000)
+        .optional()
+        .describe("New content for the note"),
+    },
+    async ({ id, title, content }) => {
+      try {
+        if (title === undefined && content === undefined) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "At least one of 'title' or 'content' must be provided",
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // Check existence first
+        const existing = db
+          .select()
+          .from(notes)
+          .where(eq(notes.id, id))
+          .get();
+
+        if (!existing) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Note with ID ${id} not found`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const updates: Record<string, unknown> = {
+          updatedAt: sql`datetime('now')`,
+        };
+        if (title !== undefined) updates.title = title;
+        if (content !== undefined) updates.content = content;
+
+        const result = db
+          .update(notes)
+          .set(updates)
+          .where(eq(notes.id, id))
+          .returning()
+          .get();
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to update note: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  // ── delete-note ──────────────────────────────────────────────────────
+  server.tool(
+    "delete-note",
+    "Delete a note by its ID",
+    {
+      id: z.number().int().positive().describe("ID of the note to delete"),
+    },
+    async ({ id }) => {
+      try {
+        const existing = db
+          .select()
+          .from(notes)
+          .where(eq(notes.id, id))
+          .get();
+
+        if (!existing) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Note with ID ${id} not found`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        db.delete(notes).where(eq(notes.id, id)).run();
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Note with ID ${id} deleted successfully`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        const message =
+          error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to delete note: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/templates/database/tests/tools.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createDatabase } from "../src/db.js";
+import { notes } from "../src/schema.js";
+import { eq } from "drizzle-orm";
+
+// We test the database operations directly rather than going through MCP
+// protocol to keep tests fast and focused on business logic.
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  const db = createDatabase(sqlite);
+  return { sqlite, db };
+}
+
+describe("Notes CRUD operations", () => {
+  let sqlite: Database.Database;
+  let db: ReturnType<typeof createDatabase>;
+
+  beforeEach(() => {
+    const testDb = createTestDb();
+    sqlite = testDb.sqlite;
+    db = testDb.db;
+  });
+
+  afterEach(() => {
+    sqlite.close();
+  });
+
+  describe("create", () => {
+    it("should create a note with title and content", () => {
+      const result = db
+        .insert(notes)
+        .values({ title: "Test Note", content: "Hello world" })
+        .returning()
+        .get();
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(1);
+      expect(result.title).toBe("Test Note");
+      expect(result.content).toBe("Hello world");
+      expect(result.createdAt).toBeDefined();
+      expect(result.updatedAt).toBeDefined();
+    });
+
+    it("should create a note with default empty content", () => {
+      const result = db
+        .insert(notes)
+        .values({ title: "Title Only" })
+        .returning()
+        .get();
+
+      expect(result.content).toBe("");
+    });
+
+    it("should auto-increment IDs", () => {
+      const first = db
+        .insert(notes)
+        .values({ title: "First" })
+        .returning()
+        .get();
+      const second = db
+        .insert(notes)
+        .values({ title: "Second" })
+        .returning()
+        .get();
+
+      expect(second.id).toBe(first.id + 1);
+    });
+  });
+
+  describe("read", () => {
+    beforeEach(() => {
+      db.insert(notes)
+        .values([
+          { title: "Note A", content: "Alpha content" },
+          { title: "Note B", content: "Beta content" },
+          { title: "Note C", content: "Gamma content" },
+        ])
+        .run();
+    });
+
+    it("should list all notes", () => {
+      const result = db.select().from(notes).all();
+
+      expect(result).toHaveLength(3);
+      expect(result.map((n) => n.title)).toEqual([
+        "Note A",
+        "Note B",
+        "Note C",
+      ]);
+    });
+
+    it("should get a note by ID", () => {
+      const result = db.select().from(notes).where(eq(notes.id, 2)).get();
+
+      expect(result).toBeDefined();
+      expect(result!.title).toBe("Note B");
+    });
+
+    it("should return undefined for a non-existent ID", () => {
+      const result = db.select().from(notes).where(eq(notes.id, 999)).get();
+
+      expect(result).toBeUndefined();
+    });
+
+    it("should search notes by title pattern", () => {
+      const result = db
+        .select()
+        .from(notes)
+        .where(eq(notes.title, "Note A"))
+        .all();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].title).toBe("Note A");
+    });
+  });
+
+  describe("update", () => {
+    beforeEach(() => {
+      db.insert(notes)
+        .values({ title: "Original Title", content: "Original Content" })
+        .run();
+    });
+
+    it("should update the title of a note", () => {
+      const result = db
+        .update(notes)
+        .set({ title: "Updated Title" })
+        .where(eq(notes.id, 1))
+        .returning()
+        .get();
+
+      expect(result.title).toBe("Updated Title");
+      expect(result.content).toBe("Original Content");
+    });
+
+    it("should update the content of a note", () => {
+      const result = db
+        .update(notes)
+        .set({ content: "Updated Content" })
+        .where(eq(notes.id, 1))
+        .returning()
+        .get();
+
+      expect(result.title).toBe("Original Title");
+      expect(result.content).toBe("Updated Content");
+    });
+
+    it("should update both title and content", () => {
+      const result = db
+        .update(notes)
+        .set({ title: "New Title", content: "New Content" })
+        .where(eq(notes.id, 1))
+        .returning()
+        .get();
+
+      expect(result.title).toBe("New Title");
+      expect(result.content).toBe("New Content");
+    });
+  });
+
+  describe("delete", () => {
+    beforeEach(() => {
+      db.insert(notes)
+        .values([
+          { title: "Keep", content: "Stay" },
+          { title: "Remove", content: "Gone" },
+        ])
+        .run();
+    });
+
+    it("should delete a note by ID", () => {
+      db.delete(notes).where(eq(notes.id, 2)).run();
+
+      const remaining = db.select().from(notes).all();
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0].title).toBe("Keep");
+    });
+
+    it("should not affect other notes when deleting", () => {
+      db.delete(notes).where(eq(notes.id, 1)).run();
+
+      const remaining = db.select().from(notes).all();
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0].title).toBe("Remove");
+    });
+
+    it("should handle deleting a non-existent ID gracefully", () => {
+      db.delete(notes).where(eq(notes.id, 999)).run();
+
+      const remaining = db.select().from(notes).all();
+      expect(remaining).toHaveLength(2);
+    });
+  });
+});

package/templates/database/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/templates/database/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    coverage: {
+      provider: "v8",
+      include: ["src/**/*.ts"],
+      exclude: ["src/index.ts"],
+    },
+  },
+});