mainStore.ts

import {defineStore} from 'pinia'
import {DBMetaInfoResponse, keepAlive, KeepAliveResponse, TableIdentifier, useAPI} from "@/services/api";
import {computed, Ref, ref, shallowReactive} from "vue";

export type APIStatus = "connecting" | "disconnected" | KeepAliveResponse

export const useMainStore = defineStore('main', () => {
  const sessionId = ref(null as string)
  const dbUrl = ref(null as string)
  const originalDBSchema = ref(null as DBMetaInfoResponse)
  const virtualDBSchema = ref(null as DBMetaInfoResponse)
  const dbSchemas = shallowReactive({"original": originalDBSchema, "virtual": virtualDBSchema} as {
    [source: string]: Ref<DBMetaInfoResponse>
  })

  const api = useAPI()

  const apiStatus = ref<APIStatus>("connecting")
  testAPI() // ASYNC call!

  const sessionCreated = computed(() => sessionId.value != null)
  const sessionReady = computed(() => sessionCreated.value && (dbUrl.value != null))
  const schemaReady = computed(() => sessionReady.value && (originalDBSchema.value != null))

  async function testAPI() {
    if (apiStatus.value === "disconnected")
      apiStatus.value = "connecting"
    const r = await keepAlive()
    if (r?.data) {
      if (r.data.session_status !== "session valid") reset()
      apiStatus.value = r.data
    } else {
      reset()
      apiStatus.value = "disconnected"
    }
    return apiStatus.value
  }

  function reset() {
    sessionId.value = null
    dbUrl.value = null
    originalDBSchema.value = null
    virtualDBSchema.value = null
  }

  async function startSession() {
    const r = await api.startSession()
    if (r) {
      sessionId.value = r.data.session_id
      return true
    } else return false
  }

  async function stopSession() {
    await api.stopSession().finally(reset);
  }

  async function testDBConn() {
    const r = await api.testDBConn()
    if (r?.data?.db_url)
      dbUrl.value = r.data.db_url
    else
      dbUrl.value = null
  }

  async function retrieveAndStoreDBInfo() {
    const [r1, r2] = await Promise.all([api.testDBConn(), api.getDBSchema()]) //.then(res => this.dbUrl = res.data.db_url), api.getDBSchema()
    if (r1?.data)
      dbUrl.value = r1.data.db_url
    if (r2?.data)
      originalDBSchema.value = r2.data
  }

  function clearDBInfos() {
    originalDBSchema.value = null
    virtualDBSchema.value = null
  }

  async function reloadVirtualDB() {
    await retrieveAndStoreVirtualDBInfo()
  }

  function getCachedTableMeta(tableIdentifier: TableIdentifier) {
    if (!!tableIdentifier) {
      const tablesInSchema = dbSchemas[tableIdentifier.source]?.value?.db_structure[tableIdentifier.schema]
      return tablesInSchema?.[tableIdentifier.name]
    }
  }

  async function retrieveAndStoreVirtualDBInfo() {
    const r = await api.getDBSchema({source: 'virtual'});

    if (r?.data) {
      virtualDBSchema.value = r.data
    }
  }

  async function getTableMeta(tableIdentifier: TableIdentifier, useCache = false) {
    if (!!tableIdentifier) {
      const r = await api.getTableSchema({
        source: tableIdentifier.source,
        schema: tableIdentifier.schema,
        table: tableIdentifier.name
      })
      return r?.data
    }
  }

  async function getTableProbe(tableIdentifier: TableIdentifier) {
    if (!!tableIdentifier) {
      const r = await api.probeTable({
        source: tableIdentifier.source,
        schema: tableIdentifier.schema,
        table: tableIdentifier.name
      })
      return r?.data
    }
  }

  function $reset() {
    reset()
  }

  return {
    sessionId,
    originalDBSchema,
    virtualDBSchema,
    dbSchemas,
    dbUrl,
    apiStatus,
    sessionReady,
    sessionCreated,
    schemaReady,
    testAPI,
    startSession,
    stopSession,
    retrieveAndStoreDBInfo,
    testDBConn,
    retrieveAndStoreVirtualDBInfo,
    clearDBInfos,
    reloadVirtualDB,
    getTableProbe,
    getCachedTableMeta,
    getTableMeta,
    $reset
  }
}, {persist: {pick: ['sessionId', 'dbUrl', 'originalDBSchema', 'virtualDBSchema']}})
// {enabled: true, strategies: [{storage: localStorage, paths: ['sessionId', 'dbUrl']}]}