fix

* react to merged pr

* fix

* fix

.aiderignore

@@ -0,0 +1,3 @@
+/*
+!/backend/
+!/frontend/

.github/workflows/aider-after-review.yaml

@@ -0,0 +1,170 @@
+name: Aider Auto-fix PR Review Change Requests
+
+on:
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  auto-fix-review:
+    if: github.event.review.state == 'changes_requested' && contains(github.event.pull_request.title, '[Aider PR]')
+    runs-on: ubicloud-standard-8
+    permissions:
+      contents: write
+      pull-requests: write
+    env:
+      GEMINI_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+      GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      WINDMILL_TOKEN: ${{ secrets.WINDMILL_TOKEN }}
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: audit
+
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Configure Git User
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Checkout PR Branch
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          echo "PR review trigger: Checking out PR branch..."
+          PR_NUMBER=${{ github.event.pull_request.number }}
+          PR_HEAD_REF=$(gh pr view $PR_NUMBER --json headRefName -q .headRefName --repo $GITHUB_REPOSITORY)
+          if [[ -z "$PR_HEAD_REF" || "$PR_HEAD_REF" == "null" ]]; then
+             echo "::error::Could not determine PR head branch for PR #$PR_NUMBER via gh CLI."
+             exit 1
+          fi
+          echo "Checking out PR head branch: $PR_HEAD_REF for PR #$PR_NUMBER"
+          git fetch origin "refs/heads/${PR_HEAD_REF}:refs/remotes/origin/${PR_HEAD_REF}" --no-tags
+          git checkout "$PR_HEAD_REF"
+          echo "Successfully checked out branch $(git rev-parse --abbrev-ref HEAD)"
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Aider and Dependencies
+        run: |
+          python -m pip install aider-install; aider-install
+          pip install -U google-generativeai
+          sudo apt-get update && sudo apt-get install -y jq
+
+      - name: Generate Prompt from Review
+        id: generate_prompt
+        shell: bash
+        run: |
+          mkdir -p .github/aider
+          PROMPT_FILE_PATH=".github/aider/review-prompt.txt"
+
+          # Get PR review body
+          REVIEW_BODY="${{ github.event.review.body }}"
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+
+          # Get PR description for context NOT USED FOR NOW
+          # PR_DETAILS=$(gh pr view $PR_NUMBER --json title,body --repo $GITHUB_REPOSITORY)
+          # PR_TITLE=$(echo "$PR_DETAILS" | jq -r .title)
+          # PR_BODY=$(echo "$PR_DETAILS" | jq -r .body)
+
+          # Get all PR review comments
+          REVIEW_COMMENTS=$(gh pr view $PR_NUMBER --json reviews -q '.reviews[] | select(.state == "CHANGES_REQUESTED") | .body' --repo $GITHUB_REPOSITORY)
+          REVIEW_BODY_Q=$(printf '%q' "$REVIEW_BODY")
+
+          # Update query to get review comments from all review types, not just "CHANGES_REQUESTED"
+          ALL_REVIEW_COMMENTS=$(gh api \
+            -H "Accept: application/vnd.github+json" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            /repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER/comments \
+            | jq '[.[] | {diff_hunk: .diff_hunk, path: .path, body: .body}]')
+
+          BASE_PROMPT="Fix the following issues in the PR based on the review feedback. The review body is prepended with REVIEW. The review comments are prepended with REVIEW_COMMENTS. The review body and comments are separated by a blank line."
+          printf "%s\nREVIEW:\n%s\nREVIEW_COMMENTS:\n%s" \
+            "$BASE_PROMPT" "$REVIEW_BODY_Q" "$ALL_REVIEW_COMMENTS" > "$PROMPT_FILE_PATH"
+          echo "PROMPT_FILE_PATH=$PROMPT_FILE_PATH" >> $GITHUB_OUTPUT
+
+      - name: Run Aider with review prompt
+        run: |
+          aider \
+            --read .cursor/rules/rust-best-practices.mdc \
+            --read .cursor/rules/svelte5-best-practices.mdc \
+            --model gemini/gemini-2.5-pro-preview-05-06 \
+            --message-file .github/aider/review-prompt.txt \
+            --yes \
+            --no-check-update \
+            --auto-commits \
+            --no-analytics \
+            --no-gitignore \
+            | tee .github/aider/aider-output.txt || true
+          echo "Aider command completed. Output saved to .github/aider/aider-output.txt"
+          # Check if there are any changes to commit
+          if [[ -z "$(git status --porcelain)" ]]; then
+            echo "No changes detected after running Aider."
+            exit 0
+          fi
+
+      - name: Clean up prompt file
+        if: always()
+        run: rm -f .github/aider/review-prompt.txt
+
+      - name: Commit and Push Changes
+        id: commit_and_push
+        if: ${{ success() }}
+        run: |
+          CURRENT_BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
+          echo "Attempting to push changes to PR branch $CURRENT_BRANCH_NAME for PR #${{ github.event.pull_request.number }}"
+
+          # Pull latest changes to avoid rejection due to non-fast-forward
+          git pull origin $CURRENT_BRANCH_NAME
+
+          if git push origin $CURRENT_BRANCH_NAME; then
+            echo "Push to $CURRENT_BRANCH_NAME successful."
+            echo "CHANGES_APPLIED=true" >> $GITHUB_OUTPUT
+          else
+            echo "::warning::Push to PR branch $CURRENT_BRANCH_NAME failed."
+            echo "CHANGES_APPLIED=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Comment on PR
+        if: success()
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUM: ${{ github.event.pull_request.number }}
+        run: |
+          # Create comment body in a temporary file to avoid command line length limits
+          if [[ "${{ steps.commit_and_push.outputs.CHANGES_APPLIED }}" == "true" ]]; then
+            cat > /tmp/pr-comment.md << EOL
+          🤖 I've automatically addressed the feedback based on the review.
+
+          ## Aider Output
+          \`\`\`
+          $(cat .github/aider/aider-output.txt || echo 'No output available')
+          \`\`\`
+
+          Please review the changes and let me know if further adjustments are needed.
+          EOL
+          else
+            cat > /tmp/pr-comment.md << EOL
+          🤖 I attempted to address the review feedback, but no modifications were made.
+
+          ## Aider Output
+          \`\`\`
+          $(cat .github/aider/aider-output.txt || echo 'No output available')
+          \`\`\`
+
+          Please review the output and provide additional guidance if needed.
+          EOL
+          fi
+
+          # Use the file for comment body
+          gh pr comment $PR_NUM --body-file /tmp/pr-comment.md

.github/workflows/aider.yaml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   auto-fix:
-    runs-on: ubuntu-latest
+    runs-on: ubicloud-standard-8
     if: |
       github.event_name == 'issue_comment' &&
       contains(github.event.comment.body, '/aider') &&
@@ -237,7 +237,7 @@ jobs:
             '{ "message": "I'\''m giving you a request that needs to be implemented. Your role is ONLY to give me the files that are relevant to the request and nothing else. The request is prepended with the word REQUEST.\\nREQUEST: \($prompt_escaped). Give me all the files relevant to this request. Your output MUST be a single json array that can be parsed with programatic json parsing, with the relevant files. Files can be rust or typescript or javascript files. DO NOT INCLUDE ANY OTHER TEXT IN YOUR OUTPUT. ONLY THE JSON ARRAY. Example of output: [\"file1.py\", \"file2.py\"]" }' | jq -r .message)
 
           set -o pipefail
-          PROBE_OUTPUT=$(npx --yes @buger/probe-chat@latest --max-iterations 50 --model-name gemini-2.5-pro-preview-05-06 --message "$MESSAGE_FOR_PROBE" 2>&1) || {
+          PROBE_OUTPUT=$(npx --yes @buger/probe-chat@latest --max-iterations 50 --model-name gemini-2.5-pro-preview-05-06 --message "$MESSAGE_FOR_PROBE") || {
             echo "::error::probe-chat command failed. Output:"
             echo "$PROBE_OUTPUT"
             exit 1
@@ -264,6 +264,8 @@ jobs:
         run: |
           echo "Files identified by probe-chat: ${{ env.FILES_TO_EDIT }}"
           aider \
+            --read .cursor/rules/rust-best-practices.mdc \
+            --read .cursor/rules/svelte5-best-practices.mdc \
             ${{ env.FILES_TO_EDIT }} \
             --model gemini/gemini-2.5-pro-preview-05-06 \
             --message-file .github/aider/issue-prompt.txt \
@@ -271,7 +273,8 @@ jobs:
             --no-check-update \
             --auto-commits \
             --no-analytics \
-            --no-stream > .github/aider/aider-output.txt 2>&1 || true
+            --no-gitignore \
+            | tee .github/aider/aider-output.txt || true
           echo "Aider command completed. Output saved to .github/aider/aider-output.txt"
 
       - name: Clean up prompt file
@@ -284,12 +287,23 @@ jobs:
         run: |
           if [[ -z "${{ github.event.issue.pull_request }}" ]]; then
             BRANCH_NAME="aider-fix-issue-${{ github.event.issue.number }}"
-            git checkout -b $BRANCH_NAME
-            echo "Created branch $BRANCH_NAME for issue #${{ github.event.issue.number }}"
+            
+            # Check if branch exists remotely
+            if git ls-remote --heads origin $BRANCH_NAME | grep -q $BRANCH_NAME; then
+              echo "Branch $BRANCH_NAME already exists remotely, fetching it"
+              git fetch origin $BRANCH_NAME
+              git checkout $BRANCH_NAME
+              git pull origin $BRANCH_NAME
+            else
+              echo "Creating new branch $BRANCH_NAME"
+              git checkout -b $BRANCH_NAME
+            fi
+            
+            echo "Created/checked out branch $BRANCH_NAME for issue #${{ github.event.issue.number }}"
             git push origin $BRANCH_NAME
-            echo "Pushed to new branch $BRANCH_NAME"
+            echo "Pushed to branch $BRANCH_NAME"
             echo "PR_BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_OUTPUT
-            echo "CHANGES_APPLIED_MESSAGE=Aider changes pushed to new branch $BRANCH_NAME." >> $GITHUB_OUTPUT
+            echo "CHANGES_APPLIED_MESSAGE=Aider changes pushed to branch $BRANCH_NAME." >> $GITHUB_OUTPUT
           else
             CURRENT_BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
             echo "Attempting to push changes to PR branch $CURRENT_BRANCH_NAME for PR #${{ github.event.issue.number }}"
@@ -310,13 +324,19 @@ jobs:
           PR_BRANCH: ${{ steps.commit_and_push.outputs.PR_BRANCH_NAME }}
           ISSUE_NUM: ${{ github.event.issue.number }}
         run: |
+          # Create PR description in a temporary file to avoid command line length limits
+          cat > /tmp/pr-description.md << EOL
+          This PR was created automatically by Aider to fix issue #${ISSUE_NUM}.
+
+          ## Aider Output
+          \`\`\`
+          $(cat .github/aider/aider-output.txt || echo "No output available")
+          \`\`\`
+          EOL
+
+          # Create PR using the file for the body content
           gh pr create \
             --title "[Aider PR] Add fixes for issue #${ISSUE_NUM}" \
-            --body "This PR was created automatically by Aider to fix issue #${ISSUE_NUM}.
-
-            ## Aider Output
-            \`\`\`
-            $(cat .github/aider/aider-output.txt || echo "No output available")
-            \`\`\`" \
+            --body-file /tmp/pr-description.md \
             --head "$PR_BRANCH" \
             --base main

.github/workflows/create-docs.yml

@@ -0,0 +1,15 @@
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  trigger-docs:
+    if: ${{ github.event.issue.pull_request && startsWith(github.event.comment.body, '/docs') }}
+    uses: windmill-labs/windmilldocs/.github/workflows/create-docs.yml@main
+    with:
+      pr_number: ${{ github.event.issue.number }}
+      repo: ${{ github.event.repository.name }}
+      comment_text: ${{ github.event.comment.body }}
+    secrets:
+      DOCS_TOKEN: ${{ secrets.DOCS_TOKEN }}
+      GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}

.github/workflows/discord-notification.yml

@@ -0,0 +1,32 @@
+name: Create discord thread when a PR is opened, react with green checkmark when PR is merged
+
+on:
+  pull_request:
+    types:
+      - opened
+      - ready_for_review
+      - closed
+
+jobs:
+  notify_discord_when_pr_opened:
+    if: (github.event.pull_request.draft == false) && (github.event.action == 'opened' || github.event.action == 'ready_for_review')
+    uses: ./.github/workflows/shareable-discord-notification.yml
+    with:
+      PR_TITLE: ${{ github.event.pull_request.title }}
+      PR_URL: ${{ github.event.pull_request.html_url }}
+      PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+      PR_STATUS: "opened"
+      PR_NUMBER: ${{ github.event.pull_request.number }}
+    secrets:
+      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_PR_REVIEWS_WEBHOOK }}
+
+  merge_success_emoji:
+    if: github.event.pull_request.merged == true
+    uses: ./.github/workflows/shareable-discord-notification.yml
+    with:
+      PR_STATUS: "merged"
+      DISCORD_CHANNEL_ID: "1372204995868491786"
+      DISCORD_GUILD_ID: "930051556043276338"
+      PR_NUMBER: ${{ github.event.pull_request.number }}
+    secrets:
+      DISCORD_BOT_TOKEN: ${{ secrets.DISCORD_PR_BOT_TOKEN }}

.github/workflows/helmchart_on_release.yml

@@ -0,0 +1,66 @@
+name: Publish Helm Chart on Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  bump-helm-version:
+    runs-on: ubicloud-standard-2
+
+    steps:
+      - name: Checkout on helm repository
+        uses: actions/checkout@v3
+        with:
+          repository: windmill-labs/windmill-helm-charts
+          token: ${{ secrets.DOCS_TOKEN }}
+
+      - name: Get version
+        id: get_version
+        run: |
+          echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
+
+      - name: Create new branch
+        run: |
+          # Check if branch already exists remotely
+          if git ls-remote --heads origin bump-helm-version-${{ env.VERSION }} | grep -q bump-helm-version-${{ env.VERSION }}; then
+            # Branch exists, check it out
+            git fetch origin bump-helm-version-${{ env.VERSION }}
+            git checkout bump-helm-version-${{ env.VERSION }}
+          else
+            # Create new branch
+            git checkout -b bump-helm-version-${{ env.VERSION }}
+          fi
+
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Bump helm version
+        run: |
+          # Get current version and increment it by 1
+          CURRENT_VERSION=$(grep "version:" ./charts/windmill/Chart.yaml | awk '{print $2}' | head -n 1)
+          NEW_VERSION=$(echo "$CURRENT_VERSION" | awk -F. '{$NF = $NF + 1;} 1' | sed 's/ /./g')
+          sed -i "s/^version: .*/version: $NEW_VERSION/" ./charts/windmill/Chart.yaml
+
+          # Get the app version from the version
+          VERSION=${{ env.VERSION }}
+          APP_VERSION=${VERSION#refs/tag/}
+          APP_VERSION=${APP_VERSION#v}
+          APP_VERSION=${APP_VERSION%/}
+          sed -i "s/appVersion: .*/appVersion: $APP_VERSION/" ./charts/windmill/Chart.yaml
+
+      - name: Commit and push
+        run: |
+          git add .
+          git commit -m "Bump helm version to ${{ env.VERSION }}"
+          git push origin bump-helm-version-${{ env.VERSION }}
+
+      - name: Create PR
+        env:
+          GH_TOKEN: ${{ secrets.DOCS_TOKEN }}
+        run: |
+          gh pr create \
+            --title "helm: bump version to ${{ env.VERSION }}" \
+            --body "This PR was auto-generated to bring the helm chart up to date for [release ${{ env.VERSION }}](https://github.com/windmill-labs/windmill/releases/tag/v${{ env.VERSION }}) in the main repo." \
+            --head bump-helm-version-${{ env.VERSION }} \
+            --base main

.github/workflows/shareable-discord-notification.yml

@@ -0,0 +1,98 @@
+name: "Notify Discord when a PR is opened or merged"
+
+on:
+  workflow_call:
+    inputs:
+      PR_TITLE:
+        description: "The title of the PR"
+        type: string
+      PR_URL:
+        description: "The URL of the PR"
+        type: string
+      PR_AUTHOR:
+        description: "The author of the PR"
+        type: string
+      PR_STATUS:
+        description: "The status of the PR"
+        type: string
+      DISCORD_CHANNEL_ID:
+        description: "The Discord channel ID"
+        type: string
+      PR_NUMBER:
+        description: "The number of the PR"
+        type: string
+      DISCORD_GUILD_ID:
+        description: "The Discord guild ID"
+        type: string
+    secrets:
+      DISCORD_WEBHOOK_URL:
+        description: "Discord Webhook URL"
+      DISCORD_BOT_TOKEN:
+        description: "Discord Bot Token"
+
+jobs:
+  open_thread:
+    runs-on: ubicloud-standard-2
+    if: ${{ inputs.PR_STATUS == 'opened' }}
+    steps:
+      - name: Send Discord notification and start a thread
+        env:
+          WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
+          PR_TITLE: ${{ inputs.PR_TITLE }}
+          PR_NUMBER: ${{ inputs.PR_NUMBER }}
+          PR_URL: ${{ inputs.PR_URL }}
+          PR_AUTHOR: ${{ inputs.PR_AUTHOR }}
+        run: |
+          payload=$(jq -n \
+            --arg content "${PR_URL}" \
+            --arg thread "#${PR_NUMBER}: $PR_TITLE by \`${PR_AUTHOR}\`" \
+            '{
+              content: $content,
+              thread_name: $thread,
+              auto_archive_duration: 10080
+            }'
+          )
+          curl -H "Content-Type: application/json" \
+            -X POST \
+            -d "$payload" \
+            "$WEBHOOK_URL"
+
+  merge_success_emoji:
+    runs-on: ubuntu-latest
+    if: ${{ inputs.PR_STATUS == 'merged' }}
+    steps:
+      - name: React
+        env:
+          BOT_TOKEN: ${{ secrets.DISCORD_BOT_TOKEN }}
+          CHANNEL_ID: ${{ inputs.DISCORD_CHANNEL_ID }}
+          GUILD_ID: ${{ inputs.DISCORD_GUILD_ID }}
+          PR_NUMBER: ${{ inputs.PR_NUMBER }}
+        run: |
+          # 1) get PR thread
+          threads=$(curl -H "Authorization: Bot $BOT_TOKEN" "https://discord.com/api/v10/guilds/${GUILD_ID}/threads/active")
+          thread_id=$(
+            echo "$threads" \
+              | jq -r --arg cid "$CHANNEL_ID" \
+                    --arg pref "#${PR_NUMBER}:" \
+                '.threads[]
+                | select(.parent_id == $cid and (.name | startswith($pref)))
+                | .id'
+          )
+          if [ -z "$thread_id" ]; then
+            echo "Thread not found"
+            exit 1
+          fi
+          # 2) get the first message in that thread
+          messages=$(curl -H "Authorization: Bot $BOT_TOKEN" \
+            "https://discord.com/api/v10/channels/$thread_id/messages?limit=1")
+          message_id=$(echo "$messages" | jq -r '.[-1].id')
+
+          if [ -z "$message_id" ]; then
+            echo "Message not found"
+            exit 1
+          fi
+
+          # 3) add the ✅ reaction
+          curl -X PUT \
+            -H "Authorization: Bot $BOT_TOKEN" \
+            "https://discord.com/api/v10/channels/$thread_id/messages/$message_id/reactions/%E2%9C%85/@me"

.gitignore

@@ -10,3 +10,5 @@ CaddyfileRemoteMalo
 .vscode
 .dev-docker-wrapper*
 backend/.minio-data
+.aider*
+!.aiderignore

CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [1.491.5](https://github.com/windmill-labs/windmill/compare/v1.491.4...v1.491.5) (2025-05-17)
+
+
+### Bug Fixes
+
+* improve handling of custom concurrency key/tag with preprocessors ([#5762](https://github.com/windmill-labs/windmill/issues/5762)) ([59afa49](https://github.com/windmill-labs/windmill/commit/59afa493fa20cc70b6825e6356713cef84d75312))
+* S3 sql mode returns S3Object ([#5764](https://github.com/windmill-labs/windmill/issues/5764)) ([b29c6e7](https://github.com/windmill-labs/windmill/commit/b29c6e7636bb21c4d977bdaf89ac90e2a1a1086c))
+
+## [1.491.4](https://github.com/windmill-labs/windmill/compare/v1.491.3...v1.491.4) (2025-05-15)
+
+
+### Bug Fixes
+
+* add v1 preprocessor support to workspace preprocessor script ([#5757](https://github.com/windmill-labs/windmill/issues/5757)) ([9b1c30e](https://github.com/windmill-labs/windmill/commit/9b1c30eeff35291ad50f3ddeb64831eac88e2f66))
+
+## [1.491.3](https://github.com/windmill-labs/windmill/compare/v1.491.2...v1.491.3) (2025-05-15)
+
+
+### Bug Fixes
+
+* **frontend:** fix accordeon tabs initialization ([f488903](https://github.com/windmill-labs/windmill/commit/f488903635a1457f839ca641ed4f8d0891ef8212))
+* http trigger routers cache version sequence ([#5755](https://github.com/windmill-labs/windmill/issues/5755)) ([d53bceb](https://github.com/windmill-labs/windmill/commit/d53bceb8004541b79d33220ae8de06d25521da91))
+
+## [1.491.2](https://github.com/windmill-labs/windmill/compare/v1.491.1...v1.491.2) (2025-05-15)
+
+
+### Bug Fixes
+
+* **cli:** --version improvement ([f8f2015](https://github.com/windmill-labs/windmill/commit/f8f201564f7a323eb96f6dc684a525a0784d41f2))
+* http trigger signature validation ([#5753](https://github.com/windmill-labs/windmill/issues/5753)) ([9e9514b](https://github.com/windmill-labs/windmill/commit/9e9514b9af2337e143a9e4cf1e915e1477032e80))
+* Improve indexer performance by factoring required queries to the DB # ([#5749](https://github.com/windmill-labs/windmill/issues/5749)) ([b12feaf](https://github.com/windmill-labs/windmill/commit/b12feaf50ae0ef03816719ff39157fcf55159dbf))
+* improve perf of job deletion ([0efba94](https://github.com/windmill-labs/windmill/commit/0efba945bac9b84a489c6ef552e834593f209fe1))
+
+
+### Performance Improvements
+
+* cache http trigger routers and auth ([#5748](https://github.com/windmill-labs/windmill/issues/5748)) ([ddd18d2](https://github.com/windmill-labs/windmill/commit/ddd18d22a615408a9f57f910d0a58f17e6d6e29d))
+
+## [1.491.1](https://github.com/windmill-labs/windmill/compare/v1.491.0...v1.491.1) (2025-05-15)
+
+
+### Bug Fixes
+
+* avoid deadlocks in sending completed job to result processors ([#5742](https://github.com/windmill-labs/windmill/issues/5742)) ([e87d4f3](https://github.com/windmill-labs/windmill/commit/e87d4f3c1afb4ad356b326b7600c89e6c7803eff))
+
 ## [1.491.0](https://github.com/windmill-labs/windmill/compare/v1.490.0...v1.491.0) (2025-05-14)
 
 

backend/.sqlx/query-0e296134f05593edc989c628c00cbb60a5446993217baffa83f843bc12a5ac73.json

@@ -1,35 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "SELECT\n                    value->'preprocessor_module' IS NOT NULL as has_preprocessor,\n                    value->'preprocessor_module'->'value'->'input_transforms'->'wm_trigger' IS NOT NULL as is_v1_preprocessor,\n                    schema as \"schema: _\"\n                FROM flow \n                WHERE workspace_id = $1 \n                    AND path = $2",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "has_preprocessor",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 1,
-        "name": "is_v1_preprocessor",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 2,
-        "name": "schema: _",
-        "type_info": "Json"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text",
-        "Text"
-      ]
-    },
-    "nullable": [
-      null,
-      null,
-      true
-    ]
-  },
-  "hash": "0e296134f05593edc989c628c00cbb60a5446993217baffa83f843bc12a5ac73"
-}

backend/.sqlx/query-16be720bf1c88ecfa2a4bf6adbb1924df4817b6236b3a949209465f3a2c42bb9.json

@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT nextval('http_trigger_version_seq')",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "nextval",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "16be720bf1c88ecfa2a4bf6adbb1924df4817b6236b3a949209465f3a2c42bb9"
+}

backend/.sqlx/query-1d819b829cd92995c39d29540df8cffbcc3334bada244a331a0bd8db06029d42.json

@@ -1,22 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "DELETE FROM v2_job_completed c\n                    USING v2_job j\n                    WHERE\n                        created_at <= now() - ($1::bigint::text || ' s')::interval\n                        AND completed_at + ($1::bigint::text || ' s')::interval <= now()\n                        AND c.id = j.id\n                    RETURNING c.id",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "id",
-        "type_info": "Uuid"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Int8"
-      ]
-    },
-    "nullable": [
-      false
-    ]
-  },
-  "hash": "1d819b829cd92995c39d29540df8cffbcc3334bada244a331a0bd8db06029d42"
-}

backend/.sqlx/query-1eeb218c30c0a6b0f7633813c764f57f8968894b4786b94109a057796ff500e4.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "\n            SELECT \n                path, \n                script_path, \n                is_flow, \n                route_path, \n                authentication_resource_path,\n                workspace_id, \n                is_async, \n                authentication_method  AS \"authentication_method: _\", \n                edited_by, \n                email, \n                static_asset_config AS \"static_asset_config: _\",\n                wrap_body,\n                raw_string,\n                workspaced_route,\n                is_static_website\n            FROM \n                http_trigger \n            WHERE \n                http_method = $1\n            ",
+  "query": "\n                    SELECT \n                        path, \n                        script_path, \n                        is_flow, \n                        route_path, \n                        authentication_resource_path,\n                        workspace_id, \n                        is_async, \n                        authentication_method  AS \"authentication_method: _\", \n                        edited_by, \n                        email, \n                        static_asset_config AS \"static_asset_config: _\",\n                        wrap_body,\n                        raw_string,\n                        workspaced_route,\n                        is_static_website\n                    FROM \n                        http_trigger \n                    WHERE \n                        http_method = $1\n                    ",
   "describe": {
     "columns": [
       {
@@ -129,5 +129,5 @@
       false
     ]
   },
-  "hash": "4053f0bb30f651ddf2214115748daca0ea457da8252394eeeead0897d184f6da"
+  "hash": "1eeb218c30c0a6b0f7633813c764f57f8968894b4786b94109a057796ff500e4"
 }

backend/.sqlx/query-20fd50949796913dd48f67ee75b11272ce5b3046f87b9efd504e013fba9724f5.json

@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT last_value FROM http_trigger_version_seq",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "last_value",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "20fd50949796913dd48f67ee75b11272ce5b3046f87b9efd504e013fba9724f5"
+}

backend/.sqlx/query-234acda79d470e99e9cbde5c7401d6f7894c25f90e39ec8606f79b8be56d1c17.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n                        SELECT EXISTS(\n                            SELECT 1\n                            FROM \n                                http_trigger \n                            WHERE \n                                workspace_id = $1 AND \n                                path = $2\n                        )\n                        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "exists",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "234acda79d470e99e9cbde5c7401d6f7894c25f90e39ec8606f79b8be56d1c17"
+}

backend/.sqlx/query-282afbff89d3186d47ef5dbd0b65026ad37fb31b485fc44b6ec257dd77825428.json

@@ -1,41 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "SELECT created_by, coalesce(job_logs.logs, '') as logs, job_logs.log_offset, job_logs.log_file_index\n        FROM v2_as_completed_job\n        LEFT JOIN job_logs ON job_logs.job_id = v2_as_completed_job.id\n        WHERE v2_as_completed_job.id = $1 AND v2_as_completed_job.workspace_id = $2",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "created_by",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 1,
-        "name": "logs",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 2,
-        "name": "log_offset",
-        "type_info": "Int4"
-      },
-      {
-        "ordinal": 3,
-        "name": "log_file_index",
-        "type_info": "TextArray"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Uuid",
-        "Text"
-      ]
-    },
-    "nullable": [
-      true,
-      null,
-      false,
-      true
-    ]
-  },
-  "hash": "282afbff89d3186d47ef5dbd0b65026ad37fb31b485fc44b6ec257dd77825428"
-}

backend/.sqlx/query-2a33a35afc1ba4c31a5713cfd1a2c662f25cda387197aaf9f35000df31b8b07d.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DROP INDEX CONCURRENTLY IF EXISTS log_file_hostname_log_ts_idx",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": []
+  },
+  "hash": "2a33a35afc1ba4c31a5713cfd1a2c662f25cda387197aaf9f35000df31b8b07d"
+}

backend/.sqlx/query-49943f69ed74bc889120dcd2571e8e868a4f4795933044ff95b20d8df45cd145.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "CREATE INDEX CONCURRENTLY IF NOT EXISTS ix_job_completed_completed_at ON v2_job_completed (completed_at DESC)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": []
+  },
+  "hash": "49943f69ed74bc889120dcd2571e8e868a4f4795933044ff95b20d8df45cd145"
+}

backend/.sqlx/query-52ad0c838d19cbd9e90b8368abe71dd12655179f41f43896e7d30fdfb3ae5939.json

@@ -1,15 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "WITH job_result AS (\n                 SELECT result \n                 FROM v2_job_completed \n                 WHERE id = $1\n             )\n             UPDATE v2_job \n             SET args = COALESCE(\n                     CASE \n                         WHEN job_result.result IS NULL THEN NULL\n                         WHEN jsonb_typeof(job_result.result) = 'object' \n                         THEN job_result.result\n                         WHEN jsonb_typeof(job_result.result) = 'null'\n                         THEN NULL\n                         ELSE jsonb_build_object('value', job_result.result)\n                     END, \n                     '{}'::jsonb\n                 ),\n                 preprocessed = TRUE\n             FROM job_result\n             WHERE v2_job.id = $2;\n             ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Uuid",
-        "Uuid"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "52ad0c838d19cbd9e90b8368abe71dd12655179f41f43896e7d30fdfb3ae5939"
-}

backend/.sqlx/query-5820d34be1a7f7b72e656c692f53146f45ad4a6e584e917a0a86280d8f473c10.json

@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM v2_job_completed c\n                    WHERE completed_at <= now() - ($1::bigint::text || ' s')::interval \n                    RETURNING c.id",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "5820d34be1a7f7b72e656c692f53146f45ad4a6e584e917a0a86280d8f473c10"
+}

backend/.sqlx/query-6e2564dc37ee967c634deade67ceabc4c516418e595dee9cd7d651acc1f4af6e.json

@@ -0,0 +1,248 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n                            cj.id AS \"id!\",\n                            cj.workspace_id AS \"workspace_id!\",\n                            cj.parent_job,\n                            cj.created_by AS \"created_by!\",\n                            cj.duration_ms AS \"duration_ms!\",\n                            cj.success AS \"success!\",\n                            cj.script_hash AS \"script_hash!: Option<ScriptHash>\",\n                            cj.script_path,\n                            cj.args AS \"args: sqlx::types::Json<HashMap<String, Box<RawValue>>>\",\n                            cj.result AS \"result: sqlx::types::Json<Box<RawValue>>\",\n                            cj.deleted AS \"deleted!\",\n                            cj.canceled AS \"canceled!\",\n                            cj.canceled_by,\n                            cj.canceled_reason,\n                            cj.job_kind AS \"job_kind!: JobKind\",\n                            cj.schedule_path,\n                            cj.permissioned_as AS \"permissioned_as!\",\n                            cj.is_flow_step AS \"is_flow_step!\",\n                            cj.language AS \"language: ScriptLang\",\n                            cj.is_skipped AS \"is_skipped!\",\n                            cj.email AS \"email!\",\n                            cj.visible_to_owner AS \"visible_to_owner!\",\n                            cj.mem_peak,\n                            cj.tag AS \"tag!\",\n                            cj.created_at AS \"created_at!\",\n                            cj.started_at,\n                            job_logs.logs,\n                            job_logs.log_offset AS \"log_offset?\",\n                            job_logs.log_file_index\n\n                        FROM v2_as_completed_job AS cj\n                        LEFT JOIN job_logs ON cj.id = job_logs.job_id\n                        WHERE (cj.created_at > $1 AND cj.created_at < $3)\n                               OR cj.id = ANY($2)\n                        ORDER BY cj.created_at ASC LIMIT $4",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id!",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 1,
+        "name": "workspace_id!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "parent_job",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 3,
+        "name": "created_by!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 4,
+        "name": "duration_ms!",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 5,
+        "name": "success!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 6,
+        "name": "script_hash!: Option<ScriptHash>",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 7,
+        "name": "script_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 8,
+        "name": "args: sqlx::types::Json<HashMap<String, Box<RawValue>>>",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 9,
+        "name": "result: sqlx::types::Json<Box<RawValue>>",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 10,
+        "name": "deleted!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 11,
+        "name": "canceled!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 12,
+        "name": "canceled_by",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 13,
+        "name": "canceled_reason",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 14,
+        "name": "job_kind!: JobKind",
+        "type_info": {
+          "Custom": {
+            "name": "job_kind",
+            "kind": {
+              "Enum": [
+                "script",
+                "preview",
+                "flow",
+                "dependencies",
+                "flowpreview",
+                "script_hub",
+                "identity",
+                "flowdependencies",
+                "http",
+                "graphql",
+                "postgresql",
+                "noop",
+                "appdependencies",
+                "deploymentcallback",
+                "singlescriptflow",
+                "flowscript",
+                "flownode",
+                "appscript"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 15,
+        "name": "schedule_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 16,
+        "name": "permissioned_as!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 17,
+        "name": "is_flow_step!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 18,
+        "name": "language: ScriptLang",
+        "type_info": {
+          "Custom": {
+            "name": "script_lang",
+            "kind": {
+              "Enum": [
+                "python3",
+                "deno",
+                "go",
+                "bash",
+                "postgresql",
+                "nativets",
+                "bun",
+                "mysql",
+                "bigquery",
+                "snowflake",
+                "graphql",
+                "powershell",
+                "mssql",
+                "php",
+                "bunnative",
+                "rust",
+                "ansible",
+                "csharp",
+                "oracledb",
+                "nu",
+                "java"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 19,
+        "name": "is_skipped!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 20,
+        "name": "email!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 21,
+        "name": "visible_to_owner!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 22,
+        "name": "mem_peak",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 23,
+        "name": "tag!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 24,
+        "name": "created_at!",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 25,
+        "name": "started_at",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 26,
+        "name": "logs",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 27,
+        "name": "log_offset?",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 28,
+        "name": "log_file_index",
+        "type_info": "TextArray"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Timestamptz",
+        "UuidArray",
+        "Timestamptz",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      false,
+      true
+    ]
+  },
+  "hash": "6e2564dc37ee967c634deade67ceabc4c516418e595dee9cd7d651acc1f4af6e"
+}

backend/.sqlx/query-72916f8e490f8252e0a51b7f562ccc3be832b12102eb86a07d8405a4fa9287d5.json

@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n                    value->'preprocessor_module'->'value' as \"preprocessor_module: _\",\n                    schema as \"schema: _\"\n                FROM flow \n                WHERE workspace_id = $1\n                    AND path = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "preprocessor_module: _",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 1,
+        "name": "schema: _",
+        "type_info": "Json"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null,
+      true
+    ]
+  },
+  "hash": "72916f8e490f8252e0a51b7f562ccc3be832b12102eb86a07d8405a4fa9287d5"
+}

backend/.sqlx/query-91f23fcc27777c279c79e2682fc15c026e55f9ec3799be65a2e8920fe6174a17.json

@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT result  as \"result: Json<HashMap<String, Box<RawValue>>>\"\n                 FROM v2_job_completed \n                 WHERE id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "result: Json<HashMap<String, Box<RawValue>>>",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "91f23fcc27777c279c79e2682fc15c026e55f9ec3799be65a2e8920fe6174a17"
+}

backend/.sqlx/query-927149213e0f8ae983652ef80464f646d6be80e702193f1acdd40dd6033652e4.json

@@ -1,134 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            SELECT \n                path, \n                script_path, \n                is_flow, \n                route_path, \n                workspace_id, \n                is_async, \n                authentication_method  AS \"authentication_method: _\", \n                edited_by, \n                email,\n                static_asset_config AS \"static_asset_config: _\",\n                wrap_body,\n                raw_string,\n                workspaced_route,\n                is_static_website,\n                authentication_resource_path\n            FROM \n                http_trigger \n            WHERE \n                workspace_id = $1 AND \n                http_method = $2\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "path",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 1,
-        "name": "script_path",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 2,
-        "name": "is_flow",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 3,
-        "name": "route_path",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 4,
-        "name": "workspace_id",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 5,
-        "name": "is_async",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 6,
-        "name": "authentication_method: _",
-        "type_info": {
-          "Custom": {
-            "name": "authentication_method",
-            "kind": {
-              "Enum": [
-                "none",
-                "windmill",
-                "api_key",
-                "basic_http",
-                "custom_script",
-                "signature"
-              ]
-            }
-          }
-        }
-      },
-      {
-        "ordinal": 7,
-        "name": "edited_by",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 8,
-        "name": "email",
-        "type_info": "Varchar"
-      },
-      {
-        "ordinal": 9,
-        "name": "static_asset_config: _",
-        "type_info": "Jsonb"
-      },
-      {
-        "ordinal": 10,
-        "name": "wrap_body",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 11,
-        "name": "raw_string",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 12,
-        "name": "workspaced_route",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 13,
-        "name": "is_static_website",
-        "type_info": "Bool"
-      },
-      {
-        "ordinal": 14,
-        "name": "authentication_resource_path",
-        "type_info": "Varchar"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text",
-        {
-          "Custom": {
-            "name": "http_method",
-            "kind": {
-              "Enum": [
-                "get",
-                "post",
-                "put",
-                "delete",
-                "patch"
-              ]
-            }
-          }
-        }
-      ]
-    },
-    "nullable": [
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      false,
-      true,
-      false,
-      false,
-      false,
-      false,
-      true
-    ]
-  },
-  "hash": "927149213e0f8ae983652ef80464f646d6be80e702193f1acdd40dd6033652e4"
-}

