windmill-components 1.665.1 → 1.677.1

package/package/hubPaths.json

@@ -25,10 +25,12 @@
 	"deprecated_gitSync_23": "hub/28160/sync-script-to-git-repo-windmill",
 	"deprecated_gitSync_24": "hub/28176/sync-script-to-git-repo-windmill",
 	"deprecated_gitSync_latest": "hub/28180/sync-script-to-git-repo-windmill",
-	"gitSyncTest": "hub/28177/git-repo-test-read-write-windmill",
+	"deprecated_gitSync_25": "hub/28183/sync-script-to-git-repo-windmill",
+	"gitSyncTest": "hub/28184/git-repo-test-read-write-windmill",
 	"gitInitRepo_0": "hub/28134/git-sync%3A-init-repository-windmill",
 	"gitInitRepo_1": "hub/28158/git-sync%3A-init-repository-windmill",
-	"gitInitRepo": "hub/28174/git-sync%3A-init-repository-windmill",
+	"gitInitRepo_2": "hub/28174/git-sync%3A-init-repository-windmill",
+	"gitInitRepo": "hub/28181/git-sync%3A-init-repository-windmill",
 	"slackErrorHandler": "hub/19741/workspace-or-schedule-error-handler-slack",
 	"slackErrorHandler_0": "hub/9079/workspace-or-schedule-error-handler-slack",
 	"slackErrorHandler_1": "hub/9206/workspace-or-schedule-error-handler-slack",
@@ -45,5 +47,6 @@
 	"appReport": "hub/28076/app-report",
 	"cloneRepoToS3forGitRepoViewer_0": "hub/19825/clone_repo_and_upload_to_instance_storage",
 	"cloneRepoToS3forGitRepoViewer_1": "hub/19827/clone_repo_and_upload_to_instance_storage",
-	"cloneRepoToS3forGitRepoViewer": "hub/28175/clone_repo_and_upload_to_instance_storage"
+	"cloneRepoToS3forGitRepoViewer_2": "hub/28175/clone_repo_and_upload_to_instance_storage",
+	"cloneRepoToS3forGitRepoViewer": "hub/28182/clone_repo_and_upload_to_instance_storage"
 }

package/package/infer.d.ts

@@ -2,6 +2,60 @@ import { type AssetUsageAccessType } from './gen';
 import type { Schema, SupportedLanguage } from './common.js';
 import { type AssetWithAccessType } from './components/assets/lib.js';
 export declare function initWasmTs(): Promise<void>;
