@africode/core 5.0.8 → 5.0.9

package/core/bun-runtime.js

@@ -13,7 +13,9 @@ import { actions } from './actions.js';
 import { MiddlewareManager, loggerMiddleware } from './middleware.js';
 import { EnhancedHMRMiddleware } from './enhanced-hmr.js';
 import { Database as BunSQLiteDatabase } from 'bun:sqlite';
-import { extname, join } from 'path';
+import { existsSync } from 'fs';
+import { extname, join, resolve } from 'path';
+import { pathToFileURL } from 'url';
 
 export const BUN_CONFIG = {
   startupTimeout: 5000,
@@ -24,14 +26,98 @@ export const BUN_CONFIG = {
 
 export class BunHTTPServer {
   constructor(options = {}) {
-    this.router = new FileSystemRouter(join(process.cwd(), options.pagesDir || 'pages'));
-
+    this.projectRoot = resolve(options.projectRoot || process.cwd());
+    this.explicitPagesDir = Boolean(options.pagesDir);
+    this.explicitPort = options.port !== undefined;
+    this.configPath = options.configPath === false
+      ? null
+      : resolve(this.projectRoot, options.configPath || 'africode.config.js');
+    this.config = options.config || {};
+    this.configLoaded = Boolean(options.config || options.configPath === false);
     this.middleware = new MiddlewareManager();
-    this.port = options.port || 3000;
+    this.configMiddlewareRegistered = false;
+    this.port = options.port || this.config.server?.port || 3000;
     this.server = null;
+
+    if (!this.configLoaded && !this.explicitPagesDir && this.configPath && existsSync(this.configPath)) {
+      this.pagesDir = null;
+      this.router = null;
+    } else {
+      this.configureRouter(options.pagesDir || this.config.directories?.pages || 'pages');
+    }
+  }
+
+  configureRouter(pagesDir) {
+    const absolutePagesDir = resolve(this.projectRoot, pagesDir || 'pages');
+    this.pagesDir = absolutePagesDir;
+    this.router = new FileSystemRouter(absolutePagesDir);
+  }
+
+  async loadProjectConfig() {
+    if (this.configLoaded) {
+      this.registerConfigMiddleware();
+      return this.config;
+    }
+
+    this.configLoaded = true;
+
+    if (!this.configPath || !existsSync(this.configPath)) {
+      this.registerConfigMiddleware();
+      return this.config;
+    }
+
+    const moduleUrl = pathToFileURL(this.configPath).href + '?t=' + Date.now();
+    const projectConfigModule = await import(moduleUrl);
+    const projectConfig = projectConfigModule.default || projectConfigModule.config || {};
+    this.config = { ...projectConfig, ...this.config };
+
+    if (!this.explicitPort && this.config.server?.port) {
+      this.port = Number(this.config.server.port) || this.port;
+    }
+
+    if (!this.explicitPagesDir) {
+      this.configureRouter(this.config.directories?.pages || this.config.pagesDir || 'pages');
+    }
+
+    this.registerConfigMiddleware();
+
+    return this.config;
+  }
+
+  getConfigMiddlewareList() {
+    const sources = [
+      this.config.middleware,
+      this.config.middlewares,
+      this.config.interceptors
+    ];
+
+    return sources
+      .flatMap((source) => {
+        if (!source) {
+          return [];
+        }
+
+        return Array.isArray(source) ? source : [source];
+      })
+      .filter(Boolean);
+  }
+
+  registerConfigMiddleware() {
+    if (this.configMiddlewareRegistered) {
+      return;
+    }
+
+    const middlewares = this.getConfigMiddlewareList();
+    for (const middleware of middlewares) {
+      this.middleware.use(middleware);
+    }
+
+    this.configMiddlewareRegistered = true;
   }
 
   async start() {
+    await this.loadProjectConfig();
+
     // Register middlewares
     this.middleware.use(loggerMiddleware());
 
@@ -55,6 +141,8 @@ export class BunHTTPServer {
   }
 
   async handleRequest(req) {
+    await this.loadProjectConfig();
+
     const url = new URL(req.url);
     const pathname = url.pathname;
     const sessionId = getRequestIdentity(req);
@@ -68,8 +156,16 @@ export class BunHTTPServer {
     let context = {
       req,
       url,
+      method: req.method,
+      headers: req.headers,
+      json: () => req.json(),
+      text: () => req.text(),
+      formData: () => req.formData(),
+      arrayBuffer: () => req.arrayBuffer(),
       pathname,
       params: {},
+      config: this.config,
+      projectRoot: this.projectRoot,
       sessionId,
       state: session,
       actions,
@@ -94,7 +190,8 @@ export class BunHTTPServer {
           pathname,
           filePath: route.filePath,
           isApi: route.isApi,
-          isDynamic: route.isDynamic
+          isDynamic: route.isDynamic,
+          params: route.params || {}
         }
       };
 
@@ -113,7 +210,13 @@ export class BunHTTPServer {
         const handler = pageModule[method];
 
         if (!handler) {
-          throw new Error("No " + method + " handler in API route");
+          const allowedMethods = this.getAllowedMethods(pageModule);
+          return this.attachSessionCookie(new Response('Method Not Allowed', {
+            status: 405,
+            headers: {
+              Allow: allowedMethods.join(', ')
+            }
+          }), sessionId);
         }
 
         const result = await handler(context);
@@ -134,6 +237,12 @@ export class BunHTTPServer {
       return this.attachSessionCookie(new Response('Route Error', { status: 500 }), sessionId);
     }
   }
+
+  getAllowedMethods(pageModule) {
+    const methodNames = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'];
+    return methodNames.filter((method) => typeof pageModule[method] === 'function');
+  }
+
   attachSessionCookie(response, sessionId) {
     const cookie = 'afri_session=' + sessionId + '; Path=/; HttpOnly; SameSite=Strict';
 
@@ -164,6 +273,12 @@ export class BunHTTPServer {
       });
     }
 
+    if (result && typeof result === 'object') {
+      return new Response(JSON.stringify(result), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
     // ❌ Invalid return type
     console.error('Invalid render output:', result);
 
@@ -176,7 +291,7 @@ export class BunHTTPServer {
       return new Response('Forbidden', { status: 403 });
     }
 
-    const filePath = join(process.cwd(), pathname);
+    const filePath = join(this.projectRoot, pathname);
 
     try {
       const file = Bun.file(filePath);

package/core/cli/commands/build.js

@@ -7,6 +7,9 @@ import { existsSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { RawHtml } from '../../html.js';
+import { actions } from '../../actions.js';
+import { sessionStore } from '../../session-store.js';
+import { getConfig } from '../../config.js';
 
 export async function normalizeRenderOutput(htmlContent) {
     if (htmlContent && typeof htmlContent.text === 'function') {
@@ -42,10 +45,13 @@ export async function build() {
 
     const distDir = './dist';
     const cwd = process.cwd();
-    const hasSrc = existsSync(path.join(cwd, 'src'));
-    const pagesDir = hasSrc ? './src/pages' : './pages';
-    const componentsDir = hasSrc ? './src/components' : './components';
-    const stylesDir = hasSrc ? './src/styles' : './styles';
+    const resolveProjectDir = (name) => {
+        const candidates = [`./src/${name}`, `./${name}`];
+        return candidates.find((candidate) => existsSync(path.join(cwd, candidate))) || candidates[0];
+    };
+    const pagesDir = resolveProjectDir('pages');
+    const componentsDir = resolveProjectDir('components');
+    const stylesDir = resolveProjectDir('styles');
 
     try {
         const buildStart = performance.now();
@@ -119,7 +125,25 @@ export async function build() {
             }
 
             if (typeof pageModule.default === 'function') {
-                let htmlContent = await pageModule.default({ data: loaderData });
+                const sessionId = 'africode-ssg-build';
+                const requestUrl = new URL(`http://localhost${route}`);
+                const renderContext = {
+                    data: loaderData,
+                    req: new Request(requestUrl),
+                    url: requestUrl,
+                    method: 'GET',
+                    headers: new Headers(),
+                    pathname: route,
+                    params: {},
+                    config: getConfig(),
+                    projectRoot: cwd,
+                    sessionId,
+                    state: sessionStore.get(sessionId),
+                    actions,
+                    sessionStore,
+                    route: { path: route, params: {}, isDynamic: false, isApi: false }
+                };
+                let htmlContent = await pageModule.default(renderContext);
                 htmlContent = await normalizeRenderOutput(htmlContent);
                 const outputPath = path.join(distDir, `${name}.html`);
                 await writeFile(outputPath, htmlContent);
@@ -164,5 +188,6 @@ export async function build() {
 
     } catch (err) {
         console.error(`${colors.red}✗ Build failed:${colors.reset}`, err.message || err);
+        throw err;
     }
 }

package/core/cli/ui.js

@@ -31,14 +31,24 @@ export function help() {
     logo();
     console.log(`
 ${colors.bold}Usage:${colors.reset}
-  africode <command> [options]
+  bun run ./bin/africode.js <command> [options]
+
+${colors.bold}Quick start:${colors.reset}
+  ${colors.green}bun install${colors.reset}
+  ${colors.green}bun run ./bin/africode.js create my-app${colors.reset}
+  ${colors.green}cd my-app${colors.reset}
+  ${colors.green}bun install${colors.reset}
+  ${colors.green}bun run ./bin/africode.js dev${colors.reset}
 
 ${colors.bold}Commands:${colors.reset}
   ${colors.green}dev${colors.reset}       Start development server
   ${colors.green}build${colors.reset}     Create production build
-  ${colors.green}add${colors.reset}       Add a component (e.g., africode add sidebar)
-  ${colors.green}new${colors.reset}       Create a new project (options: --template 3d)
+  ${colors.green}add${colors.reset}       Add a component (e.g., bun run ./bin/africode.js add sidebar)
+  ${colors.green}create${colors.reset}    Create a new project (use --template starter, tailwind, react, or 3d)
   ${colors.green}migrate${colors.reset}   Run database migrations
+  ${colors.green}lint${colors.reset}      Check project files for lint errors
+  ${colors.green}audit${colors.reset}     Audit project structure and framework usage
+  ${colors.green}test${colors.reset}      Run the project test suite
   ${colors.green}help${colors.reset}      Show this help message
 
 ${colors.gold}Powered by the rhythm of the continent.${colors.reset}

package/core/compliance.js

@@ -462,6 +462,70 @@ export class AMLComplianceEngine {
         return flags;
     }
 
+    /**
+     * Enhanced risk scoring for African markets
+     */
+    async _calculateAfricanRiskScore(transaction, customer) {
+        let score = await this._calculateRiskScore(transaction, customer);
+        
+        // Additional African-specific checks
+        
+        // Check for transactions involving multiple African countries
+        if (transaction.crossBorder) {
+            score += 0.15;
+        }
+        
+        // Check for cryptocurrency-related activities
+        if (transaction.paymentMethod?.includes('crypto')) {
+            score += 0.25;
+        }
+        
+        // Check for mobile money transactions (common in Africa)
+        if (transaction.paymentMethod === 'mobile_money' && amount > 500000) {  // 500k TZS
+            score += 0.1;
+        }
+        
+        // Check for politically exposed persons (PEPs)
+        if (customer.isPEP) {
+            score += 0.3;
+        }
+        
+        // Check for high-risk sectors common in Africa
+        if (customer.businessSector && ['casino', 'gambling', 'cash_intensive'].includes(customer.businessSector)) {
+            score += 0.2;
+        }
+        
+        return Math.min(score, 1.0);
+    }
+    
+    /**
+     * Multi-country sanctions screening
+     */
+    async screenSanctions(parties) {
+        // Screen against OFAC, UN, EU, and African Union sanctions lists
+        const results = [];
+        
+        for (const party of parties) {
+            const sanctionsCheck = {
+                name: party.name,
+                id: party.id,
+                matchedLists: [],
+                riskLevel: 'low'
+            };
+            
+            // In a real implementation, this would query sanctions databases
+            // This is a simplified version
+            if (party.name.toLowerCase().includes('sanctioned')) {
+                sanctionsCheck.matchedLists.push('internal_watchlist');
+                sanctionsCheck.riskLevel = 'high';
+            }
+            
+            results.push(sanctionsCheck);
+        }
+        
+        return results;
+    }
+
     /**
      * Queue suspicious activity for FIU reporting
      */
@@ -627,3 +691,140 @@ export class ComplianceMiddleware {
         };
     }
 }
+
+/**
+ * African Payment Systems Compliance
+ * Integration with regional payment systems and compliance requirements
+ */
+export class AfricanPaymentCompliance {
+    constructor(config = {}) {
+        this.supportedCountries = config.countries || ['TZ', 'KE', 'UG', 'RW', 'ZA'];
+        this.mobileMoneyProviders = config.providers || ['Mpesa', 'TigoPesa', 'AirtelMoney', 'MTNMobileMoney'];
+        this.currencyThresholds = config.thresholds || {
+            TZS: 1000000, // 1M TZS
+            KES: 50000,   // 50K KES
+            UGX: 2000000, // 2M UGX
+            ZAR: 2500     // 2.5K ZAR
+        };
+    }
+    
+    /**
+     * Validate mobile money transaction
+     * @param {Object} transaction - Transaction details
+     * @param {Object} sender - Sender profile
+     * @param {Object} receiver - Receiver profile
+     */
+    async validateMobileMoneyTransaction(transaction, sender, receiver) {
+        const validation = {
+            valid: true,
+            warnings: [],
+            errors: []
+        };
+        
+        // Check if countries are supported
+        if (!this.supportedCountries.includes(transaction.senderCountry)) {
+            validation.errors.push('Sender country not supported');
+            validation.valid = false;
+        }
+        
+        if (!this.supportedCountries.includes(transaction.receiverCountry)) {
+            validation.errors.push('Receiver country not supported');
+            validation.valid = false;
+        }
+        
+        // Check if provider is supported
+        if (!this.mobileMoneyProviders.includes(transaction.provider)) {
+            validation.warnings.push('Provider not in standard list');
+        }
+        
+        // Check amount thresholds
+        const threshold = this.currencyThresholds[transaction.currency];
+        if (threshold && transaction.amount > threshold) {
+            validation.warnings.push(`Amount exceeds recommended threshold for ${transaction.currency}`);
+            
+            // May require additional verification
+            if (transaction.amount > threshold * 2) {
+                validation.warnings.push('Amount significantly above threshold - enhanced due diligence recommended');
+            }
+        }
+        
+        // Check for frequent transactions (possible structuring)
+        if (sender.dailyTransactionCount > 10) {
+            validation.warnings.push('High frequency of transactions today');
+        }
+        
+        return validation;
+    }
+    
+    /**
+     * Generate compliance report for mobile money transactions
+     */
+    async generateMobileMoneyReport(transactions, period) {
+        const report = {
+            period,
+            totalTransactions: transactions.length,
+            totalVolume: 0,
+            byCountry: {},
+            flaggedTransactions: []
+        };
+        
+        for (const tx of transactions) {
+            report.totalVolume += tx.amount;
+            
+            // Group by country
+            if (!report.byCountry[tx.senderCountry]) {
+                report.byCountry[tx.senderCountry] = {
+                    count: 0,
+                    volume: 0
+                };
+            }
+            
+            report.byCountry[tx.senderCountry].count++;
+            report.byCountry[tx.senderCountry].volume += tx.amount;
+            
+            // Flag suspicious patterns
+            if (tx.amount > this.currencyThresholds[tx.currency] * 2) {
+                report.flaggedTransactions.push({
+                    id: tx.id,
+                    amount: tx.amount,
+                    reason: 'High value transaction'
+                });
+            }
+        }
+        
+        return report;
+    }
+    
+    /**
+     * Cross-border transaction compliance
+     */
+    async validateCrossBorderTransaction(transaction) {
+        const validation = {
+            compliant: true,
+            requirements: [],
+            errors: []
+        };
+        
+        // Check if transaction crosses borders
+        if (transaction.senderCountry !== transaction.receiverCountry) {
+            validation.requirements.push('cross_border_declaration');
+            validation.requirements.push('purpose_of_transfer');
+            
+            // Higher scrutiny for cross-border
+            if (transaction.amount > 5000000) { // 5M TZS
+                validation.requirements.push('enhanced_verification');
+                validation.requirements.push('source_of_funds');
+            }
+        }
+        
+        return validation;
+    }
+}
+export {
+    NIDAClient,
+    TIPSClient,
+    AMLComplianceEngine,
+    ComplianceMiddleware,
+    AfricanPaymentCompliance
+};
+

package/core/middleware.js

@@ -6,41 +6,104 @@
  */
 
 import { frameworkLog } from './logging.js';
+import { AfriCodeError } from './errors.js';
 
 export class MiddlewareManager {
   constructor() {
     this.middlewares = [];
+    this.isRunning = false;
   }
 
-  use(fn) {
+  /**
+   * Add middleware to the pipeline
+   * @param {Function} fn - Middleware function
+   * @param {string} [name] - Optional name for debugging
+   * @returns {MiddlewareManager}
+   */
+  use(fn, name = null) {
     if (typeof fn !== 'function') {
-      throw new Error('Middleware must be a function');
+      throw new AfriCodeError('Middleware must be a function', 'MIDDLEWARE_INVALID', {}, 500);
     }
 
-    this.middlewares.push(fn);
+    // Wrap with name and error handling
+    const wrappedFn = async (context) => {
+      const startTime = Date.now();
+      try {
+        frameworkLog('debug', `[Middleware] Running ${name || 'anonymous'} middleware`);
+        const result = await fn(context);
+        
+        const duration = Date.now() - startTime;
+        frameworkLog('debug', `[Middleware] ${name || 'anonymous'} completed in ${duration}ms`);
+        
+        return result;
+      } catch (error) {
+        frameworkLog('error', `[Middleware] Error in ${name || 'anonymous'}: ${error.message}`);
+        throw new AfriCodeError(`Middleware error in ${name || 'anonymous'}: ${error.message}`, 'MIDDLEWARE_EXECUTION_ERROR', { cause: error }, 500);
+      }
+    };
+    
+    // Store metadata in a WeakMap to avoid modifying the function object
+    this.middlewareMeta = this.middlewareMeta || new WeakMap();
+    this.middlewareMeta.set(wrappedFn, {
+      original: fn,
+      name: name || fn.name || 'anonymous'
+    });
+    
+    this.middlewares.push(wrappedFn);
     return this;
   }
 
+  /**
+   * Run middleware pipeline
+   * @param {Object} context - Request context
+   * @returns {Promise<Response|null>}
+   */
   async run(context) {
-    for (const mw of this.middlewares) {
-      const result = await mw(context);
+    if (this.isRunning) {
+      throw new MiddlewareError('Middleware pipeline is already running');
+    }
+    
+    this.isRunning = true;
+    
+    try {
+      for (const mw of this.middlewares) {
+        const result = await mw(context);
 
-      if (result instanceof Response) {
-        return result;
-      }
+        if (result instanceof Response) {
+          return result;
+        }
 
-      // middleware can short-circuit request
-      if (result?.response) {
-        return result.response;
-      }
+        // middleware can short-circuit request
+        if (result?.response) {
+          return result.response;
+        }
 
-      // allow mutation of context
-      if (result?.context) {
-        Object.assign(context, result.context);
+        // allow mutation of context
+        if (result?.context) {
+          Object.assign(context, result.context);
+        }
       }
-    }
 
-    return null;
+      return null;
+    } finally {
+      this.isRunning = false;
+    }
+  }
+  
+  /**
+   * Get middleware count
+   * @returns {number}
+   */
+  count() {
+    return this.middlewares.length;
+  }
+  
+  /**
+   * Clear all middlewares
+   */
+  clear() {
+    this.middlewares = [];
+    return this;
   }
 }