backend/.sqlx/query-a8ca4e588e0bf3c4bba2fe4b68a5364e4cba99964513599f8a012a5680d3dca8.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "CREATE INDEX CONCURRENTLY IF NOT EXISTS alerts_by_workspace ON alerts (workspace_id);",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": []
+  },
+  "hash": "a8ca4e588e0bf3c4bba2fe4b68a5364e4cba99964513599f8a012a5680d3dca8"
+}

backend/.sqlx/query-b3dbdfb50ee8118bdaed3164b210cb549a34b96554ae1872355b90304f5dcb76.json

@@ -18,8 +18,8 @@
       "Left": []
     },
     "nullable": [
-      true,
-      false
+      false,
+      true
     ]
   },
   "hash": "b3dbdfb50ee8118bdaed3164b210cb549a34b96554ae1872355b90304f5dcb76"

backend/.sqlx/query-b7335ac24702c86fbb4ab95916a6aa1648082287b09122755df2462dc71ce831.json

@@ -0,0 +1,46 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        WITH j AS (\n            SELECT \n                raw_flow->>'concurrency_key' as concurrency_key, \n                raw_flow->>'concurrency_time_window_s' as concurrency_time_window_s,\n                raw_flow->>'concurrency_limit' as concurrent_limit,\n                runnable_path, \n                runnable_id as version FROM v2_job\n            WHERE id = $1\n        )\n        SELECT tag, j.concurrency_key, j.concurrency_time_window_s::int, j.concurrent_limit::int, j.version\n            FROM flow, j\n            WHERE path = j.runnable_path\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "tag",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "concurrency_key",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 2,
+        "name": "concurrency_time_window_s",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 3,
+        "name": "concurrent_limit",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 4,
+        "name": "version",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      true,
+      null,
+      null,
+      null,
+      true
+    ]
+  },
+  "hash": "b7335ac24702c86fbb4ab95916a6aa1648082287b09122755df2462dc71ce831"
+}

backend/.sqlx/query-e07660e8d2a265cb6a83f3a2bb8e7e6330f09ab116e9837f6f16f8fdef938004.json

@@ -0,0 +1,18 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH job_result AS (\n                 SELECT result \n                 FROM v2_job_completed \n                 WHERE id = $1\n             ),\n             updated_queue AS (\n                UPDATE v2_job_queue\n                SET running = false,\n                tag = COALESCE($3, tag)\n                WHERE id = $2\n             )\n             UPDATE v2_job \n             SET \n                tag = COALESCE($3, tag),\n                concurrent_limit = COALESCE($4, concurrent_limit),\n                concurrency_time_window_s = COALESCE($5, concurrency_time_window_s),\n                args = COALESCE(\n                     CASE \n                         WHEN job_result.result IS NULL THEN NULL\n                         WHEN jsonb_typeof(job_result.result) = 'object' \n                         THEN job_result.result\n                         WHEN jsonb_typeof(job_result.result) = 'null'\n                         THEN NULL\n                         ELSE jsonb_build_object('value', job_result.result)\n                     END, \n                     '{}'::jsonb\n                 ),\n                 preprocessed = TRUE\n             FROM job_result\n             WHERE v2_job.id = $2;\n             ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Uuid",
+        "Varchar",
+        "Int4",
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e07660e8d2a265cb6a83f3a2bb8e7e6330f09ab116e9837f6f16f8fdef938004"
+}

backend/.sqlx/query-f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7.json

@@ -0,0 +1,246 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n                            cj.id AS \"id!\",\n                            cj.workspace_id AS \"workspace_id!\",\n                            cj.parent_job,\n                            cj.created_by AS \"created_by!\",\n                            cj.duration_ms AS \"duration_ms!\",\n                            cj.success AS \"success!\",\n                            cj.script_hash AS \"script_hash!: Option<ScriptHash>\",\n                            cj.script_path,\n                            cj.args AS \"args: sqlx::types::Json<HashMap<String, Box<RawValue>>>\",\n                            cj.result AS \"result: sqlx::types::Json<Box<RawValue>>\",\n                            cj.deleted AS \"deleted!\",\n                            cj.canceled AS \"canceled!\",\n                            cj.canceled_by,\n                            cj.canceled_reason,\n                            cj.job_kind AS \"job_kind!: JobKind\",\n                            cj.schedule_path,\n                            cj.permissioned_as AS \"permissioned_as!\",\n                            cj.is_flow_step AS \"is_flow_step!\",\n                            cj.language AS \"language: ScriptLang\",\n                            cj.is_skipped AS \"is_skipped!\",\n                            cj.email AS \"email!\",\n                            cj.visible_to_owner AS \"visible_to_owner!\",\n                            cj.mem_peak,\n                            cj.tag AS \"tag!\",\n                            cj.created_at AS \"created_at!\",\n                            cj.started_at,\n                            job_logs.logs,\n                            job_logs.log_offset AS \"log_offset?\",\n                            job_logs.log_file_index\n\n                        FROM v2_as_completed_job AS cj\n                        LEFT JOIN job_logs ON cj.id = job_logs.job_id\n                        WHERE cj.created_at < $1\n                        ORDER BY cj.created_at ASC LIMIT $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id!",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 1,
+        "name": "workspace_id!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "parent_job",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 3,
+        "name": "created_by!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 4,
+        "name": "duration_ms!",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 5,
+        "name": "success!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 6,
+        "name": "script_hash!: Option<ScriptHash>",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 7,
+        "name": "script_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 8,
+        "name": "args: sqlx::types::Json<HashMap<String, Box<RawValue>>>",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 9,
+        "name": "result: sqlx::types::Json<Box<RawValue>>",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 10,
+        "name": "deleted!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 11,
+        "name": "canceled!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 12,
+        "name": "canceled_by",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 13,
+        "name": "canceled_reason",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 14,
+        "name": "job_kind!: JobKind",
+        "type_info": {
+          "Custom": {
+            "name": "job_kind",
+            "kind": {
+              "Enum": [
+                "script",
+                "preview",
+                "flow",
+                "dependencies",
+                "flowpreview",
+                "script_hub",
+                "identity",
+                "flowdependencies",
+                "http",
+                "graphql",
+                "postgresql",
+                "noop",
+                "appdependencies",
+                "deploymentcallback",
+                "singlescriptflow",
+                "flowscript",
+                "flownode",
+                "appscript"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 15,
+        "name": "schedule_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 16,
+        "name": "permissioned_as!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 17,
+        "name": "is_flow_step!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 18,
+        "name": "language: ScriptLang",
+        "type_info": {
+          "Custom": {
+            "name": "script_lang",
+            "kind": {
+              "Enum": [
+                "python3",
+                "deno",
+                "go",
+                "bash",
+                "postgresql",
+                "nativets",
+                "bun",
+                "mysql",
+                "bigquery",
+                "snowflake",
+                "graphql",
+                "powershell",
+                "mssql",
+                "php",
+                "bunnative",
+                "rust",
+                "ansible",
+                "csharp",
+                "oracledb",
+                "nu",
+                "java"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 19,
+        "name": "is_skipped!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 20,
+        "name": "email!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 21,
+        "name": "visible_to_owner!",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 22,
+        "name": "mem_peak",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 23,
+        "name": "tag!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 24,
+        "name": "created_at!",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 25,
+        "name": "started_at",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 26,
+        "name": "logs",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 27,
+        "name": "log_offset?",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 28,
+        "name": "log_file_index",
+        "type_info": "TextArray"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Timestamptz",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      false,
+      true
+    ]
+  },
+  "hash": "f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7"
+}

backend/.sqlx/query-f632d08a8d3df691fff9f57fdf926f787287c3cd181a6853056077edba10473d.json

@@ -1,23 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "\n                SELECT EXISTS(\n                    SELECT 1 \n                    FROM \n                        http_trigger \n                    WHERE \n                        workspace_id = $1 AND \n                        path = $2\n                )\n                ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "exists",
-        "type_info": "Bool"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text",
-        "Text"
-      ]
-    },
-    "nullable": [
-      null
-    ]
-  },
-  "hash": "f632d08a8d3df691fff9f57fdf926f787287c3cd181a6853056077edba10473d"
-}

backend/.sqlx/query-fec6d5674dc6b5a6a0ece419c40508835affcb7679a48f2a443777e829bd1e74.json

@@ -41,11 +41,11 @@
       ]
     },
     "nullable": [
-      true,
-      true,
-      true,
-      true,
-      true,
+      false,
+      false,
+      false,
+      false,
+      false,
       true
     ]
   },

