windmill-components 1.473.1 → 1.493.2

package/package/script_helpers.js

@@ -227,6 +227,7 @@ export async function main(message: string, name: string, step_id: string) {
 }
 `;
 const POSTGRES_INIT_CODE = `-- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- to only return the result of the last query use '--return_last_result'
 -- $1 name1 = default arg
 -- $2 name2
@@ -236,6 +237,7 @@ INSERT INTO demo VALUES (\$1::TEXT, \$2::INT, \$3::TEXT[]) RETURNING *;
 UPDATE demo SET col2 = \$4::INT WHERE col2 = \$2::INT;
 `;
 const MYSQL_INIT_CODE = `-- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- :name1 (text) = default arg
 -- :name2 (int)
 -- :name3 (int)
@@ -243,6 +245,7 @@ INSERT INTO demo VALUES (:name1, :name2);
 UPDATE demo SET col2 = :name3 WHERE col2 = :name2;
 `;
 const BIGQUERY_INIT_CODE = `-- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- @name1 (string) = default arg
 -- @name2 (integer)
 -- @name3 (string[])
@@ -251,6 +254,7 @@ INSERT INTO \`demodb.demo\` VALUES (@name1, @name2, @name3);
 UPDATE \`demodb.demo\` SET col2 = @name4 WHERE col2 = @name2;
 `;
 const ORACLEDB_INIT_CODE = `-- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- :name1 (text) = default arg
 -- :name2 (int)
 -- :name3 (int)
@@ -258,6 +262,7 @@ INSERT INTO demo VALUES (:name1, :name2);
 UPDATE demo SET col2 = :name3 WHERE col2 = :name2;
 `;
 const SNOWFLAKE_INIT_CODE = `-- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- ? name1 (varchar) = default arg
 -- ? name2 (int)
 INSERT INTO demo VALUES (?, ?);
@@ -267,12 +272,25 @@ UPDATE demo SET col2 = ? WHERE col2 = ?;
 `;
 const MSSQL_INIT_CODE = `-- return_last_result
 -- to pin the database use '-- database f/your/path'
+-- to stream a large query result to your workspace storage use '-- s3'
 -- @P1 name1 (varchar) = default arg
 -- @P2 name2 (int)
 -- @P3 name3 (int)
 INSERT INTO demo VALUES (@P1, @P2);
 UPDATE demo SET col2 = @P3 WHERE col2 = @P2;
 `;
+const DUCKDB_INIT_CODE = `-- $friends_csv (s3object)
+-- $name (text) = Ben
+
+ATTACH '$res:u/demo/amazed_postgresql' AS db (TYPE postgres);
+CREATE TABLE IF NOT EXISTS db.public.friends (name text);
+
+INSERT INTO db.public.friends
+  SELECT name FROM read_csv($friends_csv);
+
+SELECT 'Hello ' || $name || ', you have ' || 
+  (SELECT COUNT(*) FROM read_csv($friends_csv)) || ' new friends !';
+`;
 const GRAPHQL_INIT_CODE = `query($name4: String, $name2: Int, $name3: [String]) {
 	demo(name1: $name1, name2: $name2, name3: $name3) {
 		name1,
@@ -382,6 +400,51 @@ class Script
     }
 }
 `;
