DEV Community: Nehonix Inc

Fortify Schema: Interface-Style TypeScript Validation with Conditional Logic

Nehonix Inc — Thu, 26 Jun 2025 17:57:58 +0000

Fortify Schema: Interface-Style TypeScript Validation with Conditional Logic

A TypeScript validation library designed around familiar interface syntax and advanced conditional validation capabilities.

When building TypeScript applications that handle external data, validation becomes essential. Whether you're processing API requests, user forms, or configuration files, you need a way to ensure data integrity while maintaining type safety.

Fortify Schema addresses this need by providing a validation library that uses interface-like syntax familiar to TypeScript developers, combined with advanced conditional validation capabilities for complex business logic.

Core Design Principles

Interface-Native Syntax: Schema definitions use a string-based syntax that mirrors TypeScript interface declarations, making validation rules intuitive for TypeScript developers.

Conditional Validation: Built-in support for runtime conditional logic, allowing fields to be required, optional, or have different validation rules based on other data properties.

Type Integration: Complete TypeScript inference ensures validated data maintains proper typing without additional type assertions.

Basic Schema Definition

Here's how you define a schema in Fortify Schema:

import { Interface } from "fortify-schema";

const UserSchema = Interface({
  id: "uuid",
  email: "email",
  name: "string(2,50)",
  age: "number(18,120)?",
  role: "admin|user|guest",
  tags: "string[]?",
  createdAt: "date"
});

// Validation with full type inference
const result = UserSchema.safeParse(userData);
if (result.success) {
  // result.data is properly typed
  console.log(result.data.email); // string
  console.log(result.data.age);   // number | undefined
}

Comprehensive Type Support

Fortify Schema supports a wide range of validation types:

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

  // Constrained types
  username: "string(3,20)",     // 3-20 characters
  score: "number(0,100)",       // Range validation

  // Format validation
  email: "email",
  website: "url",
  phone: "phone",
  userId: "uuid",

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

  // Union types
  status: "active|inactive|pending",
  priority: "low|medium|high",

  // Literal values
  version: "2.0",
  type: "user",

  // Optional fields
  description: "\"string?\","
  metadata: "any?"
});

Nested Object Validation

Complex nested structures are handled naturally:

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

Conditional Validation Logic

The conditional validation system allows you to express complex business rules directly in schema definitions:

const ConditionalSchema = Interface({
  // Context objects for conditional logic
  config: "any?",
  user: "any?",

  // Core data
  id: "uuid",
  type: "individual|business",

  // Conditional fields based on runtime properties
  businessName: "when type=business *? string(2,100) : =null",
  taxId: "when type=business *? string : =null",

  // Conditional validation based on configuration
  requiresApproval: "when config.strictMode.$exists() *? boolean : =false",

  // Default values based on conditions
  permissions: "when user.role=admin *? string[] : =[\"read\"]",

  // Complex nested conditions
  advancedFeatures: "when user.plan=premium && config.enableAdvanced.$exists() *? object : =null"
});

Runtime Validation Methods

The conditional system includes several runtime validation methods:

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

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

  // Empty state checking
  hasItems: "when data.items.$empty() *? boolean : =true",

  // Null validation
  isConfigured: "when data.config.$null() *? boolean : =false",

  // String operations
  hasKeyword: "when data.title.$contains(important) *? boolean : =false",
  isPrefixed: "when data.code.$startsWith(PRE-) *? boolean : =false",

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

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

Practical Application: API Request Validation

Here's a real-world example for validating API requests:

const CreateProductRequestSchema = Interface({
  // Request context
  user: "any?",
  permissions: "any?",

  // Product data
  name: "string(1,200)",
  description: "\"string(,2000)?\","
  price: "number(0.01,999999.99)",
  category: "electronics|books|clothing|home|sports",

  // Inventory
  initialStock: "number(0,)",
  trackInventory: "boolean",

  // Conditional validation based on user permissions
  bulkDiscount: "when permissions.canSetBulkPricing.$exists() *? object? : =null",

  // Admin-only fields
  internalNotes: "when user.role=admin *? string? : =null",
  costPrice: "when user.role=admin *? number(0,) : =null",

  // Category-specific requirements
  isbn: "when category=books *? string : =null",
  size: "when category=clothing *? string : =null",

  // Media uploads
  images: "url[](1,10)",
  documents: "when category=books *? url[] : =[]",

  // Metadata
  tags: "string[](0,20)",
  status: "draft|active",
  publishAt: "date?"
});

