windmill-components 1.558.4 → 1.596.0

package/package/tutorials/config.js

@@ -0,0 +1,103 @@
+import { Workflow, GraduationCap, Wrench, PlayCircle, Link2 } from 'lucide-svelte';
+import { base } from '../base';
+/**
+ * Get tutorial index from config by tutorial ID.
+ * Throws an error if the tutorial or its index is not found.
+ */
+export function getTutorialIndex(id) {
+    for (const tab of Object.values(TUTORIALS_CONFIG)) {
+        const tutorial = tab.tutorials.find((t) => t.id === id);
+        if (tutorial?.index !== undefined)
+            return tutorial.index;
+    }
+    throw new Error(`Tutorial index not found for id: ${id}. Make sure the tutorial has an index defined in config.`);
+}
+// Available roles : developer, admin, operator
+export const TUTORIALS_CONFIG = {
+    quickstart: {
+        label: 'Quickstart',
+        roles: ['admin', 'developer'],
+        progressBar: true,
+        active: true,
+        tutorials: [
+            {
+                id: 'workspace-onboarding',
+                icon: GraduationCap,
+                title: 'Workspace onboarding',
+                description: 'Discover the basics of Windmill with a quick tour of the workspace.',
+                onClick: () => {
+                    window.location.href = `${base}/?tutorial=workspace-onboarding`;
+                },
+                index: 1,
+                active: true,
+                comingSoon: false,
+                roles: ['developer', 'admin'],
+                order: 1
+            },
+            {
+                id: 'flow-live-tutorial',
+                icon: Workflow,
+                title: 'Build a flow',
+                description: 'Learn how to build workflows in Windmill with our interactive tutorial.',
+                onClick: () => {
+                    window.location.href = `${base}/flows/add?tutorial=flow-live-tutorial&nodraft=true`;
+                },
+                index: 2,
+                active: true,
+                comingSoon: false,
+                roles: ['developer', 'admin'],
+                order: 2
+            },
+            {
+                id: 'troubleshoot-flow',
+                icon: Wrench,
+                title: 'Fix a broken flow',
+                description: 'Learn how to monitor and debug your script and flow executions.',
+                onClick: () => {
+                    window.location.href = `${base}/flows/add?tutorial=troubleshoot-flow&nodraft=true`;
+                },
+                index: 3,
+                active: true,
+                comingSoon: false,
+                roles: ['admin', 'developer'],
+                order: 3
+            }
+        ]
+    },
+    app_editor: {
+        label: 'App Editor',
+        roles: ['developer', 'admin'],
+        progressBar: false,
+        active: true,
+        tutorials: [
+            {
+                id: 'backgroundrunnables',
+                icon: PlayCircle,
+                title: 'Background runnables',
+                description: 'Learn how to create and use background runnables in your apps.',
+                onClick: () => {
+                    window.location.href = `${base}/apps/add?tutorial=backgroundrunnables&nodraft=true`;
+                },
+                index: 4,
+                active: true,
+                comingSoon: false,
+                roles: ['developer', 'admin'],
+                order: 4
+            },
+            {
+                id: 'connection',
+                icon: Link2,
+                title: 'Connection',
+                description: 'Learn how to connect component inputs to outputs in your apps.',
+                onClick: () => {
+                    window.location.href = `${base}/apps/add?tutorial=connection&nodraft=true`;
+                },
+                index: 5,
+                active: true,
+                comingSoon: false,
+                roles: ['developer', 'admin'],
+                order: 5
+            }
+        ]
+    }
+};

package/package/tutorials/roleUtils.d.ts

@@ -0,0 +1,20 @@
+import type { UserExt } from '../stores';
+export type Role = 'admin' | 'developer' | 'operator';
+/**
+ * Get the effective role of a user based on their database flags.
+ * - Admin: user.is_admin === true
+ * - Operator: user.operator === true (and not admin)
+ * - Developer: default (neither admin nor operator)
+ */
+export declare function getUserEffectiveRole(user: UserExt | null | undefined): Role | null;
+/**
+ * Check if a user or preview role has access based on a roles array.
+ * This is the unified function that handles both normal user access and admin preview mode.
+ */
+export declare function hasRoleAccess(user: UserExt | null | undefined, roles?: Role[], previewRole?: Role): boolean;
+/**
+ * Check if a preview role has access based on a roles array.
+ * Used by admins to preview what other roles can see.
+ * This is a convenience wrapper around hasRoleAccess for preview mode.
+ */
+export declare function hasRoleAccessForPreview(previewRole: Role, roles?: Role[]): boolean;