+const NU_INIT_CODE = `use std assert
+
+# Nushell
+# A new type of shell
+def main [
+    no_default: string,
+    name = "Nicolas Bourbaki",
+    age: int = 42,
+    date_of_birth?: datetime,
+    obj: record = {"records": "included"},
+    l: list<string> = ["or", "lists!"],
+    tables?: table,
+    enable_kill_mode?: bool = true,
+] {
+    # Test
+    # https://www.nushell.sh/book/testing.html
+		assert ($age == 42)
+
+    print $"Hello World and a warm welcome especially to ($name)"
+    print "and its acolytes.." $age $obj $l
+    print $tables
+
+    let secret = try { 
+      get_variable f/examples/secret
+    } catch { 
+      'No secret yet at f/examples/secret !' 
+    };
+
+    print $"The variable at \`f/examples/secret\`: ($secret)"
+    # fetch context variables
+    let user = $env.WM_USERNAME
+
+    # Nu pipelines
+    ls | where size > 1kb | sort-by modified | print "ls:" $in
+
+    # Nu works with existing data
+    # Nu speaks JSON, YAML, SQLite, Excel, and more out of the box. 
+    # It's easy to bring data into a Nu pipeline whether it's in a file, a database, or a web API:
+    let nu_license = http get https://api.github.com/repos/nushell/nushell | get license
+
+    return { splitted: ($name | split words), user: $user, nu_license: $nu_license}
+    # Interested in learning more?
+    # https://www.nushell.sh/book/getting_started.html
+}
+`;
 const FETCH_INIT_CODE = `export async function main(
 	url: string | undefined,
 	method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' = 'GET',
@@ -538,96 +601,127 @@ export async function main(approver?: string) {
 
 // add a form in Advanced - Suspend
 // all on approval steps: https://www.windmill.dev/docs/flows/flow_approval`;
