Nehonix fortifyjs: توابع جاوا اسکریپت را به نیروگاههای امنیتی درجه سازمانی با پیکربندی صفر تبدیل کنید

// 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;
}

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

// 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
    // ...
}

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

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...]']

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

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

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);
});

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

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

// 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)
});  

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

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

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

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

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

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

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);
})()

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());

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"));

npm install fortify2-js