windmill-components 1.87.0 → 1.89.1

package/package/infer.js

@@ -0,0 +1,144 @@
+import { ScriptService } from './gen';
+import { get, writable } from 'svelte/store';
+import { sortObject } from './utils.js';
+const loadSchemaLastRun = writable(undefined);
+export async function inferArgs(language, code, schema) {
+    let lastRun = get(loadSchemaLastRun);
+    let inferedSchema;
+    if (lastRun && code == lastRun[0] && lastRun[1]) {
+        inferedSchema = lastRun[1];
+    }
+    else {
+        if (code == '') {
+            code = ' ';
+        }
+        if (language == 'python3') {
+            inferedSchema = await ScriptService.pythonToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'deno') {
+            inferedSchema = await ScriptService.denoToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'go') {
+            inferedSchema = await ScriptService.goToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'bash') {
+            inferedSchema = await ScriptService.bashToJsonschema({
+                requestBody: code
+            });
+        }
+        else {
+            return;
+        }
+        if (inferedSchema.type == 'Invalid') {
+            throw new Error(inferedSchema.error);
+        }
+        loadSchemaLastRun.set([code, inferedSchema]);
+    }
+    schema.required = [];
+    const oldProperties = Object.assign({}, schema.properties);
+    schema.properties = {};
+    for (const arg of inferedSchema.args) {
+        if (!(arg.name in oldProperties)) {
+            schema.properties[arg.name] = { description: '', type: '' };
+        }
+        else {
+            schema.properties[arg.name] = oldProperties[arg.name];
+        }
+        schema.properties[arg.name] = sortObject(schema.properties[arg.name]);
+        argSigToJsonSchemaType(arg.typ, schema.properties[arg.name]);
+        schema.properties[arg.name].default = arg.default;
+        if (!arg.has_default && !schema.required.includes(arg.name)) {
+            schema.required.push(arg.name);
+        }
+    }
+}
+function argSigToJsonSchemaType(t, oldS) {
+    const newS = { type: '', description: '' };
+    if (t === 'int') {
+        newS.type = 'integer';
+    }
+    else if (t === 'float') {
+        newS.type = 'number';
+    }
+    else if (t === 'bool') {
+        newS.type = 'boolean';
+    }
+    else if (t === 'email') {
+        newS.type = 'string';
+        newS.format = 'email';
+    }
+    else if (t === 'sql') {
+        newS.type = 'string';
+        newS.format = 'sql';
+    }
+    else if (t === 'yaml') {
+        newS.type = 'string';
+        newS.format = 'yaml';
+    }
+    else if (t === 'bytes') {
+        newS.type = 'string';
+        newS.contentEncoding = 'base64';
+    }
+    else if (t === 'datetime') {
+        newS.type = 'string';
+        newS.format = 'date-time';
+    }
+    else if (typeof t !== 'string' && `object` in t) {
+        newS.type = 'object';
+        if (t.object) {
+            const properties = {};
+            for (const prop of t.object) {
+                properties[prop.key] = {};
+                argSigToJsonSchemaType(prop.typ, properties[prop.key]);
+            }
+            newS.properties = properties;
+        }
+    }
+    else if (typeof t !== 'string' && `str` in t) {
+        newS.type = 'string';
+        if (t.str) {
+            newS.enum = t.str;
+        }
+    }
+    else if (typeof t !== 'string' && `resource` in t) {
+        newS.type = 'object';
+        newS.format = `resource-${t.resource}`;
+    }
+    else if (typeof t !== 'string' && `list` in t) {
+        newS.type = 'array';
+        if (t.list === 'int' || t.list === 'float') {
+            newS.items = { type: 'number' };
+        }
+        else if (t.list === 'bytes') {
+            newS.items = { type: 'string', contentEncoding: 'base64' };
+        }
+        else if (t.list && typeof t.list == 'object' && `object` in t.list) {
+            newS.items = { type: 'object' };
+        }
+        else {
+            newS.items = { type: 'string' };
+        }
+    }
+    else {
+        newS.type = 'object';
+    }
+    if (oldS.type != newS.type) {
+        for (const prop of Object.getOwnPropertyNames(newS)) {
+            if (prop != 'description') {
+                delete oldS[prop];
+            }
+        }
+    }
+    let oldDescription = oldS.description;
+    Object.assign(oldS, newS);
+    oldS.description = oldDescription;
+    if (oldS.format?.startsWith('resource-') && newS.type != 'object') {
+        oldS.format = undefined;
+    }
+}

