reliant-type 1.0.0

package/src/bench/BENCHMARK-RESULTS.md

@@ -0,0 +1,211 @@
+# ReliantType Performance Report
+
+## 📊 Executive Summary
+
+**Generated:** 7/18/2025, 8:19:17 AM
+**Node.js Version:** v24.3.0
+**Platform:** linux (x64)
+**ReliantType Version:** 2.0.21
+
+### 🏆 Performance Highlights
+
+| Metric | Value |
+|--------|-------|
+| **Total Test Suites** | 6 |
+| **Fastest Operation** | Basic Types (496,131.184 ops/sec) |
+| **Most Consistent** | Union Types (5.8% CV) |
+| **Memory Efficiency** | 1.42 KB per schema |
+
+### 💾 Memory Usage
+
+- **Total Memory Used:** 2.78 MB
+- **Schemas Created:** 2,000
+- **Memory Per Schema:** 1.42 KB
+
+## 📋 Detailed Performance Results
+
+
+### 1. Basic Types
+
+**Performance Metrics:**
+- **Operations/Second:** 496,131.184 ops/sec
+- **Average Time/Op:** 2.02 μs
+- **Median Time:** 100.78 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 100.0%
+- **Coefficient of Variation:** 32.3%
+- **Time Range:** 88.70 - 188.94 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 50,000 |
+| **Median Time** | 100.78 ms |
+| **Mean Time** | 124.86 ms |
+| **Std Deviation** | 40.36 ms |
+| **Min Time** | 88.70 ms |
+| **Max Time** | 188.94 ms |
+
+
+### 2. Complex Nested
+
+**Performance Metrics:**
+- **Operations/Second:** 12,443.531 ops/sec
+- **Average Time/Op:** 80.36 μs
+- **Median Time:** 401.82 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 100.0%
+- **Coefficient of Variation:** 10.8%
+- **Time Range:** 345.57 - 484.38 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 5,000 |
+| **Median Time** | 401.82 ms |
+| **Mean Time** | 407.29 ms |
+| **Std Deviation** | 44.08 ms |
+| **Min Time** | 345.57 ms |
+| **Max Time** | 484.38 ms |
+
+
+### 3. Array Validation
+
+**Performance Metrics:**
+- **Operations/Second:** 147,805.966 ops/sec
+- **Average Time/Op:** 6.77 μs
+- **Median Time:** 54.13 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 0.0%
+- **Coefficient of Variation:** 34.5%
+- **Time Range:** 38.10 - 98.61 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 8,000 |
+| **Median Time** | 54.13 ms |
+| **Mean Time** | 57.39 ms |
+| **Std Deviation** | 19.80 ms |
+| **Min Time** | 38.10 ms |
+| **Max Time** | 98.61 ms |
+
+
+### 4. Union Types
+
+**Performance Metrics:**
+- **Operations/Second:** 130,063.973 ops/sec
+- **Average Time/Op:** 7.69 μs
+- **Median Time:** 153.77 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 100.0%
+- **Coefficient of Variation:** 5.8%
+- **Time Range:** 145.57 - 177.70 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 20,000 |
+| **Median Time** | 153.77 ms |
+| **Mean Time** | 156.50 ms |
+| **Std Deviation** | 9.14 ms |
+| **Min Time** | 145.57 ms |
+| **Max Time** | 177.70 ms |
+
+
+### 5. Conditional Logic
+
+**Performance Metrics:**
+- **Operations/Second:** 13,833.264 ops/sec
+- **Average Time/Op:** 72.29 μs
+- **Median Time:** 1084.34 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 0.0%
+- **Coefficient of Variation:** 13.1%
+- **Time Range:** 924.03 - 1443.54 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 15,000 |
+| **Median Time** | 1084.34 ms |
+| **Mean Time** | 1078.61 ms |
+| **Std Deviation** | 140.92 ms |
+| **Min Time** | 924.03 ms |
+| **Max Time** | 1443.54 ms |
+
+
+### 6. Format Validation
+
+**Performance Metrics:**
+- **Operations/Second:** 90,788.957 ops/sec
+- **Average Time/Op:** 11.01 μs
+- **Median Time:** 132.17 ms
+
+**Reliability Metrics:**
+- **Success Rate:** 100.0%
+- **Coefficient of Variation:** 22.8%
+- **Time Range:** 109.13 - 216.44 ms
+
+| Metric | Value |
+|--------|-------|
+| **Iterations** | 12,000 |
+| **Median Time** | 132.17 ms |
+| **Mean Time** | 132.19 ms |
+| **Std Deviation** | 30.17 ms |
+| **Min Time** | 109.13 ms |
+| **Max Time** | 216.44 ms |
+
+
+## 🎯 Performance Analysis
+
+### Key Findings
+
+1. **Conditional Validation Performance**: The unique conditional validation feature maintains competitive performance while adding significant functionality.
+
+2. **Format Validation**: Regular expression-based validations show consistent performance across different pattern complexities.
+
+3. **Scaling Characteristics**: Performance scales predictably with data size and schema complexity.
+
+4. **Memory Efficiency**: Linear memory scaling with reasonable per-schema overhead.
+
+### Performance Characteristics by Test Type
+
+- **Basic Types**: 496,131.184 ops/sec (32.3% variation)
+- **Complex Nested**: 12,443.531 ops/sec (10.8% variation)
+- **Array Validation**: 147,805.966 ops/sec (34.5% variation)
+- **Union Types**: 130,063.973 ops/sec (5.8% variation)
+- **Conditional Logic**: 13,833.264 ops/sec (13.1% variation)
+- **Format Validation**: 90,788.957 ops/sec (22.8% variation)
+
+## 🔧 Technical Details
+
+### Test Environment
+- **Node.js:** v24.3.0
+- **Platform:** linux
+- **Architecture:** x64
+- **Test Type:** standalone-performance
+
+### Methodology
+- **Warm-up:** 1000 iterations per test to ensure JIT optimization
+- **Statistical Analysis:** 10 runs per test with median reporting
+- **Memory Testing:** Multiple schema creation patterns
+- **Scaling Analysis:** Variable data sizes from 10 to 5000 items
+
+### Unique Features Tested
+- **Conditional Validation:** Runtime property checking with `when` syntax
+- **Format Validation:** Email, URL, phone, UUID, and regex patterns
+- **Complex Nesting:** Deep object validation with multiple levels
+- **Array Validation:** Dynamic array sizing and type constraints
+
+## 📝 Notes
+
+- Results reflect core validation performance under controlled conditions
+- Memory usage includes schema compilation and runtime overhead
+- Conditional validation adds minimal performance overhead for significant functionality gains
+- Performance may vary based on data complexity and validation requirements
+
+---
+
+*Generated automatically by the ReliantType benchmark suite*
+*Last updated: 7/18/2025, 8:19:17 AM*

