windmill-cli 1.606.1 → 1.608.0

package/esm/deps/jsr.io/@windmill-labs/shared-utils/{1.0.11 → 1.0.12}/lib.es.js

@@ -38,7 +38,7 @@ var __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyD
     __spread: () => __spread,
     __spreadArrays: () => __spreadArrays,
     __values: () => __values
-});
+}, 1);
 function __extends(c, L) {
     extendStatics(c, L);
     function R() {
@@ -535,7 +535,7 @@ function toUtf8$1(c) {
 var init_whatwgEncodingApi = __esmMin((() => { })), dist_es_exports = /* @__PURE__ */ __export({
     fromUtf8: () => fromUtf8$3,
     toUtf8: () => toUtf8$2
-}), fromUtf8$3, toUtf8$2, init_dist_es = __esmMin((() => {
+}, 1), fromUtf8$3, toUtf8$2, init_dist_es = __esmMin((() => {
     init_pureJs(), init_whatwgEncodingApi(), fromUtf8$3 = (c) => typeof TextEncoder == "function" ? fromUtf8$2(c) : fromUtf8$1(c), toUtf8$2 = (c) => typeof TextDecoder == "function" ? toUtf8$1(c) : toUtf8(c);
 })), require_convertToBuffer = /* @__PURE__ */ __commonJSMin(((c) => {
     Object.defineProperty(c, "__esModule", { value: !0 }), c.convertToBuffer = void 0;
@@ -783,25 +783,135 @@ function getIntrospectionQuery(c) {
 let ColumnIdentity = /* @__PURE__ */ function (c) {
     return c.ByDefault = "By Default", c.Always = "Always", c.No = "No", c;
 }({});
-getIntrospectionQuery();
-function buildVisibleFieldList(c, L) {
-    return c.filter((c) => c && c.ignored !== !0).map((c) => {
-        switch (L) {
-            case "postgresql": return `"${c?.field}"`;
-            case "ms_sql_server": return `[${c?.field}]`;
-            case "mysql": return `\`${c?.field}\``;
-            case "snowflake": return `"${c?.field}"`;
-            case "bigquery": return `\`${c?.field}\``;
-            case "duckdb": return `"${c?.field}"`;
-            default: throw Error("Unsupported database type: " + L);
+var legacyScripts = {
+    postgresql: {
+        code: "SELECT table_name, column_name, udt_name, column_default, is_nullable, table_schema FROM information_schema.columns WHERE table_schema != 'pg_catalog' AND table_schema != 'information_schema'",
+        processingFn: (c) => {
+            let L = c.reduce((c, L) => {
+                let R = L.table_schema;
+                return delete L.table_schema, c[R] = c[R] || [], (L.table_name || L.column_name) && c[R].push(L), c;
+            }, {}), R = {};
+            for (let c in L)
+                R[c] = L[c].reduce((c, L) => {
+                    let R = L.table_name;
+                    delete L.table_name, c[R] = c[R] || {};
+                    let z = {
+                        type: L.udt_name,
+                        required: L.is_nullable === "NO"
+                    };
+                    return L.column_default && (z.default = L.column_default), c[R][L.column_name] = z, c;
+                }, {});
+            return R;
+        },
+        lang: "postgresql",
+        argName: "database"
+    },
+    mysql: {
+        code: "SELECT DATABASE() AS default_db_name, TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT FROM information_schema.columns WHERE table_schema = DATABASE() OR table_schema NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys', '_vt');",
+        processingFn: (c) => {
+            let L = c.reduce((c, L) => {
+                let R = L.TABLE_SCHEMA;
+                return delete L.TABLE_SCHEMA, c[R] = c[R] || [], c[R].push(L), c;
+            }, {}), R = {};
+            for (let c in L)
+                R[c] = L[c].reduce((c, L) => {
+                    let R = L.TABLE_NAME;
+                    delete L.TABLE_NAME, c[R] = c[R] || {};
+                    let z = {
+                        type: L.DATA_TYPE,
+                        required: L.is_nullable === "NO"
+                    };
+                    return L.column_default && (z.default = L.COLUMN_DEFAULT), c[R][L.COLUMN_NAME] = z, c;
+                }, {});
+            return R;
+        },
+        lang: "mysql",
+        argName: "database"
+    },
+    graphql: {
+        code: getIntrospectionQuery(),
+        lang: "graphql",
+        argName: "api"
+    },
+    bigquery: {
+        code: "import { BigQuery } from '@google-cloud/bigquery@7.5.0';\nexport async function main(args: bigquery) {\nconst bq = new BigQuery({\n	credentials: args\n})\nconst [datasets] = await bq.getDatasets();\nconst schema = {}\nfor (const dataset of datasets) {\n	schema[dataset.id] = {}\n	const query = \"SELECT table_name, ARRAY_AGG(STRUCT(if(is_nullable = 'YES', true, false) AS required, column_name AS name, data_type AS type, if(column_default = 'NULL', null, column_default) AS `default`) ORDER BY ordinal_position) AS schema FROM `{dataset.id}`.INFORMATION_SCHEMA.COLUMNS GROUP BY table_name\".replace('{dataset.id}', dataset.id)\n	const [rows] = await bq.query(query)\n	for (const row of rows) {\n		schema[dataset.id][row.table_name] = {}\n		for (const col of row.schema) {\n			const colName = col.name\n			delete col.name\n			if (col.default === null) {\n				delete col.default\n			}\n			schema[dataset.id][row.table_name][colName] = col\n		}\n	}\n}\nreturn schema\n}",
+        lang: "bun",
+        argName: "args"
+    },
+    snowflake: {
+        code: "select TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT, IS_NULLABLE from information_schema.columns where table_schema != 'INFORMATION_SCHEMA'",
+        lang: "snowflake",
+        processingFn: (c) => {
+            let L = {};
+            for (let R of c)
+                R.TABLE_SCHEMA in L || (L[R.TABLE_SCHEMA] = {}), R.TABLE_NAME in L[R.TABLE_SCHEMA] || (L[R.TABLE_SCHEMA][R.TABLE_NAME] = {}), L[R.TABLE_SCHEMA][R.TABLE_NAME][R.COLUMN_NAME] = {
+                    type: R.DATA_TYPE,
+                    required: R.IS_NULLABLE === "YES"
+                }, R.COLUMN_DEFAULT !== null && (L[R.TABLE_SCHEMA][R.TABLE_NAME][R.COLUMN_NAME].default = R.COLUMN_DEFAULT);
+            return L;
+        },
+        argName: "database"
+    },
+    snowflake_oauth: {
+        code: "select TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT, IS_NULLABLE from information_schema.columns where table_schema != 'INFORMATION_SCHEMA'",
+        lang: "snowflake",
+        processingFn: (c) => {
+            let L = {};
+            for (let R of c)
+                R.TABLE_SCHEMA in L || (L[R.TABLE_SCHEMA] = {}), R.TABLE_NAME in L[R.TABLE_SCHEMA] || (L[R.TABLE_SCHEMA][R.TABLE_NAME] = {}), L[R.TABLE_SCHEMA][R.TABLE_NAME][R.COLUMN_NAME] = {
+                    type: R.DATA_TYPE,
+                    required: R.IS_NULLABLE === "YES"
+                }, R.COLUMN_DEFAULT !== null && (L[R.TABLE_SCHEMA][R.TABLE_NAME][R.COLUMN_NAME].default = R.COLUMN_DEFAULT);
+            return L;
+        },
+        argName: "database"
+    },
+    mssql: {
+        argName: "database",
+        code: "select TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT from information_schema.columns where table_schema != 'sys'",
+        lang: "mssql",
+        processingFn: (c) => {
+            if (!c || c.length === 0)
+                return {};
+            let L = c.reduce((c, L) => {
+                let R = L.TABLE_SCHEMA;
+                return delete L.TABLE_SCHEMA, c[R] = c[R] || [], c[R].push(L), c;
+            }, {}), R = {};
+            for (let c in L)
+                R[c] = L[c].reduce((c, L) => {
+                    let R = L.TABLE_NAME;
+                    delete L.TABLE_NAME, c[R] = c[R] || {};
+                    let z = {
+                        type: L.DATA_TYPE,
+                        required: L.is_nullable === "NO"
+                    };
+                    return L.column_default && (z.default = L.COLUMN_DEFAULT), c[R][L.COLUMN_NAME] = z, c;
+                }, {});
+            return R;
         }
-    });
+    }
+};
+({ ...legacyScripts }), { ...legacyScripts.postgresql };
+function buildVisibleFieldList(c, L) {
+    return c.filter((c) => c && c.ignored !== !0).map((c) => renderDbQuotedIdentifier(c?.field, L));
+}
+function renderDbQuotedIdentifier(c, L) {
+    switch (L) {
+        case "postgresql": return `"${c}"`;
+        case "ms_sql_server": return `[${c}]`;
+        case "mysql": return `\`${c}\``;
+        case "snowflake": return `"${c}"`;
+        case "bigquery": return `\`${c}\``;
+        case "duckdb": return `"${c}"`;
+        default: throw Error("Unsupported database type: " + L);
+    }
 }
 function getLanguageByResourceType(c) {
     return {
         postgresql: "postgresql",
         mysql: "mysql",
         ms_sql_server: "mssql",
+        mssql: "mssql",
         snowflake: "snowflake",
         snowflake_oauth: "snowflake",
         bigquery: "bigquery",
@@ -1008,8 +1118,8 @@ function makeInsertQuery(c, L, R) {
         throw Error("Table name is required");
     let z = L.filter((c) => !c.hideInsert && !(R == "postgresql" && c.defaultvalue?.startsWith("nextval("))), B = L.filter((c) => !shouldOmitColumnInInsert(c)), V = z.concat(B), H = buildParameters(z, R);
     H += "\n";
-    let U = B.length > 0, W = formatColumnNames(V), G = formatInsertValues(z, R), K = formatDefaultValues(B);
-    return H += `INSERT INTO ${c} (${W}) VALUES (${G}${U ? ", " : ""}${K})`, H;
+    let U = B.length > 0, W = formatColumnNames(V), G = formatInsertValues(z, R), K = formatDefaultValues(B), q = `${G}${U ? ", " : ""}${K}`;
+    return q.trim() ? (H += `INSERT INTO ${c} (${W}) VALUES (${q})`, H) : `INSERT INTO ${c} DEFAULT VALUES`;
 }
 function getInsertInput(c, L, R) {
     let z = c.type === "ducklake" ? "duckdb" : c.resourceType, B = makeInsertQuery(L, R, z);
@@ -1067,10 +1177,10 @@ function makeSnowflakeSelectQuery(c, L, R, z) {
 		CASE WHEN ? = '${c.field}' AND ? = TRUE THEN "${c.field}" END DESC`));
     return U += ` ORDER BY ${q.join(",\n")}`, U += ` LIMIT ${B} OFFSET ${V}`, U = buildParameters(H, "snowflake") + "\n" + U, U;
 }
-function makeSelectQuery(c, L, R, z, B) {
+function makeSelectQuery(c, L, R, z, B, V) {
     if (!c)
         throw Error("Table name is required");
-    let V = "", H = buildParameters([
+    let H = "", U = buildParameters([
         {
             field: "limit",
             datatype: z === "bigquery" ? "integer" : "int"
@@ -1092,30 +1202,73 @@ function makeSelectQuery(c, L, R, z, B) {
             datatype: z === "bigquery" ? "bool" : "boolean"
         }
     ], z);
-    H += "\n";
-    let U = buildVisibleFieldList(L, z), W = U.join(", ");
+    U += "\n";
+    let W = buildVisibleFieldList(L, z), G = W.join(", ");
     switch (z) {
         case "mysql": {
             let z = L.map((c) => `
 CASE WHEN :order_by = '${c.field}' AND :is_desc IS false THEN \`${c.field}\` END,
 CASE WHEN :order_by = '${c.field}' AND :is_desc IS true THEN \`${c.field}\` END DESC`).join(",\n");
-            V = ` (:quicksearch = '' OR CONCAT_WS(' ', ${U.join(", ")}) LIKE CONCAT('%', :quicksearch, '%'))`, H += `SELECT ${W} FROM ${c}`, H += ` WHERE ${R ? `${R} AND` : ""} ${V}`, H += ` ORDER BY ${z}`, H += " LIMIT :limit OFFSET :offset";
+            H = ` (:quicksearch = '' OR CONCAT_WS(' ', ${W.join(", ")}) LIKE CONCAT('%', :quicksearch, '%'))`, U += `SELECT ${G} FROM ${c}`, U += ` WHERE ${R ? `${R} AND` : ""} ${H}`, U += ` ORDER BY ${z}`, U += " LIMIT :limit OFFSET :offset";
             break;
         }
         case "postgresql": {
-            let z = `
-      ${L.map((c) => `
-      (CASE WHEN $4 = '${c.field}' AND $5 IS false THEN "${c.field}"::text END),
-      (CASE WHEN $4 = '${c.field}' AND $5 IS true THEN "${c.field}"::text END) DESC`).join(",\n")}`;
-            V = `($3 = '' OR CONCAT(${U.join(", ")}) ILIKE '%' || $3 || '%')`, H += `SELECT ${U.map((c) => `${c}::text`).join(", ")} FROM ${c}\n`, H += ` WHERE ${R ? `${R} AND` : ""} ${V}\n`, H += ` ORDER BY ${z}\n`, H += " LIMIT $1::INT OFFSET $2::INT";
+            function z({ field: c, is_desc: L = !1, text_cast: R = !1, check_is_number: z }) {
+                return `(CASE WHEN${z === !0 ? ` pg_typeof("${c}")::text IN ('integer', 'bigint', 'smallint', 'numeric', 'real', 'double precision') AND` : z === !1 ? ` pg_typeof("${c}")::text NOT IN ('integer', 'bigint', 'smallint', 'numeric', 'real', 'double precision') AND` : ""} $4 = '${c}' AND $5 IS ${L} THEN "${c}"${R ? "::text" : ""} END)${L ? " DESC" : ""}`;
+            }
+            let B = `
+      ${L.map((c) => V?.fixPgIntTypes ? `
+      ${z({
+                field: c.field,
+                is_desc: !1,
+                text_cast: !0,
+                check_is_number: !1
+            })},
+      ${z({
+                field: c.field,
+                is_desc: !1,
+                text_cast: !1,
+                check_is_number: !0
+            })},
+      ${z({
+                field: c.field,
+                is_desc: !0,
+                text_cast: !0,
+                check_is_number: !1
+            })},
+      ${z({
+                field: c.field,
+                is_desc: !0,
+                text_cast: !1,
+                check_is_number: !0
+            })}` : `
+      ${z({
+                field: c.field,
+                is_desc: !1,
+                text_cast: !0
+            })},
+      ${z({
+                field: c.field,
+                is_desc: !0,
+                text_cast: !0
+            })}`).join(",\n")}`;
+            H = `($3 = '' OR CONCAT(${W.join(", ")}) ILIKE '%' || $3 || '%')`, U += `SELECT ${W.map((c) => `${c}::text`).join(", ")} FROM ${c}\n`, U += ` WHERE ${R ? `${R} AND` : ""} ${H}\n`, U += ` ORDER BY ${B}\n`, U += " LIMIT $1::INT OFFSET $2::INT";
             break;
         }
-        case "ms_sql_server":
-            let z = L.map((c) => `
+        case "ms_sql_server": {
+            let z = [
+                "text",
+                "ntext",
+                "image"
+            ], B = L.filter((c) => !z.includes(c.datatype.toLowerCase())).map((c) => `
 (CASE WHEN @p4 = '${c.field}' AND @p5 = 0 THEN ${c.field} END) ASC,
-(CASE WHEN @p4 = '${c.field}' AND @p5 = 1 THEN ${c.field} END) DESC`).join(",\n");
-            V = ` (@p3 = '' OR CONCAT(${W}) LIKE '%' + @p3 + '%')`, H += `SELECT ${W} FROM ${c}`, H += ` WHERE ${R ? `${R} AND` : ""} ${V}`, H += ` ORDER BY ${z}`, H += " OFFSET @p2 ROWS FETCH NEXT @p1 ROWS ONLY";
+(CASE WHEN @p4 = '${c.field}' AND @p5 = 1 THEN ${c.field} END) DESC`).join(",\n"), V = W.filter((c) => {
+                let R = c.slice(1, -1), B = L.find((c) => c.field === R);
+                return !z.includes(B?.datatype.toLowerCase() ?? "");
+            }).join(", ");
+            H = V ? ` (@p3 = '' OR CONCAT(${V}) LIKE '%' + @p3 + '%')` : " (@p3 = '')", U += `SELECT ${G} FROM ${c}`, U += ` WHERE ${R ? `${R} AND` : ""} ${H}`, U += ` ORDER BY ${B}`, U += " OFFSET @p2 ROWS FETCH NEXT @p1 ROWS ONLY";
             break;
+        }
         case "snowflake": return makeSnowflakeSelectQuery(c, L, R, B);
         case "bigquery": {
             let z = L.map((c) => c.datatype === "JSON" || c.datatype.startsWith("STRUCT") || c.datatype.startsWith("ARRAY") || c.datatype === "GEOGRAPHY" ? `
@@ -1123,10 +1276,10 @@ CASE WHEN :order_by = '${c.field}' AND :is_desc IS true THEN \`${c.field}\` END
 (CASE WHEN @order_by = '${c.field}' AND @is_desc = true THEN TO_JSON_STRING(${c.field}) END) DESC` : `
 (CASE WHEN @order_by = '${c.field}' AND @is_desc = false THEN ${c.field} END) ASC,
 (CASE WHEN @order_by = '${c.field}' AND @is_desc = true THEN ${c.field} END) DESC`).join(",\n");
-            V = ` (@quicksearch = '' OR REGEXP_CONTAINS(CONCAT(${U.map((c) => {
+            H = ` (@quicksearch = '' OR REGEXP_CONTAINS(CONCAT(${W.map((c) => {
                 let R = L.find((L) => L.field === c.slice(1, -1));
                 return R?.datatype === "JSON" || R?.datatype.startsWith("STRUCT") || R?.datatype.startsWith("ARRAY") || R?.datatype === "GEOGRAPHY" ? `TO_JSON_STRING(${c})` : `CAST(${c} AS STRING)`;
-            }).join(",")}), '(?i)' || @quicksearch))`, H += `SELECT ${W} FROM ${c}`, H += ` WHERE ${R ? `${R} AND` : ""} ${V}`, H += ` ORDER BY ${z}`, H += " LIMIT @limit OFFSET @offset";
+            }).join(",")}), '(?i)' || @quicksearch))`, U += `SELECT ${G} FROM ${c}`, U += ` WHERE ${R ? `${R} AND` : ""} ${H}`, U += ` ORDER BY ${z}`, U += " LIMIT @limit OFFSET @offset";
             break;
         }
         case "duckdb": {
@@ -1134,12 +1287,12 @@ CASE WHEN :order_by = '${c.field}' AND :is_desc IS true THEN \`${c.field}\` END
       ${L.map((c) => `
       (CASE WHEN $order_by = '${c.field}' AND $is_desc IS false THEN "${c.field}"::text END),
       (CASE WHEN $order_by = '${c.field}' AND $is_desc IS true THEN "${c.field}"::text END) DESC`).join(",\n")}`;
-            V = `($quicksearch = '' OR CONCAT(${U.join(", ")}) ILIKE '%' || $quicksearch || '%')`, H += `SELECT ${U.join(", ")} FROM ${c}\n`, H += ` WHERE ${R ? `${R} AND` : ""} ${V}\n`, H += ` ORDER BY ${z}\n`, H += " LIMIT $limit::INT OFFSET $offset::INT";
+            H = `($quicksearch = '' OR CONCAT(${W.join(", ")}) ILIKE '%' || $quicksearch || '%')`, U += `SELECT ${W.join(", ")} FROM ${c}\n`, U += ` WHERE ${R ? `${R} AND` : ""} ${H}\n`, U += ` ORDER BY ${z}\n`, U += " LIMIT $limit::INT OFFSET $offset::INT";
             break;
         }
         default: throw Error("Unsupported database type");
     }
-    return H;
+    return U;
 }
 function coerceToNumber(c) {
     return typeof c == "number" ? c : typeof c == "string" ? parseInt(c, 10) : 0;
@@ -1489,6 +1642,20 @@ export declare function waitJob(id: string): Promise<Job>;
  * @param id
  */
 export declare function getJob(id: string): Promise<Job>;
+
+export type StreamUpdate = {
+  new_result_stream?: string;
+  stream_offset?: number;
+};
+
+/**
+ * Stream job results using SSE. Calls onUpdate for each stream update,
+ * and resolves with the final result when the job completes.
+ * @param id - The job ID to stream
+ * @param onUpdate - Optional callback for stream updates with new_result_stream data
+ * @returns Promise that resolves with the final job result
+ */
+export declare function streamJob(id: string, onUpdate?: (data: StreamUpdate) => void): Promise<any>;
 `;
 }
 async function updateRawAppPolicy(c, L) {
@@ -1515,7 +1682,7 @@ async function processRunnable(c, L, R) {
                 allow_user_resources: B
             }];
 }
-var rawAppWmillTs_exports = /* @__PURE__ */ __export({ default: () => rawAppWmillTs_default }), rawAppWmillTs_default = "let reqs: Record<string, any> = {}\n\nfunction doRequest(type: string, o: object) {\n    return new Promise((resolve, reject) => {\n        const reqId = Math.random().toString(36)\n        reqs[reqId] = { resolve, reject }\n        parent.postMessage({ ...o, type, reqId }, '*')\n    })\n}\n\nexport const backend = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backend', { runnable_id, v })\n            }\n        }\n    })\n\nexport const backendAsync = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backendAsync', { runnable_id, v })\n            }\n        }\n    })\n\nexport function waitJob(jobId: string) {\n    return doRequest('waitJob', { jobId })\n}\n\nexport function getJob(jobId: string) {\n    return doRequest('getJob', { jobId })\n}\n\n\nwindow.addEventListener('message', (e) => {\n    if (e.data.type == 'backendRes' || e.data.type == 'backendAsyncRes') {\n        console.log('Message from parent backend', e.data)\n        let job = reqs[e.data.reqId]\n        if (job) {\n            const result = e.data.result\n            if (e.data.error) {\n                job.reject(new Error(result.stack ?? result.message))\n            } else {\n                job.resolve(result)\n            }\n        } else {\n            console.error('No job found for', e.data.reqId)\n        }\n    }\n})";
+var rawAppWmillTs_exports = /* @__PURE__ */ __export({ default: () => rawAppWmillTs_default }, 1), rawAppWmillTs_default = "let reqs: Record<string, any> = {}\n\nfunction doRequest(type: string, o: object) {\n	return new Promise((resolve, reject) => {\n		const reqId = Math.random().toString(36)\n		reqs[reqId] = { resolve, reject }\n		parent.postMessage({ ...o, type, reqId }, '*')\n	})\n}\n\nexport const backend = new Proxy(\n	{},\n	{\n		get(_, runnable_id: string) {\n			return (v: any) => {\n				return doRequest('backend', { runnable_id, v })\n			}\n		}\n	}\n)\n\nexport const backendAsync = new Proxy(\n	{},\n	{\n		get(_, runnable_id: string) {\n			return (v: any) => {\n				return doRequest('backendAsync', { runnable_id, v })\n			}\n		}\n	}\n)\n\nexport function waitJob(jobId: string) {\n	return doRequest('waitJob', { jobId })\n}\n\nexport function getJob(jobId: string) {\n	return doRequest('getJob', { jobId })\n}\n\n/**\n * Stream job results using SSE. Calls onUpdate for each stream update,\n * and resolves with the final result when the job completes.\n * @param jobId - The job ID to stream\n * @param onUpdate - Callback for stream updates with new_result_stream data\n * @returns Promise that resolves with the final job result\n */\nexport function streamJob(\n	jobId: string,\n	onUpdate?: (data: { new_result_stream?: string; stream_offset?: number }) => void\n): Promise<any> {\n	return new Promise((resolve, reject) => {\n		const reqId = Math.random().toString(36)\n		reqs[reqId] = { resolve, reject, onUpdate }\n		parent.postMessage({ jobId, type: 'streamJob', reqId }, '*')\n	})\n}\n\nwindow.addEventListener('message', (e) => {\n	if (e.data.type == 'streamJobUpdate') {\n		// Handle streaming update\n		let job = reqs[e.data.reqId]\n		if (job && job.onUpdate) {\n			job.onUpdate({\n				new_result_stream: e.data.new_result_stream,\n				stream_offset: e.data.stream_offset\n			})\n		}\n	} else if (e.data.type == 'streamJobRes') {\n		// Handle stream completion\n		let job = reqs[e.data.reqId]\n		if (job) {\n			if (e.data.error) {\n				job.reject(new Error(e.data.result?.stack ?? e.data.result?.message ?? 'Stream error'))\n			} else {\n				job.resolve(e.data.result)\n			}\n			delete reqs[e.data.reqId]\n		}\n	} else if (e.data.type == 'backendRes' || e.data.type == 'backendAsyncRes') {\n		console.log('Message from parent backend', e.data)\n		let job = reqs[e.data.reqId]\n		if (job) {\n			const result = e.data.result\n			if (e.data.error) {\n				job.reject(new Error(result.stack ?? result.message))\n			} else {\n				job.resolve(result)\n			}\n		} else {\n			console.error('No job found for', e.data.reqId)\n		}\n	}\n})\n";
 function capitalize(c) {
     return c ? c.charAt(0).toUpperCase() + c.slice(1) : "";
 }

package/esm/deps.js

@@ -44,18 +44,17 @@ export { minimatch } from "minimatch";
 export { default as JSZip } from "jszip";
 export * as express from "express";
 export * as http from "node:http";
-export { WebSocketServer, WebSocket } from "ws";
+export { WebSocket, WebSocketServer } from "ws";
 export * as getPort from "get-port";
 export * as open from "open";
 export * as esMain from "es-main";
-export * as windmillUtils from "./deps/jsr.io/@windmill-labs/shared-utils/1.0.11/lib.es.js";
+export * as windmillUtils from "./deps/jsr.io/@windmill-labs/shared-utils/1.0.12/lib.es.js";
 import { OpenAPI } from "./gen/index.js";
 export function setClient(token, baseUrl) {
     if (baseUrl === undefined) {
-        baseUrl =
-            getEnv("BASE_INTERNAL_URL") ??
-                getEnv("BASE_URL") ??
-                "http://localhost:8000";
+        baseUrl = getEnv("BASE_INTERNAL_URL") ??
+            getEnv("BASE_URL") ??
+            "http://localhost:8000";
     }
     if (token === undefined) {
         token = getEnv("WM_TOKEN") ?? "no_token";

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.606.1',
+    VERSION: '1.608.0',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/gen/services.gen.js

@@ -7499,6 +7499,7 @@ export const createJobSignature = (data) => {
  * @param data.id
  * @param data.resumeId
  * @param data.approver
+ * @param data.flowLevel If true, generate resume URLs for the parent flow instead of the specific step. This allows pre-approvals that can be consumed by any later suspend step in the same flow.
  * @returns unknown url endpoints
  * @throws ApiError
  */
@@ -7512,7 +7513,8 @@ export const getResumeUrls = (data) => {
             resume_id: data.resumeId
         },
         query: {
-            approver: data.approver
+            approver: data.approver,
+            flow_level: data.flowLevel
         }
     });
 };

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

@@ -17,9 +17,41 @@ 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";
-import { hasFolderSuffix, getFolderSuffix } from "../../utils/resource_folders.js";
+import { getFolderSuffix, hasFolderSuffix, setNonDottedPaths, } from "../../utils/resource_folders.js";
 const DEFAULT_PORT = 4000;
 const DEFAULT_HOST = "localhost";
+/**
+ * Search for wmill.yaml by traversing upward from the current directory.
+ * Unlike the standard findWmillYaml() in conf.ts, this does not stop at
+ * the git root - it continues searching until the filesystem root.
+ * This is needed for `app dev` which runs from inside a raw_app folder
+ * that may be deeply nested within a larger git repository.
+ */
+async function findAndLoadNonDottedPathsSetting() {
+    let currentDir = process.cwd();
+    while (true) {
+        const wmillYamlPath = path.join(currentDir, "wmill.yaml");
+        if (fs.existsSync(wmillYamlPath)) {
+            try {
+                const config = await yamlParseFile(wmillYamlPath);
+                setNonDottedPaths(config?.nonDottedPaths ?? false);
+                log.debug(`Found wmill.yaml at ${wmillYamlPath}, nonDottedPaths=${config?.nonDottedPaths ?? false}`);
+            }
+            catch (e) {
+                log.debug(`Failed to parse wmill.yaml at ${wmillYamlPath}: ${e}`);
+            }
+            return;
+        }
+        // Check if we've reached the filesystem root
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            // Reached filesystem root without finding wmill.yaml
+            log.debug("No wmill.yaml found, using default dotted paths");
+            return;
+        }
+        currentDir = parentDir;
+    }
+}
 // HTML template with live reload and SQL migration modal
 const createHTML = (jsPath, cssPath) => `
 <!DOCTYPE html>
@@ -275,6 +307,9 @@ const createHTML = (jsPath, cssPath) => `
 `;
 async function dev(opts) {
     GLOBAL_CONFIG_OPT.noCdToRoot = true;
+    // Search for wmill.yaml by traversing upward (without git root constraint)
+    // to initialize nonDottedPaths setting before using folder suffix functions
+    await findAndLoadNonDottedPathsSetting();
     // Validate that we're in a .raw_app folder
     const cwd = process.cwd();
     const currentDirName = path.basename(cwd);
@@ -356,9 +391,12 @@ async function dev(opts) {
             });
             // Provide the virtual module content
             build.onLoad({ filter: /.*/, namespace: "wmill-virtual" }, (args) => {
+                const contents = wmillTs(port);
                 log.info(colors.yellow(`[wmill-virtual] Loading virtual module: ${args.path}`));
+                log.info(colors.gray(`[wmill-virtual] Exports: ${contents.match(/export (const|function) \w+/g)?.join(", ") ??
+                    "none"}`));
                 return {
-                    contents: wmillTs(port),
+                    contents,
                     loader: "ts",
                 };
             });
@@ -745,6 +783,23 @@ async function dev(opts) {
                         }
                         break;
                     }
+                    case "streamJob": {
+                        // Stream job results using SSE
+                        log.info(colors.blue(`[streamJob] Streaming job: ${jobId}`));
+                        try {
+                            await streamJobWithSSE(workspaceId, jobId, reqId, ws, workspace.remote, workspace.token);
+                        }
+                        catch (error) {
+                            log.error(colors.red(`[streamJob] Error: ${error.message}`));
+                            ws.send(JSON.stringify({
+                                type: "streamJobRes",
+                                reqId,
+                                error: true,
+                                result: { message: error.message, stack: error.stack },
+                            }));
+                        }
+                        break;
+                    }
                     case "applySqlMigration": {
                         // Execute SQL migration against a datatable
                         const { sql, datatable, fileName } = message;
@@ -992,6 +1047,25 @@ async function genRunnablesTs(schemaOverrides = {}) {
         log.error(colors.red(`Failed to generate wmill.d.ts: ${error.message}`));
     }
 }
+/**
+ * Convert runnables from file format to API format.
+ * File format uses type: "script"|"hubscript"|"flow" for path-based runnables.
+ * API format uses type: "path" with runType: "script"|"hubscript"|"flow".
+ */
+function convertRunnablesToApiFormat(runnables) {
+    for (const [runnableId, runnable] of Object.entries(runnables)) {
+        if (runnable?.type === "script" ||
+            runnable?.type === "hubscript" ||
+            runnable?.type === "flow") {
+            // Convert from file format to API format
+            // { type: "script" } -> { type: "path", runType: "script" }
+            const originalType = runnable.type;
+            runnable.runType = originalType;
+            runnable.type = "path";
+            log.debug(`Converted runnable '${runnableId}' from type='${originalType}' to type='path', runType='${originalType}'`);
+        }
+    }
+}
 async function loadRunnables() {
     try {
         const localPath = process.cwd();
@@ -1003,6 +1077,9 @@ async function loadRunnables() {
             const rawApp = (await yamlParseFile(path.join(localPath, "raw_app.yaml")));
             runnables = rawApp?.runnables ?? {};
         }
+        // Always convert path-based runnables from file format to API format
+        // This handles both backend folder runnables and raw_app.yaml runnables
+        convertRunnablesToApiFormat(runnables);
         replaceInlineScripts(runnables, backendPath + SEP, true);
         return runnables;
     }
@@ -1044,13 +1121,24 @@ async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
             cache_ttl: inlineScript.cache_ttl,
         };
     }
-    else if (runnable.type === "path" && runnable.runType && runnable.path) {
-        // Path-based runnables have type: "path" and runType: "script"|"hubscript"|"flow"
+    else if ((runnable.type === "path" || runnable.type === "runnableByPath") &&
+        runnable.runType &&
+        runnable.path) {
+        // Path-based runnables have type: "path" (or legacy "runnableByPath") and runType: "script"|"hubscript"|"flow"
         const prefix = runnable.runType;
         requestBody.path = prefix !== "hubscript"
             ? `${prefix}/${runnable.path}`
             : `script/${runnable.path}`;
     }
+    else {
+        // Neither inline script nor valid path-based runnable
+        const debugInfo = `type=${runnable.type}, runType=${runnable.runType}, ` +
+            `path=${runnable.path}, hasInlineScript=${!!runnable
+                .inlineScript}`;
+        log.error(colors.red(`[executeRunnable] Invalid runnable configuration for '${runnableId}': ${debugInfo}`));
+        throw new Error(`Invalid runnable '${runnableId}': ${debugInfo}. ` +
+            `Must have either inlineScript (for inline type) or type="path" with runType and path fields`);
+    }
     const uuid = await wmill.executeComponent({
         workspace,
         path: appPath,
@@ -1108,3 +1196,93 @@ async function getJobStatus(workspace, jobId) {
         id: jobId,
     });
 }
+async function streamJobWithSSE(workspace, jobId, reqId, ws, baseUrl, token) {
+    const sseUrl = `${baseUrl}api/w/${workspace}/jobs_u/getupdate_sse/${jobId}?fast=true`;
+    const response = await fetch(sseUrl, {
+        headers: {
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`SSE request failed: ${response.status} ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error("No response body for SSE stream");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                    const data = line.slice(6);
+                    try {
+                        const update = JSON.parse(data);
+                        const type = update.type;
+                        if (type === "ping" || type === "timeout") {
+                            if (type === "timeout") {
+                                reader.cancel();
+                                return;
+                            }
+                            continue;
+                        }
+                        if (type === "error") {
+                            ws.send(JSON.stringify({
+                                type: "streamJobRes",
+                                reqId,
+                                error: true,
+                                result: { message: update.error || "SSE error" },
+                            }));
+                            reader.cancel();
+                            return;
+                        }
+                        if (type === "not_found") {
+                            ws.send(JSON.stringify({
+                                type: "streamJobRes",
+                                reqId,
+                                error: true,
+                                result: { message: "Job not found" },
+                            }));
+                            reader.cancel();
+                            return;
+                        }
+                        // Send stream update if there's new stream data
+                        if (update.new_result_stream !== undefined) {
+                            ws.send(JSON.stringify({
+                                type: "streamJobUpdate",
+                                reqId,
+                                new_result_stream: update.new_result_stream,
+                                stream_offset: update.stream_offset,
+                            }));
+                        }
+                        // Check if job is completed
+                        if (update.completed) {
+                            ws.send(JSON.stringify({
+                                type: "streamJobRes",
+                                reqId,
+                                error: false,
+                                result: update.only_result,
+                            }));
+                            reader.cancel();
+                            return;
+                        }
+                    }
+                    catch (parseErr) {
+                        log.warn(`Failed to parse SSE data: ${parseErr}`);
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}