npm - windmill-cli - Versions diffs - 1.597.1 → 1.599.0 - Mend

windmill-cli 1.597.1 → 1.599.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (251) hide show

package/esm/src/commands/app/dev.js CHANGED Viewed

@@ -1,13 +1,13 @@
 // deno-lint-ignore-file no-explicit-any
 import * as dntShim from "../../../_dnt.shims.js";
-import { Command, colors, log, getPort, open, windmillUtils, yamlParseFile, SEP, } from "../../../deps.js";
+import { colors, Command, getPort, log, open, SEP, windmillUtils, yamlParseFile, } from "../../../deps.js";
 import * as http from "node:http";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import process from "node:process";
 import { writeFileSync } from "node:fs";
-import { WebSocketServer } from "ws";
-import { getDevBuildOptions, ensureNodeModules, createFrameworkPlugins, detectFrameworks, } from "./bundle.js";
+import { WebSocket, WebSocketServer } from "ws";
+import { createFrameworkPlugins, detectFrameworks, ensureNodeModules, getDevBuildOptions, } from "./bundle.js";
 import { wmillTsDev as wmillTs } from "./wmillTsDev.js";
 import * as wmill from "../../../gen/services.gen.js";
 import { resolveWorkspace } from "../../core/context.js";
@@ -16,9 +16,10 @@ import { GLOBAL_CONFIG_OPT } from "../../core/conf.js";
 import { replaceInlineScripts } from "./app.js";
 import { APP_BACKEND_FOLDER, inferRunnableSchemaFromFile, } from "./app_metadata.js";
 import { loadRunnablesFromBackend } from "./raw_apps.js";
+import { regenerateAgentDocs } from "./generate_agents.js";
 const DEFAULT_PORT = 4000;
 const DEFAULT_HOST = "localhost";
-// HTML template with live reload
+// HTML template with live reload and SQL migration modal
 const createHTML = (jsPath, cssPath) => `
 <!DOCTYPE html>
 <html lang="en">
@@ -43,10 +44,136 @@ const createHTML = (jsPath, cssPath) => `
       width: 100%;
       height: 100vh;
     }
+    /* SQL Migration Modal Styles */
+    .sql-modal-overlay {
+      display: none;
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background: rgba(0, 0, 0, 0.5);
+      z-index: 10000;
+      justify-content: center;
+      align-items: center;
+    }
+    .sql-modal-overlay.visible {
+      display: flex;
+    }
+    .sql-modal {
+      background: white;
+      border-radius: 8px;
+      max-width: 700px;
+      width: 90%;
+      max-height: 80vh;
+      display: flex;
+      flex-direction: column;
+      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+    }
+    .sql-modal-header {
+      padding: 16px 20px;
+      border-bottom: 1px solid #e0e0e0;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .sql-modal-header h2 {
+      margin: 0;
+      font-size: 18px;
+      color: #333;
+    }
+    .sql-modal-header .close-btn {
+      background: none;
+      border: none;
+      font-size: 24px;
+      cursor: pointer;
+      color: #666;
+    }
+    .sql-modal-body {
+      padding: 20px;
+      overflow-y: auto;
+      flex: 1;
+    }
+    .sql-modal-body p {
+      margin-bottom: 12px;
+      color: #555;
+    }
+    .sql-modal-body pre {
+      background: #f5f5f5;
+      padding: 12px;
+      border-radius: 4px;
+      overflow-x: auto;
+      font-size: 13px;
+      max-height: 300px;
+      overflow-y: auto;
+    }
+    .sql-modal-footer {
+      padding: 16px 20px;
+      border-top: 1px solid #e0e0e0;
+      display: flex;
+      justify-content: flex-end;
+      gap: 12px;
+    }
+    .sql-modal-footer button {
+      padding: 10px 20px;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 14px;
+    }
+    .sql-modal-footer .cancel-btn {
+      background: #f0f0f0;
+      border: 1px solid #ccc;
+      color: #333;
+    }
+    .sql-modal-footer .apply-btn {
+      background: #3b82f6;
+      border: none;
+      color: white;
+    }
+    .sql-modal-footer .apply-btn:hover {
+      background: #2563eb;
+    }
+    .sql-modal-footer .apply-btn:disabled {
+      background: #9ca3af;
+      cursor: not-allowed;
+    }
+    .sql-result {
+      margin-top: 12px;
+      padding: 12px;
+      border-radius: 4px;
+    }
+    .sql-result.success {
+      background: #dcfce7;
+      color: #166534;
+    }
+    .sql-result.error {
+      background: #fee2e2;
+      color: #991b1b;
+    }
   </style>
 </head>
 <body>
   <div id="root"></div>
