: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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()
},
})),
])