package/package/tutorials/roleUtils.js

@@ -0,0 +1,52 @@
+/**
+ * Get the effective role of a user based on their database flags.
+ * - Admin: user.is_admin === true
+ * - Operator: user.operator === true (and not admin)
+ * - Developer: default (neither admin nor operator)
+ */
+export function getUserEffectiveRole(user) {
+    if (!user)
+        return null;
+    if (user.is_admin)
+        return 'admin';
+    if (user.operator)
+        return 'operator';
+    return 'developer';
+}
+/**
+ * Check if a role has access to a required role.
+ * This is the core role-checking logic used by both normal and preview modes.
+ */
+function checkRoleMatch(userRole, requiredRole) {
+    if (requiredRole === 'admin')
+        return userRole === 'admin';
+    if (requiredRole === 'operator')
+        return userRole === 'operator' || userRole === 'admin';
+    if (requiredRole === 'developer')
+        return userRole === 'developer' || userRole === 'admin';
+    return false;
+}
+/**
+ * Check if a user or preview role has access based on a roles array.
+ * This is the unified function that handles both normal user access and admin preview mode.
+ */
+export function hasRoleAccess(user, roles, previewRole) {
+    // No roles specified = available to everyone
+    if (!roles || roles.length === 0)
+        return true;
+    // If previewRole is provided, use it (admin preview mode)
+    // Otherwise, derive role from user
+    const effectiveRole = previewRole ?? getUserEffectiveRole(user);
+    if (!effectiveRole)
+        return false;
+    // Check if effective role has any of the required roles
+    return roles.some((role) => checkRoleMatch(effectiveRole, role));
+}
+/**
+ * Check if a preview role has access based on a roles array.
+ * Used by admins to preview what other roles can see.
+ * This is a convenience wrapper around hasRoleAccess for preview mode.
+ */
+export function hasRoleAccessForPreview(previewRole, roles) {
+    return hasRoleAccess(null, roles, previewRole);
+}

package/package/utils.js

@@ -317,6 +317,12 @@ export function clickOutside(node, options) {
         }
     };
 }