+  <!-- SQL Migration Modal -->
+  <div id="sql-modal-overlay" class="sql-modal-overlay">
+    <div class="sql-modal">
+      <div class="sql-modal-header">
+        <h2>Apply SQL Migration</h2>
+        <button class="close-btn" onclick="closeSqlModal()">&times;</button>
+      </div>
+      <div class="sql-modal-body">
+        <p><strong>File:</strong> <span id="sql-file-name"></span></p>
+        <p><strong>Datatable:</strong> <span id="sql-datatable"></span></p>
+        <p><strong>SQL to execute:</strong></p>
+        <pre id="sql-content"></pre>
+        <div id="sql-result"></div>
+      </div>
+      <div class="sql-modal-footer">
+        <button class="cancel-btn" onclick="closeSqlModal()">Cancel</button>
+        <button class="apply-btn" id="apply-sql-btn" onclick="applySql()">Apply SQL</button>
+      </div>
+    </div>
+  </div>
   <script src="${jsPath}"></script>
   <script>
     // Live reload via EventSource
@@ -58,6 +185,89 @@ const createHTML = (jsPath, cssPath) => `
     evtSource.addEventListener('error', () => {
       console.log('⚠️ Lost connection to dev server, retrying...');
     });
+    // SQL Migration Modal handling
+    let pendingSqlMigration = null;
+    let sqlWebSocket = null;
+    function initSqlWebSocket() {
+      const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+      sqlWebSocket = new WebSocket(wsProtocol + '//' + location.host);
+      sqlWebSocket.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        if (data.type === 'sqlMigration') {
+          showSqlModal(data);
+        } else if (data.type === 'sqlMigrationResult') {
+          showSqlResult(data);
+        }
+      };
+      sqlWebSocket.onclose = () => {
+        // Reconnect after a delay
+        setTimeout(initSqlWebSocket, 1000);
+      };
+    }
+    function showSqlModal(data) {
+      pendingSqlMigration = data;
+      document.getElementById('sql-file-name').textContent = data.fileName;
+      document.getElementById('sql-datatable').textContent = data.datatable || 'Not configured';
+      document.getElementById('sql-content').textContent = data.sql;
+      document.getElementById('sql-result').innerHTML = '';
+      document.getElementById('apply-sql-btn').disabled = !data.datatable;
+      document.getElementById('sql-modal-overlay').classList.add('visible');
+    }
+    function closeSqlModal(skip = true) {
+      if (skip && pendingSqlMigration && sqlWebSocket) {
+        // Notify server that user skipped this file
+        sqlWebSocket.send(JSON.stringify({
+          type: 'skipSqlMigration',
+          fileName: pendingSqlMigration.fileName
+        }));
+      }
+      document.getElementById('sql-modal-overlay').classList.remove('visible');
+      pendingSqlMigration = null;
+    }
+    function applySql() {
+      if (!pendingSqlMigration || !sqlWebSocket) return;
+      document.getElementById('apply-sql-btn').disabled = true;
+      document.getElementById('apply-sql-btn').textContent = 'Applying...';
+      sqlWebSocket.send(JSON.stringify({
+        type: 'applySqlMigration',
+        fileName: pendingSqlMigration.fileName,
+        sql: pendingSqlMigration.sql,
+        datatable: pendingSqlMigration.datatable
+      }));
+    }
+    function showSqlResult(data) {
+      const resultDiv = document.getElementById('sql-result');
+      if (data.error) {
+        resultDiv.className = 'sql-result error';
+        resultDiv.innerHTML = '<strong>Error:</strong> ' + escapeHtml(data.message);
+        document.getElementById('apply-sql-btn').disabled = false;
+        document.getElementById('apply-sql-btn').textContent = 'Apply SQL';
+      } else {
+        resultDiv.className = 'sql-result success';
+        resultDiv.innerHTML = '<strong>Success!</strong> SQL applied and file deleted.';
+        // Auto-close after success (don't send skip since server already handled it)
+        setTimeout(() => closeSqlModal(false), 1500);
+      }
+    }
+    function escapeHtml(text) {
+      const div = document.createElement('div');
+      div.textContent = text;
+      return div.innerHTML;
+    }
+    // Initialize WebSocket for SQL migrations
+    initSqlWebSocket();
   </script>
 </body>
 </html>
@@ -97,7 +307,9 @@ async function dev(opts) {
     const shouldOpen = opts.open ?? true;
     // Detect frameworks to determine default entry point
     const frameworks = detectFrameworks(process.cwd());
-    const defaultEntry = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
+    const defaultEntry = frameworks.svelte || frameworks.vue
+        ? "index.ts"
+        : "index.tsx";
     const entryPoint = opts.entry ?? defaultEntry;
     // Verify entry point exists
     if (!fs.existsSync(entryPoint)) {
@@ -321,8 +533,128 @@ async function dev(opts) {
     });
     // Create WebSocket server on the same HTTP server
     const wss = new WebSocketServer({ server });
-    wss.on("connection", (ws) => {
+    // SQL migration state (defined here so it's accessible in WebSocket handler)
+    const sqlToApplyPath = path.join(process.cwd(), "sql_to_apply");
+    const sqlFileQueue = [];
+    let currentSqlFile = null;
+    // Helper to read datatable from raw_app.yaml
+    async function getDatatableConfig() {
+        try {
+            const rawApp = (await yamlParseFile(path.join(process.cwd(), "raw_app.yaml")));
+            return rawApp?.data?.datatable;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Helper to broadcast SQL migration notification to all WebSocket clients
+    function broadcastSqlMigration(fileName, sql, datatable) {
+        const message = JSON.stringify({
+            type: "sqlMigration",
+            fileName,
+            sql,
+            datatable,
+        });
+        wss.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+            }
+        });
+    }
+    // Helper to add a SQL file to the queue (if not already queued)
+    function queueSqlFile(filePath) {
+        if (currentSqlFile === filePath) {
+            return; // Already being shown
+        }
+        if (sqlFileQueue.includes(filePath)) {
+            return; // Already in queue
+        }
+        sqlFileQueue.push(filePath);
+    }
+    // Helper to process the next SQL file in the queue
+    async function processNextSqlFile() {
+        if (currentSqlFile !== null) {
+            // Already showing a file, wait for it to be processed
+            return;
+        }
+        if (sqlFileQueue.length === 0) {
+            return;
+        }
+        const filePath = sqlFileQueue.shift();
+        // Check if file still exists (might have been deleted)
+        if (!fs.existsSync(filePath)) {
+            log.info(colors.gray(`File no longer exists: ${path.basename(filePath)}`));
+            // Try next file
+            await processNextSqlFile();
+            return;
+        }
+        currentSqlFile = filePath;
+        const fileName = path.basename(filePath);
+        try {
+            const sqlContent = await dntShim.Deno.readTextFile(filePath);
+            if (!sqlContent.trim()) {
+                log.info(colors.gray(`Skipping empty file: ${fileName}`));
+                currentSqlFile = null;
+                await processNextSqlFile();
+                return;
+            }
+            const datatable = await getDatatableConfig();
+            log.info(colors.magenta(`📋 SQL file ready: ${fileName} (datatable: ${datatable || "not configured"}) [${sqlFileQueue.length} more in queue]`));
+            broadcastSqlMigration(fileName, sqlContent, datatable);
+        }
+        catch (error) {
+            log.error(colors.red(`Error reading SQL file: ${error.message}`));
+            currentSqlFile = null;
+            await processNextSqlFile();
+        }
+    }
+    // Helper to handle SQL file completion (success or skip)
+    async function onSqlFileCompleted(filePath, deleteFile) {
+        if (deleteFile && fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+                log.info(colors.green(`✓ Deleted: ${path.basename(filePath)}`));
+            }
+            catch (error) {
+                log.error(colors.red(`Failed to delete ${path.basename(filePath)}: ${error.message}`));
+            }
+        }
+        currentSqlFile = null;
+        // Process next file in queue
+        await processNextSqlFile();
+    }
+    wss.on("connection", async (ws) => {
         log.info(colors.cyan("[WebSocket] Client connected"));
+        // If there's a current SQL file being shown, send it to the new client
+        if (currentSqlFile && fs.existsSync(currentSqlFile)) {
+            try {
+                const sqlContent = await dntShim.Deno.readTextFile(currentSqlFile);
+                const datatable = await getDatatableConfig();
+                const fileName = path.basename(currentSqlFile);
+                ws.send(JSON.stringify({
+                    type: "sqlMigration",
+                    fileName,
+                    sql: sqlContent,
+                    datatable,
+                }));
+                log.info(colors.magenta(`📋 Sent pending SQL file to new client: ${fileName}`));
+            }
+            catch {
+                // File might have been deleted, ignore
+            }
+        }
+        else if (fs.existsSync(sqlToApplyPath)) {
+            // No current file, but check if there are files to process
+            const entries = fs.readdirSync(sqlToApplyPath);
+            const sqlFiles = entries.filter((entry) => entry.endsWith(".sql"));
+            if (sqlFiles.length > 0 && sqlFileQueue.length === 0) {
+                // Queue and process files
+                for (const sqlFile of sqlFiles.sort()) {
+                    queueSqlFile(path.join(sqlToApplyPath, sqlFile));
+                }
+                await processNextSqlFile();
+            }
+        }
         ws.on("message", async (data) => {
             try {
                 const message = JSON.parse(data.toString());
@@ -412,6 +744,72 @@ async function dev(opts) {
                         }
                         break;
                     }
+                    case "applySqlMigration": {
+                        // Execute SQL migration against a datatable
+                        const { sql, datatable, fileName } = message;
+                        log.info(colors.blue(`[SQL Migration] Applying SQL from ${fileName} to datatable: ${datatable}`));
+                        if (!datatable) {
+                            ws.send(JSON.stringify({
+                                type: "sqlMigrationResult",
+                                error: true,
+                                message: "No datatable configured. Set data.datatable in raw_app.yaml.",
+                            }));
+                            break;
+                        }
+                        try {
+                            // Run SQL as a preview script against the datatable
+                            const uuid = await wmill.runScriptPreview({
+                                workspace: workspaceId,
+                                requestBody: {
+                                    language: "postgresql",
+                                    content: sql,
+                                    args: { database: `datatable://${datatable}` },
+                                },
+                            });
+                            log.info(colors.gray(`[SQL Migration] Job started: ${uuid}`));
+                            // Wait for the result
+                            const result = await waitForJob(workspaceId, uuid);
+                            log.info(colors.green(`[SQL Migration] SQL applied successfully`));
+                            ws.send(JSON.stringify({
+                                type: "sqlMigrationResult",
+                                error: false,
+                                result,
+                            }));
+                            // Delete the SQL file and process next in queue
+                            if (currentSqlFile) {
+                                await onSqlFileCompleted(currentSqlFile, true);
+                            }
+                            // Regenerate AGENTS.md and DATATABLES.md to reflect schema changes
+                            try {
+                                await regenerateAgentDocs(workspaceId, process.cwd(), true);
+                                log.info(colors.gray(`[SQL Migration] Refreshed AGENTS.md and DATATABLES.md`));
+                            }
+                            catch (regenError) {
+                                log.warn(colors.yellow(`[SQL Migration] Could not refresh docs: ${regenError.message}`));
+                            }
+                        }
+                        catch (error) {
+                            log.error(colors.red(`[SQL Migration] Error: ${error.message}`));
+                            ws.send(JSON.stringify({
+                                type: "sqlMigrationResult",
+                                error: true,
+                                message: error.message || String(error),
+                            }));
+                            // Don't delete file on error, but clear current so user can retry
+                            currentSqlFile = null;
+                        }
+                        break;
+                    }
+                    case "skipSqlMigration": {
+                        // User chose to skip this SQL file
+                        const { fileName } = message;
+                        log.info(colors.yellow(`[SQL Migration] Skipped: ${fileName}`));
+                        // Don't delete file, just move to next
+                        if (currentSqlFile) {
+                            await onSqlFileCompleted(currentSqlFile, false);
+                        }
+                        break;
+                    }
                     default:
                         log.warn(colors.yellow(`[WebSocket] Unknown message type: ${type}`));
                         respond("error", { message: `Unknown message type: ${type}` }, true);