-export const BUN_PREPROCESSOR_MODULE_CODE = `
-export async function preprocessor(
- wm_trigger: {
-   kind: 'http' | 'email' | 'webhook' | 'websocket' | 'kafka' | 'nats' | 'postgres' | 'sqs',
-   http?: {
-     route: string // The route path, e.g. "/users/:id"
-     path: string  // The actual path called, e.g. "/users/123"
-     method: string
-     params: Record<string, string> // path parameters
-     query: Record<string, string>  // query parameters
-     headers: Record<string, string>
-   },
-   websocket?: {
-     url: string // The websocket url
-   },
-   kafka?: {
-     brokers: string[]
-     topic: string
-     group_id: string
-   },
-   nats?: {
-     servers: string[]
-     subject: string
-     headers?: Record<string, string[]>
-     status?: number
-     description?: string
-     length: number
-   },
-   sqs?: {
-     queue_url: string,
-     message_id?: string,
-     receipt_handle?: string,
-     attributes: Record<string, string>,
-     message_attributes?: Record<string, {
-       string_value?: string,
-       data_type: string
-     }>
-   }
- },
- /* your other args */
-) {
- return {
-   // return the args to be passed to the runnable
- }
-}
-`;
-const DENO_PREPROCESSOR_MODULE_CODE = `
-export async function preprocessor(
- wm_trigger: {
-   kind: 'http' | 'email' | 'webhook' | 'websocket' | 'kafka' | 'nats' | 'postgres' | 'sqs',
-   http?: {
-     route: string // The route path, e.g. "/users/:id"
-     path: string  // The actual path called, e.g. "/users/123"
-     method: string
-     params: Record<string, string> // path parameters
-     query: Record<string, string>  // query parameters
-     headers: Record<string, string>
-   },
-   websocket?: {
-     url: string // The websocket url
-   },
-   kafka?: {
-     brokers: string[]
-     topic: string
-     group_id: string
-   },
-   nats?: {
-     servers: string[]
-     subject: string
-     headers?: Record<string, string[]>
-     status?: number
-     description?: string
-     length: number
-   },
-   sqs?: {
-     queue_url: string,
-     message_id?: string,
-     receipt_handle?: string,
-     attributes: Record<string, string>,
-     message_attributes?: Record<string, {
-       string_value?: string,
-       data_type: string
-     }>
-   }
- },
- /* your other args */
+export const TS_PREPROCESSOR_SCRIPT_INTRO = `/**
+ * Trigger preprocessor
+ *
+ * ⚠️ This function runs BEFORE the main function.
+ *
+ * It processes raw trigger data from various sources (webhook, custom HTTP route, SQS, WebSocket, Kafka, NATS, MQTT, Postgres, or email)
+ * before passing it to \`main\`. This separates the trigger logic from the main logic and keeps the auto-generated runnable UI clean.
+ *
+ * The returned object defines the parameter values passed to \`main()\`.
+ * e.g., { b: 1, a: 2 } → Calls \`main(2, 1)\`, assuming \`main\` is defined as \`main(a: number, b: number)\`.
+ * Ensure that the parameter names in \`main\` match the keys in the returned object.
+ * 
+ * Learn more: https://www.windmill.dev/docs/core_concepts/preprocessors
+ */\n`;
+export const TS_PREPROCESSOR_FLOW_INTRO = `/**
+ * Trigger preprocessor
+ *
+ * It processes raw trigger data from various sources (webhook, custom HTTP route, SQS, WebSocket, Kafka, NATS, MQTT, Postgres, or email) 
+ * before passing it to the flow. This separates the trigger logic from the flow logic and keeps the auto-generated UI clean.
+ * 
+ * The returned object determines the parameter values passed to the flow.
+ * e.g., \`{ b: 1, a: 2 }\` → Calls the flow with \`a = 2\` and \`b = 1\`, assuming the flow has two inputs called \`a\` and \`b\`.
+ * Ensure that the input names of the flow match the keys in the returned object.
+ * 
+ * Learn more: https://www.windmill.dev/docs/core_concepts/preprocessors
+ */\n`;
+export const TS_PREPROCESSOR_MODULE_CODE = `export async function preprocessor(
+  event:
+    | {
+      kind: "webhook";
+      body: any;
+      raw_string: string | null;
+      query: Record<string, string>;
+      headers: Record<string, string>;
+    }
+    | {
+      kind: "http";
+      body: any;
+      raw_string: string | null;
+      route: string;
+      path: string;
+      method: string;
+      params: Record<string, string>;
+      query: Record<string, string>;
+      headers: Record<string, string>;
+    }
+    | {
+      kind: "email";
+      parsed_email: any;
+      raw_email: string;
+    }
+    | { kind: "websocket"; msg: string; url: string }
+    | {
+      kind: "kafka";
+      payload: string;
+      brokers: string[];
+      topic: string;
+      group_id: string;
+    }
+    | {
+      kind: "nats";
+      payload: string;
+      servers: string[];
+      subject: string;
+      headers?: Record<string, string[]>;
+      status?: number;
+      description?: string;
+      length: number;
+    }
+    | {
+      kind: "sqs";
+      msg: string;
+      queue_url: string;
+      message_id?: string;
+      receipt_handle?: string;
+      attributes: Record<string, string>;
+      message_attributes?: Record<
+        string,
+        { string_value?: string; data_type: string }
+      >;
+    }
+    | {
+      kind: "mqtt";
+      payload: string;
+      topic: string;
+      retain: boolean;
+      pkid: number;
+      qos: number;
+      v5?: {
+        payload_format_indicator?: number;
+        topic_alias?: number;
+        response_topic?: string;
+        correlation_data?: Array<number>;
+        user_properties?: Array<[string, string]>;
+        subscription_identifiers?: Array<number>;
+        content_type?: string;
+      };
+    }
+    | {
+      kind: "gcp";
+      payload: string;
+      message_id: string;
+      subscription: string;
+      ordering_key?: string;
+      attributes?: Record<string, string>;
+      delivery_type: "push" | "pull";
+      headers?: Record<string, string>;
+      publish_time?: string;
+    }
+    | {
+      kind: "postgres";
+      transaction_type: "insert" | "update" | "delete",
+      schema_name: string,
+      table_name: string,
+      old_row?: Record<string, any>,
+      row: Record<string, any>
+    }
 ) {
- return {
-   // return the args to be passed to the runnable
- }
+  return {
+    // return the args to be passed to the runnable
+  };
 }
 `;
 const PYTHON_INIT_CODE_APPROVAL = `import wmill
@@ -656,57 +750,156 @@ def main():
 
 # add a form in Advanced - Suspend
 # all on approval steps: https://www.windmill.dev/docs/flows/flow_approval`;
