@africode/core 5.0.8 → 5.0.9

package/core/patterns.js

@@ -575,6 +575,60 @@ export function generateZulu({
   return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
 }
 
+/**
+ * Generate Swazi/Eswatini pattern
+ */
+export function generateSwazi({
+  primaryColor = '#003082', // Blue
+  secondaryColor = '#FCD116', // Yellow
+  accentColor = '#C8102E',   // Red
+  backgroundColor = '#FFFFFF',
+  size = 50
+} = {}) {
+  const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+      <rect width="${size}" height="${size}" fill="${backgroundColor}"/>
+      <!-- Swazi shield-like pattern -->
+      <path d="M${size * 0.5},0 C${size * 0.8},${size * 0.1} ${size},${size * 0.3} ${size},${size * 0.5} C${size},${size * 0.7} ${size * 0.8},${size * 0.9} ${size * 0.5},${size} C${size * 0.2},${size * 0.9} 0,${size * 0.7} 0,${size * 0.5} C0,${size * 0.3} ${size * 0.2},${size * 0.1} ${size * 0.5},0 Z" fill="${primaryColor}" opacity="0.8"/>
+      <!-- Diagonal stripes -->
+      <line x1="0" y1="${size * 0.2}" x2="${size * 0.2}" y2="0" stroke="${secondaryColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="0" y1="${size * 0.4}" x2="${size * 0.4}" y2="0" stroke="${accentColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="0" y1="${size * 0.6}" x2="${size * 0.6}" y2="0" stroke="${secondaryColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="0" y1="${size * 0.8}" x2="${size * 0.8}" y2="0" stroke="${accentColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="${size * 0.2}" y1="${size}" x2="${size}" y2="${size * 0.2}" stroke="${secondaryColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="${size * 0.4}" y1="${size}" x2="${size}" y2="${size * 0.4}" stroke="${accentColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="${size * 0.6}" y1="${size}" x2="${size}" y2="${size * 0.6}" stroke="${secondaryColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+      <line x1="${size * 0.8}" y1="${size}" x2="${size}" y2="${size * 0.8}" stroke="${accentColor}" stroke-width="${size * 0.1}" stroke-opacity="0.7"/>
+    </svg>
+  `;
+  return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
+}
+
+/**
+ * Generate Xhosa pattern
+ */
+export function generateXhosa({
+  primaryColor = '#000000', // Black
+  secondaryColor = '#FFFFFF', // White
+  accentColor = '#FF0000',   // Red
+  size = 50
+} = {}) {
+  const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+      <rect width="${size}" height="${size}" fill="${secondaryColor}"/>
+      <!-- Xhosa geometric triangles -->
+      <polygon points="0,0 ${size * 0.5},${size * 0.5} 0,${size}" fill="${primaryColor}"/>
+      <polygon points="${size},0 ${size * 0.5},${size * 0.5} ${size},${size}" fill="${primaryColor}"/>
+      <!-- Center diamond -->
+      <polygon points="${size * 0.4},${size * 0.3} ${size * 0.5},${size * 0.2} ${size * 0.6},${size * 0.3} ${size * 0.5},${size * 0.4}" fill="${accentColor}"/>
+      <polygon points="${size * 0.4},${size * 0.7} ${size * 0.5},${size * 0.8} ${size * 0.6},${size * 0.7} ${size * 0.5},${size * 0.6}" fill="${accentColor}"/>
+      <!-- Horizontal band -->
+      <rect x="0" y="${size * 0.45}" width="${size}" height="${size * 0.1}" fill="${primaryColor}"/>
+    </svg>
+  `;
+  return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
+}
+
 /**
  * Generate Swazi/Eswatini pattern
  * Inspired by Ligwalagwala (purple-crested turaco) and royal patterns
@@ -741,6 +795,8 @@ export default {
   generateZuluBeads,
   generateSwazi,
   generateXhosa,
+  generateYorubaAdire,
+  generateAkanKente,
   // Utilities
   applyPattern,
   // Tech Patterns
@@ -831,3 +887,115 @@ export function generateCircuit({
   `;
   return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
 }
+
+/**
+ * Generate Yoruba Adire pattern (Nigeria)
+
+ * Traditional resist-dyed cloth patterns
+
+ */
+
+export function generateYorubaAdire({
+
+  primaryColor = '#000000',
+
+  secondaryColor = '#FCD116',
+
+  backgroundColor = '#FFFFFF',
+
+  size = 50
+
+} = {}) {
+
+  const svg = `
+
+    <svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+
+      <rect width="${size}" height="${size}" fill="${backgroundColor}"/>
+
+      <!-- Adire tie-dye circles -->
+
+      <circle cx="${size * 0.2}" cy="${size * 0.2}" r="${size * 0.15}" fill="${primaryColor}"/>
+
+      <circle cx="${size * 0.8}" cy="${size * 0.2}" r="${size * 0.15}" fill="${primaryColor}"/>
+
+      <circle cx="${size * 0.2}" cy="${size * 0.8}" r="${size * 0.15}" fill="${primaryColor}"/>
+
+      <circle cx="${size * 0.8}" cy="${size * 0.8}" r="${size * 0.15}" fill="${primaryColor}"/>
+
+      <circle cx="${size * 0.5}" cy="${size * 0.5}" r="${size * 0.1}" fill="${secondaryColor}"/>
+
+      <!-- Connecting lines -->
+
+      <line x1="${size * 0.2}" y1="${size * 0.2}" x2="${size * 0.8}" y2="${size * 0.8}" stroke="${primaryColor}" stroke-width="2"/>
+
+      <line x1="${size * 0.8}" y1="${size * 0.2}" x2="${size * 0.2}" y2="${size * 0.8}" stroke="${primaryColor}" stroke-width="2"/>
+
+    </svg>
+
+  `;
+
+  return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
+
+}
+
+/**
+
+ * Generate Akan Kente pattern variation (Ghana)
+
+ * Geometric patterns with cultural significance
+
+ */
+
+export function generateAkanKente({
+
+  colors = ['#000000', '#FCD116', '#E82127', '#006B3F'],
+
+  size = 60
+
+} = {}) {
+
+  const [black, gold, red, green] = colors;
+
+  const stripe = size / 6;
+
+  const svg = `
+
+    <svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+
+      <rect width="${size}" height="${size}" fill="${gold}"/>
+
+      <!-- Horizontal black stripes -->
+
+      <rect x="0" y="0" width="${size}" height="${stripe}" fill="${black}"/>
+
+      <rect x="0" y="${stripe * 2}" width="${size}" height="${stripe}" fill="${black}"/>
+
+      <rect x="0" y="${stripe * 4}" width="${size}" height="${stripe}" fill="${black}"/>
+
+      <!-- Vertical red stripes -->
+
+      <rect x="0" y="0" width="${stripe}" height="${size}" fill="${red}" opacity="0.6"/>
+
+      <rect x="${stripe * 2}" y="0" width="${stripe}" height="${size}" fill="${red}" opacity="0.6"/>
+
+      <rect x="${stripe * 4}" y="0" width="${stripe}" height="${size}" fill="${red}" opacity="0.6"/>
+
+      <!-- Green corner squares -->
+
+      <rect x="0" y="0" width="${stripe * 0.8}" height="${stripe * 0.8}" fill="${green}"/>
+
+      <rect x="${size - stripe * 0.8}" y="0" width="${stripe * 0.8}" height="${stripe * 0.8}" fill="${green}"/>
+
+      <rect x="0" y="${size - stripe * 0.8}" width="${stripe * 0.8}" height="${stripe * 0.8}" fill="${green}"/>
+
+      <rect x="${size - stripe * 0.8}" y="${size - stripe * 0.8}" width="${stripe * 0.8}" height="${stripe * 0.8}" fill="${green}"/>
+
+    </svg>
+
+  `;
+
+  return `data:image/svg+xml,${encodeURIComponent(svg.trim())}`;
+
+}
+

package/core/request-analytics.js

@@ -0,0 +1,254 @@
+/**
+ * AfriCode Request Identity System
+ * 
+ * Identifies and tracks request origins, geolocation, and device characteristics
+ * to enhance security and analytics in the African digital economy context.
+ * 
+ * Features:
+ * - IP geolocation detection (Africa-focused)
+ * - Device fingerprinting
+ * - Request origin tracking
+ * - Bot detection
+ * - Fraud pattern recognition
+ * 
+ * @module core/request-identity
+ */
+
+import { frameworkLog } from './logging.js';
+
+/**
+ * African countries ISO codes for geolocation
+ */
+const AFRICAN_COUNTRIES = [
+  'AO', 'BF', 'BI', 'BJ', 'BW', 'CD', 'CF', 'CG', 'CI', 'CM', 'CV', 'DJ', 
+  'DZ', 'EG', 'EH', 'ER', 'ET', 'GA', 'GH', 'GM', 'GN', 'GQ', 'GW', 'KE', 
+  'KM', 'LR', 'LS', 'LY', 'MA', 'MG', 'ML', 'MR', 'MU', 'MW', 'MZ', 'NA', 
+  'NE', 'NG', 'RE', 'RW', 'SC', 'SD', 'SH', 'SL', 'SN', 'SO', 'SS', 'ST', 
+  'SZ', 'TD', 'TG', 'TN', 'TZ', 'UG', 'YT', 'ZA', 'ZM', 'ZW'
+];
+
+/**
+ * Detect bot traffic based on common patterns
+ */
+function isBotUserAgent(userAgent) {
+  if (!userAgent) return false;
+  
+  const botPatterns = [
+    /bot/i,
+    /crawl/i,
+    /spider/i,
+    /slurp/i,
+    /facebookexternalhit/i,
+    /linkedinbot/i,
+    /twitterbot/i,
+    /whatsapp/i,
+    /telegram/i
+  ];
+  
+  return botPatterns.some(pattern => pattern.test(userAgent));
+}
+
+/**
+ * Extract country from IP (simplified - in real implementation would use a service)
+ */
+function getCountryFromIP(ip) {
+  // This would normally call a geolocation service
+  // For now, return a mock implementation
+  // In production, integrate with services like ipapi.co or ipinfo.io
+  return 'UNKNOWN';
+}
+
+/**
+ * Generate request fingerprint
+ */
+function generateFingerprint(req) {
+  const headers = req.headers || new Headers();
+  const userAgent = headers.get('user-agent') || '';
+  const acceptLanguage = headers.get('accept-language') || '';
+  const acceptEncoding = headers.get('accept-encoding') || '';
+  
+  // Get IP from various headers (considering proxies)
+  let ip = headers.get('x-forwarded-for') || 
+           headers.get('x-real-ip') || 
+           headers.get('x-client-ip') ||
+           (req.connection ? req.connection.remoteAddress : null) ||
+           (req.socket ? req.socket.remoteAddress : null) ||
+           (req.connection ? req.connection.socket.remoteAddress : null) ||
+           '127.0.0.1';
+           
+  // Handle comma-separated IPs from x-forwarded-for
+  if (ip.includes(',')) {
+    ip = ip.split(',')[0].trim();
+  }
+  
+  // Create a hash of the identifying characteristics
+  const fingerprintData = {
+    ip,
+    userAgent: sanitizeUserAgent(userAgent),
+    acceptLanguage,
+    acceptEncoding,
+    path: req.url || '',
+    method: req.method || 'GET'
+  };
+  
+  return calculateHash(JSON.stringify(fingerprintData));
+}
+
+/**
+ * Sanitize user agent to remove potentially identifying info
+ */
+function sanitizeUserAgent(userAgent) {
+  if (!userAgent) return '';
+  
+  // Remove version numbers and build info for privacy
+  return userAgent
+    .replace(/\d+\.\d+(\.\d+)?/g, '[VERSION]')
+    .replace(/\([^\)]*\)/g, '(***REDACTED***)');
+}
+
+/**
+ * Simple hash function for fingerprinting
+ */
+function calculateHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash |= 0; // Convert to 32bit integer
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/**
+ * Enhanced logging with request identity
+ */
+export function requestIdentityMiddleware(options = {}) {
+  const {
+    logAllRequests = false,
+    logSuspicious = true,
+    logAfricanTraffic = true,
+    fraudDetection = true
+  } = options;
+  
+  return async (ctx) => {
+    const startTime = Date.now();
+    const fingerprint = generateFingerprint(ctx.req);
+    
+    // Add identity info to context
+    ctx.identity = {
+      fingerprint,
+      timestamp: new Date().toISOString(),
+      userAgent: ctx.req.headers?.get('user-agent') || '',
+      ip: getIPFromRequest(ctx.req),
+      isBot: isBotUserAgent(ctx.req.headers?.get('user-agent')),
+      country: getCountryFromIP(getIPFromRequest(ctx.req)),
+      isAfrican: false, // Would be set based on geolocation
+      responseTime: 0
+    };
+    
+    // Log request if configured
+    if (logAllRequests) {
+      frameworkLog('info', `[Request Identity] ${ctx.req.method} ${ctx.pathname} | Fingerprint: ${fingerprint}`);
+    }
+    
+    // Continue with request processing
+    const result = {};
+    
+    // Set up response time calculation for post-processing
+    const originalEnd = ctx.res?.end;
+    if (originalEnd) {
+      ctx.res.end = function(...args) {
+        ctx.identity.responseTime = Date.now() - startTime;
+        if (ctx.identity.responseTime > 5000) { // Slow requests
+          frameworkLog('warn', `[Slow Request] ${ctx.pathname} took ${ctx.identity.responseTime}ms`);
+        }
+        return originalEnd.apply(this, args);
+      };
+    }
+    
+    return result;
+  };
+}
+
+/**
+ * Get IP from request considering various proxy headers
+ */
+function getIPFromRequest(req) {
+  const headers = req.headers || new Headers();
+  let ip = headers.get('x-forwarded-for') || 
+           headers.get('x-real-ip') || 
+           headers.get('x-client-ip') ||
+           (req.connection ? req.connection.remoteAddress : null) ||
+           (req.socket ? req.socket.remoteAddress : null) ||
+           (req.connection ? req.connection.socket.remoteAddress : null) ||
+           '127.0.0.1';
+           
+  // Handle comma-separated IPs from x-forwarded-for
+  if (ip.includes(',')) {
+    ip = ip.split(',')[0].trim();
+  }
+  
+  return ip;
+}
+
+/**
+ * Fraud detection middleware
+ */
+export function fraudDetectionMiddleware(options = {}) {
+  const {
+    maxRequestsPerMinute = 60,
+    suspiciousPatterns = [],
+    blockBots = true
+  } = options;
+  
+  // In-memory store for request tracking (would use Redis in production)
+  const requestCounts = new Map();
+  
+  return async (ctx) => {
+    const ip = getIPFromRequest(ctx.req);
+    const now = Date.now();
+    const minuteKey = `${ip}:${Math.floor(now / 60000)}`;
+    
+    // Track requests per minute
+    if (!requestCounts.has(minuteKey)) {
+      requestCounts.set(minuteKey, 0);
+    }
+    requestCounts.set(minuteKey, requestCounts.get(minuteKey) + 1);
+    
+    const requestCount = requestCounts.get(minuteKey);
+    
+    // Check for excessive requests
+    if (requestCount > maxRequestsPerMinute) {
+      frameworkLog('warn', `[Fraud Detection] Potential DoS from IP: ${ip}, requests: ${requestCount}`);
+      return {
+        response: new Response('Too many requests', { status: 429 })
+      };
+    }
+    
+    // Check for bot traffic if configured
+    if (blockBots && isBotUserAgent(ctx.req.headers?.get('user-agent'))) {
+      frameworkLog('info', `[Bot Traffic] Blocked bot: ${ctx.req.headers?.get('user-agent')} from ${ip}`);
+      return {
+        response: new Response('Bot traffic not allowed', { status: 403 })
+      };
+    }
+    
+    // Add identity info to context
+    ctx.identity = ctx.identity || {};
+    Object.assign(ctx.identity, {
+      ip,
+      isBot: isBotUserAgent(ctx.req.headers?.get('user-agent')),
+      requestCount
+    });
+    
+    return {};
+  };
+}
+
+export default {
+  requestIdentityMiddleware,
+  fraudDetectionMiddleware,
+  generateFingerprint,
+  getIPFromRequest,
+  isBotUserAgent
+};

package/core/request-identity.js

@@ -1,44 +1,94 @@
 /**
- * Request identity resolver for AfriCode sessions.
- *
+ * AfriCode Request Identity Utilities
+ * 
+ * Core utilities for handling request identity, cookies, and session management
+ * that are referenced by the SDK
+ * 
  * @module core/request-identity
  */
 
-const SESSION_COOKIE_NAME = 'afri_session';
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-export function parseCookieHeader(cookieHeader = '') {
-  return cookieHeader
-    .split(';')
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .reduce((cookies, part) => {
-      const separatorIndex = part.indexOf('=');
-      if (separatorIndex === -1) {
-        return cookies;
-      }
-
-      const key = part.slice(0, separatorIndex).trim();
-      const value = part.slice(separatorIndex + 1).trim();
-      cookies[key] = value;
-      return cookies;
-    }, {});
+/**
+ * Parse cookie header into key-value pairs
+ * @param {string} cookieHeader - The Cookie header value
+ * @returns {Object} Parsed cookies as key-value pairs
+ */
+export function parseCookieHeader(cookieHeader) {
+  if (!cookieHeader) return {};
+  
+  const cookies = {};
+  cookieHeader.split(';').forEach(cookie => {
+    const [name, value] = cookie.trim().split('=');
+    if (name && value) {
+      cookies[decodeURIComponent(name)] = decodeURIComponent(value);
+    }
+  });
+  
+  return cookies;
 }
 
+/**
+ * Create a secure session ID
+ * @returns {string} A cryptographically secure session ID
+ */
 export function createSessionId() {
+  // Use crypto.randomUUID() for secure UUID generation
   return crypto.randomUUID();
 }
 
-export function getRequestIdentity(req) {
-  const cookieHeader = req?.headers?.get?.('cookie') || '';
+/**
+ * Get request identity (session ID from cookies)
+ * @param {Request} request - The incoming request
+ * @returns {string|null} Session ID from cookie
+ */
+export function getRequestIdentity(request) {
+  const headers = request.headers || {};
+  const cookieHeader = headers.get('cookie');
   const cookies = parseCookieHeader(cookieHeader);
-  const sessionId = cookies[SESSION_COOKIE_NAME];
+  return cookies[SESSION_COOKIE_NAME] || null;
+}
 
-  if (sessionId && UUID_PATTERN.test(sessionId)) {
-    return sessionId;
+/**
+ * Get full request identity information
+ * @param {Request} request - The incoming request
+ * @returns {Object} Detailed request identity information
+ */
+export function getFullRequestIdentity(request) {
+  const headers = request.headers || {};
+  const userAgent = headers.get('user-agent') || '';
+  const forwardedFor = headers.get('x-forwarded-for');
+  const realIp = headers.get('x-real-ip') || headers.get('x-client-ip');
+  const cfConnectingIp = headers.get('cf-connecting-ip');
+  const xClusterClientIp = headers.get('x-cluster-client-ip');
+  
+  let ip = realIp || forwardedFor?.split(',')[0] || cfConnectingIp || xClusterClientIp;
+  if (!ip) {
+    ip = request.connection?.remoteAddress || request.socket?.remoteAddress;
   }
-
-  return createSessionId();
+  if (!ip) ip = '127.0.0.1';
+  if (ip.startsWith('::ffff:')) {
+    ip = ip.substring(7);
+  }
+  
+  return {
+    ip,
+    userAgent,
+    sessionId: parseCookieHeader(headers.get('cookie'))[SESSION_COOKIE_NAME] || null,
+    timestamp: new Date().toISOString(),
+    method: request.method || 'GET',
+    url: request.url || '',
+    referer: headers.get('referer') || headers.get('referrer') || '',
+    language: headers.get('accept-language') || ''
+  };
 }
 
-export { SESSION_COOKIE_NAME };
+/**
+ * Constant for session cookie name
+ */
+export const SESSION_COOKIE_NAME = 'session_id';
+
+export default {
+  parseCookieHeader,
+  createSessionId,
+  getRequestIdentity,
+  SESSION_COOKIE_NAME
+};

package/core/sdk.js

@@ -17,6 +17,7 @@ import { getRequestIdentity, parseCookieHeader, createSessionId, SESSION_COOKIE_
 import { sessionStore } from './session-store.js';
 import { actions as runtimeActions } from './actions.js';
 import { MiddlewareManager, loggerMiddleware, authMiddleware } from './middleware.js';
+import * as requestAnalytics from './request-analytics.js';
 import {
     AfriCodeError, ValidationError, InvalidUrlError,
     SecurityError, CsrfError, RateLimitError,
@@ -84,7 +85,8 @@ export {
     CsrfError,
     RateLimitError,
     DatabaseError,
-    ComponentError
+    ComponentError,
+    requestAnalytics
 };
 
 // v5.0.0 exports
@@ -141,5 +143,6 @@ export default {
     RateLimitError,
     DatabaseError,
     ComponentError,
+    requestAnalytics,
     init
 };

package/core/validation.js

@@ -372,6 +372,19 @@ export class AfriFieldBuilder {
    */
   message(message) {
     this._customMessage = message;
+    // Update the base schema with the custom message if applicable
+    if (this._customMessage && this._baseSchema) {
+      // For string schemas with min validation
+      if (this._fieldType === 'string' && this._baseSchema._def?.minLength) {
+        this._baseSchema = z.string().min(this._baseSchema._def.minLength.value, message);
+      } else if (this._fieldType === 'url') {
+        this._baseSchema = z.string().min(1, 'URL cannot be empty').url(message);
+      } else if (this._fieldType === 'email') {
+        this._baseSchema = z.string().min(1, 'Email cannot be empty').email(message);
+      } else if (this._fieldType === 'phone') {
+        this._baseSchema = z.string().regex(/^[\+]?[1-9][\d]{0,15}$/, message);
+      }
+    }
     return this;
   }