test: add edge-case branch tests for collect-routes and reach full function coverage

Author: liorcodev

.gitignore

@@ -4,5 +4,6 @@ dist/
 .DS_Store
 .idea
 src/assets-inline.ts
-/.prettierrc
 preview.html
+
+bun.lock

.prettierrc

@@ -0,0 +1,13 @@
+{
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "bracketSpacing": true,
+  "arrowParens": "avoid",
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "always"
+}

bun.lock

@@ -4,6 +4,6 @@
 
 # Multiple patterns
 coveragePathIgnorePatterns = [
-  "**/*.ts",
+  "tests/**/*.ts",
   "*.config.js",
 ]

bunfig.toml

@@ -500,3 +500,15 @@ function traverseRouter(router: AnyRouter): RouteInfo[] {
 export function collectRoutes(router: AnyRouter): RouteInfo[] {
   return traverseRouter(router);
 }
+
+// Internal helpers exported for white-box tests of branch behavior.
+export const __internal = {
+  extractOptionalFields,
+  generateExampleFromSchema,
+  generateJSONExample,
+  generateTypeScriptExample,
+  generateTypeScriptFromSchema,
+  getOptionalFields,
+  isZodDateSchema,
+  zodSchemaToString
+};

src/collect-routes.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from 'bun:test';
 import { initTRPC } from '@trpc/server';
 import { z } from 'zod';
-import { collectRoutes } from '../src/collect-routes';
+import { collectRoutes, __internal } from '../src/collect-routes';
 import { getRoute, inputSchema, inputExample } from './_helpers';
 
 const t = initTRPC.create();
@@ -54,4 +54,93 @@ describe('edge cases', () => {
     const dateVariant = variants.find((s: any) => s.format === 'date-time');
     expect(dateVariant).toMatchObject({ type: 'string', format: 'date-time' });
   });
+
+  test('example generator returns undefined for invalid JSON schema string', () => {
+    expect(__internal.generateExampleFromSchema('{')).toBeUndefined();
+  });
+
+  test('TypeScript generator returns undefined for invalid JSON schema string', () => {
+    expect(__internal.generateTypeScriptFromSchema('{')).toBeUndefined();
+  });
+
+  test('optional-fields extractor returns undefined for invalid JSON schema string', () => {
+    expect(__internal.extractOptionalFields('{')).toBeUndefined();
+  });
+
+  test('allOf optional-field extraction includes non-required keys', () => {
+    const fields = __internal.getOptionalFields({
+      allOf: [
+        {
+          type: 'object',
+          properties: {
+            id: { type: 'number' },
+            nickname: { type: 'string' }
+          },
+          required: ['id']
+        }
+      ]
+    });
+
+    expect(fields).toEqual([{ name: 'nickname', example: '"string"' }]);
+  });
+
+  test('JSON example handles oneOf by choosing first branch', () => {
+    expect(
+      __internal.generateJSONExample({ oneOf: [{ type: 'number' }, { type: 'string' }] })
+    ).toBe('0');
+  });
+
+  test('JSON example handles array schema without items', () => {
+    expect(__internal.generateJSONExample({ type: 'array' })).toBe('[]');
+  });
+
+  test('JSON example handles date format and unknown schemas', () => {
+    expect(__internal.generateJSONExample({ type: 'string', format: 'date' })).toBe('"2024-01-01"');
+    expect(__internal.generateJSONExample({ allOf: [{ type: 'string' }] })).toBe('"value"');
+  });
+
+  test('TypeScript generation handles allOf object and non-object intersections', () => {
+    const ts = __internal.generateTypeScriptExample({
+      allOf: [
+        {
+          type: 'object',
+          properties: { id: { type: 'number' } },
+          required: ['id']
+        },
+        {
+          oneOf: [{ type: 'string' }, { type: 'number' }]
+        }
+      ]
+    });
+
+    expect(ts).toContain('id: number');
+    expect(ts).toContain('& (string | number)');
+  });
+
+  test('TypeScript generation handles allOf with only non-objects', () => {
+    expect(
+      __internal.generateTypeScriptExample({ allOf: [{ type: 'string' }, { type: 'number' }] })
+    ).toBe('string & number');
+  });
+
+  test('TypeScript generation handles oneOf, arrays without items, and unknown schema', () => {
+    expect(
+      __internal.generateTypeScriptExample({ oneOf: [{ type: 'string' }, { type: 'number' }] })
+    ).toBe('string | number');
+    expect(__internal.generateTypeScriptExample({ type: 'array' })).toBe('any[]');
+    expect(__internal.generateTypeScriptExample({ foo: 'bar' })).toBe('any');
+  });
+
+  test('zodSchemaToString returns undefined when toJSONSchema is not callable', () => {
+    expect(__internal.zodSchemaToString({ toJSONSchema: 123 })).toBeUndefined();
+  });
+
+  test('zodSchemaToString catches conversion errors', () => {
+    const schema = {
+      toJSONSchema() {
+        throw new Error('boom');
+      }
+    };
+    expect(__internal.zodSchemaToString(schema)).toBeUndefined();
+  });
 });