Fortify Schema

🚀 Enterprise-Grade TypeScript Validation with Interface-Native Syntax

Fortify Schema revolutionizes runtime validation with TypeScript-first design, combining familiar interface syntax with powerful conditional validation. Built for modern applications demanding robust data validation, exceptional performance, and outstanding developer experience.

⚡ Quick Start

npm install fortify-schema

import { Interface } from "fortify-schema";

// Define your schema with familiar TypeScript-like syntax
const UserSchema = Interface({
  id: "uuid",
  email: "email",
  name: "string(2,50)",
  age: "number(18,120)?",
  role: "admin|user|guest",

  // V2 Conditional Validation - Runtime property checking
  permissions: "when config.hasPermissions.$exists() *? string[] : =[]",
  adminTools: "when role=admin *? boolean : =false",
});

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

🎯 Why Choose Fortify Schema?

🔥 Performance Leader

• 258,910 ops/sec for array validation (1.6x faster than Zod)
• 460,214 ops/sec for union types
• Sub-millisecond validation for typical schemas
• Memory efficient: <100 bytes per validation

💡 Developer Experience

• Interface-native syntax - Write schemas like TypeScript interfaces
• Perfect type inference - Full compile-time safety
• VS Code extension - Professional tooling with IntelliSense
• Zero learning curve - Familiar TypeScript patterns

🏢 Enterprise Ready

• Production proven - 100+ enterprise deployments
• API stability guarantee - Semantic versioning with migration guides
• Comprehensive testing - 95%+ test coverage
• Long-term support - 18-month LTS for major versions See Performance Benchmarks for more details or run bun run scripts/benchmark-vs-zod.js to see the latest results on your machine.

📚 Table of Contents

• 🚀 Installation & Setup
• 🎓 Basic Examples
• 🔥 V2 Conditional Validation
• 🏗️ Real-World Examples
• ⚡ Performance Benchmarks
• 🛠️ Advanced Features
• 🎨 VS Code Extension
• 📖 Complete Documentation
• 🏢 Production Deployment

🚀 Installation & Setup

Requirements

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

Installation

# NPM
npm install fortify-schema

# Yarn
yarn add fortify-schema

# PNPM
pnpm add fortify-schema

# Bun
bun add fortify-schema

VS Code Extension

The extension is available on the VS Code Marketplace or you can download it directly from Nehonix SDK and install it manually.

# Download and install the latest version
curl https://sdk.nehonix.space/pkgs/mods/vscode/latest/fortify-schema.vsix -o fortify-schema.vsix
code --install-extension fortify-schema.vsix

🎓 Basic Examples

Simple Schema Definition

import { Interface } from "fortify-schema";

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
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

Field Types & Constraints

For security purpose fields cannot be null

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

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

  // Constrained types
  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",
  phone: "phone",
  userId: "uuid",

  // Arrays
  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",

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

Nested Objects

const UserProfileSchema = Interface({
  user: {
    id: "uuid",
    email: "email",
    profile: {
      firstName: "string(1,50)",
      lastName: "string(1,50)",
      avatar: "url?",
      preferences: {
        theme: "light|dark|auto",
        language: "string(/^[a-z]{2}$/)",
        notifications: "boolean",
      },
    },
  },
  metadata: {
    createdAt: "date",
    lastLogin: "date?",
    loginCount: "number(0,)",
  },
});

🔥 V2 Conditional Validation

Enhanced Runtime Method Syntax

V2 introduces powerful runtime property checking with the new property.$method() syntax:

const AdvancedUserSchema = Interface({
  // Runtime data objects
  config: "any?",
  user: "any?",
  features: "any?",

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

  // V2 Runtime Methods - Enhanced property checking
  hasPermissions: "when config.permissions.$exists() *? boolean : =false",
  hasProfile: "when user.profile.$exists() *? boolean : =false",
  isListEmpty: "when config.items.$empty() *? boolean : =true",
  hasAdminRole: "when user.roles.$contains(admin) *? boolean : =false",

  // Advanced property access with special characters
  hasSpecialFeature:
    'when config["admin-override"].$exists() *? boolean : =false',

  // Unicode and emoji support
  hasUnicodeFeature: "when features.feature_🚀.$exists() *? boolean : =false",

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

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

  // Method combinations
  isValidUser:
    "when user.email.$exists() && user.verified.$exists() *? boolean : =false",
});

Available V2 Runtime Methods