package/src/bench/benchmark-results.json

@@ -0,0 +1,148 @@
+{
+  "metadata": {
+    "timestamp": "2025-07-18T08:19:17.534Z",
+    "nodeVersion": "v24.3.0",
+    "platform": "linux",
+    "arch": "x64",
+    "fortifyVersion": "2.0.21",
+    "testType": "standalone-performance"
+  },
+  "summary": {
+    "totalTests": 6,
+    "fastestTest": {
+      "name": "Basic Types",
+      "iterations": 50000,
+      "median": 100.77979699999992,
+      "mean": 124.8620427,
+      "std": 40.36453915326238,
+      "min": 88.70023300000003,
+      "max": 188.9411030000001,
+      "avgTimePerOp": 0.002015595939999998,
+      "operationsPerSecond": 496131.18391179177,
+      "successRate": 100,
+      "coefficientOfVariation": 32.327309629431824
+    },
+    "mostConsistent": {
+      "name": "Union Types",
+      "iterations": 20000,
+      "median": 153.77048300000024,
+      "mean": 156.50413840000002,
+      "std": 9.143031275966724,
+      "min": 145.56904900000063,
+      "max": 177.70391199999995,
+      "avgTimePerOp": 0.007688524150000012,
+      "operationsPerSecond": 130063.97333095435,
+      "successRate": 100,
+      "coefficientOfVariation": 5.842038024961724
+    },
+    "memoryUsage": {
+      "totalMB": 2.7825021743774414,
+      "schemasCreated": 2000,
+      "memoryPerSchemaKB": 1.42464111328125
+    }
+  },
+  "detailedResults": [
+    {
+      "testName": "Basic Types",
+      "iterations": 50000,
+      "performance": {
+        "operationsPerSecond": 496131.18391179177,
+        "avgTimePerOpMs": 0.002015595939999998,
+        "medianTimeMs": 100.77979699999992,
+        "meanTimeMs": 124.8620427
+      },
+      "reliability": {
+        "standardDeviationMs": 40.36453915326238,
+        "coefficientOfVariation": 32.327309629431824,
+        "minTimeMs": 88.70023300000003,
+        "maxTimeMs": 188.9411030000001,
+        "successRate": 100
+      }
+    },
+    {
+      "testName": "Complex Nested",
+      "iterations": 5000,
+      "performance": {
+        "operationsPerSecond": 12443.531317100646,
+        "avgTimePerOpMs": 0.08036303960000005,
+        "medianTimeMs": 401.81519800000024,
+        "meanTimeMs": 407.28758210000007
+      },
+      "reliability": {
+        "standardDeviationMs": 44.081113162774365,
+        "coefficientOfVariation": 10.823092846457387,
+        "minTimeMs": 345.57275200000004,
+        "maxTimeMs": 484.38353800000027,
+        "successRate": 100
+      }
+    },
+    {
+      "testName": "Array Validation",
+      "iterations": 8000,
+      "performance": {
+        "operationsPerSecond": 147805.96638737075,
+        "avgTimePerOpMs": 0.006765626750000024,
+        "medianTimeMs": 54.12501400000019,
+        "meanTimeMs": 57.39228440000024
+      },
+      "reliability": {
+        "standardDeviationMs": 19.797747163451515,
+        "coefficientOfVariation": 34.49548553507557,
+        "minTimeMs": 38.095392000000174,
+        "maxTimeMs": 98.61152699999911,
+        "successRate": 0
+      }
+    },
+    {
+      "testName": "Union Types",
+      "iterations": 20000,
+      "performance": {
+        "operationsPerSecond": 130063.97333095435,
+        "avgTimePerOpMs": 0.007688524150000012,
+        "medianTimeMs": 153.77048300000024,
+        "meanTimeMs": 156.50413840000002
+      },
+      "reliability": {
+        "standardDeviationMs": 9.143031275966724,
+        "coefficientOfVariation": 5.842038024961724,
+        "minTimeMs": 145.56904900000063,
+        "maxTimeMs": 177.70391199999995,
+        "successRate": 100
+      }
+    },
+    {
+      "testName": "Conditional Logic",
+      "iterations": 15000,
+      "performance": {
+        "operationsPerSecond": 13833.264244632099,
+        "avgTimePerOpMs": 0.07228951766666662,
+        "medianTimeMs": 1084.3427649999994,
+        "meanTimeMs": 1078.6061701999997
+      },
+      "reliability": {
+        "standardDeviationMs": 140.92447308897908,
+        "coefficientOfVariation": 13.065424339529624,
+        "minTimeMs": 924.0281079999986,
+        "maxTimeMs": 1443.5429700000004,
+        "successRate": 0
+      }
+    },
+    {
+      "testName": "Format Validation",
+      "iterations": 12000,
+      "performance": {
+        "operationsPerSecond": 90788.95717269111,
+        "avgTimePerOpMs": 0.011014555416666856,
+        "medianTimeMs": 132.17466500000228,
+        "meanTimeMs": 132.18898519999965
+      },
+      "reliability": {
+        "standardDeviationMs": 30.17182710625554,
+        "coefficientOfVariation": 22.824766421049446,
+        "minTimeMs": 109.12656799999968,
+        "maxTimeMs": 216.44466499999908,
+        "successRate": 100
+      }
+    }
+  ]
+}

