Implement basic zodSchemaToParamSchema

Author: razor-x

src/lib/parse.ts

@@ -22,7 +22,6 @@ export const parseUrlSearchParams = (
     )
   }
 
-  // TODO:
   // const paramSchema = zodSchemaToParamSchema(schema)
   // traverse paramSchema, and build a new object
   // for each node, lookup expected key in searchParams

src/lib/schema.test.ts

@@ -0,0 +1,50 @@
+import test from 'ava'
+import { z } from 'zod'
+
+import { UnparseableSchemaError, zodSchemaToParamSchema } from './schema.js'
+
+test('parse flat object schemas', (t) => {
+  t.deepEqual(zodSchemaToParamSchema(z.object({ foo: z.string() })), {
+    foo: 'string',
+  })
+  t.deepEqual(
+    zodSchemaToParamSchema(
+      z.object({
+        a: z.string(),
+        b: z.number(),
+        c: z.boolean(),
+        d: z.array(z.string()),
+      }),
+    ),
+    {
+      a: 'string',
+      b: 'number',
+      c: 'boolean',
+      d: 'string_array',
+    },
+  )
+})
+
+test('cannot parse non-object schemas', (t) => {
+  t.throws(() => zodSchemaToParamSchema(z.number()), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.enum(['foo'])), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.string()), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.map(z.string(), z.string())), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.array(z.string())), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.null()), {
+    instanceOf: UnparseableSchemaError,
+  })
+  t.throws(() => zodSchemaToParamSchema(z.union([z.number(), z.string()])), {
+    instanceOf: UnparseableSchemaError,
+  })
+})

src/lib/schema.ts

@@ -6,7 +6,14 @@
 
 import type { ZodTypeAny } from 'zod'
 
-import { isZodObject } from './zod.js'
+import {
+  isZodArray,
+  isZodBoolean,
+  isZodNumber,
+  isZodObject,
+  isZodSchema,
+  isZodString,
+} from './zod.js'
 
 type ValueType =
   | 'string'
@@ -23,15 +30,51 @@ interface ParamSchema {
 export const zodSchemaToParamSchema = (schema: ZodTypeAny): ParamSchema => {
   if (!isZodObject(schema)) {
     throw new UnparseableSchemaError(
+      [],
       'top level schema must be an object schema',
     )
   }
-  return {}
+  const paramSchema = nestedZodSchemaToParamSchema(schema, [])
+  if (typeof paramSchema === 'string') {
+    throw new Error('Expected ParamSchema not ValueType')
+  }
+  return paramSchema
+}
+
+const nestedZodSchemaToParamSchema = (
+  schema: ZodTypeAny,
+  path: string[],
+): ParamSchema | ValueType => {
+  if (isZodObject(schema)) {
+    const shape = schema.shape as unknown as Record<string, unknown>
+    const entries = Object.entries(shape).reduce<
+      Array<[string, ParamSchema | ValueType]>
+    >((acc, entry) => {
+      const [k, v] = entry
+      const currentPath = [...path, k]
+      if (isZodSchema(v)) {
+        return [...acc, [k, nestedZodSchemaToParamSchema(v, currentPath)]]
+      }
+      throw new UnparseableSchemaError(currentPath, 'unexpected non-zod schema')
+    }, [])
+    return Object.fromEntries(entries)
+  }
+
+  if (isZodNumber(schema)) return 'number'
+  if (isZodString(schema)) return 'string'
+  if (isZodBoolean(schema)) return 'boolean'
+  if (isZodArray(schema)) {
+    // TODO: handle number_array
+    return 'string_array'
+  }
+
+  throw new UnparseableSchemaError(path, `schema type is not supported`)
 }
 
 export class UnparseableSchemaError extends Error {
-  constructor(message: string) {
-    super(`Could not parse Zod schema: ${message}`)
+  constructor(path: string[], message: string) {
+    const part = path.length === 0 ? '' : ` at ${path.join('.')}`
+    super(`Could not parse Zod schema${part}: ${message}`)
     this.name = this.constructor.name
   }
 }