ReliantType


TypeScript Schema Validation with Interface-Like Syntax

A modern TypeScript validation library designed around familiar interface syntax and powerful conditional validation. Experience schema validation that feels natural to TypeScript developers while unlocking advanced runtime validation capabilities.

> Formerly Fortify Schema - Originally developed at github.com/Nehonix-Team/fortify-schema

Migration Notice: The fortify-schema package will be deprecated in favor of reliant-type. While fortify-schema will continue to receive critical security updates, new features and improvements will only be available in reliant-type. We recommend migrating to reliant-type for the best experience and ongoing support.

New Features

- Function Types: Define strict contracts for functions with fn(...) syntax, enforcing argument types and return values at runtime.
- Required Fields: Enforce non-empty strings and non-zero numbers with "string!" and "number!".
- Object Types: Validate generic object structures with "object" and "object?".
- Enhanced Security: All string operations now use secure regex patterns.
- Improved Performance: Optimized validation paths with better caching and precompilation.
- Better Error Messages: More descriptive validation errors with clear property paths.

Quick Start

``bash
npm install reliant-type
`

`typescript
import { Interface } from "reliant-type";

// Define schemas with familiar TypeScript-like syntax
const UserSchema = Interface({
id: "uuid",
email: "email!", // Required (non-empty) email
name: "string(2,50)!", // Required string with length constraints
age: "number(18,120)?",
role: "admin|user|guest",

// Function validation
onUpdate: "fn((status: string) => boolean)",

// Object and array types
profile: "object", // Any object structure
tags: "string[]", // Array of strings
metadata: "record", // Dynamic key-value pairs

// Advanced conditional validation based on runtime properties
permissions: "when config.hasPermissions.$exists() *? string[] : =[]",
adminTools: "when role=admin *? boolean : =false",
});

// Validate with complete TypeScript inference
const result = UserSchema.safeParse(userData);
if (result.success) {
console.log("Valid user:", result.data); // Fully typed!
} else {
console.log("Validation errors:", result.errors);
}
`

_Note: For nested objects, we recommend limiting depth to 50-100 or no more than 300 levels for performance and safety. Default depth limit is 500._

Test by running:

- bun src/__tests__/test_nested_obj.ts (requires bun: npm i -g bun)
- npm run benchmark:nestedObject (requires tsx: npm i -g tsx)

Table of Contents

- Installation & Setup
- Core Features
- Function Types
- Utility Functions
- Conditional Validation
- Live Utility - Real-time Validation
- Real-World Applications
- Performance Excellence
- Advanced Capabilities
- Developer Experience
- API Reference

Installation & Setup

$3

- TypeScript 4.5+
- Node.js 14+
- VS Code (recommended for enhanced development experience)

$3

`bash


NPM

npm install reliant-type

Yarn

yarn add reliant-type

PNPM

pnpm add reliant-type

Bun

bun add reliant-type
`

$3

Enhance your development workflow with our dedicated VS Code extension featuring comprehensive developer tools:

#### Enhanced Features

- Syntax Highlighting: Full syntax highlighting for all Reliant Type types and utilities.
- Hover Documentation: Detailed type information, examples, and use cases on hover.
- Go-to-Definition: Ctrl+Click on types to open comprehensive documentation.
- IntelliSense Support: Smart autocomplete for schema definitions.
- Error Detection: Real-time validation of schema syntax.
- Code Snippets: Pre-built templates for common schema patterns.

#### Interactive Documentation

When you hover over any type in Interface({...}) blocks, you'll see:

- Type Description: What the type validates.
- Usage Examples: "string", "string?", "string[]".
- Use Cases: When and where to use each type.
- Code Examples: Complete working examples.

#### Installation

`bash


Download and install

curl https://sdk.nehonix.com/pkgs/mods/vscode/latest/reliant-type.vsix -o reliant-type.vsix
code --install-extension reliant-type.vsix

Or just search for "reliant-type" in the vscode marketplace

`

Core Features

$3

`typescript
import { Interface } from "reliant-type";

const ProductSchema = Interface({
id: "uuid",
name: "string(1,100)",
price: "number(0.01,99999.99)",
category: "electronics|books|clothing|home",
inStock: "boolean",
tags: "string[]?",
description: "string(,500)?",
createdAt: "date",
});

// Usage with full type safety
const product = {
id: "123e4567-e89b-12d3-a456-426614174000",
name: "Wireless Headphones",
price: 99.99,
category: "electronics",
inStock: true,
tags: ["wireless", "audio", "bluetooth"],
createdAt: new Date(),
};