+export function undefinedIfEmpty(obj) {
+    if (Object.keys(obj).length === 0) {
+        return undefined;
+    }
+    return obj;
+}
 export function pointerDownOutside(node, options) {
     const handlePointerDown = async (event) => {
         if (!event.isTrusted)
@@ -681,9 +687,7 @@ export function pluralize(quantity, word, customPlural) {
 export function addDeterminant(word) {
     return (/^[aeiou]/i.test(word) ? 'an ' : 'a ') + word;
 }
-export function capitalize(word) {
-    return word ? word.charAt(0).toUpperCase() + word.slice(1) : '';
-}
+export { capitalize } from './sharedUtils';
 export function addWhitespaceBeforeCapitals(word) {
     if (!word) {
         return '';
@@ -1230,12 +1234,7 @@ export function getOS() {
     }
     return 'Unknown OS';
 }
-import { clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
 import { OpenAPIV2 } from 'openapi-types';
-export function cn(...inputs) {
-    return twMerge(clsx(inputs));
-}
 export function readFieldsRecursively(obj, options = {}) {
     if (Array.isArray(obj)) {
         // <= in case a new object is added. should read as undefined
@@ -1277,7 +1276,7 @@ export function scroll_into_view_if_needed_polyfill(elem, centerIfNeeded = true)
     observer.observe(elem);
     return observer; // return for testing
 }
-// Structured clone raises an error on $state values
+// Structured clone raises an error on $state values and some stuff like Window
 // $state.snapshot clones everything but prints warnings for some values (e.g. functions)
 import _clone from 'clone';
 export function clone(t) {
@@ -1357,3 +1356,159 @@ export function createCache(compute, params) {
 export async function wait(ms) {
     return new Promise((resolve) => setTimeout(() => resolve(undefined), ms));
 }
+export function validateRetryConfig(retry) {
+    if (retry?.exponential?.seconds !== undefined) {
+        const seconds = retry.exponential.seconds;
+        if (typeof seconds !== 'number' || !Number.isInteger(seconds) || seconds < 0) {
+            return 'Exponential backoff base (seconds) must be an integer ≥ 0';
+        }
+    }
+    return null;
+}
+import tokensFile from './assets/tokens/tokens.json';
+import { darkModeName, lightModeName } from './assets/tokens/colorTokensConfig';
+import BarsStaggered from './components/icons/BarsStaggered.svelte';
+import { GitIcon } from './components/icons';
+import { Bot, Code, Package } from 'lucide-svelte';
+export function getCssColor(color, { alpha = 1, format = 'css-var' }) {
+    if (format === 'hex-light') {
+        return tokensFile.tokens[lightModeName][color];
+    }
+    if (format === 'hex-dark') {
+        return tokensFile.tokens[darkModeName][color];
+    }
+    return `rgb(var(--color-${color}) / ${alpha})`;
+}
+export function getJobKindIcon(jobKind) {
+    if (jobKind === 'flow' || isFlowPreview(jobKind) || jobKind === 'unassigned_flow') {
+        return BarsStaggered;
+    }
+    else if (jobKind === 'deploymentcallback') {
+        return GitIcon;
+    }
+    else if (jobKind === 'dependencies' ||
+        jobKind === 'appdependencies' ||
+        jobKind === 'flowdependencies') {
+        return Package;
+    }
+    else if (jobKind === 'script' ||
+        isScriptPreview(jobKind) ||
+        jobKind === 'script_hub' ||
+        jobKind === 'singlestepflow' ||
+        jobKind === 'unassigned_script' ||
+        jobKind === 'unassigned_singlestepflow') {
+        return Code;
+    }
+    else if (jobKind === 'aiagent') {
+        return Bot;
+    }
+    else if (jobKind)
+        return Code;
+}
+export function chunkBy(array, getKey) {
+    const chunks = [];
+    for (const item of array) {
+        const key = getKey(item);
+        let lastChunk = chunks[chunks.length - 1];
+        if (!lastChunk || getKey(lastChunk[0]) !== key) {
+            lastChunk = [];
+            chunks.push(lastChunk);
+        }
+        lastChunk.push(item);
+    }
+    return chunks;
+}
+// AI generated
+export function getQueryStmtCountHeuristic(query) {
+    // Handle empty or whitespace-only strings
+    if (query.trim() === '') {
+        return 0;
+    }
+    let count = 0;
+    let currState = 'normal';
+    let hasContentAfterLastSemicolon = false;
+    for (let i = 0; i < query.length; i++) {
+        const char = query[i];
+        const nextChar = query[i + 1];
+        switch (currState) {
+            case 'normal':
+                if (char === "'") {
+                    currState = 'single-quote';
+                    hasContentAfterLastSemicolon = true;
+                }
+                else if (char === '"') {
+                    currState = 'double-quote';
+                    hasContentAfterLastSemicolon = true;
+                }
+                else if (char === '-' && nextChar === '-') {
+                    currState = 'line-comment';
+                    i++; // skip next char
+                }
+                else if (char === '/' && nextChar === '*') {
+                    currState = 'block-comment';
+                    hasContentAfterLastSemicolon = true;
+                    i++; // skip next char
+                }
+                else if (char === ';') {
+                    count++;
+                    hasContentAfterLastSemicolon = false;
+                }
+                else if (char !== ' ' && char !== '\t' && char !== '\n' && char !== '\r') {
+                    // Non-whitespace character means we have content
+                    hasContentAfterLastSemicolon = true;
+                }
+                break;
+            case 'single-quote':
+                if (char === "'") {
+                    // In SQL, '' is an escaped single quote
+                    if (nextChar === "'") {
+                        i++; // skip the escaped quote
+                    }
+                    else {
+                        currState = 'normal';
+                    }
+                }
+                break;
+            case 'double-quote':
+                if (char === '"') {
+                    // In SQL, "" is an escaped double quote
+                    if (nextChar === '"') {
+                        i++; // skip the escaped quote
+                    }
+                    else {
+                        currState = 'normal';
+                    }
+                }
+                break;
+            case 'line-comment':
+                if (char === '\n') {
+                    currState = 'normal';
+                }
+                break;
+            case 'block-comment':
+                if (char === '*' && nextChar === '/') {
+                    currState = 'normal';
+                    i++; // skip next char
+                }
+                break;
+        }
+    }
+    // Count implicit final statement if:
+    // 1. We're in normal state and query doesn't end with semicolon, OR
+    // 2. We're in a quote state (unclosed quote) - there's an implicit statement
+    // 3. We're in a block comment state - there's an implicit statement before the unclosed comment
+    // 4. We're in a line comment state and we had content after the last semicolon before entering the comment
+    const trimmedQuery = query.trimEnd();
+    if (currState === 'normal' && trimmedQuery !== '' && !trimmedQuery.endsWith(';')) {
+        count++;
+    }
+    else if (currState === 'single-quote' || currState === 'double-quote' || currState === 'block-comment') {
+        // Unclosed quote or unclosed block comment means there's an implicit statement
+        count++;
+    }
+    else if (currState === 'line-comment' && hasContentAfterLastSemicolon) {
+        // Line comment with content before it means there's an implicit statement
+        count++;
+    }
+    return count;
+}

package/package/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/utils.test.js

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import { getQueryStmtCountHeuristic } from './utils';
+describe('getQueryStmtCountHeuristic', () => {
+    describe('basic statements', () => {
+        it('should count a single statement without semicolon', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users')).toBe(1);
+        });
+        it('should count a single statement with semicolon', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users;')).toBe(1);
+        });
+        it('should count multiple statements', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users; SELECT * FROM posts;')).toBe(2);
+        });
+        it('should handle empty string as implicit statement', () => {
+            expect(getQueryStmtCountHeuristic('')).toBe(0);
+        });
+        it('should handle whitespace only as implicit statement', () => {
+            expect(getQueryStmtCountHeuristic('   \n\t  ')).toBe(0);
+        });
+        it('should handle statement with trailing whitespace', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users;   \n  ')).toBe(1);
+        });
+        it('should count three statements', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1; UPDATE users SET name = "test"; DELETE FROM logs;')).toBe(3);
+        });
+    });
+    describe('single-quoted strings', () => {
+        it('should ignore semicolon in single-quoted string', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'hello;world' FROM users")).toBe(1);
+        });
+        it('should handle escaped single quote', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'it''s working' FROM users")).toBe(1);
+        });
+        it('should handle multiple escaped single quotes', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'it''s a ''test''' FROM users")).toBe(1);
+        });
+        it('should handle semicolon in escaped quote context', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'val''s;data' FROM users")).toBe(1);
+        });
+        it('should handle multiple statements with single-quoted strings', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'hello;' FROM users; SELECT 'world;' FROM posts")).toBe(2);
+        });
+        it('should handle adjacent escaped quotes', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '''' FROM users")).toBe(1);
+        });
+    });
+    describe('double-quoted strings', () => {
+        it('should ignore semicolon in double-quoted string', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "hello;world" FROM users')).toBe(1);
+        });
+        it('should handle escaped double quote', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "it""s working" FROM users')).toBe(1);
+        });
+        it('should handle multiple escaped double quotes', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "it""s a ""test""" FROM users')).toBe(1);
+        });
+        it('should handle semicolon in escaped quote context', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "val""s;data" FROM users')).toBe(1);
+        });
+        it('should handle adjacent escaped quotes', () => {
+            expect(getQueryStmtCountHeuristic('SELECT """" FROM users')).toBe(1);
+        });
+    });
+    describe('mixed quotes', () => {
+        it('should handle both single and double quotes in same query', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "col;1", \'val;2\' FROM users')).toBe(1);
+        });
+        it('should handle single quote inside double quote', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "it\'s;ok" FROM users')).toBe(1);
+        });
+        it('should handle double quote inside single quote', () => {
+            expect(getQueryStmtCountHeuristic('SELECT \'"quoted";value\' FROM users')).toBe(1);
+        });
+        it('should handle complex nested scenarios', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "a\'b;c", \'d"e;f\', g FROM users; DELETE FROM logs')).toBe(2);
+        });
+    });
+    describe('line comments', () => {
+        it('should ignore semicolon in line comment', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 -- comment;here\nFROM users')).toBe(1);
+        });
+        it('should handle multiple line comments', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 -- comment;1\n-- comment;2\nFROM users')).toBe(1);
+        });
+        it('should handle line comment at end of query', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users -- final;comment')).toBe(1);
+        });
+        it('should handle line comment with semicolon at end', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users; -- comment;here')).toBe(1);
+        });
+        it('should count statements after line comment', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1; -- comment\nSELECT 2')).toBe(2);
+        });
+        it('should handle line comment without newline at end (stays in comment state)', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 FROM users -- comment;here')).toBe(1);
+        });
+        it('should handle dashes inside string not as comment', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '--not;comment' FROM users")).toBe(1);
+        });
+        it('should handle single dash (not a comment)', () => {
+            expect(getQueryStmtCountHeuristic('SELECT a-b FROM users')).toBe(1);
+        });
+    });
+    describe('block comments', () => {
+        it('should ignore semicolon in block comment', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 /* comment;here */ FROM users')).toBe(1);
+        });
+        it('should handle multiline block comment', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 /* comment;\nacross;\nlines */ FROM users')).toBe(1);
+        });
+        it('should handle multiple block comments', () => {
+            expect(getQueryStmtCountHeuristic('SELECT /* c1;here */ 1, /* c2;here */ 2 FROM /* c3;here */ users')).toBe(1);
+        });
+        it('should handle nested-looking block comments', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 /* outer /* inner;here */ still */ FROM users')).toBe(1);
+        });
+        it('should handle block comment at end', () => {
+            expect(getQueryStmtCountHeuristic('SELECT * FROM users /* final;comment */')).toBe(1);
+        });
+        it('should count statements after block comment', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1; /* comment */ SELECT 2')).toBe(2);
+        });
+        it('should handle block comment markers in string', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '/* not;comment */' FROM users")).toBe(1);
+        });
+        it('should handle unclosed block comment (stays in comment state)', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1 /* unclosed;comment')).toBe(1);
+        });
+        it('should handle slash-star inside string not as comment', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '/*;not comment' FROM users")).toBe(1);
+        });
+    });
+    describe('mixed comments and strings', () => {
+        it('should handle comment after string', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'value;1' -- comment;2\nFROM users")).toBe(1);
+        });
+        it('should handle string after comment', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 1 -- comment\n, 'value;here' FROM users")).toBe(1);
+        });
+        it('should handle complex mix', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "col;1" /* comment;1 */ , \'val;2\' -- comment;2\nFROM users')).toBe(1);
+        });
+        it('should handle quotes in comments', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 1 /* it's;working */ FROM users")).toBe(1);
+        });
+        it('should handle comment markers in string', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '--/*;*/' FROM users -- real;comment")).toBe(1);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle only semicolons', () => {
+            expect(getQueryStmtCountHeuristic(';;;')).toBe(3);
+        });
+        it('should handle semicolons with whitespace', () => {
+            expect(getQueryStmtCountHeuristic(' ; ; ; ')).toBe(3);
+        });
+        it('should handle query ending with multiple semicolons', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1;;')).toBe(2);
+        });
+        it('should handle unclosed single quote (stays in quote state)', () => {
+            expect(getQueryStmtCountHeuristic("SELECT 'unclosed")).toBe(1);
+        });
+        it('should handle unclosed double quote (stays in quote state)', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "unclosed')).toBe(1);
+        });
+        it('should handle unclosed line comment (no newline at end)', () => {
+            expect(getQueryStmtCountHeuristic('SELECT 1; -- comment;here')).toBe(1);
+        });
+        it('should handle all types together', () => {
+            expect(getQueryStmtCountHeuristic(`SELECT "col;1", 'val;2' FROM users WHERE x = 1; -- comment;here
+/* block;comment */ UPDATE posts SET title = 'new;title';
+DELETE FROM logs -- final;cleanup`)).toBe(3);
+        });
+        it('should handle empty statements', () => {
+            expect(getQueryStmtCountHeuristic(';')).toBe(1);
+        });
+        it('should handle consecutive escaped quotes at statement boundary', () => {
+            expect(getQueryStmtCountHeuristic("SELECT '''';")).toBe(1);
+        });
+        it('should handle alternating quote types', () => {
+            expect(getQueryStmtCountHeuristic('SELECT "a", \'b\', "c", \'d\' FROM users')).toBe(1);
+        });
+        it('should handle very long string with semicolons', () => {
+            const longString = ';'.repeat(1000);
+            expect(getQueryStmtCountHeuristic(`SELECT '${longString}' FROM users`)).toBe(1);
+        });
+        it('should handle realistic multiline query', () => {
+            const query = `
+SELECT
+  id,
+  name,
+  "user;email" -- email column
+FROM users
+WHERE status = 'active;pending'
+  AND created_at > '2024-01-01';
+
+/* Update user preferences */
+UPDATE user_settings
+SET theme = 'dark;mode'
+WHERE user_id IN (SELECT id FROM users WHERE name LIKE '%test%');
+
+-- Cleanup old data
+DELETE FROM logs WHERE timestamp < NOW() - INTERVAL '30 days'
+			`;
+            expect(getQueryStmtCountHeuristic(query)).toBe(3);
+        });
+    });
+});