package/package/init_scripts/python_failure_module.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "import os\n\n# flow is considered recovered and a success unless an exception is raised\n\n\ndef main(message: str, name: str):\n    flow_id = os.environ.get(\"WM_FLOW_JOB_ID\")\n    print(\"message\", message)\n    print(\"name\", name)\n    return message, flow_id";
+export default _default;

package/package/init_scripts/python_failure_module.js

@@ -0,0 +1,10 @@
+export default `import os
+
+# flow is considered recovered and a success unless an exception is raised
+
+
+def main(message: str, name: str):
+    flow_id = os.environ.get("WM_FLOW_JOB_ID")
+    print("message", message)
+    print("name", name)
+    return message, flow_id`;

package/package/init_scripts/python_init_code.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "import os\nimport wmill\n\n# You can import any PyPi package. \n# See here for more info: https://docs.windmill.dev/docs/advanced/imports#python\n\n# you can use typed resources by doing a type alias to dict\n#postgresql = dict\n\ndef main(\n    no_default: str,\n    #db: postgresql,\n    name=\"Nicolas Bourbaki\",\n    age=42,\n    obj: dict = {\"even\": \"dicts\"},\n    l: list = [\"or\", \"lists!\"],\n    file_: bytes = bytes(0),\n):\n\n    print(f\"Hello World and a warm welcome especially to {name}\")\n    print(\"and its acolytes..\", age, obj, l, len(file_))\n\n    # retrieve variables, resources, states using the wmill client\n    try:\n        secret = wmill.get_variable(\"f/examples/secret\")\n    except:\n        secret = \"No secret yet at f/examples/secret !\"\n    print(f\"The variable at `f/examples/secret`: {secret}\")\n\n    # Get last state of this script execution by the same trigger/user\n    last_state = wmill.get_state()\n    new_state = {\"foo\": 42} if last_state is None else last_state\n    new_state[\"foo\"] += 1\n    wmill.set_state(new_state)\n\n    # fetch context variables\n    user = os.environ.get(\"WM_USERNAME\")\n\n    # return value is converted to JSON\n    return {\"splitted\": name.split(), \"user\": user, \"state\": new_state}";
+export default _default;

package/package/init_scripts/python_init_code.js

@@ -0,0 +1,40 @@
+export default `import os
+import wmill
+
+# You can import any PyPi package. 
+# See here for more info: https://docs.windmill.dev/docs/advanced/imports#python
+
+# you can use typed resources by doing a type alias to dict
+#postgresql = dict
+
+def main(
+    no_default: str,
+    #db: postgresql,
+    name="Nicolas Bourbaki",
+    age=42,
+    obj: dict = {"even": "dicts"},
+    l: list = ["or", "lists!"],
+    file_: bytes = bytes(0),
+):
+
+    print(f"Hello World and a warm welcome especially to {name}")
+    print("and its acolytes..", age, obj, l, len(file_))
+
+    # retrieve variables, resources, states using the wmill client
+    try:
+        secret = wmill.get_variable("f/examples/secret")
+    except:
+        secret = "No secret yet at f/examples/secret !"
+    print(f"The variable at \`f/examples/secret\`: {secret}")
+
+    # Get last state of this script execution by the same trigger/user
+    last_state = wmill.get_state()
+    new_state = {"foo": 42} if last_state is None else last_state
+    new_state["foo"] += 1
+    wmill.set_state(new_state)
+
+    # fetch context variables
+    user = os.environ.get("WM_USERNAME")
+
+    # return value is converted to JSON
+    return {"splitted": name.split(), "user": user, "state": new_state}`;

package/package/init_scripts/python_init_code_clear.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "# import wmill\n\n\ndef main(x: str):\n    return x";
+export default _default;

package/package/init_scripts/python_init_code_clear.js

@@ -0,0 +1,5 @@
+export default `# import wmill
+
+
+def main(x: str):
+    return x`;

package/package/init_scripts/python_init_code_trigger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "import wmill\n\n\ndef main():\n    # A common trigger script would follow this pattern:\n    # 1. Get the last saved state\n    # const state = wnmill.get_state()\n    # 2. Get the actual state from the external service\n    # const newState = ...\n    # 3. Compare the two states and update the internal state\n    # wmill.setState(newState)\n    # 4. Return the new rows\n    # return range from (state to newState)\n    return [1, 2, 3]";
+export default _default;