const result = ProductSchema.safeParse(product);
console.log(result.success); // true
console.log(result.data); // Fully typed product data
`

$3

`typescript
const ComprehensiveSchema = Interface({
// Fundamental types
name: "string",
age: "number",
active: "boolean",
birthday: "date",

// Optional fields
nickname: "string?",
bio: "string?",

// Required fields (cannot be empty/zero)
requiredName: "string!", // Non-empty string required
requiredCount: "number!", // Non-zero number required

// Constraint validation
username: "string(3,20)", // 3-20 characters
password: "string(8,)", // Minimum 8 characters
score: "number(0,100)", // Range 0-100

// Format validation
email: "email",
website: "url",
secureApi: "url.https", // HTTPS-only validation
devServer: "url.dev", // Development mode (allows localhost and security features disabled)
phone: "phone",
userId: "uuid",

// Array validation
tags: "string[]", // Required array
scores: "number[]?", // Optional array
limitedTags: "string[](1,5)", // 1-5 items

// Union types
status: "active|inactive|pending",
role: "user|admin|moderator",

// Object types
profile: "object", // Any object
config: "object?", // Optional object

// Record types (dynamic key-value objects)
settings: "record", // String keys, any values
counters: "record", // String keys, number values
metadata: "record", // String keys, string values

// Literal values
version: "=2.0",
type: "=user",
});
`

Function Types

ReliantType introduces powerful runtime and compile-time validation for function signatures using the fn type. This feature allows you to define strict contracts for functions within your schema.

$3

`typescript
"fn((argument_list) => return_type)";
`

$3

`typescript
const ServiceSchema = Interface({
// Basic function: takes string, returns boolean
isValid: "fn((input: string) => boolean)",

// Multiple arguments
add: "fn((a: number, b: number) => number)",

// Optional arguments
log: "fn((message: string, context?: object) => void)",

// Rest parameters (Spread operator)
sum: "fn((...numbers: number[]) => number)",

// Generic placeholder (TYPE = any)
transform: "fn((input: TYPE) => TYPE)",
});
`

$3

When a function defined in a schema is accessed, it is wrapped in a validation proxy that enforces:

1. Argument Count: Throws an error if required arguments are missing.
2. Argument Types: Throws an error if arguments do not match defined types.
3. Return Type: Throws an error if the return value does not match the defined type.

This ensures strict contract adherence during execution.

$3

Due to JavaScript's dynamic nature, some validation aspects are deferred:

- Deferred Execution Validation: safeParse verifies that the field is a function and checks its declared argument count (arity). However, it cannot validate the function's internal logic or return value without executing it.
- _Implication_: A function that returns an invalid type will pass safeParse, but will throw an error when called.
- Side Effects: To prevent unintended side effects (e.g., database writes), ReliantType never speculatively executes functions during validation.
- Spread Operator Arity: Functions using spread operators (...args) have a declared length of 0 in JavaScript. Therefore, ReliantType cannot enforce a minimum argument count at safeParse time for these functions; validation occurs strictly at runtime.

Utility Functions

Reliant Type provides powerful utility functions for advanced schema definition:

$3

Create schemas that validate against exact constant values:

`typescript
import { Interface, Make } from "reliant-type";

const ConfigSchema = Interface({
// Exact string constants
apiVersion: Make.const("v2.1"),
environment: Make.const("production"),

// Numeric constants
maxRetries: Make.const(3),
timeout: Make.const(5000),

// Boolean constants
enableLogging: Make.const(true),

// Complex constants
defaultSettings: Make.const({
theme: "dark",
language: "en",
}),

// Array constants
supportedFormats: Make.const(["json", "xml", "csv"]),
});
`

$3

Validate objects with dynamic keys but consistent value types:

`typescript
const DynamicSchema = Interface({
// String keys with any values
metadata: "record",

// String keys with number values (counters, scores, etc.)
scores: "record",

// String keys with string values (translations, labels, etc.)
translations: "record",

// Optional record types
optionalSettings: "record?",
});
`

Conditional Validation

Reliant Type's standout feature: advanced conditional validation based on runtime properties and business logic.

`typescript
const SmartUserSchema = Interface({
// Runtime context objects
config: "any?",
user: "any?",
features: "any?",

// Core user data
id: "uuid",
email: "email",
role: "admin|user|guest",

// Dynamic validation based on runtime state
hasPermissions: "when config.permissions.$exists() *? string[] : =[]",
hasProfile: "when user.profile.$exists() *? boolean : =false",
isListEmpty: "when config.items.$empty() *? boolean : =true",
hasAdminRole: "when user.roles.$contains(admin) *? boolean : =false",

// Smart default values
defaultTags: 'when config.tags.$exists() *? string[] : =["default","user"]',
defaultSettings:
'when config.theme.$exists() *? any : ={"mode":"light","lang":"en"}',

// Deep property access
advancedFeature:
"when user.profile.settings.advanced.$exists() *? boolean : =false",

// Complex business rules
isValidUser:
"when user.email.$exists() && user.verified.$exists() *? boolean : =false",
});
`

$3

`typescript
const RuntimeMethodsSchema = Interface({
data: "any?",

// Property existence checking
hasData: "when data.field.$exists() *? boolean : =false",

// Empty state validation
isEmpty: "when data.list.$empty() *? boolean : =true",

// Null checking
isNull: "when data.value.$null() *? boolean : =false",

// String pattern matching
containsText:
"when data.description.$contains(important) *? boolean : =false",
startsWithPrefix: "when data.code.$startsWith(PRE) *? boolean : =false",
endsWithSuffix: "when data.filename.$endsWith(.pdf) *? boolean : =false",

// Numeric range validation
inRange: "when data.score.$between(0,100) *? boolean : =false",

// Value inclusion testing
isValidStatus:
"when data.status.$in(active,pending,inactive) *? boolean : =false",
});
`

Live Utility - Real-time Validation

The Live utility transforms Reliant Type into a powerful real-time validation system with EventEmitter-like interface, data transformation pipelines, and stream control methods. Perfect for modern applications requiring reactive validation.

$3

- Real-time Field Validation: Validate form fields as users type.
- EventEmitter Interface: Full .on(), .emit(), .off(), .once() support.
- Data Transformation Pipeline: Chain .transform(), .filter(), .map() operations.
- Stream Control: .pause(), .resume(), .destroy() for flow control.
- Stream Piping: Connect validators with .pipe() for complex workflows.
- Performance Monitoring: Built-in statistics and performance tracking.
- InterfaceSchema Sync: Perfect synchronization with Interface validation.

$3

`typescript
import { Live, Interface } from "reliant-type";

