DEV Community: ProCoder 😌

Fortify Schema

ProCoder 😌 — Wed, 03 Sep 2025 07:06:33 +0000

Fortify Schema

TypeScript-First Validation Library with Intuitive Syntax
Report any bugs to Nehonix-Team via: team@nehonix.space

Fortify Schema, is a powerful TypeScript-first schema validation library that combines the familiarity of TypeScript interfaces with runtime validation and automatic type inference.

✨ Key Features

🎯 Interface-like Syntax — Define schemas using familiar TypeScript interface syntax
⚡ Runtime Type Inference — Validated data is automatically typed without manual casting
🚫 Non-Empty Validation — New "!" syntax for non-empty strings and non-zero numbers
🔧 Rich Constraints — Support for string length, number ranges, arrays, unions, and constants
🛠️ Schema Utilities — Transform schemas with partial(), omit(), and extend() methods
🎨 VSCode Integration — Dedicated extension with syntax highlighting and IntelliSense
📦 Zero Dependencies — Lightweight and performant

🚀 Quick Start

Installation

npm install fortify-schema
# or
yarn add fortify-schema
# or
pnpm add fortify-schema

Requirements: TypeScript 4.5+ and Node.js 14+

Basic Usage

import { Interface } from 'fortify-schema';

// Define your schema
const UserSchema = Interface({
  id: "number!",                 // Non-zero number (basic type with "!")
  name: "string(2,50)",          // String with length constraints (2-50 chars)
  email: "email",                // Email validation (no "!" available)
  age: "number(18,120)?",        // Optional age between 18-120
  bio: "string!?",               // Optional, but if provided must be non-empty
  tags: "string[](1,10)?",       // Optional array of 1-10 strings
  status: "active|inactive",     // Union type
  role: "=admin",                // Constant value
});

// Valid data
const userData = {
  id: 1,                         // ✅ Non-zero number
  name: "Jane Doe",              // ✅ String within length constraints
  email: "hello@example.com",    // ✅ Valid email format
  status: "active",
  role: "admin",
};

// Invalid data examples
const invalidData = {
  id: 0,                         // ❌ Fails: number! rejects 0
  name: "J",                     // ❌ Fails: string(2,50) requires minimum 2 chars
  email: "invalid-email",        // ❌ Fails: invalid email format
  status: "active",
  role: "admin",
};

const result = UserSchema.safeParse(userData);

if (result.success) {
  // ✅ Data is valid and properly typed
  console.log("Welcome,", result.data.name);
  console.log("User ID:", result.data.id); // TypeScript knows this is a number
} else {
  // ❌ Handle validation errors
  console.error("Validation failed:", result.error.issues);
}

📋 Schema Syntax Reference

Primitive Types

const schema = Interface({
  text: "string",           // Any string (including empty "")
  count: "number",          // Any number (including 0)
  flag: "boolean",          // Boolean value
  timestamp: "date",        // Date object
  contact: "email",         // Valid email format
  website: "url",           // Valid URL format
});

Non-Empty/Non-Zero Values (New!)

const schema = Interface({
  // "!" syntax - ONLY for basic string and number types
  name: "string!",          // Non-empty string (rejects "")
  count: "number!",         // Non-zero number (rejects 0)

  // Other types don't support "!" - they have their own validation logic
  email: "email",           // ❌ Cannot do "email!" - not supported
  url: "url",               // ❌ Cannot do "url!" - not supported  
  date: "date",             // ❌ Cannot do "date!" - not supported

  // Optional variants
  title: "string!?",        // Optional, but if provided must be non-empty
  score: "number!?",        // Optional, but if provided must be non-zero
});

Constrained Types

const schema = Interface({
  // Constraint syntax - for length/range validation
  username: "string(3,20)",      // String with length 3-20
  age: "number(0,150)",          // Number between 0-150
  score: "number(0,)",           // Number >= 0
  code: "string(,10)",           // String with max length 10
});

// Non-empty validation - alternative to constraints
const nonEmptySchema = Interface({
  title: "string!",              // Non-empty string (simpler than "string(1,)")
  quantity: "number!",           // Non-zero number
});

// IMPORTANT: Choose ONE approach - cannot combine both:
// ✅ "string(1,100)"     - Use constraints for length validation
// ✅ "string!"           - Use for simple non-empty validation  
// ❌ "string!(1,100)"    - INVALID: Cannot combine both syntaxes

Arrays

const schema = Interface({
  tags: "string[]",              // Array of strings
  scores: "number[](1,5)",       // 1-5 numbers
  items: "string[](,10)",        // Max 10 strings
  required: "number[](1,)",      // At least 1 number
});