package/package/init_scripts/python_init_code_trigger.js

@@ -0,0 +1,14 @@
+export default `import wmill
+
+
+def main():
+    # A common trigger script would follow this pattern:
+    # 1. Get the last saved state
+    # const state = wnmill.get_state()
+    # 2. Get the actual state from the external service
+    # const newState = ...
+    # 3. Compare the two states and update the internal state
+    # wmill.setState(newState)
+    # 4. Return the new rows
+    # return range from (state to newState)
+    return [1, 2, 3]`;

package/package/logout.d.ts

@@ -0,0 +1,3 @@
+export declare function logoutWithRedirect(rd?: string): Promise<void>;
+export declare function logout(): Promise<void>;
+export declare function clearUser(): Promise<void>;

package/package/logout.js

@@ -0,0 +1,30 @@
+import { goto } from '$app/navigation';
+import { UserService } from './gen';
+import { clearStores } from './stores.js';
+import { sendUserToast } from './utils.js';
+export async function logoutWithRedirect(rd) {
+    await clearUser();
+    if (rd && rd != "/" && rd?.split('?')[0] != '/user/login') {
+        const error = document.cookie.includes('token')
+            ? `error=${encodeURIComponent('You have been logged out because your session has expired.')}&`
+            : '';
+        console.log({ rd });
+        goto(`/user/login?${error}${rd ? 'rd=' + encodeURIComponent(rd) : ''}`, { replaceState: true });
+    }
+    else {
+        goto('/user/login', { replaceState: true });
+    }
+}
+export async function logout() {
+    await clearUser();
+    goto(`/user/login`);
+    sendUserToast('you have been logged out');
+}
+export async function clearUser() {
+    try {
+        clearStores();
+        await UserService.logout();
+    }
+    catch (error) {
+    }
+}

package/package/script_helpers.d.ts