const UserSchema = Interface({
name: "string(2,50)",
email: "email",
age: "number(18,120)",
});

// Create stream validator with transformation pipeline
const validator = Live.stream(UserSchema)
.transform((data) => ({ ...data, timestamp: Date.now() }))
.filter((data) => data.age >= 21)
.map((data) => ({ ...data, name: data.name.toUpperCase() }));

// Listen for results
validator.on("valid", (data) => console.log("Valid:", data));
validator.on("invalid", (data, errors) => console.log("Invalid:", errors));
validator.on("filtered", (data) => console.log("Filtered:", data));

// Process data
validator.validate({ name: "john", email: "john@example.com", age: 25 });
`

Real-World Applications

$3

`typescript
const ECommerceProductSchema = Interface({
// Product identification
id: "uuid",
sku: "string(/^[A-Z0-9-]{8,20}$/)",
name: "string(1,200)",
slug: "string(/^[a-z0-9-]+$/)",

// Pricing structure
price: "number(0.01,999999.99)",
compareAtPrice: "number(0.01,999999.99)?",
cost: "number(0,999999.99)?",

// Inventory management
inventory: {
quantity: "number(0,)",
trackQuantity: "boolean",
allowBackorder: "boolean",
lowStockThreshold: "number(0,)?"
},

// Content management
description: "string(,5000)?",
shortDescription: "string(,500)?",
category: "electronics|clothing|books|home|sports|beauty",
tags: "string[](0,20)",

// Media assets
images: {
primary: "url",
gallery: "url[](0,10)",
alt: "string(,100)?"
}?,

// SEO optimization
seo: {
title: "string(,60)?",
description: "string(,160)?",
keywords: "string[](0,10)"
}?,

// Business logic with conditional validation
config: "any?",

// Product type-specific requirements
shipping: "when config.isDigital.$exists() *? any? : ={weight:0,dimensions:{}}",
subscription: "when config.isSubscription.$exists() *? any : =null",
variants: "when config.hasVariants.$exists() *? any[] : =[]",

// Publication workflow
status: "draft|active|archived",
publishedAt: "date?",
createdAt: "date",
updatedAt: "date"
});
`

Performance Excellence

Reliant Type is engineered for high-performance validation with multiple optimization strategies:

$3

`typescript
// Built-in performance optimizations
const performanceFeatures = {
// Schema compilation
precompilation: "Schemas optimized at creation time",
caching: "Intelligent caching for union types and constraints",

// Memory management
memoryOptimized: "Minimal runtime overhead per validation",
zeroAllocation: "Hot paths avoid unnecessary object creation",

// Validation efficiency
earlyTermination: "Fast-fail validation on first error",
typeSpecialization: "Optimized validation paths per data type",
};
`

$3

Our continuous performance monitoring shows excellent results across all validation scenarios:

- High Throughput: Millions of operations per second for common validation patterns.
- Consistent Performance: Low variation in execution times.
- Memory Efficient: Minimal memory overhead per schema instance.
- Scalable: Performance scales predictably with data complexity.

Advanced Capabilities

$3

`typescript
import { Mod } from "reliant-type";

