cogsbox-sync 0.0.1

package/templates/worker/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "my-sync-worker",
+  "version": "0.0.1",
+  "scripts": {
+    "init": "tsx bin/init.ts",
+    "init:deploy": "tsx bin/init.ts --deploy",
+    "deploy": "wrangler deploy",
+    "dev": "wrangler dev --port 8788",
+    "start": "wrangler dev",
+    "test": "vitest",
+    "cf-typegen": "wrangler types"
+  },
+  "devDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.12.12",
+    "@cloudflare/workers-types": "^4.20260214.0",
+    "@vitest/runner": "3.2.4",
+    "@vitest/snapshot": "3.2.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "~3.2.4",
+    "wrangler": "^4.65.0"
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@cloudflare/containers": "^0.1.0",
+    "@tsndr/cloudflare-worker-jwt": "^3.2.1",
+    "cogsbox-shape": "^0.5.158",
+    "fast-json-patch": "^3.1.1"
+  }
+}

package/templates/worker/schema-processor/Dockerfile

@@ -0,0 +1,16 @@
+# schema-processor/Dockerfile
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy package.json first
+COPY package.json ./
+RUN npm install
+
+# Copy server code
+COPY server.js ./
+
+# Expose the port
+EXPOSE 8080
+
+CMD ["node", "server.js"]

package/templates/worker/schema-processor/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "schema-processor",
+  "version": "1.0.0",
+  "dependencies": {
+    "hono":"^4.10.4"
+  },  
+  "devDependencies": {
+    "@hono/node-server": "^1.19.6"
+  }
+}

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

