sqlmesh 0.187.5__tar.gz → 0.187.6.dev1__tar.gz

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.187.5
+Version: 0.187.6.dev1
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.187.5'
-__version_tuple__ = version_tuple = (0, 187, 5)
+__version__ = version = '0.187.6.dev1'
+__version_tuple__ = version_tuple = (0, 187, 6, 'dev1')

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.187.5
+Version: 0.187.6.dev1
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/sqlmesh.egg-info/SOURCES.txt

@@ -772,6 +772,7 @@ vscode/react/src/style/variants.ts
 vscode/react/src/utils/index.spec.ts
 vscode/react/src/utils/index.ts
 vscode/react/src/utils/receiveEvents.ts
+vscode/react/src/utils/rpc.ts
 vscode/react/src/utils/vscodeapi.ts
 vscode/react/src/workers/index.ts
 vscode/react/src/workers/lineage.ts

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/bus/src/callbacks.ts

@@ -1,15 +1,13 @@
+import type { Result } from './result'
+
+export type CallbackShape = Record<string, any>
+
 export type Callback = {
   openFile: {
     uri: string
   }
-  queryRequest: {
-    requestId: string
-    url: string
-    method?: string
-    params?: Record<string, string>
-    body?: Record<string, any>
-  }
-}
+  rpcResponse: RPCResponse
+} & CallbackShape
 
 /**
  * A tuple type representing a callback event with its associated payload.
@@ -23,6 +21,8 @@ export type CallbackEvent = {
   [K in keyof Callback]: { key: K; payload: Callback[K] }
 }[keyof Callback]
 
+export type VSCodeCallbackShape = Record<string, any>
+
 /**
  * A tuple type representing a VSCode event with its associated payload.
  */
@@ -30,15 +30,43 @@ export type VSCodeCallback = {
   changeFocusOnFile: {
     path: string
   }
-  queryResponse: {
-    requestId: string
-    response: any
-  }
   savedFile: {
     fileUri: string
   }
-}
+  rpcRequest: RPCRequest
+} & VSCodeCallbackShape
 
 export type VSCodeEvent = {
   [K in keyof VSCodeCallback]: { key: K; payload: VSCodeCallback[K] }
 }[keyof VSCodeCallback]
+
+type RPCMethodsShape = Record<string, { params: any; result: any }>
+
+export type RPCMethods = {
+  get_active_file: {
+    params: {}
+    result: {
+      fileUri?: string
+    }
+  }
+  api_query: {
+    params: {
+      url: string
+      method: string
+      params: any
+      body: any
+    }
+    result: any
+  }
+} & RPCMethodsShape
+
+export type RPCRequest = {
+  requestId: string
+  method: keyof RPCMethods
+  params: RPCMethods[keyof RPCMethods]['params']
+}
+
+export type RPCResponse = {
+  requestId: string
+  result: Result<RPCMethods[keyof RPCMethods]['result'], string>
+}

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/extension/src/webviews/lineagePanel.ts

