windmill-components 1.542.5 → 1.555.0

package/package/components/git_sync/GitSyncContext.svelte.d.ts

@@ -12,6 +12,8 @@ export type GitSyncRepository = BackendGitRepositorySettings & {
     detectionJobId?: string;
     detectionJobStatus?: 'running' | 'success' | 'failure';
     _trackedPath?: string;
+    _targetBranch?: string;
+    _detectionTimestamp?: number;
 };
 export type GitSyncTestJob = {
     jobId: string;
@@ -60,7 +62,10 @@ export declare function createGitSyncContext(workspace: string): {
     readonly hasUnsavedConnections: boolean;
     readonly hasWorkspaceLevelSettings: boolean;
     addRepository: () => void;
+    addSyncRepository: () => void;
+    addPromotionRepository: () => void;
     removeRepository: (idx: number) => Promise<void>;
+    removeRepositoryByPath: (resourcePath: string) => Promise<void>;
     getRepository: (idx: number) => GitSyncRepository;
     getValidation: (idx: number) => ValidationState;
     revertRepository: (idx: number) => void;
@@ -76,6 +81,23 @@ export declare function createGitSyncContext(workspace: string): {
     closeSuccessModal: () => void;
     loadSettings: () => Promise<void>;
     saveRepository: (idx: number, savedWithoutInit?: boolean) => Promise<void>;
+    getPrimarySyncRepository: () => {
+        repo: GitSyncRepository;
+        idx: number;
+    } | null;
+    getPrimaryPromotionRepository: () => {
+        repo: GitSyncRepository;
+        idx: number;
+    } | null;
+    getSecondarySyncRepositories: () => {
+        repo: GitSyncRepository;
+        idx: number;
+    }[];
+    getLegacyPromotionRepositories: () => {
+        repo: GitSyncRepository;
+        idx: number;
+    }[];
+    getTargetBranch: (repo: GitSyncRepository) => Promise<string>;
 };
 export type GitSyncContextType = ReturnType<typeof createGitSyncContext>;
 export declare function setGitSyncContext(workspace: string): GitSyncContextType;

package/package/components/git_sync/GitSyncContext.svelte.js

@@ -1,5 +1,5 @@
 import { getContext, setContext } from 'svelte';
-import { JobService, WorkspaceService } from '../../gen';
+import { JobService, WorkspaceService, ResourceService } from '../../gen';
 import { jobManager } from '../../services/JobManager';
 import hubPaths from '../../hubPaths.json';
 const GIT_SYNC_CONTEXT_KEY = Symbol('git-sync-context');
@@ -20,8 +20,14 @@ export function createGitSyncContext(workspace) {
         repositories.forEach((repo) => {
             if (repo.isUnsavedConnection) {
                 const currentPath = repo.git_repo_resource_path;
-                if (repo._trackedPath && repo._trackedPath !== currentPath && repo.detectionState && repo.detectionState !== 'idle') {
-                    _resetRepoDetectionState(repo);
+                if (repo._trackedPath && repo._trackedPath !== currentPath) {
+                    // Clear cached branch when resource path changes
+                    repo._targetBranch = undefined;
+                    // Reset detection state for any non-idle state (including errors)
+                    if (repo.detectionState && repo.detectionState !== 'idle') {
+                        // Cancel any running detection job by resetting immediately
+                        _resetRepoDetectionState(repo);
+                    }
                 }
                 repo._trackedPath = currentPath;
             }
@@ -187,6 +193,8 @@ export function createGitSyncContext(workspace) {
         repo.detectionError = undefined;
         repo.detectionJobId = undefined;
         repo.detectionJobStatus = undefined;
+        // Track the detection timestamp to avoid race conditions from old jobs
+        const detectionTimestamp = Date.now();
         try {
             const jobId = await JobService.runScriptByPath({
                 workspace,
@@ -204,12 +212,17 @@ export function createGitSyncContext(workspace) {
             });
             repo.detectionJobId = jobId;
             repo.detectionJobStatus = 'running';
+            repo._detectionTimestamp = detectionTimestamp;
             // Use JobManager for polling - result will be the actual job response
             await jobManager.runWithProgress(() => Promise.resolve(jobId), {
                 workspace,
-                timeout: 30000,
-                timeoutMessage: 'Detection job timed out after 30s',
+                timeout: 60000,
+                timeoutMessage: 'Detection job timed out after 60s',
                 onProgress: (status) => {
+                    // Only update state if this detection is still current
+                    if (repo._detectionTimestamp !== detectionTimestamp) {
+                        return;
+                    }
                     repo.detectionJobStatus = status.status;
                     // Process successful detection result
                     if (status.status === 'success' && status.result) {
@@ -239,6 +252,10 @@ export function createGitSyncContext(workspace) {
             });
         }
         catch (error) {
+            // Only set error if this detection is still current
+            if (repo._detectionTimestamp !== detectionTimestamp) {
+                return;
+            }
             repo.detectionState = 'error';
             repo.detectionError = error?.message || error?.toString() || 'Failed to detect repository';
             repo.detectionJobStatus = 'failure';
@@ -412,6 +429,119 @@ export function createGitSyncContext(workspace) {
             gitSyncTestJobs[idx].status = 'failure';
         }
     }
+    function getPrimarySyncRepository() {
+        const idx = repositories.findIndex(r => !r.use_individual_branch);
+        return idx !== -1 ? { repo: repositories[idx], idx } : null;
+    }
+    function getPrimaryPromotionRepository() {
+        const idx = repositories.findIndex(r => r.use_individual_branch);
+        return idx !== -1 ? { repo: repositories[idx], idx } : null;
+    }
+    function getSecondarySyncRepositories() {
+        const result = [];
+        let foundFirst = false;
+        repositories.forEach((repo, idx) => {
+            if (!repo.use_individual_branch) {
+                if (foundFirst) {
+                    result.push({ repo, idx });
+                }
+                else {
+                    foundFirst = true;
+                }
+            }
+        });
+        return result;
+    }
+    function getLegacyPromotionRepositories() {
+        const result = [];
+        let foundFirst = false;
+        repositories.forEach((repo, idx) => {
+            if (repo.use_individual_branch) {
+                if (foundFirst) {
+                    result.push({ repo, idx });
+                }
+                else {
+                    foundFirst = true;
+                }
+            }
+        });
+        return result;
+    }
+    async function removeRepositoryByPath(resourcePath) {
+        const idx = repositories.findIndex(r => r.git_repo_resource_path === resourcePath);
+        if (idx !== -1) {
+            await removeRepository(idx);
+        }
+    }
+    function addSyncRepository() {
+        repositories.push({
+            git_repo_resource_path: '',
+            script_path: hubPaths.gitSync,
+            use_individual_branch: false,
+            group_by_folder: false,
+            settings: {
+                include_path: ['f/**'],
+                exclude_path: [],
+                extra_include_path: [],
+                include_type: ['script', 'flow', 'app', 'folder']
+            },
+            exclude_types_override: [],
+            legacyImported: false,
+            isUnsavedConnection: true,
+            collapsed: false
+        });
+        gitSyncTestJobs.push({
+            jobId: '',
+            status: undefined
+        });
+    }
+    function addPromotionRepository() {
+        repositories.push({
+            git_repo_resource_path: '',
+            script_path: hubPaths.gitSync,
+            use_individual_branch: true,
+            group_by_folder: false,
+            settings: {
+                include_path: ['f/**'],
+                exclude_path: [],
+                extra_include_path: [],
+                include_type: ['script', 'flow', 'app', 'folder']
+            },
+            exclude_types_override: [],
+            legacyImported: false,
+            isUnsavedConnection: true,
+            collapsed: false
+        });
+        gitSyncTestJobs.push({
+            jobId: '',
+            status: undefined
+        });
+    }
+    // Helper to get target branch from git resource
+    async function getTargetBranch(repo) {
+        if (!repo.git_repo_resource_path) {
+            return 'main';
+        }
+        if (repo._targetBranch) {
+            return repo._targetBranch;
+        }
+        try {
+            const resource = await ResourceService.getResource({
+                workspace,
+                path: repo.git_repo_resource_path
+            });
+            // Extract branch from git resource value
+            const resourceValue = resource.value;
+            const targetBranch = resourceValue?.branch || 'main';
+            // Cache the result
+            repo._targetBranch = targetBranch;
+            return targetBranch;
+        }
+        catch (error) {
+            console.warn('Failed to fetch git resource for branch info:', error);
+            return 'main';
+        }
+    }
     // Return context object
     return {
         // State (read-only access)
@@ -430,7 +560,10 @@ export function createGitSyncContext(workspace) {
         get hasWorkspaceLevelSettings() { return hasWorkspaceLevelSettings; },
         // Methods
         addRepository,
+        addSyncRepository,
+        addPromotionRepository,
         removeRepository,
+        removeRepositoryByPath,
         getRepository,
         getValidation,
         revertRepository,
@@ -446,6 +579,13 @@ export function createGitSyncContext(workspace) {
         closeSuccessModal,
         loadSettings,
         saveRepository,
+        // Repository categorization methods
+        getPrimarySyncRepository,
+        getPrimaryPromotionRepository,
+        getSecondarySyncRepositories,
+        getLegacyPromotionRepositories,
+        // Helper methods
+        getTargetBranch,
     };
 }
 export function setGitSyncContext(workspace) {

package/package/components/git_sync/GitSyncModeDisplay.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">let { mode, targetBranch, repository } = $props();
+export {};
+</script>
+
+<div class="text-base">
+	{#if mode === 'promotion'}
+		<div><span class="font-bold">Promotion:</span> Creating branches whose promotion target is {targetBranch}</div>
+		{#if repository?.group_by_folder}
+			<div class="text-sm text-tertiary mt-1">Grouped by folder</div>
+		{/if}
+	{:else}
+		<div><span class="font-bold">Sync:</span> Syncing back to branch {targetBranch}</div>
+	{/if}
+</div>

package/package/components/git_sync/GitSyncModeDisplay.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { GitSyncRepository } from './GitSyncContext.svelte';
+type $$ComponentProps = {
+    mode?: 'sync' | 'promotion' | null;
+    targetBranch: string;
+    repository?: GitSyncRepository | null;
+};
+declare const GitSyncModeDisplay: import("svelte").Component<$$ComponentProps, {}, "">;
+type GitSyncModeDisplay = ReturnType<typeof GitSyncModeDisplay>;
+export default GitSyncModeDisplay;