@nyaruka/temba-components 0.129.7 → 0.129.9

package/web-dev-server.config.mjs

@@ -3,14 +3,26 @@ import { fromRollup } from '@web/dev-server-rollup';
 import fs from 'fs';
 import path from 'path';
 
+// Import the shared flow info generator and Minio functionality
+import { generateFlowInfo, handleMinioUpload, handleLabelCreation } from './web-dev-mock.mjs';
+
 const replacePlugin = fromRollup(replace);
 
+// Simple wrapper function to use the shared flow info generator
+function generateFlowMetadata(flowDefinition) {
+  return generateFlowInfo(flowDefinition);
+}
+
 export default {
   nodeResolve: true,
   plugins: [
     replacePlugin({
       preventAssignment: true,
       'process.env.NODE_ENV': JSON.stringify('development'),
+      'process.env.MINIO_ENDPOINT': JSON.stringify('http://minio:9000'),
+      'process.env.MINIO_PUBLIC_ENDPOINT': JSON.stringify('http://localhost:9000'),
+      'process.env.MINIO_ACCESS_KEY': JSON.stringify('root'),
+      'process.env.MINIO_SECRET_KEY': JSON.stringify('tembatemba'),
     }),
     {
       name: 'api-mock-server',
@@ -20,9 +32,10 @@ export default {
           // Map API endpoints to static files
           const apiMappings = {
             '/api/v2/groups.json': './static/api/groups.json',
+            '/api/v2/labels.json': './static/api/labels.json',
             '/api/v2/fields.json': './static/api/fields.json', 
             '/api/v2/globals.json': './static/api/globals.json',
-            '/api/v2/completion.json': './static/api/completion.json',
+            '/api/v2/completion.json': './static/mr/docs/en-us/editor.json',
             '/api/v2/functions.json': './static/api/functions.json',
             '/api/internal/templates.json': './static/api/templates.json',
             '/api/v2/media.json': './static/api/media.json',
@@ -44,6 +57,16 @@ export default {
             return;
           }
         }
+
+        // Handle minio file uploads for media
+        if (context.request.method === 'POST' && context.path === '/api/v2/media.json') {
+          return handleMinioUpload(context);
+        }
+
+        // Handle label creation
+        if (context.request.method === 'POST' && context.path === '/api/v2/labels.json') {
+          return handleLabelCreation(context);
+        }
       }
     },
     {
@@ -80,15 +103,48 @@ export default {
             context.req.on('end', () => {
               context.contentType = 'application/json';
               if (body) {
+                const flowDefinition = JSON.parse(body);
                 fs.writeFileSync(
                   path.resolve(`./demo/data/flows/${uuid}.json`),
-                  JSON.stringify({ definition: JSON.parse(body) }, null, 2)
+                  JSON.stringify({ definition: flowDefinition }, null, 2)
                 );
-                context.body = {
+                
+                // Generate metadata similar to production
+                const metadata = generateFlowMetadata(flowDefinition);
+                
+                const response = {
                   status: 'success',
-                  message: `Flow ${uuid} saved successfully.`,
-                  definition: JSON.parse(body),
+                  saved_on: new Date().toISOString(),
+                  revision: {
+                    id: Math.floor(Math.random() * 1000) + 1,
+                    user: {
+                      email: 'admin1@textit.com',
+                      name: 'Adam McAdmin'
+                    },
+                    created_on: new Date().toISOString(),
+                    version: flowDefinition.spec_version || '14.3.0',
+                    revision: (flowDefinition.revision || 0) + 1
+                  },
+                  info: {
+                    counts: metadata.counts,
+                    dependencies: metadata.dependencies,
+                    locals: metadata.locals,
+                    results: metadata.results,
+                    parent_refs: [],
+                    issues: []
+                  },
+                  issues: [],
+                  metadata: {
+                    counts: metadata.counts,
+                    dependencies: metadata.dependencies,
+                    locals: metadata.locals,
+                    results: metadata.results,
+                    parent_refs: [],
+                    issues: []
+                  }
                 };
+                
+                context.body = JSON.stringify(response);
                 context.status = 200;
               } else {
                 console.log(`No body received for flow ${uuid}.`);
@@ -107,10 +163,22 @@ export default {
           const parts = context.path.split('/');
           const uuid = parts[3];
           context.contentType = 'application/json';
-          context.body = fs.readFileSync(
+          
+          // Read the flow definition from file
+          const flowFileContent = fs.readFileSync(
             path.resolve(`./demo/data/flows/${uuid}.json`),
             'utf-8',
           );
+          
+          const flowData = JSON.parse(flowFileContent);
+          
+          if (flowData.definition) {
+            const info = generateFlowMetadata(flowData.definition);
+            context.body = JSON.stringify({
+              definition: flowData.definition,
+              info: info
+            });
+          }
         }
       }
     }

package/web-test-runner.config.mjs

@@ -13,6 +13,7 @@ import rimraf from 'rimraf';
 
 import replace from '@rollup/plugin-replace';
 import { fromRollup } from '@web/dev-server-rollup';
+
 const replacePlugin = fromRollup(replace);
 
 const SCREENSHOTS = 'screenshots';
@@ -151,10 +152,14 @@ const wireScreenshots = async (page, context, wait, replaceScreenshots) => {
         const truthFile = await getPath(TRUTH, filename);
 
         // Only wait for network idle if explicitly requested
-        if (wait) {
-          await page.waitForNetworkIdle();
-        } else {
-          await page.waitForNetworkIdle({ idleTime: 100, timeout: 1000 });
+        try{
+          if (wait) {
+            await page.waitForNetworkIdle({idleTime: 500, timeout: 2000});
+          } else {
+            await page.waitForNetworkIdle({ idleTime: 100, timeout: 1000 });
+          }
+        } catch (error) {
+          console.error('Error waiting for network idle, proceeding: ' + filename);
         }
 
         if (!(await fileExists(truthFile))) {