-export const PYTHON_PREPROCESSOR_MODULE_CODE = `from typing import TypedDict, Literal
-class Http(TypedDict):
-   route: str # The route path, e.g. "/users/:id"
-   path: str  # The actual path called, e.g. "/users/123"
-   method: str
-   params: dict[str, str]
-   query: dict[str, str]
-   headers: dict[str, str]
-
-class Websocket(TypedDict):
-   url: str # The websocket url
-
-class Kafka(TypedDict):
-   topic: str
-   brokers: list[str]
-   group_id: str
-
-class Nats(TypedDict):
-   servers: list[str]
-   subject: str
-   headers: dict[str, list[str]] | None
-   status: int | None
-   description: str | None
-   length: int
+export const PYTHON_PREPROCESSOR_SCRIPT_INTRO = `# Trigger preprocessor
+#
+# ⚠️ This function runs BEFORE the main function.
+#
+# It processes raw trigger data from various sources (webhook, custom HTTP route, SQS, WebSocket, Kafka, NATS, MQTT, Postgres, or email) 
+# before passing it to \`main\`. This separates the trigger logic from the main logic and keeps the auto-generated UI clean.
+#
+# The returned object defines the parameter values passed to \`main()\`.
+# e.g., { b: 1, a: 2 } → Calls \`main(2, 1)\`, assuming \`main\` is defined as \`main(a: int, b: int)\`.
+# Ensure that the parameter names in \`main\` match the keys in the returned object.
+#
+# Learn more: https://www.windmill.dev/docs/core_concepts/preprocessors\n\n`;
+export const PYTHON_PREPROCESSOR_FLOW_INTRO = `# Trigger preprocessor
+#
+# It processes raw trigger data from various sources (webhook, custom HTTP route, SQS, WebSocket, Kafka, NATS, MQTT, Postgres, or email) 
+# before passing it to the flow. This separates the trigger logic from the flow logic and keeps the auto-generated UI clean.
+# 
+# The returned object determines the parameter values passed to the flow.
+# e.g., \`{ b: 1, a: 2 }\` → Calls the flow with \`a = 2\` and \`b = 1\`, assuming the flow has two inputs called \`a\` and \`b\`.
+# Ensure that the input names of the flow match the keys in the returned object.
+#
+# Learn more: https://www.windmill.dev/docs/core_concepts/preprocessors\n\n`;
+export const PYTHON_PREPROCESSOR_MODULE_CODE = `from typing import TypedDict, Literal, Optional, Union
+
+
+class WebhookEvent(TypedDict):
+    kind: Literal["webhook"]
+    body: dict
+    raw_string: Optional[str]
+    query: dict[str, str]
+    headers: dict[str, str]
+
+
+class HttpEvent(TypedDict):
+    kind: Literal["http"]
+    body: dict
+    raw_string: Optional[str]
+    route: str
+    path: str
+    method: str
+    params: dict[str, str]
+    query: dict[str, str]
+    headers: dict[str, str]
+
+
+class EmailEvent(TypedDict):
+    kind: Literal["email"]
+    parsed_email: dict
+    raw_email: str
+
+
+class WebsocketEvent(TypedDict):
+    kind: Literal["websocket"]
+    msg: str
+    url: str
+
+
+class KafkaEvent(TypedDict):
+    kind: Literal["kafka"]
+    payload: str
+    brokers: list[str]
+    topic: str
+    group_id: str
+
+
+class NatsEvent(TypedDict):
+    kind: Literal["nats"]
+    payload: str
+    servers: list[str]
+    subject: str
+    headers: Optional[dict[str, list[str]]]
+    status: Optional[int]
+    description: Optional[str]
+    length: int
+
 
 class MessageAttribute(TypedDict):
-   string_value: str | None
-   data_type: str
-
-class Sqs(TypedDict):
-   queue_url: str
-   message_id: str | None
-   receipt_handle: str | None
-   attributes: dict[str, str]
-   message_attributes: dict[str, MessageAttribute] | None
-
-class WmTrigger(TypedDict):
-   kind: Literal["http", "email", "webhook", "websocket", "kafka", "nats", "postgres", "sqs"]
-   http: Http | None
-   websocket: Websocket | None
-   kafka: Kafka | None
-   nats: Nats | None
-   sqs: Sqs | None
-
-def preprocessor(
-   wm_trigger: WmTrigger,
-   # your other args
-):
-   return {
-       # return the args to be passed to the runnable
-   }
+    string_value: Optional[str]
+    data_type: str
+
+
+class SqsEvent(TypedDict):
+    kind: Literal["sqs"]
+    msg: str
+    queue_url: str
+    message_id: Optional[str]
+    receipt_handle: Optional[str]
+    attributes: dict[str, str]
+    message_attributes: Optional[dict[str, MessageAttribute]]
+
+
+class MqttV5Properties(TypedDict, total=False):
+    payload_format_indicator: Optional[int]
+    topic_alias: Optional[int]
+    response_topic: Optional[str]
+    correlation_data: Optional[list[int]]
+    user_properties: Optional[list[tuple[str, str]]]
+    subscription_identifiers: Optional[list[int]]
+    content_type: Optional[str]
+
+
+class MqttEvent(TypedDict):
+    kind: Literal["mqtt"]
+    payload: str
+    topic: str
+    retain: bool
+    pkid: int
+    qos: int
+    v5: Optional[MqttV5Properties]
+
+
+class GcpEvent(TypedDict):
+    kind: Literal["gcp"]
+    payload: str
+    message_id: str
+    subscription: str
+    ordering_key: Optional[str]
+    attributes: Optional[dict[str, str]]
+    delivery_type: Literal["push", "pull"]
+    headers: Optional[dict[str, str]]
+    publish_time: Optional[str]
+
+
+class PostgresEvent(TypedDict):
+    kind: Literal["postgres"]
+    transaction_type: Literal["insert", "update", "delete"]
+    schema_name: str
+    table_name: str
+    old_row: Optional[dict[str, any]]
+    row: dict[str, any]
+
+
+Event = Union[
+    WebhookEvent,
+    HttpEvent,
+    EmailEvent,
+    WebsocketEvent,
+    KafkaEvent,
+    NatsEvent,
+    SqsEvent,
+    MqttEvent,
+    GcpEvent,
+    PostgresEvent,
+]
+
+
+def preprocessor(event: Event):
+    return {
+        # return the args to be passed to the runnable
+    }
 `;
 const DOCKER_INIT_CODE = `# shellcheck shell=bash
 # docker
@@ -740,6 +933,12 @@ inventory:
   - resource_type: ansible_inventory
     # You can pin an inventory to this script by hardcoding the resource path:
     # resource: u/user/your_resource
+# - name: hcloud.yml
+#   resource_type: dynamic_inventory
+
+options:
+  - verbosity: vvv
+
 
 # File resources will be written in the relative \`target\` location before
 # running the playbook
@@ -755,11 +954,15 @@ extra_vars:
   world_qualifier:
     type: string
 
+# If using Ansible Vault:
+# vault_password: u/user/ansible_vault_password
+
 dependencies:
   galaxy:
     collections:
       - name: community.general
       - name: community.vmware
+    roles:
   python:
     - jmespath
 ---
@@ -782,6 +985,61 @@ dependencies:
       content: "{{ my_result | to_json }}"
       dest: result.json
 `;