@@ -1,4 +1,4 @@
-import { CallbackEvent } from '@bus/callbacks'
+import { CallbackEvent, RPCRequest } from '@bus/callbacks'
 import {
   Disposable,
   Uri,
@@ -83,18 +83,43 @@ export class LineagePanel implements WebviewViewProvider, Disposable {
             await window.showTextDocument(document)
             break
           }
-          case 'queryRequest': {
-            const payload = message.payload
-            const requestId = message.payload.requestId
-            const response = await this.lsp.call_custom_method(
-              'sqlmesh/api',
-              payload as any,
-            )
-            webviewView.webview.postMessage({
-              key: 'query_response',
-              payload: response,
-              requestId,
-            })
+          case 'rpcRequest': {
+            const payload: RPCRequest = message.payload
+            const requestId = payload.requestId
+            switch (payload.method) {
+              case 'api_query': {
+                const response = await this.lsp.call_custom_method(
+                  'sqlmesh/api',
+                  payload.params,
+                )
+                const responseCallback: CallbackEvent = {
+                  key: 'rpcResponse',
+                  payload: {
+                    requestId,
+                    result: response,
+                  },
+                }
+                webviewView.webview.postMessage(responseCallback)
+                break
+              }
+              case 'get_active_file': {
+                const active_file = window.activeTextEditor?.document.uri.fsPath
+                const responseCallback: CallbackEvent = {
+                  key: 'rpcResponse',
+                  payload: {
+                    requestId,
+                    result: {
+                      fileUri: active_file,
+                    },
+                  },
+                }
+                webviewView.webview.postMessage(responseCallback)
+                break
+              }
+              default: {
+                throw new Error(`Unhandled RPC method: ${payload.method}`)
+              }
+            }
             break
           }
           default:

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/react/src/api/index.ts

@@ -70,7 +70,15 @@ export function useApiModelLineage(
   return useQuery({
     queryKey: ['/api/lineage', modelName],
     queryFn: async ({ signal }) => {
-      return await modelLineageApiLineageModelNameGet(modelName, { signal })
+      try {
+        const response = await modelLineageApiLineageModelNameGet(modelName, {
+          signal,
+        })
+        return response
+      } catch (error) {
+        console.error('error fetching lineage', error)
+        throw error
+      }
     },
   })
 }

sqlmesh-0.187.6.dev1/vscode/react/src/api/instance.ts

@@ -0,0 +1,53 @@
+import { callRpc } from '@/utils/rpc'
+import { isErr } from '@bus/result'
+
+declare global {
+  interface Window {
+    __BASE_URL__?: string
+  }
+}
+
+interface ResponseWithDetail {
+  ok: boolean
+  detail?: string
+}
+
+interface FetchOptionsWithSignal {
+  signal?: AbortSignal
+}
+
+interface FetchOptions<B extends object = any> {
+  url: string
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
+  data?: B
+  responseType?: string
+  headers?: Record<string, string>
+  credentials?: 'omit' | 'same-origin' | 'include'
+  mode?: 'cors' | 'no-cors' | 'same-origin'
+  cache?:
+    | 'default'
+    | 'no-store'
+    | 'reload'
+    | 'no-cache'
+    | 'force-cache'
+    | 'only-if-cached'
+  params?: Record<string, string | number | boolean | undefined | null>
+}
+
+export async function fetchAPI<T = any, B extends object = any>(
+  config: FetchOptions<B>,
+  _options?: Partial<FetchOptionsWithSignal>,
+): Promise<T & ResponseWithDetail> {
+  const request = {
+    url: config.url,
+    method: config.method,
+    params: config.params,
+    body: config.data,
+  }
+  const result = await callRpc('api_query', request)
+  if (isErr(result)) {
+    throw new Error(result.error)
+  }
+  const response = result.value.data
+  return response
+}

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/react/src/components/graph/ModelLineage.tsx

@@ -78,7 +78,7 @@ export function ModelLineage({
     useApiModelLineage(model.name)
   const { isFetching: isFetchingModels } = useApiModels()
 
-  const [isMegringModels, setIsMergingModels] = useState(false)
+  const [isMergingModels, setIsMergingModels] = useState(false)
   const [modelLineage, setModelLineage] = useState<
     ModelLineageApiLineageModelNameGet200 | undefined
   >(undefined)
@@ -91,7 +91,6 @@ export function ModelLineage({
     getModelLineage()
       .then(({ data }) => {
         setModelLineage(data)
-
         if (isNil(data)) return
 
         setIsMergingModels(true)
@@ -164,7 +163,7 @@ export function ModelLineage({
   }
 
   const isFetching =
-    isFetchingModelLineage || isFetchingModels || isMegringModels
+    isFetchingModelLineage || isFetchingModels || isMergingModels
 
   return (
     <div className="relative h-full w-full overflow-hidden">

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/react/src/components/graph/context.tsx

@@ -104,7 +104,7 @@ export const LineageFlowContext = createContext<LineageFlow>({
   setActiveEdges: () => {},
   handleClickModel: () => {},
   setManuallySelectedColumn: () => {},
-  handleError: () => {},
+  handleError: error => console.error(error),
   setLineage: () => {},
   setLineageCache: () => {},
   isActiveColumn: () => false,

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/react/src/components/graph/help.ts

@@ -176,7 +176,6 @@ function getNodeMap({
       ? decodeURI(modelName)
       : modelName
     const model = Object.values(models).find(m => m.fqn === decodedModelName)
-    console.log('model', model)
     const nodeType: LineageNodeModelType = isNotNil(model)
       ? (model.type as LineageNodeModelType)
       : // If model name present in lineage but not in global models

{sqlmesh-0.187.5 → sqlmesh-0.187.6.dev1}/vscode/react/src/pages/lineage.tsx

@@ -15,6 +15,7 @@ import { useEventBus } from '@/hooks/eventBus'
 import type { VSCodeEvent } from '@bus/callbacks'
 import { URI } from 'vscode-uri'
 import type { Model } from '@/api/client'
+import { useRpc } from '@/utils/rpc'
 
 export function LineagePage() {
   const { emit } = useEventBus()
@@ -66,49 +67,93 @@ export function LineagePage() {
 }
 
 function Lineage() {
-  const [selectedModelSet, setSelectedModelSet] = useState<string | undefined>(
+  const [selectedModel, setSelectedModel] = useState<string | undefined>(
     undefined,
   )
   const { on } = useEventBus()
   const queryClient = useQueryClient()
 
   const { data: models, isLoading: isLoadingModels } = useApiModels()
+  const rpc = useRpc()
   React.useEffect(() => {
-    if (selectedModelSet === undefined && models && Array.isArray(models)) {
-      setSelectedModelSet(models[0].name)
+    const fetchFirstTimeModelIfNotSet = async (
+      models: Model[],
+    ): Promise<string | undefined> => {
+      if (!Array.isArray(models)) {
+        return undefined
+      }
+      const activeFile = await rpc('get_active_file', {})
+      // @ts-ignore
+      if (!activeFile.fileUri) {
+        return models[0].name
+      }
+      // @ts-ignore
+      const fileUri: string = activeFile.fileUri
+      const filePath = URI.parse(fileUri).fsPath
+      const model = models.find((m: Model) => m.full_path === filePath)
+      if (model) {
+        return model.name
+      }
+      return undefined
     }
-  }, [models, selectedModelSet])
+    if (selectedModel === undefined && Array.isArray(models)) {
+      fetchFirstTimeModelIfNotSet(models).then(modelName => {
+        if (modelName && selectedModel === undefined) {
+          setSelectedModel(modelName)
+        }
+      })
+    }
+  }, [models, selectedModel])
+
+  const modelsRecord =
+    Array.isArray(models) &&
+    models.reduce(
+      (acc, model) => {
+        acc[model.name] = model
+        return acc
+      },
+      {} as Record<string, Model>,
+    )
+
+  React.useEffect(() => {
+    const handleChangeFocusedFile = (fileUri: { fileUri: string }) => {
+      const full_path = URI.parse(fileUri.fileUri).fsPath
+      const model = Object.values(modelsRecord).find(
+        m => m.full_path === full_path,
+      )
+      if (model) {
+        setSelectedModel(model.name)
+      }
+    }
+
+    const handleSavedFile = () => {
+      queryClient.invalidateQueries()
+    }
+
+    const offChangeFocusedFile = on(
+      'changeFocusedFile',
+      handleChangeFocusedFile,
+    )
+    const offSavedFile = on('savedFile', handleSavedFile)
+
+    // If your event bus returns an "off" function, call it on cleanup
+    return () => {
+      if (offChangeFocusedFile) offChangeFocusedFile()
+      if (offSavedFile) offSavedFile()
+    }
+  }, [on, queryClient, modelsRecord])
 
   if (
     isLoadingModels ||
     models === undefined ||
-    selectedModelSet === undefined
+    modelsRecord === false ||
+    selectedModel === undefined
   ) {
     return <div>Loading models...</div>
   }
   if (!Array.isArray(models)) {
     return <div>Error: Models data is not in the expected format</div>
   }
-  const modelsRecord = models.reduce(
-    (acc, model) => {
-      acc[model.name] = model
-      return acc
-    },
-    {} as Record<string, Model>,
-  )
-  const selectedModel = selectedModelSet
-  on('changeFocusedFile', fileUri => {
-    const full_path = URI.parse(fileUri.fileUri).fsPath
-    const model = Object.values(modelsRecord).find(
-      m => m.full_path === full_path,
-    )
-    if (model) {
-      setSelectedModelSet(model.name)
-    }
-  })
-  on('savedFile', () => {
-    queryClient.invalidateQueries()
-  })
 
   return (
     <LineageComponentFromWeb
@@ -127,7 +172,6 @@ export function LineageComponentFromWeb({
 }): JSX.Element {
   const vscode = useVSCode()
   function handleClickModel(id: string): void {
-    console.log('handling click', id)
     const decodedId = decodeURIComponent(id)
     const model = Object.values(models).find(m => m.fqn === decodedId)
     if (!model) {
@@ -137,7 +181,7 @@ export function LineageComponentFromWeb({
   }
 
   function handleError(error: any): void {
-    console.log(error)
+    console.error(error)
   }
 
   const model = models[selectedModel]

sqlmesh-0.187.6.dev1/vscode/react/src/utils/rpc.ts

@@ -0,0 +1,50 @@
+import {
+  type RPCRequest,
+  type RPCMethods,
+  type CallbackEvent,
+} from '@bus/callbacks'
+import { type Result } from '@bus/result'
+import { sendVSCodeMessage } from './vscodeapi'
+
+export const useRpc = () => {
+  return callRpc
+}
+
+export const callRpc = async <T extends keyof RPCMethods>(
+  method: T,
+  params: RPCMethods[T]['params'],
+): Promise<Result<RPCMethods[T]['result'], string>> => {
+  return new Promise((resolve, reject) => {
+    const requestId = `query_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+    const messageHandler = (event: MessageEvent) => {
+      if (event.data) {
+        const eventData = event.data as CallbackEvent
+        if (eventData.key !== 'rpcResponse') {
+          return
+        }
+        if (eventData.payload.requestId !== requestId) {
+          return
+        }
+        const payload = eventData.payload.result
+        window.removeEventListener('message', messageHandler)
+        return resolve(payload)
+      }
+    }
+
+    // Add the listener
+    window.addEventListener('message', messageHandler)
+
+    const request: RPCRequest = {
+      requestId,
+      method,
+      params,
+    }
+    sendVSCodeMessage('rpcRequest', request)
+
+    // Set a timeout to prevent hanging promises
+    setTimeout(() => {
+      window.removeEventListener('message', messageHandler)
+      reject(new Error('Query request timed out'))
+    }, 30000) // 30 second timeout
+  })
+}

sqlmesh-0.187.5/vscode/react/src/api/instance.ts

@@ -1,80 +0,0 @@
-import { sendVSCodeMessage } from '@/utils/vscodeapi'
-import { isErr } from '@bus/result'
-
-declare global {
-  interface Window {
-    __BASE_URL__?: string
-  }
-}
-
-interface ResponseWithDetail {
-  ok: boolean
-  detail?: string
-}
-
-interface FetchOptionsWithSignal {
-  signal?: AbortSignal
-}
-
-interface FetchOptions<B extends object = any> {
-  url: string
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
-  data?: B
-  responseType?: string
-  headers?: Record<string, string>
-  credentials?: 'omit' | 'same-origin' | 'include'
-  mode?: 'cors' | 'no-cors' | 'same-origin'
-  cache?:
-    | 'default'
-    | 'no-store'
-    | 'reload'
-    | 'no-cache'
-    | 'force-cache'
-    | 'only-if-cached'
-  params?: Record<string, string | number | boolean | undefined | null>
-}
-
-export async function fetchAPI<T = any, B extends object = any>(
-  config: FetchOptions<B>,
-  _options?: Partial<FetchOptionsWithSignal>,
-): Promise<T & ResponseWithDetail> {
-  // Generate a unique ID for this request
-  // Create a promise that will resolve when we get a response with matching ID
-  return new Promise((resolve, reject) => {
-    const requestId = `query_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-    const messageHandler = (event: MessageEvent) => {
-      if (
-        event.data &&
-        event.data.key === 'query_response' &&
-        event.data.requestId === requestId
-      ) {
-        // Remove the listener once we get our response
-        window.removeEventListener('message', messageHandler)
-
-        const payload = event.data.payload
-        if (isErr(payload)) {
-          reject(new Error(payload.error as string))
-        } else {
-          resolve(payload.value.data)
-        }
-      }
-    }
-
-    // Add the listener
-    window.addEventListener('message', messageHandler)
-
-    sendVSCodeMessage('queryRequest', {
-      requestId,
-      url: config.url,
-      params: config.params as any,
-      body: config.data,
-      method: config.method,
-    })
-
-    // Set a timeout to prevent hanging promises
-    setTimeout(() => {
-      window.removeEventListener('message', messageHandler)
-      reject(new Error('Query request timed out'))
-    }, 30000) // 30 second timeout
-  })
-}