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

package/dist/generator.js

@@ -10,7 +10,23 @@ function getTemplatesDir() {
     const srcPath = path.resolve(__dirname, "templates");
     return fs.existsSync(devPath) ? devPath : srcPath;
 }
+const PREMIUM_TEMPLATES = new Set(["database"]);
 export async function generateProject(config) {
+    // Premium templates are not bundled — redirect to purchase page
+    if (PREMIUM_TEMPLATES.has(config.template)) {
+        console.log();
+        console.log(chalk.yellow.bold("  ★ Premium Template"));
+        console.log();
+        console.log(`  The ${chalk.bold(config.template)} template is a premium template.`);
+        console.log(`  It includes production-ready database integration with:`);
+        console.log(`  • SQLite + Drizzle ORM`);
+        console.log(`  • Full CRUD tools (create, list, get, update, delete)`);
+        console.log(`  • Test suite + migration support`);
+        console.log();
+        console.log(`  ${chalk.cyan("Get it here:")} https://nexus-lab.gumroad.com/l/mcp-database`);
+        console.log();
+        return;
+    }
     const targetDir = path.resolve(process.cwd(), config.projectName);
     if (await fs.pathExists(targetDir)) {
         const files = await fs.readdir(targetDir);

package/dist/index.js

@@ -7,7 +7,7 @@ const program = new Command();
 program
     .name("create-mcp-server")
     .description("Scaffold a new MCP server project with TypeScript and secure defaults")
-    .version("0.1.1")
+    .version("0.2.0")
     .argument("[project-name]", "Name of the project to create")
     .option("-t, --template <template>", "Template to use (minimal, full, http)", "minimal")
     .option("--no-install", "Skip npm install")

package/dist/prompts.d.ts

@@ -1,7 +1,7 @@
 export interface ProjectConfig {
     projectName: string;
     description: string;
-    template: "minimal" | "full" | "http";
+    template: "minimal" | "full" | "http" | "database";
     install: boolean;
     git: boolean;
 }

package/dist/prompts.js

@@ -13,6 +13,10 @@ const TEMPLATES = [
         title: `${chalk.bold("http")} ${chalk.dim("— Streamable HTTP transport with Express")}`,
         value: "http",
     },
+    {
+        title: `${chalk.bold.yellow("database")} ${chalk.dim("— SQLite + Drizzle ORM + CRUD")} ${chalk.yellow("★ Premium")}`,
+        value: "database",
+    },
 ];
 export async function runPrompts(projectName, options) {
     const questions = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexus-lab/create-mcp-server",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Scaffold a new MCP server project with TypeScript, testing, and secure defaults",
   "type": "module",
   "bin": {

package/templates/database/.env.example

@@ -0,0 +1 @@
+DATABASE_URL=./data.db

package/templates/database/README.md

@@ -0,0 +1,110 @@
+# MCP Server — Database Template
+
+A production-ready [Model Context Protocol](https://modelcontextprotocol.io/) server with built-in SQLite database connectivity, powered by [Drizzle ORM](https://orm.drizzle.team/).
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Copy environment config
+cp .env.example .env
+
+# Build the project
+npm run build
+
+# Start the server
+npm start
+```
+
+## Available Tools
+
+| Tool            | Description                                          |
+| --------------- | ---------------------------------------------------- |
+| `create-note`   | Create a new note with a title and optional content  |
+| `list-notes`    | List all notes, with optional search query filtering |
+| `get-note`      | Retrieve a single note by its ID                     |
+| `update-note`   | Update a note's title and/or content by ID           |
+| `delete-note`   | Delete a note by its ID                              |
+
+## Available Resources
+
+| URI            | Description                          |
+| -------------- | ------------------------------------ |
+| `notes://list` | All notes in the database as JSON    |
+| `db://schema`  | Database schema documentation        |
+
+## Configuration
+
+### Environment Variables
+
+| Variable       | Default      | Description                 |
+| -------------- | ------------ | --------------------------- |
+| `DATABASE_URL` | `./data.db`  | Path to the SQLite database |
+
+### Claude Desktop Integration
+
+Add this to your Claude Desktop config (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "my-mcp-server": {
+      "command": "node",
+      "args": ["/absolute/path/to/dist/index.js"]
+    }
+  }
+}
+```
+
+## Database Management
+
+```bash
+# Generate migration files from schema changes
+npm run db:generate
+
+# Apply migrations
+npm run db:migrate
+
+# Open Drizzle Studio (visual DB browser)
+npm run db:studio
+```
+
+## Development
+
+```bash
+# Watch mode — recompiles on file changes
+npm run dev
+
+# Run tests
+npm test
+```
+
+## Extending the Schema
+
+1. Edit `src/schema.ts` to add new tables or columns.
+2. Run `npm run db:generate` to create a migration.
+3. Run `npm run db:migrate` to apply it.
+4. Add corresponding tools in `src/tools.ts` and resources in `src/resources.ts`.
+
+## Project Structure
+
+```
+├── src/
+│   ├── index.ts        # Entry point — server setup and transport
+│   ├── db.ts           # Database connection and initialization
+│   ├── schema.ts       # Drizzle ORM table definitions
+│   ├── tools.ts        # MCP tool handlers (CRUD)
+│   └── resources.ts    # MCP resource handlers
+├── tests/
+│   └── tools.test.ts   # CRUD operation tests
+├── drizzle.config.ts   # Drizzle Kit configuration
+├── vitest.config.ts    # Test runner configuration
+├── tsconfig.json       # TypeScript configuration
+└── package.json
+```
+
+## License
+
+MIT

package/templates/database/_gitignore

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+*.log
+.env
+*.db
+coverage/
+drizzle/

package/templates/database/drizzle.config.ts

@@ -0,0 +1,11 @@
+import "dotenv/config";
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dialect: "sqlite",
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? "./data.db",
+  },
+});

package/templates/database/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "my-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server with database connectivity powered by Drizzle ORM",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:studio": "drizzle-kit studio"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^11.8.1",
+    "dotenv": "^16.5.0",
+    "drizzle-orm": "^0.39.3",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.3",
+    "drizzle-kit": "^0.31.1",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
+}

package/templates/database/src/db.ts

@@ -0,0 +1,51 @@
+import Database from "better-sqlite3";
+import { drizzle, BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "./data.db";
+
+const sqlite = new Database(DATABASE_URL);
+
+// Enable WAL mode for better concurrent read performance
+sqlite.pragma("journal_mode = WAL");
+sqlite.pragma("foreign_keys = ON");
+
+export const db: BetterSQLite3Database<typeof schema> = drizzle(sqlite, {
+  schema,
+});
+
+/**
+ * Initialize the database by creating tables if they don't exist.
+ * Called once at server startup.
+ */
+export function setupDatabase(): void {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+/**
+ * Create a database instance from a custom SQLite connection.
+ * Useful for testing with in-memory databases.
+ */
+export function createDatabase(
+  connection: Database.Database,
+): BetterSQLite3Database<typeof schema> {
+  connection.pragma("foreign_keys = ON");
+  connection.exec(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  return drizzle(connection, { schema });
+}

package/templates/database/src/index.ts

@@ -0,0 +1,30 @@
+import "dotenv/config";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { setupDatabase } from "./db.js";
+import { registerTools } from "./tools.js";
+import { registerResources } from "./resources.js";
+
+const server = new McpServer({
+  name: "my-mcp-server",
+  version: "0.1.0",
+});
+
+// Initialize the database (creates tables if they don't exist)
+setupDatabase();
+
+// Register all tools and resources
+registerTools(server);
+registerResources(server);
+
+// Start the server with stdio transport
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP server running on stdio");
+}
+
+main().catch((error: unknown) => {
+  console.error("Fatal error starting server:", error);
+  process.exit(1);
+});

package/templates/database/src/resources.ts

@@ -0,0 +1,68 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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>;
+
+/** Database schema description exposed as a resource. */
+const SCHEMA_DESCRIPTION = `# Database Schema
+
+## Table: notes
+
+| Column     | Type    | Constraints                         |
+|------------|---------|-------------------------------------|
+| id         | INTEGER | PRIMARY KEY, AUTOINCREMENT          |
+| title      | TEXT    | NOT NULL                            |
+| content    | TEXT    | NOT NULL, DEFAULT ''                |
+| created_at | TEXT    | NOT NULL, DEFAULT datetime('now')   |
+| updated_at | TEXT    | NOT NULL, DEFAULT datetime('now')   |
+
+### Notes
+- Timestamps are stored as ISO 8601 strings (SQLite has no native datetime type).
+- WAL journal mode is enabled for better concurrent read performance.
+- Foreign keys are enforced.
+`;
+
+/**
+ * Register all resources on the given MCP server.
+ * Accepts an optional database override for testing.
+ */
+export function registerResources(server: McpServer, database?: Db): void {
+  const db = database ?? defaultDb;
+
+  // ── notes://list ─────────────────────────────────────────────────────
+  server.resource("notes-list", "notes://list", {
+    description: "List all notes in the database as JSON",
+    mimeType: "application/json",
+  }, async () => {
+    const allNotes = db.select().from(notes).all();
+
+    return {
+      contents: [
+        {
+          uri: "notes://list",
+          mimeType: "application/json",
+          text: JSON.stringify(allNotes, null, 2),
+        },
+      ],
+    };
+  });
+
+  // ── db://schema ──────────────────────────────────────────────────────
+  server.resource("db-schema", "db://schema", {
+    description: "Database schema documentation",
+    mimeType: "text/markdown",
+  }, async () => {
+    return {
+      contents: [
+        {
+          uri: "db://schema",
+          mimeType: "text/markdown",
+          text: SCHEMA_DESCRIPTION,
+        },
+      ],
+    };
+  });
+}

package/templates/database/src/schema.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+
+/**
+ * Notes table — stores user notes with title, content, and timestamps.
+ *
+ * Timestamps are stored as ISO 8601 strings (SQLite has no native date type).
+ * Defaults are handled at the database level via SQL expressions.
+ */
+export const notes = sqliteTable("notes", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  title: text("title").notNull(),
+  content: text("content").notNull().default(""),
+  createdAt: text("created_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+  updatedAt: text("updated_at")
+    .notNull()
+    .default(sql`(datetime('now'))`),
+});
+
+/** TypeScript type for a note row returned from the database. */
+export type Note = typeof notes.$inferSelect;
+
+/** TypeScript type for inserting a new note. */
+export type NewNote = typeof notes.$inferInsert;

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"],
+    },
+  },
+});