@vertz/schema 0.1.0 → 0.2.1

package/README.md

@@ -0,0 +1,543 @@
+# @vertz/schema
+
+Type-safe validation with end-to-end type inference. Define schemas with a fluent API, get full TypeScript types automatically.
+
+## Installation
+
+```bash
+bun add @vertz/schema
+```
+
+## Quick Start
+
+```typescript
+import { s, type Infer } from '@vertz/schema';
+
+// Define a schema
+const userSchema = s.object({
+  name: s.string().min(1),
+  email: s.email(),
+  age: s.number().int().min(18),
+});
+
+// Infer the type
+type User = Infer<typeof userSchema>;
+// { name: string; email: string; age: number }
+
+// Parse (throws on invalid)
+const user = userSchema.parse({
+  name: 'Alice',
+  email: 'alice@example.com',
+  age: 25,
+});
+
+// Safe parse (never throws)
+const result = userSchema.safeParse(data);
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.log(result.error.issues);
+}
+```
+
+## Schema Types
+
+### Primitives
+
+```typescript
+s.string()      // string
+s.number()      // number
+s.boolean()     // boolean
+s.bigint()      // bigint
+s.date()        // Date
+s.symbol()      // symbol
+s.int()         // number (integer-only)
+s.nan()         // NaN
+```
+
+### Special Types
+
+```typescript
+s.any()         // any
+s.unknown()     // unknown
+s.null()        // null
+s.undefined()   // undefined
+s.void()        // void
+s.never()       // never
+```
+
+### Composites
+
+```typescript
+// Objects
+s.object({
+  name: s.string(),
+  age: s.number(),
+})
+
+// Arrays
+s.array(s.number())
+
+// Tuples
+s.tuple([s.string(), s.number()])
+
+// Enums
+s.enum(['admin', 'user', 'guest'])
+
+// Literals
+s.literal('active')
+
+// Unions
+s.union([s.string(), s.number()])
+
+// Discriminated unions
+s.discriminatedUnion('type', [
+  s.object({ type: s.literal('text'), content: s.string() }),
+  s.object({ type: s.literal('image'), url: s.url() }),
+])
+
+// Intersections
+s.intersection(
+  s.object({ id: s.string() }),
+  s.object({ name: s.string() }),
+)
+
+// Records (dynamic keys)
+s.record(s.string())
+
+// Maps
+s.map(s.string(), s.number())
+
+// Sets
+s.set(s.string())
+
+// Files
+s.file()
+
+// Custom validators
+s.custom<number>(
+  (val) => typeof val === 'number' && val % 2 === 0,
+  'Must be an even number',
+)
+
+// Instance checks
+s.instanceof(Date)
+
+// Recursive types
+s.lazy(() => categorySchema)
+```
+
+### Format Validators
+
+Built-in validators for common formats:
+
+```typescript
+s.email()         // Email address
+s.uuid()          // UUID
+s.url()           // HTTP(S) URL
+s.hostname()      // Valid hostname
+s.ipv4()          // IPv4 address
+s.ipv6()          // IPv6 address
+s.base64()        // Base64 string
+s.hex()           // Hexadecimal string
+s.jwt()           // JWT token (format only)
+s.cuid()          // CUID
+s.ulid()          // ULID
+s.nanoid()        // Nano ID
+
+// ISO formats
+s.iso.date()      // YYYY-MM-DD
+s.iso.time()      // HH:MM:SS
+s.iso.datetime()  // ISO 8601 datetime
+s.iso.duration()  // ISO 8601 duration (P1Y2M3D)
+```
+
+### Database Enum Bridge
+
+```typescript
+// Convert a @vertz/db enum column to a schema
+s.fromDbEnum(statusColumn)
+```
+
+## Modifiers
+
+### Optional & Nullable
+
+```typescript
+s.string().optional()         // string | undefined
+s.string().nullable()         // string | null
+s.string().nullable().optional()  // string | null | undefined
+```
+
+### Default Values
+
+```typescript
+s.string().default('hello')
+s.number().default(() => Math.random())
+
+s.string().default('hello').parse(undefined)  // 'hello'
+```
+
+### Transformations
+
+```typescript
+s.string().transform((val) => val.toUpperCase())
+s.string().trim().transform((s) => s.split(','))
+```
+
+### Refinements
+
+```typescript
+// Simple predicate
+s.string().refine(
+  (val) => val.includes('@'),
+  { message: 'Must contain @' },
+)
+
+// Multiple refinements
+s.string()
+  .min(8)
+  .refine((val) => /[A-Z]/.test(val), { message: 'Need uppercase' })
+  .refine((val) => /[0-9]/.test(val), { message: 'Need digit' })
+```
+
+### Super Refine
+
+Access the refinement context for cross-field validation:
+
+```typescript
+s.object({
+  password: s.string(),
+  confirm: s.string(),
+}).superRefine((data, ctx) => {
+  if (data.password !== data.confirm) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['confirm'],
+      message: 'Passwords must match',
+    });
+  }
+})
+```
+
+### Branded Types
+
+```typescript
+const UserId = s.string().uuid().brand('UserId');
+const PostId = s.string().uuid().brand('PostId');
+
+type UserId = Infer<typeof UserId>;  // string & { __brand: 'UserId' }
+type PostId = Infer<typeof PostId>;  // string & { __brand: 'PostId' }
+
+function getUser(id: UserId) { /* ... */ }
+getUser(UserId.parse('...'));  // OK
+getUser(PostId.parse('...'));  // Type error
+```
+
+### Catch (Error Recovery)
+
+```typescript
+s.number().catch(0).parse('invalid')  // 0
+```
+
+### Readonly
+
+```typescript
+s.object({ tags: s.array(s.string()) }).readonly()
+// Readonly<{ tags: readonly string[] }>
+```
+
+### Pipe
+
+Chain schemas sequentially:
+
+```typescript
+s.string().pipe(s.coerce.number())
+```
+
+## String Validations
+
+```typescript
+s.string()
+  .min(3)                  // min length
+  .max(20)                 // max length
+  .length(10)              // exact length
+  .regex(/^[a-z]+$/)       // pattern
+  .startsWith('hello')
+  .endsWith('world')
+  .includes('mid')
+  .uppercase()             // must be uppercase
+  .lowercase()             // must be lowercase
+  .trim()                  // trims whitespace (transform)
+  .toLowerCase()           // converts to lowercase (transform)
+  .toUpperCase()           // converts to uppercase (transform)
+```
+
+## Number Validations
+
+```typescript
+s.number()
+  .int()                   // integer only
+  .positive()              // > 0
+  .negative()              // < 0
+  .nonnegative()           // >= 0
+  .nonpositive()           // <= 0
+  .min(0)                  // >= n
+  .max(100)                // <= n
+  .gt(0)                   // > n
+  .lt(100)                 // < n
+  .multipleOf(5)           // divisible by n
+  .finite()                // no Infinity
+```
+
+## Array Validations
+
+```typescript
+s.array(s.string())
+  .min(1)                  // at least 1 element
+  .max(10)                 // at most 10 elements
+  .length(5)               // exactly 5 elements
+```
+
+## Object Methods
+
+```typescript
+const base = s.object({ id: s.string(), name: s.string(), email: s.email() });
+
+base.pick('id', 'name')           // { id: string; name: string }
+base.omit('email')                // { id: string; name: string }
+base.partial()                    // { id?: string; name?: string; email?: string }
+base.required()                   // all fields required
+base.extend({ age: s.number() }) // add fields
+base.merge(otherSchema)          // merge two object schemas
+base.strict()                    // reject unknown keys
+base.passthrough()               // pass through unknown keys
+base.catchall(s.string())        // validate unknown keys with schema
+base.keyof()                     // ['id', 'name', 'email']
+```
+
+## Tuple Rest Elements
+
+```typescript
+s.tuple([s.string(), s.number()]).rest(s.boolean())
+// [string, number, ...boolean[]]
+```
+
+## Parsing
+
+### `.parse(data)`
+
+Returns the parsed value. Throws `ParseError` on failure:
+
+```typescript
+try {
+  const value = schema.parse(data);
+} catch (error) {
+  if (error instanceof ParseError) {
+    console.log(error.issues);
+  }
+}
+```
+
+### `.safeParse(data)`
+
+Returns a result object. Never throws:
+
+```typescript
+const result = schema.safeParse(data);
+
+if (result.success) {
+  result.data   // parsed value
+} else {
+  result.error  // ParseError
+  result.error.issues  // ValidationIssue[]
+}
+```
+
+## Type Inference
+
+```typescript
+import type { Infer, Input, Output } from '@vertz/schema';
+
+const schema = s.string().transform((s) => s.length);
+
+type In = Input<typeof schema>;   // string
+type Out = Output<typeof schema>; // number
+type Out2 = Infer<typeof schema>; // number (alias for Output)
+
+// Also available as instance properties:
+type In3 = typeof schema._input;
+type Out3 = typeof schema._output;
+```
+
+## Coercion
+
+Convert values to the target type before validation:
+
+```typescript
+s.coerce.string()   // String(value)
+s.coerce.number()   // Number(value)
+s.coerce.boolean()  // Boolean(value)
+s.coerce.bigint()   // BigInt(value)
+s.coerce.date()     // new Date(value)
+
+s.coerce.number().parse('42')  // 42
+s.coerce.date().parse('2024-01-01')  // Date object
+```
+
+## Error Handling
+
+### ParseError
+
+```typescript
+import { ParseError } from '@vertz/schema';
+
+const result = schema.safeParse(data);
+
+if (!result.success) {
+  for (const issue of result.error.issues) {
+    console.log(issue.code);     // 'invalid_type', 'too_small', etc.
+    console.log(issue.message);  // human-readable message
+    console.log(issue.path);     // ['address', 'street']
+  }
+}
+```
+
+### Error Codes
+
+```typescript
+import { ErrorCode } from '@vertz/schema';
+
+ErrorCode.InvalidType        // 'invalid_type'
+ErrorCode.TooSmall           // 'too_small'
+ErrorCode.TooBig             // 'too_big'
+ErrorCode.InvalidString      // 'invalid_string'
+ErrorCode.InvalidEnumValue   // 'invalid_enum_value'
+ErrorCode.InvalidLiteral     // 'invalid_literal'
+ErrorCode.InvalidUnion       // 'invalid_union'
+ErrorCode.InvalidDate        // 'invalid_date'
+ErrorCode.MissingProperty    // 'missing_property'
+ErrorCode.UnrecognizedKeys   // 'unrecognized_keys'
+ErrorCode.Custom             // 'custom'
+ErrorCode.NotMultipleOf      // 'not_multiple_of'
+ErrorCode.NotFinite          // 'not_finite'
+```
+
+## Result Type
+
+Errors-as-values pattern for explicit error handling without try/catch:
+
+```typescript
+import { ok, err, unwrap, map, flatMap, match, matchErr } from '@vertz/schema';
+import type { Result, Ok, Err } from '@vertz/schema';
+
+// Create results
+const success: Result<number, string> = ok(42);
+const failure: Result<number, string> = err('not found');
+
+// Check and extract
+if (success.ok) {
+  success.data  // 42
+}
+if (failure.ok === false) {
+  failure.error  // 'not found'
+}
+
+// Unwrap (throws if Err)
+const value = unwrap(success);  // 42
+
+// Map success value
+const doubled = map(success, (n) => n * 2);  // Ok(84)
+
+// Chain Result-returning functions
+const chained = flatMap(success, (n) =>
+  n > 0 ? ok(n.toString()) : err('must be positive')
+);
+
+// Pattern matching
+const message = match(result, {
+  ok: (data) => `Got ${data}`,
+  err: (error) => `Failed: ${error}`,
+});
+
+// Exhaustive error matching by code
+const handled = matchErr(result, {
+  ok: (data) => data,
+  NOT_FOUND: (e) => fallback,
+  CONFLICT: (e) => retry(),
+});
+```
+
+The `Result` type is used throughout `@vertz/db` for all query methods.
+
+## JSON Schema Generation
+
+```typescript
+import { toJSONSchema } from '@vertz/schema';
+
+const schema = s.object({
+  name: s.string().min(1),
+  age: s.number().int().min(0),
+});
+
+const jsonSchema = toJSONSchema(schema);
+// {
+//   type: 'object',
+//   properties: {
+//     name: { type: 'string', minLength: 1 },
+//     age: { type: 'integer', minimum: 0 }
+//   },
+//   required: ['name', 'age']
+// }
+
+// Also available as instance method:
+schema.toJSONSchema()
+```
+
+## Schema Registry
+
+Register and retrieve schemas by name:
+
+```typescript
+import { SchemaRegistry } from '@vertz/schema';
+
+// Register via .id()
+const userSchema = s.object({ name: s.string() }).id('User');
+
+// Retrieve
+const schema = SchemaRegistry.get('User');
+SchemaRegistry.has('User');      // true
+SchemaRegistry.getAll();         // Map<string, Schema>
+```
+
+## Schema Metadata
+
+```typescript
+const schema = s.string()
+  .id('Username')
+  .describe('The user display name')
+  .meta({ deprecated: true })
+  .example('alice');
+
+schema.metadata.id           // 'Username'
+schema.metadata.description  // 'The user display name'
+schema.metadata.meta         // { deprecated: true }
+schema.metadata.examples     // ['alice']
+```
+
+## Preprocessing
+
+Transform raw input before schema validation:
+
+```typescript
+import { preprocess } from '@vertz/schema';
+
+const schema = preprocess(
+  (val) => typeof val === 'string' ? val.trim() : val,
+  s.string().min(1),
+);
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -56,6 +56,8 @@ declare class RefTracker {
 	getDefs(): Record<string, JSONSchemaObject>;
 }
 declare function toJSONSchema2(schema: SchemaAny): JSONSchemaObject;
+import { Err, Ok, Result } from "@vertz/errors";
+import { err, flatMap, isErr, isOk, map, match, matchErr, ok, unwrap } from "@vertz/errors";
 declare enum SchemaType {
 	String = "string",
 	Number = "number",
@@ -93,13 +95,6 @@ interface SchemaMetadata {
 	meta: Record<string, unknown> | undefined;
 	examples: unknown[];
 }
-type SafeParseResult<T> = {
-	success: true;
-	data: T;
-} | {
-	success: false;
-	error: ParseError;
-};
 type SchemaAny = Schema<any, any>;
 /** Apply Readonly only to object types; leave primitives and `any` unchanged. */
 type ReadonlyOutput<O> = 0 extends 1 & O ? O : O extends object ? Readonly<O> : O;
@@ -119,8 +114,8 @@ declare abstract class Schema<
 	abstract _schemaType(): SchemaType;
 	abstract _toJSONSchema(tracker: RefTracker): JSONSchemaObject;
 	abstract _clone(): Schema<O, I>;
-	parse(value: unknown): O;
-	safeParse(value: unknown): SafeParseResult<O>;
+	parse(value: unknown): Result<O, ParseError>;
+	safeParse(value: unknown): Result<O, ParseError>;
 	id(name: string): this;
 	describe(description: string): this;
 	meta(data: Record<string, unknown>): this;
@@ -380,26 +375,26 @@ declare class StringSchema extends Schema<string> {
 	private _toUpperCase;
 	private _normalize;
 	_parse(value: unknown, ctx: ParseContext): string;
-	min(n: number, message?: string): StringSchema;
-	max(n: number, message?: string): StringSchema;
-	length(n: number, message?: string): StringSchema;
-	regex(pattern: RegExp): StringSchema;
-	startsWith(prefix: string): StringSchema;
-	endsWith(suffix: string): StringSchema;
-	includes(substring: string): StringSchema;
-	uppercase(): StringSchema;
-	lowercase(): StringSchema;
-	trim(): StringSchema;
-	toLowerCase(): StringSchema;
-	toUpperCase(): StringSchema;
-	normalize(): StringSchema;
+	min(n: number, message?: string): this;
+	max(n: number, message?: string): this;
+	length(n: number, message?: string): this;
+	regex(pattern: RegExp): this;
+	startsWith(prefix: string): this;
+	endsWith(suffix: string): this;
+	includes(substring: string): this;
+	uppercase(): this;
+	lowercase(): this;
+	trim(): this;
+	toLowerCase(): this;
+	toUpperCase(): this;
+	normalize(): this;
 	_schemaType(): SchemaType;
 	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
-	_clone(): StringSchema;
+	_clone(): this;
 }
 declare class CoercedStringSchema extends StringSchema {
 	_parse(value: unknown, ctx: ParseContext): string;
-	_clone(): CoercedStringSchema;
+	_clone(): this;
 }
 declare class CoercedNumberSchema extends NumberSchema {
 	_parse(value: unknown, ctx: ParseContext): number;
@@ -465,6 +460,8 @@ declare class DiscriminatedUnionSchema<T extends DiscriminatedOptions> extends S
 declare class EnumSchema<T extends readonly [string, ...string[]]> extends Schema<T[number]> {
 	private readonly _values;
 	constructor(values: T);
+	/** Public accessor for the enum's allowed values. */
+	get values(): T;
 	_parse(value: unknown, ctx: ParseContext): T[number];
 	_schemaType(): SchemaType;
 	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
@@ -770,6 +767,11 @@ declare const s: {
 		datetime: () => IsoDatetimeSchema;
 		duration: () => IsoDurationSchema;
 	};
+	fromDbEnum: <const TValues extends readonly [string, ...string[]]>(column: {
+		_meta: {
+			enumValues: TValues;
+		};
+	}) => EnumSchema<TValues>;
 	coerce: {
 		string: () => CoercedStringSchema;
 		number: () => CoercedNumberSchema;
@@ -779,4 +781,4 @@ declare const s: {
 	};
 };
 declare const schema: typeof s;
-export { toJSONSchema2 as toJSONSchema, schema, s, preprocess, VoidSchema, ValidationIssue, UuidSchema, UrlSchema, UnknownSchema, UnionSchema, UndefinedSchema, UlidSchema, TupleSchema, TransformSchema, SymbolSchema, SuperRefinedSchema, StringSchema, SetSchema, SchemaType, SchemaRegistry, SchemaMetadata, SchemaAny, Schema, SafeParseResult, RefinementContext, RefinedSchema, RefTracker, RecordSchema, ReadonlySchema, ReadonlyOutput, PipeSchema, ParseError, ParseContext, Output, OptionalSchema, ObjectSchema, NumberSchema, NullableSchema, NullSchema, NeverSchema, NanoidSchema, NanSchema, MapSchema, LiteralSchema, LazySchema, JwtSchema, JSONSchemaObject, IsoTimeSchema, IsoDurationSchema, IsoDatetimeSchema, IsoDateSchema, Ipv6Schema, Ipv4Schema, IntersectionSchema, InstanceOfSchema, Input, Infer, HostnameSchema, HexSchema, FileSchema, ErrorCode, EnumSchema, EmailSchema, DiscriminatedUnionSchema, DefaultSchema, DateSchema, CustomSchema, CuidSchema, CoercedStringSchema, CoercedNumberSchema, CoercedDateSchema, CoercedBooleanSchema, CoercedBigIntSchema, CatchSchema, BrandedSchema, BooleanSchema, BigIntSchema, Base64Schema, ArraySchema, AnySchema };
+export { unwrap, toJSONSchema2 as toJSONSchema, schema, s, preprocess, ok, matchErr, match, map, isOk, isErr, flatMap, err, VoidSchema, ValidationIssue, UuidSchema, UrlSchema, UnknownSchema, UnionSchema, UndefinedSchema, UlidSchema, TupleSchema, TransformSchema, SymbolSchema, SuperRefinedSchema, StringSchema, SetSchema, SchemaType, SchemaRegistry, SchemaMetadata, SchemaAny, Schema, Result, RefinementContext, RefinedSchema, RefTracker, RecordSchema, ReadonlySchema, ReadonlyOutput, PipeSchema, ParseError, ParseContext, Output, OptionalSchema, Ok, ObjectSchema, NumberSchema, NullableSchema, NullSchema, NeverSchema, NanoidSchema, NanSchema, MapSchema, LiteralSchema, LazySchema, JwtSchema, JSONSchemaObject, IsoTimeSchema, IsoDurationSchema, IsoDatetimeSchema, IsoDateSchema, Ipv6Schema, Ipv4Schema, IntersectionSchema, InstanceOfSchema, Input, Infer, HostnameSchema, HexSchema, FileSchema, ErrorCode, Err, EnumSchema, EmailSchema, DiscriminatedUnionSchema, DefaultSchema, DateSchema, CustomSchema, CuidSchema, CoercedStringSchema, CoercedNumberSchema, CoercedDateSchema, CoercedBooleanSchema, CoercedBigIntSchema, CatchSchema, BrandedSchema, BooleanSchema, BigIntSchema, Base64Schema, ArraySchema, AnySchema };

package/dist/index.js

@@ -102,6 +102,20 @@ function toJSONSchema(schema) {
   return schema.toJSONSchema();
 }
 
+// src/result.ts
+import {
+  err,
+  flatMap,
+  isErr,
+  isOk,
+  map,
+  match,
+  matchErr,
+  ok,
+  unwrap,
+  unwrapOr
+} from "@vertz/errors";
+
 // src/core/schema.ts
 class Schema {
   _id;
@@ -115,21 +129,21 @@ class Schema {
     const ctx = new ParseContext;
     const result = this._runPipeline(value, ctx);
     if (ctx.hasIssues()) {
-      throw new ParseError(ctx.issues);
+      return err(new ParseError(ctx.issues));
     }
-    return result;
+    return ok(result);
   }
   safeParse(value) {
     const ctx = new ParseContext;
     try {
       const data = this._runPipeline(value, ctx);
       if (ctx.hasIssues()) {
-        return { success: false, error: new ParseError(ctx.issues) };
+        return err(new ParseError(ctx.issues));
       }
-      return { success: true, data };
+      return ok(data);
     } catch (e) {
       if (e instanceof ParseError) {
-        return { success: false, error: e };
+        return err(e);
       }
       throw e;
     }
@@ -1095,7 +1109,8 @@ class StringSchema extends Schema {
     return schema;
   }
   _clone() {
-    const clone = this._cloneBase(new StringSchema);
+    const Ctor = this.constructor;
+    const clone = this._cloneBase(new Ctor);
     clone._min = this._min;
     clone._minMessage = this._minMessage;
     clone._max = this._max;
@@ -1122,7 +1137,8 @@ class CoercedStringSchema extends StringSchema {
     return super._parse(value == null ? "" : String(value), ctx);
   }
   _clone() {
-    return Object.assign(new CoercedStringSchema, super._clone());
+    const Ctor = this.constructor;
+    return Object.assign(new Ctor, super._clone());
   }
 }
 
@@ -1299,6 +1315,9 @@ class EnumSchema extends Schema {
     super();
     this._values = values;
   }
+  get values() {
+    return this._values;
+  }
   _parse(value, ctx) {
     if (!this._values.includes(value)) {
       ctx.addIssue({
@@ -1435,10 +1454,10 @@ var IPV4_RE = /^(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})\.(0|[1-9]\d
 class Ipv4Schema extends FormatSchema {
   _errorMessage = "Invalid IPv4 address";
   _validate(value) {
-    const match = IPV4_RE.exec(value);
-    if (!match)
+    const match2 = IPV4_RE.exec(value);
+    if (!match2)
       return false;
-    return [match[1], match[2], match[3], match[4]].every((o) => Number(o) <= 255);
+    return [match2[1], match2[2], match2[3], match2[4]].every((o) => Number(o) <= 255);
   }
   _jsonSchemaExtra() {
     return { format: "ipv4" };
@@ -1614,7 +1633,7 @@ class IntersectionSchema extends Schema {
   _parse(value, ctx) {
     const leftResult = this._left.safeParse(value);
     const rightResult = this._right.safeParse(value);
-    if (!leftResult.success || !rightResult.success) {
+    if (!leftResult.ok || !rightResult.ok) {
       ctx.addIssue({
         code: "invalid_intersection" /* InvalidIntersection */,
         message: "Value does not satisfy intersection"
@@ -2249,7 +2268,7 @@ class UnionSchema extends Schema {
   _parse(value, ctx) {
     for (const option of this._options) {
       const result = option.safeParse(value);
-      if (result.success) {
+      if (result.ok) {
         return result.data;
       }
     }
@@ -2355,6 +2374,13 @@ var s = {
     datetime: () => new IsoDatetimeSchema,
     duration: () => new IsoDurationSchema
   },
+  fromDbEnum: (column) => {
+    const values = column._meta.enumValues;
+    if (!values || values.length === 0) {
+      throw new Error("s.fromDbEnum(): not an enum column — _meta.enumValues is missing or empty");
+    }
+    return new EnumSchema(values);
+  },
   coerce: {
     string: () => new CoercedStringSchema,
     number: () => new CoercedNumberSchema,
@@ -2365,10 +2391,19 @@ var s = {
 };
 var schema = s;
 export {
+  unwrap,
   toJSONSchema,
   schema,
   s,
   preprocess,
+  ok,
+  matchErr,
+  match,
+  map,
+  isOk,
+  isErr,
+  flatMap,
+  err,
   VoidSchema,
   UuidSchema,
   UrlSchema,

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@vertz/schema",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "license": "MIT",
+  "description": "Type-safe schema definitions for Vertz",
   "repository": {
     "type": "git",
     "url": "https://github.com/vertz-dev/vertz.git",
@@ -25,16 +26,22 @@
   ],
   "scripts": {
     "build": "bunup",
-    "test": "vitest run",
+    "test": "bun test",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "@vertz/errors": "0.2.1"
+  },
   "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
     "bunup": "latest",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=22"
-  }
+  },
+  "sideEffects": false
 }