backend/Cargo.lock

@@ -744,9 +744,9 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "aws-config"
-version = "1.6.2"
+version = "1.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6fcc63c9860579e4cb396239570e979376e70aab79e496621748a09913f8b36"
+checksum = "02a18fd934af6ae7ca52410d4548b98eb895aab0f1ea417d168d85db1434a141"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -833,9 +833,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sqs"
-version = "1.67.0"
+version = "1.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6f15bedfb1c4385fccc474f0fe46dffb0335d0b3d6b4413df06fb30d90caba8"
+checksum = "5b484821a335b02b109c17623b8347e692583c2229f8db2f029edd0fdbbd3bea"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -849,16 +849,15 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
- "once_cell",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sdk-sso"
-version = "1.67.0"
+version = "1.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4863da26489d1e6da91d7e12b10c17e86c14f94c53f416bd10e0a9c34057ba"
+checksum = "bd5f01ea61fed99b5fe4877abff6c56943342a56ff145e9e0c7e2494419008be"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -872,16 +871,15 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
- "once_cell",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sdk-ssooidc"
-version = "1.68.0"
+version = "1.69.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95caa3998d7237789b57b95a8e031f60537adab21fa84c91e35bef9455c652e4"
+checksum = "27454e4c55aaa4ef65647e3a1cf095cb834ca6d54e959e2909f1fef96ad87860"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -895,16 +893,15 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
- "once_cell",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sdk-sts"
-version = "1.68.0"
+version = "1.69.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4939f6f449a37308a78c5a910fd91265479bd2bb11d186f0b8fc114d89ec828d"
+checksum = "ffd6ef5d00c94215960fabcdf2d9fe7c090eed8be482d66d47b92d4aba1dd4aa"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -919,16 +916,15 @@ dependencies = [
  "aws-types",
  "fastrand",
  "http 0.2.12",
- "once_cell",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sigv4"
-version = "1.3.1"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3503af839bd8751d0bdc5a46b9cac93a003a353e635b0c12cf2376b5b53e41ea"
+checksum = "3734aecf9ff79aa401a6ca099d076535ab465ff76b46440cf567c8e70b65dc13"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-http",
@@ -1303,7 +1299,7 @@ version = "0.69.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cexpr",
  "clang-sys",
  "itertools 0.12.1",
@@ -1326,7 +1322,7 @@ version = "0.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -1378,9 +1374,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 dependencies = [
  "serde",
 ]
@@ -1843,9 +1839,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.22"
+version = "1.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32db95edf998450acc7881c932f94cd9b05c87b4b2599e8bab064753da4acfd1"
+checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
 dependencies = [
  "jobserver",
  "libc",
@@ -2438,7 +2434,7 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b28bfe653d79bd16c77f659305b195b82bb5ce0c0eb2a4846b82ddbd77586813"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "libloading 0.8.7",
  "winapi",
 ]
@@ -3215,7 +3211,7 @@ dependencies = [
  "once_cell",
  "percent-encoding",
  "serde",
- "sourcemap 9.2.0",
+ "sourcemap 9.2.1",
  "swc_atoms",
  "swc_common",
  "swc_config",
@@ -4152,9 +4148,9 @@ dependencies = [
 
 [[package]]
 name = "deno_unsync"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d774fd83f26b24f0805a6ab8b26834a0d06ceac0db517b769b1e4633c96a2057"
+checksum = "47c618b51088b3ac67f15c69b3ed7620ba3a7d495e5a090186df9424b5ab623e"
 dependencies = [
  "futures",
  "parking_lot 0.12.3",
@@ -4871,9 +4867,9 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
 dependencies = [
  "libc",
  "windows-sys 0.59.0",
@@ -5075,7 +5071,7 @@ version = "25.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1045398c1bfd89168b5fd3f1fc11f6e70b34f6f66300c87d44d3de849463abf1"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "rustc_version 0.4.1",
 ]
 
@@ -5895,7 +5891,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "gpu-alloc-types",
 ]
 
@@ -5905,7 +5901,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -5914,7 +5910,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcf29e94d6d243368b7a56caa16bc213e4f9f8ed38c4d9557069527b5d5281ca"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "gpu-descriptor-types",
  "hashbrown 0.15.3",
 ]
@@ -5925,7 +5921,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -6494,7 +6490,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.0",
+ "windows-core 0.61.1",
 ]
 
 [[package]]
@@ -7205,7 +7201,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "libc",
  "redox_syscall 0.5.12",
 ]
@@ -7634,7 +7630,7 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5637e166ea14be6063a3f8ba5ccb9a4159df7d8f6d61c02fc3d480b1f90dcfcb"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "block",
  "core-graphics-types",
  "foreign-types 0.5.0",