@@ -0,0 +1,483 @@
+// schema-processor/server.js - Hono version
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import fs from 'fs';
+
+const app = new Hono();
+
+// Enable CORS if needed
+app.use('*', cors());
+
+// In-memory cache for schemas per tenant
+const schemaCache = new Map();
+
+// Utility function to safely import schema module
+async function importSchemaModule(filePath) {
+  try {
+
+    
+    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;
+}
+
+// Health check endpoint
+app.get('/health', (c) => {
+  return c.json({ 
+    status: 'healthy', 
+    timestamp: new Date().toISOString(),
+    cachedSchemas: Array.from(schemaCache.keys())
+  });
+});
+
+// GET endpoint to check schema status
+app.get('/load-schema', async (c) => {
+  try {
+    const tenantId = c.req.query('tenantId');
+    
+    if (!tenantId) {
+      return c.json({ error: 'tenantId is required' }, 400);
+    }
+    
+    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);
+      }
+    }
+    
+    return c.json({ 
+      hasSchema: !!schema,
+      schemaKeys: schemaKeys
+    });
+  } catch (error) {
+    console.error('Error in GET /load-schema:', error);
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// POST endpoint to load/update schema
+app.post('/load-schema', async (c) => {
+  try {
+    const tenantId = c.req.query('tenantId');
+    const { bundledCode } = await c.req.json();
+    
+    if (!tenantId) {
+      return c.json({ error: 'tenantId is required' }, 400);
+    }
+    
+    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);
+      }
+    }
+    
+    return c.json({ 
+      success: true,
+      hasSchema: !!schema,
+      schemaKeys: schemaKeys
+    });
+  } catch (error) {
+    console.error('Error loading schema:', error);
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Validate endpoint
+app.post('/validate', async (c) => {
+  try {
+    const { data, schemaKey, bundledCode, context } = await c.req.json();
+    const tenantId = c.req.query('tenantId');
+ 
+    if (!tenantId || !schemaKey || data === undefined || !bundledCode) {
+      return c.json({ 
+        valid: false, 
+        errors: [{ path: [], message: 'Missing tenantId, schemaKey, data, or bundledCode' }] 
+      }, 400);
+    }
+ 
+    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 c.json({
+        valid: false,
+        errors: [{ path: [], message: `Schema '${schemaKey}' not found within the provided bundle.` }]
+      }, 404);
+    }
+
+    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 || {});
+
+    if (!result.success) {
+      return c.json({
+        valid: false,
+        errors: result.error.issues // Using the correct "issues" property from Zod
+      }, 422);
+    }
+
+    return c.json({ valid: true, errors: [] });
+
+  } catch (error) {
+    console.error('[Container] /validate Error:', error);
+    if (error.name === 'ZodError') {
+      return c.json({
+        valid: false,
+        errors: error.issues
+      }, 422);
+    }
+    return c.json({ 
+      valid: false, 
+      errors: [{ path: [], message: error.message }] 
+    }, 500);
+  }
+});
+
+// Validate path endpoint
+app.post('/validate-path', async (c) => {
+  try {
+    const { path, value, schemaKey, bundledCode } = await c.req.json();
+    const tenantId = c.req.query('tenantId');
+
+    if (!tenantId || !schemaKey || !bundledCode || !path) {
+      return c.json({ 
+        valid: false, 
+        errors: [{ path: [], message: 'Missing required parameters' }] 
+      }, 400);
+    }
+
+    // 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 c.json({
+        valid: false,
+        errors: [{ path: [], message: `Schema '${schemaKey}' not found` }]
+      }, 404);
+    }
+
+    if (!schemaDefinition.schemas || !schemaDefinition.schemas.validation) {
+      return c.json({
+        valid: false,
+        errors: [{ path: [], message: `Validation schema not found for '${schemaKey}'` }]
+      }, 404);
+    }
+
+    // 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 c.json({ valid: true });
+        }
+      } 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 c.json({ valid: true });
+        }
+      }
+      
+      if (!fieldValidator) {
+        return c.json({ valid: true });
+      }
+    }
+
+    // Validate the value
+    const result = fieldValidator.safeParse(value);
+    
+    if (!result.success) {
+      return c.json({
+        valid: false,
+        errors: result.error.issues.map(issue => ({
+          path: issue.path,
+          message: issue.message,
+          code: issue.code
+        }))
+      }, 422);
+    }
+
+    return c.json({ valid: true, errors: [] });
+
+  } catch (error) {
+    console.error('[Container] /validate-path Error:', error);
+    return c.json({ 
+      valid: false, 
+      errors: [{ path: [], message: error.message }] 
+    }, 500);
+  }
+});
+
+// Get API routes endpoint
+app.post('/get-api-routes', async (c) => {
+  try {
+    const { tenantId, schemaKey, bundledCode, params } = await c.req.json();
+
+    if (!tenantId || !schemaKey || !bundledCode) {
+      return c.json({ error: 'Missing tenantId, schemaKey, or bundledCode' }, 400);
+    }
+    
+    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 c.json({ error: `Schema '${justSchemaKey}' not found in bundle.` }, 404);
+    }
+
+    const apiConfig = schemaDefinition.api || {};
+    
+    // Process both queryData and mutateData with the same logic
+    const processApiConfig = (config) => {
+      if (!config) return null;
+      
+      if (config && typeof config.handler === 'function') {
+        if (!params || typeof params !== 'object') {
+          throw new Error('Missing or invalid params object for parameterized route.');
+        }
+
+        const validationResult = schemaDefinition.validateApiParams(config, params);
+
+        if (!validationResult.success) {
+          throw new Error(`API parameter validation failed: ${JSON.stringify(validationResult.error.flatten())}`);
+        }
+        
+        const result = config.handler(validationResult.data);
+        
+        if (typeof result === 'string') {
+          return { url: result, method: 'GET' };
+        } else if (result && typeof result === 'object' && result.url) {
+          return {
+            url: result.url,
+            method: result.data ? 'POST' : 'GET',
+            data: result.data
+          };
+        }
+        
+        throw new Error('Invalid handler return value');
+      } else if (typeof config === 'string') {
+        return { url: config, method: 'GET' };
+      }
+      
+      return null;
+    };
+
+    try {
+      const queryConfig = processApiConfig(apiConfig.queryData);
+      const mutateConfig = processApiConfig(apiConfig.mutateData);
+      
+      return c.json({
+        queryData: queryConfig,
+        mutateData: mutateConfig
+      });
+    } catch (error) {
+      return c.json({ error: error.message }, 400);
+    }
+
+  } catch (error) {
+    console.error('[Container] /get-api-routes Error:', error);
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Process notifications batch endpoint
+app.post('/process-notifications-batch', async (c) => {
+  try {
+    const { bundledCode, fullState, contexts, operation } = await c.req.json();
+    const tenantId = c.req.query('tenantId');
+    
+    if (!tenantId || !bundledCode || !fullState || !Array.isArray(contexts)) {
+      return c.json({ error: 'Missing tenantId, bundledCode, fullState, or contexts array' }, 400);
+    }
+
+    const tempFile = `/tmp/schema-${tenantId}-${Date.now()}.mjs`;
+    fs.writeFileSync(tempFile, bundledCode);
+    const schemaModule = await importSchemaModule(tempFile);
+    fs.unlinkSync(tempFile);
+
+    const schema = schemaModule.syncSchema;
+    if (!schema) {
+      return c.json({ error: 'syncSchema not found in the provided bundle.' }, 404);
+    }
+
+    const notificationFunctions = schema.notifications;
+    if (!notificationFunctions) {
+      return c.json({});
+    }
+
+    const notificationsByUserId = {};
+
+    for (const context of contexts) {
+      if (!context || !context.userId) continue;
+
+      const matchedNotificationsForUser = [];
+
+      for (const channelName in notificationFunctions) {
+        try {
+          const notificationFn = notificationFunctions[channelName];
+          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);
+        }
+      }
+
+      if (matchedNotificationsForUser.length > 0) {
+        notificationsByUserId[context.userId] = matchedNotificationsForUser;
+      }
+    }
+    
+    return c.json(notificationsByUserId);
+
+  } catch (error) {
+    console.error('[Container] /process-notifications-batch Error:', error);
+    return c.json({ 
+      error: 'Internal server error processing notification batch', 
+      details: error.message 
+    }, 500);
+  }
+});
+
+// Error handling
+app.onError((err, c) => {
+  console.error('Unhandled error:', err);
+  return c.json({ error: 'Internal server error' }, 500);
+});
+
+// Graceful shutdown handlers
+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);
+});
+
+// Export for Cloudflare Container or start server for Node.js
+const PORT = process.env.PORT || 8080;
+
+// For Cloudflare Container Runtime
+export default {
+  fetch: app.fetch,
+};
+
+// For Node.js runtime (if needed for local testing)
+if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+  const { serve } = await import('@hono/node-server');
+  serve({
+    fetch: app.fetch,
+    port: PORT,
+  });
+  console.log(`Schema processor listening on port ${PORT}`);
+}