Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

28.9 KB
Raw Blame
import { MakeLogicType, actions, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import { objectsEqual } from 'lib/utils/objects'

import { performQuery } from '~/queries/query'
import { setLatestVersionsOnQuery } from '~/queries/schema/query-versions'
import {
    DatabaseSchemaDataWarehouseTable,
    DatabaseSchemaEndpointTable,
    DatabaseSchemaManagedViewTable,
    DatabaseSchemaQuery,
    DatabaseSchemaQueryResponse,
    DatabaseSchemaTable,
    DatabaseSchemaViewTable,
    NodeKind,
} from '~/queries/schema/schema-general'

import { parseEndpointModelName } from 'products/data_modeling/frontend/endpointModelName'

export const MANAGED_TRINO_SCHEMA_SCOPE = 'managed_trino'

export const getDatabaseSchemaQueryScope = (
    scope: string | undefined
): Pick<DatabaseSchemaQuery, 'connectionId' | 'executionTarget'> =>
    scope === MANAGED_TRINO_SCHEMA_SCOPE ? { executionTarget: 'managed_trino' } : { connectionId: scope }

const toMapByName = <T extends { name: string }>(items: T[]): Record<string, T> =>
    items.reduce(
        (acc, cur) => {
            acc[cur.name] = cur
            return acc
        },
        {} as Record<string, T>
    )

const toMapById = <T extends { id: string }>(items: T[]): Record<string, T> =>
    items.reduce(
        (acc, cur) => {
            acc[cur.id] = cur
            return acc
        },
        {} as Record<string, T>
    )

export type TableFieldsStatus = Record<string, 'loading' | 'loaded' | 'error' | 'missing'>

let inFlightDatabaseLoadKey: string | null = null
let inFlightDatabaseLoadPromise: Promise<Required<DatabaseSchemaQueryResponse> | null> | null = null
let inFlightDatabaseLoadIsShallow = false

// Monotonic epoch advanced only when a load issues a fresh request. A newer load (e.g. one
// triggered by a schema mutation via refreshDatabaseSchema) supersedes older in-flight ones, so a
// slow or out-of-order response can never overwrite a fresher schema. Piggybacking loads adopt the
// in-flight request's epoch rather than advancing it, so they never make the original fetcher look
// superseded.
let latestDatabaseLoadEpoch = 0
let inFlightDatabaseLoadEpoch = 0

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface databaseTableListLogicValues {
    allPosthogTables: DatabaseSchemaTable[]
    allTables: DatabaseSchemaTable[]
    allTablesMap: Record<string, DatabaseSchemaTable>
    connectionId: string | null
    dataWarehouseTables: DatabaseSchemaDataWarehouseTable[]
    dataWarehouseTablesMap: Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable>
    dataWarehouseTablesMapById: Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable>
    database: Required<DatabaseSchemaQueryResponse> | null
    databaseFieldsComplete: boolean
    databaseLoadError: string | null
    databaseLoading: boolean
    endpointTables: DatabaseSchemaEndpointTable[]
    externalDataSourceTables: DatabaseSchemaDataWarehouseTable[]
    filteredTables: DatabaseSchemaTable[]
    latestEndpointTables: DatabaseSchemaEndpointTable[]
    managedViews: DatabaseSchemaManagedViewTable[]
    posthogTables: DatabaseSchemaTable[]
    posthogTablesMap: Record<string, DatabaseSchemaTable>
    searchTerm: string
    systemTables: DatabaseSchemaTable[]
    systemTablesMap: Record<string, DatabaseSchemaTable>
    tableFieldsStatus: TableFieldsStatus
    views: DatabaseSchemaViewTable[]
    viewsMap: Record<string, DatabaseSchemaEndpointTable | DatabaseSchemaManagedViewTable | DatabaseSchemaViewTable>
    viewsMapById: Record<string, DatabaseSchemaEndpointTable | DatabaseSchemaManagedViewTable | DatabaseSchemaViewTable>
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface databaseTableListLogicActions {
    ensureAllTableFields: () => {
        value: true
    }
    hydrateTableFields: (tableNames: string[]) => {
        tableNames: string[]
    }
    hydrateTableFieldsFailure: (tableNames: string[]) => {
        tableNames: string[]
    }
    hydrateTableFieldsStart: (tableNames: string[]) => {
        tableNames: string[]
    }
    hydrateTableFieldsSuccess: (
        tableNames: string[],
        tables: Record<string, DatabaseSchemaTable>
    ) => {
        tableNames: string[]
        tables: Record<string, DatabaseSchemaTable>
    }
    loadDatabase: ({ force, shallow }?: { force?: boolean; shallow?: boolean }) => {
        force?: boolean
        shallow?: boolean
    }
    loadDatabaseFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadDatabaseSuccess: (
        database: Required<DatabaseSchemaQueryResponse> | null,
        payload?: {
            force?: boolean
            shallow?: boolean
        }
    ) => {
        database: Required<DatabaseSchemaQueryResponse> | null
        payload?: {
            force?: boolean
            shallow?: boolean
        }
    }
    refreshDatabaseSchema: () => {
        value: true
    }
    resetConnectionScope: () => {
        value: true
    }
    setConnection: (connectionId: string | null) => {
        connectionId: string | null
    }
    setDatabaseFieldsComplete: (complete: boolean) => {
        complete: boolean
    }
    setSearchTerm: (searchTerm: string) => {
        searchTerm: string
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface databaseTableListLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        allPosthogTables: (allTables: DatabaseSchemaTable[]) => DatabaseSchemaTable[]
        filteredTables: (allTables: DatabaseSchemaTable[], searchTerm: string) => DatabaseSchemaTable[]
        allTables: (
            database: Required<DatabaseSchemaQueryResponse> | null,
            databaseLoading: boolean
        ) => DatabaseSchemaTable[]
        allTablesMap: (allTables: DatabaseSchemaTable[]) => Record<string, DatabaseSchemaTable>
        posthogTables: (allPosthogTables: DatabaseSchemaTable[], connectionId: string | null) => DatabaseSchemaTable[]
        posthogTablesMap: (posthogTables: DatabaseSchemaTable[]) => Record<string, DatabaseSchemaTable>
        systemTables: (allTables: DatabaseSchemaTable[], connectionId: string | null) => DatabaseSchemaTable[]
        systemTablesMap: (systemTables: DatabaseSchemaTable[]) => Record<string, DatabaseSchemaTable>
        dataWarehouseTables: (allTables: DatabaseSchemaTable[]) => DatabaseSchemaDataWarehouseTable[]
        externalDataSourceTables: (
            dataWarehouseTables: DatabaseSchemaDataWarehouseTable[]
        ) => DatabaseSchemaDataWarehouseTable[]
        dataWarehouseTablesMap: (
            dataWarehouseTables: DatabaseSchemaDataWarehouseTable[],
            views: DatabaseSchemaViewTable[]
        ) => Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable>
        dataWarehouseTablesMapById: (
            dataWarehouseTables: DatabaseSchemaDataWarehouseTable[],
            views: DatabaseSchemaViewTable[]
        ) => Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable>
        views: (allTables: DatabaseSchemaTable[]) => DatabaseSchemaViewTable[]
        managedViews: (allTables: DatabaseSchemaTable[]) => DatabaseSchemaManagedViewTable[]
        endpointTables: (allTables: DatabaseSchemaTable[]) => DatabaseSchemaEndpointTable[]
        latestEndpointTables: (endpointTables: DatabaseSchemaEndpointTable[]) => DatabaseSchemaEndpointTable[]
        viewsMap: (
            views: DatabaseSchemaViewTable[],
            managedViews: DatabaseSchemaManagedViewTable[],
            endpointTables: DatabaseSchemaEndpointTable[]
        ) => Record<string, DatabaseSchemaEndpointTable | DatabaseSchemaManagedViewTable | DatabaseSchemaViewTable>
        viewsMapById: (
            views: DatabaseSchemaViewTable[],
            managedViews: DatabaseSchemaManagedViewTable[],
            endpointTables: DatabaseSchemaEndpointTable[]
        ) => Record<string, DatabaseSchemaEndpointTable | DatabaseSchemaManagedViewTable | DatabaseSchemaViewTable>
    }
}

export type databaseTableListLogicType = MakeLogicType<
    databaseTableListLogicValues,
    databaseTableListLogicActions,
    Record<string, any>,
    databaseTableListLogicMeta
>

export const databaseTableListLogic = kea<databaseTableListLogicType>([
    path(['scenes', 'data-management', 'database', 'databaseTableListLogic']),
    actions({
        setSearchTerm: (searchTerm: string) => ({ searchTerm }),
        setConnection: (connectionId: string | null) => ({ connectionId }),
        refreshDatabaseSchema: true,
        // Drop any direct-connection scope and go back to the project's own catalog. This logic is
        // shared and outlives the SQL editor, so without an explicit reset every other consumer
        // (sources list, taxonomic filters, joins) keeps seeing the connection's tables.
        resetConnectionScope: true,
        hydrateTableFields: (tableNames: string[]) => ({ tableNames }),
        hydrateTableFieldsStart: (tableNames: string[]) => ({ tableNames }),
        hydrateTableFieldsSuccess: (tableNames: string[], tables: Record<string, DatabaseSchemaTable>) => ({
            tableNames,
            tables,
        }),
        hydrateTableFieldsFailure: (tableNames: string[]) => ({ tableNames }),
        setDatabaseFieldsComplete: (complete: boolean) => ({ complete }),
        // Upgrade a shallow (table names only) schema to a full one. Consumers that read
        // `fields` across many tables at once (search, join modal, expressions) call this.
        ensureAllTableFields: true,
    }),
    loaders(({ values, actions }) => ({
        database: [
            null as Required<DatabaseSchemaQueryResponse> | null,
            {
                loadDatabase: async ({
                    force,
                    shallow,
                }: {
                    force?: boolean
                    shallow?: boolean
                } = {}): Promise<Required<DatabaseSchemaQueryResponse> | null> => {
                    const requestConnectionId = values.connectionId ?? undefined
                    const requestKey = requestConnectionId ?? '__posthog__'

                    // Non-forced loads may piggyback on an identical in-flight request and adopt its
                    // epoch (they don't start a new generation). A forced refresh always issues a
                    // fresh request so it can never return pre-mutation data (and never waits on a
                    // hung stale request). A full load never piggybacks on a shallow request — it
                    // would come back without any fields.
                    if (
                        !force &&
                        inFlightDatabaseLoadKey === requestKey &&
                        inFlightDatabaseLoadPromise &&
                        (shallow || !inFlightDatabaseLoadIsShallow)
                    ) {
                        const epoch = inFlightDatabaseLoadEpoch
                        const result = await inFlightDatabaseLoadPromise
                        // Reading `values` post-unmount throws kea's path-not-found error.
                        if (!databaseTableListLogic.isMounted()) {
                            return null
                        }
                        if (epoch !== latestDatabaseLoadEpoch) {
                            return values.database
                        }
                        return result
                    }

                    const epoch = ++latestDatabaseLoadEpoch
                    const request = performQuery(
                        setLatestVersionsOnQuery({
                            kind: NodeKind.DatabaseSchemaQuery,
                            ...getDatabaseSchemaQueryScope(requestConnectionId),
                            includeFields: shallow ? false : undefined,
                        }) as DatabaseSchemaQuery
                    )

                    inFlightDatabaseLoadKey = requestKey
                    inFlightDatabaseLoadPromise = request
                    inFlightDatabaseLoadEpoch = epoch
                    inFlightDatabaseLoadIsShallow = !!shallow

                    let database: Required<DatabaseSchemaQueryResponse> | null = null
                    try {
                        database = await request
                    } finally {
                        // Identity check, not key equality: a concurrent forced refresh may have
                        // replaced the in-flight slot with its own request under the same key.
                        if (inFlightDatabaseLoadPromise === request) {
                            inFlightDatabaseLoadKey = null
                            inFlightDatabaseLoadPromise = null
                        }
                    }

                    // Reading `values` post-unmount throws kea's path-not-found error.
                    if (!databaseTableListLogic.isMounted()) {
                        return null
                    }

                    // A newer load or refresh started after us: discard this possibly-stale response
                    // rather than clobbering the fresher schema.
                    if (epoch !== latestDatabaseLoadEpoch) {
                        return values.database
                    }

                    const currentConnectionId = values.connectionId ?? undefined
                    if (currentConnectionId !== requestConnectionId) {
                        return values.database
                    }

                    actions.setDatabaseFieldsComplete(!shallow)
                    return database
                },
            },
        ],
    })),
    reducers({
        searchTerm: ['', { setSearchTerm: (_, { searchTerm }) => searchTerm }],
        database: {
            hydrateTableFieldsSuccess: (state, { tableNames, tables }) => {
                if (!state) {
                    return state
                }
                const nextTables = { ...state.tables, ...tables }
                for (const tableName of tableNames) {
                    if (!(tableName in tables)) {
                        delete nextTables[tableName]
                    }
                }
                return { ...state, tables: nextTables }
            },
        },
        // False while the store only holds a shallow schema (table names and metadata, no fields).
        databaseFieldsComplete: [
            true,
            {
                setDatabaseFieldsComplete: (_, { complete }) => complete,
            },
        ],
        tableFieldsStatus: [
            {} as TableFieldsStatus,
            {
                hydrateTableFieldsStart: (state, { tableNames }) => {
                    const next = { ...state }
                    for (const name of tableNames) {
                        next[name] = 'loading'
                    }
                    return next
                },
                hydrateTableFieldsSuccess: (state, { tableNames, tables }) => {
                    const next = { ...state }
                    for (const name of tableNames) {
                        next[name] = name in tables ? 'loaded' : 'missing'
                    }
                    return next
                },
                hydrateTableFieldsFailure: (state, { tableNames }) => {
                    const next = { ...state }
                    for (const name of tableNames) {
                        next[name] = 'error'
                    }
                    return next
                },
                // Any full or shallow reload replaces `database.tables` wholesale, so per-table
                // hydration state no longer describes the store.
                loadDatabaseSuccess: () => ({}),
                loadDatabaseFailure: () => ({}),
                setConnection: () => ({}),
                resetConnectionScope: () => ({}),
            },
        ],
        // Without this the logic settles on `database: null, databaseLoading: false` after a failed
        // load, which every consumer reads as "loaded, and the project has no tables".
        databaseLoadError: [
            null as string | null,
            {
                loadDatabase: () => null,
                loadDatabaseSuccess: () => null,
                loadDatabaseFailure: (_, { error }) => error || 'Unknown error',
            },
        ],
        connectionId: [
            null as string | null,
            { setConnection: (_, { connectionId }) => connectionId, resetConnectionScope: () => null },
        ],
    }),
    selectors({
        allPosthogTables: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): DatabaseSchemaTable[] => {
                return allTables.filter((n) => n.type === 'posthog')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        filteredTables: [
            (s) => [s.allTables, s.searchTerm],
            (allTables: DatabaseSchemaTable[], searchTerm: string): DatabaseSchemaTable[] => {
                return allTables
                    .filter(({ name }) => name.toLowerCase().includes(searchTerm.toLowerCase()))
                    .sort((a, b) => a.name.localeCompare(b.name))
            },
            { resultEqualityCheck: objectsEqual },
        ],
        allTables: [
            (s) => [s.database, s.databaseLoading],
            (
                database: Required<DatabaseSchemaQueryResponse> | null,
                databaseLoading: boolean
            ): DatabaseSchemaTable[] => {
                if (databaseLoading || !database || !database.tables) {
                    return []
                }

                return Object.values(database.tables)
            },
            { resultEqualityCheck: objectsEqual },
        ],
        allTablesMap: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): Record<string, DatabaseSchemaTable> =>
                toMapByName(allTables.filter((t) => t.type !== 'endpoint')),
            { resultEqualityCheck: objectsEqual },
        ],
        posthogTables: [
            (s) => [s.allPosthogTables, s.connectionId],
            (allPosthogTables: DatabaseSchemaTable[], connectionId: string | null): DatabaseSchemaTable[] => {
                if (connectionId) {
                    return []
                }
                const visiblePosthogTableNames = new Set(['events', 'groups', 'persons', 'sessions'])
                return allPosthogTables.filter((table) => visiblePosthogTableNames.has(table.name))
            },
            { resultEqualityCheck: objectsEqual },
        ],
        posthogTablesMap: [
            (s) => [s.posthogTables],
            (posthogTables: DatabaseSchemaTable[]): Record<string, DatabaseSchemaTable> => toMapByName(posthogTables),
            { resultEqualityCheck: objectsEqual },
        ],
        systemTables: [
            (s) => [s.allTables, s.connectionId],
            (allTables: DatabaseSchemaTable[], connectionId: string | null): DatabaseSchemaTable[] => {
                if (connectionId) {
                    return []
                }
                return allTables.filter((n) => n.type === 'system')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        systemTablesMap: [
            (s) => [s.systemTables],
            (systemTables: DatabaseSchemaTable[]): Record<string, DatabaseSchemaTable> => toMapByName(systemTables),
            { resultEqualityCheck: objectsEqual },
        ],
        dataWarehouseTables: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): DatabaseSchemaDataWarehouseTable[] => {
                return allTables.filter((n): n is DatabaseSchemaDataWarehouseTable => n.type === 'data_warehouse')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        // Tables synced from an external data source (Stripe, Postgres, etc). Excludes views/saved
        // queries and self-managed S3 tables — only these can trigger CDP from a warehouse sync.
        externalDataSourceTables: [
            (s) => [s.dataWarehouseTables],
            (dataWarehouseTables: DatabaseSchemaDataWarehouseTable[]): DatabaseSchemaDataWarehouseTable[] => {
                return dataWarehouseTables.filter((table) => table.source != null)
            },
            { resultEqualityCheck: objectsEqual },
        ],
        dataWarehouseTablesMap: [
            (s) => [s.dataWarehouseTables, s.views],
            (
                dataWarehouseTables: DatabaseSchemaDataWarehouseTable[],
                views: DatabaseSchemaViewTable[]
            ): Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable> =>
                toMapByName([...dataWarehouseTables, ...views]),
            { resultEqualityCheck: objectsEqual },
        ],
        dataWarehouseTablesMapById: [
            (s) => [s.dataWarehouseTables, s.views],
            (
                dataWarehouseTables: DatabaseSchemaDataWarehouseTable[],
                views: DatabaseSchemaViewTable[]
            ): Record<string, DatabaseSchemaDataWarehouseTable | DatabaseSchemaViewTable> =>
                toMapById([...dataWarehouseTables, ...views]),
            { resultEqualityCheck: objectsEqual },
        ],
        views: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): DatabaseSchemaViewTable[] => {
                return allTables.filter((n): n is DatabaseSchemaViewTable => n.type === 'view')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        managedViews: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): DatabaseSchemaManagedViewTable[] => {
                return allTables.filter((n): n is DatabaseSchemaManagedViewTable => n.type === 'managed_view')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        endpointTables: [
            (s) => [s.allTables],
            (allTables: DatabaseSchemaTable[]): DatabaseSchemaEndpointTable[] => {
                return allTables.filter((n): n is DatabaseSchemaEndpointTable => n.type === 'endpoint')
            },
            { resultEqualityCheck: objectsEqual },
        ],
        latestEndpointTables: [
            (s) => [s.endpointTables],
            (endpointTables: DatabaseSchemaEndpointTable[]): DatabaseSchemaEndpointTable[] => {
                const grouped: Record<string, { table: DatabaseSchemaEndpointTable; version: number }> = {}
                for (const table of endpointTables) {
                    const parsed = parseEndpointModelName(table.name)
                    if (!parsed) {
                        continue
                    }
                    const existing = grouped[parsed.endpointName]
                    if (!existing || parsed.version > existing.version) {
                        grouped[parsed.endpointName] = { table, version: parsed.version }
                    }
                }
                return Object.values(grouped).map(({ table }) => table)
            },
            { resultEqualityCheck: objectsEqual },
        ],
        viewsMap: [
            (s) => [s.views, s.managedViews, s.endpointTables],
            (
                views: DatabaseSchemaViewTable[],
                managedViews: DatabaseSchemaManagedViewTable[],
                endpointTables: DatabaseSchemaEndpointTable[]
            ): Record<string, DatabaseSchemaViewTable | DatabaseSchemaManagedViewTable | DatabaseSchemaEndpointTable> =>
                toMapByName([...views, ...managedViews, ...endpointTables]),
            { resultEqualityCheck: objectsEqual },
        ],
        viewsMapById: [
            (s) => [s.views, s.managedViews, s.endpointTables],
            (
                views: DatabaseSchemaViewTable[],
                managedViews: DatabaseSchemaManagedViewTable[],
                endpointTables: DatabaseSchemaEndpointTable[]
            ): Record<string, DatabaseSchemaViewTable | DatabaseSchemaManagedViewTable | DatabaseSchemaEndpointTable> =>
                toMapById([...views, ...managedViews, ...endpointTables]),
            { resultEqualityCheck: objectsEqual },
        ],
    }),
    listeners(({ actions, asyncActions, values, cache }) => ({
        refreshDatabaseSchema: async (_, breakpoint) => {
            const connectionId = values.connectionId
            const tableNames = Object.keys(values.database?.tables ?? {}).filter(
                (name) => values.tableFieldsStatus[name] === 'loaded' || values.tableFieldsStatus[name] === 'loading'
            )
            await asyncActions.loadDatabase({ force: true, shallow: !values.databaseFieldsComplete })
            breakpoint()
            if (values.connectionId === connectionId) {
                actions.hydrateTableFields(tableNames)
            }
        },
        loadDatabaseSuccess: () => {
            if (cache.allTableFieldsRequested && values.database) {
                actions.ensureAllTableFields()
            }
        },
        hydrateTableFields: async ({ tableNames }) => {
            const requestConnectionId = values.connectionId ?? undefined
            const tables = values.database?.tables ?? {}
            const toLoad = tableNames.filter((name) => {
                const status = values.tableFieldsStatus[name]
                if (status === 'loading' || status === 'loaded' || status === 'missing') {
                    return false
                }
                const table = tables[name]
                // Unknown tables can't be hydrated; tables with fields already are.
                return !!table && Object.keys(table.fields).length === 0
            })
            if (values.databaseFieldsComplete || toLoad.length === 0) {
                return
            }

            const epoch = latestDatabaseLoadEpoch
            actions.hydrateTableFieldsStart(toLoad)
            try {
                const response = await performQuery(
                    setLatestVersionsOnQuery({
                        kind: NodeKind.DatabaseSchemaQuery,
                        ...getDatabaseSchemaQueryScope(requestConnectionId),
                        tables: toLoad,
                    }) as DatabaseSchemaQuery
                )
                if (!databaseTableListLogic.isMounted()) {
                    return
                }
                // A newer full/shallow load replaced the store while we were fetching — its tables
                // (and any statuses) supersede this response.
                if (epoch !== latestDatabaseLoadEpoch || (values.connectionId ?? undefined) !== requestConnectionId) {
                    return
                }
                actions.hydrateTableFieldsSuccess(toLoad, response.tables ?? {})
                // Once every table's fields are in the store, it's equivalent to a full load.
                const tablesNow = values.database?.tables ?? {}
                const statusNow = values.tableFieldsStatus
                const allLoaded = Object.values(tablesNow).every(
                    (table) =>
                        Object.keys(table.fields).length > 0 ||
                        statusNow[table.name] === 'loaded' ||
                        statusNow[table.name] === 'missing'
                )
                if (allLoaded) {
                    actions.setDatabaseFieldsComplete(true)
                }
            } catch {
                if (!databaseTableListLogic.isMounted()) {
                    return
                }
                // Same staleness guard as the success path: a rejection from a superseded request
                // must not stamp errors onto the schema that replaced it.
                if (epoch !== latestDatabaseLoadEpoch || (values.connectionId ?? undefined) !== requestConnectionId) {
                    return
                }
                actions.hydrateTableFieldsFailure(toLoad)
            }
        },
        ensureAllTableFields: () => {
            cache.allTableFieldsRequested = true
            if (values.databaseFieldsComplete && values.database) {
                return
            }
            // A full (non-shallow) load is already in flight and will land complete fields.
            if (values.databaseLoading && !inFlightDatabaseLoadIsShallow) {
                return
            }
            const tables = values.database?.tables
            if (tables && Object.keys(tables).length > 0) {
                // Upgrade in place: hydrating every table merges fields into the store without
                // flipping `databaseLoading`, so consumers keep rendering the shallow schema
                // meanwhile. Tables already loading/loaded are skipped, errored ones retried.
                actions.hydrateTableFields(Object.keys(tables))
                return
            }
            // Nothing loaded yet. A shallow request may be in flight under the same key; force a
            // fresh full request rather than piggybacking on it.
            actions.loadDatabase({ force: inFlightDatabaseLoadIsShallow && !!inFlightDatabaseLoadPromise })
        },
        // Reload immediately: the cached `database` still holds the connection's schema, and
        // consumers that only load when `database` is empty would otherwise never refetch it.
        resetConnectionScope: () => {
            actions.loadDatabase()
        },
    })),
])