@agentuity/schema 0.0.69

package/AGENTS.md

@@ -0,0 +1,86 @@
+# Agent Guidelines for @agentuity/schema
+
+## Package Overview
+
+Lightweight schema validation library with StandardSchema v1 support. Provides type-safe runtime validation for the Agentuity platform.
+
+## Commands
+
+- **Build**: `bun run build` (compiles TypeScript with tsc)
+- **Typecheck**: `bun run typecheck` (runs TypeScript type checking)
+- **Clean**: `rm -rf dist` (removes build artifacts)
+
+## Architecture
+
+- **Runtime**: Node/Bun/Browser compatible, no runtime-specific code
+- **Build target**: ESNext with TypeScript declaration files
+- **Exports**: All public APIs exported from `src/index.ts`
+- **Dependencies**: Only depends on `@agentuity/core` for StandardSchema types
+
+## Structure
+
+```text
+src/
+├── index.ts              # Main entry point, exports all schemas
+├── base.ts               # Base schema class and types
+├── primitives/           # Primitive type schemas
+│   ├── string.ts
+│   ├── number.ts
+│   ├── boolean.ts
+│   ├── null.ts
+│   └── undefined.ts
+├── complex/              # Complex type schemas
+│   ├── object.ts
+│   └── array.ts
+├── utils/                # Utility schemas
+│   ├── optional.ts
+│   ├── nullable.ts
+│   ├── union.ts
+│   └── literal.ts
+├── coerce/               # Type coercion schemas
+│   ├── string.ts
+│   ├── number.ts
+│   ├── boolean.ts
+│   └── date.ts
+├── json-schema.ts        # JSON Schema conversion utilities
+└── __tests__/            # Bun unit tests
+    ├── primitives.test.ts
+    ├── complex.test.ts
+    ├── utils.test.ts
+    ├── coerce.test.ts
+    ├── type-inference.test.ts
+    ├── json-schema.test.ts
+    └── errors.test.ts
+```
+
+## Code Style
+
+- **StandardSchema compliant** - All schemas implement StandardSchemaV1
+- **Fluent API** - Chainable methods where appropriate
+- **Type-safe** - Full TypeScript support with type inference
+- **Vendor name**: "agentuity" for all schemas
+- **No side effects** - Pure validation functions
+
+## Important Conventions
+
+- All schemas must implement `StandardSchemaV1` from `@agentuity/core`
+- Use `'~standard'` property for StandardSchema interface
+- Export main builder as `s` (e.g., `s.string()`, `s.object()`)
+- Error messages should be clear and actionable
+- Support type inference via `Infer<T>` utility type
+
+## Testing
+
+- **Test Framework**: Bun's built-in test runner
+- **Test Count**: 72 tests across 7 test files
+- **Command**: `bun test` (run from package directory)
+- **Coverage**: Primitives, complex types, utilities, coercion, type inference, JSON Schema, error handling
+- **CI**: Tests run automatically on PR builds
+- All tests must pass before merging
+
+## Publishing Checklist
+
+1. Run `bun run build` to compile
+2. Verify `dist/` contains `.js` and `.d.ts` files
+3. Ensure StandardSchema compliance
+4. This package depends on `@agentuity/core` (must be published first)

package/README.md

