@tigerdata/mcp-boilerplate 0.7.0 → 0.8.0

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.8.0",
   "description": "MCP boilerplate code for Node.js",
   "license": "Apache-2.0",
   "author": "TigerData",
@@ -39,9 +39,9 @@
     "prettier:check": "prettier --check ."
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@modelcontextprotocol/sdk": "^1.23.0",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.67.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.67.1",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.208.0",
     "@opentelemetry/instrumentation-http": "^0.208.0",
     "@opentelemetry/sdk-metrics": "^2.2.0",
@@ -49,18 +49,19 @@
     "@opentelemetry/sdk-trace-node": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "express": "^5.1.0",
-    "raw-body": "^3.0.1",
+    "raw-body": "^3.0.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@types/bun": "^1.3.3",
     "@types/express": "^5.0.5",
     "@types/node": "^22.19.1",
-    "ai": "^5.0.93",
+    "ai": "^5.0.102",
     "eslint": "^9.39.1",
     "prettier": "^3.6.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.4"
+    "typescript-eslint": "^8.48.0"
   },
   "publishConfig": {
     "access": "public"