windmill-components 1.394.7 → 1.405.0

package/package/hubPaths.json

@@ -1,12 +1,10 @@
 {
-	"gitSyncLegacy0": "hub/8931/sync-script-to-git-repo-windmill",
-	"gitSync": "hub/9074/sync-script-to-git-repo-windmill",
+	"gitSync": "hub/9087/sync-script-to-git-repo-windmill",
 	"gitSyncTest": "hub/9073/git-repo-test-read-write-windmill",
-	"slackErrorHandler": "hub/6512/workspace-or-schedule-error-handler-slack",
-	"slackRecoveryHandler": "hub/9067/slack/schedule-recovery-handler-slack",
-	"slackRecoveryHandler_0": "hub/2430/slack/schedule-recovery-handler-slack",
+	"slackErrorHandler": "hub/9079/workspace-or-schedule-error-handler-slack",
+	"slackRecoveryHandler": "hub/9080/slack/schedule-recovery-handler-slack",
 	"slackSuccessHandler": "hub/9072/slack/schedule-success-handler-slack",
-	"slackReport": "hub/7836/slack",
-	"discordReport": "hub/7838/discord",
-	"smtpReport": "hub/7837/smtp"
+	"slackReport": "hub/9084/slack",
+	"discordReport": "hub/9085/discord",
+	"smtpReport": "hub/9086/smtp"
 }

package/package/infer.d.ts

@@ -1,7 +1,9 @@
 import type { Schema, SupportedLanguage } from './common.js';
 export declare function initWasmTs(): Promise<void>;