Schema Transformations

Fortify Schema provides utilities for creating schema variations:

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

// Schema transformations
const PublicUserSchema = Mod.omit(BaseUserSchema, ["password"]);
const UpdateUserSchema = Mod.partial(Mod.omit(BaseUserSchema, ["id", "createdAt"]));
const AdminUserSchema = Mod.extend(BaseUserSchema, {
  permissions: "string[]",
  lastLogin: "date?",
  adminNotes: "string?"
});

// Combining schemas
const UserWithProfileSchema = Mod.extend(BaseUserSchema, {
  profile: {
    avatar: "url?",
    bio: "string(,500)?",
    website: "url?",
    location: "string?"
  }
});

Error Handling and Debugging

Fortify Schema provides detailed error information for debugging:

const result = UserSchema.safeParse(invalidData);

if (!result.success) {
  result.errors.forEach(error => {
    console.log(`Field: ${error.path.join('.')}`);
    console.log(`Error: ${error.message}`);
    console.log(`Code: ${error.code}`);
    console.log(`Expected: ${error.expected}`);
    console.log(`Received: ${error.received}`);
  });
}

Performance Considerations

Fortify Schema is designed for production use with several performance optimizations:

Schema Compilation: Schemas are optimized at creation time rather than during validation
Caching: Repeated validations benefit from intelligent caching of constraint checks
Memory Efficiency: Minimal memory overhead per validation operation
Early Termination: Validation stops on first error for faster feedback

Development Tooling

A VS Code extension provides enhanced development experience:

Syntax highlighting for schema definitions
IntelliSense with type and method completion
Real-time validation with inline error detection
Documentation on hover for validation types

Installation and Setup

npm install fortify-schema

Basic usage:

import { Interface } from "fortify-schema";

const schema = Interface({
  email: "email",
  name: "string(2,100)",
  age: "number(18,)?"
});

const result = schema.safeParse(data);

Use Cases

Fortify Schema is well-suited for:

API Request Validation: Complex request schemas with role-based field requirements
Configuration Management: Validating application configuration with conditional settings
Form Processing: Multi-step forms with conditional field requirements
Data Pipeline Validation: Ensuring data integrity in processing workflows
Business Rule Enforcement: Expressing complex validation logic in a readable format

Technical Architecture

The library provides several validation methods:

parse(data): Synchronous validation with exceptions
safeParse(data): Safe validation returning result objects
parseAsync(data): Asynchronous validation with promises
safeParseAsync(data): Safe asynchronous validation

All methods maintain full TypeScript type inference, ensuring validated data is properly typed without additional assertions.

Fortify Schema offers TypeScript developers a validation solution that integrates naturally with existing codebases while providing advanced conditional validation capabilities. The interface-like syntax reduces the learning curve, while the conditional validation system handles complex business logic requirements.

Resources:

Have you worked with conditional validation requirements in your TypeScript projects? What approaches have you found most effective?

[Boost]

Nehonix Inc — Mon, 02 Jun 2025 07:03:06 +0000

Nehonix Inc

May 31 '25

Nehonix FortifyJS: Transform JavaScript Functions into Enterprise-Grade Security Powerhouses with Zero Configuration

Comments

6 min read

Nehonix FortifyJS: Transform JavaScript Functions into Enterprise-Grade Security Powerhouses with Zero Configuration

Nehonix Inc — Sat, 31 May 2025 10:24:51 +0000

The Problem Every Developer Faces

// Standard JavaScript - Vulnerable and Unoptimized
async function processUserData(userData) {
    // ❌ No caching - executes every time
    // ❌ No security - parameters exposed
    // ❌ No optimization - same performance always
    // ❌ No monitoring - no insights
    // ❌ Manual error handling required

    const validated = validateUser(userData);
    const result = await expensiveAPICall(validated);
    return result;
}

