☕ FUJSEN Functions in TuskLang for Java Applications
FUJSEN Functions in TuskLang for Java Applications
This guide covers comprehensive usage of FUJSEN (Function JavaScript) functions in TuskLang for Java applications, including JavaScript integration, execution, security, and advanced patterns.
Table of Contents
- Overview - Basic FUJSEN Functions - Advanced FUJSEN Patterns - Java Integration - Security Considerations - Performance Optimization - Error Handling - Testing FUJSEN Functions - Best Practices - Troubleshooting
Overview
FUJSEN (Function JavaScript) allows you to embed and execute JavaScript functions directly in TuskLang configuration files, providing dynamic computation and logic execution capabilities.
FUJSEN Benefits
// Benefits of FUJSEN functions
public enum FujsenBenefit {
DYNAMIC_COMPUTATION, // Real-time calculations and transformations
BUSINESS_LOGIC, // Complex business rules and validations
DATA_TRANSFORMATION, // Data processing and formatting
CONDITIONAL_LOGIC, // Dynamic decision making
INTEGRATION, // External service integration
CUSTOMIZATION // Application-specific logic
}Basic FUJSEN Functions
Create and execute basic JavaScript functions in TuskLang configuration.
Simple Function Definition
import com.tusklang.fujsen.FujsenEngine;
import com.tusklang.fujsen.FujsenFunction;public class BasicFujsenExample {
public void useBasicFujsen() {
// Basic FUJSEN function configuration
String config = """
[app]
name = MyApplication
# Simple calculation function
calculate_tax = """function(amount, rate) {
return amount * (rate / 100);
}"""
# Function with default parameters
format_currency = """function(value, currency = 'USD') {
return currency + ' ' + value.toFixed(2);
}"""
# Function with conditional logic
get_discount = """function(total, customer_type) {
if (customer_type === 'premium') {
return total * 0.15;
} else if (customer_type === 'regular') {
return total * 0.05;
}
return 0;
}"""
""";
// Configure FUJSEN engine
FujsenEngine engine = new FujsenEngine();
engine.setTimeout(5000); // 5 second timeout
engine.setMemoryLimit(50 1024 1024); // 50MB memory limit
// Parse configuration with FUJSEN functions
TuskLangConfig result = engine.parse(config);
// Execute functions
double tax = result.executeFunction("calculate_tax", 1000.0, 8.5);
String formattedCurrency = result.executeFunction("format_currency", 1234.56, "EUR");
double discount = result.executeFunction("get_discount", 500.0, "premium");
System.out.println("Tax: " + tax);
System.out.println("Formatted currency: " + formattedCurrency);
System.out.println("Discount: " + discount);
}
}
Function with Context
public class ContextFujsenExample {
public void useContextFujsen() {
// FUJSEN function with configuration context
String config = """
[app]
base_url = https://api.example.com
api_version = v1
# Function using configuration context
build_api_url = """function(endpoint) {
return this.base_url + '/' + this.api_version + '/' + endpoint;
}"""
# Function with multiple context values
create_user_data = """function(name, email, age) {
return {
name: name,
email: email,
age: age,
api_url: this.base_url,
created_at: new Date().toISOString()
};
}"""
""";
// Configure FUJSEN engine with context
FujsenEngine engine = new FujsenEngine();
engine.enableContextAccess(true);
engine.setContextProvider(new ConfigurationContextProvider());
// Parse and execute with context
TuskLangConfig result = engine.parse(config);
// Execute functions with context
String apiUrl = result.executeFunction("build_api_url", "users");
Map<String, Object> userData = result.executeFunction("create_user_data",
"John Doe", "john@example.com", 30);
System.out.println("API URL: " + apiUrl);
System.out.println("User data: " + userData);
}
}Advanced FUJSEN Patterns
Implement advanced patterns and complex logic in FUJSEN functions.
Async Functions
public class AsyncFujsenExample {
public void useAsyncFujsen() {
// Async FUJSEN functions
String config = """
[app]
# Async function for external API calls
fetch_user_data = """async function(userId) {
const response = await fetch(this.base_url + '/users/' + userId);
return await response.json();
}"""
# Async function with error handling
process_payment = """async function(amount, cardToken) {
try {
const response = await fetch(this.payment_url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + this.api_key
},
body: JSON.stringify({
amount: amount,
token: cardToken
})
});
if (!response.ok) {
throw new Error('Payment failed: ' + response.status);
}
return await response.json();
} catch (error) {
return { error: error.message };
}
}"""
""";
// Configure async FUJSEN engine
FujsenEngine engine = new FujsenEngine();
engine.enableAsyncExecution(true);
engine.setAsyncTimeout(30000); // 30 second timeout for async operations
// Parse and execute async functions
TuskLangConfig result = engine.parse(config);
// Execute async functions
CompletableFuture<Map<String, Object>> userDataFuture =
result.executeAsyncFunction("fetch_user_data", "12345");
CompletableFuture<Map<String, Object>> paymentFuture =
result.executeAsyncFunction("process_payment", 100.0, "tok_123");
// Handle results
userDataFuture.thenAccept(userData -> {
System.out.println("User data: " + userData);
});
paymentFuture.thenAccept(paymentResult -> {
System.out.println("Payment result: " + paymentResult);
});
}
}Complex Business Logic
public class ComplexBusinessLogicExample {
public void useComplexBusinessLogic() {
// Complex business logic in FUJSEN
String config = """
[app]
# Complex pricing calculation
calculate_price = """function(basePrice, quantity, customerType, region) {
let discount = 0;
let tax = 0;
// Quantity discounts
if (quantity >= 100) {
discount += 0.15;
} else if (quantity >= 50) {
discount += 0.10;
} else if (quantity >= 10) {
discount += 0.05;
}
// Customer type discounts
if (customerType === 'premium') {
discount += 0.10;
} else if (customerType === 'vip') {
discount += 0.20;
}
// Regional taxes
const taxRates = {
'US': 0.08,
'EU': 0.20,
'CA': 0.13,
'AU': 0.10
};
tax = taxRates[region] || 0;
// Calculate final price
const subtotal = basePrice * quantity;
const discountAmount = subtotal * discount;
const taxAmount = (subtotal - discountAmount) * tax;
const total = subtotal - discountAmount + taxAmount;
return {
subtotal: subtotal,
discount: discountAmount,
tax: taxAmount,
total: total,
breakdown: {
discount_rate: discount,
tax_rate: tax
}
};
}"""
# Data validation and transformation
validate_user_input = """function(userData) {
const errors = [];
const warnings = [];
// Required fields
if (!userData.name || userData.name.trim().length < 2) {
errors.push('Name must be at least 2 characters long');
}
if (!userData.email || !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(userData.email)) {
errors.push('Valid email address is required');
}
if (!userData.age || userData.age < 13 || userData.age > 120) {
errors.push('Age must be between 13 and 120');
}
// Warnings
if (userData.age < 18) {
warnings.push('User is under 18');
}
if (userData.email && userData.email.includes('temp')) {
warnings.push('Temporary email detected');
}
return {
valid: errors.length === 0,
errors: errors,
warnings: warnings,
sanitized: {
name: userData.name ? userData.name.trim() : '',
email: userData.email ? userData.email.toLowerCase() : '',
age: parseInt(userData.age) || 0
}
};
}"""
""";
// Configure FUJSEN engine for complex logic
FujsenEngine engine = new FujsenEngine();
engine.enableComplexOperations(true);
engine.setMaxExecutionTime(10000); // 10 second timeout
// Parse and execute complex functions
TuskLangConfig result = engine.parse(config);
// Execute pricing calculation
Map<String, Object> priceResult = result.executeFunction("calculate_price",
100.0, 50, "premium", "US");
// Execute validation
Map<String, Object> validationResult = result.executeFunction("validate_user_input",
Map.of("name", "John",
"email", "john@example.com",
"age", 25));
System.out.println("Price calculation: " + priceResult);
System.out.println("Validation result: " + validationResult);
}
}Java Integration
Integrate FUJSEN functions with Java code and frameworks.
Spring Boot Integration
@Service
public class FujsenSpringService {
@Autowired
private FujsenEngine fujsenEngine;
@Autowired
private TuskLangConfig config;
public Object executeFujsenFunction(String functionName, Object... args) {
return config.executeFunction(functionName, args);
}
public CompletableFuture<Object> executeAsyncFujsenFunction(String functionName, Object... args) {
return config.executeAsyncFunction(functionName, args);
}
@EventListener
public void handleConfigurationChange(ConfigurationChangeEvent event) {
// Reload FUJSEN functions when configuration changes
fujsenEngine.reloadFunctions();
}
}@RestController
@RequestMapping("/api/fujsen")
public class FujsenController {
@Autowired
private FujsenSpringService fujsenService;
@PostMapping("/execute")
public ResponseEntity<Object> executeFunction(@RequestBody FujsenRequest request) {
try {
Object result = fujsenService.executeFujsenFunction(
request.getFunctionName(),
request.getArguments().toArray()
);
return ResponseEntity.ok(result);
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("error", e.getMessage()));
}
}
@PostMapping("/execute-async")
public CompletableFuture<ResponseEntity<Object>> executeAsyncFunction(
@RequestBody FujsenRequest request) {
return fujsenService.executeAsyncFujsenFunction(
request.getFunctionName(),
request.getArguments().toArray()
).thenApply(result -> ResponseEntity.ok(result))
.exceptionally(throwable -> ResponseEntity.badRequest()
.body(Map.of("error", throwable.getMessage())));
}
}
Database Integration
public class FujsenDatabaseIntegration {
public void integrateWithDatabase() {
// FUJSEN functions with database integration
String config = """
[app]
# Database query function
get_user_stats = """function(userId) {
const query = 'SELECT COUNT(*) as orders, SUM(amount) as total FROM orders WHERE user_id = ?';
const result = this.executeQuery(query, [userId]);
return result[0];
}"""
# Data processing function
process_user_data = """function(userData) {
// Validate and process user data
const processed = this.validate_user_input(userData);
if (processed.valid) {
// Insert into database
const insertQuery = 'INSERT INTO users (name, email, age) VALUES (?, ?, ?)';
const result = this.executeQuery(insertQuery, [
processed.sanitized.name,
processed.sanitized.email,
processed.sanitized.age
]);
return { success: true, userId: result.insertId };
} else {
return { success: false, errors: processed.errors };
}
}"""
""";
// Configure FUJSEN engine with database access
FujsenEngine engine = new FujsenEngine();
engine.enableDatabaseAccess(true);
engine.setDatabaseProvider(new JdbcDatabaseProvider(dataSource));
// Parse and execute database functions
TuskLangConfig result = engine.parse(config);
// Execute database functions
Map<String, Object> userStats = result.executeFunction("get_user_stats", "12345");
Map<String, Object> processResult = result.executeFunction("process_user_data",
Map.of("name", "Jane Doe",
"email", "jane@example.com",
"age", 28));
System.out.println("User stats: " + userStats);
System.out.println("Process result: " + processResult);
}
}Security Considerations
Implement security measures for FUJSEN function execution.
Security Configuration
public class FujsenSecurityExample {
public void configureSecurity() {
// Secure FUJSEN configuration
FujsenSecurityConfig securityConfig = new FujsenSecurityConfig();
// Enable security features
securityConfig.enableSandboxing(true);
securityConfig.enableCodeSigning(true);
securityConfig.enableExecutionLogging(true);
// Set security policies
securityConfig.setAllowedApis(Arrays.asList("Math", "Date", "JSON"));
securityConfig.setRestrictedApis(Arrays.asList("eval", "Function", "setTimeout"));
securityConfig.setMaxExecutionTime(5000); // 5 seconds
securityConfig.setMaxMemoryUsage(10 1024 1024); // 10MB
// Configure FUJSEN engine with security
FujsenEngine engine = new FujsenEngine();
engine.setSecurityConfig(securityConfig);
// Secure function execution
String secureConfig = """
[app]
# Secure function with validation
secure_calculation = """function(input) {
// Input validation
if (typeof input !== 'number' || input < 0 || input > 1000000) {
throw new Error('Invalid input: must be a number between 0 and 1000000');
}
// Safe calculation
return Math.sqrt(input) * 2;
}"""
# Function with sanitization
sanitize_input = """function(userInput) {
// Remove potentially dangerous characters
return userInput.replace(/[<>\"'&]/g, '');
}"""
""";
// Parse and execute with security
TuskLangConfig result = engine.parse(secureConfig);
try {
double calculation = result.executeFunction("secure_calculation", 100.0);
String sanitized = result.executeFunction("sanitize_input", "<script>alert('xss')</script>");
System.out.println("Secure calculation: " + calculation);
System.out.println("Sanitized input: " + sanitized);
} catch (SecurityException e) {
System.err.println("Security violation: " + e.getMessage());
}
}
}Code Signing
public class FujsenCodeSigningExample {
public void implementCodeSigning() {
// Code signing for FUJSEN functions
FujsenCodeSigner codeSigner = new FujsenCodeSigner();
// Generate signing key
KeyPair keyPair = codeSigner.generateKeyPair();
// Sign function code
String functionCode = """
function calculateTax(amount, rate) {
return amount * (rate / 100);
}
""";
String signature = codeSigner.signFunction(functionCode, keyPair.getPrivate());
// Verify function signature
boolean isValid = codeSigner.verifyFunction(functionCode, signature, keyPair.getPublic());
if (isValid) {
System.out.println("Function signature is valid");
// Execute signed function
FujsenEngine engine = new FujsenEngine();
engine.enableCodeSigning(true);
engine.setPublicKey(keyPair.getPublic());
String config = """
[app]
signed_function = """ + functionCode + """
signature = """ + signature + """
""";
TuskLangConfig result = engine.parse(config);
double tax = result.executeFunction("calculateTax", 1000.0, 8.5);
System.out.println("Tax: " + tax);
} else {
System.err.println("Function signature is invalid");
}
}
}Performance Optimization
Optimize FUJSEN function execution for better performance.
Caching and Optimization
public class FujsenPerformanceExample {
public void optimizePerformance() {
// Performance optimization for FUJSEN functions
FujsenPerformanceOptimizer optimizer = new FujsenPerformanceOptimizer();
// Enable function caching
optimizer.enableFunctionCaching(true);
optimizer.setCacheSize(1000);
optimizer.setCacheTtl(300); // 5 minutes
// Enable JIT compilation
optimizer.enableJitCompilation(true);
optimizer.setJitThreshold(10); // Compile after 10 executions
// Enable parallel execution
optimizer.enableParallelExecution(true);
optimizer.setMaxConcurrency(4);
// Configure optimized engine
FujsenEngine engine = new FujsenEngine();
engine.setPerformanceOptimizer(optimizer);
// Optimized function configuration
String config = """
[app]
# Optimized calculation function
optimized_calculation = """function(values) {
// Use optimized array operations
return values.reduce((sum, val) => sum + val, 0) / values.length;
}"""
# Cached expensive operation
expensive_operation = """function(input) {
// This function will be cached after first execution
return this.heavyComputation(input);
}"""
""";
// Parse and execute optimized functions
TuskLangConfig result = engine.parse(config);
// Execute optimized functions
List<Double> values = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
double average = result.executeFunction("optimized_calculation", values);
// Multiple executions to trigger optimization
for (int i = 0; i < 15; i++) {
result.executeFunction("expensive_operation", "test_input_" + i);
}
System.out.println("Average: " + average);
// Get performance statistics
FujsenPerformanceStats stats = optimizer.getPerformanceStats();
System.out.println("Cache hits: " + stats.getCacheHits());
System.out.println("JIT compilations: " + stats.getJitCompilations());
System.out.println("Average execution time: " + stats.getAverageExecutionTime() + "ms");
}
}Error Handling
Implement comprehensive error handling for FUJSEN functions.
Error Handling Patterns
public class FujsenErrorHandlingExample {
public void handleErrors() {
// Error handling for FUJSEN functions
FujsenErrorHandler errorHandler = new FujsenErrorHandler();
// Configure error handling
errorHandler.enableDetailedErrors(true);
errorHandler.enableErrorRecovery(true);
errorHandler.setMaxRetries(3);
// Configure FUJSEN engine with error handling
FujsenEngine engine = new FujsenEngine();
engine.setErrorHandler(errorHandler);
// Function with error handling
String config = """
[app]
# Function with try-catch
safe_division = """function(a, b) {
try {
if (b === 0) {
throw new Error('Division by zero');
}
return a / b;
} catch (error) {
return { error: error.message, result: null };
}
}"""
# Function with validation
validate_and_process = """function(data) {
const errors = [];
if (!data || typeof data !== 'object') {
errors.push('Data must be an object');
return { success: false, errors: errors };
}
if (!data.name || data.name.length < 2) {
errors.push('Name must be at least 2 characters');
}
if (errors.length > 0) {
return { success: false, errors: errors };
}
// Process valid data
return { success: true, processed: data.name.toUpperCase() };
}"""
""";
// Parse and execute with error handling
TuskLangConfig result = engine.parse(config);
// Execute functions with error handling
Object divisionResult = result.executeFunction("safe_division", 10, 0);
Object validationResult = result.executeFunction("validate_and_process",
Map.of("name", "John"));
System.out.println("Division result: " + divisionResult);
System.out.println("Validation result: " + validationResult);
// Handle execution errors
try {
result.executeFunction("non_existent_function");
} catch (FujsenExecutionException e) {
System.err.println("Execution error: " + e.getMessage());
System.err.println("Function: " + e.getFunctionName());
System.err.println("Line: " + e.getLineNumber());
}
}
}Testing FUJSEN Functions
Comprehensive testing strategies for FUJSEN functions.
Unit Testing
@Test
public class FujsenFunctionTest {
private FujsenEngine engine;
private TuskLangConfig config;
@BeforeEach
void setUp() {
engine = new FujsenEngine();
engine.enableTesting(true);
String testConfig = """
[app]
# Test function
add_numbers = """function(a, b) {
return a + b;
}"""
# Complex test function
process_user = """function(user) {
return {
name: user.name.toUpperCase(),
age: user.age,
category: user.age >= 18 ? 'adult' : 'minor'
};
}"""
""";
config = engine.parse(testConfig);
}
@Test
void testSimpleFunction() {
// Test simple function
int result = config.executeFunction("add_numbers", 5, 3);
assertEquals(8, result);
}
@Test
void testComplexFunction() {
// Test complex function
Map<String, Object> user = Map.of("name", "john", "age", 25);
Map<String, Object> result = config.executeFunction("process_user", user);
assertEquals("JOHN", result.get("name"));
assertEquals(25, result.get("age"));
assertEquals("adult", result.get("category"));
}
@Test
void testFunctionWithInvalidInput() {
// Test function with invalid input
assertThrows(FujsenExecutionException.class, () -> {
config.executeFunction("add_numbers", "invalid", "input");
});
}
@Test
void testAsyncFunction() {
// Test async function
CompletableFuture<Object> future = config.executeAsyncFunction("add_numbers", 10, 20);
future.thenAccept(result -> {
assertEquals(30, result);
});
}
}Integration Testing
@SpringBootTest
public class FujsenIntegrationTest {
@Autowired
private FujsenSpringService fujsenService;
@Test
void testFujsenWithDatabase() {
// Test FUJSEN function with database integration
Object result = fujsenService.executeFujsenFunction("get_user_stats", "12345");
assertNotNull(result);
assertTrue(result instanceof Map);
Map<String, Object> stats = (Map<String, Object>) result;
assertTrue(stats.containsKey("orders"));
assertTrue(stats.containsKey("total"));
}
@Test
void testFujsenWithExternalApi() {
// Test FUJSEN function with external API
CompletableFuture<Object> future = fujsenService.executeAsyncFujsenFunction(
"fetch_user_data", "12345");
future.thenAccept(result -> {
assertNotNull(result);
assertTrue(result instanceof Map);
});
}
}Best Practices
Follow these best practices for effective FUJSEN function usage.
Code Organization
public class FujsenBestPracticesExample {
public void organizeFujsenCode() {
// Best practices for FUJSEN function organization
String config = """
[app]
# Use descriptive function names
calculate_monthly_revenue = """function(sales, expenses, tax_rate) {
const gross_profit = sales - expenses;
const tax_amount = gross_profit * (tax_rate / 100);
return gross_profit - tax_amount;
}"""
# Separate concerns
validate_email = """function(email) {
const email_regex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;
return email_regex.test(email);
}"""
format_currency = """function(amount, currency = 'USD') {
return currency + ' ' + amount.toFixed(2);
}"""
# Use helper functions
process_order = """function(order) {
// Validate order
if (!this.validate_order(order)) {
return { success: false, error: 'Invalid order' };
}
// Calculate total
const total = this.calculate_order_total(order);
// Format result
return {
success: true,
total: total,
formatted_total: this.format_currency(total)
};
}"""
""";
// Configure FUJSEN engine with best practices
FujsenEngine engine = new FujsenEngine();
engine.enableCodeAnalysis(true);
engine.setCodeStyleChecker(new FujsenCodeStyleChecker());
// Parse and validate
TuskLangConfig result = engine.parse(config);
// Execute functions following best practices
double revenue = result.executeFunction("calculate_monthly_revenue", 10000, 3000, 8.5);
boolean validEmail = result.executeFunction("validate_email", "user@example.com");
String formattedAmount = result.executeFunction("format_currency", 1234.56, "EUR");
System.out.println("Monthly revenue: " + revenue);
System.out.println("Valid email: " + validEmail);
System.out.println("Formatted amount: " + formattedAmount);
}
}Troubleshooting
Common issues and solutions for FUJSEN functions.
Common Issues
public class FujsenTroubleshootingExample {
public void troubleshootFujsen() {
// Troubleshooting FUJSEN functions
FujsenTroubleshooter troubleshooter = new FujsenTroubleshooter();
// Check function syntax
List<SyntaxError> syntaxErrors = troubleshooter.checkSyntax(config);
for (SyntaxError error : syntaxErrors) {
System.err.println("Syntax error: " + error.getMessage());
System.err.println("Line: " + error.getLine());
System.err.println("Column: " + error.getColumn());
}
// Check function dependencies
List<DependencyError> dependencyErrors = troubleshooter.checkDependencies(config);
for (DependencyError error : dependencyErrors) {
System.err.println("Dependency error: " + error.getMessage());
System.err.println("Function: " + error.getFunctionName());
System.err.println("Missing: " + error.getMissingDependency());
}
// Check performance issues
List<PerformanceIssue> performanceIssues = troubleshooter.checkPerformance(config);
for (PerformanceIssue issue : performanceIssues) {
System.err.println("Performance issue: " + issue.getMessage());
System.err.println("Function: " + issue.getFunctionName());
System.err.println("Suggestion: " + issue.getSuggestion());
}
// Fix common issues
troubleshooter.fixCommonIssues(config);
}
}This comprehensive FUJSEN functions guide provides everything needed to effectively use JavaScript functions in TuskLang Java applications, enabling dynamic computation and complex business logic execution.