-export declare function parseDeps(code: string): string[];
-export declare function inferArgs(language: SupportedLanguage | 'bunnative' | undefined, code: string, schema: Schema): Promise<boolean | null>;
+export declare function inferArgs(language: SupportedLanguage | 'bunnative' | undefined, code: string, schema: Schema, mainOverride?: string): Promise<{
+    no_main_func: boolean | null;
+    has_preprocessor: boolean | null;
+} | null>;
 export declare function loadSchemaFromPath(path: string, hash?: string): Promise<Schema>;
 export declare function loadSchema(workspace: string, path: string, runType: 'script' | 'flow' | 'hubscript'): Promise<{
     schema: Schema;

package/package/infer.js

@@ -2,18 +2,20 @@ import { ScriptService, FlowService } from './gen';
 import { get, writable } from 'svelte/store';
 import { emptySchema, sortObject } from './utils.js';
 import { tick } from 'svelte';
-import initTsParser, { parse_deno, parse_outputs, parse_ts_imports } from 'windmill-parser-wasm-ts';
-import initRegexParsers, { parse_sql, parse_mysql, parse_bigquery, parse_snowflake, parse_graphql, parse_mssql, parse_db_resource, parse_bash, parse_powershell, } from 'windmill-parser-wasm-regex';
-import initPythonParser, { parse_python, } from 'windmill-parser-wasm-py';
-import initGoParser, { parse_go, } from 'windmill-parser-wasm-go';
-import initPhpParser, { parse_php, } from 'windmill-parser-wasm-php';
-import initRustParser, { parse_rust, } from 'windmill-parser-wasm-rust';
+import initTsParser, { parse_deno, parse_outputs } from 'windmill-parser-wasm-ts';
+import initRegexParsers, { parse_sql, parse_mysql, parse_bigquery, parse_snowflake, parse_graphql, parse_mssql, parse_db_resource, parse_bash, parse_powershell } from 'windmill-parser-wasm-regex';
+import initPythonParser, { parse_python } from 'windmill-parser-wasm-py';
+import initGoParser, { parse_go } from 'windmill-parser-wasm-go';
+import initPhpParser, { parse_php } from 'windmill-parser-wasm-php';
+import initRustParser, { parse_rust } from 'windmill-parser-wasm-rust';
+import initYamlParser, { parse_ansible } from 'windmill-parser-wasm-yaml';
 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';
 import wasmUrlGo from 'windmill-parser-wasm-go/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlPhp from 'windmill-parser-wasm-php/windmill_parser_wasm_bg.wasm?url';
 import wasmUrlRust from 'windmill-parser-wasm-rust/windmill_parser_wasm_bg.wasm?url';
+import wasmUrlYaml from 'windmill-parser-wasm-yaml/windmill_parser_wasm_bg.wasm?url';
 import { workspaceStore } from './stores.js';
 import { argSigToJsonSchemaType } from './inferArgSig.js';
 const loadSchemaLastRun = writable(undefined);
@@ -39,20 +41,13 @@ async function initWasmRust() {
 async function initWasmGo() {
     await initGoParser(wasmUrlGo);
 }
-export function parseDeps(code) {
-    let r = JSON.parse(parse_ts_imports(code));
-    if (r.error) {
-        console.error(r.error);
-        return [];
-    }
-    else {
-        return r.imports;
-    }
+async function initWasmYaml() {
+    await initYamlParser(wasmUrlYaml);
 }
-export async function inferArgs(language, code, schema) {
+export async function inferArgs(language, code, schema, mainOverride) {
     const lastRun = get(loadSchemaLastRun);
     let inferedSchema;
-    if (lastRun && code == lastRun[0] && lastRun[1]) {
+    if (lastRun && code == lastRun[0] && lastRun[1] && lastRun[2] == mainOverride) {
         inferedSchema = lastRun[1];
     }
     else {
@@ -66,19 +61,19 @@ export async function inferArgs(language, code, schema) {
         }
         if (language == 'python3') {
             await initWasmPython();
-            inferedSchema = JSON.parse(parse_python(code));
+            inferedSchema = JSON.parse(parse_python(code, mainOverride));
         }
         else if (language == 'deno') {
             await initWasmTs();
-            inferedSchema = JSON.parse(parse_deno(code));
+            inferedSchema = JSON.parse(parse_deno(code, mainOverride));
         }
         else if (language == 'nativets') {
             await initWasmTs();
-            inferedSchema = JSON.parse(parse_deno(code));
+            inferedSchema = JSON.parse(parse_deno(code, mainOverride));
         }
         else if (language == 'bun' || language == 'bunnative') {
             await initWasmTs();
-            inferedSchema = JSON.parse(parse_deno(code));
+            inferedSchema = JSON.parse(parse_deno(code, mainOverride));
         }
         else if (language == 'postgresql') {
             inferedSchema = JSON.parse(parse_sql(code));
@@ -153,13 +148,17 @@ export async function inferArgs(language, code, schema) {
             await initWasmRust();
             inferedSchema = JSON.parse(parse_rust(code));
         }
+        else if (language == 'ansible') {
+            await initWasmYaml();
+            inferedSchema = JSON.parse(parse_ansible(code));
+        }
         else {
             return null;
         }
         if (inferedSchema.type == 'Invalid') {
             throw new Error(inferedSchema.error);
         }
-        loadSchemaLastRun.set([code, inferedSchema]);
+        loadSchemaLastRun.set([code, inferedSchema, mainOverride]);
     }
     schema.required = [];
     const oldProperties = JSON.parse(JSON.stringify(schema.properties));
@@ -179,7 +178,10 @@ export async function inferArgs(language, code, schema) {
         }
     }
     await tick();
-    return inferedSchema.no_main_func;
+    return {
+        no_main_func: inferedSchema.no_main_func,
+        has_preprocessor: inferedSchema.has_preprocessor
+    };
 }
 export async function loadSchemaFromPath(path, hash) {
     if (path.startsWith('hub/')) {

package/package/inferArgSig.js

@@ -1,5 +1,5 @@
 export function argSigToJsonSchemaType(t, oldS) {
-    let newS = { type: '' };
+    const newS = { type: '' };
     if (t === 'int') {
         newS.type = 'integer';
     }
@@ -108,7 +108,10 @@ export function argSigToJsonSchemaType(t, oldS) {
             newS.items = { type: 'string', enum: t.list.str };
         }
         else if (t.list && typeof t.list == 'object' && 'resource' in t.list && t.list.resource) {
-            newS.items = { type: 'resource', resourceType: t.list.resource };
+            newS.items = {
+                type: 'resource',
+                resourceType: t.list.resource
+            };
         }
         else if (t.list &&
             typeof t.list == 'object' &&
@@ -147,13 +150,16 @@ export function argSigToJsonSchemaType(t, oldS) {
         'placeholder'
     ];
     preservedFields.forEach((field) => {
+        // @ts-ignore
         if (oldS[field] !== undefined) {
+            // @ts-ignore
             newS[field] = oldS[field];
         }
     });
     if (oldS.type != newS.type) {
         for (const prop of Object.getOwnPropertyNames(newS)) {
             if (prop != 'description') {
+                // @ts-ignore
                 delete oldS[prop];
             }
         }

package/package/monaco_workers/build_workers.js

@@ -2,48 +2,43 @@ import { useWorkerFactory } from 'monaco-editor-wrapper/workerFactory';
 // import cssWorker from 'monaco-editor-wrapper/workers/module/css?worker&url'
 // import htmlWorker from 'monaco-editor-wrapper/workers/module/html?worker&url'
 // import jsonWorker from 'monaco-editor-wrapper/workers/module/json?worker&url'
-// import editorWorker from 'monaco-editor-wrapper/workers/module/editor'
+// import editorWorker from 'monaco-editor-wrapper/workers/module/editor?worker&url'
 export function buildWorkerDefinition() {
     useWorkerFactory({
         ignoreMapping: true,
         workerLoaders: {
             editorWorkerService: () => {
-                return new Worker(new URL('./editorWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/editor', import.meta.url), {
                     type: 'module'
                 });
             },
             javascript: () => {
-                return new Worker(new URL('./tsWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/ts', import.meta.url), {
                     type: 'module'
                 });
             },
             typescript: () => {
-                return new Worker(new URL('./tsWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/ts', import.meta.url), {
                     type: 'module'
                 });
             },
             json: () => {
-                return new Worker(new URL('./jsonWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/json', import.meta.url), {
                     type: 'module'
                 });
             },
             html: () => {
-                return new Worker(new URL('./htmlWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/html', import.meta.url), {
                     type: 'module'
                 });
             },
             css: () => {
-                return new Worker(new URL('./cssWorker-es.js', import.meta.url), {
+                return new Worker(new URL('monaco-editor-wrapper/workers/module/css', import.meta.url), {
                     type: 'module'
                 });
             },
             graphql: () => {
-                // const workerFilename =
-                // const workerPathLocal = `${workerPath}/${workerFilename}`
-                // const workerUrl = new URL(workerPathLocal, basePath)
-                // return new Worker(workerUrl.href, {
-                // 	name: 'graphql'
-                // })
+                console.log('Creating graphql worker');
                 return new Worker(new URL(`./graphql.worker.bundle.js`, import.meta.url), {
                     name: 'graphql'
                 });