What if I told you that you could transform this ordinary function into an enterprise-grade, self-optimizing, security-hardened powerhouse with literally zero configuration?

Meet Nehonix FortifyJS: The Zero-Config Security Revolution

Nehonix FortifyJS is a game-changing JavaScript library that transforms your ordinary functions and data structures into enterprise-grade, production-ready components with automatic security, intelligent caching, and comprehensive monitoring.

🚀 The Magic of `func()` - Zero Configuration Required

import { func } from "fortify2-js";

// Transform ANY function with zero configuration
const processUserData = func(async (userData) => {
    const validated = validateUser(userData);
    const result = await expensiveAPICall(validated);
    return result;
});

// Execute normally - get extraordinary results
const result = await processUserData(userData);

What just happened? Your function now has:

✅ 50-80% faster execution (intelligent caching)
✅ Military-grade encryption (automatic parameter protection)
✅ Self-optimization (learns usage patterns)
✅ Threat detection (blocks suspicious patterns)
✅ Memory management (automatic cleanup)
✅ Real-time analytics (performance insights)
✅ Intelligent retry logic (handles failures gracefully)

🎯 Core Philosophy: Security by Default, Performance by Design

Traditional Approach (Painful)

// Manual implementation nightmare
const cache = new Map();
const rateLimiter = new RateLimiter();
const monitor = new PerformanceMonitor();

async function secureFunction(data) {
    // 50+ lines of boilerplate code
    // Cache management logic
    // Security validation
    // Error handling
    // Performance monitoring
    // Memory cleanup
    // Retry logic
    // ...
}

FortifyJS Approach (Effortless)

const secureFunction = func(async (data) => {
    // Your business logic only
    return processData(data);
});
// Done. Everything else is automatic.

🔐 Secure Data Structures That Actually Work

SecureArray - Arrays with Military-Grade Protection

import { fArray } from "fortify2-js";

// Create secure array with automatic encryption
const sensitiveData = fArray(["api-key", "password", "token"]);

// Set encryption (optional - can be automatic)
sensitiveData.setEncryptionKey("your-secure-key");
sensitiveData.encryptAll();

// Use like normal array - security is transparent
sensitiveData.push("new-secret");
const value = sensitiveData.get(0); // Automatically decrypted
console.log(sensitiveData.toArray()); // All decrypted

// Bonus: Raw encrypted data verification
console.log(sensitiveData.getRawEncryptedData());
// Output: ['[ENCRYPTED:AES256:base64data...]', '[ENCRYPTED:AES256:base64data...]']

SecureObject - Objects with Automatic Threat Detection

import { fObject } from "fortify2-js";

// Automatic sensitive key detection
const config = fObject({
    username: "admin",
    password: "secret123",     // ✅ Automatically marked sensitive
    apiKey: "sk-1234567890",   // ✅ Automatically marked sensitive
    email: "admin@company.com"
});

// Automatic encryption for sensitive data
config.encryptAll();

// Access with automatic decryption
const password = config.get("password"); // Decrypted automatically

SecureString - Strings with Memory Fragmentation

import { fString } from "fortify2-js";

// Maximum protection for credit cards, passwords, etc.
const creditCard = fString("4532-1234-5678-9012", {
    protectionLevel: "maximum",      // Military-grade security
    enableFragmentation: true,       // Scatter across memory
    enableEncryption: true          // AES-256 encryption
});

// Multi-pass secure wiping when destroyed
creditCard.destroy(); // 7-pass military-grade wiping

🎯 Real-World Performance Comparison

Express.js API Route - Before & After

Before (Standard Express):

app.get('/users/:id', async (req, res) => {
    // No caching - database hit every time
    // No security - parameters exposed
    // No monitoring - no insights
    const user = await database.findById(req.params.id);
    res.json(user);
});

After (FortifyJS Enhanced):

app.get('/users/:id', func(async (req, res) => {
    const user = await database.findById(req.params.id);
    res.json(user);
}));

// Automatic benefits:
// ✅ Smart caching - 50-80% faster response times
// ✅ Request parameters automatically encrypted
// ✅ Circular reference handling (no JSON.stringify errors)
// ✅ Performance monitoring per route
// ✅ Memory leak prevention
// ✅ Automatic retry logic for database failures