const BaseUserSchema = Interface({
id: "uuid",
email: "email",
name: "string",
password: "string",
role: "user|admin",
createdAt: "date",
});

// Powerful schema transformations
const PublicUserSchema = Mod.omit(BaseUserSchema, ["password"]);
const PartialUserSchema = Mod.partial(BaseUserSchema);
const RequiredUserSchema = Mod.required(PartialUserSchema);
const ExtendedUserSchema = Mod.extend(BaseUserSchema, {
lastLogin: "date?",
preferences: {
theme: "light|dark",
notifications: "boolean",
},
});
`

$3

`typescript
const result = UserSchema.safeParse(invalidData);

if (!result.success) {
// Rich error information for debugging
result.errors.forEach((error) => {
console.log(Field: ${error.path.join(".")});
console.log(Message: ${error.message});
console.log(Code: ${error.code});
console.log(Expected: ${error.expected});
console.log(Received: ${error.received});
});
}

// Exception-based validation
try {
const data = UserSchema.parse(userData);
// Process validated data
} catch (error) {
if (error instanceof ValidationError) {
console.log("Validation failed:", error.errors);
}
}
`

Developer Experience

$3

Our dedicated VS Code extension transforms your development experience:

- Intelligent Syntax Highlighting for schema definitions.
- Advanced IntelliSense with type and method completion.
- Real-time Validation with inline error detection.
- Rich Hover Documentation for all types and methods.
- Multiple Theme Support for different coding preferences.

`typescript
const UserSchema = Interface({
// IntelliSense provides comprehensive type suggestions
email: "email", // Hover documentation explains validation rules

// Smart constraint completion
name: "string(2,50)", // Auto-suggests constraint syntax patterns

// Conditional method IntelliSense
hasProfile: "when user.profile.$exists() *? boolean : =false",
// ^ Shows all 8 available runtime methods
});
`

What Sets Reliant Type Apart

$3

- Developer-Centric: Built around familiar TypeScript patterns and conventions.
- Interface Syntax: Schema definitions that feel like native TypeScript interfaces.
- Conditional Intelligence: Advanced runtime validation based on dynamic properties.
- Performance Focused: Optimized for high-throughput production applications.
- Tooling Excellence: Professional-grade development tools and IDE integration.
- Type Safety: Complete TypeScript inference and compile-time validation.

$3

- Familiar Syntax: Write schemas using TypeScript-like interface definitions.
- Advanced Conditionals: Unique runtime property validation and business logic.
- Rich Tooling: Dedicated VS Code extension with comprehensive development support.
- Type Integration: Seamless TypeScript integration with full type inference.
- Production Ready: Battle-tested with comprehensive error handling and debugging.

$3

We're building Reliant Type with transparency and community feedback at its core. We welcome:

- Real-world usage feedback and performance insights.
- Issue reports with detailed reproduction cases.
- Feature requests based on practical development needs.
- Performance benchmarking on diverse use cases.
- Constructive feedback on API design and developer experience.

API Reference

$3

#### Interface(schema, options?)

Creates a new schema instance with comprehensive validation rules.

`typescript
const UserSchema = Interface(
{
id: "uuid",
name: "string",
},
{
strict: true, // Reject extra properties
loose: false, // Disable automatic type coercion
allowUnknown: false, // Reject unknown properties
}
);
`

#### schema.parse(data)

Synchronous validation that returns validated data or throws detailed errors.

`typescript
try {
const user = UserSchema.parse(userData);
// user is fully typed and validated
} catch (error) {
console.error(error.errors);
}
`

#### schema.safeParse(data)

Safe validation that returns a result object without throwing exceptions.

`typescript
const result = UserSchema.safeParse(userData);
if (result.success) {
console.log(result.data); // Fully typed and validated
} else {
console.error(result.errors); // Detailed validation errors
}
`

#### schema.safeParseUnknown(data)

Safe validation for unknown data types, ideal for testing and debugging.

`typescript
const result = UserSchema.safeParseUnknown(unknownData);
// Same return type as safeParse() but accepts any input type
`

#### schema.parseAsync(data)

Asynchronous validation with promise-based error handling.

`typescript
try {
const user = await UserSchema.parseAsync(userData);
console.log("Valid user:", user);
} catch (error) {
console.error("Validation failed:", error.message);
}
`

#### schema.safeParseAsync(data)

Asynchronous safe validation that never throws exceptions.

`typescript
const result = await UserSchema.safeParseAsync(userData);
if (result.success) {
console.log("Valid user:", result.data);
} else {
console.error("Validation errors:", result.errors);
}
`

#### schema.safeParseUnknownAsync(data)`

Asynchronous safe validation for unknown data types.