@@ -7875,7 +7871,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e0ec195e788c95f36b7cf88127d538465fc2f7773e6e47af01834738eab0aee"
 dependencies = [
  "base64 0.22.1",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "btoi",
  "byteorder",
  "bytes",
@@ -7904,7 +7900,7 @@ checksum = "e536ae46fcab0876853bd4a632ede5df4b1c2527a58f6c5a4150fe86be858231"
 dependencies = [
  "arrayvec",
  "bit-set 0.5.3",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "codespan-reporting",
  "hexf-parse",
  "indexmap 2.9.0",
@@ -7996,7 +7992,7 @@ version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "libc",
 ]
@@ -8007,7 +8003,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "cfg_aliases 0.2.1",
  "libc",
@@ -8080,7 +8076,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -8594,7 +8590,7 @@ version = "0.10.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "foreign-types 0.3.2",
  "libc",
@@ -8823,9 +8819,9 @@ dependencies = [
 
 [[package]]
 name = "owo-colors"
-version = "4.2.0"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1036865bb9422d3300cf723f657c2851d0e9ab12567854b1f4eba3d77decf564"
+checksum = "26995317201fa17f3656c36716aed4a7c81743a9634ac4c99c0eeda495db0cec"
 
 [[package]]
 name = "p224"
@@ -9466,7 +9462,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc5b72d8145275d844d4b5f6d4e1eef00c8cd889edb6035c21675d1bb1f45c9f"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "chrono",
  "flate2",
  "hex",
@@ -9480,7 +9476,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "239df02d8349b06fc07398a3a1697b06418223b1c7725085e801e7c0fc6a12ec"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "chrono",
  "hex",
 ]
@@ -9606,7 +9602,7 @@ version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "getopts",
  "memchr",
  "unicase",
@@ -9873,7 +9869,7 @@ version = "11.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -9995,7 +9991,7 @@ version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -10359,7 +10355,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
 dependencies = [
  "base64 0.21.7",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "serde",
  "serde_derive",
 ]
@@ -10410,7 +10406,7 @@ version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "fallible-iterator 0.3.0",
  "fallible-streaming-iterator",
  "hashlink 0.9.1",
@@ -10531,7 +10527,7 @@ version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
@@ -10544,7 +10540,7 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys 0.9.4",
@@ -10772,7 +10768,7 @@ version = "13.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02a2d683a4ac90aeef5b1013933f6d977bd37d51ff3f4dad829d4931a7e6be86"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "clipboard-win",
  "fd-lock",
@@ -10965,7 +10961,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
@@ -10978,7 +10974,7 @@ version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "core-foundation 0.10.0",
  "core-foundation-sys",
  "libc",
@@ -11497,9 +11493,9 @@ dependencies = [
 
 [[package]]
 name = "sourcemap"
-version = "9.2.0"
+version = "9.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd430118acc9fdd838557649b9b43fd0a78e3834d84a283b466f8e84720d6101"
+checksum = "bdee719193ae5c919a3ee43f64c2c0dd87f9b9a451d67918a2a5ec2e3c70561c"
 dependencies = [
  "base64-simd 0.8.0",
  "bitvec",
@@ -11534,7 +11530,7 @@ version = "0.3.0+sdk-1.3.268.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -11697,7 +11693,7 @@ dependencies = [
  "atoi",
  "base64 0.22.1",
  "bigdecimal",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "byteorder",
  "bytes",
  "chrono",
@@ -11742,7 +11738,7 @@ dependencies = [
  "atoi",
  "base64 0.22.1",
  "bigdecimal",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "byteorder",
  "chrono",
  "crc",
@@ -11980,7 +11976,7 @@ dependencies = [
  "rustc-hash 1.1.0",
  "serde",
  "siphasher 0.3.11",
- "sourcemap 9.2.0",
+ "sourcemap 9.2.1",
  "swc_allocator",
  "swc_atoms",
  "swc_eq_ignore_macros",
@@ -12022,7 +12018,7 @@ version = "0.118.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6f866d12e4d519052b92a0a86d1ac7ff17570da1272ca0c89b3d6f802cd79df"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "is-macro",
  "num-bigint",
  "phf",
@@ -12044,7 +12040,7 @@ dependencies = [
  "num-bigint",
  "once_cell",
  "serde",
- "sourcemap 9.2.0",
+ "sourcemap 9.2.1",
  "swc_allocator",
  "swc_atoms",
  "swc_common",
@@ -12108,7 +12104,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65f21494e75d0bd8ef42010b47cabab9caaed8f2207570e809f6f4eb51a710d1"
 dependencies = [
  "better_scoped_tls",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "indexmap 2.9.0",
  "once_cell",
  "phf",
@@ -12376,7 +12372,7 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec7dddc5f0fee506baf8b9fdb989e242f17e4b11c61dfbb0635b705217199eea"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "byteorder",
  "enum-as-inner",
  "libc",
@@ -12390,7 +12386,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "byteorder",
  "enum-as-inner",
  "libc",
@@ -12429,7 +12425,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "core-foundation 0.9.4",
  "system-configuration-sys 0.6.0",
 ]
@@ -13312,7 +13308,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fdb0c213ca27a9f57ab69ddb290fd80d970922355b83ae380b395d3986b8a2e"
 dependencies = [
  "async-compression",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "bytes",
  "futures-core",
  "http 1.3.1",
@@ -13945,7 +13941,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a511192602f7b435b0a241c1947aa743eb7717f20a9195f4b5e8ed1952e01db1"
 dependencies = [
  "bindgen 0.70.1",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "fslock",
  "gzip-header",
  "home",
@@ -13961,7 +13957,7 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97599c400fc79925922b58303e98fcb8fa88f573379a08ddb652e72cbd2e70f6"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "encoding_rs",
  "indexmap 2.9.0",
  "num-bigint",
@@ -14252,7 +14248,7 @@ checksum = "d50819ab545b867d8a454d1d756b90cd5f15da1f2943334ca314af10583c9d39"
 dependencies = [
  "arrayvec",
  "bit-vec 0.6.3",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg_aliases 0.1.1",
  "codespan-reporting",
  "document-features",
@@ -14283,7 +14279,7 @@ dependencies = [
  "arrayvec",
  "ash",
  "bit-set 0.5.3",
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "block",
  "cfg_aliases 0.1.1",
  "core-graphics-types",
@@ -14321,7 +14317,7 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1353d9a46bff7f955a680577f34c69122628cc2076e1d6f3a9be6ef00ae793ef"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "js-sys",
  "serde",
  "web-sys",
@@ -14401,7 +14397,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windmill"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "axum",
@@ -14450,7 +14446,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "argon2",
@@ -14559,7 +14555,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-client"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "base64 0.22.1",
  "chrono",
@@ -14574,7 +14570,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-audit"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "chrono",
  "serde",
@@ -14587,7 +14583,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-autoscaling"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "serde",
@@ -14601,7 +14597,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-common"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "async-stream",
@@ -14671,7 +14667,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-git-sync"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "regex",
  "serde",
@@ -14685,7 +14681,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-indexer"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "bytes",
@@ -14708,7 +14704,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-macros"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "itertools 0.14.0",
  "lazy_static",
@@ -14720,7 +14716,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "convert_case 0.6.0",
  "serde",
@@ -14729,7 +14725,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-bash"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14741,7 +14737,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-csharp"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14753,7 +14749,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-go"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "gosyn",
@@ -14765,7 +14761,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-graphql"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14777,7 +14773,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-java"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14789,7 +14785,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-nu"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "nu-parser",
@@ -14800,7 +14796,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-php"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14811,7 +14807,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14822,7 +14818,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-imports"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -14842,7 +14838,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-rust"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "convert_case 0.6.0",
@@ -14859,7 +14855,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14871,7 +14867,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14889,7 +14885,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wasm"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "getrandom 0.2.16",
@@ -14913,7 +14909,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-yaml"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14923,7 +14919,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-queue"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -14956,7 +14952,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-sql-datatype-parser-wasm"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-test",
@@ -14966,7 +14962,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-worker"
-version = "1.491.0"
+version = "1.491.5"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15027,6 +15023,7 @@ dependencies = [
  "tiberius",
  "tokio",
  "tokio-postgres 0.7.13",
+ "tokio-stream",
  "tokio-util",
  "tracing",
  "url",
@@ -15082,7 +15079,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
 dependencies = [
  "windows-collections",
- "windows-core 0.61.0",
+ "windows-core 0.61.1",
  "windows-future",
  "windows-link",
  "windows-numerics",
@@ -15094,7 +15091,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core 0.61.0",
+ "windows-core 0.61.1",
 ]
 
 [[package]]
@@ -15123,25 +15120,26 @@ dependencies = [
 
 [[package]]
 name = "windows-core"
-version = "0.61.0"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+checksum = "46ec44dc15085cea82cf9c78f85a9114c463a369786585ad2882d1ff0b0acf40"
 dependencies = [
  "windows-implement 0.60.0",
  "windows-interface 0.59.1",
  "windows-link",
- "windows-result 0.3.2",
- "windows-strings 0.4.0",
+ "windows-result 0.3.3",
+ "windows-strings 0.4.1",
 ]
 
 [[package]]
 name = "windows-future"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a1d6bbefcb7b60acd19828e1bc965da6fcf18a7e39490c5f8be71e54a19ba32"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
- "windows-core 0.61.0",
+ "windows-core 0.61.1",
  "windows-link",
+ "windows-threading",
 ]
 
 [[package]]
@@ -15222,7 +15220,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-core 0.61.0",
+ "windows-core 0.61.1",
  "windows-link",
 ]
 
@@ -15232,7 +15230,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4286ad90ddb45071efd1a66dfa43eb02dd0dfbae1545ad6cc3c51cf34d7e8ba3"
 dependencies = [
- "windows-result 0.3.2",
+ "windows-result 0.3.3",
  "windows-strings 0.3.1",
  "windows-targets 0.53.0",
 ]
@@ -15248,9 +15246,9 @@ dependencies = [
 
 [[package]]
 name = "windows-result"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+checksum = "4b895b5356fc36103d0f64dd1e94dfa7ac5633f1c9dd6e80fe9ec4adef69e09d"
 dependencies = [
  "windows-link",
 ]
@@ -15266,9 +15264,9 @@ dependencies = [
 
 [[package]]
 name = "windows-strings"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+checksum = "2a7ab927b2637c19b3dbe0965e75d8f2d30bdd697a1516191cad2ec4df8fb28a"
 dependencies = [
  "windows-link",
 ]
@@ -15347,6 +15345,15 @@ dependencies = [
  "windows_x86_64_msvc 0.53.0",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -15534,7 +15541,7 @@ version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]

backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "windmill"
-version = "1.491.0"
+version = "1.491.5"
 authors.workspace = true
 edition.workspace = true
 
@@ -32,7 +32,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.491.0"
+version = "1.491.5"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 edition = "2021"
 

backend/ee-repo-ref.txt

@@ -1 +1 @@
-0a4b3d0ecc9976951517672702e948651806f40b
+3efa7fa51e9f93f60e141fef5b8b9338528cf955

backend/migrations/20250514120017_http_trigger_update_notify.down.sql

@@ -0,0 +1,4 @@
+-- Add down migration script here
+DROP TRIGGER http_trigger_change_trigger ON http_trigger;
+DROP FUNCTION notify_http_trigger_change();
+DROP SEQUENCE http_trigger_version_seq;

backend/migrations/20250514120017_http_trigger_update_notify.up.sql

@@ -0,0 +1,15 @@
+-- Add up migration script here
+CREATE OR REPLACE FUNCTION notify_http_trigger_change()
+RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('notify_http_trigger_change', NEW.workspace_id || ':' || NEW.path);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+CREATE TRIGGER http_trigger_change_trigger
+AFTER INSERT OR UPDATE OR DELETE ON http_trigger
+FOR EACH ROW
+EXECUTE FUNCTION notify_http_trigger_change();
+
+CREATE SEQUENCE http_trigger_version_seq;
+

backend/migrations/20250515155403_add_grant_on_dependency_map.down.sql

@@ -0,0 +1 @@
+-- Add down migration script here

backend/migrations/20250515155403_add_grant_on_dependency_map.up.sql

@@ -0,0 +1,3 @@
+-- Add up migration script here
+GRANT ALL ON dependency_map TO windmill_user;
+GRANT ALL ON dependency_map TO windmill_admin;

backend/migrations/20250515181903_fix_http_routers_cache.down.sql

@@ -0,0 +1 @@
+-- Add down migration script here

backend/migrations/20250515181903_fix_http_routers_cache.up.sql

@@ -0,0 +1,9 @@
+-- Add up migration script here
+-- this makes sure that the first time nextval is called, 2 is returned
+-- otherwise, `SELECT last_value from http_trigger_version_seq;` would return 1 before and after the first nextval call
+-- which would not refresh the routers cache after the first create/update/delete
+SELECT setval(                                  
+    'http_trigger_version_seq',
+    (SELECT last_value FROM http_trigger_version_seq),
+    true
+);

backend/src/main.rs

@@ -810,6 +810,21 @@ Windmill Community Edition {GIT_VERSION}
                                                         }
                                                     }
                                                 },
+                                                #[cfg(feature = "http_trigger")]
+                                                "notify_http_trigger_change" => {
+                                                    tracing::info!("HTTP trigger change detected: {}", n.payload());
+                                                    match windmill_api::http_triggers::refresh_routers(&db).await {
+                                                        Ok((true, _)) => {
+                                                            tracing::info!("Refreshed HTTP routers (trigger change)");
+                                                        },
+                                                        Ok((false, _)) => {
+                                                            tracing::warn!("Should have refreshed HTTP routers (trigger change) but did not");
+                                                        },
+                                                        Err(err) => {
+                                                            tracing::error!("Error refreshing HTTP routers (trigger change): {err:#}");
+                                                        }
+                                                    };
+                                                },
                                                 "notify_global_setting_change" => {
                                                     tracing::info!("Global setting change detected: {}", n.payload());
                                                     match n.payload() {
@@ -1133,6 +1148,10 @@ async fn listen_pg(url: &str) -> Option<PgListener> {
         "notify_workspace_envs_change",
         "notify_runnable_version_change",
     ];
+
+    #[cfg(feature = "http_trigger")]
+    channels.push("notify_http_trigger_change");
+
     #[cfg(feature = "cloud")]
     channels.push("notify_workspace_premium_change");
 

backend/src/monitor.rs

@@ -62,7 +62,11 @@ use windmill_common::{
     users::truncate_token,
     utils::{empty_as_none, now_from_db, rd_string, report_critical_error, Mode},
     worker::{
-        load_env_vars, load_init_bash_from_env, load_whitelist_env_vars_from_env, load_worker_config, reload_custom_tags_setting, store_pull_query, store_suspended_pull_query, update_min_version, Connection, WorkerConfig, DEFAULT_TAGS_PER_WORKSPACE, DEFAULT_TAGS_WORKSPACES, INDEXER_CONFIG, SCRIPT_TOKEN_EXPIRY, SMTP_CONFIG, TMP_DIR, WORKER_CONFIG, WORKER_GROUP
+        load_env_vars, load_init_bash_from_env, load_whitelist_env_vars_from_env,
+        load_worker_config, reload_custom_tags_setting, store_pull_query,
+        store_suspended_pull_query, update_min_version, Connection, WorkerConfig,
+        DEFAULT_TAGS_PER_WORKSPACE, DEFAULT_TAGS_WORKSPACES, INDEXER_CONFIG, SCRIPT_TOKEN_EXPIRY,
+        SMTP_CONFIG, TMP_DIR, WORKER_CONFIG, WORKER_GROUP,
     },
     KillpillSender, BASE_URL, CRITICAL_ALERTS_ON_DB_OVERSIZE, CRITICAL_ALERT_MUTE_UI_ENABLED,
     CRITICAL_ERROR_CHANNELS, DB, DEFAULT_HUB_BASE_URL, HUB_BASE_URL, JOB_RETENTION_SECS,
@@ -829,11 +833,7 @@ pub async fn delete_expired_items(db: &DB) -> () {
             Ok(mut tx) => {
                 let deleted_jobs = sqlx::query_scalar!(
                     "DELETE FROM v2_job_completed c
-                    USING v2_job j
-                    WHERE
-                        created_at <= now() - ($1::bigint::text || ' s')::interval
-                        AND completed_at + ($1::bigint::text || ' s')::interval <= now()
-                        AND c.id = j.id
+                    WHERE completed_at <= now() - ($1::bigint::text || ' s')::interval 
                     RETURNING c.id",
                     job_retention_secs
                 )

backend/windmill-api/openapi.yaml

@@ -1,7 +1,7 @@
 openapi: "3.0.3"
 
 info:
-  version: 1.491.0
+  version: 1.491.5
   title: Windmill API
 
   contact:
@@ -11028,7 +11028,8 @@ paths:
           description: a config
           content:
             application/json:
-              schema: {}
+              schema:
+                $ref: "#/components/schemas/Configs"
 
   /configs/update/{name}:
     post:
@@ -13183,6 +13184,37 @@ components:
         code_completion_model:
           $ref: "#/components/schemas/AIProviderModel"
 
+    Alert:
+      type: object
+      properties:
+        name:
+          type: string
+        tags_to_monitor:
+          type: array
+          items:
+            type: string
+        jobs_num_threshold:
+          type: integer
+        alert_cooldown_seconds:
+          type: integer
+        alert_time_threshold_seconds:
+          type: integer
+      required:
+        - name
+        - tags_to_monitor
+        - jobs_num_threshold
+        - alert_cooldown_seconds
+        - alert_time_threshold_seconds
+
+    Configs:
+      type: object
+      nullable: true
+      properties:
+        alerts:
+          type: array
+          items:
+            $ref: '#/components/schemas/Alert'
+
     Script:
       type: object
       properties:

backend/windmill-api/src/agent_workers_ee.rs

@@ -28,7 +28,7 @@ pub fn workspaced_service(
     use windmill_worker::JobCompletedSender;
 
     let (job_completed_tx, _job_completed_rx) =
-        JobCompletedSender::new(&Connection::Sql(db.clone()), 100);
+        JobCompletedSender::new(&Connection::Sql(db.clone()), 10);
 
     let router = Router::new();
 

backend/windmill-api/src/args.rs

@@ -29,14 +29,14 @@ pub enum RawBody {
     Empty,
 }
 
-#[derive(Clone, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(untagged)]
 pub enum Body {
     HashMap(HashMap<String, Box<RawValue>>),
     NoHashMap(Box<RawValue>),
 }
 
-#[derive(Clone, Default)]
+#[derive(Debug, Clone, Default)]
 pub struct WebhookArgsMetadata {
     pub raw_string: Option<String>,
     pub headers: HashMap<String, Box<RawValue>>,
@@ -51,7 +51,7 @@ pub struct RawWebhookArgs {
     pub metadata: WebhookArgsMetadata,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct WebhookArgs {
     pub body: Body,
     pub metadata: WebhookArgsMetadata,

backend/windmill-api/src/capture.rs

@@ -14,11 +14,18 @@ use {
 };
 
 #[cfg(all(feature = "enterprise", feature = "gcp_trigger"))]
-use crate::gcp_triggers_ee::{
-    manage_google_subscription, process_google_push_request, validate_jwt_token,
-    CreateUpdateConfig, SubscriptionMode,
+use {
+    crate::gcp_triggers_ee::{
+        manage_google_subscription, process_google_push_request, validate_jwt_token,
+        CreateUpdateConfig, SubscriptionMode,
+    },
+    axum::extract::Request,
+    http::HeaderMap,
 };
 
+#[cfg(all(feature = "enterprise", feature = "gcp_trigger"))]
+use windmill_common::utils::empty_as_none;
+
 #[cfg(all(feature = "enterprise", feature = "sqs_trigger"))]
 use windmill_common::auth::aws::AwsAuthResourceType;
 
@@ -26,12 +33,7 @@ use windmill_common::auth::aws::AwsAuthResourceType;
     feature = "http_trigger",
     all(feature = "enterprise", feature = "gcp_trigger")
 ))]
-use {
-    axum::extract::Request,
-    http::HeaderMap,
-    serde::de::DeserializeOwned,
-    windmill_common::{error::Error, utils::empty_as_none},
-};
+use {serde::de::DeserializeOwned, windmill_common::error::Error};
 
 #[cfg(all(feature = "enterprise", feature = "kafka"))]
 use crate::kafka_triggers_ee::KafkaTriggerConfigConnection;

backend/windmill-api/src/db.rs

@@ -782,10 +782,32 @@ async fn fix_job_completed_index(db: &DB) -> Result<(), Error> {
         .execute(db)
         .await?;
     });
+
+    run_windmill_migration!("job_completed_completed_at", db, |tx| {
+        sqlx::query!(
+            "CREATE INDEX CONCURRENTLY IF NOT EXISTS ix_job_completed_completed_at ON v2_job_completed (completed_at DESC)"
+        )
+        .execute(db)
+        .await?;
+    });
+
+    run_windmill_migration!("alerts_by_workspace", db, |tx| {
+        sqlx::query!(
+            "CREATE INDEX CONCURRENTLY IF NOT EXISTS alerts_by_workspace ON alerts (workspace_id);"
+        )
+        .execute(db)
+        .await?;
+    });
+
+    run_windmill_migration!("remove_redundant_log_file_index", db, |tx| {
+        sqlx::query!("DROP INDEX CONCURRENTLY IF EXISTS log_file_hostname_log_ts_idx")
+            .execute(db)
+            .await?;
+    });
     Ok(())
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
 pub struct ApiAuthed {
     pub email: String,
     pub username: String,

backend/windmill-api/src/http_trigger_args.rs

@@ -17,7 +17,7 @@ use crate::{
 
 pub struct RawHttpTriggerArgs(pub RawWebhookArgs);
 
-#[derive(Serialize, Deserialize, sqlx::Type, Debug)]
+#[derive(Serialize, Deserialize, sqlx::Type, Debug, Clone, Hash, Eq, PartialEq)]
 #[sqlx(type_name = "HTTP_METHOD", rename_all = "lowercase")]
 #[serde(rename_all = "lowercase")]
 pub enum HttpMethod {
@@ -56,7 +56,7 @@ where
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HttpTriggerArgs(pub WebhookArgs);
 
 impl RawHttpTriggerArgs {

backend/windmill-api/src/http_trigger_auth.rs

@@ -414,7 +414,7 @@ pub enum Encoding {
     Base64Uri,
     Hex,
 }
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SignatureAuthenticationMethod {
     algorithm: HmacAlgorithm,
     encoding: Encoding,
@@ -426,20 +426,20 @@ pub struct SignatureConfigData<'config> {
     secret_key: &'config str,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SignatureAuthentication {
     signature_provider: WebhookType,
     secret_key: String,
     authentication_config: Option<SignatureAuthenticationMethod>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct BasicAuthAuthentication {
     pub username: String,
     pub password: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ApiKeyAuthentication {
     api_key_header: String,
     api_key_secret: String,
@@ -558,7 +558,7 @@ pub fn verify_hmac_signature(
     Ok(())
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(untagged)]
 pub enum AuthenticationMethod {
     Signature(SignatureAuthentication),

backend/windmill-api/src/http_triggers.rs

@@ -4,7 +4,7 @@ use crate::http_trigger_args::{HttpMethod, RawHttpTriggerArgs};
 use crate::job_helpers_ee::get_workspace_s3_resource;
 use crate::resources::try_get_resource_from_db_as;
 use crate::trigger_helpers::{get_runnable_format, RunnableId};
-use crate::utils::non_empty_str;
+use crate::utils::{non_empty_str, ExpiringCacheEntry};
 use crate::{
     auth::{AuthCache, OptTokened},
     db::{ApiAuthed, DB},
@@ -24,11 +24,14 @@ use axum::{
 #[cfg(feature = "parquet")]
 use http::header::IF_NONE_MATCH;
 use http::{HeaderMap, StatusCode};
+use quick_cache::sync::Cache;
 use serde::{Deserialize, Serialize};
 use sql_builder::{bind::Bind, SqlBuilder};
 use sqlx::prelude::FromRow;
+use sqlx::PgTransaction;
 use std::borrow::Cow;
 use std::{collections::HashMap, sync::Arc};
+use tokio::sync::{RwLock, RwLockReadGuard};
 use tower_http::cors::CorsLayer;
 use windmill_audit::{audit_ee::audit_log, ActionKind};
 use windmill_common::error::Error;
@@ -283,6 +286,16 @@ fn validate_authentication_method(
     Ok(())
 }
 
+async fn increase_trigger_version_and_commit(mut tx: PgTransaction<'_>) -> error::Result<()> {
+    sqlx::query!("SELECT nextval('http_trigger_version_seq')",)
+        .fetch_one(&mut *tx)
+        .await?;
+
+    tx.commit().await?;
+
+    Ok(())
+}
+
 async fn create_trigger(
     authed: ApiAuthed,
     Extension(db): Extension<DB>,
@@ -382,7 +395,7 @@ async fn create_trigger(
     )
     .await?;
 
-    tx.commit().await?;
+    increase_trigger_version_and_commit(tx).await?;
 
     Ok((StatusCode::CREATED, format!("{}", ct.path)))
 }
@@ -538,7 +551,7 @@ async fn update_trigger(
     )
     .await?;
 
-    tx.commit().await?;
+    increase_trigger_version_and_commit(tx).await?;
 
     Ok(path.to_string())
 }
@@ -572,7 +585,7 @@ async fn delete_trigger(
     )
     .await?;
 
-    tx.commit().await?;
+    increase_trigger_version_and_commit(tx).await?;
 
     Ok(format!("HTTP trigger {path} deleted"))
 }
@@ -685,8 +698,8 @@ async fn exists_route(
     Ok(Json(exists))
 }
 
-#[derive(Debug, Deserialize)]
-struct TriggerRoute {
+#[derive(Debug, Deserialize, Clone)]
+pub struct TriggerRoute {
     path: String,
     script_path: String,
     is_flow: bool,
@@ -704,6 +717,145 @@ struct TriggerRoute {
     raw_string: bool,
 }
 
+pub struct RoutersCache {
+    routers: HashMap<HttpMethod, matchit::Router<TriggerRoute>>,
+    version: i64,
+}
+
+lazy_static::lazy_static! {
+    static ref HTTP_ACCESS_CACHE: Cache<(String, String, ApiAuthed), ExpiringCacheEntry<()>> = Cache::new(100);
+    static ref HTTP_AUTH_CACHE: Cache<(String, String, ApiAuthed), ExpiringCacheEntry<crate::http_trigger_auth::AuthenticationMethod>> = Cache::new(100);
+
+    static ref HTTP_ROUTERS_CACHE: RwLock<RoutersCache> = RwLock::new(RoutersCache {
+        routers: HashMap::new(),
+        version: 0,
+    });
+}
+
+pub async fn refresh_routers_loop(
+    db: &DB,
+    mut killpill_rx: tokio::sync::broadcast::Receiver<()>,
+) -> () {
+    match refresh_routers(db).await {
+        Ok(_) => {
+            tracing::info!("Loaded HTTP routers");
+        }
+        Err(err) => {
+            tracing::error!("Error loading HTTP routers: {err:#}");
+        }
+    };
+    let db = db.clone();
+    tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                _ = killpill_rx.recv() => {
+                    break;
+                }
+                _ = tokio::time::sleep(std::time::Duration::from_secs(60)) => {
+                    match refresh_routers(&db).await {
+                        Ok((true, _)) => {
+                            tracing::info!("Refreshed HTTP routers");
+                        }
+                        Err(err) => {
+                            tracing::error!("Error refreshing HTTP routers: {err:#}");
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    });
+}
+
+pub async fn refresh_routers(db: &DB) -> Result<(bool, RwLockReadGuard<'_, RoutersCache>), Error> {
+    let version = sqlx::query_scalar!("SELECT last_value FROM http_trigger_version_seq",)
+        .fetch_one(db)
+        .await?;
+    let routers_cache = HTTP_ROUTERS_CACHE.read().await;
+    if routers_cache.version == 0 || version > routers_cache.version {
+        drop(routers_cache);
+        let mut routers = HashMap::new();
+
+        for http_method in [
+            HttpMethod::Get,
+            HttpMethod::Post,
+            HttpMethod::Put,
+            HttpMethod::Patch,
+            HttpMethod::Delete,
+        ] {
+            let triggers = sqlx::query_as!(
+                TriggerRoute,
+                r#"
+                    SELECT 
+                        path, 
+                        script_path, 
+                        is_flow, 
+                        route_path, 
+                        authentication_resource_path,
+                        workspace_id, 
+                        is_async, 
+                        authentication_method  AS "authentication_method: _", 
+                        edited_by, 
+                        email, 
+                        static_asset_config AS "static_asset_config: _",
+                        wrap_body,
+                        raw_string,
+                        workspaced_route,
+                        is_static_website
+                    FROM 
+                        http_trigger 
+                    WHERE 
+                        http_method = $1
+                    "#,
+                &http_method as &HttpMethod
+            )
+            .fetch_all(db)
+            .await?;
+
+            let mut router = matchit::Router::new();
+
+            for trigger in triggers {
+                let full_path = if trigger.workspaced_route || *CLOUD_HOSTED {
+                    format!("/{}/{}", trigger.workspace_id, trigger.route_path)
+                } else {
+                    format!("/{}", trigger.route_path)
+                };
+
+                if trigger.is_static_website {
+                    router
+                        .insert(format!("{}/*wm_subpath", full_path), trigger.clone())
+                        .unwrap_or_else(|e| {
+                            tracing::warn!(
+                                "Failed to consider http trigger route {}/*wm_subpath: {:?}",
+                                full_path,
+                                e,
+                            );
+                        });
+                }
+                router
+                    .insert(full_path.clone(), trigger.clone())
+                    .unwrap_or_else(|e| {
+                        tracing::warn!(
+                            "Failed to consider http trigger route {}: {:?}",
+                            full_path,
+                            e,
+                        );
+                    });
+            }
+
+            routers.insert(http_method, router);
+        }
+
+        let mut routers_cache = HTTP_ROUTERS_CACHE.write().await;
+        *routers_cache = RoutersCache { routers, version };
+
+        Ok((true, routers_cache.downgrade()))
+    } else {
+        tracing::debug!("No HTTP routers refresh needed");
+        Ok((false, routers_cache))
+    }
+}
+
 async fn get_http_route_trigger(
     route_path: &str,
     auth_cache: &Arc<AuthCache>,
@@ -713,111 +865,30 @@ async fn get_http_route_trigger(
     method: &http::Method,
 ) -> error::Result<(TriggerRoute, String, HashMap<String, String>, ApiAuthed)> {
     let http_method: HttpMethod = method.try_into()?;
-    let (mut triggers, route_path) = if *CLOUD_HOSTED {
-        let mut splitted = route_path.split("/");
-        let w_id = splitted.next().ok_or_else(|| {
-            error::Error::BadRequest("Missing workspace id in route path".to_string())
-        })?;
-        let route_path = StripPath(splitted.collect::<Vec<_>>().join("/"));
-        let triggers = sqlx::query_as!(
-            TriggerRoute,
-            r#"
-            SELECT 
-                path, 
-                script_path, 
-                is_flow, 
-                route_path, 
-                workspace_id, 
-                is_async, 
-                authentication_method  AS "authentication_method: _", 
-                edited_by, 
-                email,
-                static_asset_config AS "static_asset_config: _",
-                wrap_body,
-                raw_string,
-                workspaced_route,
-                is_static_website,
-                authentication_resource_path
-            FROM 
-                http_trigger 
-            WHERE 
-                workspace_id = $1 AND 
-                http_method = $2
-            "#,
-            w_id,
-            http_method as HttpMethod
-        )
-        .fetch_all(db)
-        .await?;
-        (triggers, route_path)
+
+    let requested_path = format!("/{}", route_path);
+
+    let routers_cache = HTTP_ROUTERS_CACHE.read().await;
+
+    let routers_cache = if routers_cache.routers.is_empty() {
+        tracing::warn!("HTTP routers are not loaded, loading from db");
+        let (_, routers_cache) = refresh_routers(db).await?;
+        routers_cache
     } else {
-        let triggers = sqlx::query_as!(
-            TriggerRoute,
-            r#"
-            SELECT 
-                path, 
-                script_path, 
-                is_flow, 
-                route_path, 
-                authentication_resource_path,
-                workspace_id, 
-                is_async, 
-                authentication_method  AS "authentication_method: _", 
-                edited_by, 
-                email, 
-                static_asset_config AS "static_asset_config: _",
-                wrap_body,
-                raw_string,
-                workspaced_route,
-                is_static_website
-            FROM 
-                http_trigger 
-            WHERE 
-                http_method = $1
-            "#,
-            http_method as HttpMethod
-        )
-        .fetch_all(db)
-        .await?;
-        (triggers, StripPath(route_path.to_string()))
+        routers_cache
     };
 
-    let mut router = matchit::Router::new();
+    let router = routers_cache
+        .routers
+        .get(&http_method)
+        .ok_or(error::Error::internal_err(
+            "HTTP routers could not be loaded".to_string(),
+        ))?;
 
-    for (idx, trigger) in triggers.iter().enumerate() {
-        let route_path = match trigger.workspaced_route {
-            true => format!("{}/{}", &trigger.workspace_id, &trigger.route_path),
-            _ => trigger.route_path.clone(),
-        };
-        if trigger.is_static_website {
-            router
-                .insert(format!("/{}/*wm_subpath", route_path), idx)
-                .unwrap_or_else(|e| {
-                    tracing::warn!(
-                        "Failed to consider http trigger route {}: {:?}",
-                        route_path,
-                        e,
-                    );
-                });
-        }
-        router
-            .insert(format!("/{}", route_path), idx)
-            .unwrap_or_else(|e| {
-                tracing::warn!(
-                    "Failed to consider http trigger route {}: {:?}",
-                    route_path,
-                    e,
-                );
-            });
-    }
+    let trigger_match = router.at(requested_path.as_str()).ok();
 
-    let requested_path = format!("/{}", route_path.0);
-    let trigger_idx = router.at(requested_path.as_str()).ok();
-
-    let matchit::Match { value: trigger_idx, params } =
-        not_found_if_none(trigger_idx, "Trigger", requested_path.as_str())?;
-
-    let trigger = triggers.remove(trigger_idx.to_owned());
+    let matchit::Match { value: trigger, params } =
+        not_found_if_none(trigger_match, "Trigger", requested_path.as_str())?;
 
     let params: HashMap<String, String> = params
         .iter()
@@ -834,25 +905,49 @@ async fn get_http_route_trigger(
         };
         if let Some(authed) = opt_authed {
             // check that the user has access to the trigger
-            let mut tx = user_db.begin(&authed).await?;
-            let exists = sqlx::query_scalar!(
-                r#"
-                SELECT EXISTS(
-                    SELECT 1 
-                    FROM 
-                        http_trigger 
-                    WHERE 
-                        workspace_id = $1 AND 
-                        path = $2
-                )
-                "#,
-                trigger.workspace_id,
-                trigger.path
-            )
-            .fetch_one(&mut *tx)
-            .await?
-            .unwrap_or(false);
-            tx.commit().await?;
+            let cache_key = (
+                trigger.workspace_id.clone(),
+                trigger.path.clone(),
+                authed.clone(),
+            );
+            let exists = match HTTP_ACCESS_CACHE.get(&cache_key) {
+                Some(cache_entry) if cache_entry.expiry > std::time::Instant::now() => {
+                    tracing::debug!("HTTP access cache hit for trigger {}", trigger.path);
+                    true
+                }
+                _ => {
+                    tracing::debug!("HTTP access cache miss for trigger {}", trigger.path);
+                    let mut tx = user_db.begin(&authed).await?;
+                    let exists = sqlx::query_scalar!(
+                        r#"
+                        SELECT EXISTS(
+                            SELECT 1
+                            FROM 
+                                http_trigger 
+                            WHERE 
+                                workspace_id = $1 AND 
+                                path = $2
+                        )
+                        "#,
+                        trigger.workspace_id,
+                        trigger.path
+                    )
+                    .fetch_one(&mut *tx)
+                    .await?
+                    .unwrap_or(false);
+                    if exists {
+                        HTTP_ACCESS_CACHE.insert(
+                            cache_key,
+                            ExpiringCacheEntry {
+                                value: (),
+                                expiry: std::time::Instant::now()
+                                    + std::time::Duration::from_secs(10),
+                            },
+                        );
+                    }
+                    exists
+                }
+            };
             if exists {
                 Some(authed.display_username().to_owned())
             } else {
@@ -876,7 +971,7 @@ async fn get_http_route_trigger(
     )
     .await?;
 
-    Ok((trigger, route_path.0, params, authed))
+    Ok((trigger.clone(), route_path.to_string(), params, authed))
 }
 
 async fn route_job(
@@ -901,7 +996,15 @@ async fn route_job(
     .map_err(|e| e.into_response())?;
 
     let args = args
-        .process_args(&authed, &db, &trigger.workspace_id, trigger.raw_string)
+        .process_args(
+            &authed,
+            &db,
+            &trigger.workspace_id,
+            match trigger.authentication_method {
+                AuthenticationMethod::CustomScript | AuthenticationMethod::Signature => true,
+                _ => trigger.raw_string,
+            },
+        )
         .await
         .map_err(|e| e.into_response())?;
 
@@ -920,31 +1023,45 @@ async fn route_job(
                 }
             };
 
-            let authentication_method =
-                try_get_resource_from_db_as::<crate::http_trigger_auth::AuthenticationMethod>(
-                    authed.clone(),
-                    Some(user_db.clone()),
-                    &db,
-                    &resource_path,
-                    &trigger.workspace_id,
-                )
-                .await
-                .map_err(|e| e.into_response())?;
+            let cache_key = (
+                trigger.workspace_id.clone(),
+                resource_path.clone(),
+                authed.clone(),
+            );
 
-            let raw_payload = args
-                .0
-                .metadata
-                .raw_string
-                .as_ref()
-                .map(|raw_payload| serde_json::from_str::<String>(raw_payload))
-                .transpose()
-                .map_err(|e| {
-                    windmill_common::error::Error::SerdeJson { location: e.to_string(), error: e }
-                        .into_response()
-                })?;
+            let authentication_method = match HTTP_AUTH_CACHE.get(&cache_key) {
+                Some(cache_entry) if cache_entry.expiry > std::time::Instant::now() => {
+                    tracing::debug!("HTTP auth method cache hit for trigger {}", trigger.path);
+                    cache_entry.value
+                }
+                _ => {
+                    tracing::debug!("HTTP auth method cache miss for trigger {}", trigger.path);
+                    let auth_method = try_get_resource_from_db_as::<
+                        crate::http_trigger_auth::AuthenticationMethod,
+                    >(
+                        authed.clone(),
+                        Some(user_db.clone()),
+                        &db,
+                        &resource_path,
+                        &trigger.workspace_id,
+                    )
+                    .await
+                    .map_err(|e| e.into_response())?;
+                    HTTP_AUTH_CACHE.insert(
+                        cache_key,
+                        ExpiringCacheEntry {
+                            value: auth_method.clone(),
+                            expiry: std::time::Instant::now() + std::time::Duration::from_secs(60),
+                        },
+                    );
+                    auth_method
+                }
+            };
+
+            let raw_payload = args.0.metadata.raw_string.as_ref();
 
             let response = authentication_method
-                .authenticate_http_request(&headers, raw_payload.as_ref())
+                .authenticate_http_request(&headers, raw_payload)
                 .map_err(|e| e.into_response())?;
 
             if let Some(response) = response {

backend/windmill-api/src/lib.rs

@@ -85,13 +85,14 @@ mod http_trigger_args;
 #[cfg(feature = "http_trigger")]
 mod http_trigger_auth;
 #[cfg(feature = "http_trigger")]
-mod http_triggers;
+pub mod http_triggers;
 mod indexer_ee;
 mod inputs;
 mod integration;
 #[cfg(feature = "postgres_trigger")]
 mod postgres_triggers;
 
+mod approvals;
 #[cfg(feature = "enterprise")]
 mod apps_ee;
 #[cfg(all(feature = "enterprise", feature = "gcp_trigger"))]
@@ -120,12 +121,11 @@ mod scripts;
 mod service_logs;
 mod settings;
 mod slack_approvals;
-mod approvals;
-mod teams_approvals_ee;
 #[cfg(feature = "smtp")]
 mod smtp_server_ee;
 #[cfg(all(feature = "enterprise", feature = "sqs_trigger"))]
 mod sqs_triggers_ee;
+mod teams_approvals_ee;
 mod trigger_helpers;
 
 mod static_assets;
@@ -406,6 +406,12 @@ pub async fn run_server(
         Router::new()
     };
 
+    #[cfg(feature = "http_trigger")]
+    {
+        let http_killpill_rx = killpill_rx.resubscribe();
+        http_triggers::refresh_routers_loop(&db, http_killpill_rx).await;
+    }
+
     let postgres_triggers_service = {
         #[cfg(feature = "postgres_trigger")]
         {

backend/windmill-api/src/trigger_helpers.rs

@@ -4,6 +4,7 @@ use serde_json::value::RawValue;
 use std::collections::HashMap;
 use windmill_common::{
     error::Result,
+    flows::FlowModuleValue,
     get_latest_deployed_hash_for_path, get_latest_flow_version_info_for_path,
     scripts::{ScriptHash, ScriptLang},
     worker::to_raw_value,
@@ -38,12 +39,6 @@ struct ScriptInfo {
     schema: Option<sqlx::types::Json<PartialSchema>>,
 }
 
-struct FlowInfo {
-    has_preprocessor: Option<bool>,
-    is_v1_preprocessor: Option<bool>,
-    schema: Option<sqlx::types::Json<PartialSchema>>,
-}
-
 #[derive(Debug, Deserialize)]
 struct PropertyDefinition {
     r#type: Option<String>,
@@ -104,9 +99,8 @@ async fn get_script_info(
         .await
 }
 
-fn runnable_format_from_schema(
+fn runnable_format_from_schema_without_preprocessor(
     trigger_kind: &TriggerKind,
-    has_preprocessor: bool,
     schema: Option<sqlx::types::Json<PartialSchema>>,
 ) -> RunnableFormat {
     match trigger_kind {
@@ -119,7 +113,7 @@ fn runnable_format_from_schema(
                 })
             }) =>
         {
-            RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor }
+            RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: false }
         }
         TriggerKind::Kafka | TriggerKind::Nats
             if schema.as_ref().is_some_and(|schema| {
@@ -129,18 +123,46 @@ fn runnable_format_from_schema(
                     .is_some_and(|properties| properties.keys().any(|key| key == "msg"))
             }) =>
         {
-            RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor }
+            RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: false }
         }
-        _ => RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor },
+        _ => RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: false },
     }
 }
+
+fn runnable_format_from_preprocessor_args(
+    args: Option<Vec<windmill_parser::Arg>>,
+) -> RunnableFormat {
+    if let Some(args) = args {
+        if args.iter().any(|arg| arg.name == "wm_trigger")
+            || (args.len() > 0 && args.iter().all(|arg| arg.name != "event"))
+        {
+            RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: true }
+        } else {
+            RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: true }
+        }
+    } else {
+        RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: true }
+    }
+}
+
+enum PreprocessorInfo {
+    Preprocessor { content: String, language: ScriptLang },
+    NoPreprocessor { schema: Option<sqlx::types::Json<PartialSchema>> },
+}
+
+#[derive(Debug, Deserialize)]
+struct FlowInfo {
+    preprocessor_module: Option<sqlx::types::Json<FlowModuleValue>>,
+    schema: Option<sqlx::types::Json<PartialSchema>>,
+}
+
 pub async fn get_runnable_format(
     runnable_id: RunnableId,
     workspace_id: &str,
     db: &DB,
     trigger_kind: &TriggerKind,
 ) -> Result<RunnableFormat> {
-    match runnable_id {
+    let (key, preprocessor_info) = match runnable_id {
         RunnableId::FlowPath(path) => {
             let FlowVersionInfo { version, .. } =
                 get_latest_flow_version_info_for_path(db, workspace_id, &path, true).await?;
@@ -157,11 +179,10 @@ pub async fn get_runnable_format(
             let flow_info = sqlx::query_as!(
                 FlowInfo,
                 "SELECT
-                    value->'preprocessor_module' IS NOT NULL as has_preprocessor,
-                    value->'preprocessor_module'->'value'->'input_transforms'->'wm_trigger' IS NOT NULL as is_v1_preprocessor,
+                    value->'preprocessor_module'->'value' as \"preprocessor_module: _\",
                     schema as \"schema: _\"
                 FROM flow 
-                WHERE workspace_id = $1 
+                WHERE workspace_id = $1
                     AND path = $2",
                 workspace_id,
                 path
@@ -169,18 +190,40 @@ pub async fn get_runnable_format(
             .fetch_one(db)
             .await?;
 
-            let has_preprocessor = flow_info.has_preprocessor.unwrap_or(false);
-            let is_v1_preprocessor = flow_info.is_v1_preprocessor.unwrap_or(false);
-
-            let runnable_format = if has_preprocessor && is_v1_preprocessor {
-                RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: true }
+            if let Some(preprocessor_module) = flow_info.preprocessor_module {
+                match preprocessor_module.0 {
+                    FlowModuleValue::RawScript { content, language, .. } => {
+                        (key, PreprocessorInfo::Preprocessor { content, language })
+                    }
+                    FlowModuleValue::Script { path, hash, .. } => {
+                        let hash = if let Some(hash) = hash {
+                            hash.0
+                        } else {
+                            let script_hash =
+                                get_latest_deployed_hash_for_path(db, workspace_id, &path).await?;
+                            script_hash.hash
+                        };
+                        let script_info = get_script_info(db, workspace_id, hash).await?;
+                        (
+                            key,
+                            PreprocessorInfo::Preprocessor {
+                                content: script_info.content,
+                                language: script_info.language,
+                            },
+                        )
+                    }
+                    _ => {
+                        return Err(windmill_common::error::Error::internal_err(
+                            "Unsupported preprocessor module".to_string(),
+                        ));
+                    }
+                }
             } else {
-                runnable_format_from_schema(trigger_kind, has_preprocessor, flow_info.schema)
-            };
-
-            RUNNABLE_FORMAT_VERSION_CACHE.insert(key, runnable_format);
-
-            Ok(runnable_format)
+                (
+                    key,
+                    PreprocessorInfo::NoPreprocessor { schema: flow_info.schema },
+                )
+            }
         }
         RunnableId::ScriptId(script_id) => {
             let hash = script_id.get_script_hash(workspace_id, db).await?;
@@ -194,47 +237,59 @@ pub async fn get_runnable_format(
 
             let script_info = get_script_info(db, workspace_id, hash).await?;
 
-            let has_preprocessor = script_info.has_preprocessor.unwrap_or(false);
-
-            let runnable_format = if has_preprocessor {
-                let args = match script_info.language {
-                    ScriptLang::Bun
-                    | ScriptLang::Bunnative
-                    | ScriptLang::Deno
-                    | ScriptLang::Nativets => {
-                        let args = windmill_parser_ts::parse_deno_signature(
-                            &script_info.content,
-                            true,
-                            false,
-                            Some("preprocessor".to_string()),
-                        )?;
-                        Some(args.args)
-                    }
-                    ScriptLang::Python3 => {
-                        let args = windmill_parser_py::parse_python_signature(
-                            &script_info.content,
-                            Some("preprocessor".to_string()),
-                            false,
-                        )?;
-                        Some(args.args)
-                    }
-                    _ => None,
-                };
-
-                if args.is_some_and(|args| args.iter().any(|arg| arg.name == "wm_trigger")) {
-                    RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: true }
-                } else {
-                    runnable_format_from_schema(trigger_kind, has_preprocessor, script_info.schema)
-                }
+            if script_info.has_preprocessor.unwrap_or(false) {
+                (
+                    key,
+                    PreprocessorInfo::Preprocessor {
+                        content: script_info.content,
+                        language: script_info.language,
+                    },
+                )
             } else {
-                runnable_format_from_schema(trigger_kind, has_preprocessor, script_info.schema)
+                (
+                    key,
+                    PreprocessorInfo::NoPreprocessor { schema: script_info.schema },
+                )
+            }
+        }
+    };
+
+    let runnable_format = match preprocessor_info {
+        PreprocessorInfo::Preprocessor { content, language } => {
+            let args = match language {
+                ScriptLang::Bun
+                | ScriptLang::Bunnative
+                | ScriptLang::Deno
+                | ScriptLang::Nativets => {
+                    let args = windmill_parser_ts::parse_deno_signature(
+                        &content,
+                        true,
+                        false,
+                        Some("preprocessor".to_string()),
+                    )?;
+                    Some(args.args)
+                }
+                ScriptLang::Python3 => {
+                    let args = windmill_parser_py::parse_python_signature(
+                        &content,
+                        Some("preprocessor".to_string()),
+                        false,
+                    )?;
+                    Some(args.args)
+                }
+                _ => None,
             };
 
-            RUNNABLE_FORMAT_VERSION_CACHE.insert(key, runnable_format);
-
-            Ok(runnable_format)
+            runnable_format_from_preprocessor_args(args)
         }
-    }
+        PreprocessorInfo::NoPreprocessor { schema } => {
+            runnable_format_from_schema_without_preprocessor(trigger_kind, schema)
+        }
+    };
+
+    RUNNABLE_FORMAT_VERSION_CACHE.insert(key, runnable_format);
+
+    Ok(runnable_format)
 }
 
 #[allow(dead_code)]

backend/windmill-api/src/users.rs

@@ -8,6 +8,8 @@
 
 #![allow(non_snake_case)]
 
+use quick_cache::sync::Cache;
+
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use std::time::Duration;
@@ -20,7 +22,8 @@ use crate::utils::{
     generate_instance_wide_unique_username, get_instance_username_or_create_pending,
 };
 use crate::{
-    db::DB, utils::require_super_admin, webhook_util::WebhookShared, COOKIE_DOMAIN, IS_SECURE,
+    auth::ExpiringAuthCache, db::DB, utils::require_super_admin, webhook_util::WebhookShared,
+    COOKIE_DOMAIN, IS_SECURE,
 };
 use argon2::{Argon2, PasswordHash, PasswordVerifier};
 use axum::{
@@ -214,6 +217,10 @@ pub async fn fetch_api_authed(
     fetch_api_authed_from_permissioned_as(permissioned_as, email, w_id, db, username_override).await
 }
 
+lazy_static::lazy_static! {
+    static ref API_AUTHED_CACHE: Cache<(String,String,String), ExpiringAuthCache> = Cache::new(300);
+}
+
 #[allow(unused)]
 pub async fn fetch_api_authed_from_permissioned_as(
     permissioned_as: String,
@@ -222,18 +229,43 @@ pub async fn fetch_api_authed_from_permissioned_as(
     db: &DB,
     username_override: Option<String>,
 ) -> error::Result<ApiAuthed> {
-    let authed =
-        fetch_authed_from_permissioned_as(permissioned_as, email.clone(), w_id, db).await?;
-    Ok(ApiAuthed {
-        username: authed.username,
-        email: email,
-        is_admin: authed.is_admin,
-        is_operator: authed.is_operator,
-        groups: authed.groups,
-        folders: authed.folders,
-        scopes: authed.scopes,
-        username_override: username_override,
-    })
+    let key = (w_id.to_string(), permissioned_as.clone(), email.clone());
+
+    let mut api_authed = match API_AUTHED_CACHE.get(&key) {
+        Some(expiring_authed) if expiring_authed.expiry > chrono::Utc::now() => {
+            tracing::debug!("API authed cache hit for user {}", email);
+            expiring_authed.authed
+        }
+        _ => {
+            tracing::debug!("API authed cache miss for user {}", email);
+            let authed =
+                fetch_authed_from_permissioned_as(permissioned_as, email.clone(), w_id, db).await?;
+
+            let api_authed = ApiAuthed {
+                username: authed.username,
+                email: email,
+                is_admin: authed.is_admin,
+                is_operator: authed.is_operator,
+                groups: authed.groups,
+                folders: authed.folders,
+                scopes: authed.scopes,
+                username_override: None,
+            };
+
+            API_AUTHED_CACHE.insert(
+                key,
+                ExpiringAuthCache {
+                    authed: api_authed.clone(),
+                    expiry: chrono::Utc::now() + chrono::Duration::try_seconds(120).unwrap(),
+                },
+            );
+
+            api_authed
+        }
+    };
+
+    api_authed.username_override = username_override;
+    Ok(api_authed)
 }
 
 #[derive(FromRow, Serialize)]

backend/windmill-api/src/utils.rs

@@ -5,7 +5,6 @@
  * Please see the included NOTICE for copyright information and
  * LICENSE-AGPL for a copy of the license.
  */
-
 use axum::{body::Body, response::Response};
 use regex::Regex;
 use serde::{Deserialize, Deserializer};
@@ -415,3 +414,10 @@ pub async fn acknowledge_all_critical_alerts(
     );
     Ok("All unacknowledged critical alerts acknowledged".to_string())
 }
+
+#[cfg(feature = "http_trigger")]
+#[derive(Clone)]
+pub struct ExpiringCacheEntry<T> {
+    pub value: T,
+    pub expiry: std::time::Instant,
+}

backend/windmill-queue/src/jobs.rs

@@ -140,6 +140,7 @@ pub struct CanceledBy {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JobCompleted {
     pub job: Arc<MiniPulledJob>,
+    pub preprocessed_args: Option<HashMap<String, Box<RawValue>>>,
     pub result: Arc<Box<RawValue>>,
     pub result_columns: Option<Vec<String>>,
     pub mem_peak: i32,
@@ -2664,7 +2665,7 @@ async fn concurrency_key(db: &Pool<Postgres>, id: &Uuid) -> windmill_common::err
     )
 }
 
-fn interpolate_args(x: String, args: &PushArgs, workspace_id: &str) -> String {
+pub fn interpolate_args(x: String, args: &PushArgs, workspace_id: &str) -> String {
     // Save this value to avoid parsing twice
     let workspaced = x.as_str().replace("$workspace", workspace_id).to_string();
     if RE_ARG_TAG.is_match(&workspaced) {
@@ -2702,7 +2703,6 @@ fn interpolate_args(x: String, args: &PushArgs, workspace_id: &str) -> String {
                     .trim_matches('"')
                     .to_string()
             };
-            tracing::error!("arg_value: {}", arg_value);
             interpolated =
                 interpolated.replace(format!("$args[{}]", arg_name).as_str(), &arg_value);
         }
@@ -3887,11 +3887,13 @@ pub async fn push<'c, 'd>(
             let cache_ttl = value.cache_ttl.map(|x| x as i32);
             let custom_concurrency_key = value.concurrency_key.clone();
             let concurrency_time_window_s = value.concurrency_time_window_s;
-            let concurrent_limit = value.concurrent_limit;
+            let mut concurrent_limit = value.concurrent_limit;
 
             if !apply_preprocessor {
                 value.preprocessor_module = None;
             } else {
+                tag = None;
+                concurrent_limit = None;
                 preprocessed = Some(false);
             }
 
@@ -4173,27 +4175,7 @@ pub async fn push<'c, 'd>(
     };
 
     if concurrent_limit.is_some() {
-        let concurrency_key = custom_concurrency_key
-            .map(|x| interpolate_args(x, &args, workspace_id))
-            .unwrap_or(fullpath_with_workspace(
-                workspace_id,
-                script_path.as_ref(),
-                &job_kind,
-            ));
-        sqlx::query!(
-            "WITH inserted_concurrency_counter AS (
-                INSERT INTO concurrency_counter (concurrency_id, job_uuids) 
-                VALUES ($1, '{}'::jsonb)
-                ON CONFLICT DO NOTHING
-            )
-            INSERT INTO concurrency_key(key, job_id) VALUES ($1, $2)",
-            concurrency_key,
-            job_id,
-        )
-        .execute(&mut *tx)
-        .warn_after_seconds(3)
-        .await
-        .map_err(|e| Error::internal_err(format!("Could not insert concurrency_key={concurrency_key} for job_id={job_id} script_path={script_path:?} workspace_id={workspace_id}: {e:#}")))?;
+        insert_concurrency_key(workspace_id, &args, &script_path, job_kind, custom_concurrency_key, &mut tx, job_id).await?;
     }
 
     let stringified_args = if *JOB_ARGS_AUDIT_LOGS {
@@ -4211,6 +4193,7 @@ pub async fn push<'c, 'd>(
         Some("preprocessor") => Some(false),
         _ => None,
     });
+    
 
     let job_authed = match authed {
         Some(authed)
@@ -4433,6 +4416,31 @@ pub async fn push<'c, 'd>(
     Ok((job_id, tx))
 }
 
+pub async fn insert_concurrency_key<'d, 'c>(workspace_id: &str, args: &PushArgs<'d>, script_path: &Option<String>, job_kind: JobKind, custom_concurrency_key: Option<String>, tx: &mut Transaction<'c, Postgres>, job_id: Uuid) -> Result<(), Error> {
+    let concurrency_key = custom_concurrency_key
+        .map(|x| interpolate_args(x, args, workspace_id))
+        .unwrap_or(fullpath_with_workspace(
+            workspace_id,
+            script_path.as_ref(),
+            &job_kind,
+        ));
+    sqlx::query!(
+        "WITH inserted_concurrency_counter AS (
+                INSERT INTO concurrency_counter (concurrency_id, job_uuids) 
+                VALUES ($1, '{}'::jsonb)
+                ON CONFLICT DO NOTHING
+            )
+            INSERT INTO concurrency_key(key, job_id) VALUES ($1, $2)",
+        concurrency_key,
+        job_id,
+    )
+    .execute(&mut **tx)
+    .warn_after_seconds(3)
+    .await
+    .map_err(|e| Error::internal_err(format!("Could not insert concurrency_key={concurrency_key} for job_id={job_id} script_path={script_path:?} workspace_id={workspace_id}: {e:#}")))?;
+    Ok(())
+}
+
 pub fn canceled_job_to_result(job: &MiniPulledJob) -> serde_json::Value {
     let reason = job
         .canceled_reason

backend/windmill-worker/Cargo.toml

@@ -57,6 +57,7 @@ sqlx.workspace = true
 uuid.workspace = true
 tracing.workspace = true
 tokio.workspace = true
+tokio-stream.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 futures.workspace = true

backend/windmill-worker/src/bigquery_executor.rs

@@ -206,7 +206,7 @@ fn do_bigquery_inner<'a>(
                             convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
                         s3.upload(stream.boxed()).await?;
 
-                        return Ok(to_raw_value(&s3.object_key));
+                        return Ok(to_raw_value(&s3.to_return_s3_obj()));
                     }
 
                     Ok(to_raw_value(&rows))

backend/windmill-worker/src/common.rs

@@ -1591,7 +1591,7 @@ pub struct S3ModeWorkerData {
 }
 
 impl S3ModeWorkerData {
-    pub async fn upload<S>(&self, stream: S) -> error::Result<reqwest::Response>
+    pub async fn upload<S>(&self, stream: S) -> error::Result<()>
     where
         S: futures::stream::TryStream + Send + 'static,
         S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
@@ -1606,6 +1606,14 @@ impl S3ModeWorkerData {
             )
             .await
     }
+
+    pub fn to_return_s3_obj(&self) -> windmill_common::s3_helpers::S3Object {
+        windmill_common::s3_helpers::S3Object {
+            s3: self.object_key.clone(),
+            storage: self.storage.clone(),
+            ..Default::default()
+        }
+    }
 }
 
 pub fn s3_mode_args_to_worker_data(

backend/windmill-worker/src/dedicated_worker.rs

@@ -187,14 +187,14 @@ pub async fn handle_dedicated_process(
                                 let result = Arc::new(result);
                                 append_logs(&job.id, &job.workspace_id,  logs.clone(), &db.into()).await;
                                 if line.starts_with("wm_res[success]:") {
-                                    job_completed_tx.send_job(JobCompleted { job , result, result_columns: None, mem_peak: 0, canceled_by: None, success: true, cached_res_path: None, token: token.to_string(), duration: None }).await.unwrap()
+                                    job_completed_tx.send_job(JobCompleted { job , result, result_columns: None, mem_peak: 0, canceled_by: None, success: true, cached_res_path: None, token: token.to_string(), duration: None, preprocessed_args: None }, true).await.unwrap()
                                 } else {
-                                    job_completed_tx.send_job(JobCompleted { job , result, result_columns: None, mem_peak: 0, canceled_by: None, success: false, cached_res_path: None, token: token.to_string(), duration: None }).await.unwrap()
+                                    job_completed_tx.send_job(JobCompleted { job , result, result_columns: None, mem_peak: 0, canceled_by: None, success: false, cached_res_path: None, token: token.to_string(), duration: None, preprocessed_args: None }, true).await.unwrap()
                                 }
                             },
                             Err(e) => {
                                 tracing::error!("Could not deserialize job result `{line}`: {e:?}");
-                                job_completed_tx.send_job(JobCompleted { job , result: Arc::new(to_raw_value(&serde_json::json!({"error": format!("Could not deserialize job result `{line}`: {e:?}")}))), result_columns: None, mem_peak: 0, canceled_by: None, success: false, cached_res_path: None, token: token.to_string(), duration: None }).await.unwrap();
+                                job_completed_tx.send_job(JobCompleted { job , result: Arc::new(to_raw_value(&serde_json::json!({"error": format!("Could not deserialize job result `{line}`: {e:?}")}))), result_columns: None, mem_peak: 0, canceled_by: None, success: false, cached_res_path: None, token: token.to_string(), duration: None, preprocessed_args: None }, true).await.unwrap();
                             },
                         };
                         logs = init_log.clone();

backend/windmill-worker/src/mssql_executor.rs

@@ -214,7 +214,7 @@ pub async fn do_mssql(
             let stream = convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
             s3.upload(stream.boxed()).await?;
 
-            Ok(serde_json::value::to_raw_value(&s3.object_key)?)
+            Ok(to_raw_value(&s3.to_return_s3_obj()))
         } else {
             let stream = prepared_query.query(&mut client).await.map_err(to_anyhow)?;
             let results = stream.into_results().await.map_err(to_anyhow)?;

backend/windmill-worker/src/mysql_executor.rs

@@ -105,7 +105,7 @@ fn do_mysql_inner<'a>(
             let stream = convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
             s3.upload(stream.boxed()).await?;
 
-            Ok(serde_json::value::to_raw_value(&s3.object_key)?)
+            Ok(to_raw_value(&s3.to_return_s3_obj()))
         } else {
             let rows: Vec<Row> = conn
                 .lock()

backend/windmill-worker/src/oracledb_executor.rs

@@ -1,26 +1,31 @@
 use anyhow::anyhow;
 use chrono::Utc;
-use std::{collections::HashMap, str::FromStr, sync::Arc};
+use std::{collections::HashMap, str::FromStr, sync::Arc, vec};
 use windmill_parser::Arg;
 
-use futures::{future::BoxFuture, FutureExt};
+use futures::{future::BoxFuture, FutureExt, StreamExt};
 use itertools::Itertools;
 use oracle::sql_type::{InnerValue, OracleType, ToSql};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, value::RawValue, Value};
 use windmill_common::{
     error::{to_anyhow, Error},
+    s3_helpers::convert_json_line_stream,
     worker::{to_raw_value, Connection},
 };
 use windmill_queue::MiniPulledJob;
 
 use windmill_parser_sql::{
-    parse_db_resource, parse_oracledb_sig, parse_sql_blocks, parse_sql_statement_named_params,
+    parse_db_resource, parse_oracledb_sig, parse_s3_mode, parse_sql_blocks,
+    parse_sql_statement_named_params,
 };
 use windmill_queue::CanceledBy;
 
 use crate::{
-    common::{build_args_values, check_executor_binary_exists, OccupancyMetrics},
+    common::{
+        build_args_values, check_executor_binary_exists, s3_mode_args_to_worker_data,
+        OccupancyMetrics, S3ModeWorkerData,
+    },
     handle_child::run_future_with_polling_update_job_poller,
     sanitized_sql_params::sanitize_and_interpolate_unsafe_sql_args,
     AuthedClient,
@@ -43,6 +48,7 @@ pub fn do_oracledb_inner<'a>(
     conn: Arc<std::sync::Mutex<oracle::Connection>>,
     column_order: Option<&'a mut Option<Vec<String>>>,
     skip_collect: bool,
+    s3: Option<S3ModeWorkerData>,
 ) -> windmill_common::error::Result<BoxFuture<'a, windmill_common::error::Result<Box<RawValue>>>> {
     let qw = query.trim_end_matches(';').to_string();
 
@@ -81,55 +87,90 @@ pub fn do_oracledb_inner<'a>(
 
             Ok(to_raw_value(&Value::Array(vec![])))
         } else {
-            let rows = tokio::task::spawn_blocking(move || {
-                let params2: Vec<(&str, &dyn ToSql)> = params
-                    .iter()
-                    .filter(|(k, _)| param_names.contains(&k.clone().into_bytes()))
-                    .map(|(key, val)| (key.as_str(), &**val as &dyn ToSql))
-                    .collect();
+            // We use an mpsc because we need an async stream for s3 mode. However since everything is sync
+            // in rust-oracle, I assumed that calling ResultSet::next() is blocking when it has to refetch.
+            let (tx, rx) = tokio::sync::mpsc::channel::<oracle::Result<Value>>(1000);
+            let (column_order_oneshot_tx, column_order_oneshot_rx) =
+                tokio::sync::oneshot::channel::<Option<Vec<String>>>();
+            let mut column_order_oneshot_tx = Some(column_order_oneshot_tx);
+            let rows_stream = tokio_stream::wrappers::ReceiverStream::new(rx);
+            tokio::task::spawn_blocking(move || {
+                let result = (|| {
+                    let tx = tx.clone();
+                    let params2: Vec<(&str, &dyn ToSql)> = params
+                        .iter()
+                        .filter(|(k, _)| param_names.contains(&k.clone().into_bytes()))
+                        .map(|(key, val)| (key.as_str(), &**val as &dyn ToSql))
+                        .collect();
 
-                let c = conn.lock()?;
-                let mut stmt = c.statement(&qw).build()?;
+                    let c = conn.lock()?;
+                    let mut stmt = c.statement(&qw).build()?;
 
-                let rows = match stmt.statement_type() {
-                    oracle::StatementType::Select => {
-                        let result_rows = stmt.query_named(&params2)?;
-                        let rows: Vec<oracle::Row> =
-                            result_rows.into_iter().filter_map(Result::ok).collect_vec();
-                        rows
-                    }
-                    _ => {
-                        stmt.execute_named(&params2)?;
-                        c.commit()?;
-                        vec![]
-                    }
-                };
+                    match stmt.statement_type() {
+                        oracle::StatementType::Select => {
+                            let mut result_rows = stmt.query_named(&params2)?.enumerate();
+                            while let Some((i, row)) = result_rows.next() {
+                                match row {
+                                    Ok(row) => {
+                                        // If first row, infer column order and send it to the channel
+                                        if i == 0 {
+                                            let col_order: Vec<String> = row
+                                                .column_info()
+                                                .iter()
+                                                .map(|x| x.name().to_string())
+                                                .collect::<Vec<String>>();
+                                            let _ = column_order_oneshot_tx
+                                                .take()
+                                                .unwrap()
+                                                .send(Some(col_order));
+                                        }
 
-                oracle::Result::Ok(rows)
-            })
-            .await
-            .map_err(to_anyhow)?
-            .map_err(to_anyhow)?;
+                                        // called in a spawn_blocking synchronous context, unwrap won't panic
+                                        tx.blocking_send(Ok(convert_row_to_value(row))).unwrap()
+                                    }
+                                    Err(e) => {
+                                        tx.blocking_send(Err(e)).unwrap();
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        _ => {
+                            stmt.execute_named(&params2)?;
+                            c.commit()?;
+                        }
+                    };
+                    drop(column_order_oneshot_tx);
+                    Ok::<_, oracle::Error>(())
+                })();
+                match result {
+                    Ok(_) => {}
+                    Err(e) => tx.blocking_send(Err(e)).unwrap(),
+                }
+                // all instances of tx should be dropped here
+            });
 
-            if let Some(column_order) = column_order {
-                *column_order = Some(
-                    rows.first()
-                        .map(|x| {
-                            x.column_info()
-                                .iter()
-                                .map(|x| x.name().to_string())
-                                .collect::<Vec<String>>()
-                        })
-                        .unwrap_or_default(),
-                );
+            if let Ok(Some(col_order)) = column_order_oneshot_rx.await {
+                if let Some(column_order) = column_order {
+                    *column_order = Some(col_order);
+                }
             }
 
-            Ok(to_raw_value(
-                &rows
-                    .into_iter()
-                    .map(|x| convert_row_to_value(x))
-                    .collect::<Vec<serde_json::Value>>(),
-            ))
+            if let Some(s3) = s3 {
+                let stream = convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
+                s3.upload(stream.boxed()).await?;
+                return Ok(to_raw_value(&s3.to_return_s3_obj()));
+            } else {
+                let rows: Vec<_> = rows_stream.collect().await;
+                Ok(to_raw_value(
+                    &rows
+                        .into_iter()
+                        .collect::<Result<Vec<_>, _>>()
+                        .map_err(to_anyhow)?
+                        .into_iter()
+                        .collect::<Vec<serde_json::Value>>(),
+                ))
+            }
         }
     };
 
@@ -312,6 +353,7 @@ pub async fn do_oracledb(
     let job_args = build_args_values(job, client, conn).await?;
 
     let inline_db_res_path = parse_db_resource(&query);
+    let s3 = parse_s3_mode(&query)?.map(|s3| s3_mode_args_to_worker_data(s3, client.clone(), job));
 
     let db_arg = if let Some(inline_db_res_path) = inline_db_res_path {
         Some(
@@ -376,6 +418,7 @@ pub async fn do_oracledb(
                     conn_a.clone(),
                     None,
                     annotations.return_last_result && i < queries.len() - 1,
+                    s3.clone(),
                 )?
                 .await?;
                 res.push(r);
@@ -390,7 +433,14 @@ pub async fn do_oracledb(
 
         f.boxed()
     } else {
-        do_oracledb_inner(&query, statement_values, conn_a, Some(column_order), false)?
+        do_oracledb_inner(
+            &query,
+            statement_values,
+            conn_a,
+            Some(column_order),
+            false,
+            s3,
+        )?
     };
 
     let result = run_future_with_polling_update_job_poller(

backend/windmill-worker/src/pg_executor.rs

@@ -124,7 +124,7 @@ fn do_postgresql_inner<'a>(
             let stream = convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
             s3.upload(stream.boxed()).await?;
 
-            return Ok(serde_json::value::to_raw_value(&s3.object_key)?);
+            return Ok(to_raw_value(&s3.to_return_s3_obj()));
         } else {
             let rows = client
                 .query_raw(&query, query_params)

backend/windmill-worker/src/result_processor.rs

@@ -29,12 +29,13 @@ use windmill_common::{
 use windmill_common::bench::{BenchmarkInfo, BenchmarkIter};
 
 use windmill_queue::{
-    append_logs, get_queued_job, CanceledBy, JobCompleted, MiniPulledJob, WrappedError,
+    append_logs, get_queued_job,  CanceledBy, JobCompleted, MiniPulledJob,
+    WrappedError,
 };
 
 use serde_json::{json, value::RawValue};
 
-use tokio::{sync::broadcast, task::JoinHandle};
+use tokio::task::JoinHandle;
 
 use windmill_queue::{add_completed_job, add_completed_job_error};
 
@@ -43,7 +44,8 @@ use crate::{
     common::{error_to_value, read_result, save_in_cache},
     otel_ee::add_root_flow_job_to_otlp,
     worker_flow::update_flow_status_after_job_completion,
-    AuthedClient, JobCompletedSender, SameWorkerSender, SendResult, INIT_SCRIPT_TAG,
+    AuthedClient, JobCompletedReceiver, JobCompletedSender, SameWorkerSender, SendResult,
+    UpdateFlow, INIT_SCRIPT_TAG,
 };
 
 async fn process_jc(
@@ -118,7 +120,7 @@ async fn process_jc(
 }
 
 pub fn start_background_processor(
-    job_completed_rx: flume::Receiver<SendResult>,
+    job_completed_rx: JobCompletedReceiver,
     job_completed_sender: JobCompletedSender,
     same_worker_queue_size: Arc<AtomicU16>,
     job_completed_processor_is_done: Arc<AtomicBool>,
@@ -127,13 +129,14 @@ pub fn start_background_processor(
     worker_dir: String,
     same_worker_tx: SameWorkerSender,
     worker_name: String,
-    mut killpill_rx: broadcast::Receiver<()>,
     killpill_tx: KillpillSender,
     is_dedicated_worker: bool,
 ) -> JoinHandle<()> {
     tokio::spawn(async move {
         let mut has_been_killed = false;
 
+        let JobCompletedReceiver { bounded_rx, mut killpill_rx, unbounded_rx } = job_completed_rx;
+
         #[cfg(feature = "benchmark")]
         let mut infos = BenchmarkInfo::new();
 
@@ -144,15 +147,21 @@ pub fn start_background_processor(
         //if we have been killed, we want to drain the queue of jobs
         while let Some(sr) = {
             if has_been_killed && same_worker_queue_size.load(Ordering::SeqCst) == 0 {
-                job_completed_rx
+                unbounded_rx
                     .try_recv()
                     .ok()
                     .map(JobCompletedRx::JobCompleted)
+                    .or_else(|| bounded_rx.try_recv().ok().map(JobCompletedRx::JobCompleted))
             } else {
                 tokio::select! {
-                    result = job_completed_rx.recv_async() => {
+                    biased;
+                    result = unbounded_rx.recv_async() => {
                         result.ok().map(JobCompletedRx::JobCompleted)
                     }
+                    result = bounded_rx.recv_async() => {
+                        result.ok().map(JobCompletedRx::JobCompleted)
+                    }
+
                     _ = killpill_rx.recv() => {
                         Some(JobCompletedRx::Killpill)
                     }
@@ -207,7 +216,7 @@ pub fn start_background_processor(
                         infos.add_iter(bench, true);
                     }
                 }
-                JobCompletedRx::JobCompleted(SendResult::UpdateFlow {
+                JobCompletedRx::JobCompleted(SendResult::UpdateFlow(UpdateFlow {
                     flow,
                     w_id,
                     success,
@@ -215,7 +224,7 @@ pub fn start_background_processor(
                     worker_dir,
                     stop_early_override,
                     token,
-                }) => {
+                })) => {
                     // let r;
                     tracing::info!(parent_flow = %flow, "updating flow status");
                     if let Err(e) = update_flow_status_after_job_completion(
@@ -266,29 +275,11 @@ pub fn start_background_processor(
 
 async fn send_job_completed(
     job_completed_tx: JobCompletedSender,
-    job: Arc<MiniPulledJob>,
-    result: Arc<Box<RawValue>>,
-    result_columns: Option<Vec<String>>,
-    mem_peak: i32,
-    canceled_by: Option<CanceledBy>,
-    success: bool,
-    cached_res_path: Option<String>,
-    token: &str,
-    duration: Option<i64>,
+    jc: JobCompleted,
+
 ) {
-    let jc = JobCompleted {
-        job,
-        result,
-        result_columns,
-        mem_peak,
-        canceled_by,
-        success,
-        cached_res_path,
-        token: token.to_string(),
-        duration,
-    };
     job_completed_tx
-        .send_job(jc)
+        .send_job(jc, true)
         .with_context(windmill_common::otel_ee::otel_ctx())
         .await
         .expect("send job completed")
@@ -303,37 +294,28 @@ pub async fn process_result(
     canceled_by: Option<CanceledBy>,
     cached_res_path: Option<String>,
     token: &str,
-    column_order: Option<Vec<String>>,
-    new_args: Option<HashMap<String, Box<RawValue>>>,
+    result_columns: Option<Vec<String>>,
+    preprocessed_args: Option<HashMap<String, Box<RawValue>>>,
     conn: &Connection,
     duration: Option<i64>,
 ) -> error::Result<bool> {
     match result {
-        Ok(r) => {
-            // Update script args to preprocessed args
-            if let Connection::Sql(db) = conn {
-                if let Some(preprocessed_args) = new_args {
-                    sqlx::query!(
-                        "UPDATE v2_job SET args = $1, preprocessed = TRUE WHERE id = $2",
-                        Json(preprocessed_args) as Json<HashMap<String, Box<RawValue>>>,
-                        job.id
-                    )
-                    .execute(db)
-                    .await?;
-                }
-            }
+        Ok(result) => {
 
             send_job_completed(
                 job_completed_tx,
-                job,
-                r,
-                column_order,
-                mem_peak,
-                canceled_by,
-                true,
-                cached_res_path,
-                token,
-                duration,
+                JobCompleted {
+                    job,
+                    preprocessed_args,
+                    result,
+                    result_columns,
+                    mem_peak,
+                    canceled_by,
+                    success: true,
+                    cached_res_path,
+                    token: token.to_string(),
+                    duration,
+                },
             )
             .with_context(windmill_common::otel_ee::otel_ctx())
             .await;
@@ -384,15 +366,18 @@ pub async fn process_result(
 
             send_job_completed(
                 job_completed_tx,
-                job,
-                Arc::new(to_raw_value(&error_value)),
-                None,
-                mem_peak,
-                canceled_by,
-                false,
-                cached_res_path,
-                token,
-                duration,
+                JobCompleted {
+                    job,
+                    result: Arc::new(to_raw_value(&error_value)),
+                    result_columns: None,
+                    preprocessed_args: None,
+                    mem_peak,
+                    canceled_by,
+                    success: false,
+                    cached_res_path,
+                    token: token.to_string(),
+                    duration,
+                },
             )
             .with_context(windmill_common::otel_ee::otel_ctx())
             .await;
@@ -468,6 +453,7 @@ pub async fn process_completed_job(
         canceled_by,
         duration,
         result_columns,
+        preprocessed_args,
         ..
     }: JobCompleted,
     client: &AuthedClient,
@@ -492,6 +478,7 @@ pub async fn process_completed_job(
         if job.flow_step_id.as_deref() == Some("preprocessor") {
             // Do this before inserting to `v2_job_completed` for backwards compatibility
             // when we set `flow_status->_metadata->preprocessed_args` to true.
+
             sqlx::query!(
                 r#"UPDATE v2_job SET
                     args = '{"reason":"PREPROCESSOR_ARGS_ARE_DISCARDED"}'::jsonb,
@@ -506,6 +493,15 @@ pub async fn process_completed_job(
                     "error while deleting args of preprocessing step: {e:#}"
                 ))
             })?;
+        } else if let Some(preprocessed_args) = preprocessed_args {
+            // Update script args to preprocessed args
+            sqlx::query!(
+                "UPDATE v2_job SET args = $1, preprocessed = TRUE WHERE id = $2",
+                Json(preprocessed_args) as Json<HashMap<String, Box<RawValue>>>,
+                job.id
+            )
+            .execute(db)
+            .await?;
         }
 
         add_time!(bench, "pre add_completed_job");

backend/windmill-worker/src/snowflake_executor.rs

@@ -256,7 +256,7 @@ fn do_snowflake_inner<'a>(
                     rows_stream.map(|r| serde_json::value::to_value(&r?).map_err(to_anyhow));
                 let stream = convert_json_line_stream(rows_stream.boxed(), s3.format).await?;
                 s3.upload(stream.boxed()).await?;
-                Ok(to_raw_value(&s3.object_key))
+                Ok(to_raw_value(&s3.to_return_s3_obj()))
             } else {
                 let rows = rows_stream
                     .collect::<Vec<_>>()

backend/windmill-worker/src/worker.rs

@@ -527,7 +527,7 @@ impl AuthedClient {
         object_key: String,
         storage: Option<String>,
         body: S,
-    ) -> error::Result<Response>
+    ) -> error::Result<()>
     where
         S: futures::stream::TryStream + Send + 'static,
         S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
@@ -537,7 +537,8 @@ impl AuthedClient {
         if let Some(storage) = storage {
             query.push(("storage", storage));
         }
-        self.force_client
+        let response = self
+            .force_client
             .as_ref()
             .unwrap_or(&HTTP_CLIENT)
             .post(format!(
@@ -558,7 +559,12 @@ impl AuthedClient {
             .send()
             .await
             .context(format!("Sent upload_s3_file request",))
-            .map_err(error::Error::from)
+            .map_err(error::Error::from)?;
+
+        match response.status().as_u16() {
+            200u16 => Ok(()),
+            _ => Err(anyhow::anyhow!(response.text().await.unwrap_or_default()))?,
+        }
     }
 }
 
@@ -568,26 +574,44 @@ pub struct SameWorkerSender(pub Sender<SameWorkerPayload>, pub Arc<AtomicU16>);
 #[allow(dead_code)]
 #[derive(Clone)]
 pub enum JobCompletedSender {
-    Sql(flume::Sender<SendResult>, broadcast::Sender<()>),
+    Sql(SqlJobCompletedSender),
     Http(HttpClient),
     NeverUsed,
 }
 
+#[derive(Clone)]
+pub struct SqlJobCompletedSender {
+    sender: flume::Sender<SendResult>,
+    unbounded_sender: flume::Sender<SendResult>,
+    killpill_tx: broadcast::Sender<()>,
+}
+
+pub struct JobCompletedReceiver {
+    pub bounded_rx: flume::Receiver<SendResult>,
+    pub killpill_rx: broadcast::Receiver<()>,
+    pub unbounded_rx: flume::Receiver<SendResult>,
+}
+
+impl JobCompletedReceiver {
+    pub fn clone(&self) -> Self {
+        Self {
+            bounded_rx: self.bounded_rx.clone(),
+            killpill_rx: self.killpill_rx.resubscribe(),
+            unbounded_rx: self.unbounded_rx.clone(),
+        }
+    }
+}
+
 impl JobCompletedSender {
-    pub fn new(
-        conn: &Connection,
-        buffer_size: usize,
-    ) -> (
-        Self,
-        Option<(flume::Receiver<SendResult>, broadcast::Receiver<()>)>,
-    ) {
+    pub fn new(conn: &Connection, buffer_size: u8) -> (Self, Option<JobCompletedReceiver>) {
         match conn {
             Connection::Sql(_) => {
-                let (sender, receiver) = flume::bounded::<SendResult>(buffer_size);
-                let (killpill_tx, killpill_rx) = broadcast::channel::<()>(buffer_size);
+                let (sender, receiver) = flume::bounded::<SendResult>(buffer_size as usize);
+                let (unbounded_sender, unbounded_rx) = flume::unbounded::<SendResult>();
+                let (killpill_tx, killpill_rx) = broadcast::channel::<()>(10);
                 (
-                    Self::Sql(sender, killpill_tx),
-                    Some((receiver, killpill_rx)),
+                    Self::Sql(SqlJobCompletedSender { sender, unbounded_sender, killpill_tx }),
+                    Some(JobCompletedReceiver { bounded_rx: receiver, killpill_rx, unbounded_rx }),
                 )
             }
             Connection::Http(client) => (Self::Http(client.clone()), None),
@@ -597,14 +621,20 @@ impl JobCompletedSender {
         (Self::NeverUsed, None)
     }
 
-    pub async fn send_job(&self, jc: JobCompleted) -> anyhow::Result<()> {
+    pub async fn send_job(&self, jc: JobCompleted, wait_for_capacity: bool) -> anyhow::Result<()> {
         match self {
-            Self::Sql(sender, _) => sender
+            Self::Sql(SqlJobCompletedSender { sender, unbounded_sender, .. }) => {
+                if wait_for_capacity {
+                    sender
+                } else {
+                    unbounded_sender
+                }
                 .send_async(SendResult::JobCompleted(jc))
                 .await
                 .map_err(|_e| {
                     anyhow::anyhow!("Failed to send job completed to background processor")
-                }),
+                })
+            }
             Self::Http(client) => {
                 crate::agent_workers::send_result(client, jc).await?;
                 Ok(())
@@ -618,9 +648,19 @@ impl JobCompletedSender {
         }
     }
 
-    pub async fn send(&self, send_result: SendResult) -> Result<(), flume::SendError<SendResult>> {
+    pub async fn send(
+        &self,
+        send_result: SendResult,
+        wait_for_capacity: bool,
+    ) -> Result<(), flume::SendError<SendResult>> {
         match self {
-            Self::Sql(sender, _) => sender.send_async(send_result).await,
+            Self::Sql(SqlJobCompletedSender { sender, unbounded_sender, .. }) => {
+                if wait_for_capacity {
+                    sender.send_async(send_result).await
+                } else {
+                    unbounded_sender.send_async(send_result).await
+                }
+            }
             Self::Http(_) => {
                 tracing::error!("Sending job completed to http client, this should not happen");
                 Ok(())
@@ -636,7 +676,7 @@ impl JobCompletedSender {
 
     pub async fn kill(&self) -> Result<(), broadcast::error::SendError<()>> {
         match self {
-            Self::Sql(_, killpill_tx) => {
+            Self::Sql(SqlJobCompletedSender { killpill_tx, .. }) => {
                 tracing::info!("Sending killpill to bg processors");
                 killpill_tx.send(())?;
                 Ok(())
@@ -1057,7 +1097,7 @@ pub async fn run_worker(
 
     let (same_worker_tx, mut same_worker_rx) = mpsc::channel::<SameWorkerPayload>(5);
 
-    let (job_completed_tx, job_completed_rx) = JobCompletedSender::new(&conn, 3);
+    let (job_completed_tx, job_completed_rx) = JobCompletedSender::new(&conn, 10);
 
     let same_worker_queue_size = Arc::new(AtomicU16::new(0));
     let same_worker_tx = SameWorkerSender(same_worker_tx, same_worker_queue_size.clone());
@@ -1065,22 +1105,19 @@ pub async fn run_worker(
         Arc::new(AtomicBool::new(matches!(conn, Connection::Http(_))));
 
     let send_result = match (conn, job_completed_rx) {
-        (Connection::Sql(db), Some((job_completed_rx, bg_killpill_rx))) => {
-            Some(start_background_processor(
-                job_completed_rx,
-                job_completed_tx.clone(),
-                same_worker_queue_size.clone(),
-                job_completed_processor_is_done.clone(),
-                base_internal_url.to_string(),
-                db.clone(),
-                worker_dir.clone(),
-                same_worker_tx.clone(),
-                worker_name.clone(),
-                bg_killpill_rx,
-                killpill_tx.clone(),
-                is_dedicated_worker,
-            ))
-        }
+        (Connection::Sql(db), Some(job_completed_receiver)) => Some(start_background_processor(
+            job_completed_receiver,
+            job_completed_tx.clone(),
+            same_worker_queue_size.clone(),
+            job_completed_processor_is_done.clone(),
+            base_internal_url.to_string(),
+            db.clone(),
+            worker_dir.clone(),
+            same_worker_tx.clone(),
+            worker_name.clone(),
+            killpill_tx.clone(),
+            is_dedicated_worker,
+        )),
         _ => None,
     };
 
@@ -1482,17 +1519,21 @@ pub async fn run_worker(
                 if matches!(job.kind, JobKind::Noop) {
                     add_time!(bench, "send job completed START");
                     job_completed_tx
-                        .send_job(JobCompleted {
-                            job: Arc::new(job.job()),
-                            success: true,
-                            result: Arc::new(empty_result()),
-                            result_columns: None,
-                            mem_peak: 0,
-                            cached_res_path: None,
-                            token: "".to_string(),
-                            canceled_by: None,
-                            duration: None,
-                        })
+                        .send_job(
+                            JobCompleted {
+                                preprocessed_args: None,
+                                job: Arc::new(job.job()),
+                                success: true,
+                                result: Arc::new(empty_result()),
+                                result_columns: None,
+                                mem_peak: 0,
+                                cached_res_path: None,
+                                token: "".to_string(),
+                                canceled_by: None,
+                                duration: None,
+                            },
+                            true,
+                        )
                         .await
                         .expect("send job completed END");
                     add_time!(bench, "sent job completed");
@@ -1706,21 +1747,25 @@ pub async fn run_worker(
                                 }
                                 Connection::Http(_) => {
                                     job_completed_tx
-                                        .send_job(JobCompleted {
-                                            job: arc_job.clone(),
-                                            result: Arc::new(
-                                                windmill_common::worker::to_raw_value(
-                                                    &error_to_value(err),
+                                        .send_job(
+                                            JobCompleted {
+                                                preprocessed_args: None,
+                                                job: arc_job.clone(),
+                                                result: Arc::new(
+                                                    windmill_common::worker::to_raw_value(
+                                                        &error_to_value(err),
+                                                    ),
                                                 ),
-                                            ),
-                                            result_columns: None,
-                                            mem_peak: 0,
-                                            canceled_by: None,
-                                            success: false,
-                                            cached_res_path: None,
-                                            token: authed_client.token.clone(),
-                                            duration: None,
-                                        })
+                                                result_columns: None,
+                                                mem_peak: 0,
+                                                canceled_by: None,
+                                                success: false,
+                                                cached_res_path: None,
+                                                token: authed_client.token.clone(),
+                                                duration: None,
+                                            },
+                                            false,
+                                        )
                                         .await
                                         .expect("send job completed");
                                 }
@@ -1885,15 +1930,17 @@ async fn queue_init_bash_maybe<'c>(
 
 pub enum SendResult {
     JobCompleted(JobCompleted),
-    UpdateFlow {
-        flow: Uuid,
-        w_id: String,
-        success: bool,
-        result: Box<RawValue>,
-        worker_dir: String,
-        stop_early_override: Option<bool>,
-        token: String,
-    },
+    UpdateFlow(UpdateFlow),
+}
+
+pub struct UpdateFlow {
+    pub flow: Uuid,
+    pub w_id: String,
+    pub success: bool,
+    pub result: Box<RawValue>,
+    pub worker_dir: String,
+    pub stop_early_override: Option<bool>,
+    pub token: String,
 }
 
 async fn do_nativets(
@@ -2065,17 +2112,21 @@ async fn handle_queued_job(
                     append_logs(&job.id, &job.workspace_id, logs, conn).await;
                 }
                 job_completed_tx
-                    .send_job(JobCompleted {
-                        job,
-                        result,
-                        result_columns: None,
-                        mem_peak: 0,
-                        canceled_by: None,
-                        success: true,
-                        cached_res_path: None,
-                        token: client.token.clone(),
-                        duration: None,
-                    })
+                    .send_job(
+                        JobCompleted {
+                            preprocessed_args: None,
+                            job,
+                            result,
+                            result_columns: None,
+                            mem_peak: 0,
+                            canceled_by: None,
+                            success: true,
+                            cached_res_path: None,
+                            token: client.token.clone(),
+                            duration: None,
+                        },
+                        true,
+                    )
                     .await
                     .expect("send job completed");
 

backend/windmill-worker/src/worker_flow.rs

@@ -13,8 +13,10 @@ use std::time::Duration;
 
 use crate::common::{cached_result_path, save_in_cache};
 use crate::js_eval::{eval_timeout, IdContext};
+use crate::worker_utils::get_tag_and_concurrency;
 use crate::{
-    AuthedClient, JobCompletedSender, PreviousResult, SameWorkerSender, SendResult, KEEP_JOB_DIR,
+    AuthedClient, JobCompletedSender, PreviousResult, SameWorkerSender, SendResult, UpdateFlow,
+    KEEP_JOB_DIR,
 };
 use anyhow::Context;
 use futures::TryFutureExt;
@@ -58,8 +60,8 @@ use windmill_queue::flow_status::Step;
 use windmill_queue::schedule::get_schedule_opt;
 use windmill_queue::{
     add_completed_job, add_completed_job_error, append_logs, get_mini_pulled_job,
-    handle_maybe_scheduled_job, CanceledBy, MiniPulledJob, PushArgs, PushIsolationLevel,
-    SameWorkerPayload, WrappedError,
+    handle_maybe_scheduled_job, insert_concurrency_key, interpolate_args, CanceledBy,
+    MiniPulledJob, PushArgs, PushIsolationLevel, SameWorkerPayload, WrappedError,
 };
 
 type DB = sqlx::Pool<sqlx::Postgres>;
@@ -161,6 +163,10 @@ pub async fn update_flow_status_after_job_completion(
                 add_time!(bench, "update flow status internal END");
                 return Ok(None);
             }
+            UpdateFlowStatusAfterJobCompletion::PreprocessingStep => {
+                add_time!(bench, "update flow status preprocessing step END");
+                return Ok(None);
+            }
         }
     }
 }
@@ -170,6 +176,7 @@ pub enum UpdateFlowStatusAfterJobCompletion {
     Done(Arc<MiniPulledJob>),
     NotDone,
     NonLastParallelBranch,
+    PreprocessingStep,
 }
 pub struct RecUpdateFlowStatusAfterJobCompletion {
     flow: uuid::Uuid,
@@ -425,41 +432,6 @@ pub async fn update_flow_status_after_job_completion_internal(
             _ => false,
         };
 
-        if matches!(module_step, Step::PreprocessorStep) {
-            sqlx::query!(
-                "WITH job_result AS (
-                 SELECT result 
-                 FROM v2_job_completed 
-                 WHERE id = $1
-             )
-             UPDATE v2_job 
-             SET args = COALESCE(
-                     CASE 
-                         WHEN job_result.result IS NULL THEN NULL
-                         WHEN jsonb_typeof(job_result.result) = 'object' 
-                         THEN job_result.result
-                         WHEN jsonb_typeof(job_result.result) = 'null'
-                         THEN NULL
-                         ELSE jsonb_build_object('value', job_result.result)
-                     END, 
-                     '{}'::jsonb
-                 ),
-                 preprocessed = TRUE
-             FROM job_result
-             WHERE v2_job.id = $2;
-             ",
-                job_id_for_status,
-                flow
-            )
-            .execute(db)
-            .await
-            .map_err(|e| {
-                Error::internal_err(format!(
-                    "error while updating args in preprocessing step: {e:#}"
-                ))
-            })?;
-        }
-
         let mut tx = db.begin().await?;
 
         add_time!(bench, "process module status START");
@@ -1009,6 +981,128 @@ pub async fn update_flow_status_after_job_completion_internal(
             .ok_or_else(|| Error::internal_err(format!("requiring flow to be in the queue")))?;
         tx.commit().await?;
 
+        if matches!(module_step, Step::PreprocessorStep) {
+            let tag_and_concurrency_key = get_tag_and_concurrency(&flow, db).await;
+            let require_args = tag_and_concurrency_key.as_ref().is_some_and(|x| {
+                x.tag.as_ref().is_some_and(|t| t.contains("$args"))
+                    || x.concurrency_key
+                        .as_ref()
+                        .is_some_and(|ck| ck.contains("$args"))
+            });
+            let mut tag = tag_and_concurrency_key
+                .as_ref()
+                .map(|x| x.tag.clone())
+                .flatten();
+            let concurrency_key = tag_and_concurrency_key
+                .as_ref()
+                .map(|x| x.concurrency_key.clone())
+                .flatten();
+            let concurrent_limit = tag_and_concurrency_key
+                .as_ref()
+                .map(|x| x.concurrent_limit)
+                .flatten();
+            let concurrency_time_window_s = tag_and_concurrency_key
+                .as_ref()
+                .map(|x| x.concurrency_time_window_s)
+                .flatten();
+            if require_args {
+                let args = sqlx::query_scalar!(
+                    "SELECT result  as \"result: Json<HashMap<String, Box<RawValue>>>\"
+                 FROM v2_job_completed 
+                 WHERE id = $1",
+                    job_id_for_status
+                )
+                .fetch_one(db)
+                .await
+                .map_err(|e| {
+                    Error::internal_err(format!("error while fetching preprocessing args: {e:#}"))
+                })?;
+                let args_hm = args.unwrap_or_default().0;
+                let args = PushArgs::from(&args_hm);
+                if let Some(ck) = concurrency_key {
+                    let mut tx = db.begin().await?;
+                    insert_concurrency_key(
+                        &flow_job.workspace_id,
+                        &args,
+                        &flow_job.runnable_path,
+                        JobKind::Flow,
+                        Some(ck),
+                        &mut tx,
+                        flow,
+                    )
+                    .await?;
+                    tx.commit().await?;
+                }
+                if let Some(t) = tag {
+                    tag = Some(interpolate_args(t, &args, &flow_job.workspace_id));
+                }
+            } else if let Some(ck) = concurrency_key {
+                let mut tx = db.begin().await?;
+                insert_concurrency_key(
+                    &flow_job.workspace_id,
+                    &PushArgs::from(&HashMap::new()),
+                    &flow_job.runnable_path,
+                    JobKind::Flow,
+                    Some(ck),
+                    &mut tx,
+                    flow,
+                )
+                .await?;
+                tx.commit().await?;
+            }
+
+            // let tag = tag_and_concurrency_key.and_then(|tc| tc.tag.map(|t| interpolate_args(t.clone(), &args, &workspace_id)));
+            // let concurrency_key = tag_and_concurrency_key.and_then(|tc| tc.concurrency_key.map(|ck| interpolate_args(&ck, &args, &workspace_id)));
+            sqlx::query!(
+                "WITH job_result AS (
+                 SELECT result 
+                 FROM v2_job_completed 
+                 WHERE id = $1
+             ),
+             updated_queue AS (
+                UPDATE v2_job_queue
+                SET running = false,
+                tag = COALESCE($3, tag)
+                WHERE id = $2
+             )
+             UPDATE v2_job 
+             SET 
+                tag = COALESCE($3, tag),
+                concurrent_limit = COALESCE($4, concurrent_limit),
+                concurrency_time_window_s = COALESCE($5, concurrency_time_window_s),
+                args = COALESCE(
+                     CASE 
+                         WHEN job_result.result IS NULL THEN NULL
+                         WHEN jsonb_typeof(job_result.result) = 'object' 
+                         THEN job_result.result
+                         WHEN jsonb_typeof(job_result.result) = 'null'
+                         THEN NULL
+                         ELSE jsonb_build_object('value', job_result.result)
+                     END, 
+                     '{}'::jsonb
+                 ),
+                 preprocessed = TRUE
+             FROM job_result
+             WHERE v2_job.id = $2;
+             ",
+                job_id_for_status,
+                flow,
+                tag,
+                concurrent_limit,
+                concurrency_time_window_s,
+            )
+            .execute(db)
+            .await
+            .map_err(|e| {
+                Error::internal_err(format!(
+                    "error while updating args in preprocessing step: {e:#}"
+                ))
+            })?;
+            if success {
+                return Ok(UpdateFlowStatusAfterJobCompletion::PreprocessingStep);
+            }
+        }
+
         let job_root = flow_job
             .flow_innermost_root_job
             .map(|x| x.to_string())
@@ -1539,22 +1633,47 @@ pub async fn handle_flow(
             );
         }
     }
-    let mut rec = Some(PushNextFlowJobRec { flow_job: flow_job, status: status });
-    while let Some(nrec) = rec {
-        rec = push_next_flow_job(
-            nrec.flow_job,
-            nrec.status,
+    let mut rec = PushNextFlowJobRec { flow_job: flow_job, status: status };
+    loop {
+        let PushNextFlowJobRec { flow_job, status } = rec;
+        let next = push_next_flow_job(
+            flow_job,
+            status,
             flow,
             db,
             client,
             last_result.clone(),
             same_worker_tx.clone(),
             worker_dir,
-            job_completed_tx.clone(),
             worker_name,
         )
         .warn_after_seconds(10)
         .await?;
+        match next {
+            PushNextFlowJob::Rec(nrec) => {
+                tracing::info!("recursively pushing next flow job {}", nrec.flow_job.id);
+                rec = nrec;
+            }
+            PushNextFlowJob::Done(update_flow) => {
+                if let Some(update_flow) = update_flow {
+                    tracing::info!(
+                        "sending flow status update {} with success {} to job completed channel",
+                        update_flow.flow,
+                        update_flow.success
+                    );
+                    job_completed_tx
+                        .send(SendResult::UpdateFlow(update_flow), false)
+                        .warn_after_seconds(3)
+                        .await
+                        .map_err(|e| {
+                            Error::internal_err(format!(
+                                "error sending update flow message to job completed channel: {e:#}"
+                            ))
+                        })?;
+                }
+                break;
+            }
+        }
     }
 
     Ok(())
@@ -1600,6 +1719,10 @@ lazy_static::lazy_static! {
     pub static ref EHM: HashMap<String, Box<RawValue>> = HashMap::new();
 }
 
+enum PushNextFlowJob {
+    Rec(PushNextFlowJobRec),
+    Done(Option<UpdateFlow>),
+}
 struct PushNextFlowJobRec {
     flow_job: Arc<MiniPulledJob>,
     status: FlowStatus,
@@ -1615,9 +1738,8 @@ async fn push_next_flow_job(
     last_job_result: Option<Arc<Box<RawValue>>>,
     same_worker_tx: SameWorkerSender,
     worker_dir: &str,
-    job_completed_tx: JobCompletedSender,
     worker_name: &str,
-) -> error::Result<Option<PushNextFlowJobRec>> {
+) -> error::Result<PushNextFlowJob> {
     let job_root = flow_job
         .flow_innermost_root_job
         .map(|x| x.to_string())
@@ -1650,30 +1772,20 @@ async fn push_next_flow_job(
 
     // if this is an empty module of if the module has already been completed, successfully, update the parent flow
     if flow.modules.is_empty() || matches!(status_module, FlowStatusModule::Success { .. }) {
-        job_completed_tx
-            .send(SendResult::UpdateFlow {
-                flow: flow_job.id,
-                success: true,
-                result: if flow.modules.is_empty() {
-                    to_raw_value(arc_flow_job_args.as_ref())
-                } else {
-                    // it has to be an empty for loop event
-                    serde_json::from_str("[]").unwrap()
-                },
-                stop_early_override: None,
-                w_id: flow_job.workspace_id.clone(),
-                worker_dir: worker_dir.to_string(),
-                token: client.token.clone(),
-            })
-            .warn_after_seconds(3)
-            .await
-            .map_err(|e| {
-                Error::internal_err(format!(
-                    "error sending update flow message to job completed channel: {e:#}"
-                ))
-            })?;
-
-        return Ok(None);
+        return Ok(PushNextFlowJob::Done(Some(UpdateFlow {
+            flow: flow_job.id,
+            success: true,
+            result: if flow.modules.is_empty() {
+                to_raw_value(arc_flow_job_args.as_ref())
+            } else {
+                // it has to be an empty for loop event
+                serde_json::from_str("[]").unwrap()
+            },
+            stop_early_override: None,
+            w_id: flow_job.workspace_id.clone(),
+            worker_dir: worker_dir.to_string(),
+            token: client.token.clone(),
+        })));
     }
 
     if matches!(step, Step::Step(0)) {
@@ -1714,28 +1826,21 @@ async fn push_next_flow_job(
                         .map(|x| x.to_string())
                         .collect::<Vec<String>>()
                         .join(", ");
-                    job_completed_tx
-                         .send(SendResult::UpdateFlow {
-                             flow: flow_job.id,
-                             success: true,
-                             result: serde_json::from_str(
-                                 &format!("\"not allowed to overlap with {overlapping_str}, scheduling next iteration\""),
-                             )
-                             .unwrap(),
-                             stop_early_override: Some(true),
-                             w_id: flow_job.workspace_id.clone(),
-                             worker_dir: worker_dir.to_string(),
-                             token: client.token.clone(),
-                         })
-                         .warn_after_seconds(3)
-                         .await
-                         .map_err(|e| {
-                             Error::internal_err(format!(
-                                 "error sending update flow message to job completed channel: {e:#}"
-                             ))
-                         })?;
 
-                    return Ok(None);
+                    return Ok(PushNextFlowJob::Done(Some(
+                        UpdateFlow {
+                            flow: flow_job.id,
+                            success: true,
+                            result: serde_json::from_str(
+                                &format!("\"not allowed to overlap with {overlapping_str}, scheduling next iteration\""),
+                            )
+                            .unwrap(),
+                            stop_early_override: Some(true),
+                            w_id: flow_job.workspace_id.clone(),
+                            worker_dir: worker_dir.to_string(),
+                            token: client.token.clone(),
+                        }
+                    )));
                 }
             }
         }
@@ -1756,25 +1861,15 @@ async fn push_next_flow_job(
             .warn_after_seconds(3)
             .await?;
             if skip {
-                job_completed_tx
-                    .send(SendResult::UpdateFlow {
-                        flow: flow_job.id,
-                        success: true,
-                        result: serde_json::from_str("\"stopped early\"").unwrap(),
-                        stop_early_override: Some(true),
-                        w_id: flow_job.workspace_id.clone(),
-                        worker_dir: worker_dir.to_string(),
-                        token: client.token.clone(),
-                    })
-                    .warn_after_seconds(3)
-                    .await
-                    .map_err(|e| {
-                        Error::internal_err(format!(
-                            "error sending update flow message to job completed channel: {e:#}"
-                        ))
-                    })?;
-
-                return Ok(None);
+                return Ok(PushNextFlowJob::Done(Some(UpdateFlow {
+                    flow: flow_job.id,
+                    success: true,
+                    result: serde_json::from_str("\"stopped early\"").unwrap(),
+                    stop_early_override: Some(true),
+                    w_id: flow_job.workspace_id.clone(),
+                    worker_dir: worker_dir.to_string(),
+                    token: client.token.clone(),
+                })));
             }
         }
     }
@@ -2032,7 +2127,7 @@ async fn push_next_flow_job(
                 .await?;
 
                 tx.commit().warn_after_seconds(3).await?;
-                return Ok(None);
+                return Ok(PushNextFlowJob::Done(None));
 
             /* cancelled or we're WaitingForEvents but we don't have enough messages (timed out) */
             } else {
@@ -2080,25 +2175,15 @@ async fn push_next_flow_job(
                 .warn_after_seconds(3)
                 .await;
 
-                job_completed_tx
-                    .send(SendResult::UpdateFlow {
-                        flow: flow_job.id,
-                        success: false,
-                        result: to_raw_value(&result),
-                        stop_early_override: None,
-                        w_id: flow_job.workspace_id.clone(),
-                        worker_dir: worker_dir.to_string(),
-                        token: client.token.clone(),
-                    })
-                    .warn_after_seconds(3)
-                    .await
-                    .map_err(|e| {
-                        Error::internal_err(format!(
-                            "error sending update flow message to job completed channel: {e:#}"
-                        ))
-                    })?;
-
-                return Ok(None);
+                return Ok(PushNextFlowJob::Done(Some(UpdateFlow {
+                    flow: flow_job.id,
+                    success: false,
+                    result: to_raw_value(&result),
+                    stop_early_override: None,
+                    w_id: flow_job.workspace_id.clone(),
+                    worker_dir: worker_dir.to_string(),
+                    token: client.token.clone(),
+                })));
             }
         }
     }
@@ -2437,13 +2522,13 @@ async fn push_next_flow_job(
 
             if let Some(status) = status {
                 // // flow is reprocessed by the worker in a state where the module has completed successfully.
-                return Ok(Some(PushNextFlowJobRec {
+                return Ok(PushNextFlowJob::Rec(PushNextFlowJobRec {
                     flow_job: flow_job,
                     status: status,
                 }));
             } else {
                 return Err(Error::BadRequest(
-                    "impossible to parse new flow status after applying innr flows".to_string(),
+                    "impossible to parse new flow status after applying inner flows".to_string(),
                 ));
             }
         }
@@ -2657,8 +2742,8 @@ async fn push_next_flow_job(
         };
 
         tracing::debug!(id = %flow_job.id, root_id = %job_root, "computed perms for job {i} of {len}");
-        let tag = if flow_job.tag == "flow"
-            || flow_job.tag == format!("flow-{}", flow_job.workspace_id)
+        let tag = if !matches!(step, Step::PreprocessorStep)
+            && (flow_job.tag == "flow" || flow_job.tag == format!("flow-{}", flow_job.workspace_id))
         {
             payload_tag.tag.clone()
         } else {
@@ -2956,7 +3041,7 @@ async fn push_next_flow_job(
             .await
             .map_err(to_anyhow)?;
     }
-    return Ok(None);
+    return Ok(PushNextFlowJob::Done(None));
 }
 
 // async fn jump_to_next_step(

backend/windmill-worker/src/worker_utils.rs

@@ -3,13 +3,14 @@ use tracing::Instrument;
 use uuid::Uuid;
 use windmill_common::{
     agent_workers::{PingJobStatus, PingJobStatusResponse},
+    cache,
     worker::{
         get_memory, get_vcpus, get_windmill_memory_usage, get_worker_memory_usage,
         insert_ping_query, update_job_ping_query, update_worker_ping_from_job_query,
         update_worker_ping_main_loop_query, Connection, Ping, PingType, WORKER_CONFIG,
         WORKER_GROUP,
     },
-    KillpillSender,
+    KillpillSender, DB,
 };
 
 use crate::{
@@ -320,3 +321,71 @@ pub(crate) async fn queue_vacuum(conn: &Connection, worker_name: &str, hostname:
         }
     }
 }
+
+#[derive(Debug, Clone, sqlx::FromRow)]
+pub struct TagAndConcurrencyKey {
+    pub tag: Option<String>,
+    pub concurrency_key: Option<String>,
+    pub concurrent_limit: Option<i32>,
+    pub concurrency_time_window_s: Option<i32>,
+    pub version: Option<i64>,
+}
+
+pub async fn get_tag_and_concurrency(job_id: &Uuid, db: &DB) -> Option<TagAndConcurrencyKey> {
+    let r = sqlx::query_as!(
+        TagAndConcurrencyKey,
+        "
+        WITH j AS (
+            SELECT 
+                raw_flow->>'concurrency_key' as concurrency_key, 
+                raw_flow->>'concurrency_time_window_s' as concurrency_time_window_s,
+                raw_flow->>'concurrency_limit' as concurrent_limit,
+                runnable_path, 
+                runnable_id as version FROM v2_job
+            WHERE id = $1
+        )
+        SELECT tag, j.concurrency_key, j.concurrency_time_window_s::int, j.concurrent_limit::int, j.version
+            FROM flow, j
+            WHERE path = j.runnable_path
+        ",
+        job_id
+    )
+    .fetch_optional(db)
+    .await
+    .ok()
+    .flatten();
+    if let Some(tag_and_concurrency_key) = r {
+        if tag_and_concurrency_key.concurrency_key.as_ref().is_some()
+            || tag_and_concurrency_key.version.as_ref().is_none()
+        {
+            return Some(tag_and_concurrency_key);
+        } else {
+            let version = tag_and_concurrency_key.version.unwrap();
+
+            let r = cache::flow::fetch_version_lite(db, version).await;
+            let flow = match r {
+                Ok(data) => Ok(data),
+                Err(_) => cache::flow::fetch_version(db, version).await,
+            };
+            let flow_value = flow.map(|f| f.value().clone()).ok();
+            let concurrency_key = flow_value
+                .as_ref()
+                .map(|fv| fv.concurrency_key.clone())
+                .flatten();
+            let concurrent_limit = flow_value.as_ref().map(|fv| fv.concurrent_limit).flatten();
+            let concurrent_time_window_s = flow_value
+                .as_ref()
+                .map(|fv| fv.concurrency_time_window_s)
+                .flatten();
+            Some(TagAndConcurrencyKey {
+                tag: tag_and_concurrency_key.tag,
+                concurrency_key,
+                concurrent_limit,
+                concurrency_time_window_s: concurrent_time_window_s,
+                version: None,
+            })
+        }
+    } else {
+        None
+    }
+}

benchmarks/lib.ts

@@ -2,7 +2,7 @@ import { sleep } from "https://deno.land/x/sleep@v1.2.1/mod.ts";
 import * as windmill from "https://deno.land/x/windmill@v1.174.0/mod.ts";
 import * as api from "https://deno.land/x/windmill@v1.174.0/windmill-api/index.ts";
 
-export const VERSION = "v1.491.0";
+export const VERSION = "v1.491.5";
 
 export async function login(email: string, password: string): Promise<string> {
   return await windmill.UserService.login({

cli/main.ts

@@ -63,7 +63,7 @@ export {
 //   }
 // });
 
-export const VERSION = "1.491.0";
+export const VERSION = "1.491.5";
 
 const command = new Command()
   .name("wmill")
@@ -94,6 +94,7 @@ const command = new Command()
     "Specify headers to use for all requests. e.g: \"HEADERS='h1: v1, h2: v2'\""
   )
   .version(VERSION)
+  .versionOption(false)
   .command("init", "Bootstrap a windmill project with a wmill.yaml file")
   .action(async () => {
     if (await Deno.stat("wmill.yaml").catch(() => null)) {
@@ -134,15 +135,34 @@ const command = new Command()
   .command("worker-groups", workerGroups)
   .command("workers", workers)
   .command("queues", queues)
-  .command("version", "Show version information")
+  .command("version --version", "Show version information")
   .action(async (opts) => {
-    console.log("CLI build against " + VERSION);
+    console.log("CLI version: " + VERSION);
+    try {
+      const provider = new NpmProvider({ package: "windmill-cli" });
+      const versions = await provider.getVersions("windmill-cli");
+      if (versions.latest !== VERSION) {
+        console.log(
+          `CLI is outdated. Latest version ${versions.latest} is available. Run \`wmill upgrade\` to update.`
+        );
+      } else {
+        console.log("CLI is up to date");
+      }
+    } catch (e) {
+      console.warn(
+        `Cannot fetch latest CLI version on npmjs to check if up-to-date: ${e}`
+      );
+    }
     const workspace = await getActiveWorkspace(opts as GlobalOptions);
     if (workspace) {
-      const backendVersion = await fetchVersion(workspace.remote);
-      console.log("Backend Version: " + backendVersion);
+      try {
+        const backendVersion = await fetchVersion(workspace.remote);
+        console.log("Backend Version: " + backendVersion);
+      } catch (e) {
+        console.warn("Cannot fetch backend version: " + e);
+      }
     } else {
-      console.log(
+      console.warn(
         "Cannot fetch backend version: no active workspace selected, choose one to pick a remote to fetch version of"
       );
     }

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "windmill-components",
-	"version": "1.491.0",
+	"version": "1.491.5",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "windmill-components",
-			"version": "1.491.0",
+			"version": "1.491.5",
 			"hasInstallScript": true,
 			"license": "AGPL-3.0",
 			"dependencies": {

frontend/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.491.0",
+	"version": "1.491.5",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",

frontend/src/lib/components/LogViewer.svelte

@@ -69,7 +69,7 @@
 			? truncateContent.substring(
 					s3LogPrefixes[prefixIndex]?.length,
 					end == -1 ? undefined : end + 1
-			  )
+				)
 			: undefined
 	}
 
@@ -109,7 +109,7 @@
 			? truncatedContent.substring(
 					truncatedContent.substring(1).indexOf('\n') + 2,
 					truncatedContent.length
-			  )
+				)
 			: truncatedContent
 	)
 	export function scrollToBottom() {

frontend/src/lib/components/QueueMetricsDrawer.svelte

@@ -2,7 +2,7 @@
 	import { onMount } from 'svelte'
 	import { Drawer, DrawerContent, Button } from './common'
 	import QueueMetricsDrawerInner from './QueueMetricsDrawerInner.svelte'
-	import { ConfigService } from '$lib/gen'
+	import { ConfigService, type Alert } from '$lib/gen'
 	import Section from './Section.svelte'
 	import { sendUserToast } from '$lib/toast'
 	import { Pencil, Trash, Check, PlusCircle, SaveIcon } from 'lucide-svelte'
@@ -21,14 +21,6 @@
 		}
 	}
 
-	type Alert = {
-		name: string
-		tags_to_monitor: string[]
-		jobs_num_threshold: number
-		alert_cooldown_seconds: number
-		alert_time_threshold_seconds: number
-	}
-
 	let drawer: Drawer
 	export function openDrawer() {
 		drawer?.openDrawer()
@@ -55,8 +47,8 @@
 
 	async function fetchConfig() {
 		try {
-			const response = (await ConfigService.getConfig({ name: configName })) as { alerts: Alert[] }
-			alerts = response.alerts || []
+			const response = await ConfigService.getConfig({ name: configName })
+			alerts = response?.alerts || []
 			originalAlerts = JSON.parse(JSON.stringify(alerts))
 		} catch (error) {
 			console.error('Failed to fetch config:', error)
@@ -298,7 +290,9 @@
 														<input
 															type="text"
 															bind:value={newTag}
-															placeholder="{workerTags.length === alert.tags_to_monitor.length ? 'All tags already added' : 'Add tag from dropdown' }"
+															placeholder={workerTags.length === alert.tags_to_monitor.length
+																? 'All tags already added'
+																: 'Add tag from dropdown'}
 															on:input={(e) => filterTags(e)}
 															disabled={workerTags.length === alert.tags_to_monitor.length}
 															class="p-1 flex-grow mr-1"
@@ -321,15 +315,15 @@
 														>
 															{#each filteredTags as tag}
 																{#if !alert.tags_to_monitor.includes(tag)}
-																<li>
-																	<button
-																		type="button"
-																		class="w-full text-left p-2 cursor-pointer hover:bg-slate-200 dark:hover:bg-slate-700"
-																		on:click={() => addTag(index, tag)}
-																	>
-																		{tag}
-																	</button>
-																</li>
+																	<li>
+																		<button
+																			type="button"
+																			class="w-full text-left p-2 cursor-pointer hover:bg-slate-200 dark:hover:bg-slate-700"
+																			on:click={() => addTag(index, tag)}
+																		>
+																			{tag}
+																		</button>
+																	</li>
 																{/if}
 															{/each}
 														</ul>

frontend/src/lib/components/S3FilePicker.svelte

@@ -41,9 +41,9 @@
 	export let fromWorkspaceSettings: boolean = false
 	export let readOnlyMode: boolean
 
-	export let initialFileKey: { s3: string } | undefined = undefined
-	let initialFileKeyInternalCopy: { s3: string }
-	export let selectedFileKey: { s3: string } | undefined = undefined
+	export let initialFileKey: { s3: string; storage?: string } | undefined = undefined
+	let initialFileKeyInternalCopy: { s3: string; storage?: string }
+	export let selectedFileKey: { s3: string; storage?: string } | undefined = undefined
 	export let folderOnly = false
 	export let regexFilter: RegExp | undefined = undefined
 
@@ -298,7 +298,7 @@
 			deletionModalOpen = false
 		}
 		sendUserToast(`${fileKey} deleted from S3 bucket`)
-		selectedFileKey = { s3: '' }
+		selectedFileKey = { s3: '', storage }
 		const currentPage = page
 		await clearAndLoadFiles()
 		for (let i = 0; i < currentPage; i++) {
@@ -359,7 +359,7 @@
 			moveModalOpen = false
 		}
 		sendUserToast(`${srcFileKey} moved to ${destFileKey}`)
-		selectedFileKey = { s3: destFileKey! }
+		selectedFileKey = { s3: destFileKey!, storage }
 		await clearAndLoadFiles()
 		await loadFileMetadataPlusPreviewAsync(selectedFileKey.s3)
 	}
@@ -397,7 +397,7 @@
 		await clearAndLoadFiles()
 		if (selectedFileKey !== undefined) {
 			if (allFilesByKey[selectedFileKey.s3] === undefined) {
-				selectedFileKey = { s3: '' }
+				selectedFileKey = { s3: '', storage }
 			} else {
 				loadFileMetadataPlusPreviewAsync(selectedFileKey.s3)
 			}
@@ -421,7 +421,8 @@
 		if (item.type === 'folder') {
 			if (folderOnly) {
 				selectedFileKey = {
-					s3: item_key
+					s3: item_key,
+					storage
 				}
 			}
 			if (toggleCollapsed) {
@@ -456,7 +457,8 @@
 			displayedFileKeys = displayedFileKeys.sort()
 		} else {
 			selectedFileKey = {
-				s3: item_key
+				s3: item_key,
+				storage
 			}
 			loadFileMetadataPlusPreviewAsync(selectedFileKey.s3)
 		}
@@ -841,7 +843,7 @@
 	on:close={async (evt) => {
 		uploadModalOpen = false
 		if (evt.detail !== undefined && evt.detail !== null) {
-			selectedFileKey = { s3: evt.detail }
+			selectedFileKey = { s3: evt.detail, storage }
 			await clearAndLoadFiles()
 			loadFileMetadataPlusPreviewAsync(evt.detail)
 		}

frontend/src/lib/components/apps/components/layout/AppTabs.svelte

@@ -199,24 +199,22 @@
 							<span class="mr-2 w-8 font-mono">{selected == res ? '-' : '+'}</span>
 							{res}
 						</button>
-						{#if selected == res}
-							<div class="border-t">
-								<SubGridEditor
-									{id}
-									visible={render && index === selectedIndex}
-									subGridId={`${id}-${index}`}
-									class={twMerge(css?.container?.class, 'wm-tabs-container')}
-									style={css?.container?.style}
-									containerHeight={componentContainerHeight - (titleBarHeight * tabs.length + 40)}
-									on:focus={() => {
-										if (!$connectingInput.opened) {
-											$selectedComponent = [id]
-											handleTabSelection()
-										}
-									}}
-								/>
-							</div>
-						{/if}
+						<div class={selected == res ? 'border-t' : ''}>
+							<SubGridEditor
+								{id}
+								visible={render && index === selectedIndex}
+								subGridId={`${id}-${index}`}
+								class={twMerge(css?.container?.class, 'wm-tabs-container')}
+								style={css?.container?.style}
+								containerHeight={componentContainerHeight - (titleBarHeight * tabs.length + 40)}
+								on:focus={() => {
+									if (!$connectingInput.opened) {
+										$selectedComponent = [id]
+										handleTabSelection()
+									}
+								}}
+							/>
+						</div>
 					</div>
 				{/each}
 			</div>

frontend/src/lib/components/search/GlobalSearchModal.svelte

@@ -262,6 +262,7 @@
 	}
 
 	let selectedItem: any
+
 	async function handleKeydown(event: KeyboardEvent) {
 		if ((!isMac() ? event.ctrlKey : event.metaKey) && event.key === 'k') {
 			event.preventDefault()
@@ -641,11 +642,11 @@
 								<div class="w-4/12 overflow-y-auto max-h-[70vh]">
 									{#each itemMap['runs'] ?? [] as r}
 										<QuickMenuItem
-											on:hover={() => {
+											on:select={() => {
 												selectedItem = r
 												selectedWorkspace = r?.document.workspace_id[0]
 											}}
-											on:select={() => {
+											on:keyboardOnlySelect={() => {
 												open = false
 												goto(`/run/${r?.document.id[0]}`)
 											}}
@@ -657,10 +658,7 @@
 										>
 											<svelte:fragment slot="itemReplacement">
 												<div
-													class={twMerge(
-														`w-full flex flex-row items-center gap-4 transition-all`,
-														r?.document.id === selectedItem?.document?.id ? 'bg-surface-hover' : ''
-													)}
+													class="w-full flex flex-row items-center gap-4 transition-all"
 												>
 													<div
 														class="rounded-full w-2 h-2 {r?.document.success[0]

frontend/src/lib/components/search/QuickMenuItem.svelte

@@ -24,6 +24,7 @@
 	async function handleKeydown(event: KeyboardEvent) {
 		if (hovered && event.key === 'Enter') {
 			event.preventDefault()
+			dispatch('keyboardOnlySelect')
 			runAction()
 		}
 	}

frontend/src/lib/components/triggers/gcp/GcpTriggerEditorInner.svelte

@@ -263,7 +263,7 @@
 								btnClasses="ml-4 mt-2"
 								color="dark"
 								size="xs"
-								href={itemKind === 'flow' ? '/flows/add?hub=68' : '/scripts/add?hub=hub%2F11446'}
+								href={itemKind === 'flow' ? '/flows/add?hub=68' : '/scripts/add?hub=hub%2F19662'}
 								target="_blank">Create from template</Button
 							>
 						{/if}

frontend/src/lib/components/triggers/http/RouteEditorInner.svelte

@@ -268,6 +268,7 @@
 		bind:selectedFileKey={static_asset_config}
 		on:close={() => {
 			s3Editor?.setCode(JSON.stringify(static_asset_config, null, 2))
+			s3FileUploadRawMode = true
 		}}
 		readOnlyMode={false}
 	/>
@@ -366,6 +367,7 @@
 										disabled={!can_write}
 									/>
 								{/if}
+								{s3FileUploadRawMode}
 								{#if s3FileUploadRawMode}
 									{#if can_write}
 										<JsonEditor
@@ -396,7 +398,6 @@
 													s3: evt.detail?.path ?? '',
 													filename: evt.detail?.filename ?? undefined
 												}
-												s3FileUploadRawMode = true
 											}}
 											on:deletion={(evt) => {
 												static_asset_config = {
@@ -447,7 +448,7 @@
 										size="xs"
 										href={itemKind === 'flow'
 											? '/flows/add?hub=62'
-											: '/scripts/add?hub=hub%2F11627'}
+											: '/scripts/add?hub=hub%2F19669'}
 										target="_blank">Create from template</Button
 									>
 								{/if}
@@ -622,7 +623,9 @@
 								{/if}
 							{/if}
 
-							<RouteBodyTransformerOption bind:raw_string bind:wrap_body />
+							{#if !static_asset_config}
+								<RouteBodyTransformerOption bind:raw_string bind:wrap_body />
+							{/if}
 						</div>
 					</Section>
 				{/if}

frontend/src/lib/components/triggers/http/utils.ts

@@ -2,7 +2,7 @@ import { base } from '$lib/base'
 import { isCloudHosted } from '$lib/cloud'
 
 export const SECRET_KEY_PATH = 'secret_key_path'
-export const HUB_SCRIPT_ID = 19661
+export const HUB_SCRIPT_ID = 19670
 export const SIGNATURE_TEMPLATE_SCRIPT_HUB_PATH: string = `hub/${HUB_SCRIPT_ID}`
 export const SIGNATURE_TEMPLATE_FLOW_HUB_ID = '67'
 

frontend/src/lib/script_helpers.ts

@@ -249,6 +249,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
@@ -259,6 +260,7 @@ 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)
@@ -267,6 +269,7 @@ 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[])
@@ -276,6 +279,7 @@ 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)
@@ -284,6 +288,7 @@ 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 (?, ?);
@@ -294,6 +299,7 @@ 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)
@@ -654,86 +660,94 @@ export const TS_PREPROCESSOR_FLOW_INTRO = `/**
 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: "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: "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: "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: "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: "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: "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: "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: "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
@@ -892,6 +906,16 @@ class GcpEvent(TypedDict):
     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,
@@ -902,6 +926,7 @@ Event = Union[
     SqsEvent,
     MqttEvent,
     GcpEvent,
+    PostgresEvent,
 ]
 
 

lsp/Pipfile

@@ -4,8 +4,8 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
-wmill = ">=1.491.0"
-wmill_pg = ">=1.491.0"
+wmill = ">=1.491.5"
+wmill_pg = ">=1.491.5"
 sendgrid = "*"
 mysql-connector-python = "*"
 pymongo = "*"

openflow.openapi.yaml

@@ -1,7 +1,7 @@
 openapi: "3.0.3"
 
 info:
-  version: 1.491.0
+  version: 1.491.5
   title: OpenFlow Spec
   contact:
     name: Ruben Fiszel

powershell-client/WindmillClient/WindmillClient.psd1

@@ -12,7 +12,7 @@
     RootModule        = 'WindmillClient.psm1'
 
     # Version number of this module.
-    ModuleVersion     = '1.491.0'
+    ModuleVersion     = '1.491.5'
 
     # Supported PSEditions
     # CompatiblePSEditions = @()

python-client/wmill/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wmill"
-version = "1.491.0"
+version = "1.491.5"
 description = "A client library for accessing Windmill server wrapping the Windmill client API"
 license = "Apache-2.0"
 homepage = "https://windmill.dev"

python-client/wmill_pg/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wmill-pg"
-version = "1.491.0"
+version = "1.491.5"
 description = "An extension client for the wmill client library focused on pg"
 license = "Apache-2.0"
 homepage = "https://windmill.dev"

typescript-client/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@windmill/windmill",
-  "version": "1.491.0",
+  "version": "1.491.5",
   "exports": "./src/index.ts",
   "publish": {
     "exclude": ["!src", "./s3Types.ts", "./client.ts"]

typescript-client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "1.491.0",
+  "version": "1.491.5",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "devDependencies": {

version.txt

@@ -1 +1 @@
-1.491.0
+1.491.5