Data Processing Pipeline

// Transform your entire data pipeline
const pipeline = [
    func(validateInput),
    func(enrichData),
    func(processAnalytics),
    func(generateReport)
].map(step => func(step)); // Double security for critical pipelines

// Each step now has automatic:
// - Caching for repeated operations
// - Security for sensitive data
// - Performance optimization
// - Error recovery

📊 Memory Management That Actually Works

The JavaScript Memory Problem

Standard JavaScript strings and objects have a critical flaw: you cannot securely wipe them from memory. This leaves sensitive data vulnerable to memory dumps and forensic analysis.

FortifyJS Solution: Automatic Memory Management

// Automatic memory registration and tracking
const secureData = fObject({
    password: "super-secret",
    apiKey: "🤣😋"
});

// Behind the scenes (AUTOMATIC):
// ✅ Memory tracking enabled
// ✅ Leak detection monitoring
// ✅ Pressure handling configured
// ✅ Pool optimization active
// ✅ Secure wiping prepared

// When memory pressure hits 80%:
// ✅ Automatic cleanup triggered
// ✅ Unused buffers securely wiped
// ✅ Memory pools optimized
// ✅ Garbage collection optimized

// Get real-time memory insights
const stats = secureData.getMemoryUsage();
console.log({
    memory: stats.formattedMemory,    // "2.5 B"
    buffers: stats.bufferCount,       // 3
    hitRate: stats.poolStats.hitRate  // 0.85 (85% efficiency)
});

🛡️ Security Features That Set FortifyJS Apart

1. Automatic Sensitive Data Detection

const userData = fObject({
    name: "John Doe",
    email: "john@example.com",
    password: "secret123",        // ✅ Auto-detected as sensitive (to get default keys: use `getSensitiveKeys()` method )
    socialSecurity: "123-45-6789",
    apiKey: "sk-1234567890",     
    phoneNumber: "+1-555-0123"
});

// Sensitive keys automatically encrypted
// Regular data remains performant

2. Military-Grade Memory Wiping

const sensitiveString = fString("classified-information");

// When destroyed - 7-pass secure wiping:
// Pass 1: Fill with 0x00 (zeros)
// Pass 2: Fill with 0xFF (ones)  
// Pass 3: Fill with 0xAA (alternating)
// Pass 4: Fill with 0x55 (inverse)
// Pass 5: Fill with 0x00 (zeros again)
// Pass 6: Cryptographic random data
// Pass 7: Final zero pass

sensitiveString.destroy(); // Memory forensically unrecoverable

3. Memory Fragmentation

const creditCard = fString("4532-1234-5678-9012", {
    enableFragmentation: true
});

// String automatically split across multiple memory locations
// Even if one fragment is found, others remain secure
// Reconstruction requires all fragments + encryption keys

📈 Performance Metrics That Prove the Value

Metric	Standard JS	FortifyJS	Improvement
Execution Speed	Baseline	50-80% faster	Intelligent caching
Memory Efficiency	Manual	95% efficiency	Pool management
Security Vulnerabilities	High	Zero*	Automatic protection
Memory Leaks	Common	Prevented	Auto-detection
Development Time	100%	30%	Zero config

*With proper key management