@@ -0,0 +1,20 @@
+import type { Script } from './gen';
+import PYTHON_INIT_CODE from './init_scripts/python_init_code';
+import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
+import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
+import PYTHON_FAILURE_MODULE_CODE from './init_scripts/python_failure_module';
+export { PYTHON_INIT_CODE, PYTHON_INIT_CODE_CLEAR, PYTHON_INIT_CODE_TRIGGER, PYTHON_FAILURE_MODULE_CODE };
+export declare const DENO_INIT_CODE: string;
+export declare const GO_INIT_CODE = "package inner\n\nimport (\n\t\"fmt\"\n\t\"rsc.io/quote\"\n\t// wmill \"github.com/windmill-labs/windmill-go-client\"\n)\n\n// the main must return (interface{}, error)\n\nfunc main(x string, nested struct {\n\tFoo string `json:\"foo\"`\n}) (interface{}, error) {\n\tfmt.Println(\"Hello, World\")\n\tfmt.Println(nested.Foo)\n\tfmt.Println(quote.Opt())\n\t// v, _ := wmill.GetVariable(\"f/examples/secret\")\n\treturn x, nil\n}\n";
+export declare const GO_FAILURE_MODULE_CODE = "package inner\n\nimport (\n\t\"fmt\"\n  \"os\"\n)\n\n// connect the error parameter to 'previous_result.error'\n\nfunc main(message string, name string) (interface{}, error) {\n\tfmt.Println(message)\n\tfmt.Println(name)\n\tfmt.Println(\"flow id that failed\", os.Getenv(\"WM_FLOW_JOB_ID\"))\n  return message, nil\n}\n";
+export declare const DENO_INIT_CODE_CLEAR: string;
+export declare const DENO_FAILURE_MODULE_CODE = "// flow is considered recovered and a success unless an exception is thrown\n\nexport async function main(message: string, name: string) {\n  const flow_id = Deno.env.get(\"WM_FLOW_JOB_ID\")\n  console.log(\"message\", message)\n  console.log(\"name\",name)\n  return { message, flow_id }\n}\n";
+export declare const POSTGRES_INIT_CODE: string;
+export declare const MYSQL_INIT_CODE: string;
+export declare const FETCH_INIT_CODE = "export async function main(\n\turl: string | undefined,\n\tmethod: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' = 'GET',\n\tbody: Object = {},\n\theaders: Record<string, string> = {}\n): Promise<Response | null> {\n\tif (!url) {\n\t\tconsole.error('Error: URL is undefined')\n\t\treturn null\n\t}\n\n\tconst requestOptions: RequestInit = {\n\t\tmethod: method || 'GET',\n\t\theaders: headers || {}\n\t}\n\n\tif (requestOptions.method !== 'GET' && requestOptions.method !== 'HEAD' && body !== undefined) {\n\t\trequestOptions.body = JSON.stringify(body)\n\t\trequestOptions.headers = {\n\t\t\t'Content-Type': 'application/json',\n\t\t\t...requestOptions.headers\n\t\t}\n\t}\n\n\treturn await fetch(url, requestOptions)\n\t\t.then((res) => res.json())\n\t\t.catch(() => {\n\t\t\tthrow new Error('An error occured')\n\t\t})\n}";
+export declare const BASH_INIT_CODE = "# arguments of the form X=\"$I\" are parsed as parameters X of type string\nmsg=\"$1\"\ndflt=\"${2:-default value}\"\n\n# the last line of the stdout is the return value\necho \"Hello $msg\"\n";
+export declare const DENO_INIT_CODE_TRIGGER: string;
+export declare const GO_INIT_CODE_TRIGGER = "package inner\n\nimport (\n\twmill \"github.com/windmill-labs/windmill-go-client\"\n)\n\nfunc main() (interface{}, error) {\n\n\t// A common trigger script would follow this pattern:\n\t// 1. Get the last saved state\n\tstate, _ := wmill.GetState()\n\t// 2. Get the actual state from the external service\n\t// newState := ...\n\t// 3. Compare the two states and update the internal state\n\twmill.SetState(4)\n\t// 4. Return the new rows\n\n\treturn state, nil\n\n\t// In subsequent scripts, you may refer to each row/value returned by the trigger script using\n\t// 'flow_input.iter.value'\n}\n";
+export declare const DENO_INIT_CODE_APPROVAL = "import * as wmill from \"https://deno.land/x/windmill@v1.41.0/mod.ts\"\n\nexport async function main(approver?: string) {\n  return wmill.getResumeEndpoints(approver)\n}";
+export declare function isInitialCode(content: string): boolean;
+export declare function initialCode(language: 'deno' | 'python3' | 'go' | 'bash', kind: Script.kind, subkind: 'pgsql' | 'mysql' | 'flow' | 'script' | 'fetch' | undefined): string;

package/package/script_helpers.js

