refactor!: move parse and safeParse to top level and rename ~build to build (#15)

Author: schplitt

packages/bench/bench/number.bench.ts

@@ -13,13 +13,13 @@ const invalidNumber = 142
 const spurAsyncUnbuild = spurNumberAsync().min(0).max(100)
 
 // Spur async schemas (with constraints)
-const spurAsyncBuilt = await (spurNumberAsync().min(0).max(100))['~build']()
+const spurAsyncBuilt = await (spurNumberAsync().min(0).max(100)).build()
 
 // Spur sync schemas (with constraints)
-const spurSyncBuilt = spurNumberSync().min(0).max(100)['~build']()
+const spurSyncBuilt = spurNumberSync().min(0).max(100).build()
 
 // Spur inline schemas (with constraints)
-const spurInlineBuilt = await spurNumberInline().min(0).max(100)['~build']()
+const spurInlineBuilt = await spurNumberInline().min(0).max(100).build()
 
 // Zod schemas (with constraints)
 const zValid = z.number().min(0).max(100)

packages/bench/bench/string.bench.ts

@@ -1,6 +1,5 @@
-import { safeParse as safeParseAsync, string as spurStringAsync } from 'spur'
-import { safeParse as safeParseInlined, string as spurStringInline } from 'spur/inline'
-import { safeParse as safeParseSync, string as spurStringSync } from 'spur/sync'
+import { string as spurStringAsync } from 'spur'
+import { string as spurStringInline } from 'spur/inline'
 
 import * as v from 'valibot'
 import { bench, describe } from 'vitest'
@@ -13,13 +12,10 @@ const invalidString = 'a'
 const spurAsyncUnbuild = spurStringAsync().minLength(3).maxLength(12)
 
 // Async spur schemas (built once)
-const spurAsyncBuilt = await spurStringAsync().minLength(3).maxLength(12)['~build']()
-
-// Sync spur schemas
-const spurSyncBuilt = spurStringSync().minLength(3).maxLength(12)['~build']()
+const spurAsyncBuilt = await spurStringAsync().minLength(3).maxLength(12).build()
 
 // Inline spur schemas
-const spurInlineBuilt = await spurStringInline().minLength(3).maxLength(12)['~build']()
+const spurInlineBuilt = await spurStringInline().minLength(3).maxLength(12).build()
 
 // Zod
 const zValid = z.string().min(3).max(12)
@@ -29,16 +25,13 @@ const vSchema = v.pipe(v.string(), v.minLength(3), v.maxLength(12))
 
 describe('string: valid parse', () => {
   bench('spur unbuild async valid', () => {
-    safeParseAsync(spurAsyncUnbuild, validString)
+    spurAsyncUnbuild.safeParse(validString)
   })
   bench('spur async valid', () => {
-    safeParseAsync(spurAsyncBuilt, validString)
-  })
-  bench('spur sync valid', () => {
-    safeParseSync(spurSyncBuilt, validString)
+    spurAsyncBuilt.safeParse(validString)
   })
   bench('spur inline valid', () => {
-    safeParseInlined(spurInlineBuilt, validString)
+    spurInlineBuilt.safeParse(validString)
   })
   bench('zod valid', () => {
     zValid.safeParse(validString)
@@ -50,16 +43,13 @@ describe('string: valid parse', () => {
 
 describe('string: invalid parse', () => {
   bench('spur unbuild async invalid', () => {
-    safeParseAsync(spurAsyncUnbuild, invalidString)
+    spurAsyncUnbuild.safeParse(validString)
   })
   bench('spur async invalid', () => {
-    safeParseAsync(spurAsyncBuilt, invalidString)
-  })
-  bench('spur sync invalid', () => {
-    safeParseSync(spurSyncBuilt, invalidString)
+    spurAsyncBuilt.safeParse(validString)
   })
   bench('spur inline invalid', () => {
-    safeParseInlined(spurInlineBuilt, invalidString)
+    spurInlineBuilt.safeParse(invalidString)
   })
   bench('zod invalid', () => {
     zValid.safeParse(invalidString)

packages/spur/src/__tests__/leitplanken/array.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
 
-import { parse, safeParse } from '../../index'
 import { array } from '../../leitplanken/array'
 import { number } from '../../leitplanken/number'
 import { string } from '../../leitplanken/string'
@@ -9,35 +8,35 @@ describe('array schema', () => {
   it('parses arrays when every element matches the child schema', async () => {
     const schema = array(string().minLength(2))
 
-    await expect(parse(schema, ['hi', 'there'])).resolves.toEqual(['hi', 'there'])
+    await expect(schema.parse(['hi', 'there'])).resolves.toEqual(['hi', 'there'])
   })
 
   it('fails when at least one element violates the child schema', async () => {
     const schema = array(number().min(0))
 
-    const report = await safeParse(schema, [1, -1])
+    const report = await schema.safeParse([1, -1])
 
     expect(report.passed).toBe(false)
   })
 
   it('supports optional modifier on the array schema', async () => {
     const schema = array(string()).optional()
 
-    const report = await safeParse(schema, undefined)
+    const report = await schema.safeParse(undefined)
     expect(report.passed).toBe(true)
     expect(report.value).toBeUndefined()
   })
 
   it('enforces array-level minLength constraint', async () => {
     const schema = array(string()).minLength(2)
 
-    const report = await safeParse(schema, ['only-one'])
+    const report = await schema.safeParse(['only-one'])
     expect(report.passed).toBe(false)
   })
 
   it('allows transforming the parsed array result', async () => {
     const schema = array(number()).transform(values => values.reduce((total, value) => total + value, 0))
 
-    await expect(parse(schema, [1, 2, 3])).resolves.toBe(6)
+    await expect(schema.parse([1, 2, 3])).resolves.toBe(6)
   })
 })

packages/spur/src/__tests__/leitplanken/boolean.test.ts

@@ -1,18 +1,18 @@
 import { describe, expect, it } from 'vitest'
 
-import { boolean, parse, safeParse } from '../../index'
+import { boolean } from '../../index'
 
 describe('boolean schema', () => {
   it('accepts boolean values', async () => {
     const schema = boolean()
 
-    await expect(parse(schema, true)).resolves.toBe(true)
-    await expect(parse(schema, false)).resolves.toBe(false)
+    await expect(schema.parse(true)).resolves.toBe(true)
+    await expect(schema.parse(false)).resolves.toBe(false)
   })
 
   it('rejects non-boolean values', async () => {
     const schema = boolean()
-    const report = await safeParse(schema, 'not-boolean')
+    const report = await schema.safeParse('not-boolean')
 
     expect(report.passed).toBe(false)
     expect('value' in report).toBe(false)
@@ -21,22 +21,22 @@ describe('boolean schema', () => {
   it('supports optional modifier', async () => {
     const schema = boolean().optional()
 
-    const hit = await safeParse(schema, true)
+    const hit = await schema.safeParse(true)
     expect(hit.passed).toBe(true)
     expect(hit.value).toBe(true)
 
-    const optionalReport = await safeParse(schema, undefined)
+    const optionalReport = await schema.safeParse(undefined)
     expect(optionalReport.passed).toBe(true)
     expect(optionalReport.value).toBeUndefined()
 
-    const nullReport = await safeParse(schema, null)
+    const nullReport = await schema.safeParse(null)
     expect(nullReport.passed).toBe(false)
   })
 
   it('supports exactOptional modifier', async () => {
     const schema = boolean().exactOptional()
 
-    const report = await safeParse(schema, undefined)
+    const report = await schema.safeParse(undefined)
     expect(report.passed).toBe(true)
     if (report.passed) {
       expect(report.value).toBeUndefined()
@@ -46,68 +46,68 @@ describe('boolean schema', () => {
   it('supports undefinable modifier', async () => {
     const schema = boolean().undefinable()
 
-    const undefReport = await safeParse(schema, undefined)
+    const undefReport = await schema.safeParse(undefined)
     expect(undefReport.passed).toBe(true)
     expect(undefReport.value).toBeUndefined()
 
-    const nullReport = await safeParse(schema, null)
+    const nullReport = await schema.safeParse(null)
     expect(nullReport.passed).toBe(false)
   })
 
   it('supports nullable modifier', async () => {
     const schema = boolean().nullable()
 
-    const nullReport = await safeParse(schema, null)
+    const nullReport = await schema.safeParse(null)
     expect(nullReport.passed).toBe(true)
     expect(nullReport.value).toBeNull()
 
-    const undefinedReport = await safeParse(schema, undefined)
+    const undefinedReport = await schema.safeParse(undefined)
     expect(undefinedReport.passed).toBe(false)
   })
 
   it('supports nullish modifier', async () => {
     const schema = boolean().nullish()
 
-    const undefinedReport = await safeParse(schema, undefined)
+    const undefinedReport = await schema.safeParse(undefined)
     expect(undefinedReport.passed).toBe(true)
     expect(undefinedReport.value).toBeUndefined()
 
-    const nullReport = await safeParse(schema, null)
+    const nullReport = await schema.safeParse(null)
     expect(nullReport.passed).toBe(true)
     expect(nullReport.value).toBeNull()
   })
 
   it('supports default modifier', async () => {
     const schema = boolean().default(true)
 
-    await expect(parse(schema, undefined)).resolves.toBe(true)
-    await expect(parse(schema, null)).resolves.toBe(true)
-    await expect(parse(schema, false)).resolves.toBe(false)
+    await expect(schema.parse(undefined)).resolves.toBe(true)
+    await expect(schema.parse(null)).resolves.toBe(true)
+    await expect(schema.parse(false)).resolves.toBe(false)
   })
 
   it('applies required after optional', async () => {
     const schema = boolean().optional().required()
 
-    const report = await safeParse(schema, undefined)
+    const report = await schema.safeParse(undefined)
     expect(report.passed).toBe(false)
   })
 
   it('uses last optionality modifier wins semantics', async () => {
     const optionalThenNullable = boolean().optional().nullable()
     const nullableThenOptional = boolean().nullable().optional()
 
-    const optionalThenNullableNull = await safeParse(optionalThenNullable, null)
+    const optionalThenNullableNull = await optionalThenNullable.safeParse(null)
     expect(optionalThenNullableNull.passed).toBe(true)
     expect(optionalThenNullableNull.value).toBeNull()
 
-    const optionalThenNullableUndefined = await safeParse(optionalThenNullable, undefined)
+    const optionalThenNullableUndefined = await optionalThenNullable.safeParse(undefined)
     expect(optionalThenNullableUndefined.passed).toBe(false)
 
-    const nullableThenOptionalUndefined = await safeParse(nullableThenOptional, undefined)
+    const nullableThenOptionalUndefined = await nullableThenOptional.safeParse(undefined)
     expect(nullableThenOptionalUndefined.passed).toBe(true)
     expect(nullableThenOptionalUndefined.value).toBeUndefined()
 
-    const nullableThenOptionalNull = await safeParse(nullableThenOptional, null)
+    const nullableThenOptionalNull = await nullableThenOptional.safeParse(null)
     expect(nullableThenOptionalNull.passed).toBe(false)
   })
 })