@@ -428,6 +826,82 @@ async function dev(opts) {
             log.error(colors.red(`[WebSocket] Error: ${error.message}`));
         });
     });
+    // Watch sql_to_apply folder for SQL migration files
+    let sqlWatcher;
+    // Helper to scan for existing SQL files and add them to the queue
+    async function scanExistingSqlFiles() {
+        if (!fs.existsSync(sqlToApplyPath)) {
+            return;
+        }
+        try {
+            const entries = fs.readdirSync(sqlToApplyPath);
+            const sqlFiles = entries
+                .filter((entry) => entry.endsWith(".sql"))
+                .sort(); // Sort alphabetically to process in order
+            if (sqlFiles.length === 0) {
+                return;
+            }
+            log.info(colors.blue(`🔍 Found ${sqlFiles.length} SQL file(s) in sql_to_apply/`));
+            // Add each SQL file to the queue
+            for (const sqlFile of sqlFiles) {
+                const filePath = path.join(sqlToApplyPath, sqlFile);
+                queueSqlFile(filePath);
+            }
+            // Start processing the queue
+            await processNextSqlFile();
+        }
+        catch (error) {
+            log.error(colors.red(`Error scanning sql_to_apply folder: ${error.message}`));
+        }
+    }
+    if (fs.existsSync(sqlToApplyPath)) {
+        log.info(colors.blue(`🗃️  Watching sql_to_apply folder at: ${sqlToApplyPath}\n`));
+        sqlWatcher = dntShim.Deno.watchFs(sqlToApplyPath);
+        // Debounce timeout for SQL file changes
+        const sqlDebounceTimeouts = {};
+        const SQL_DEBOUNCE_MS = 300;
+        // Handle SQL file changes in the background
+        (async () => {
+            try {
+                for await (const event of sqlWatcher) {
+                    for (const changedPath of event.paths) {
+                        // Only handle .sql files
+                        if (!changedPath.endsWith(".sql")) {
+                            continue;
+                        }
+                        // Only handle modify and create events
+                        if (event.kind !== "modify" && event.kind !== "create") {
+                            continue;
+                        }
+                        const fileName = path.basename(changedPath);
+                        // Debounce per file
+                        if (sqlDebounceTimeouts[changedPath]) {
+                            clearTimeout(sqlDebounceTimeouts[changedPath]);
+                        }
+                        sqlDebounceTimeouts[changedPath] = setTimeout(async () => {
+                            delete sqlDebounceTimeouts[changedPath];
+                            log.info(colors.cyan(`📋 SQL file detected: ${fileName}`));
+                            // Add to queue and process
+                            queueSqlFile(changedPath);
+                            await processNextSqlFile();
+                        }, SQL_DEBOUNCE_MS);
+                    }
+                }
+            }
+            catch (error) {
+                if (error.name !== "Interrupted") {
+                    log.error(colors.red(`Error watching sql_to_apply: ${error.message}`));
+                }
+            }
+        })();
+        // Scan for existing SQL files after a delay (to let WebSocket clients connect)
+        setTimeout(() => {
+            scanExistingSqlFiles();
+        }, 2000);
+    }
+    else {
+        log.info(colors.gray("ℹ️  No sql_to_apply folder found (will not watch for SQL migrations)\n"));
+    }
     server.listen(port, host, () => {
         const url = `http://${host}:${port}`;
         log.info(colors.bold.green(`🚀 Dev server running at ${url}`));
@@ -458,6 +932,10 @@ async function dev(opts) {
         if (runnablesWatcher) {
             runnablesWatcher.close();
         }
+        // Close SQL watcher if it exists
+        if (sqlWatcher) {
+            sqlWatcher.close();
+        }
         await ctx.dispose();
         process.exit(0);
     });
@@ -535,7 +1013,7 @@ async function loadRunnables() {
 async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
     const requestBody = {
         component: runnableId,
-        args,
+        args: args ?? {},
         force_viewer_static_fields: {},
         force_viewer_one_of_fields: {},
         force_viewer_allow_user_resources: [],
@@ -568,10 +1046,9 @@ async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
     else if (runnable.type === "path" && runnable.runType && runnable.path) {
         // Path-based runnables have type: "path" and runType: "script"|"hubscript"|"flow"
         const prefix = runnable.runType;
-        requestBody.path =
-            prefix !== "hubscript"
-                ? `${prefix}/${runnable.path}`
-                : `script/${runnable.path}`;
+        requestBody.path = prefix !== "hubscript"
+            ? `${prefix}/${runnable.path}`
+            : `script/${runnable.path}`;
     }
     const uuid = await wmill.executeComponent({
         workspace,