@@ -0,0 +1,288 @@
+import PYTHON_INIT_CODE from './init_scripts/python_init_code';
+import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
+import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
+import PYTHON_FAILURE_MODULE_CODE from './init_scripts/python_failure_module';
+export { PYTHON_INIT_CODE, PYTHON_INIT_CODE_CLEAR, PYTHON_INIT_CODE_TRIGGER, PYTHON_FAILURE_MODULE_CODE };
+export const DENO_INIT_CODE = `// Ctrl/CMD+. to cache dependencies on imports hover, Ctrl/CMD+S to format.
+
+// import { toWords } from "npm:number-to-words@1"
+// import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main(
+  a: number,
+  b: "my" | "enum",
+  //c: wmill.Resource<'postgresql'>,
+  d = "inferred type string from default arg",
+  e = { nested: "object" },
+  //e: wmill.Base64
+) {
+  // let x = await wmill.getVariable('u/user/foo')
+  return { foo: a };
+}
+`;
+export const GO_INIT_CODE = `package inner
+
+import (
+	"fmt"
+	"rsc.io/quote"
+	// wmill "github.com/windmill-labs/windmill-go-client"
+)
+
+// the main must return (interface{}, error)
+
+func main(x string, nested struct {
+	Foo string \`json:"foo"\`
+}) (interface{}, error) {
+	fmt.Println("Hello, World")
+	fmt.Println(nested.Foo)
+	fmt.Println(quote.Opt())
+	// v, _ := wmill.GetVariable("f/examples/secret")
+	return x, nil
+}
+`;
+export const GO_FAILURE_MODULE_CODE = `package inner
+
+import (
+	"fmt"
+  "os"
+)
+
+// connect the error parameter to 'previous_result.error'
+
+func main(message string, name string) (interface{}, error) {
+	fmt.Println(message)
+	fmt.Println(name)
+	fmt.Println("flow id that failed", os.Getenv("WM_FLOW_JOB_ID"))
+  return message, nil
+}
+`;
+export const DENO_INIT_CODE_CLEAR = `// import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main(x: string) {
+  return x
+}
+`;
+export const DENO_FAILURE_MODULE_CODE = `// flow is considered recovered and a success unless an exception is thrown
+
+export async function main(message: string, name: string) {
+  const flow_id = Deno.env.get("WM_FLOW_JOB_ID")
+  console.log("message", message)
+  console.log("name",name)
+  return { message, flow_id }
+}
+`;
+export const POSTGRES_INIT_CODE = `import {
+  pgSql,
+  type Resource,
+} from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts";
+
+//PG parameterized statement. No SQL injection is possible.
+export async function main(
+  db: Resource<"postgresql"> = "$res:f/examples/demodb",
+  key: number,
+  value: string,
+) {
+  const query = await pgSql(
+    db,
+  )\`INSERT INTO demo VALUES (\${key}, \${value}) RETURNING *\`;
+  return query.rows;
+
+}
+	/**
+	// The following code accepts raw queries. The code above is recommended because it uses SQL prepared statement.
+	import { pgClient, type Resource, type Sql } from "https://deno.land/x/windmill@v1.88.1/mod.ts";
+
+	export async function main(
+		db: Resource<"postgresql">,
+		query: Sql = "SELECT * FROM demo;",
+	) {
+		if(!query) {
+			throw Error('Query must not be empty.')
+		}
+		const { rows } = await pgClient(db).queryObject(query);
+		return rows;
+	}
+   */
+	
+`;
+export const MYSQL_INIT_CODE = `import {
+  mySql,
+  type Resource
+} from "https://deno.land/x/windmill@v${__pkg__.version}/mysql.ts";
+
+// MySQL parameterized statement. No SQL injection is possible.
+export async function main(
+  db: Resource<"mysql">,
+  key: number,
+  value: string,
+) {
+  const query = await mySql(
+    db
+  )\`INSERT INTO demo VALUES (\${key}, \${value})\`;
+  return query.rows;
+}`;
+export const FETCH_INIT_CODE = `export async function main(
+	url: string | undefined,
+	method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' = 'GET',
+	body: Object = {},
+	headers: Record<string, string> = {}
+): Promise<Response | null> {
+	if (!url) {
+		console.error('Error: URL is undefined')
+		return null
+	}
+
+	const requestOptions: RequestInit = {
+		method: method || 'GET',
+		headers: headers || {}
+	}
+
+	if (requestOptions.method !== 'GET' && requestOptions.method !== 'HEAD' && body !== undefined) {
+		requestOptions.body = JSON.stringify(body)
+		requestOptions.headers = {
+			'Content-Type': 'application/json',
+			...requestOptions.headers
+		}
+	}
+
+	return await fetch(url, requestOptions)
+		.then((res) => res.json())
+		.catch(() => {
+			throw new Error('An error occured')
+		})
+}`;
+export const BASH_INIT_CODE = `# arguments of the form X="$I" are parsed as parameters X of type string
+msg="$1"
+dflt="\${2:-default value}"
+
+# the last line of the stdout is the return value
+echo "Hello $msg"
+`;
+export const DENO_INIT_CODE_TRIGGER = `import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main() {
+
+  // A common trigger script would follow this pattern:
+  // 1. Get the last saved state
+  // const state = await wmill.getState()
+  // 2. Get the actual state from the external service
+  // const newState = await (await fetch('https://hacker-news.firebaseio.com/v0/topstories.json')).json()
+  // 3. Compare the two states and update the internal state
+  // await wmill.setState(newState)
+  // 4. Return the new rows
+  // return range from (state to newState)
+
+  return [1,2,3]
+
+  // In subsequent scripts, you may refer to each row/value returned by the trigger script using
+  // 'flow_input.iter.value'
+}
+`;
+export const GO_INIT_CODE_TRIGGER = `package inner
+
+import (
+	wmill "github.com/windmill-labs/windmill-go-client"
+)
+
+func main() (interface{}, error) {
+
+	// A common trigger script would follow this pattern:
+	// 1. Get the last saved state
+	state, _ := wmill.GetState()
+	// 2. Get the actual state from the external service
+	// newState := ...
+	// 3. Compare the two states and update the internal state
+	wmill.SetState(4)
+	// 4. Return the new rows
+
+	return state, nil
+
+	// In subsequent scripts, you may refer to each row/value returned by the trigger script using
+	// 'flow_input.iter.value'
+}
+`;
+export const DENO_INIT_CODE_APPROVAL = `import * as wmill from "https://deno.land/x/windmill@v1.41.0/mod.ts"
+
+export async function main(approver?: string) {
+  return wmill.getResumeEndpoints(approver)
+}`;
+const ALL_INITIAL_CODE = [
+    PYTHON_INIT_CODE,
+    PYTHON_INIT_CODE_TRIGGER,
+    DENO_INIT_CODE,
+    POSTGRES_INIT_CODE,
+    DENO_INIT_CODE_TRIGGER,
+    DENO_INIT_CODE_CLEAR,
+    PYTHON_INIT_CODE_CLEAR,
+    DENO_INIT_CODE_APPROVAL,
+    DENO_FAILURE_MODULE_CODE
+];
+export function isInitialCode(content) {
+    for (const code of ALL_INITIAL_CODE) {
+        if (content === code) {
+            return true;
+        }
+    }
+    return false;
+}
+export function initialCode(language, kind, subkind) {
+    if (language === 'deno') {
+        if (kind === 'trigger') {
+            return DENO_INIT_CODE_TRIGGER;
+        }
+        else if (kind === 'script') {
+            if (subkind === 'flow') {
+                return DENO_INIT_CODE_CLEAR;
+            }
+            else if (subkind === 'pgsql') {
+                return POSTGRES_INIT_CODE;
+            }
+            else if (subkind === 'mysql') {
+                return MYSQL_INIT_CODE;
+            }
+            else if (subkind === 'fetch') {
+                return FETCH_INIT_CODE;
+            }
+            else {
+                return DENO_INIT_CODE;
+            }
+        }
+        else if (kind === 'failure') {
+            return DENO_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'approval') {
+            return DENO_INIT_CODE_APPROVAL;
+        }
+        else {
+            return DENO_INIT_CODE;
+        }
+    }
+    else if (language === 'python3') {
+        if (subkind === 'flow') {
+            return PYTHON_INIT_CODE_CLEAR;
+        }
+        else if (kind === 'failure') {
+            return PYTHON_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'trigger') {
+            return PYTHON_INIT_CODE_TRIGGER;
+        }
+        else {
+            return PYTHON_INIT_CODE;
+        }
+    }
+    else if (language == 'bash') {
+        return BASH_INIT_CODE;
+    }
+    else {
+        if (kind === 'failure') {
+            return GO_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'trigger') {
+            return GO_INIT_CODE_TRIGGER;
+        }
+        else {
+            return GO_INIT_CODE;
+        }
+    }
+}