@@ -0,0 +1,323 @@
+# @agentuity/schema
+
+A lightweight, type-safe schema validation library for the Agentuity platform. Supports the [StandardSchema](https://standardschema.dev/) specification.
+
+## Features
+
+- 🎯 Type-safe schema validation
+- 📦 Lightweight with zero runtime dependencies
+- 🔗 StandardSchema v1 compliant
+- 🌐 Works in browser and server environments (Node.js, Bun)
+- ⚡ Simple, fluent API
+
+## Installation
+
+```bash
+bun add @agentuity/schema
+```
+
+## Usage
+
+```typescript
+import { s, ValidationError } from '@agentuity/schema';
+
+// Define a schema
+const userSchema = s.object({
+	name: s.string(),
+	age: s.number(),
+	email: s.string(),
+	isActive: s.boolean(),
+});
+
+// Extract the inferred type (like zod's z.infer)
+type User = s.infer<typeof userSchema>;
+
+// Parse with validation (throws on error)
+try {
+	const user: User = userSchema.parse({
+		name: 'John',
+		age: 30,
+		email: 'john@example.com',
+		isActive: true,
+	});
+	console.log('Valid user:', user);
+} catch (error) {
+	if (error instanceof ValidationError) {
+		console.error('Validation failed:', error.message);
+		console.error('Issues:', error.issues);
+	}
+}
+
+// Safe parse (returns result object)
+const result = userSchema.safeParse(data);
+if (result.success) {
+	console.log('Valid data:', result.data);
+} else {
+	console.error('Validation failed:', result.error.message);
+}
+
+// Optional and nullable
+const optionalSchema = s.object({
+	name: s.string(),
+	nickname: s.optional(s.string()),
+	age: s.nullable(s.number()),
+});
+
+// Arrays
+const stringArraySchema = s.array(s.string());
+const userArraySchema = s.array(userSchema);
+
+// Unions
+const statusSchema = s.union(s.literal('active'), s.literal('inactive'), s.literal('pending'));
+
+// Enums (shorthand for union of literals)
+const roleSchema = s.enum(['admin', 'user', 'guest']);
+const prioritySchema = s.enum([1, 2, 3, 4, 5]);
+
+// Literal values
+const roleSchema = s.literal('admin');
+```
+
+## API
+
+### Basic Types
+
+- `s.string()` - String validation
+- `s.number()` - Number validation
+- `s.boolean()` - Boolean validation
+- `s.null()` - Null validation
+- `s.undefined()` - Undefined validation
+
+### Complex Types
+
+- `s.object(shape)` - Object validation with typed properties
+- `s.array(schema)` - Array validation with typed elements
+
+### Utility Types
+
+- `s.optional(schema)` - Makes a schema optional
+- `s.nullable(schema)` - Makes a schema nullable
+- `s.union(...schemas)` - Union of multiple schemas
+- `s.literal(value)` - Exact value matching
+- `s.enum([...values])` - Enum type (union of literals)
+
+```typescript
+// Enum (shorthand for union of literals)
+const roleSchema = s.enum(['admin', 'user', 'guest']);
+const role = roleSchema.parse('admin'); // 'admin'
+
+// Equivalent to:
+const roleSchema2 = s.union(s.literal('admin'), s.literal('user'), s.literal('guest'));
+```
+
+### Coercion
+
+Automatically convert values to the correct type (like zod.coerce):
+
+- `s.coerce.string()` - Coerce to string using `String(value)`
+- `s.coerce.number()` - Coerce to number using `Number(value)`
+- `s.coerce.boolean()` - Coerce to boolean using `Boolean(value)`
+- `s.coerce.date()` - Coerce to Date using `new Date(value)`
+
+```typescript
+// Parse form data where everything is a string
+const formSchema = s.object({
+	name: s.string(),
+	age: s.coerce.number(), // "30" → 30
+	newsletter: s.coerce.boolean(), // "on" → true
+	createdAt: s.coerce.date(), // "2025-01-01" → Date
+});
+
+const formData = formSchema.parse({
+	name: 'John',
+	age: '30', // String coerced to number
+	newsletter: 'on', // String coerced to boolean
+	createdAt: '2025-01-01', // String coerced to Date
+});
+
+// Query parameters (always strings)
+const querySchema = s.object({
+	page: s.coerce.number(),
+	limit: s.coerce.number(),
+});
+
+const params = querySchema.parse({
+	page: '1', // "1" → 1
+	limit: '20', // "20" → 20
+});
+```
+
+### Documentation
+
+All schemas support a `.describe(description: string)` method for adding documentation:
+
+```typescript
+const userSchema = s
+	.object({
+		id: s.string().describe('The unique identifier'),
+		name: s.string().describe('The user full name'),
+		age: s.number().describe('Age in years'),
+	})
+	.describe('User profile');
+```
+
+### JSON Schema Conversion
+
+Convert schemas to JSON Schema format:
+
+```typescript
+const schema = s.object({
+	name: s.string().describe('User name'),
+	age: s.number().describe('User age'),
+});
+
+const jsonSchema = s.toJSONSchema(schema);
+// {
+//   "type": "object",
+//   "properties": {
+//     "name": { "type": "string", "description": "User name" },
+//     "age": { "type": "number", "description": "User age" }
+//   },
+//   "required": ["name", "age"]
+// }
+```
+
+Convert JSON Schema to schemas:
+
+```typescript
+const jsonSchema = {
+	type: 'object',
+	properties: {
+		firstName: {
+			type: 'string',
+			description: 'First name',
+		},
+		lastName: {
+			type: 'string',
+			description: 'Last name',
+		},
+		age: {
+			type: 'number',
+			description: 'Age',
+		},
+		hobbies: {
+			type: 'array',
+			items: { type: 'string' },
+		},
+	},
+	required: ['firstName', 'lastName', 'age', 'hobbies'],
+};
+
+const schema = s.fromJSONSchema(jsonSchema);
+// Now you can use schema for validation
+const result = schema['~standard'].validate(data);
+```
+
+Round-trip conversion is supported:
+
+```typescript
+const original = s.object({ name: s.string() });
+const json = s.toJSONSchema(original);
+const reconstructed = s.fromJSONSchema(json);
+// reconstructed works exactly like original
+```
+
+### Parsing & Validation
+
+#### `.parse(value)` - Throws on validation error
+
+```typescript
+try {
+	const user = userSchema.parse(data);
+	// user is typed and validated
+} catch (error) {
+	if (error instanceof ValidationError) {
+		console.error(error.message); // Human-readable error
+		console.error(error.issues); // Detailed issue array with paths
+	}
+}
+```
+
+#### `.safeParse(value)` - Returns result object
+
+```typescript
+const result = userSchema.safeParse(data);
+
+if (result.success) {
+	console.log(result.data); // Typed data
+} else {
+	console.error(result.error); // ValidationError instance
+}
+```
+
+### Type Inference
+
+Use `s.infer` to extract TypeScript types from schemas (like zod's `z.infer`):
+
+```typescript
+import { s } from '@agentuity/schema';
+
+const Player = s.object({
+	username: s.string(),
+	xp: s.number(),
+	inventory: s.array(s.string()),
+});
+
+// Extract the inferred type (like zod's z.infer)
+type Player = s.infer<typeof Player>;
+// { username: string; xp: number; inventory: string[] }
+
+const player: Player = Player.parse(data);
+```
+
+You can also import the `Infer` type directly if preferred:
+
+```typescript
+import { s, type Infer } from '@agentuity/schema';
+
+type Player = Infer<typeof Player>; // Alternative syntax
+```
+
+### Error Handling
+
+Validation errors are structured and include paths to the failed fields:
+
+```typescript
+const profileSchema = s.object({
+	user: s.object({
+		name: s.string(),
+		age: s.number(),
+	}),
+});
+
+try {
+	profileSchema.parse({ user: { name: 'John', age: 'thirty' } });
+} catch (error) {
+	if (error instanceof ValidationError) {
+		console.log(error.message);
+		// "[user.age]: Expected number, got string"
+
+		console.log(error.issues);
+		// [{ message: "Expected number, got string", path: ["user", "age"] }]
+	}
+}
+```
+
+## StandardSchema Support
+
+All schemas implement the StandardSchema v1 interface:
+
+```typescript
+interface StandardSchemaV1<Input, Output> {
+	readonly '~standard': {
+		readonly version: 1;
+		readonly vendor: string;
+		readonly validate: (value: unknown) => Result<Output>;
+		readonly types?: { input: Input; output: Output };
+	};
+}
+```
+
+## License
+
+Apache-2.0

package/dist/base.d.ts

@@ -0,0 +1,111 @@
+import type { StandardSchemaV1 } from '@agentuity/core';
+/**
+ * A validation issue from a failed schema validation.
+ */
+export type ValidationIssue = StandardSchemaV1.Issue;
+/**
+ * The result of a schema validation (success or failure).
+ */
+export type ValidationResult<T> = StandardSchemaV1.Result<T>;
+/**
+ * Successful parse result containing validated data.
+ */
+export interface SafeParseSuccess<T> {
+    /** Indicates successful validation */
+    success: true;
+    /** The validated and typed data */
+    data: T;
+}
+/**
+ * Failed parse result containing validation error.
+ */
+export interface SafeParseError {
+    /** Indicates failed validation */
+    success: false;
+    /** The validation error with detailed issues */
+    error: ValidationError;
+}
+/**
+ * Result of safeParse - either success with data or failure with error.
+ */
+export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError;
+/**
+ * Error thrown when schema validation fails.
+ * Contains detailed information about all validation issues including field paths.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   schema.parse(data);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log(error.message);  // Human-readable error
+ *     console.log(error.issues);   // Detailed issues array
+ *   }
+ * }
+ * ```
+ */
+export declare class ValidationError extends Error {
+    /** Array of validation issues with paths and messages */
+    readonly issues: readonly ValidationIssue[];
+    constructor(issues: readonly ValidationIssue[]);
+    toString(): string;
+}
+/**
+ * Base schema interface that all schemas implement.
+ * Provides StandardSchema v1 compliance plus additional methods for parsing and description.
+ */
+export interface Schema<Input = unknown, Output = Input> extends StandardSchemaV1<Input, Output> {
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+    /** Optional description for documentation */
+    description?: string;
+    /** Add a description to the schema for documentation and JSON Schema */
+    describe(description: string): this;
+    /** Parse and validate data, throwing ValidationError on failure */
+    parse(value: unknown): Output;
+    /** Parse and validate data, returning result object without throwing */
+    safeParse(value: unknown): SafeParseResult<Output>;
+    /** Make this schema optional (allow undefined) */
+    optional(): Schema<Input | undefined, Output | undefined>;
+    /** Make this schema nullable (allow null) */
+    nullable(): Schema<Input | null, Output | null>;
+}
+/**
+ * Extract the output type from a schema (like zod's z.infer).
+ *
+ * @example
+ * ```typescript
+ * const User = s.object({ name: s.string(), age: s.number() });
+ * type User = Infer<typeof User>;  // { name: string; age: number }
+ * ```
+ */
+export type Infer<T extends Schema<any, any>> = StandardSchemaV1.InferOutput<T>;
+/**
+ * Extract the input type from a schema.
+ */
+export type InferInput<T extends Schema<any, any>> = StandardSchemaV1.InferInput<T>;
+/**
+ * Extract the output type from a schema (alias for Infer).
+ */
+export type InferOutput<T extends Schema<any, any>> = StandardSchemaV1.InferOutput<T>;
+/**
+ * Create a validation issue with an optional field path.
+ */
+export declare function createIssue(message: string, path?: ReadonlyArray<PropertyKey | StandardSchemaV1.PathSegment>): ValidationIssue;
+/**
+ * Create a successful validation result.
+ */
+export declare function success<T>(value: T): StandardSchemaV1.SuccessResult<T>;
+/**
+ * Create a failed validation result.
+ */
+export declare function failure(issues: ValidationIssue[]): StandardSchemaV1.FailureResult;
+/**
+ * Create parse and safeParse methods for a schema.
+ * @internal
+ */
+export declare function createParseMethods<Output>(): {
+    parse(this: Schema<any, Output>, value: unknown): Output;
+    safeParse(this: Schema<any, Output>, value: unknown): SafeParseResult<Output>;
+};
+//# sourceMappingURL=base.d.ts.map

package/dist/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"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"}

package/dist/base.js

@@ -0,0 +1,93 @@
+/**
+ * Error thrown when schema validation fails.
+ * Contains detailed information about all validation issues including field paths.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   schema.parse(data);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log(error.message);  // Human-readable error
+ *     console.log(error.issues);   // Detailed issues array
+ *   }
+ * }
+ * ```
+ */
+export class ValidationError extends Error {
+    /** Array of validation issues with paths and messages */
+    issues;
+    constructor(issues) {
+        const message = issues
+            .map((issue) => {
+            const path = issue.path
+                ? `[${issue.path
+                    .map((p) => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                typeof p === 'object' ? p.key : p)
+                    .join('.')}]`
+                : '';
+            return path ? `${path}: ${issue.message}` : issue.message;
+        })
+            .join('\n');
+        super(message);
+        this.name = 'ValidationError';
+        this.issues = issues;
+        // Maintain proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationError);
+        }
+    }
+    toString() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+/**
+ * Create a validation issue with an optional field path.
+ */
+export function createIssue(message, path) {
+    return path ? { message, path } : { message };
+}
+/**
+ * Create a successful validation result.
+ */
+export function success(value) {
+    return { value };
+}
+/**
+ * Create a failed validation result.
+ */
+export function failure(issues) {
+    return { issues };
+}
+/**
+ * Create parse and safeParse methods for a schema.
+ * @internal
+ */
+export function createParseMethods() {
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parse(value) {
+            const result = this['~standard'].validate(value);
+            if (result instanceof Promise) {
+                throw new Error('Async validation not supported in parse()');
+            }
+            if (result.issues) {
+                throw new ValidationError(result.issues);
+            }
+            return result.value;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        safeParse(value) {
+            const result = this['~standard'].validate(value);
+            if (result instanceof Promise) {
+                throw new Error('Async validation not supported in safeParse()');
+            }
+            if (result.issues) {
+                return { success: false, error: new ValidationError(result.issues) };
+            }
+            return { success: true, data: result.value };
+        },
+    };
+}
+//# sourceMappingURL=base.js.map

package/dist/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"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"}

