fix(zui): do not generate .optional().secret() (#626)

Author: pascal-botpress

zui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpinternal/zui",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A fork of Zod with additional features",
   "type": "module",
   "source": "./src/index.ts",
@@ -55,4 +55,4 @@
     "pnpm": "8.6.2"
   },
   "packageManager": "[email protected]"
-}
+}

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test, it } from 'vitest'
 import { toTypescriptSchema as toTypescript } from '.'
 import { evalZuiString } from '../common/eval-zui-string'
 import * as errors from '../common/errors'
@@ -30,7 +30,7 @@ const assert = (source: ZodType) => ({
   },
 })
 
-describe.concurrent('toTypescriptZuiString', () => {
+describe.concurrent('toTypescriptSchema', () => {
   describe.concurrent('string', () => {
     test('no checks', () => {
       const schema = z.string()
@@ -152,6 +152,62 @@ describe.concurrent('toTypescriptZuiString', () => {
       const evaluated = generate(schema)
       expect(evaluated._def.checks).toEqual([{ kind: 'ip', message: undefined }])
     })
+
+    describe.concurrent('optional', () => {
+      it('should preserve .secret modifier', () => {
+        // Arrange
+        const schema = z.string().secret().optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().secret(')
+      })
+
+      it('should preserve .disabled modifier', () => {
+        // Arrange
+        const schema = z.string().disabled().optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().disabled(')
+      })
+
+      it('should preserve .hidden modifier', () => {
+        // Arrange
+        const schema = z.string().hidden().optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().hidden(')
+      })
+
+      it('should preserve .title modifier', () => {
+        // Arrange
+        const schema = z.string().title('a').optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().title(')
+      })
+
+      it('should preserve .placeholder modifier', () => {
+        // Arrange
+        const schema = z.string().placeholder('a').optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().placeholder(')
+      })
+
+      it('should preserve .displayAs modifier', () => {
+        // Arrange
+        const schema = z.string().displayAs({ id: '', params: {} }).optional()
+
+        // Act & Assert
+        assert(schema).toGenerateItself()
+        expect(toTypescript(schema)).toContain('z.string().displayAs(')
+      })
+    })
   })
   describe.concurrent('number', () => {
     test('no checks', () => {

zui/src/z/types/basetype/index.ts

@@ -134,13 +134,13 @@ export type RawCreateParams =
       invalid_type_error?: string
       required_error?: string
       description?: string
-      [zuiKey]?: any
+      [zuiKey]?: ZuiExtensionObject
     }
   | undefined
 export type ProcessedCreateParams = {
   errorMap?: ZodErrorMap
   description?: string
-  [zuiKey]?: any
+  [zuiKey]?: ZuiExtensionObject
 }
 export type SafeParseSuccess<Output> = {
   success: true

zui/src/z/types/string/index.ts

@@ -523,7 +523,7 @@ export class ZodString extends ZodType<string, ZodStringDef> {
       checks: [],
       typeName: ZodFirstPartyTypeKind.ZodString,
       coerce: params?.coerce ?? false,
-      ...processCreateParams(params),
+      ...processCreateParams({ ...params, supportsExtensions: ['secret'] }),
     })
   }
 

zui/src/z/types/utils/index.ts

@@ -232,16 +232,32 @@ export const getParsedType = (data: any): ZodParsedType => {
       return ZodParsedType.unknown
   }
 }
-export function processCreateParams(params: RawCreateParams): ProcessedCreateParams {
+
+export function processCreateParams(
+  params: RawCreateParams & ({ supportsExtensions?: 'secret'[] } | undefined),
+): ProcessedCreateParams {
   if (!params) return {}
 
-  const { errorMap, invalid_type_error, required_error, description } = params
+  const {
+    errorMap,
+    invalid_type_error,
+    required_error,
+    description,
+    supportsExtensions,
+    [zuiKey]: zuiExtensions,
+  } = params
 
   if (errorMap && (invalid_type_error || required_error)) {
     throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`)
   }
 
-  if (errorMap) return { errorMap: errorMap, description, [zuiKey]: params?.[zuiKey] }
+  const filteredZuiExtensions = zuiExtensions
+    ? Object.fromEntries(
+        Object.entries(zuiExtensions).filter(([key]) => key !== 'secret' || supportsExtensions?.includes('secret')),
+      )
+    : undefined
+
+  if (errorMap) return { errorMap: errorMap, description, [zuiKey]: filteredZuiExtensions }
 
   const customMap: ZodErrorMap = (iss, ctx) => {
     if (iss.code !== 'invalid_type') return { message: ctx.defaultError }
@@ -250,5 +266,5 @@ export function processCreateParams(params: RawCreateParams): ProcessedCreatePar
     }
     return { message: invalid_type_error ?? ctx.defaultError }
   }
-  return { errorMap: customMap, description, [zuiKey]: params?.[zuiKey] }
+  return { errorMap: customMap, description, [zuiKey]: filteredZuiExtensions }
 }