+export type WacDagNode = {
+    id: string;
+    node_type: {
+        type: 'Step';
+        name: string;
+        script: string;
+    } | {
+        type: 'InlineStep';
+        name: string;
+    } | {
+        type: 'Sleep';
+        seconds: string;
+    } | {
+        type: 'WaitForApproval';
+    } | {
+        type: 'Branch';
+        condition_source: string;
+    } | {
+        type: 'ParallelStart';
+    } | {
+        type: 'ParallelEnd';
+    } | {
+        type: 'LoopStart';
+        iter_source: string;
+    } | {
+        type: 'LoopEnd';
+    } | {
+        type: 'Merge';
+    } | {
+        type: 'Return';
+    };
+    label: string;
+    line: number;
+};
+export type WacDagEdge = {
+    from: string;
+    to: string;
+    label?: string;
+};
+export type WacWorkflowDag = {
+    nodes: WacDagNode[];
+    edges: WacDagEdge[];
+    params: {
+        name: string;
+        typ?: string;
+    }[];
+    source_hash: string;
+};
+export declare function parseWacDag(code: string, language: string): Promise<WacWorkflowDag | {
+    errors: {
+        message: string;
+        line: number;
+    }[];
+} | null>;
 type InferAssetsResult = {
     status: 'ok';
     assets: AssetWithAccessType[];
@@ -19,6 +73,7 @@ export type InferAssetsSqlQueryDetails = {
     source_kind: 'datatable' | 'ducklake';
     source_name: string;
     source_schema?: string;
+    has_raw_interpolation?: boolean;
     prepared?: PreparedAssetsSqlQuery;
 };
 export type PreparedAssetsSqlQuery = {

package/package/infer.js

@@ -14,6 +14,7 @@ import initCSharpParser, { parse_csharp } from 'windmill-parser-wasm-csharp';
 import initNuParser, { parse_nu } from 'windmill-parser-wasm-nu';
 import initJavaParser, { parse_java } from 'windmill-parser-wasm-java';
 import initRubyParser, { parse_ruby } from 'windmill-parser-wasm-ruby';
+import initRParser, { parse_r } from 'windmill-parser-wasm-r';
 import wasmUrlTs from 'windmill-parser-wasm-ts/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlRegex from 'windmill-parser-wasm-regex/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlPy from 'windmill-parser-wasm-py/windmill_parser_wasm_bg.wasm?url';
@@ -25,7 +26,10 @@ import wasmUrlCSharp from 'windmill-parser-wasm-csharp/windmill_parser_wasm_bg.w
 import wasmUrlNu from 'windmill-parser-wasm-nu/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlJava from 'windmill-parser-wasm-java/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlRuby from 'windmill-parser-wasm-ruby/windmill_parser_wasm_bg.wasm?url';
+import wasmUrlR from 'windmill-parser-wasm-r/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlAsset from 'windmill-parser-wasm-asset/windmill_parser_wasm_bg.wasm?url';
+import initWacParser, { parse_workflow_as_code } from 'windmill-parser-wasm-wac';
+import wasmUrlWac from 'windmill-parser-wasm-wac/windmill_parser_wasm_bg.wasm?url';
 import { workspaceStore } from './stores.js';
 import { argSigToJsonSchemaType } from 'windmill-utils-internal';
 import {} from './components/assets/lib.js';
@@ -67,9 +71,36 @@ async function initWasmJava() {
 async function initWasmRuby() {
     await initRubyParser(wasmUrlRuby);
 }
+async function initWasmR() {
+    await initRParser(wasmUrlR);
+}
 async function initWasmAsset() {
     await initAssetParser(wasmUrlAsset);
 }
+let initializeWacPromise = undefined;
+async function initWasmWac() {
+    if (initializeWacPromise == undefined) {
+        initializeWacPromise = initWacParser(wasmUrlWac);
+    }
+    await initializeWacPromise;
+}
+export async function parseWacDag(code, language) {
+    try {
+        await initWasmWac();
+        const raw = parse_workflow_as_code(code, language);
+        const result = JSON.parse(raw);
+        if (result.type === 'success') {
+            return result;
+        }
+        else if (result.type === 'error') {
+            return { errors: result.errors };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseVolumeAnnotations(code, commentPrefix) {
     const volumes = [];
     for (const line of code.split('\n')) {
@@ -93,6 +124,7 @@ function getCommentPrefix(language) {
         case 'powershell':
         case 'ansible':
         case 'ruby':
+        case 'rlang':
             return '#';
         case 'deno':
         case 'bun':
@@ -301,6 +333,15 @@ export async function inferArgs(language, code, schema, mainOverride) {
         else if (language == 'ruby') {
             await initWasmRuby();
             inferedSchema = JSON.parse(parse_ruby(code));
+        }
+        else if (language == 'rlang') {
+            try {
+                await initWasmR();
+                inferedSchema = JSON.parse(parse_r(code));
+            }
+            catch {
+                inferedSchema = parseRSignatureFallback(code);
+            }
             // for related places search: ADD_NEW_LANG
         }
         else {
@@ -334,6 +375,18 @@ export async function inferArgs(language, code, schema, mainOverride) {
             schema.required.push(arg.name);
         }
     }
+    // Store PowerShell CmdletBinding metadata as schema extensions
+    const psSchema = inferedSchema;
+    if (language === 'powershell' && psSchema.has_cmd_binding) {
+        ;
+        schema['x-windmill-ps-cmd-binding'] = true;
+        schema['x-windmill-ps-supports-should-process'] =
+            psSchema.supports_should_process ?? false;
+    }
+    else {
+        delete schema['x-windmill-ps-cmd-binding'];
+        delete schema['x-windmill-ps-supports-should-process'];
+    }
     await tick();
     return {
         auto_kind: inferedSchema.auto_kind,
@@ -417,3 +470,81 @@ export async function parseOutputs(code, ignoreError) {
     }
     return outputs.error ? [] : outputs.outputs;
 }
+/** JS fallback parser for R main() signatures when WASM parser is unavailable. */
+function parseRSignatureFallback(code) {
+    const result = {
+        type: 'Valid',
+        error: '',
+        star_args: false,
+        star_kwargs: false,
+        args: [],
+        has_preprocessor: null,
+        auto_kind: null
+    };
+    const mainMatch = code.match(/\bmain\s*(?:<-|=)\s*function\s*\(([^)]*)\)/);
+    if (!mainMatch) {
+        return result;
+    }
+    const paramsStr = mainMatch[1].trim();
+    if (!paramsStr)
+        return result;
+    // Split params respecting nested parens
+    const params = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of paramsStr) {
+        if ('([{'.includes(ch)) {
+            depth++;
+            current += ch;
+        }
+        else if (')]}'.includes(ch)) {
+            depth--;
+            current += ch;
+        }
+        else if (ch === ',' && depth === 0) {
+            params.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        params.push(current);
+    for (const param of params) {
+        const trimmed = param.trim();
+        if (!trimmed)
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1) {
+            result.args.push({ name: trimmed, typ: 'unknown', has_default: false, default: undefined });
+        }
+        else {
+            const name = trimmed.slice(0, eqIndex).trim();
+            const raw = trimmed.slice(eqIndex + 1).trim();
+            const parsed = parseRDefault(raw);
+            result.args.push({ name, typ: parsed.typ, has_default: true, default: parsed.value });
+        }
+    }
+    return result;
+}
+function parseRDefault(raw) {
+    if (raw === 'TRUE' || raw === 'true')
+        return { value: true, typ: 'bool' };
+    if (raw === 'FALSE' || raw === 'false')
+        return { value: false, typ: 'bool' };
+    if (raw === 'NULL')
+        return { value: null, typ: 'unknown' };
+    if (/^-?\d+(\.\d+)?$/.test(raw)) {
+        const num = Number(raw);
+        if (Number.isInteger(num) && !raw.includes('.'))
+            return { value: num, typ: 'int' };
+        return { value: num, typ: 'float' };
+    }
+    const strMatch = raw.match(/^"((?:[^"\\]|\\.)*)"$/) || raw.match(/^'((?:[^'\\]|\\.)*)'$/);
+    if (strMatch)
+        return { value: strMatch[1], typ: { str: null } };
+    if (raw.startsWith('list(') || raw.startsWith('c('))
+        return { value: null, typ: { list: null } };
+    return { value: null, typ: 'unknown' };
+}

package/package/infer.svelte.js

@@ -16,6 +16,8 @@ export function usePreparedAssetSqlQueries(_getQueries, getWorkspace) {
     let map = new MapResource(() => Object.fromEntries(getQueries.value?.map((q) => [computeQueryKey(q, getWorkspace() ?? ''), q]) || []), async (toFetch) => {
         let queries = Object.entries(clone(toFetch));
         queries = queries.filter(([_, q]) => q.source_kind === 'datatable' || q.source_kind === 'ducklake');
+        // Skip queries with raw interpolations — they can't be prepared
+        queries = queries.filter(([_, q]) => !q.has_raw_interpolation);
         // We only support preparing single-statement queries for now.
         queries = queries.filter(([_, q]) => getQueryStmtCountHeuristic(q.query_string) === 1);
         if (!queries?.length)