Unions and Constants

const schema = Interface({
  status: "pending|approved|rejected",  // Union type
  role: "=admin",                       // Constant value
  priority: "low|medium|high",          // Multiple options
  version: "=1.0.0",                    // Exact match
});

Optional Fields

const schema = Interface({
  id: "number!",          // Required non-zero number
  name: "string!",        // Required non-empty string
  email: "email!?",       // Optional, but if provided must be non-empty
  phone: "string?",       // Optional, can be empty string
  bio: "string!?",        // Optional, but if provided must be non-empty
  tags: "string[]?",      // Optional array
});

🔧 Schema Utilities

Making Fields Optional

const BaseSchema = Interface({
  id: "number",
  name: "string",
  email: "email",
});

// Make specific fields optional
const PartialSchema = Mod.partial(BaseSchema, ['email']);
// Result: { id: number, name: string, email?: string }

// Make all fields optional
const AllOptionalSchema = Mod.partial(BaseSchema);
// Result: { id?: number, name?: string, email?: string }

Omitting Fields

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

// Remove sensitive fields
const PublicUserSchema = Mod.omit(UserSchema, ['password']);
// Result: { id: number, name: string, email: string }

Extending Schemas

const BaseSchema = Interface({
  id: "number",
  name: "string",
});

// Add new fields
const ExtendedSchema = Mod.extend(BaseSchema, {
  email: "email",
  createdAt: "date",
});
// Result: { id: number, name: string, email: string, createdAt: Date }

📖 Advanced Examples

API Response Validation

const ApiResponseSchema = Interface({
  success: "boolean",
  data: Interface({
    users: Interface({
      id: "number",
      username: "string(3,20)",
      email: "email",
      role: "admin|user|moderator",
      isActive: "boolean",
      lastLogin: "date?",
    })[],
  }),
  pagination: Interface({
    page: "number(1,)",
    limit: "number(1,100)",
    total: "number(0,)",
  }),
});

// Use in API handler
async function getUsers(req: Request) {
  const response = await fetch('/api/users');
  const rawData = await response.json();

  const result = ApiResponseSchema.safeParse(rawData);

  if (!result.success) {
    throw new Error('Invalid API response format');
  }

  // Fully typed response data
  return result.data;
}

Form Validation

const ContactFormSchema = Interface({
  name: "string!",              // Required non-empty name (basic validation)
  email: "email",               // Required valid email (has built-in validation)
  phone: "string(10,15)?",      // Optional phone, if provided 10-15 chars
  subject: "support|sales|general",
  message: "string(10,1000)",   // Required message, 10-1000 chars (use constraints)
  newsletter: "boolean?",
});

// Test data
const formData = {
  name: "",                     // ❌ Will fail: string! rejects empty
  email: "user@example.com",    // ✅ Valid email
  subject: "support",           // ✅ Valid union value
  message: "Hi there",          // ✅ Valid length
};

function handleFormSubmit(formData: unknown) {
  const result = ContactFormSchema.safeParse(formData);

  if (!result.success) {
    return {
      success: false,
      errors: result.error.issues.map(issue => ({
        field: issue.path.join('.'),
        message: issue.message
      }))
    };
  }

  // Process valid form data
  return { success: true, data: result.data };
}

Configuration Validation

const ConfigSchema = Interface({
  database: Interface({
    host: "string!",            // Required non-empty host
    port: "number(1,65535)",    // Required port with range validation
    name: "string(1,50)",       // Required database name with length constraint
    ssl: "boolean?",
  }),
  redis: Interface({
    url: "url",                 // Required valid URL (has built-in validation)
    ttl: "number(60,)",         // Required TTL with minimum constraint
  })["?"], // Optional nested object
  features: Interface({
    enableCache: "boolean",
    maxUsers: "number!",        // Required non-zero max users
    environment: "development|staging|production",
  }),
});

// Load and validate configuration
function loadConfig(): ConfigType {
  const rawConfig = JSON.parse(process.env.APP_CONFIG || '{}');
  const result = ConfigSchema.safeParse(rawConfig);

  if (!result.success) {
    console.error('Invalid configuration:', result.error.issues);
    process.exit(1);
  }

  return result.data;
}

type ConfigType = typeof ConfigSchema.infer;

🎯 Use Cases

API Validation — Validate request/response payloads with automatic typing
Form Processing — Ensure user input meets requirements before processing
Configuration Management — Validate app settings and environment variables
Data Pipelines — Type-safe data transformation and validation
Database Models — Validate data before database operations
Integration Testing — Ensure external APIs return expected data structures

