@tigerdata/mcp-boilerplate 0.7.0 → 0.9.0

package/dist/cliEntrypoint.js

@@ -1,7 +1,5 @@
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-export async function cliEntrypoint(stdioEntrypoint, httpEntrypoint, instrumentation = join(__dirname, './instrumentation.js')) {
+import { join } from 'path';
+export async function cliEntrypoint(stdioEntrypoint, httpEntrypoint, instrumentation = join(import.meta.dir, './instrumentation.js')) {
     // Parse command line arguments first
     const args = process.argv.slice(2);
     const scriptName = args[0] || 'stdio';

package/dist/httpServer.d.ts

@@ -3,7 +3,7 @@ import express from 'express';
 import { ApiFactory, PromptFactory, ResourceFactory } from './types.js';
 import { AdditionalSetupArgs } from './mcpServer.js';
 import { Server } from 'node:http';
-export declare const httpServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, stateful, }: {
+export declare const httpServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, stateful, instructions, }: {
     name: string;
     version?: string;
     context: Context;
@@ -13,6 +13,7 @@ export declare const httpServerFactory: <Context extends Record<string, unknown>
     additionalSetup?: (args: AdditionalSetupArgs<Context>) => void;
     cleanupFn?: () => void | Promise<void>;
     stateful?: boolean;
+    instructions?: string;
 }) => {
     app: express.Express;
     server: Server;

package/dist/httpServer.js

@@ -6,7 +6,7 @@ import { registerExitHandlers } from './registerExitHandlers.js';
 import { mcpServerFactory } from './mcpServer.js';
 import { log } from './logger.js';
 import { StatusError } from './StatusError.js';
-export const httpServerFactory = ({ name, version, context, apiFactories = [], promptFactories, resourceFactories, additionalSetup, cleanupFn, stateful = true, }) => {
+export const httpServerFactory = ({ name, version, context, apiFactories = [], promptFactories, resourceFactories, additionalSetup, cleanupFn, stateful = true, instructions, }) => {
     const cleanupFns = cleanupFn
         ? [cleanupFn]
         : [];
@@ -23,6 +23,7 @@ export const httpServerFactory = ({ name, version, context, apiFactories = [], p
         resourceFactories,
         additionalSetup,
         featureFlags,
+        instructions,
     }), { name, stateful });
     cleanupFns.push(mcpCleanup);
     app.use('/mcp', mcpRouter);

package/dist/mcpServer.d.ts

@@ -6,7 +6,7 @@ export interface AdditionalSetupArgs<Context extends Record<string, unknown>> {
     server: McpServer;
     featureFlags: McpFeatureFlags;
 }
-export declare const mcpServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, additionalCapabilities, featureFlags, }: {
+export declare const mcpServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, additionalCapabilities, featureFlags, instructions, }: {
     name: string;
     version?: string;
     context: Context;
@@ -16,6 +16,7 @@ export declare const mcpServerFactory: <Context extends Record<string, unknown>>
     additionalSetup?: (args: AdditionalSetupArgs<Context>) => void;
     additionalCapabilities?: ServerCapabilities;
     featureFlags?: McpFeatureFlags;
+    instructions?: string;
 }) => {
     server: McpServer;
 };

package/dist/mcpServer.js

@@ -25,7 +25,7 @@ const shouldSkip = (item, enabledSets, disabledSets) => {
     }
     return false;
 };