+const JAVA_INIT_CODE = `//requirements:
+//com.google.code.gson:gson:2.8.9
+//com.github.ricksbrown:cowsay:1.1.0
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.github.ricksbrown.cowsay.Cowsay;
+import com.github.ricksbrown.cowsay.plugin.CowExecutor;
+
+public class Main {
+  public static class Person {
+    private String name;
+    private int age;
+
+    // Constructor
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+  }
+
+  public static Object main(
+    // Primitive
+    int a,
+    float b,
+    // Objects
+    Integer age,
+    Float d,
+    Object e,
+    String name,
+    // Lists
+    String[] f
+    // No trailing commas!
+    ){
+    Gson gson = new Gson();
+
+    // Get resources
+    var theme = Wmill.getResource("f/app_themes/theme_0");
+    System.out.println("Theme: " + theme);
+    
+    // Create a Person object
+    Person person = new Person( (name == "") ? "Alice" : name, (age == null) ? 30 : age);
+
+    // Serialize the Person object to JSON
+    String json = gson.toJson(person);
+    System.out.println("Serialized JSON: " + json);
+
+    // Use cowsay
+    String[] args = new String[]{"-f", "dragon", json };
+    String result = Cowsay.say(args);
+    return result;
+  }
+}
+`;
+// for related places search: ADD_NEW_LANG
 export const INITIAL_CODE = {
     bun: {
         scriptInitCodeBlock: BUN_INIT_BLOCK,
@@ -789,7 +1047,7 @@ export const INITIAL_CODE = {
         trigger: BUN_INIT_CODE_TRIGGER,
         approval: BUN_INIT_CODE_APPROVAL,
         failure: BUN_FAILURE_MODULE_CODE,
-        preprocessor: BUN_PREPROCESSOR_MODULE_CODE,
+        preprocessor: TS_PREPROCESSOR_FLOW_INTRO + TS_PREPROCESSOR_MODULE_CODE,
         clear: BUN_INIT_CODE_CLEAR
     },
     python3: {
@@ -797,7 +1055,7 @@ export const INITIAL_CODE = {
         trigger: PYTHON_INIT_CODE_TRIGGER,
         approval: PYTHON_INIT_CODE_APPROVAL,
         failure: PYTHON_FAILURE_MODULE_CODE,
-        preprocessor: PYTHON_PREPROCESSOR_MODULE_CODE,
+        preprocessor: PYTHON_PREPROCESSOR_FLOW_INTRO + PYTHON_PREPROCESSOR_MODULE_CODE,
         clear: PYTHON_INIT_CODE_CLEAR
     },
     deno: {
@@ -806,7 +1064,7 @@ export const INITIAL_CODE = {
         trigger: DENO_INIT_CODE_TRIGGER,
         approval: DENO_INIT_CODE_APPROVAL,
         failure: DENO_FAILURE_MODULE_CODE,
-        preprocessor: DENO_PREPROCESSOR_MODULE_CODE,
+        preprocessor: TS_PREPROCESSOR_FLOW_INTRO + TS_PREPROCESSOR_MODULE_CODE,
         fetch: FETCH_INIT_CODE,
         clear: DENO_INIT_CODE_CLEAR
     },
@@ -839,6 +1097,9 @@ export const INITIAL_CODE = {
     mssql: {
         script: MSSQL_INIT_CODE
     },
+    duckdb: {
+        script: DUCKDB_INIT_CODE
+    },
     graphql: {
         script: GRAPHQL_INIT_CODE
     },
@@ -857,12 +1118,19 @@ export const INITIAL_CODE = {
     csharp: {
         script: CSHARP_INIT_CODE
     },
+    nu: {
+        script: NU_INIT_CODE
+    },
     docker: {
         script: DOCKER_INIT_CODE
     },
     bunnative: {
         script: BUNNATIVE_INIT_CODE
+    },
+    java: {
+        script: JAVA_INIT_CODE
     }
+    // for related places search: ADD_NEW_LANG
 };
 export function isInitialCode(content) {
     for (const lang of Object.values(INITIAL_CODE)) {
@@ -967,6 +1235,9 @@ export function initialCode(language, kind, subkind, templateScript) {
     else if (language == 'graphql') {
         return INITIAL_CODE.graphql.script;
     }
+    else if (language == 'duckdb') {
+        return INITIAL_CODE.duckdb.script;
+    }
     else if (language == 'php') {
         return INITIAL_CODE.php.script;
     }
@@ -979,6 +1250,13 @@ export function initialCode(language, kind, subkind, templateScript) {
     else if (language == 'csharp') {
         return INITIAL_CODE.csharp.script;
     }
+    else if (language == 'nu') {
+        return INITIAL_CODE.nu.script;
+    }
+    else if (language == 'java') {
+        return INITIAL_CODE.java.script;
+        // for related places search: ADD_NEW_LANG
+    }
     else if (language == 'bun' || language == 'bunnative') {
         if (kind == 'trigger') {
             return INITIAL_CODE.bun.trigger;