fix(string): add missing implementation (#580)

* fix: throw error if faker instance is not set

* fix(string): should sometimes generate shorter string

* fix(string): implement

Author: soc221b

src/internals/random.ts

@@ -14,7 +14,11 @@ export function setFaker(faker: Faker): void {
  * Get the faker instance.
  */
 export function getFaker(): Faker {
-  return _faker!
+  if (_faker) {
+    return _faker
+  } else {
+    throw ReferenceError('Faker instance not set. Use `setFaker` to set it.')
+  }
 }
 
 const _simpleFaker = new SimpleFaker()

src/internals/schemas/checks/string-format.ts

@@ -1,4 +1,5 @@
 import * as core from 'zod/v4/core'
+import { HashFormat } from 'zod/v4/core/util'
 import { rootFake as internalFake } from '../../fake'
 import { getFaker, randexp } from '../../random'
 
@@ -7,7 +8,7 @@ export function fakeStringFormat<T extends core.$ZodStringFormat>(
   rootFake: typeof internalFake,
 ): undefined | string {
   let data = undefined
-  const format = schema._zod.def.format as core.$ZodStringFormats
+  const format = schema._zod.def.format as core.$ZodStringFormats | 'hex' | 'hostname' | 'httpUrl' | HashFormat
   switch (format) {
     case 'base64': {
       data = randexp(core.regexes.base64)
@@ -41,7 +42,14 @@ export function fakeStringFormat<T extends core.$ZodStringFormat>(
       break
     }
     case 'datetime': {
-      data = randexp(core.regexes.datetime({}))
+      const def = schema._zod.def as core.$ZodISODateTimeDef
+      data = randexp(
+        core.regexes.datetime({
+          local: def.local,
+          offset: def.offset,
+          precision: def.precision,
+        }),
+      )
       break
     }
     case 'duration': {
@@ -67,13 +75,25 @@ export function fakeStringFormat<T extends core.$ZodStringFormat>(
       break
     }
     case 'email': {
-      data = getFaker().internet.email()
+      data = randexp(new RegExp(schema._zod.def.pattern ?? core.regexes.email.source))
       break
     }
     case 'emoji': {
       data = '☘'
       break
     }
+    case 'hex': {
+      data = randexp(core.regexes.hex)
+      break
+    }
+    case 'hostname': {
+      data = getFaker().internet.domainName()
+      break
+    }
+    case 'httpUrl': {
+      data = getFaker().internet.url()
+      break
+    }
     case 'guid': {
       data = randexp(core.regexes.guid)
       break
@@ -87,13 +107,31 @@ export function fakeStringFormat<T extends core.$ZodStringFormat>(
       break
     }
     case 'jwt': {
-      data = getFaker().internet.jwt()
+      const def = schema._zod.def as core.$ZodJWTDef
+      data = getFaker().internet.jwt({
+        header: {
+          alg: def.alg || getFaker().internet.jwtAlgorithm(),
+          typ: 'JWT',
+        },
+      })
       break
     }
     case 'ksuid': {
       data = randexp(core.regexes.ksuid)
       break
     }
+    case 'md5_base64': {
+      data = randexp(core.regexes.md5_base64)
+      break
+    }
+    case 'md5_base64url': {
+      data = randexp(core.regexes.md5_base64url)
+      break
+    }
+    case 'md5_hex': {
+      data = randexp(core.regexes.md5_hex)
+      break
+    }
     case 'nanoid': {
       data = randexp(core.regexes.nanoid)
       break
@@ -102,20 +140,113 @@ export function fakeStringFormat<T extends core.$ZodStringFormat>(
       data = randexp(schema._zod.def.pattern!)
       break
     }
+    case 'sha1_base64': {
+      data = randexp(core.regexes.sha1_base64)
+      break
+    }
+    case 'sha1_base64url': {
+      data = randexp(core.regexes.sha1_base64url)
+      break
+    }
+    case 'sha1_hex': {
+      data = randexp(core.regexes.sha1_hex)
+      break
+    }
+    case 'sha256_base64': {
+      data = randexp(core.regexes.sha256_base64)
+      break
+    }
+    case 'sha256_base64url': {
+      data = randexp(core.regexes.sha256_base64url)
+      break
+    }
+    case 'sha256_hex': {
+      data = randexp(core.regexes.sha256_hex)
+      break
+    }
+    case 'sha384_base64': {
+      data = randexp(core.regexes.sha384_base64)
+      break
+    }
+    case 'sha384_base64url': {
+      data = randexp(core.regexes.sha384_base64url)
+      break
+    }
+    case 'sha384_hex': {
+      data = randexp(core.regexes.sha384_hex)
+      break
+    }
+    case 'sha512_base64': {
+      data = randexp(core.regexes.sha512_base64)
+      break
+    }
+    case 'sha512_base64url': {
+      data = randexp(core.regexes.sha512_base64url)
+      break
+    }
+    case 'sha512_hex': {
+      data = randexp(core.regexes.sha512_hex)
+      break
+    }
     case 'time': {
-      data = randexp(core.regexes.time({}))
+      const def = schema._zod.def as core.$ZodISOTimeDef
+      data = randexp(
+        core.regexes.time({
+          precision: def.precision,
+        }),
+      )
       break
     }
     case 'ulid': {
       data = randexp(core.regexes.ulid)
       break
     }
     case 'url': {
-      data = getFaker().internet.url()
+      const protocol = (schema as core.$ZodURL)._zod.def.protocol
+      const hostname = (schema as core.$ZodURL)._zod.def.hostname
+      if (protocol && hostname) {
+        data = randexp(protocol) + '://' + randexp(hostname)
+      } else if (protocol) {
+        data = randexp(protocol) + '://' + getFaker().internet.domainName()
+      } else if (hostname) {
+        data = 'https://' + randexp(hostname)
+      } else {
+        data = getFaker().internet.url()
+      }
       break
     }
     case 'uuid': {
-      data = randexp(core.regexes.uuid())
+      const version = (schema as core.$ZodUUID)._zod.def.version
+      switch (version) {
+        case 'v1':
+          data = randexp(core.regexes.uuid(1))
+          break
+        case 'v2':
+          data = randexp(core.regexes.uuid(2))
+          break
+        case 'v3':
+          data = randexp(core.regexes.uuid(3))
+          break
+        case 'v4':
+          data = randexp(core.regexes.uuid(4))
+          break
+        case 'v5':
+          data = randexp(core.regexes.uuid(5))
+          break
+        case 'v6':
+          data = randexp(core.regexes.uuid(6))
+          break
+        case 'v7':
+          data = randexp(core.regexes.uuid(7))
+          break
+        case 'v8':
+          data = randexp(core.regexes.uuid(8))
+          break
+        default: {
+          const _: undefined = version
+          data = randexp(core.regexes.uuid())
+        }
+      }
       break
     }
     case 'xid': {

src/internals/schemas/string.ts

@@ -121,7 +121,7 @@ export function fakeString<T extends core.$ZodString>(
     data = data.padEnd(min, ' ')
   }
   if (max !== undefined && data.length > max) {
-    data = data.slice(0, max)
+    data = data.slice(0, getFaker().number.int({ min, max }))
   }
   if (uppercase) {
     data = data.toUpperCase()

tests/mini.test.ts

@@ -319,7 +319,7 @@ const validSuits: { schema: z.ZodMiniType; description?: string; only?: boolean;
   {
     schema: (() => {
       const User = z.object({
-        email: z.email(),
+        email: z.email({ pattern: z.core.regexes.idnEmail }),
         get posts() {
           return z.array(Post)
         },
@@ -529,24 +529,74 @@ const validSuits: { schema: z.ZodMiniType; description?: string; only?: boolean;
   { schema: z.cuid2(), description: 'cuid2' },
   { schema: z.e164(), description: 'e164' },
   { schema: z.email(), description: 'email' },
-  { schema: z.email({ pattern: z.regexes.html5Email }), description: 'email html5' },
   { schema: z.email({ pattern: z.regexes.browserEmail }), description: 'email browser' },
+  { schema: z.email({ pattern: z.regexes.email }), description: 'email email' },
+  { schema: z.email({ pattern: z.regexes.idnEmail }), description: 'email idnEmail' },
+  { schema: z.email({ pattern: z.regexes.html5Email }), description: 'email html5' },
   { schema: z.email({ pattern: z.regexes.rfc5322Email }), description: 'email rfc5322' },
   { schema: z.email({ pattern: z.regexes.unicodeEmail }), description: 'email unicode' },
   { schema: z.emoji(), description: 'emoji' },
   { schema: z.guid(), description: 'guid' },
+  { schema: z.hash('md5'), description: 'hash md5' },
+  { schema: z.hash('md5', { enc: 'hex' }), description: 'hash md5 hex' },
+  { schema: z.hash('md5', { enc: 'base64' }), description: 'hash md5 base64' },
+  { schema: z.hash('md5', { enc: 'base64url' }), description: 'hash md5 base64url' },
+  { schema: z.hash('sha1'), description: 'hash sha1' },
+  { schema: z.hash('sha1', { enc: 'hex' }), description: 'hash sha1 hex' },
+  { schema: z.hash('sha1', { enc: 'base64' }), description: 'hash sha1 base64' },
+  { schema: z.hash('sha1', { enc: 'base64url' }), description: 'hash sha1 base64url' },
+  { schema: z.hash('sha256'), description: 'hash sha256' },
+  { schema: z.hash('sha256', { enc: 'hex' }), description: 'hash sha256 hex' },
+  { schema: z.hash('sha256', { enc: 'base64' }), description: 'hash sha256 base64' },
+  { schema: z.hash('sha256', { enc: 'base64url' }), description: 'hash sha256 base64url' },
+  { schema: z.hash('sha384'), description: 'hash sha384' },
+  { schema: z.hash('sha384', { enc: 'hex' }), description: 'hash sha384 hex' },
+  { schema: z.hash('sha384', { enc: 'base64' }), description: 'hash sha384 base64' },
+  { schema: z.hash('sha384', { enc: 'base64url' }), description: 'hash sha384 base64url' },
+  { schema: z.hash('sha512'), description: 'hash sha512' },
+  { schema: z.hash('sha512', { enc: 'hex' }), description: 'hash sha512 hex' },
+  { schema: z.hash('sha512', { enc: 'base64' }), description: 'hash sha512 base64' },
+  { schema: z.hash('sha512', { enc: 'base64url' }), description: 'hash sha512 base64url' },
+  { schema: z.hex(), description: 'hex' },
+  { schema: z.hostname(), description: 'hostname' },
+  { schema: z.httpUrl(), description: 'httpUrl' },
   { schema: z.ipv4(), description: 'ipv4' },
   { schema: z.ipv6(), description: 'ipv6' },
   { schema: z.iso.date(), description: 'date' },
   { schema: z.iso.datetime(), description: 'datetime' },
+  { schema: z.iso.datetime({ local: true }), description: 'datetime local' },
+  { schema: z.iso.datetime({ offset: true }), description: 'datetime offset' },
+  { schema: z.iso.datetime({ precision: 3 }), description: 'datetime precision' },
   { schema: z.iso.duration(), description: 'duration' },
   { schema: z.iso.time(), description: 'time' },
+  { schema: z.iso.time({ precision: 9 }), description: 'time precision' },
   { schema: z.jwt(), description: 'jwt' },
+  { schema: z.jwt({ alg: 'HS256' }), description: 'jwt alg' },
   { schema: z.ksuid(), description: 'ksuid' },
   { schema: z.nanoid(), description: 'naoid' },
   { schema: z.ulid(), description: 'ulid' },
   { schema: z.url(), description: 'url' },
+  { schema: z.url({ hostname: /^example\.com$/ }), description: 'url hostname' },
+  { schema: z.url({ protocol: /^https$/ }), description: 'url protocol' },
+  {
+    schema: z.url({
+      protocol: /^https?$/,
+      hostname: z.regexes.domain,
+    }),
+    description: 'url protocol hostname',
+  },
   { schema: z.uuid(), description: 'uuid' },
+  { schema: z.uuid({ version: 'v1' }), description: 'uuid v1' },
+  { schema: z.uuid({ version: 'v2' }), description: 'uuid v2' },
+  { schema: z.uuid({ version: 'v3' }), description: 'uuid v3' },
+  { schema: z.uuid({ version: 'v4' }), description: 'uuid v4' },
+  { schema: z.uuid({ version: 'v5' }), description: 'uuid v5' },
+  { schema: z.uuid({ version: 'v6' }), description: 'uuid v6' },
+  { schema: z.uuid({ version: 'v7' }), description: 'uuid v7' },
+  { schema: z.uuid({ version: 'v8' }), description: 'uuid v8' },
+  { schema: z.uuidv4(), description: 'uuidv4' },
+  { schema: z.uuidv6(), description: 'uuidv6' },
+  { schema: z.uuidv7(), description: 'uuidv7' },
   { schema: z.xid(), description: 'xid' },
   {
     schema: z.string().check(z.minLength(5), z.minLength(3), z.minLength(4), z.maxLength(5)),

tests/random.test.ts

@@ -6,9 +6,7 @@ import { getFaker, randexp, seed, setFaker } from '../src/internals/random'
 
 describe('@faker-js/faker', () => {
   it('does not have a default faker', () => {
-    const faker = getFaker()
-
-    expect(faker).toBeUndefined()
+    expect(() => getFaker()).toThrow()
   })
 
   it('can set a faker', () => {