package/package/scripts.d.ts

@@ -0,0 +1,3 @@
+import type { Schema } from './common';
+export declare function loadSchema(path: string, hash?: string): Promise<Schema>;
+export declare function loadSchemaFlow(path: string): Promise<Schema>;

package/package/scripts.js

@@ -0,0 +1,39 @@
+import { get } from 'svelte/store';
+import { FlowService, ScriptService } from './gen';
+import { inferArgs } from './infer';
+import { workspaceStore } from './stores';
+import { emptySchema } from './utils';
+export async function loadSchema(path, hash) {
+    if (path.startsWith('hub/')) {
+        const { content, language, schema } = await ScriptService.getHubScriptByPath({ path });
+        if (language == 'deno') {
+            const newSchema = emptySchema();
+            await inferArgs('deno', content ?? '', newSchema);
+            return newSchema;
+        }
+        else {
+            return schema ?? emptySchema();
+        }
+    }
+    else if (hash) {
+        const script = await ScriptService.getScriptByHash({
+            workspace: get(workspaceStore),
+            hash
+        });
+        return script.schema;
+    }
+    else {
+        const script = await ScriptService.getScriptByPath({
+            workspace: get(workspaceStore),
+            path: path ?? ''
+        });
+        return script.schema;
+    }
+}
+export async function loadSchemaFlow(path) {
+    const flow = await FlowService.getFlowByPath({
+        workspace: get(workspaceStore),
+        path: path ?? ''
+    });
+    return flow.schema;
+}