🚀 Getting Started (Seriously, It's This Simple)

Installation

npm install fortify2-js
# or
yarn add fortify2-js

Basic Usage

import { func, fArray, fObject, fString } from "fortify2-js";

// Transform functions
const smartFunction = func(yourFunction);

// Secure data structures
const secureArray = fArray(["sensitive", "data"]);
const secureObject = fObject({ password: "secret" });
const secureString = fString("classified-info");

// Execute normally - get extraordinary results
const result = await smartFunction(data);

Express.js Integration

import express from "express";
import { func } from "fortify2-js";

const app = express();

// Transform ALL your routes with zero configuration
app.get('/api/users/:id', func(async (req, res) => {
    const user = await getUserById(req.params.id);
    res.json(user);
}));

// Every route now has enterprise-grade security and performance

🎨 Advanced Features for Power Users

Real-Time Analytics

const smartFunction = func(async(s: string)=>{
 return await (fString(s).hash("SHA-256", "uint8array"))
});

func(async()=>{
  // Execute operations
await smartFunction("data1");
await smartFunction("data2");

// Access rich analytics
const analytics = smartFunction.getAnalyticsData();
const suggestions = smartFunction.getOptimizationSuggestions();
const trends = smartFunction.getPerformanceTrends();

console.log("analytics result:", analytics);
console.log("suggestions:", suggestions);
console.log("trends: ", trends);
})()

Snapshot Management


const versionedArray = fArray(["v1-data", "v1-config"]);

// Create snapshot
const snapshotId = versionedArray.createSnapshot();

// Modify data
versionedArray.push("v2-data");

// logging before restore
console.log("versionedArray: ", versionedArray.toArray());

// Restore to previous state
versionedArray.restoreFromSnapshot(snapshotId);

console.log("snapshotId: ", snapshotId);
console.log("versionedArray: ", versionedArray.toArray());

Event-Driven Security

const secureData = fObject({ sensitive: "data" });


// Listen for security events
secureData.addEventListener("filtered", (event) => {
    console.log("Data filtered:", event);
});

// filter
secureData.filter((item) => item.includes("sensitive"));

🏆 Why FortifyJS Is a Game-Changer

For Startups

Zero learning curve - works with existing code
Instant security - no security expertise required
Performance boost - faster apps with less effort
Cost savings - reduce infrastructure needs

For Enterprises

Compliance ready - military-grade encryption
Audit friendly - comprehensive logging
Scalable - handles enterprise workloads
Zero maintenance - automatic optimization

For Developers

No boilerplate - focus on business logic
Type safety - full TypeScript support
Rich analytics - understand your app's performance
Peace of mind - security handled automatically

🔮 The Future of Secure JavaScript

FortifyJS represents a paradigm shift from "security as an afterthought" to "security by default." By automatically handling the complex security and performance challenges that plague modern applications, it allows developers to focus on what matters most: building great products.

What's Next?

The library is actively developed with upcoming features:

Quantum-resistant encryption
Advanced threat intelligence
Cloud integration
AI-powered optimization

🤝 Join the Community

FortifyJS is more than a library - it's a movement toward making JavaScript applications secure by default.

Get involved:

⭐ Star the repository
🐛 Report issues and feature requests
💬 Join discussions
🤝 Contribute to the codebase

📚 Resources

Documentation: Comprehensive guides and API references
Examples: Real-world usage patterns
Best Practices: Security and performance recommendations
Migration Guides: Easy transition from standard JavaScript

Contribute now: https://github.com/nehonix/fortifyjs

for full doc, check: https://lab.nehonix.space

Ready to transform your JavaScript applications?

npm install fortify2-js

Your functions will never be the same again. 🚀

What do you think? Have you faced similar security or performance challenges in your JavaScript applications? Share your experiences in the comments below!

JavaScript #Security #Performance #WebDevelopment #NodeJS #TypeScript

Secure Your URLs with NehonixURIProcessor v2.2.0: The Ultimate TypeScript Library for URI Validation

Nehonix Inc — Fri, 25 Apr 2025 23:40:01 +0000

Hey Dev.to community! 👋 I’m thrilled to share NehonixURIProcessor v2.2.0, a powerful TypeScript library designed for developers and security enthusiasts who need to validate, decode, and secure URIs like pros. Whether you’re building web apps, testing for vulnerabilities, or just wrestling with tricky URLs, this library has your back. Let’s dive into why it’s a game-changer and how you can start using it today!
A full documentation is availlable on lab.nehonix.space

What’s NehonixURIProcessor?

NehonixURIProcessor is a TypeScript-first library for URI processing, offering robust validation, encoding/decoding, and security analysis. It’s built for:

Security testing: Detect malicious patterns like XSS or SQL injection.
Web development: Validate URLs with fine-grained control.
Penetration testing: Analyze and decode complex URI encodings.

With version 2.2.0, we’ve leveled up the library with new features, better type safety, and enhanced documentation. Here’s the scoop!

Key Features in v2.2.0

1. Advanced URL Validation with `checkUrl` and `asyncCheckUrl`

The checkUrl (synchronous) and asyncCheckUrl (asynchronous) methods let you validate URLs against customizable rules. Need to ensure a URL uses HTTPS, has a specific hostname, or avoids duplicate query params? No problem!

import { NehonixURIProcessor as __processor__ } from "nehonix-uri-processor";

const result = await __processor__.asyncCheckUrl(
  "https://example.com?user=<script>",
  {
    httpsOnly: true,
    detectMaliciousPatterns: true,
    customValidations: [["hostname", "===", "example.com"]],
  }
);

console.log(result.validationDetails.maliciousPatterns);
// Output: { isValid: false, message: "Malicious pattern detected", detectedPatterns: [{ type: "XSS", value: "<script>", score: 90 }], ... }

New in 2.2.0: asyncCheckUrl now includes malicious pattern results in validationDetails.maliciousPatterns, making it easier to integrate with your security workflows.

2. Malicious Pattern Detection

Protect your app from attacks with detectMaliciousPatterns and needsDeepScan. These methods analyze URIs for threats like XSS or SQL injection, with configurable sensitivity.

const needsScan = __processor__.needsDeepScan(
  "https://example.com?user=admin' OR '1'='1"
);
console.log(needsScan); // true

const result = __processor__.detectMaliciousPatterns(
  "https://example.com?user=<script>",
  { sensitivity: 1.0 }
);
console.log(result); // Detailed analysis with detected patterns

3. Auto-Detection and Decoding

Decode complex URIs effortlessly with autoDetectAndDecode or its async counterpart. It handles Base64, percent encoding, JWT, and more, even in nested scenarios.

const decoded = await __processor__.asyncAutoDetectAndDecode(
  "https://example.com?data=SGVsbG8gV29ybGQ="
);
console.log(decoded); // https://example.com?data=Hello World

4. Framework Integrations

Seamlessly integrate with Express or React:

Express Middleware: Block malicious URIs automatically.
React Hook: Validate URLs in your components with useNehonixShield.

const SecurityDemo = () => {
  const { scanUrl } = useNehonixShield();
  const handleAnalyze = async () => {
    const result = await scanUrl("https://example.com?category=books");
    console.log(result);
  };
  return <button onClick={handleAnalyze}>Analyze URL</button>;
};

5. TypeScript Awesomeness

Version 2.2.0 brings enhanced type safety. The new AsyncUrlCheckResult type ensures maliciousPatterns lives in validationDetails, keeping your code clean and predictable.

type AsyncUrlCheckResult = Omit<UrlCheckResult, 'validationDetails'> & {
  validationDetails: UrlCheckResult['validationDetails'] & {
    maliciousPatterns?: { isValid?: boolean; message?: string; detectedPatterns?: DetectedPattern[]; ... };
  };
};

6. New Methods and Utilities

asyncIsUrlValid: Async URI validation for non-blocking workflows.
sanitizeInput: Strip malicious patterns (use cautiously, it’s still stabilizing).
__processor__ alias: Import NehonixURIProcessor as __processor__ for shorter code.

What’s New in v2.2.0?

Improved Type Structure: maliciousPatterns now resides in validationDetails for asyncCheckUrl, streamlining security result handling.
New Security Features: Added needsDeepScan and detectMaliciousPatterns for robust threat detection.
Better Docs: Updated readme.md and checkUrlMethod.md with clearer examples and detailed type info.
Fixed Bugs: Corrected analyzeUrl to scanUrl in React Hook examples and improved literalValue type safety.

Check out the full changelog for details!

Why You’ll Love It

Security-First: Built for detecting and preventing URI-based attacks.
Flexible: Supports custom validation rules, international characters, and framework integrations.
Developer-Friendly: TypeScript types, clear docs, and a short import alias (__processor__).
Open-Source: MIT-licensed, with a welcoming community for contributions.

Get Started in Minutes

Install the library:

   npm install nehonix-uri-processor punycode

Try a quick example:

   import { NehonixURIProcessor as __processor__ } from "nehonix-uri-processor";

   async function validateUrl() {
     const result = await __processor__.asyncCheckUrl(
       "https://example.com/login",
       {
         httpsOnly: true,
         detectMaliciousPatterns: true,
       }
     );
     console.log(result.isValid ? "Safe URL!" : "Potential threat detected!");
   }
   validateUrl();

Explore the docs and GitHub repo for more.

Join the Community

I’d love for you to try NehonixURIProcessor and share your feedback! Whether you’re securing a web app, testing APIs, or decoding gnarly URIs, this library is here to help. Star the GitHub repo, open an issue, or contribute a feature. Let’s make the web safer together! 🚀

Have questions or ideas? Drop a comment below. Happy coding, Dev.to fam! 😎

TypeScript #JavaScript #Security #WebDevelopment #OpenSource

Introducing Nehonix URI Processor: Simplify URI Validation and Security in TypeScript

Nehonix Inc — Tue, 22 Apr 2025 09:26:09 +0000

Introducing Nehonix URI Processor: Simplify URI Validation and Security in TypeScript

Hey Dev.to community! 👋 I’m thrilled to share a project I’ve been working on: nehonix-uri-processor, a TypeScript library that makes URI validation, decoding, and security analysis a breeze. Whether you’re building a web app, securing an API, or conducting security tests, this library is here to help. Let’s dive in!

What is nehonix-uri-processor?

nehonix-uri-processor is a lightweight TypeScript library for handling URIs securely and efficiently. It’s packed with features to validate, decode, and analyze URIs, making it an essential tool for web developers and security researchers.

Key Features

Validate URIs: Check URIs against custom rules (e.g., HTTPS-only, max length).
Auto-Decode URIs: Automatically detect and decode encodings like Base64, percent encoding, and more.
Security Analysis: Identify potential vulnerabilities in URIs.
WAF Testing: Generate encoding variants to test Web Application Firewalls (WAFs).

The library is at version 2.1.3, published under the MIT License, so it’s free to use in any project!

Why I Built This

Handling URIs can be tricky—whether it’s validating user inputs, decoding encoded parameters, or checking for security risks. I often found myself writing repetitive code to handle these tasks, and existing solutions either lacked TypeScript support or were too complex. So, I created nehonix-uri-processor to simplify URI processing while keeping security in mind.

Getting Started

Installation

Install the library via npm:

npm i nehonix-uri-processor

You’ll also need to install the punycode dependency:

npm install punycode

A Quick Example

Here’s how you can use nehonix-uri-processor to decode a Base64-encoded URI parameter:

import { NehonixURIProcessor } from "nehonix-uri-processor";

// Decode a Base64-encoded query parameter
const encodedUri = "SGVsbG8gV29ybGQ="; // "Hello World" in Base64
const decoded = NehonixURIProcessor.autoDetectAndDecode(encodedUri);
console.log(decoded); // Outputs: "Hello World"

This example uses the recommended autoDetectAndDecode method, which automatically detects the encoding (Base64 in this case) and decodes it to plaintext.

Use Case: Securing an API Endpoint

Let’s say you’re building an API that accepts URLs as query parameters. You want to validate and decode the URIs before processing them to avoid security issues. Here’s how nehonix-uri-processor can help:

import { NehonixURIProcessor } from "nehonix-uri-processor";

// Example API endpoint
async function handleRequest(queryParam: string) {
  try {
    // Decode the query parameter
    const decoded = NehonixURIProcessor.autoDetectAndDecode(queryParam);
    console.log("Decoded:", decoded);

    // Validate the URI (e.g., only allow HTTPS URLs)
    const isValid = NehonixURIProcessor.isValidUri(decoded, { httpsOnly: true });
    if (!isValid) {
      throw new Error("Invalid URI");
    }

    // Process the URI safely
    return { status: "success", data: decoded };
  } catch (error) {
    return { status: "error", message: error.message };
  }
}

// Test with an encoded URI
const result = handleRequest("https://example.com?data=SGVsbG8gV29ybGQ=");
console.log(result); // { status: "success", data: "https://example.com?data=Hello World" }

This code ensures the URI is decoded and validated before being processed, reducing risks like injection attacks or malformed inputs.

What’s New in v2.1.3?

The latest version includes several improvements:

Added MIT License for open-source usage.
Fixed circular dependency issues for better reliability.
Improved decoding to handle edge cases (e.g., correctly converting Hello+World to Hello World).
Switched to named exports for a clearer API (import { NehonixURIProcessor } from "nehonix-uri-processor").

Try It Out!

You can install nehonix-uri-processor now and give it a try:

npm i nehonix-uri-processor

For more examples and details, check out the documentation. I’d love to hear your feedback—let me know how it works for you in the comments! 😄

Contribute

Want to help make this library even better? Contributions are welcome! Fork the repo on GitHub and submit a pull request.

Thanks for reading! If you’re working on a project that involves URIs, I hope nehonix-uri-processor can save you some time and keep your app secure. Let’s discuss in the comments—what’s your go-to tool for URI handling?

DEV Community: Nehonix Inc

Fortify Schema: Interface-Style TypeScript Validation with Conditional Logic

Fortify Schema: Interface-Style TypeScript Validation with Conditional Logic

Core Design Principles

Basic Schema Definition

Comprehensive Type Support

Nested Object Validation

Conditional Validation Logic

Runtime Validation Methods

Practical Application: API Request Validation

Schema Transformations

Error Handling and Debugging

Performance Considerations

Development Tooling

Installation and Setup

Use Cases

Technical Architecture

[Boost]

Nehonix FortifyJS: Transform JavaScript Functions into Enterprise-Grade Security Powerhouses with Zero Configuration

Nehonix FortifyJS: Transform JavaScript Functions into Enterprise-Grade Security Powerhouses with Zero Configuration

The Problem Every Developer Faces

Meet Nehonix FortifyJS: The Zero-Config Security Revolution

🚀 The Magic of func() - Zero Configuration Required

🎯 Core Philosophy: Security by Default, Performance by Design

Traditional Approach (Painful)

FortifyJS Approach (Effortless)

🔐 Secure Data Structures That Actually Work

SecureArray - Arrays with Military-Grade Protection

SecureObject - Objects with Automatic Threat Detection

SecureString - Strings with Memory Fragmentation

🎯 Real-World Performance Comparison

Express.js API Route - Before & After

Data Processing Pipeline

📊 Memory Management That Actually Works

The JavaScript Memory Problem

FortifyJS Solution: Automatic Memory Management

🛡️ Security Features That Set FortifyJS Apart

1. Automatic Sensitive Data Detection

2. Military-Grade Memory Wiping

3. Memory Fragmentation

📈 Performance Metrics That Prove the Value

🚀 Getting Started (Seriously, It's This Simple)

Installation

Basic Usage

Express.js Integration

🎨 Advanced Features for Power Users

Real-Time Analytics

Snapshot Management

Event-Driven Security

🏆 Why FortifyJS Is a Game-Changer

For Startups

For Enterprises

For Developers

🔮 The Future of Secure JavaScript

What's Next?

🤝 Join the Community

📚 Resources

Contribute now: https://github.com/nehonix/fortifyjs

JavaScript #Security #Performance #WebDevelopment #NodeJS #TypeScript

Secure Your URLs with NehonixURIProcessor v2.2.0: The Ultimate TypeScript Library for URI Validation

What’s NehonixURIProcessor?

Key Features in v2.2.0

1. Advanced URL Validation with checkUrl and asyncCheckUrl

2. Malicious Pattern Detection

3. Auto-Detection and Decoding

4. Framework Integrations

5. TypeScript Awesomeness

6. New Methods and Utilities

What’s New in v2.2.0?

Why You’ll Love It

Get Started in Minutes

Join the Community

TypeScript #JavaScript #Security #WebDevelopment #OpenSource

Introducing Nehonix URI Processor: Simplify URI Validation and Security in TypeScript

Introducing Nehonix URI Processor: Simplify URI Validation and Security in TypeScript

What is nehonix-uri-processor?

Key Features

Why I Built This

Getting Started

Installation

🚀 The Magic of `func()` - Zero Configuration Required

1. Advanced URL Validation with `checkUrl` and `asyncCheckUrl`