-export const mcpServerFactory = ({ name, version = '1.0.0', context, apiFactories = [], promptFactories = [], resourceFactories = [], additionalSetup, additionalCapabilities = {}, featureFlags = {}, }) => {
+export const mcpServerFactory = ({ name, version = '1.0.0', context, apiFactories = [], promptFactories = [], resourceFactories = [], additionalSetup, additionalCapabilities = {}, featureFlags = {}, instructions, }) => {
     const enablePrompts = featureFlags.prompts !== false;
     const enableResources = featureFlags.resources !== false;
     const enableTools = featureFlags.tools !== false;
@@ -41,6 +41,7 @@ export const mcpServerFactory = ({ name, version = '1.0.0', context, apiFactorie
                 : null),
             ...additionalCapabilities,
         },
+        instructions,
     });
     if (enableTools) {
         for (const factory of apiFactories) {

package/dist/stdio.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { ApiFactory, PromptFactory, ResourceFactory } from './types.js';
 import { AdditionalSetupArgs } from './mcpServer.js';
-export declare const stdioServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, }: {
+export declare const stdioServerFactory: <Context extends Record<string, unknown>>({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, instructions, }: {
     name: string;
     version?: string;
     context: Context;
@@ -10,4 +10,5 @@ export declare const stdioServerFactory: <Context extends Record<string, unknown
     resourceFactories?: readonly ResourceFactory<Context>[];
     additionalSetup?: (args: AdditionalSetupArgs<Context>) => void;
     cleanupFn?: () => Promise<void>;
+    instructions?: string;
 }) => Promise<void>;

package/dist/stdio.js

@@ -2,7 +2,7 @@
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { mcpServerFactory } from './mcpServer.js';
 import { registerExitHandlers } from './registerExitHandlers.js';
-export const stdioServerFactory = async ({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, }) => {
+export const stdioServerFactory = async ({ name, version, context, apiFactories, promptFactories, resourceFactories, additionalSetup, cleanupFn, instructions, }) => {
     try {
         console.error('Starting default (STDIO) server...');
         const transport = new StdioServerTransport();
@@ -14,6 +14,7 @@ export const stdioServerFactory = async ({ name, version, context, apiFactories,
             promptFactories,
             resourceFactories,
             additionalSetup,
+            instructions,
         });
         await server.connect(transport);
         // Cleanup on exit

package/dist/types.d.ts

@@ -70,6 +70,18 @@ export interface McpFeatureFlags {
     disabledTools?: Set<string> | null;
     query?: ParsedQs;
 }
-export type InferSchema<T extends Record<string, z.ZodType>> = {
-    [K in keyof T]: z.infer<T[K]>;
-};
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type OptionalKeys<T extends Record<string, z.ZodType>> = {
+    [K in keyof T]: T[K] extends z.ZodOptional<z.ZodType> ? K : never;
+}[keyof T];
+type RequiredKeys<T extends Record<string, z.ZodType>> = {
+    [K in keyof T]: T[K] extends z.ZodOptional<z.ZodType> ? never : K;
+}[keyof T];
+export type InferSchema<T extends Record<string, z.ZodType>> = Flatten<{
+    [K in RequiredKeys<T>]: z.infer<T[K]>;
+} & {
+    [K in OptionalKeys<T>]?: z.infer<T[K]>;
+}>;
+export {};

package/dist/types.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.spec.js

@@ -0,0 +1,153 @@
+import { describe, it, expect, expectTypeOf } from 'bun:test';
+import { z } from 'zod';
+describe('InferSchema', () => {
+    it('should infer required properties correctly', () => {
+        const schema = {
+            name: z.string(),
+            age: z.number(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        expectTypeOf().toEqualTypeOf();
+        // Runtime check with zod validation
+        const valid = { name: 'John', age: 30 };
+        const parsed = zodSchema.parse(valid);
+        expect(parsed.name).toBe('John');
+        expect(parsed.age).toBe(30);
+    });
+    it('should make optional zod properties optional in the inferred type', () => {
+        const schema = {
+            name: z.string(),
+            nickname: z.string().optional(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        // nickname should be optional (string | undefined with optional key)
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks - should compile without providing nickname
+        const withoutNickname = { name: 'John' };
+        const parsedWithout = zodSchema.parse(withoutNickname);
+        expect(parsedWithout.name).toBe('John');
+        expect(parsedWithout.nickname).toBeUndefined();
+        // Should also compile with nickname provided
+        const withNickname = { name: 'John', nickname: 'Johnny' };
+        const parsedWith = zodSchema.parse(withNickname);
+        expect(parsedWith.nickname).toBe('Johnny');
+    });
+    it('should handle nullable properties', () => {
+        const schema = {
+            name: z.string(),
+            middleName: z.string().nullable(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        // Nullable properties should still be required, but allow null
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks with zod validation
+        const withNull = { name: 'John', middleName: null };
+        const parsedNull = zodSchema.parse(withNull);
+        expect(parsedNull.middleName).toBeNull();
+        const withValue = { name: 'John', middleName: 'William' };
+        const parsedValue = zodSchema.parse(withValue);
+        expect(parsedValue.middleName).toBe('William');
+    });
+    it('should handle optional and nullable combined', () => {
+        const schema = {
+            name: z.string(),
+            suffix: z.string().nullable().optional(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        // Should be optional and nullable
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks with zod validation
+        const withoutSuffix = { name: 'John' };
+        const parsedWithout = zodSchema.parse(withoutSuffix);
+        expect(parsedWithout.suffix).toBeUndefined();
+        const withNull = { name: 'John', suffix: null };
+        const parsedNull = zodSchema.parse(withNull);
+        expect(parsedNull.suffix).toBeNull();
+        const withValue = { name: 'John', suffix: 'Jr.' };
+        const parsedValue = zodSchema.parse(withValue);
+        expect(parsedValue.suffix).toBe('Jr.');
+    });
+    it('should handle complex nested schemas', () => {
+        const schema = {
+            user: z.object({
+                name: z.string(),
+                email: z.string().optional(),
+            }),
+            metadata: z
+                .object({
+                createdAt: z.date(),
+            })
+                .optional(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        // metadata should be optional
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks with zod validation
+        const withoutMetadata = {
+            user: { name: 'John' },
+        };
+        const parsedWithout = zodSchema.parse(withoutMetadata);
+        expect(parsedWithout.user.name).toBe('John');
+        expect(parsedWithout.metadata).toBeUndefined();
+        const now = new Date();
+        const withMetadata = {
+            user: { name: 'John', email: 'john@example.com' },
+            metadata: { createdAt: now },
+        };
+        const parsedWith = zodSchema.parse(withMetadata);
+        expect(parsedWith.metadata?.createdAt).toEqual(now);
+    });
+    it('should handle arrays with optional elements', () => {
+        const schema = {
+            items: z.array(z.string()),
+            tags: z.array(z.string()).optional(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        // tags should be optional
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks with zod validation
+        const withoutTags = { items: ['a', 'b'] };
+        const parsedWithout = zodSchema.parse(withoutTags);
+        expect(parsedWithout.items).toEqual(['a', 'b']);
+        expect(parsedWithout.tags).toBeUndefined();
+        const withTags = { items: ['a'], tags: ['tag1', 'tag2'] };
+        const parsedWith = zodSchema.parse(withTags);
+        expect(parsedWith.tags).toEqual(['tag1', 'tag2']);
+    });
+    it('should correctly type a mixed schema', () => {
+        const schema = {
+            id: z.string(),
+            description: z.string().optional(),
+            count: z.number(),
+            deletedAt: z.date().nullable().optional(),
+        };
+        const zodSchema = z.object(schema);
+        // Type-level assertion (checked by tsc --noEmit)
+        expectTypeOf().toEqualTypeOf();
+        // Runtime checks - minimal valid object (only required fields)
+        const minimal = {
+            id: '123',
+            count: 0,
+        };
+        const parsedMinimal = zodSchema.parse(minimal);
+        expect(parsedMinimal.id).toBe('123');
+        expect(parsedMinimal.count).toBe(0);
+        // Full object
+        const now = new Date();
+        const full = {
+            id: '456',
+            description: 'A test',
+            count: 5,
+            deletedAt: now,
+        };
+        const parsedFull = zodSchema.parse(full);
+        expect(parsedFull.description).toBe('A test');
+        expect(parsedFull.deletedAt).toEqual(now);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigerdata/mcp-boilerplate",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "MCP boilerplate code for Node.js",
   "license": "Apache-2.0",
   "author": "TigerData",
@@ -39,28 +39,29 @@
     "prettier:check": "prettier --check ."
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@modelcontextprotocol/sdk": "^1.24.2",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.67.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.67.2",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.208.0",
     "@opentelemetry/instrumentation-http": "^0.208.0",
     "@opentelemetry/sdk-metrics": "^2.2.0",
     "@opentelemetry/sdk-node": "^0.208.0",
     "@opentelemetry/sdk-trace-node": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
-    "express": "^5.1.0",
-    "raw-body": "^3.0.1",
+    "express": "^5.2.1",
+    "raw-body": "^3.0.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
-    "@types/express": "^5.0.5",
+    "@types/bun": "^1.3.3",
+    "@types/express": "^5.0.6",
     "@types/node": "^22.19.1",
-    "ai": "^5.0.93",
+    "ai": "^5.0.106",
     "eslint": "^9.39.1",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.4"
+    "typescript-eslint": "^8.48.1"
   },
   "publishConfig": {
     "access": "public"