chore(sql-editor): move toasts (#41076)

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

Author: EDsCODE

frontend/src/scenes/data-warehouse/editor/QueryWindow.tsx

@@ -125,7 +125,7 @@ export function QueryWindow({ onSetMonacoAndEditor, tabId }: QueryWindowProps):
                                         },
                                         editingView.id,
                                         currentDraft?.id || undefined,
-                                        activeTab
+                                        activeTab ?? undefined
                                     )
                                 } else {
                                     saveOrUpdateDraft(
@@ -135,7 +135,7 @@ export function QueryWindow({ onSetMonacoAndEditor, tabId }: QueryWindowProps):
                                         },
                                         undefined,
                                         currentDraft?.id || undefined,
-                                        activeTab
+                                        activeTab ?? undefined
                                     )
                                 }
                             }}

frontend/src/scenes/data-warehouse/editor/multitabEditorLogic.tsx

@@ -122,6 +122,7 @@ function getTabHash(values: multitabEditorLogicType['values']): Record<string, a
     return hash
 }
 
+// Misnomer now: this logic is responsible for the state of one sql editor tab
 export const multitabEditorLogic = kea<multitabEditorLogicType>([
     path(['data-warehouse', 'editor', 'multitabEditorLogic']),
     props({} as MultitabEditorLogicProps),
@@ -166,7 +167,6 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
         }),
         setActiveQuery: (query: string) => ({ query }),
 
-        setTabs: (tabs: QueryTab[]) => ({ tabs }),
         createTab: (
             query?: string,
             view?: DataWarehouseSavedQuery,
@@ -290,11 +290,10 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                 updateTab: (_, { tab }) => tab.insight ?? null,
             },
         ],
-        allTabs: [
-            [] as QueryTab[],
+        activeTab: [
+            null as QueryTab | null,
             {
-                updateTab: (_, { tab }) => [tab],
-                setTabs: (_, { tabs }) => tabs,
+                updateTab: (_, { tab }) => tab,
             },
         ],
         error: [
@@ -625,17 +624,15 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                 }
             }
         },
