@africode/core 5.0.1 → 5.0.2

package/core/request-identity.js

@@ -0,0 +1,44 @@
+/**
+ * Request identity resolver for AfriCode sessions.
+ *
+ * @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;
+    }, {});
+}
+
+export function createSessionId() {
+  return crypto.randomUUID();
+}
+
+export function getRequestIdentity(req) {
+  const cookieHeader = req?.headers?.get?.('cookie') || '';
+  const cookies = parseCookieHeader(cookieHeader);
+  const sessionId = cookies[SESSION_COOKIE_NAME];
+
+  if (sessionId && UUID_PATTERN.test(sessionId)) {
+    return sessionId;
+  }
+
+  return createSessionId();
+}
+
+export { SESSION_COOKIE_NAME };

package/core/sdk.js

@@ -13,6 +13,10 @@ import { hydrate } from './hydration.js';
 import { html, Layout } from './html.js';
 import { schemas, Validation, rules, afri, AfriFieldBuilder, normalizeInput, buildSchema } from './validation.js';
 import { createFramework, getConfig } from './config.js';
+import { getRequestIdentity, parseCookieHeader, createSessionId, SESSION_COOKIE_NAME } from './request-identity.js';
+import { sessionStore } from './session-store.js';
+import { actions as runtimeActions } from './actions.js';
+import { MiddlewareManager, loggerMiddleware, authMiddleware } from './middleware.js';
 import {
     AfriCodeError, ValidationError, InvalidUrlError,
     SecurityError, CsrfError, RateLimitError,
@@ -64,6 +68,15 @@ export {
     buildSchema,
     createFramework,
     getConfig,
+    getRequestIdentity,
+    parseCookieHeader,
+    createSessionId,
+    SESSION_COOKIE_NAME,
+    sessionStore,
+    runtimeActions,
+    MiddlewareManager,
+    loggerMiddleware,
+    authMiddleware,
     AfriCodeError,
     ValidationError,
     InvalidUrlError,
@@ -111,6 +124,15 @@ export default {
     buildSchema,
     createFramework,
     getConfig,
+    getRequestIdentity,
+    parseCookieHeader,
+    createSessionId,
+    SESSION_COOKIE_NAME,
+    sessionStore,
+    runtimeActions,
+    MiddlewareManager,
+    loggerMiddleware,
+    authMiddleware,
     AfriCodeError,
     ValidationError,
     InvalidUrlError,

package/core/session-store.js

@@ -0,0 +1,68 @@
+/**
+ * Server-side session state store for AfriCode.
+ *
+ * @module core/session-store
+ */
+
+class SessionStore {
+  constructor() {
+    this.sessions = new Map();
+  }
+
+  ensure(sessionId) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, {
+        data: {
+          counter: { value: 0 }
+        },
+        meta: {
+          createdAt: new Date(),
+          lastSeenAt: new Date()
+        }
+      });
+    }
+
+    return this.sessions.get(sessionId);
+  }
+
+  touch(sessionId) {
+    const session = this.ensure(sessionId);
+    session.meta.lastSeenAt = new Date();
+    return session;
+  }
+
+  has(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+
+  get(sessionId) {
+    return this.touch(sessionId).data;
+  }
+
+  set(sessionId, path, value) {
+    const session = this.get(sessionId);
+    const keys = path.split('/');
+    let obj = session;
+
+    while (keys.length > 1) {
+      const key = keys.shift();
+      if (!obj[key] || typeof obj[key] !== 'object') {
+        obj[key] = {};
+      }
+      obj = obj[key];
+    }
+
+    obj[keys[0]] = value;
+    return value;
+  }
+
+  delete(sessionId) {
+    return this.sessions.delete(sessionId);
+  }
+
+  clear() {
+    this.sessions.clear();
+  }
+}
+
+export const sessionStore = new SessionStore();

package/core/state.js

@@ -124,6 +124,40 @@ function notifySubscribers(state, newValue, oldValue, property) {
   });
 }
 
+/**
+ * Simple server-side state store for Phase 3A
+ */
+export class GlobalState {
+  constructor() {
+    this.store = {};
+  }
+
+  get(path) {
+    return path.split('/').reduce((obj, key) => obj?.[key], this.store);
+  }
+
+  set(path, value) {
+    const keys = path.split('/');
+    let obj = this.store;
+
+    while (keys.length > 1) {
+      const key = keys.shift();
+      if (!obj[key] || typeof obj[key] !== 'object') {
+        obj[key] = {};
+      }
+      obj = obj[key];
+    }
+
+    obj[keys[0]] = value;
+  }
+
+  getAll() {
+    return this.store;
+  }
+}
+
+export const globalState = new GlobalState();
+
 /**
  * Create a computed value that updates when dependencies change
  * 

package/core/websocket.js

@@ -10,6 +10,8 @@
  * - Automatic reconnection
  */
 