🛠️ Error Handling

const result = UserSchema.safeParse(invalidData);

if (!result.success) {
  // Access detailed error information
  result.error.issues.forEach(issue => {
    console.log({
      path: issue.path.join('.'),        // Field path: "user.email"
      code: issue.code,                  // Error code: "invalid_email" 
      message: issue.message,            // Human readable message
      received: issue.received,          // Actual value received
      expected: issue.expected,          // Expected type/format
    });
  });
}

🔗 VSCode Extension

Enhance your development experience with our VSCode extension:

Search for "Fortify Schema" in the Extensions marketplace
Install the extension for syntax highlighting and IntelliSense
Enjoy autocomplete and validation in your schema definitions

See the GitHub. Report any bugs to team@nehonix.space

XyPriss or ExpressJs ?🤔

ProCoder 😌 — Wed, 27 Aug 2025 09:36:20 +0000

For Node.js developers, the choice is becoming inevitable:
Stick with the reliability of Express.js, or explore the fresh possibilities of XyPriss?

⚡ Express.js — lightweight, proven, and trusted by millions.
⚡ XyPriss — TypeScript-first, with 12+ built-in security modules, clustering, caching, and performance optimizations right out of the box.

It’s no longer just a question of what’s familiar vs what’s built for the future.

👉 If you want a framework where security and performance come by default, XyPriss is one to watch.
With just two lines of code, you can spin up a secure, high-performance server — no need for extra middleware. It automatically protects against XSS attacks, SQL injections, and more.

I’ve tested it, and honestly, y’all will have a lot to learn from XyPriss. It’s packed with modules and plugins. At first glance, it may look like Express.js — but trust me, it’s not Express 😂.

So, what’s your take? Would you give XyPriss a shot over Express.js in your next project?

📖 Docs:
XyPriss: https://docs.xypriss.nehonix.space

Express.js: https://expressjs.com

🔗 Post: https://www.linkedin.com/posts/seth-eleazar-9602b4241_nodejs-webdevelopment-expressjs-activity-7366101984061431808-HuMV?utm_source=share&utm_medium=member_android&rcm=ACoAADwFw1gBIon4Y6b8AqE1mSYQgMo_SQLlQmQ

typescript

#javascript #javascriptchallenge #nehonix #security

Fortify Schema: A Revolutionary TypeScript-First Schema Validation Library

ProCoder 😌 — Mon, 16 Jun 2025 15:01:09 +0000

Fortify Schema: A Revolutionary TypeScript-First Schema Validation Library

If you're a TypeScript developer tired of verbose, complex schema validation libraries that don't fully leverage TypeScript's power, you need to check out Fortify Schema — a revolutionary schema validation library that brings TypeScript interface syntax to runtime validation.

Why Fortify Schema?

Traditional libraries like Zod, Joi, or Yup often require cumbersome APIs and manual type definitions. Fortify Schema changes the game by allowing you to write schemas that look exactly like TypeScript interfaces — intuitive, clean, and type-safe.

Key Features

Interface-like syntax that TypeScript developers instantly understand
Perfect type inference with no manual typings needed
Compile-time safety that prevents invalid properties before runtime
Exact union and constant types instead of generic unions
Intuitive constraint syntax with function-like parameters
Zero learning curve if you know TypeScript

Example

import { Interface, Make } from 'fortify-schema';

const UserSchema = Interface({
  id: "number",
  email: "email",
  name: "string(2,50)",       // String length constraints
  age: "number(18,120)?",     // Optional number with range
  tags: "string[](1,10)?",    // Optional array with size constraints
  status: Make.union("active", "inactive"),
  role: Make.const("admin")
});

const result = UserSchema.safeParse(userData);
if (result.success) {
  // result.data is perfectly typed with exact union and literal types
  console.log('Valid user:', result.data);
} else {
  console.log('Validation errors:', result.errors);
}

Schema Transformation Made Easy

Fortify Schema also includes powerful utilities for schema transformation such as Mod.partial(), Mod.omit(), Mod.extend(), and more, allowing you to create variations of your schemas effortlessly.

Installation

npm install fortify-schema

Requirements: TypeScript 4.5+ and Node.js 14+

Fortify Schema is designed to make your TypeScript validation code cleaner, safer, and more maintainable. Give it a try and experience a zero learning curve schema validation library that feels just like writing TypeScript interfaces!

Check it out on GitHub: Nehonix-Team/fortify-schema

Hello I'm new member of dev.to 😢

ProCoder 😌 — Wed, 31 Jul 2024 18:10:10 +0000