-        saveDraft: async ({ activeTab, queryInput, viewId }) => {
-            const latestActiveTab = values.allTabs.find((tab) => tab.uri.toString() === activeTab.uri.toString())
-
-            if (latestActiveTab) {
+        saveDraft: async ({ queryInput, viewId }) => {
+            if (values.activeTab) {
                 actions.saveAsDraft(
                     {
                         kind: NodeKind.HogQLQuery,
                         query: queryInput,
                     },
                     viewId,
-                    latestActiveTab
+                    values.activeTab
                 )
             }
         },
@@ -814,34 +811,30 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
             router.actions.push(urls.insightView(savedInsight.short_id))
         },
         loadDataWarehouseSavedQueriesSuccess: ({ dataWarehouseSavedQueries }) => {
-            // keep tab views up to date
-            const tab = values.activeTab
-            const view = dataWarehouseSavedQueries.find((v) => v.id === tab.view?.id)
-            if (tab && view) {
-                actions.setTabs([{ ...tab, view }])
-                actions.setQueryInput(view.query.query || '')
+            if (values.activeTab?.view) {
+                const view = dataWarehouseSavedQueries.find((v) => v.id === values.activeTab?.view?.id)
+                if (view && values.activeTab) {
+                    actions.updateTab({ ...values.activeTab, view })
+                    actions.setQueryInput(view.query.query || '')
+                }
             }
         },
         deleteDataWarehouseSavedQuerySuccess: ({ payload: viewId }) => {
-            const mustRemoveTab = values.allTabs.find((tab) => tab.view?.id === viewId && !tab.draft)
-            if (mustRemoveTab) {
-                actions.setTabs([])
+            if (values.activeTab?.view?.id === viewId && !values.activeTab?.draft) {
                 actions.createTab()
             }
-            lemonToast.success('View deleted')
         },
         createDataWarehouseSavedQuerySuccess: ({ dataWarehouseSavedQueries, payload: view }) => {
             const newView = view && dataWarehouseSavedQueries.find((v) => v.name === view.name)
             if (newView) {
                 const oldTab = values.activeTab
-                if (oldTab) {
+                // Only update the tab if it doesn't have a view (new query being saved)
+                // or if it's the same view being recreated (edge case)
+                if (oldTab && (!oldTab.view || oldTab.view.id === newView.id)) {
                     actions.updateTab({ ...oldTab, view: newView })
                 }
             }
         },
-        updateDataWarehouseSavedQuerySuccess: () => {
-            lemonToast.success('View updated')
-        },
         updateView: async ({ view, draftId }) => {
             const latestView = await api.dataWarehouseSavedQueries.get(view.id)
             // Only check for conflicts if there's an activity log (latest_history_id exists)
@@ -880,13 +873,13 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
             }
         },
         deleteDraftSuccess: ({ draftId, viewName }) => {
-            // remove draft from all tabs
-            const newTabs = values.allTabs.map((tab) => ({
-                ...tab,
-                draft: tab.draft?.id === draftId ? undefined : tab.draft,
-                name: tab.draft?.id === draftId && viewName ? viewName : tab.name,
-            }))
-            actions.setTabs(newTabs)
+            if (values.activeTab && values.activeTab.draft?.id === draftId) {
+                actions.updateTab({
+                    ...values.activeTab,
+                    draft: undefined,
+                    name: viewName ?? values.activeTab.name,
+                })
+            }
         },
     })),
     subscriptions(({ actions, values }) => ({
@@ -921,20 +914,21 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
             }
         },
         drafts: (drafts) => {
-            // update all drafts in all tabs
-            const newTabs = values.allTabs.map((tab) => ({
-                ...tab,
-                draft: drafts.find((d: DataWarehouseSavedQueryDraft) => d.id === tab.draft?.id),
-                name:
-                    drafts.find((d: DataWarehouseSavedQueryDraft) => d.id === tab.draft?.id)?.name ??
-                    tab.view?.name ??
-                    tab.name,
-            }))
-            actions.setTabs(newTabs)
+            if (values.activeTab && values.activeTab.draft) {
+                const updatedDraft = drafts.find(
+                    (d: DataWarehouseSavedQueryDraft) => d.id === values.activeTab?.draft?.id
+                )
+                if (updatedDraft) {
+                    actions.updateTab({
+                        ...values.activeTab,
+                        draft: updatedDraft,
+                        name: updatedDraft.name ?? values.activeTab.view?.name ?? values.activeTab.name,
+                    })
+                }
+            }
         },
     })),
     selectors({
-        activeTab: [(s) => [s.allTabs], (allTabs: QueryTab[]) => allTabs?.[0] ?? null],
         suggestedSource: [
             (s) => [s.suggestionPayload],
             (suggestionPayload) => {
@@ -1130,9 +1124,7 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                         return
                     }
 
-                    const existingTab = values.allTabs.find((tab) => {
-                        return tab.draft?.id === draft.id
-                    })
+                    const existingTab = values.activeTab?.draft?.id === draft.id ? values.activeTab : null
 
                     if (!existingTab) {
                         const associatedView = draft.saved_query_id
@@ -1141,9 +1133,8 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
 
                         actions.createTab(draft.query.query, associatedView, undefined, draft)
 
-                        const newTab = values.allTabs[values.allTabs.length - 1]
-                        if (newTab) {
-                            actions.setTabDraftId(newTab.uri.toString(), draft.id)
+                        if (values.activeTab) {
+                            actions.setTabDraftId(values.activeTab.uri.toString(), draft.id)
                         }
                     }
                     return

frontend/src/scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic.tsx

@@ -160,10 +160,15 @@ export const dataWarehouseViewsLogic = kea<dataWarehouseViewsLogicType>([
             }
 
             actions.loadDatabase()
+
+            // Toast is handled by dataWarehouseSettingsSceneLogic when needed
         },
         updateDataWarehouseSavedQueryError: () => {
             lemonToast.error('Failed to update view')
         },
+        deleteDataWarehouseSavedQuerySuccess: () => {
+            lemonToast.success('View deleted')
+        },
         runDataWarehouseSavedQuery: async ({ viewId }) => {
             try {
                 await api.dataWarehouseSavedQueries.run(viewId)