404 describe

apps/zui/src/app/lakes/root.tsx

@@ -8,8 +8,8 @@ import {updateStatus} from "src/js/flows/lake/update-status"
 import Current from "src/js/state/Current"
 import LakeStatuses from "src/js/state/LakeStatuses"
 import styled from "styled-components"
-import {initCurrentTab} from "src/js/flows/initCurrentTab"
 import {invoke} from "src/core/invoke"
+import {Active} from "src/models/active"
 
 const SpinnerWrap = styled.div`
   width: 100%;
@@ -27,6 +27,7 @@ export function InitLake({children}) {
   useLayoutEffect(() => {
     if (status) return
     if (lake) dispatch(updateStatus(lake.id))
+    Active.lake.sync()
   }, [lake?.id, status])
 
   useEffect(() => {
@@ -35,7 +36,7 @@ export function InitLake({children}) {
 
   switch (status) {
     case "disconnected":
-      return <ConnectionError onRetry={() => dispatch(initCurrentTab())} />
+      return <ConnectionError onRetry={() => dispatch(updateStatus(lake.id))} />
     case "login-required":
       return <Login lake={lake} />
     case "connected":

apps/zui/src/components/toolbar-tabs.tsx

@@ -26,7 +26,6 @@ function cancelTimer() {
 
 function checkTimer() {
   const ellapsed = new Date().getTime() - time.getTime()
-  console.log(ellapsed)
   if (ellapsed > 10 * 1000) {
     throw new Error("Expected Scaling to Be Finished After 10 Seconds")
   }

apps/zui/src/core/main/main-object.ts

@@ -105,6 +105,7 @@ export class MainObject {
   }
 
   openUrl(uri: string) {
+    // This is written to handle an auth0 url
     const urlParts = url.parse(uri, true)
     const {code, state, error, error_description} = urlParts.query as {
       [key: string]: string

apps/zui/src/domain/editor/operations.ts

@@ -5,7 +5,7 @@ export const describe = createOperation(
   "editor.describe",
   async (ctx, string, pool?) => {
     try {
-      const resp = await lake.client.describeQuery(string, pool)
+      const resp = await lake.client.describeQuery(string, {pool})
       return resp.error ? {error: resp} : resp
     } catch (error) {
       return {error: error.toString()}

apps/zui/src/js/initializers/init-lake.ts

@@ -2,10 +2,13 @@ import Current from "../state/Current"
 import {Store} from "../state/types"
 import {defaultLake} from "./initLakeParams"
 import Window from "../state/Window"
+import {Lake} from "src/models/lake"
 
 export function initLake(store: Store) {
   const lakeId = Current.getLakeId(store.getState())
   const id = lakeId || defaultLake().id
   // This sets up the lake's tabs
+  const lake = Lake.find(id)
+  lake.sync()
   store.dispatch(Window.setLakeId(id))
 }

apps/zui/src/js/initializers/initialize.ts

@@ -44,11 +44,7 @@ export default async function initialize(
   const api = new ZuiApi()
   const store = await initStore(api, renderer)
   const asyncTasks = initAsyncTasks(renderer)
-  await initGlobals(store)
-  await initLake(store)
-  api.init(store.dispatch, store.getState)
-  initDOM()
-  initIpcListeners(store)
+  initDomainModels({store})
   initHandlers({
     transition: startTransition,
     oldApi: api,
@@ -59,9 +55,13 @@ export default async function initialize(
     toast,
     asyncTasks,
   })
-  initDomainModels({
-    store,
-  })
+
+  await initGlobals(store)
+  await initLake(store)
+  api.init(store.dispatch, store.getState)
+  initDOM()
+  initIpcListeners(store)
+
   ViewHandler.store = store
   setMenuContext({select: (fn) => fn(store.getState()), api})
   initDebugGlobals(store, api)

apps/zui/src/js/state/Lakes/types.ts

@@ -6,6 +6,9 @@ export type LakeAttrs = {
   version?: string
   authType: AuthType
   authData?: AuthData
+  features?: {
+    describe: boolean
+  }
 }
 
 export type AuthType = "none" | "auth0"

apps/zui/src/js/state/QueryInfo/reducer.ts

@@ -16,6 +16,9 @@ const slice = createSlice({
     set(_, action) {
       return action.payload
     },
+    merge(state, action) {
+      return {...state, ...action.payload}
+    },
     reset(_) {
       return getInitialState()
     },

apps/zui/src/models/active.ts

@@ -6,6 +6,7 @@ import {BrowserTab} from "./browser-tab"
 import {Frame} from "./frame"
 import {getActiveTab} from "src/js/state/Tabs/selectors"
 import Editor from "src/js/state/Editor"
+import {Lake} from "./lake"
 
 export class Active extends DomainModel {
   static get tab() {
@@ -36,4 +37,9 @@ export class Active extends DomainModel {
       id: globalThis.windowId,
     })
   }
+
+  static get lake() {
+    const id = this.select(Current.getLakeId)
+    return Lake.find(id)
+  }
 }

apps/zui/src/models/lake.ts

@@ -1,7 +1,20 @@
 import {DomainModel} from "src/core/domain-model"
 import {LakeAttrs} from "../js/state/Lakes/types"
+import {Client} from "@brimdata/zed-js"
+import Slice from "src/js/state/Lakes"
+import LakeStatuses from "src/js/state/LakeStatuses"
+import {LakeStatus} from "src/js/state/LakeStatuses/types"
+import {FeatureDetector} from "./lake/feature-detector"
+
+type LakeModelAttrs = LakeAttrs & {status: LakeStatus}
+
+export class Lake extends DomainModel<LakeModelAttrs> {
+  static find(id: string) {
+    const attrs = this.select(Slice.id(id))
+    const status = this.select(LakeStatuses.get(id))
+    return new Lake({...attrs, status})
+  }
 
-export class Lake extends DomainModel<LakeAttrs> {
   getAddress(): string {
     return this.attrs.port
       ? [this.attrs.host, this.attrs.port].join(":")
@@ -39,4 +52,37 @@ export class Lake extends DomainModel<LakeAttrs> {
   get version() {
     return this.attrs.version
   }
+
+  get client() {
+    return new Client(this.getAddress())
+  }
+
+  get features() {
+    return this.attrs.features ?? ({} as any)
+  }
+
+  async sync() {
+    // Also authenticate (later)
+    // Also check status (later)
+    const detector = new FeatureDetector(this)
+    const features = await detector.detect()
+    this.update({features})
+  }
+
+  update(attrs: Partial<LakeModelAttrs>) {
+    this.attrs = {...this.attrs, ...attrs}
+    this.save()
+  }
+
+  save() {
+    const {status: _, ...attrs} = this.attrs
+    this.dispatch(Slice.add(attrs))
+  }
+
+  isRunning() {
+    return this.client
+      .version()
+      .then(() => true)
+      .catch(() => false)
+  }
 }

apps/zui/src/models/lake/feature-detector.ts

@@ -0,0 +1,21 @@
+import {Lake} from "../lake"
+
+export class FeatureDetector {
+  constructor(public lake: Lake) {}
+
+  async hasDescribe() {
+    try {
+      const resp = await this.lake.client.describeQuery("from :pools")
+      return !resp.error
+    } catch (e) {
+      if (/404/.test(e.message)) return false
+      else throw e
+    }
+  }
+
+  async detect() {
+    return {
+      describe: await this.hasDescribe(),
+    }
+  }
+}

apps/zui/src/views/session-page/handler.ts

@@ -65,6 +65,11 @@ export class SessionPageHandler extends ViewHandler {
     const program = this.select(Current.getQueryText)
     const history = this.select(Current.getHistory)
 
+    if (!Active.lake.features.describe) {
+      this.dispatch(QueryInfo.merge({isParsed: true}))
+      return
+    }
+
     fetchQueryInfo(program).then((info) => {
       this.dispatch(QueryInfo.set({isParsed: true, ...info}))
       const poolName = this.select(QueryInfo.getPoolName)

packages/zed-js/src/client/base-client.ts

@@ -52,22 +52,24 @@ export abstract class BaseClient {
 
   async describeQuery(
     query: string,
-    pool?: string,
-    options: { signal?: AbortSignal; timeout?: number } = {}
+    options: { signal?: AbortSignal; timeout?: number; pool?: string } = {}
   ) {
-    const head = pool ? { pool } : null;
+    const head = options.pool ? { pool: options.pool } : null;
     const abortCtl = wrapAbort(options.signal);
-    const result = await this.send({
+    const response = await this.request({
       method: 'POST',
       path: `/query/describe`,
       body: JSON.stringify({ query, head }),
       contentType: 'application/json',
       format: 'json',
       signal: abortCtl.signal,
       timeout: options.timeout,
-      dontRejectError: true,
     });
-    return result.json();
+    if (response.ok || response.status === 400) {
+      return response.json();
+    } else {
+      throw createError(await parseContent(response));
+    }
   }
 
   async createPool(name: string, opts: Partial<Types.CreatePoolOpts> = {}) {
@@ -145,18 +147,7 @@ export abstract class BaseClient {
   ${this.baseURL}/query`;
   }
 
