cogsbox-sync 0.0.1

package/templates/worker/schema-processor/serverOldExpress.js

@@ -0,0 +1,488 @@
+// schema-processor/server.js
+const express = require('express');
+const fs = require('fs');
+
+const app = express();
+
+app.use(express.json({ limit: '10mb' }));
+
+// In-memory cache for schemas per tenant
+const schemaCache = new Map();
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'healthy', 
+    timestamp: new Date().toISOString(),
+    cachedSchemas: Array.from(schemaCache.keys())
+  });
+});
+
+// Utility function to safely import schema module
+async function importSchemaModule(filePath) {
+  try {
+    // Clear Node.js module cache to ensure fresh import
+    delete require.cache[filePath];
+    
+    const schemaModule = await import(`file://${filePath}?t=${Date.now()}`);
+    
+    if (!schemaModule.syncSchema) {
+      throw new Error('syncSchema not found in module');
+    }
+    
+    return schemaModule;
+  } catch (error) {
+    console.error(`Failed to import schema module from ${filePath}:`, error.message);
+    throw error;
+  }
+}
+
+// Load schema for a tenant and cache it
+async function loadSchemaForTenant(tenantId) {
+  console.log(`[loadSchemaForTenant] Starting load for tenant ${tenantId}`);
+  
+  if (schemaCache.has(tenantId)) {
+    console.log(`[loadSchemaForTenant] Schema already cached for tenant ${tenantId}`);
+    return schemaCache.get(tenantId);
+  }
+  
+  // Load from file system cache first
+  const cacheFile = `/tmp/schema-${tenantId}.mjs`;
+  console.log(`[loadSchemaForTenant] Checking cache file: ${cacheFile}`);
+  
+  if (fs.existsSync(cacheFile)) {
+    try {
+      console.log(`[loadSchemaForTenant] Cache file exists, importing...`);
+      const schemaModule = await importSchemaModule(cacheFile);
+      
+      schemaCache.set(tenantId, schemaModule.syncSchema);
+      console.log(`[loadSchemaForTenant] Schema cached successfully for tenant ${tenantId}`);
+      return schemaModule.syncSchema;
+    } catch (error) {
+      console.error(`[loadSchemaForTenant] Cache file import failed:`, error.message);
+      console.log('Cache file invalid, will reload:', error.message);
+      try {
+        fs.unlinkSync(cacheFile);
+        console.log(`[loadSchemaForTenant] Removed invalid cache file`);
+      } catch (unlinkError) {
+        console.error(`[loadSchemaForTenant] Failed to remove cache file:`, unlinkError.message);
+      }
+    }
+  } else {
+    console.log(`[loadSchemaForTenant] Cache file does not exist`);
+  }
+  
+  console.log(`[loadSchemaForTenant] No schema available for tenant ${tenantId}`);
+  return null;
+}
+
+// GET endpoint to check schema status
+app.get('/load-schema', async (req, res) => {
+  try {
+    const { tenantId } = req.query;
+    
+    if (!tenantId) {
+      return res.status(400).json({ error: 'tenantId is required' });
+    }
+    
+    const schema = await loadSchemaForTenant(tenantId);
+    
+    // Handle both schema formats - direct schemas or nested under 'schemas'
+    let schemaKeys = [];
+    if (schema) {
+      if (schema.schemas) {
+        schemaKeys = Object.keys(schema.schemas);
+      } else {
+        schemaKeys = Object.keys(schema);
+      }
+    }
+    
+    res.json({ 
+      hasSchema: !!schema,
+      schemaKeys: schemaKeys
+    });
+  } catch (error) {
+    console.error('Error in GET /load-schema:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST endpoint to load/update schema
+app.post('/load-schema', async (req, res) => {
+  try {
+    const { tenantId } = req.query;
+    const { bundledCode } = req.body;
+    
+    if (!tenantId) {
+      return res.status(400).json({ error: 'tenantId is required' });
+    }
+    
+    if (bundledCode) {
+      // Save and cache new schema
+      const cacheFile = `/tmp/schema-${tenantId}.mjs`;
+      fs.writeFileSync(cacheFile, bundledCode);
+      
+      const schemaModule = await importSchemaModule(cacheFile);
+      schemaCache.set(tenantId, schemaModule.syncSchema);
+      
+      console.log(`Schema loaded and cached for tenant ${tenantId}`);
+    }
+    
+    const schema = await loadSchemaForTenant(tenantId);
+    
+    // Handle both schema formats
+    let schemaKeys = [];
+    if (schema) {
+      if (schema.schemas) {
+        schemaKeys = Object.keys(schema.schemas);
+      } else {
+        schemaKeys = Object.keys(schema);
+      }
+    }
+    
+    res.json({ 
+      success: true,
+      hasSchema: !!schema,
+      schemaKeys: schemaKeys
+    });
+  } catch (error) {
+    console.error('Error loading schema:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.post('/validate', async (req, res) => {
+  try {
+    const { data, schemaKey, bundledCode, context } = req.body;
+    const { tenantId } = req.query;
+ 
+    if (!tenantId || !schemaKey || data === undefined || !bundledCode) {
+      return res.status(400).json({ 
+        valid: false, 
+        errors: [{ path: [], message: 'Missing tenantId, schemaKey, data, or bundledCode' }] 
+      });
+    }
+ 
+    const tempFile = `/tmp/schema-${tenantId}-${Date.now()}.mjs`;
+    fs.writeFileSync(tempFile, bundledCode);
+    
+    const schemaModule = await importSchemaModule(tempFile);
+    fs.unlinkSync(tempFile);
+
+    let schemaDefinition = null;
+    if (schemaModule.syncSchema && schemaModule.syncSchema.schemas && schemaModule.syncSchema.schemas[schemaKey]) {
+      schemaDefinition = schemaModule.syncSchema.schemas[schemaKey];
+    }
+
+    if (!schemaDefinition) {
+      return res.status(404).json({
+        valid: false,
+        errors: [{ path: [], message: `Schema '${schemaKey}' not found within the provided bundle.` }]
+      });
+    }
+
+    const validator = schemaDefinition.validate;
+    if (typeof validator !== 'function') {
+      throw new Error(`Validator function not found for schema '${schemaKey}'`);
+    }
+
+    // Pass the context from the request
+    const result = validator(data, context || {});
+
+    // --- CORRECTED LOGIC ---
+    if (!result.success) {
+      // The correct property name from Zod is .issues, not .errors
+      return res.status(422).json({
+        valid: false,
+        // Using the correct "issues" property from the Zod error object
+        errors: result.error.issues 
+      });
+    }
+    // --- END CORRECTION ---
+
+    res.json({ valid: true, errors: [] });
+
+  } catch (error) {
+    console.error('[Container] /validate Error:', error);
+    // Also correct the property name here in the catch block for safety
+    if (error.name === 'ZodError') {
+        return res.status(422).json({
+            valid: false,
+            errors: error.issues // Use .issues here as well
+        });
+    }
+    res.status(500).json({ valid: false, errors: [{ path: [], message: error.message }] });
+  }
+});
+app.post('/validate-path', async (req, res) => {
+  try {
+    const { path, value, schemaKey, bundledCode } = req.body;
+    const { tenantId } = req.query;
+
+    if (!tenantId || !schemaKey || !bundledCode || !path) {
+      return res.status(400).json({ 
+        valid: false, 
+        errors: [{ path: [], message: 'Missing required parameters' }] 
+      });
+    }
+
+    // Write and load schema
+    const tempFile = `/tmp/schema-${tenantId}-${Date.now()}.mjs`;
+    fs.writeFileSync(tempFile, bundledCode);
+    const schemaModule = await importSchemaModule(tempFile);
+    fs.unlinkSync(tempFile);
+
+    // Get the specific schema from the schemas collection
+    const schemaDefinition = schemaModule.syncSchema?.schemas?.[schemaKey];
+    
+    if (!schemaDefinition) {
+      return res.status(404).json({
+        valid: false,
+        errors: [{ path: [], message: `Schema '${schemaKey}' not found` }]
+      });
+    }
+
+    // The validation schema is at schemaDefinition.schemas.validation
+    // NOT schemaDefinition.schemas?.validation (which would be looking for a nested schemas.schemas)
+    if (!schemaDefinition.schemas || !schemaDefinition.schemas.validation) {
+      return res.status(404).json({
+        valid: false,
+        errors: [{ path: [], message: `Validation schema not found for '${schemaKey}'` }]
+      });
+    }
+
+    // Walk to the target field
+    let fieldValidator = schemaDefinition.schemas.validation;
+    
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i];
+      
+      if (typeof segment === 'number' || segment.startsWith('id:')) {
+        // Array element
+        if (fieldValidator._def?.typeName === 'ZodArray') {
+          fieldValidator = fieldValidator._def.type || fieldValidator.element;
+        } else {
+          return res.json({ valid: true }); // Path doesn't exist in schema
+        }
+      } else {
+        // Object property
+        if (fieldValidator.shape) {
+          fieldValidator = fieldValidator.shape[segment];
+        } else if (fieldValidator._def?.shape) {
+          const shape = fieldValidator._def.shape();
+          fieldValidator = shape[segment];
+        } else {
+          return res.json({ valid: true }); // Path doesn't exist in schema
+        }
+      }
+      
+      if (!fieldValidator) {
+        return res.json({ valid: true }); // No validator for this path
+      }
+    }
+
+    // Validate the value
+    const result = fieldValidator.safeParse(value);
+    
+    if (!result.success) {
+      return res.status(422).json({
+        valid: false,
+        errors: result.error.issues.map(issue => ({
+          path: issue.path,  // Just the relative path from Zod
+          message: issue.message,
+          code: issue.code
+        }))
+      });
+    }
+
+    res.json({ valid: true, errors: [] });
+
+  } catch (error) {
+    console.error('[Container] /validate-path Error:', error);
+    res.status(500).json({ 
+      valid: false, 
+      errors: [{ path: [], message: error.message }] 
+    });
+  }
+});
+app.post('/get-api-routes', async (req, res) => {
+  try {
+    // Destructure params from the body, which will be sent by the DO
+    const { tenantId, schemaKey, bundledCode, params } = req.body;
+
+    if (!tenantId || !schemaKey || !bundledCode) {
+      return res.status(400).json({ error: 'Missing tenantId, schemaKey, or bundledCode' });
+    }
+    
+    const justSchemaKey = schemaKey.split('[')[0];
+    const tempFile = `/tmp/schema-${tenantId}-${Date.now()}.mjs`;
+    fs.writeFileSync(tempFile, bundledCode);
+    
+    const schemaModule = await importSchemaModule(tempFile);
+    fs.unlinkSync(tempFile);
+
+    const schemaDefinition = schemaModule.syncSchema?.schemas?.[justSchemaKey];
+
+    if (!schemaDefinition) {
+      return res.status(404).json({ error: `Schema '${justSchemaKey}' not found in bundle.` });
+    }
+
+    const apiConfig = schemaDefinition.api || {};
+    
+    // Process both queryData and mutateData with the same logic
+    const processApiConfig = (config) => {
+      if (!config) return null;
+      
+      // Check if it's an apiWithParams object
+   if (config && typeof config.handler === 'function') {
+        if (!params || typeof params !== 'object') {
+            throw new Error('Missing or invalid params object for parameterized route.');
+        }
+
+        // Validate the params object directly with Zod
+      const validationResult = schemaDefinition.validateApiParams(config, params);
+
+        if (!validationResult.success) {
+            throw new Error(`API parameter validation failed: ${JSON.stringify(validationResult.error.flatten())}`);
+        }
+        
+        // Execute handler with the validated params object
+        const result = config.handler(validationResult.data);
+        
+        // Determine if it's GET or POST based on return type
+        if (typeof result === 'string') {
+          // Just a URL = GET request
+          return { url: result, method: 'GET' };
+        } else if (result && typeof result === 'object' && result.url) {
+          // Object with url and optional data = POST if data exists, otherwise GET
+          return {
+            url: result.url,
+            method: result.data ? 'POST' : 'GET',
+            data: result.data
+          };
+        }
+        
+        throw new Error('Invalid handler return value');
+      } else if (typeof config === 'string') {
+        // Static string = GET request
+        return { url: config, method: 'GET' };
+      }
+      
+      return null;
+    };
+
+    try {
+      const queryConfig = processApiConfig(apiConfig.queryData);
+      const mutateConfig = processApiConfig(apiConfig.mutateData);
+      
+      res.json({
+        queryData: queryConfig,
+        mutateData: mutateConfig
+      });
+    } catch (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+  } catch (error) {
+    console.error('[Container] /get-api-routes Error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+
+app.post('/process-notifications-batch', async (req, res) => {
+  try {
+    // 1. Accept the new batch payload structure
+    const { bundledCode, fullState, contexts, operation } = req.body;
+    const { tenantId } = req.query;
+    
+    // Validate the incoming batch payload
+    if (!tenantId || !bundledCode || !fullState || !Array.isArray(contexts)) {
+      return res.status(400).json({ error: 'Missing tenantId, bundledCode, fullState, or contexts array' });
+    }
+
+    // 2. Use the stateless pattern (UNCHANGED): write, import, and delete the temp file.
+    const tempFile = `/tmp/schema-${tenantId}-${Date.now()}.mjs`;
+    fs.writeFileSync(tempFile, bundledCode);
+    const schemaModule = await importSchemaModule(tempFile);
+    fs.unlinkSync(tempFile);
+
+    // 3. Get the schema definition from the imported module (UNCHANGED).
+    const schema = schemaModule.syncSchema;
+    if (!schema) {
+      return res.status(404).json({ error: 'syncSchema not found in the provided bundle.' });
+    }
+
+    // 4. The notification functions are attached to the top-level schema object (UNCHANGED).
+    const notificationFunctions = schema.notifications;
+    if (!notificationFunctions) {
+      // No notifications defined, return an empty object.
+      return res.json({});
+    }
+
+    // This will become the final response object: { userId: [notifications] }
+    const notificationsByUserId = {};
+
+    // 5. BATCH PROCESSING LOOP: Iterate over the array of contexts.
+    for (const context of contexts) {
+      // Ensure context is valid before processing
+      if (!context || !context.userId) continue;
+
+      const matchedNotificationsForUser = [];
+
+      // 6. Execute all notification functions for this specific context.
+      for (const channelName in notificationFunctions) {
+        try {
+          const notificationFn = notificationFunctions[channelName];
+          
+          // Execute the function with the full state and the current user's context
+          const result = notificationFn( context,fullState);
+
+          if (result !== null && result !== undefined) {
+            matchedNotificationsForUser.push({
+              channel: channelName,
+              payload: { ...result },
+            });
+          }
+        } catch (fnError) {
+          console.error(`[Container] Error executing notification function '${channelName}' for user '${context.userId}':`, fnError);
+          // Continue to the next notification function, do not stop the batch
+        }
+      }
+
+      // 7. If any notifications were generated for this user, add them to the results map.
+      if (matchedNotificationsForUser.length > 0) {
+        notificationsByUserId[context.userId] = matchedNotificationsForUser;
+      }
+    }
+    
+    // 8. Send the single, consolidated response back to the Durable Object.
+    res.json(notificationsByUserId);
+
+  } catch (error) {
+    console.error('[Container] /process-notifications-batch Error:', error);
+    res.status(500).json({ error: 'Internal server error processing notification batch', details: error.message });
+  }
+});
+
+// Error handling middleware
+app.use((error, req, res, next) => {
+  console.error('Unhandled error:', error);
+  res.status(500).json({ error: 'Internal server error' });
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('Received SIGTERM, shutting down gracefully');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('Received SIGINT, shutting down gracefully');
+  process.exit(0);
+});
+
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`Schema processor listening on port ${PORT}`);
+});

package/templates/worker/src/UserObject.ts

@@ -0,0 +1,40 @@
+import { DurableObject } from 'cloudflare:workers';
+
+export interface UserPresence {
+	forwardNotification(message: object): Promise<void>;
+}
+
+export class UserPresenceDO extends DurableObject implements UserPresence {
+	async fetch(request: Request) {
+		if (request.headers.get('Upgrade') !== 'websocket') {
+			return new Response('Expected WebSocket', { status: 400 });
+		}
+
+		const pair = new WebSocketPair();
+		const [client, server] = Object.values(pair);
+
+		this.ctx.acceptWebSocket(server);
+
+		return new Response(null, { status: 101, webSocket: client });
+	}
+
+	// This method will be called by other Durable Objects (the WebSocketSyncEngine)
+	async forwardNotification(message: object): Promise<void> {
+		console.log(`[UserPresenceDO] Forwarding notification:`, message);
+		const messageString = JSON.stringify(message);
+
+		// Broadcast to all sessions for this user (e.g., laptop and phone)
+		for (const ws of this.ctx.getWebSockets()) {
+			try {
+				ws.send(messageString);
+			} catch (e) {
+				// The socket might be closing. This is normal.
+				console.warn('[UserPresenceDO] Failed to send to a closing socket.');
+			}
+		}
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		console.log(`[UserPresenceDO] Socket closed. Code: ${code}, Reason: ${reason}`);
+	}
+}

package/templates/worker/src/auth.ts

@@ -0,0 +1,58 @@
+import { sign, verify } from '@tsndr/cloudflare-worker-jwt';
+
+export class AuthError extends Error {
+	constructor(
+		message: string,
+		public status: number,
+	) {
+		super(message);
+		this.name = 'AuthError';
+	}
+}
+
+type AuthResult = {
+	success: boolean;
+	valid: boolean;
+	tenantId: number;
+	serviceId: number;
+	scopes: string[];
+};
+
+export class AuthService {
+	constructor(
+		private jwtSecret: string,
+		private authSecret: string,
+	) {}
+
+	async validateApiKey(apiKey: string): Promise<AuthResult> {
+		if (apiKey !== this.authSecret) {
+			return { success: false, valid: false, tenantId: 0, serviceId: 0, scopes: [] };
+		}
+
+		return {
+			success: true,
+			valid: true,
+			tenantId: 1,
+			serviceId: 1,
+			scopes: ['*'],
+		};
+	}
+
+	extractBearerToken(request: Request): string {
+		const authHeader = request.headers.get('Authorization');
+		if (!authHeader || !authHeader.startsWith('Bearer ')) {
+			throw new AuthError('Missing or invalid authorization header', 401);
+		}
+		return authHeader.substring(7);
+	}
+
+	async verifyToken(token: string): Promise<any> {
+		const isValid = await verify(token, this.jwtSecret);
+		if (!isValid) throw new AuthError('Invalid token', 401);
+		return JSON.parse(atob(token.split('.')[1]));
+	}
+
+	async signToken(payload: Record<string, any>): Promise<string> {
+		return sign(payload, this.jwtSecret);
+	}
+}