package/dist/coerce/boolean.d.ts

@@ -0,0 +1,37 @@
+import type { Schema } from '../base';
+/**
+ * Schema that coerces values to booleans using Boolean(value).
+ * Uses JavaScript truthy/falsy rules.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.coerce.boolean();
+ * schema.parse(1); // true
+ * schema.parse(0); // false
+ * schema.parse(''); // false
+ * schema.parse('hello'); // true
+ * ```
+ */
+export declare class CoerceBooleanSchema implements Schema<unknown, boolean> {
+    description?: string;
+    readonly '~standard': {
+        version: 1;
+        vendor: string;
+        validate: (value: unknown) => import("@agentuity/core").StandardSchemaV1.SuccessResult<boolean>;
+        types: {
+            input: unknown;
+            output: boolean;
+        };
+    };
+    describe(description: string): this;
+    optional(): import("..").OptionalSchema<this>;
+    nullable(): import("..").NullableSchema<this>;
+    parse: (this: Schema<any, boolean>, value: unknown) => boolean;
+    safeParse: (this: Schema<any, boolean>, value: unknown) => import("..").SafeParseResult<boolean>;
+}
+/**
+ * Create a schema that coerces values to booleans.
+ * Useful for parsing checkboxes or boolean flags from strings.
+ */
+export declare function coerceBoolean(): CoerceBooleanSchema;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/coerce/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/coerce/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOtC;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,YAAW,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eAIM;YAAE,KAAK,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,OAAO,CAAA;SAAE;MACjE;IAEF,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ;IAIR,QAAQ;IAGR,KAAK,0DAAsB;IAC3B,SAAS,wFAA0B;CACnC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,mBAAmB,CAEnD"}