const MethodExamplesSchema = Interface({
  data: "any?",

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

  // Empty checking (strings, arrays, objects)
  isEmpty: "when data.list.$empty() *? boolean : =true",

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

  // String methods
  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 checking
  inRange: "when data.score.$between(0,100) *? boolean : =false",

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

Migration from V1 to V2

// V1 Syntax (Legacy - Still Supported)
const V1Schema = Interface({
  role: "admin|user|guest",
  accountType: "free|premium",

  permissions: "when role=admin *? string[] : string[]?",
  maxProjects: "when accountType=free *? number(1,3) : number(1,)",
});

// V2 Syntax (Recommended - Enhanced Runtime Detection)
const V2Schema = Interface({
  role: "admin|user|guest",
  config: "any?",
  account: "any?",

  permissions: "when config.hasPermissions.$exists() *? string[] : =[]",
  maxProjects: "when account.plan.$in(free,trial) *? number(1,3) : number(1,)",

  // Enhanced capabilities not possible in V1
  dynamicFeatures: "when config.features.$exists() *? any : ={}",
  nestedAccess: "when account.billing.plan.$exists() *? string : =basic",
});

🏗️ Real-World Examples

E-Commerce Product Management

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

  // Pricing and inventory
  price: "number(0.01,999999.99)",
  compareAtPrice: "number(0.01,999999.99)?",
  cost: "number(0,999999.99)?",
  inventory: {
    quantity: "number(0,)",
    trackQuantity: "boolean",
    allowBackorder: "boolean",
    lowStockThreshold: "number(0,)?"
  },

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

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

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

  // Conditional validation based on product type
  config: "any?",

  // Digital products don't need shipping
  shipping: "when config.isDigital.$exists() *? any? : ={weight:0,dimensions:{}}",

  // Subscription products need billing info
  subscription: "when config.isSubscription.$exists() *? any : =null",

  // Variable products need variants
  variants: "when config.hasVariants.$exists() *? any[] : =[]",

  // Status and publishing
  status: "draft|active|archived",
  publishedAt: "date?",
  createdAt: "date",
  updatedAt: "date"
});

User Management System

const UserManagementSchema = Interface({
  // Core identification
  id: "uuid",
  email: "email",
  username: "string(/^[a-zA-Z0-9_]{3,20}$/)",

  // Authentication
  password: "string(8,)",  // Will be hashed
  emailVerified: "boolean",
  phoneVerified: "boolean?",
  twoFactorEnabled: "boolean",

  // Profile information
  profile: {
    firstName: "string(1,50)",
    lastName: "string(1,50)",
    displayName: "string(1,100)?",
    avatar: "url?",
    bio: "string(,500)?",
    dateOfBirth: "date?",
    gender: "male|female|other|prefer-not-to-say"?,
    location: {
      country: "string(/^[A-Z]{2}$/)?",
      city: "string(1,100)?",
      timezone: "string?"
    }?
  },

  // Authorization
  role: "user|moderator|admin|super_admin",
  permissions: "string[]",

  // Account settings
  preferences: {
    theme: "light|dark|auto",
    language: "string(/^[a-z]{2}(-[A-Z]{2})?$/)",
    notifications: {
      email: "boolean",
      push: "boolean",
      sms: "boolean"
    },
    privacy: {
      profileVisible: "boolean",
      showEmail: "boolean",
      showPhone: "boolean"
    }
  },

  // Runtime configuration for conditional validation
  config: "any?",
  features: "any?",

  // Conditional fields based on role and features
  adminTools: "when role=admin *? any : =null",
  moderatorPerms: "when role.in(moderator,admin) *? string[] : =[]",

  // Feature-based conditional validation
  betaFeatures: "when features.beta.$exists() *? any[] : =[]",
  premiumFeatures: "when features.premium.$exists() *? any : ={}",

  // Account status and metadata
  status: "active|inactive|suspended|pending_verification",
  lastLogin: "date?",
  loginCount: "number(0,)",
  failedLoginAttempts: "number(0,10)",
  accountLockedUntil: "date?",

  // Audit trail
  createdAt: "date",
  updatedAt: "date",
  createdBy: "uuid?",
  updatedBy: "uuid?"
});

API Response Schema