+import { frameworkLog } from './logging.js';
+
 /**
  * WebSocket Server Manager
  * Handles connections, rooms, and broadcasting
@@ -117,11 +119,11 @@ export class WebSocketServer {
                         timestamp: Date.now()
                     });
                 } catch (error) {
-                    console.error(`Error in handler for ${type}:`, error);
+                    frameworkLog('error', `Error in handler for ${type}:`, error);
                 }
             }
         } catch (error) {
-            console.error('Error handling message:', error);
+            frameworkLog('error', 'Error handling message:', error);
         }
     }
 
@@ -230,7 +232,7 @@ export class WebSocketServer {
             }));
             return true;
         } catch (error) {
-            console.error(`Error sending to ${connectionId}:`, error);
+            frameworkLog('error', `Error sending to ${connectionId}:`, error);
             return false;
         }
     }
@@ -255,7 +257,7 @@ export class WebSocketServer {
                                 timestamp
                             }));
                         } catch (error) {
-                            console.error(`Error broadcasting to ${connectionId}:`, error);
+                            frameworkLog('error', `Error broadcasting to ${connectionId}:`, error);
                         }
                     }
                 }
@@ -269,28 +271,28 @@ export class WebSocketServer {
             }
         } else if (scope === 'presence') {
             // Broadcast presence to all connections
-            for (const [connId, connInfo] of this.connections.entries()) {
-                try {
+                for (const [connId, connInfo] of this.connections.entries()) {
+                    try {
                     connInfo.ws.send(JSON.stringify({
                         type,
                         payload,
                         timestamp
                     }));
-                } catch (error) {
-                    console.error(`Error broadcasting presence to ${connId}:`, error);
+                    } catch (error) {
+                    frameworkLog('error', `Error broadcasting presence to ${connId}:`, error);
                 }
             }
         } else {
             // Global broadcast
-            for (const [connId, connInfo] of this.connections.entries()) {
-                try {
+                for (const [connId, connInfo] of this.connections.entries()) {
+                    try {
                     connInfo.ws.send(JSON.stringify({
                         type,
                         payload,
                         timestamp
                     }));
-                } catch (error) {
-                    console.error(`Error broadcasting to ${connId}:`, error);
+                    } catch (error) {
+                    frameworkLog('error', `Error broadcasting to ${connId}:`, error);
                 }
             }
         }
@@ -504,7 +506,7 @@ export class WebSocketClient {
             this.ws = new WebSocket(this.url);
 
             this.ws.onopen = () => {
-                console.log('Connected to WebSocket server');
+                frameworkLog('log', 'Connected to WebSocket server');
                 this.reconnectAttempts = 0;
                 this.reconnectDelay = 1000;
                 this.emit('connected', { userId: this.userId });
@@ -516,18 +518,18 @@ export class WebSocketClient {
             };
 
             this.ws.onerror = (error) => {
-                console.error('WebSocket error:', error);
+                frameworkLog('error', 'WebSocket error:', error);
                 this.emit('error', error);
             };
 
             this.ws.onclose = () => {
-                console.log('Disconnected from WebSocket');
+                frameworkLog('log', 'Disconnected from WebSocket');
                 this.ws = null;
                 this.isConnecting = false;
                 this.attemptReconnect();
             };
         } catch (error) {
-            console.error('Failed to connect to WebSocket:', error);
+            frameworkLog('error', 'Failed to connect to WebSocket:', error);
             this.isConnecting = false;
             this.attemptReconnect();
         }
@@ -547,7 +549,7 @@ export class WebSocketClient {
         this.reconnectAttempts++;
         const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 30000);
 
-        console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        frameworkLog('log', `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
         
         setTimeout(() => {
             this.connect();
@@ -574,7 +576,7 @@ export class WebSocketClient {
             try {
                 handler(payload);
             } catch (error) {
-                console.error(`Error in handler for ${type}:`, error);
+                frameworkLog('error', `Error in handler for ${type}:`, error);
             }
         }
     }
@@ -584,7 +586,7 @@ export class WebSocketClient {
      */
     send(type, payload) {
         if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            console.warn('WebSocket not connected');
+            frameworkLog('warn', 'WebSocket not connected');
             return false;
         }
 
@@ -596,7 +598,7 @@ export class WebSocketClient {
             }));
             return true;
         } catch (error) {
-            console.error('Error sending message:', error);
+            frameworkLog('error', 'Error sending message:', error);
             return false;
         }
     }