-  protected async send(opts: {
-    method: 'GET' | 'POST' | 'DELETE' | 'PUT';
-    path: string;
-    body?: Types.IsoBody;
-    format?: Types.ResponseFormat;
-    signal?: Types.IsoAbortSignal;
-    headers?: Record<string, string>;
-    timeout?: number;
-    contentType?: string;
-    duplex?: 'half';
-    dontRejectError?: boolean;
-  }) {
+  protected request(opts: Types.RequestOpts) {
     const abortCtl = wrapAbort(opts.signal);
     const clearTimer = this.setTimeout(() => {
       abortCtl.abort();
@@ -169,22 +160,21 @@ export abstract class BaseClient {
     if (this.auth) {
       headers['Authorization'] = `Bearer ${this.auth}`;
     }
-
-    const resp = await this.fetch(this.baseURL + opts.path, {
+    const promise = this.fetch(this.baseURL + opts.path, {
       method: opts.method,
       headers: headers,
-      // eslint-disable-next-line
-      // @ts-ignore
       signal: abortCtl.signal,
-      // eslint-disable-next-line
-      // @ts-ignore
       body: opts.body,
-      // eslint-disable-next-line
       // @ts-ignore
       duplex: opts.duplex,
     });
-    clearTimer();
-    if (resp.ok || opts.dontRejectError) {
+    promise.finally(clearTimer);
+    return promise;
+  }
+
+  protected async send(opts: Types.RequestOpts) {
+    const resp = await this.request(opts);
+    if (resp.ok) {
       return resp;
     } else {
       return Promise.reject(createError(await parseContent(resp)));

packages/zed-js/src/client/types.ts

@@ -2,6 +2,18 @@ export type ClientOpts = {
   auth: string | null;
 };
 
+export type RequestOpts = {
+  method: 'GET' | 'POST' | 'DELETE' | 'PUT';
+  path: string;
+  body?: IsoBody;
+  format?: ResponseFormat;
+  signal?: IsoAbortSignal;
+  headers?: Record<string, string>;
+  timeout?: number;
+  contentType?: string;
+  duplex?: 'half';
+};
+
 export type ResponseFormat =
   | 'arrows'
   | 'csv'