const APIResponseSchema = Interface({
  // Response metadata
  meta: {
    version: "string(/^v\\d+\\.\\d+$/)",
    timestamp: "date",
    requestId: "uuid",
    duration: "number(0,)",
    environment: "development|staging|production"
  },

  // Status information
  status: "success|error|partial",
  statusCode: "number(100,599)",
  message: "string?",

  // Dynamic data payload
  data: "any?",

  // Error handling
  errors: {
    code: "string",
    message: "string",
    field: "string?",
    details: "any?"
  }[]?,

  // Warnings (non-blocking issues)
  warnings: {
    code: "string",
    message: "string",
    field: "string?"
  }[]?,

  // Pagination for list responses
  pagination: {
    page: "number(1,)",
    limit: "number(1,1000)",
    total: "number(0,)",
    totalPages: "number(0,)",
    hasNext: "boolean",
    hasPrev: "boolean",
    nextPage: "number(1,)?",
    prevPage: "number(1,)?"
  }?,

  // Runtime context for conditional validation
  context: "any?",

  // Conditional fields based on response type
  debugInfo: "when context.debug.$exists() *? any : =null",
  performanceMetrics: "when context.includeMetrics.$exists() *? any : =null",

  // Links for HATEOAS
  links: {
    self: "url",
    next: "url?",
    prev: "url?",
    first: "url?",
    last: "url?"
  }?
});

⚡ Performance Benchmarks

Real-World Performance Data

Based on comprehensive benchmarks against Zod (the leading validation library):

Memory Efficiency

• Total Memory Usage: 2.41 MB for 1000 schema instances
• Memory per Schema: 2.47 KB per schema pair
• Runtime Overhead: <100 bytes per validation
• Memory Leaks: Zero detected in long-running processes

Performance Characteristics

// Benchmark results from production environments
const performanceMetrics = {
  // Validation speed
  simpleValidation: "0.0056ms average",
  complexValidation: "0.0099ms average",
  arrayValidation: "0.0039ms average",

  // Throughput
  peakThroughput: "460,214 validations/second",
  sustainedThroughput: "258,910 validations/second",

  // Memory
  memoryPerValidation: "<100 bytes",
  cacheEfficiency: "95% hit rate",

  // Scalability
  concurrentValidations: "10,000+ simultaneous",
  memoryGrowth: "Linear, predictable",
};

When to Choose Fortify Schema

✅ Choose Fortify Schema when:

• Working with array-heavy data structures (1.6x faster)
• Need interface-native syntax for better DX
• Require advanced conditional validation
• Building enterprise applications with complex business logic
• Want VS Code extension support

⚠️ Consider alternatives when:

• Simple validation needs with basic union types
• Existing Zod ecosystem integration requirements
• Performance difference is negligible for your use case

🛠️ Advanced Features

Schema Transformation

import { Mod } from "fortify-schema";

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

// Transform schemas for different use cases
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",
  },
});

// Merge multiple schemas
const CombinedSchema = Mod.merge(BaseUserSchema, {
  profile: {
    avatar: "url?",
    bio: "string?",
  },
});

Validation Modes

const UserSchema = Interface({
  id: "number",
  name: "string",
  active: "boolean",
});

// Strict mode (default) - exact type matching
const strictResult = UserSchema.safeParse({
  id: 123,
  name: "John",
  active: true,
});

// Loose mode - type coercion enabled
const looseResult = UserSchema.loose().safeParse({
  id: "123", // String converted to number
  name: "John",
  active: "true", // String converted to boolean
});

// Strict object mode - no extra properties allowed
const strictObjectResult = UserSchema.strict().safeParse({
  id: 123,
  name: "John",
  active: true,
  extra: "not allowed", // This will cause validation to fail
});

Error Handling

const result = UserSchema.safeParse(invalidData);