package/src/bench/performance-comparison.ts

@@ -0,0 +1,218 @@
+/**
+ * Performance comparison between optimized and original implementations
+ */
+
+import { Interface } from "../core/schema/mode/interfaces/Interface";
+import { ConstraintParser } from "../core/schema/mode/interfaces/validators/ConstraintParser";
+
+console.log("=== PERFORMANCE COMPARISON ===\n");
+
+// Test schema
+const testSchema = Interface({
+  id: "positive",
+  email: "email",
+  name: "string(2,50)",
+  age: "int(18,120)?",
+  tags: "string[](1,10)?",
+  status: "active|inactive|pending",
+  metadata: {
+    created: "date",
+    updated: "date?",
+    version: "string",
+  },
+});
+
+// Test data
+const testData: any = {
+  id: 1,
+  email: "test@example.com",
+  name: "John Doe",
+  age: 25,
+  tags: ["developer", "typescript", "nodejs"],
+  status: "active",
+  metadata: {
+    created: new Date(),
+    updated: new Date(),
+    version: "1.0.0",
+  },
+};
+
+console.log("1. Constraint Parser Cache Performance:");
+
+// Test constraint parsing performance
+const constraintTypes = [
+  "string(2,50)",
+  "int(18,120)?",
+  "string[](1,10)?",
+  "email",
+  "positive",
+  "active|inactive|pending",
+];
+
+// First run (cache miss)
+const startParse1 = performance.now();
+for (let i = 0; i < 10000; i++) {
+  for (const type of constraintTypes) {
+    ConstraintParser.parseConstraints(type);
+  }
+}
+const endParse1 = performance.now();
+
+// Clear cache and run again
+ConstraintParser.clearCache();
+
+// Second run (cache miss again)
+const startParse2 = performance.now();
+for (let i = 0; i < 10000; i++) {
+  for (const type of constraintTypes) {
+    ConstraintParser.parseConstraints(type);
+  }
+}
+const endParse2 = performance.now();
+
+// Third run (cache hit)
+const startParse3 = performance.now();
+for (let i = 0; i < 10000; i++) {
+  for (const type of constraintTypes) {
+    ConstraintParser.parseConstraints(type);
+  }
+}
+const endParse3 = performance.now();
+
+console.log(`First run (no cache): ${(endParse1 - startParse1).toFixed(2)}ms`);
+console.log(`Second run (no cache): ${(endParse2 - startParse2).toFixed(2)}ms`);
+console.log(
+  `Third run (with cache): ${(endParse3 - startParse3).toFixed(2)}ms`
+);
+console.log(
+  `Cache speedup: ${((endParse2 - startParse2) / (endParse3 - startParse3)).toFixed(2)}x`
+);
+
+console.log("\n2. Schema Validation Performance:");
+
+// Warm up
+for (let i = 0; i < 1000; i++) {
+  testSchema.safeParse(testData);
+}
+
+// Test different data sizes
+const testSizes = [1000, 5000, 10000];
+
+for (const size of testSizes) {
+  const startTime = performance.now();
+
+  for (let i = 0; i < size; i++) {
+    testSchema.safeParse(testData);
+  }
+
+  const endTime = performance.now();
+  const totalTime = endTime - startTime;
+  const avgTime = totalTime / size;
+  const opsPerSec = size / (totalTime / 1000);
+
+  console.log(
+    `${size} validations: ${totalTime.toFixed(2)}ms (${avgTime.toFixed(4)}ms avg, ${opsPerSec.toFixed(0)} ops/sec)`
+  );
+}
+
+console.log("\n3. Memory Usage Test:");
+
+// Test memory usage with many validations
+const memBefore = process.memoryUsage();
+
+for (let i = 0; i < 50000; i++) {
+  testSchema.safeParse(testData);
+}
+
+const memAfter = process.memoryUsage();
+const memDiff = memAfter.heapUsed - memBefore.heapUsed;
+
+console.log(
+  `Memory used for 50,000 validations: ${(memDiff / 1024 / 1024).toFixed(2)} MB`
+);
+console.log(`Memory per validation: ${(memDiff / 50000).toFixed(0)} bytes`);
+
+console.log("\n4. Cache Statistics:");
+
+const cacheStats = ConstraintParser.getCacheStats();
+console.log(`Constraint parser cache size: ${cacheStats.size} entries`);
+
+console.log("\n5. Complex Schema Performance:");
+
+// Test with a more complex schema
+const complexSchema = Interface({
+  user: {
+    id: "positive",
+    profile: {
+      name: "string(2,100)",
+      email: "email",
+      phone: "phone?",
+      address: {
+        street: "string",
+        city: "string",
+        country: "string",
+        zipCode: "string",
+      },
+    },
+    preferences: {
+      theme: "light|dark",
+      notifications: "boolean",
+      language: "string(2,5)",
+    },
+  },
+  permissions: "when user.profile.email~@admin *? string[] : string[]?",
+  metadata: {
+    created: "date",
+    updated: "date?",
+    tags: "string[](0,20)?",
+  },
+});
+
+const complexData: any = {
+  user: {
+    id: 1,
+    profile: {
+      name: "John Doe",
+      email: "john@example.com",
+      phone: "+1234567890",
+      address: {
+        street: "123 Main St",
+        city: "New York",
+        country: "USA",
+        zipCode: "10001",
+      },
+    },
+    preferences: {
+      theme: "dark",
+      notifications: true,
+      language: "en",
+    },
+  },
+  metadata: {
+    created: new Date(),
+    updated: new Date(),
+    tags: ["user", "premium", "verified"],
+  },
+};
+
+const complexIterations = 5000;
+const complexStart = performance.now();
+
+for (let i = 0; i < complexIterations; i++) {
+  complexSchema.safeParse(complexData);
+}
+
+const complexEnd = performance.now();
+const complexTime = complexEnd - complexStart;
+const complexAvg = complexTime / complexIterations;
+const complexOps = complexIterations / (complexTime / 1000);
+
+console.log(
+  `Complex schema (${complexIterations} validations): ${complexTime.toFixed(2)}ms`
+);
+console.log(
+  `Complex schema average: ${complexAvg.toFixed(4)}ms per validation`
+);
+console.log(`Complex schema ops/sec: ${complexOps.toFixed(0)}`);
+
+console.log("\nPerformance comparison completed! 📊");