@tigerdata/mcp-boilerplate 1.3.2 → 1.3.4

package/dist/cliEntrypoint.d.ts

@@ -1 +1,2 @@
-export declare function cliEntrypoint(stdioEntrypoint: string, httpEntrypoint: string, instrumentation?: string): Promise<void>;
+import type { MigrationsConfig } from './types.js';
+export declare function cliEntrypoint(stdioEntrypoint: string, httpEntrypoint: string, instrumentation?: string, dbConfig?: MigrationsConfig): Promise<void>;

package/dist/cliEntrypoint.js

@@ -1,11 +1,17 @@
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { log } from './logger.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-export async function cliEntrypoint(stdioEntrypoint, httpEntrypoint, instrumentation = join(__dirname, './instrumentation.js')) {
+export async function cliEntrypoint(stdioEntrypoint, httpEntrypoint, instrumentation = join(__dirname, './instrumentation.js'), dbConfig) {
     // Parse command line arguments first
     const args = process.argv.slice(2);
     const scriptName = args[0] || 'stdio';
     try {
+        if (dbConfig) {
+            const { createMigrator } = await import('./migrate.js');
+            log.info('starting server...');
+            await createMigrator(dbConfig).run();
+        }
         // Dynamically import only the requested module to prevent all modules from initializing
         switch (scriptName) {
             case 'stdio': {

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { cliEntrypoint } from './cliEntrypoint.js';
 export { httpServerFactory } from './httpServer.js';
 export { log } from './logger.js';
 export type { AdditionalSetupArgs } from './mcpServer.js';
+export { createMigrator } from './migrate.js';
 export { registerExitHandlers } from './registerExitHandlers.js';
 export { StatusError } from './StatusError.js';
 export { stdioServerFactory } from './stdio.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { cliEntrypoint } from './cliEntrypoint.js';
 export { httpServerFactory } from './httpServer.js';
 export { log } from './logger.js';
+export { createMigrator } from './migrate.js';
 export { registerExitHandlers } from './registerExitHandlers.js';
 export { StatusError } from './StatusError.js';
 export { stdioServerFactory } from './stdio.js';

package/dist/migrate.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationsConfig } from './types.js';
+export declare const createMigrator: (config: MigrationsConfig) => {
+    run: () => Promise<void>;
+};

package/dist/migrate.js

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import migrate from 'migrate';
+import { Client } from 'pg';
+import { log } from './logger.js';
+const createStateStore = (name, schema = 'public') => {
+    let client;
+    // Use a hash of the project name to create a lock
+    const hash = createHash('sha256').update(name).digest('hex');
+    const advisoryLockId = parseInt(hash.substring(0, 15), 16);
+    return {
+        async load(callback) {
+            try {
+                client = new Client();
+                await client.connect();
+                // Acquire advisory lock to prevent concurrent migrations
+                await client.query(/* sql */ `SELECT pg_advisory_lock($1)`, [
+                    advisoryLockId,
+                ]);
+                // Ensure migrations table exists
+                await client.query(/* sql */ `
+          CREATE SCHEMA IF NOT EXISTS ${schema};
+
+          CREATE TABLE IF NOT EXISTS ${schema}.migrations (
+            id SERIAL PRIMARY KEY,
+            set JSONB NOT NULL,
+            applied_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+          );
+        `);
+                // Load the most recent migration set
+                const result = await client.query(
+                /* sql */ `SELECT set FROM ${schema}.migrations ORDER BY applied_at DESC LIMIT 1`);
+                const set = result.rows.length > 0 ? result.rows[0].set : {};
+                callback(null, set);
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+        async save(set, callback) {
+            try {
+                // Insert the entire set as JSONB
+                await client.query(
+                /* sql */ `INSERT INTO ${schema}.migrations (set) VALUES ($1)`, [JSON.stringify(set)]);
+                callback(null);
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+        async close() {
+            if (client) {
+                // Release advisory lock
+                await client.query(/* sql */ `SELECT pg_advisory_unlock($1)`, [
+                    advisoryLockId,
+                ]);
+                await client.end();
+            }
+        },
+    };
+};
+export const createMigrator = (config) => {
+    const { schema, migrationsDirectory, serviceName } = config;
+    const stateStore = createStateStore(serviceName, schema);
+    return {
+        run: async () => new Promise((resolve, reject) => {
+            log.info('Running database migrations...');
+            migrate.load({
+                stateStore,
+                migrationsDirectory: migrationsDirectory ?? './migrations',
+            }, (err, set) => {
+                if (err) {
+                    log.error('Database migration failed:', err);
+                    stateStore.close().finally(() => reject(err));
+                    return;
+                }
+                set.up((err) => {
+                    stateStore.close().finally(() => {
+                        if (err) {
+                            log.error('Database migration failed:', err);
+                            reject(err);
+                        }
+                        else {
+                            log.info('Database migrations completed successfully');
+                            resolve();
+                        }
+                    });
+                });
+            });
+        }),
+    };
+};

package/dist/types.d.ts

@@ -107,4 +107,9 @@ export type InferSchema<T extends Record<string, z.ZodType>> = Flatten<{
 } & {
     [K in OptionalKeys<T>]?: z.infer<T[K]>;
 }>;
+export interface MigrationsConfig {
+    serviceName: string;
+    migrationsDirectory?: string;
+    schema?: string;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigerdata/mcp-boilerplate",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "MCP boilerplate code for Node.js",
   "license": "Apache-2.0",
   "author": "TigerData",
@@ -58,10 +58,22 @@
     "yaml": "^2.8.2"
   },
   "peerDependencies": {
+    "migrate": "^2.1.0",
+    "pg": "^8.16.3",
     "zod": "^3.25 || ^4.0"
   },
+  "peerDependenciesMeta": {
+    "migrate": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.4.8",
+    "migrate": "^2.1.0",
+    "pg": "^8.16.3",
     "zod": "^4.3.6",
     "@octokit/rest": "^22.0.1",
     "@types/bun": "^1.3.10",