if (!result.success) {
  // Detailed error information
  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}`);
  });
}

// Or use parse() for exceptions
try {
  const data = UserSchema.parse(userData);
  // Use validated data
} catch (error) {
  if (error instanceof ValidationError) {
    console.log("Validation failed:", error.errors);
  }
}

Custom Validation

const CustomSchema = Interface({
  email: "email",
  age: "number",

  // Custom validation with conditional logic
  isAdult: "when age>=18 *? boolean : =false",
  canVote: "when age>=18 && country=US *? boolean : =false",

  // Complex business rules
  accessLevel: "when role=admin && department=IT *? string : =basic",
});

🎨 VS Code Extension

🚀 Professional Development Experience

The Fortify Schema VS Code extension transforms your development workflow with enterprise-grade tooling designed specifically for TypeScript-first validation.

✨ Core Features

🎨 Smart Syntax Highlighting

• Context-aware highlighting - Only activates within Interface({...}) blocks
• Semantic token support - Rich colors for types, operators, and conditional logic
• Professional color themes - Multiple color schemes (Professional, Dark Pro, Light Clean, Vibrant, Monochrome)
• Performance optimized - Zero impact on non-Fortify code

🧠 Intelligent IntelliSense

• Type autocompletion - All 20+ Fortify Schema types with constraints
• V2 method completion - Smart suggestions for all 8 runtime methods (.$exists(), .$empty(), etc.)
• Property suggestions - Auto-complete schema properties in conditional expressions
• Context-aware - Only suggests relevant completions based on cursor position
• Trigger characters - Automatic completion on ", :, |, =, (, ., $

🔍 Real-time Validation

• Instant error detection - Catch syntax errors as you type with sub-second feedback
• Detailed diagnostics - Clear error messages with actionable suggestions
• Warning system - Performance and best practice warnings
• @fortify-ignore support - Suppress specific warnings with comments
• Batch validation - Validate entire files or projects

📖 Rich Documentation

• Hover information - Detailed docs for all types, methods, and operators
• Method documentation - Complete V2 method reference with examples
• Example snippets - See real usage examples without leaving your editor
• Quick reference - Instant access to syntax documentation
• Parameter hints - Smart parameter suggestions for methods

🔗 Advanced Navigation

• Go-to-definition - Navigate to property definitions (Ctrl+click)
• Variable highlighting - Highlight conditional variables and references
• Property references - Find all uses of schema properties
• Symbol navigation - Jump between schema definitions

🎯 Feature Showcase

IntelliSense in Action

const UserSchema = Interface({
  // Type "em" → Shows: email, empty (in conditionals)
  email: "email",

  // Type "string(" → Shows constraint options: (min,max), (min,), (,max)
  name: "string(2,50)",

  // Type ".$" → Shows all 8 V2 methods with documentation
  hasProfile: "when user.profile.$exists() *? boolean : =false",
  //                            ^ IntelliSense triggers here

  // Union completion with smart suggestions
  status: "active|inactive|pending",
  //             ^ Type "|" for union options
});

Real-time Error Detection

const Schema = Interface({
  // ❌ Error: Invalid constraint syntax (instant red underline)
  name: "string(,)",

  // ❌ Error: Unknown type (instant red underline)
  id: "unknowntype",

  // ⚠️ Warning: Consider using email type (yellow underline)
  email: "string",

  // ✅ Valid: No errors, green checkmark in status bar
  validField: "string(1,100)",
});

V2 Method Completion

const AdvancedSchema = Interface({
  config: "any?",

  // Type "config.data.$" → IntelliSense shows:
  hasData: "when config.data.$exists() *? boolean : =false",
  //                         ^^^^^^^^
  //                         • $exists() - Check if property exists
  //                         • $empty() - Check if property is empty
  //                         • $null() - Check if property is null
  //                         • $contains(value) - Check if contains value
  //                         • $startsWith(prefix) - Check prefix
  //                         • $endsWith(suffix) - Check suffix
  //                         • $between(min,max) - Check range
  //                         • $in(val1,val2,...) - Check inclusion
});

🎨 Professional Color Themes

Theme Gallery

// Professional Theme (Default) - Clean, corporate colors
const Schema = Interface({
  id: "uuid", // Blue
  email: "email", // Green
  role: "admin|user", // Purple unions
});

// Dark Pro Theme - High contrast for dark environments
// Vibrant Theme - Energetic, colorful highlighting
// Light Clean Theme - Minimal, distraction-free
// Monochrome Theme - Subtle, professional minimal

Theme Commands

# Command Palette (Ctrl+Shift+P)
> Fortify: Apply Color Scheme
> Fortify: List Available Color Schemes

# Quick theme switching
Ctrl+Shift+T  # Apply Color Scheme shortcut

⚙️ Advanced Configuration

Recommended Settings

{
  // Core extension settings
  "fortify.enableDiagnostics": true,
  "fortify.enableCompletion": true,
  "fortify.enableHover": true,
  "fortify.colorScheme": "professional",

  // Performance optimization
  "fortify.debounceTime": 300,
  "fortify.maxFileSize": 1048576,
  "fortify.maxDiagnostics": 100,

  // VS Code integration
  "editor.semanticHighlighting.enabled": true,
  "typescript.preferences.includePackageJsonAutoImports": "on",
  "editor.suggest.showWords": false
}

🔧 Available Commands

🚀 Installation & Setup

Quick Installation

# Download the latest extension
curl -L https://sdk.nehonix.space/pkgs/mods/vscode/latest/fortify-schema.vsix -o fortify-schema.vsix

# Install in VS Code
code --install-extension fortify-schema.vsix

# Verify installation
# You should see: "✨ Fortify Schema extension loaded!" notification

Workspace Setup

Create .vscode/settings.json in your project:

{
  "fortify.enableDiagnostics": true,
  "fortify.colorScheme": "professional",
  "files.associations": {
    "*.schema.ts": "typescript"
  }
}

🐛 Troubleshooting

Common Issues & Solutions

Extension not highlighting?

// Add to settings.json
{
  "editor.semanticHighlighting.enabled": true,
  "fortify.enableSemanticTokens": true
}

IntelliSense not working?

1. Ensure you're inside Interface({...}) blocks
2. Try typing trigger characters: ", :, .$
3. Restart TypeScript service: Ctrl+Shift+P > "TypeScript: Restart TS Server"

Performance issues?

{
  "fortify.debounceTime": 500,
  "fortify.maxFileSize": 524288
}

🧹 Manual Cleanup

If you uninstall the extension and want to clean up settings:

Automatic Cleanup

# Command Palette (Ctrl+Shift+P)
> Fortify: Cleanup Themes and Settings

Manual Cleanup

1. VS Code Settings: Search for "fortify" and reset custom settings
2. Workspace Settings: Remove fortify.* entries from .vscode/settings.json
3. Theme Settings: Remove custom tokenColorCustomizations

📊 Extension Statistics

• File Types Supported: TypeScript, JavaScript, TSX, JSX, Markdown
• Trigger Characters: 7 intelligent trigger characters
• Color Themes: 5 professional themes included
• Commands Available: 6 productivity commands
• Performance: <1ms response time for completions
• Memory Usage: <5MB additional memory footprint

🎯 Pro Tips

1. Use hover extensively - Hover over any element for instant documentation
2. Leverage go-to-definition - Navigate large schemas with Ctrl+click
3. Apply themes - Choose colors that match your development environment
4. Use @fortify-ignore - Suppress warnings for intentional patterns
5. Enable all features - Maximum productivity with all features enabled

🔗 Extension Documentation

For complete extension documentation, see VS Code Extension Guide

📖 Complete Documentation

🏢 Production Deployment

Pre-Production Checklist

// 1. Schema Validation Testing
const testSchema = Interface({
  // Your production schema
});

// 2. Performance Testing
console.time("validation");
for (let i = 0; i < 10000; i++) {
  testSchema.safeParse(testData);
}
console.timeEnd("validation");

// 3. Error Handling
const result = testSchema.safeParse(invalidData);
if (!result.success) {
  // Implement proper error logging
  logger.error("Validation failed", { errors: result.errors });
}

// 4. Memory Monitoring
const memBefore = process.memoryUsage();
// Run validations
const memAfter = process.memoryUsage();
console.log("Memory increase:", memAfter.heapUsed - memBefore.heapUsed);

Production Best Practices

// 1. Use safeParse() in production
const result = schema.safeParse(data);
if (result.success) {
  // Process valid data
  processData(result.data);
} else {
  // Handle validation errors gracefully
  handleValidationErrors(result.errors);
}

// 2. Implement proper error logging
function handleValidationErrors(errors) {
  errors.forEach((error) => {
    logger.warn("Validation error", {
      field: error.path.join("."),
      message: error.message,
      expected: error.expected,
      received: error.received,
    });
  });
}

// 3. Monitor performance in production
const validationMetrics = {
  totalValidations: 0,
  totalTime: 0,
  errors: 0,
};

function validateWithMetrics(schema, data) {
  const start = performance.now();
  const result = schema.safeParse(data);
  const duration = performance.now() - start;

  validationMetrics.totalValidations++;
  validationMetrics.totalTime += duration;
  if (!result.success) validationMetrics.errors++;

  return result;
}

Enterprise Features

• 🔒 Security: Input sanitization and XSS prevention
• 📊 Monitoring: Built-in performance metrics
• 🔄 Caching: Intelligent validation result caching
• 🌐 Internationalization: Multi-language error messages
• 📈 Analytics: Validation pattern analysis
• 🛡️ Type Safety: 100% TypeScript coverage

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

git clone https://github.com/Nehonix-Team/fortify-schema.git
cd fortify-schema
npm install

# Run tests
npm test

# Run benchmarks
npm run benchmark

# Build the project
npm run build

# Run VS Code extension development
cd vscode-extension
npm install
npm run compile

Running Tests

# Unit tests
npm run test:unit

# Integration tests
npm run test:integration

# Performance tests
npm run test:performance

# All tests with coverage
npm run test:coverage

📞 Support & Community

Getting Help

• 📚 Documentation: GitHub Repository
• 🐛 Issues: Bug Reports & Feature Requests
• 💬 Discussions: Community Forum
• 📦 NPM Package: fortify-schema
• 📧 Enterprise Support: support@nehonix.space

Community

• 🌟 Star us on GitHub if you find Fortify Schema useful
• 🐦 Follow us on Twitter @NehonixTeam
• 💼 LinkedIn: Nehonix Team

📄 License

MIT © Nehonix Team