fix(zui): support transform of a default array to typescript schema

zui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpinternal/zui",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "A fork of Zod with additional features",
   "type": "module",
   "source": "./src/index.ts",

zui/src/transforms/common/errors.ts

@@ -61,7 +61,7 @@ export class ZuiToTypescriptTypeError extends ZuiTransformError {
   }
 }
 export class UnsupportedZuiToTypescriptTypeError extends ZuiToTypescriptTypeError {
-  public constructor(type: ZodFirstPartyTypeKind | string) {
+  public constructor(type: ZodFirstPartyTypeKind) {
     super(`Zod type ${type} cannot be transformed to TypeScript type.`)
   }
 }

zui/src/transforms/zui-to-typescript-schema/index.test.ts

@@ -2,16 +2,20 @@ import { describe, expect } from 'vitest'
 import { toTypescriptSchema as toTypescript } from '.'
 import { evalZuiString } from '../common/eval-zui-string'
 import * as errors from '../common/errors'
-import z, { ZodType } from '../../z'
+import z, { ZodLiteral, ZodSchema, ZodType } from '../../z'
+
+const evalZui = (source: string): ZodSchema => {
+  const evalResult = evalZuiString(source)
+  if (!evalResult.sucess) {
+    throw new Error(`${evalResult.error}: ${source}`)
+  }
+  return evalResult.value
+}
 
 const assert = (source: ZodType) => ({
   toGenerateItself: async () => {
     const actual = toTypescript(source)
-    const evalResult = evalZuiString(actual)
-    if (!evalResult.sucess) {
-      throw new Error(evalResult.error)
-    }
-    const destination = evalResult.value
+    const destination = evalZui(actual)
     expect(source.isEqual(destination)).toBe(true)
   },
   toThrowErrorWhenGenerating: async () => {
@@ -131,10 +135,31 @@ describe('toTypescriptZuiString', () => {
     const schema = z.literal(42)
     await assert(schema).toGenerateItself()
   })
+  test('literal symbol', async () => {
+    const source = z.literal(Symbol('banana'))
+    const dest = evalZui(toTypescript(source)) as ZodLiteral
+
+    expect(dest instanceof ZodLiteral).toBe(true)
+    const value = dest.value as symbol
+    expect(typeof value).toBe('symbol')
+    expect(value.description).toBe('banana')
+  })
+  test('literal bigint', async () => {
+    const schema = z.literal(BigInt(42))
+    await assert(schema).toGenerateItself()
+  })
   test('literal boolean', async () => {
     const schema = z.literal(true)
     await assert(schema).toGenerateItself()
   })
+  test('literal null', async () => {
+    const schema = z.literal(null)
+    await assert(schema).toGenerateItself()
+  })
+  test('literal undefined', async () => {
+    const schema = z.literal(undefined)
+    await assert(schema).toGenerateItself()
+  })
   test('enum', async () => {
     const schema = z.enum(['banana', 'apple', 'orange'])
     await assert(schema).toGenerateItself()
@@ -160,8 +185,11 @@ describe('toTypescriptZuiString', () => {
     await assert(schema).toGenerateItself()
   })
   test('default', async () => {
-    const schema = z.string().default('banana')
-    await assert(schema).toGenerateItself()
+    const schema1 = z.string().default('banana')
+    await assert(schema1).toGenerateItself()
+
+    const schema2 = z.string().array().default(['banana'])
+    await assert(schema2).toGenerateItself()
   })
   test('catch', async () => {
     const schema = z.string().catch('banana')

zui/src/transforms/zui-to-typescript-schema/index.ts

@@ -1,6 +1,10 @@
+import mapValues from 'lodash/mapValues'
 import z, { util } from '../../z'
-import { escapeString, getMultilineComment } from '../zui-to-typescript-type/utils'
-import { mapValues, toTypesriptPrimitive } from './utils'
+import {
+  primitiveToTypescriptValue,
+  getMultilineComment,
+  unknownToTypescriptValue,
+} from '../zui-to-typescript-type/utils'
 import * as errors from '../common/errors'
 
 /**
@@ -81,7 +85,7 @@ function sUnwrapZod(schema: z.Schema): string {
 
     case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       const opts = (def.options as z.ZodSchema[]).map(sUnwrapZod)
-      const discriminator = escapeString(def.discriminator)
+      const discriminator = primitiveToTypescriptValue(def.discriminator)
       return `${getMultilineComment(def.description)}z.discriminatedUnion(${discriminator}, [${opts.join(', ')}])`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodIntersection:
@@ -116,11 +120,11 @@ function sUnwrapZod(schema: z.Schema): string {
       return `${getMultilineComment(def.description)}z.lazy(() => ${sUnwrapZod(def.getter())})`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodLiteral:
-      const value = toTypesriptPrimitive(def.value)
+      const value = primitiveToTypescriptValue(def.value)
       return `${getMultilineComment(def.description)}z.literal(${value})`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodEnum:
-      const values = def.values.map(toTypesriptPrimitive)
+      const values = def.values.map(primitiveToTypescriptValue)
       return `${getMultilineComment(def.description)}z.enum([${values.join(', ')}])`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodEffects:
@@ -136,7 +140,7 @@ function sUnwrapZod(schema: z.Schema): string {
       return `${getMultilineComment(def.description)}z.nullable(${sUnwrapZod(def.innerType)})`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodDefault:
-      const defaultValue = toTypesriptPrimitive(def.defaultValue())
+      const defaultValue = unknownToTypescriptValue(def.defaultValue())
       // TODO: use z.default() notation
       return `${getMultilineComment(def.description)}${sUnwrapZod(def.innerType)}.default(${defaultValue})`.trim()
 
@@ -159,7 +163,7 @@ function sUnwrapZod(schema: z.Schema): string {
       return `${getMultilineComment(def.description)}z.readonly(${sUnwrapZod(def.innerType)})`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodRef:
-      const uri = escapeString(def.uri)
+      const uri = primitiveToTypescriptValue(def.uri)
       return `${getMultilineComment(def.description)}z.ref(${uri})`.trim()
 
     default:

zui/src/transforms/zui-to-typescript-type/index.test.ts

@@ -170,8 +170,14 @@ describe.concurrent('functions', () => {
 
   it('bigint literals', async () => {
     const n = BigInt(100)
-    const fn = () => toTypescript(z.literal(n))
-    expect(fn).toThrowError()
+    const typings = toTypescript(z.literal(n))
+    await expect(typings).toMatchWithoutFormatting('declare const x: 100n')
+  })
+
+  it('symbol literals', async () => {
+    const n = Symbol('hello')
+    const typings = toTypescript(z.literal(n))
+    await expect(typings).toMatchWithoutFormatting('declare const x: symbol')
   })
 
   it('non explicitly discriminated union', async () => {

zui/src/transforms/zui-to-typescript-type/index.ts

@@ -1,5 +1,11 @@
 import z, { util } from '../../z'
-import { escapeString, getMultilineComment, toPropertyKey, toTypeArgumentName } from './utils'
+import {
+  primitiveToTypescriptValue,
+  getMultilineComment,
+  toPropertyKey,
+  toTypeArgumentName,
+  primitiveToTypscriptLiteralType,
+} from './utils'
 import * as errors from '../common/errors'
 
 const Primitives = [
@@ -263,15 +269,12 @@ ${opts.join(' | ')}`
       return sUnwrapZod(def.getter(), newConfig)
 
     case z.ZodFirstPartyTypeKind.ZodLiteral:
-      if (typeof def.value === 'bigint') {
-        throw new errors.UnsupportedZuiToTypescriptTypeError(`${z.ZodFirstPartyTypeKind.ZodLiteral}<bigint>`)
-      }
-      const value: string = typeof def.value === 'string' ? escapeString(def.value) : String(def.value)
+      const value: string = primitiveToTypscriptLiteralType(def.value)
       return `${getMultilineComment(def.description)}
 ${value}`.trim()
 
     case z.ZodFirstPartyTypeKind.ZodEnum:
-      const values = def.values.map(escapeString)
+      const values = def.values.map(primitiveToTypescriptValue)
       return values.join(' | ')
 
     case z.ZodFirstPartyTypeKind.ZodEffects:

zui/src/transforms/zui-to-typescript-type/utils.test.ts

@@ -1,6 +1,6 @@
 import { isValidTypescript } from '../../setup.test'
 import { expect } from 'vitest'
-import { escapeString, toTypeArgumentName } from './utils'
+import { toTypeArgumentName, primitiveToTypescriptValue } from './utils'
 
 describe('Typescript Checker', () => {
   it('passes successfully on valid string definition', () => {
@@ -48,34 +48,62 @@ const d: { a: string } = { a: 1 }
   })
 })
 
-describe('Escape String', () => {
-  it('escapes a string containing nothing special', () => {
-    expect(escapeString('hello')).toBe("'hello'")
+describe('primitiveToTypscriptLiteral', () => {
+  it('converts a string to a valid typescript string value', () => {
+    const input: string = 'hello'
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('string')
+    expect(actual).toEqual(input)
   })
-
-  it('escapes a string containing single quotes', () => {
-    expect(escapeString("'hello'")).toMatchInlineSnapshot(`"'\\'hello\\''"`)
+  it('converts a number to a valid typescript number value', () => {
+    const input: number = 42
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('number')
+    expect(actual).toEqual(input)
   })
-
-  it('escapes a string containing double quotes', () => {
-    const world = 'world'
-    expect(escapeString(`"Hey ${world}"`)).toMatchInlineSnapshot(`"'"Hey world"'"`)
+  it('converts a boolean to a valid typescript boolean value', () => {
+    const input: boolean = true
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('boolean')
+    expect(actual).toEqual(input)
   })
-
-  it('escapes a string containing double quotes', () => {
-    expect(
-      escapeString(`
-\`\`\`
-Hey world
-\`\`\`
-`),
-    ).toMatchInlineSnapshot(`
-      ""
-      \`\`\`
-      Hey world
-      \`\`\`
-      ""
-    `)
+  it('converts a null to a valid typescript null value', () => {
+    const input: null = null
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('object') // null is an object in javascript
+    expect(actual).toEqual(input)
+  })
+  it('converts a symbol with name to a valid typescript symbol value', () => {
+    const input: symbol = Symbol('hello')
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('symbol')
+    expect(actual.description).toEqual(input.description)
+  })
+  it('converts a symbol without name to a valid typescript symbol value', () => {
+    const input: symbol = Symbol()
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('symbol')
+    expect(actual.description).toEqual(input.description)
+  })
+  it('converts a undefined to a valid typescript undefined value', () => {
+    const input: undefined = undefined
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('undefined')
+    expect(actual).toEqual(input)
+  })
+  it('converts a bigint to a valid typescript bigint value', () => {
+    const input: bigint = BigInt(42)
+    const tsValue: string = primitiveToTypescriptValue(input)
+    const actual = eval(tsValue)
+    expect(typeof actual).toEqual('bigint')
+    expect(actual).toEqual(input)
   })
 })
 

zui/src/transforms/zui-to-typescript-type/utils.ts

@@ -1,29 +1,57 @@
 import { camelCase, deburr } from '../../ui/utils'
+import { Primitive } from '../../z'
 
-export function escapeString(str: string) {
-  if (typeof str !== 'string') {
-    return ''
+/**
+ * @returns a valid typescript literal type usable in `type MyType = ${x}`
+ */
+export function primitiveToTypscriptLiteralType(x: Primitive): string {
+  if (typeof x === 'symbol') {
+    return 'symbol' // there's no way to represent a symbol literal in a single line with typescript
   }
+  if (typeof x === 'bigint') {
+    const str = x.toString()
+    return `${str}n`
+  }
+  return primitiveToTypescriptValue(x)
+}
 
-  // Use String.raw to get the raw string with escapes preserved
-  const rawStr = String.raw`${str}`
+/**
+ * @returns a valid typescript primitive value usable in `const myValue = ${x}`
+ */
+export function primitiveToTypescriptValue(x: Primitive): string {
+  if (typeof x === 'undefined') {
+    return 'undefined'
+  }
+  if (typeof x === 'symbol') {
+    if (x.description) {
+      return `Symbol(${primitiveToTypescriptValue(x.description)})`
+    }
+    return 'Symbol()'
+  }
+  if (typeof x === 'bigint') {
+    const str = x.toString()
+    return `BigInt(${str})`
+  }
+  return JSON.stringify(x)
+}
 
-  // Determine the appropriate quote style
-  if (rawStr.includes('`')) {
-    return `"${rawStr.replace(/"/g, '\\"')}"`
-  } else if (rawStr.includes("'")) {
-    return `'${rawStr.replace(/'/g, "\\'")}'`
-  } else {
-    return `'${rawStr}'`
+/**
+ * @returns a valid typescript value usable in `const myValue = ${x}`
+ */
+export function unknownToTypescriptValue(x: unknown): string {
+  if (typeof x === 'undefined') {
+    return 'undefined'
   }
+  // will fail or not behave as expected if x contains a symbol or a bigint
+  return JSON.stringify(x)
 }
 
 export const toPropertyKey = (key: string) => {
   if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
     return key
   }
 
-  return escapeString(key)
+  return primitiveToTypescriptValue(key)
 }
 
 const capitalize = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1)