Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix(databases): trace read causes and refresh failures (#7411)

Wolf Mermelstein37f606475cc6
diff --git a/apps/web/src/features/block-database/context/table-source.ts b/apps/web/src/features/block-database/context/table-source.ts
index cf015e8102..415c1025ea 100644
--- a/apps/web/src/features/block-database/context/table-source.ts
+++ b/apps/web/src/features/block-database/context/table-source.ts
@@ -36,7 +36,9 @@ export type DatabaseRowsSource = {
loading: Accessor<boolean>;
refreshing: Accessor<boolean>;
error: Accessor<DatabaseReadFailure | undefined>;
- refresh(): ResultAsync<void, DatabaseReadFailure>;
+ refresh(
+ reason?: 'after-write' | 'refresh'
+ ): ResultAsync<void, DatabaseReadFailure>;
/**
* `inferenceBaseVersion` is the table version a new column's type is
* settled against from its first value; ops themselves carry no version.
diff --git a/apps/web/src/features/block-database/primitives/table-controller.ts b/apps/web/src/features/block-database/primitives/table-controller.ts
index 459bcf6a81..697dbde945 100644
--- a/apps/web/src/features/block-database/primitives/table-controller.ts
+++ b/apps/web/src/features/block-database/primitives/table-controller.ts
@@ -159,7 +159,7 @@ export function createTableController(
if (written.isErr()) {
const failure = written.error;
const outcomeUnknown = failure.kind === 'outcome-unknown';
- if (outcomeUnknown && (await source.refresh()).isErr())
+ if (outcomeUnknown && (await source.refresh('after-write')).isErr())
setRefreshWarning(true);
const failed: FailedWrite = {
mutation,
@@ -216,7 +216,9 @@ export function createTableController(
});
// A failed refresh cannot turn a committed write into a failed edit.
span.event('committed_state_applied');
- await span.span('database.rows.refresh', async () => refresh());
+ await span.span('database.rows.refresh', async () =>
+ refresh('after-write')
+ );
span.event('refresh_completed');
return ok(saved);
})
@@ -261,8 +263,8 @@ export function createTableController(
);
}
- async function refresh() {
- const refreshed = await source.refresh();
+ async function refresh(reason: 'after-write' | 'refresh' = 'refresh') {
+ const refreshed = await source.refresh(reason);
setRefreshWarning(refreshed.isErr());
if (refreshed.isOk()) pruneCommitted();
}
@@ -277,7 +279,7 @@ export function createTableController(
return await writes.run(TABLE_WRITES, async () => {
const added = await source.addOption(columnId, label);
// The option is saved even if its subsequent rows refresh fails.
- if (added.isOk()) await refresh();
+ if (added.isOk()) await refresh('after-write');
return added;
});
} finally {
@@ -359,7 +361,7 @@ export function createTableController(
drain: (writes: AcceptedDraftWrites) => Promise<boolean>
) => (disposed ? Promise.resolve(false) : drain({ save })),
retry,
- refresh,
+ refresh: () => refresh(),
addGroup: (
...request: Parameters<typeof addGroup>
): ReturnType<typeof addGroup> =>
diff --git a/apps/web/src/features/block-database/queries/table-rows.ts b/apps/web/src/features/block-database/queries/table-rows.ts
index 15ff2f71f4..d346e29f54 100644
--- a/apps/web/src/features/block-database/queries/table-rows.ts
+++ b/apps/web/src/features/block-database/queries/table-rows.ts
@@ -1,5 +1,6 @@
import { databaseSqlSchema } from '@core/database-sql/catalog';
import type { DatabaseOp } from '@core/database-sql/generated/types';
+import type { DatabaseSqlReadReason } from '@core/database-sql/trace';
import { type ResultError, thrownResultErrorHasCode } from '@core/util/result';
import { Telemetry } from '@macro-inc/observability';
import {
@@ -308,32 +309,42 @@ export function createDatabaseRowsSource(props: {
* Read from the network again; what comes back is at least `version`. A
* read a later one replaced shows nothing, so it leaves the version alone.
*/
- function readAgain(version: number): ResultAsync<void, DatabaseReadFailure> {
+ function readAgain(
+ version: number,
+ reason: DatabaseSqlReadReason
+ ): ResultAsync<void, DatabaseReadFailure> {
return ResultAsync.combine([
- rowsQuery.refresh(),
+ rowsQuery.refresh(reason),
retainedRowIds().length
- ? retainedQuery.refresh()
+ ? retainedQuery.refresh(reason)
: okAsync<DatabaseSqlRun>({ landed: true }),
]).map(([rows, retained]) => {
if (rows.landed && retained.landed)
setReadVersion((previous) => Math.max(previous, version));
});
}
- function refresh(): ResultAsync<void, DatabaseReadFailure> {
- const failed = rowsQuery.error();
- const schema =
- failed && isStaleSchema(failed) ? refreshSchema() : okAsync(undefined);
+ function refresh(
+ reason: 'after-write' | 'refresh' = 'refresh'
+ ): ResultAsync<void, DatabaseReadFailure> {
const span = Telemetry.span('database.rows.read_refresh');
span.setAttr('database.id', props.databaseId);
span.setAttr('database.table_id', tableId);
- const reading = span.run(() =>
- schema.andThen(() => {
+ span.setAttr('database.read_reason', reason);
+ const reading = span.run(() => {
+ const failed = rowsQuery.error();
+ const staleSchema = failed && isStaleSchema(failed);
+ const schema = staleSchema ? refreshSchema() : okAsync(undefined);
+ span.setAttr('database.refresh_schema', Boolean(staleSchema));
+ return schema.andThen(() => {
const table = currentTable();
return table
- ? readAgain(table.table.version)
+ ? readAgain(
+ table.table.version,
+ staleSchema ? 'schema-change' : reason
+ )
: errAsync<void, DatabaseReadFailure>(TABLE_UNAVAILABLE);
- })
- );
+ });
+ });
return reading
.andTee(() => {
span.setAttr('database.outcome', 'success');
@@ -342,15 +353,19 @@ export function createDatabaseRowsSource(props: {
.orTee((failure) => {
span.setAttr('database.outcome', 'error');
span.setAttr('database.error_kind', failure.kind);
- span.error(JSON.stringify(failure));
- Telemetry.warn('database rows could not be refreshed', {
- databaseId: props.databaseId,
- tableId,
- failure: JSON.stringify(failure),
- });
+ span.error(failure.kind);
+ span.run(() =>
+ Telemetry.warn('database rows could not be refreshed', {
+ databaseId: props.databaseId,
+ tableId,
+ reason,
+ failureKind: failure.kind,
+ })
+ );
span.end();
});
}
+
/** Read these rows again by id, through the engine, into the cache the view reads. */
function readRows(rowIds: string[]): ResultAsync<void, DatabaseReadFailure> {
const detail = cachedDetail();
@@ -362,7 +377,8 @@ export function createDatabaseRowsSource(props: {
scope: props.databaseId,
sql: rowsByIdStatement(table.sql_name, rowIds),
},
- props.read
+ props.read,
+ 'websocket'
).map(() => undefined);
}
/** Answer the open reads from the cache rows were read into; at least `version` once they land. */
@@ -384,7 +400,7 @@ export function createDatabaseRowsSource(props: {
props.onTableChanged((version) => {
if (version <= Math.max(readVersion(), writtenVersion)) return;
const target = Math.max(version, currentTable()?.table.version ?? version);
- const fullRead = () => readAgain(target);
+ const fullRead = () => readAgain(target, 'websocket');
refreshInBackground({
// Rows read by id reach the view only through a local cache; without one, read whole.
refresh: () =>
diff --git a/apps/web/src/lib/core/database-sql/driver.ts b/apps/web/src/lib/core/database-sql/driver.ts
index 630da7b834..c6d25a7517 100644
--- a/apps/web/src/lib/core/database-sql/driver.ts
+++ b/apps/web/src/lib/core/database-sql/driver.ts
@@ -14,6 +14,7 @@ import type {
Step,
} from './generated/types';
import {
+ type DatabaseSqlReadContext,
type DatabaseSqlRunTrace,
type DatabaseSqlStepTrace,
traceDatabaseSqlRun,
@@ -176,10 +177,14 @@ export function runDatabaseSql(
{
source,
open = openDatabaseSqlQuery,
- }: { source: RowSource; open?: OpenEngine }
+ context,
+ }: { source: RowSource; open?: OpenEngine; context?: DatabaseSqlReadContext }
): ResultAsync<Outcome, DatabaseSqlFailure> {
- return traceDatabaseSqlRun({ kind: 'sql', sql }, catalog, (trace) =>
- drive(() => open(catalog, sql), source, trace)
+ return traceDatabaseSqlRun(
+ { kind: 'sql', sql },
+ catalog,
+ (trace) => drive(() => open(catalog, sql), source, trace),
+ context
);
}
@@ -190,10 +195,14 @@ export function runDatabaseView(
{
source,
open = openDatabaseViewQuery,
- }: { source: RowSource; open?: OpenView }
+ context,
+ }: { source: RowSource; open?: OpenView; context?: DatabaseSqlReadContext }
): ResultAsync<Outcome, DatabaseSqlFailure> {
- return traceDatabaseSqlRun({ kind: 'view', view }, catalog, (trace) =>
- drive(() => open(catalog, view), source, trace)
+ return traceDatabaseSqlRun(
+ { kind: 'view', view },
+ catalog,
+ (trace) => drive(() => open(catalog, view), source, trace),
+ context
);
}
diff --git a/apps/web/src/lib/core/database-sql/trace.test.ts b/apps/web/src/lib/core/database-sql/trace.test.ts
index 548d9b283a..b54ed8a1bb 100644
--- a/apps/web/src/lib/core/database-sql/trace.test.ts
+++ b/apps/web/src/lib/core/database-sql/trace.test.ts
@@ -1,4 +1,4 @@
-import { ok, okAsync } from 'neverthrow';
+import { errAsync, ok, okAsync } from 'neverthrow';
import { afterEach, describe, expect, it, vi } from 'vitest';
import type { Catalog, Outcome } from './generated/types';
import { traceDatabaseSqlRun } from './trace';
@@ -10,7 +10,10 @@ type RecordedSpan = {
ended: boolean;
};
-const recorded = vi.hoisted(() => ({ roots: [] as RecordedSpan[] }));
+const recorded = vi.hoisted(() => ({
+ roots: [] as RecordedSpan[],
+ warnings: vi.fn(),
+}));
vi.mock('@macro-inc/observability', () => {
const fake = (node: RecordedSpan) => ({
@@ -35,6 +38,7 @@ vi.mock('@macro-inc/observability', () => {
});
return {
Telemetry: {
+ warn: recorded.warnings,
span: (name: string) => {
const root = { name, attributes: {}, children: [], ended: false };
recorded.roots.push(root);
@@ -46,6 +50,7 @@ vi.mock('@macro-inc/observability', () => {
afterEach(() => {
recorded.roots.length = 0;
+ recorded.warnings.mockClear();
vi.restoreAllMocks();
});
@@ -188,4 +193,64 @@ describe('database SQL run traces', () => {
],
]);
});
+ it('logs failed reads with their cause and IDs without SQL or error content', async () => {
+ const result = await traceDatabaseSqlRun(
+ { kind: 'sql', sql: "SELECT 'private cell value' FROM Guests" },
+ catalog,
+ () => errAsync({ kind: 'fetch', message: 'private cell value' }),
+ { reason: 'after-write', scope: 'party', requestPolicy: 'network-only' }
+ );
+ expect(result.isErr()).toBe(true);
+ expect(recorded.roots[0].attributes).toMatchObject({
+ 'database_sql.read_reason': 'after-write',
+ 'database_sql.request_policy': 'network-only',
+ 'database_sql.scope_id': 'party',
+ });
+ expect(recorded.warnings).toHaveBeenCalledWith('database SQL read failed', {
+ 'database_sql.error_kind': 'fetch',
+ 'database_sql.read_reason': 'after-write',
+ 'database_sql.request_policy': 'network-only',
+ 'database_sql.scope_id': 'party',
+ 'database_sql.database_ids': 'party',
+ 'database_sql.table_ids': 'guests',
+ });
+ expect(JSON.stringify(recorded.warnings.mock.calls)).not.toContain(
+ 'private cell value'
+ );
+ expect(recorded.roots[0].ended).toBe(true);
+ });
+
+ it('keeps an expected cache warmup miss out of failure logs', async () => {
+ await traceDatabaseSqlRun(
+ { kind: 'sql', sql: 'SELECT Name FROM Guests' },
+ catalog,
+ () => errAsync({ kind: 'fetch' }),
+ { reason: 'initial', requestPolicy: 'cache-only', reportFailure: false }
+ );
+ expect(recorded.warnings).not.toHaveBeenCalled();
+ expect(recorded.roots[0].ended).toBe(true);
+ });
+ it('records structural engine error codes without the unknown column value', async () => {
+ await traceDatabaseSqlRun(
+ { kind: 'sql', sql: 'SELECT confidential FROM Guests' },
+ catalog,
+ () =>
+ errAsync({
+ kind: 'engine',
+ error: {
+ stage: 'view' as const,
+ kind: 'unknownColumn' as const,
+ column: 'confidential',
+ },
+ }),
+ { reason: 'schema-change', requestPolicy: 'network-only' }
+ );
+ expect(recorded.roots[0].attributes).toMatchObject({
+ 'database_sql.error_stage': 'view',
+ 'database_sql.error_code': 'unknownColumn',
+ });
+ expect(JSON.stringify(recorded.warnings.mock.calls)).not.toContain(
+ 'confidential'
+ );
+ });
});
diff --git a/apps/web/src/lib/core/database-sql/trace.ts b/apps/web/src/lib/core/database-sql/trace.ts
index a6111bbf58..c3ef05fa14 100644
--- a/apps/web/src/lib/core/database-sql/trace.ts
+++ b/apps/web/src/lib/core/database-sql/trace.ts
@@ -11,6 +11,7 @@ import type {
DatabaseView,
Outcome,
Request,
+ RunError,
} from './generated/types';
const PREFIX = '[database-sql]';
@@ -23,6 +24,26 @@ export type DatabaseSqlSubject =
| { kind: 'check'; sql: string }
| { kind: 'view'; view: DatabaseView };
+/** Why the caller is reading; contains no statement or cell content. */
+export type DatabaseSqlReadReason =
+ | 'initial'
+ | 'statement-change'
+ | 'schema-change'
+ | 'refresh'
+ | 'after-write'
+ | 'websocket'
+ | 'cache-change'
+ | 'cache-reconcile'
+ | 'read';
+
+export type DatabaseSqlReadContext = {
+ reason: DatabaseSqlReadReason;
+ scope?: string;
+ requestPolicy: string;
+ /** An initial cache-only miss is expected, not a failed network read. */
+ reportFailure?: boolean;
+};
+
/** What a row source tells a step about the GraphQL request it sends. */
export interface DatabaseSqlStepTrace {
request(document: string, variables: unknown): void;
@@ -119,6 +140,7 @@ function subjectAttributes(span: Span, subject: DatabaseSqlSubject) {
)
.with({ kind: 'view' }, ({ view }) => {
span.setAttr('database_sql.view_id', view.id);
+ span.setAttr('database_sql.table_id', view.tableId);
span.setAttr('database_sql.view_name', view.name);
})
.exhaustive();
@@ -165,14 +187,22 @@ function logStep(step: DatabaseSqlStepRecord, tableNames: Map<string, string>) {
* Run `drive` inside a `database_sql.run` span, giving it a trace whose
* fetches and folds are child spans, then log the run as one group.
*/
-export function traceDatabaseSqlRun<Failure extends { kind: string }>(
+export function traceDatabaseSqlRun<
+ Failure extends { kind: string; error?: RunError },
+>(
subject: DatabaseSqlSubject,
catalog: Catalog,
- drive: (trace: DatabaseSqlRunTrace) => ResultAsync<Outcome, Failure>
+ drive: (trace: DatabaseSqlRunTrace) => ResultAsync<Outcome, Failure>,
+ context?: DatabaseSqlReadContext
): ResultAsync<Outcome, Failure> {
const started = performance.now();
const runSpan = Telemetry.span('database_sql.run');
subjectAttributes(runSpan, subject);
+ if (context) {
+ runSpan.setAttr('database_sql.read_reason', context.reason);
+ runSpan.setAttr('database_sql.request_policy', context.requestPolicy);
+ if (context.scope) runSpan.setAttr('database_sql.scope_id', context.scope);
+ }
runSpan.setAttr(
'database_sql.database_ids',
[...new Set(catalog.tables.map((table) => table.databaseId))].join(',')
@@ -291,8 +321,37 @@ export function traceDatabaseSqlRun<Failure extends { kind: string }>(
);
})
.orTee((failure) => {
+ const engineError = failure.error;
+ const detail = {
+ ...(engineError
+ ? { 'database_sql.error_stage': engineError.stage }
+ : {}),
+ ...(engineError?.stage === 'resolve' || engineError?.stage === 'view'
+ ? { 'database_sql.error_code': engineError.kind }
+ : {}),
+ };
+ for (const [key, value] of Object.entries(detail))
+ runSpan.setAttr(key, value);
runSpan.setAttr('database_sql.error_kind', failure.kind);
runSpan.error(JSON.stringify(failure));
+ // Error messages may contain SQL literals or cell values. The error kind
+ // and target IDs locate the failed trace without exporting that content.
+ if (context && context.reportFailure !== false)
+ runSpan.run(() =>
+ Telemetry.warn('database SQL read failed', {
+ ...detail,
+ 'database_sql.error_kind': failure.kind,
+ 'database_sql.read_reason': context.reason,
+ 'database_sql.request_policy': context.requestPolicy,
+ 'database_sql.scope_id': context.scope ?? '',
+ 'database_sql.database_ids': [
+ ...new Set(catalog.tables.map((table) => table.databaseId)),
+ ].join(','),
+ 'database_sql.table_ids': catalog.tables
+ .map((table) => table.id)
+ .join(','),
+ })
+ );
finish({ error: failure.kind }, failure);
});
}
diff --git a/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts b/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts
index 95a059409d..9b61e6885b 100644
--- a/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts
+++ b/apps/web/src/lib/queries/database-sql/create-database-sql-query.test.ts
@@ -6,6 +6,7 @@ import type {
Schema,
Step,
} from '@core/database-sql/generated/types';
+import * as sqlTrace from '@core/database-sql/trace';
import type { CacheHost } from '@graphql-cache/host/types';
import type {
CacheRevision,
@@ -380,6 +381,7 @@ describe('createDatabaseSqlQuery', () => {
});
it('refreshes from the network, and a failed refresh fails as a fetch and keeps the answer', async () => {
+ const traced = vi.spyOn(sqlTrace, 'traceDatabaseSqlRun');
const policies: string[] = [];
let failing = false;
const exchange: Exchange = () => (incoming) =>
@@ -426,9 +428,9 @@ describe('createDatabaseSqlQuery', () => {
expect(query.outcome()?.rows).toEqual([[{ type: 'text', value: 'Acme' }]])
);
- expect(await query.refresh()).toEqual(ok({ landed: true }));
+ expect(await query.refresh('after-write')).toEqual(ok({ landed: true }));
failing = true;
- expect((await query.refresh())._unsafeUnwrapErr()).toEqual({
+ expect((await query.refresh('after-write'))._unsafeUnwrapErr()).toEqual({
kind: 'fetch',
message: '[Network] offline',
});
@@ -443,6 +445,11 @@ describe('createDatabaseSqlQuery', () => {
message: '[Network] offline',
});
expect(query.outcome()?.rows).toEqual([[{ type: 'text', value: 'Acme' }]]);
+ expect(traced.mock.calls.map((call) => call[3]?.reason)).toEqual([
+ 'initial',
+ 'after-write',
+ 'after-write',
+ ]);
});
it('keeps a refresh from the network when the cache changes while it is in flight', async () => {
diff --git a/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts b/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts
index 3e469cbb25..b69a7e4d87 100644
--- a/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts
+++ b/apps/web/src/lib/queries/database-sql/create-database-sql-query.ts
@@ -19,6 +19,10 @@ import type {
Outcome,
Schema,
} from '@core/database-sql/generated/types';
+import type {
+ DatabaseSqlReadContext,
+ DatabaseSqlReadReason,
+} from '@core/database-sql/trace';
import { buildDatabaseSqlCatalog } from '@core/database-sql/wasm-module';
import { idToDisplayName, idToEmail } from '@core/user/util';
import type { CacheHost } from '@graphql-cache/host/types';
@@ -99,15 +103,18 @@ function runStatement(
catalog: Catalog,
statement: DatabaseSqlStatement,
source: RowSource,
- capabilities: Pick<DatabaseSqlQueryCapabilities, 'open' | 'openView'>
+ capabilities: Pick<DatabaseSqlQueryCapabilities, 'open' | 'openView'>,
+ context: DatabaseSqlReadContext
): ResultAsync<Outcome, DatabaseSqlFailure> {
if (statement.view)
return runDatabaseView(catalog, statement.view, {
source,
+ context,
...(capabilities.openView ? { open: capabilities.openView } : {}),
});
return runDatabaseSql(catalog, statement.sql, {
source,
+ context,
...(capabilities.open ? { open: capabilities.open } : {}),
});
}
@@ -124,7 +131,9 @@ export interface DatabaseSqlQuery {
error: Accessor<DatabaseSqlFailure | undefined>;
loading: Accessor<boolean>;
/** Read the statement's tables from the server again. */
- refresh: () => ResultAsync<DatabaseSqlRun, DatabaseSqlFailure>;
+ refresh: (
+ reason?: DatabaseSqlReadReason
+ ) => ResultAsync<DatabaseSqlRun, DatabaseSqlFailure>;
/** Whether a local cache backs the reads, so rows read into it can answer the statement. */
cached: () => boolean;
/** Answer the statement again from the local cache, as a cache change would, without waiting on one. */
@@ -167,6 +176,7 @@ export function createDatabaseSqlQuery(
current: DatabaseSqlStatement,
requestPolicy: RequestPolicy,
reconcile: boolean,
+ reason: DatabaseSqlReadReason,
options: { reportFailure?: boolean; keepLoading?: boolean } = {}
): ResultAsync<DatabaseSqlRun, DatabaseSqlFailure> => {
const generation = ++latest;
@@ -184,7 +194,13 @@ export function createDatabaseSqlQuery(
people: capabilities.people,
membership: host ? { host, baselines, reconcile } : undefined,
}),
- capabilities
+ capabilities,
+ {
+ reason,
+ scope: current.scope,
+ requestPolicy,
+ reportFailure: options.reportFailure,
+ }
).map((answer): DatabaseSqlRun => {
if (generation !== latest) return { landed: false };
// A cache change that left the answer alone keeps the same outcome.
@@ -223,13 +239,16 @@ export function createDatabaseSqlQuery(
return new ResultAsync(settle());
}
- function openStatement(current: DatabaseSqlStatement): void {
+ function openStatement(
+ current: DatabaseSqlStatement,
+ reason: DatabaseSqlReadReason
+ ): void {
if (!capabilities.cacheHost()) {
- void trackNetwork(run(current, 'cache-and-network', false));
+ void trackNetwork(run(current, 'cache-and-network', false, reason));
return;
}
// Only a complete cached answer is shown. A miss still reads the network.
- const cached = run(current, 'cache-only', false, {
+ const cached = run(current, 'cache-only', false, reason, {
reportFailure: false,
keepLoading: true,
});
@@ -237,13 +256,13 @@ export function createDatabaseSqlQuery(
const reconcile = async () => {
await cached;
if (generation !== latest) return ok({ landed: false });
- return await run(current, 'network-only', false);
+ return await run(current, 'network-only', false, reason);
};
void trackNetwork(new ResultAsync(reconcile()));
}
createEffect(
- on(statement, (current) => {
+ on(statement, (current, previous) => {
baselines = new Map();
latest += 1;
setError(undefined);
@@ -255,7 +274,12 @@ export function createDatabaseSqlQuery(
});
return;
}
- openStatement(current);
+ const reason = !previous
+ ? 'initial'
+ : JSON.stringify(previous.schema) !== JSON.stringify(current.schema)
+ ? 'schema-change'
+ : 'statement-change';
+ openStatement(current, reason);
})
);
@@ -271,7 +295,7 @@ export function createDatabaseSqlQuery(
return;
}
const current = untrack(statement);
- if (current) await run(current, 'cache-first', true);
+ if (current) await run(current, 'cache-first', true, 'cache-change');
})
);
});
@@ -285,16 +309,16 @@ export function createDatabaseSqlQuery(
catalog,
error,
loading,
- refresh: () => {
+ refresh: (reason = 'refresh') => {
const current = untrack(statement);
if (!current) return okAsync({ landed: false });
- return trackNetwork(run(current, 'network-only', false));
+ return trackNetwork(run(current, 'network-only', false, reason));
},
cached: () => capabilities.cacheHost() !== undefined,
answerFromCache: () => {
const current = untrack(statement);
if (!current) return okAsync({ landed: false });
- return run(current, 'cache-first', true);
+ return run(current, 'cache-first', true, 'cache-reconcile');
},
};
}
@@ -309,7 +333,8 @@ export function refreshInBackground(reader: {
/** One read of a statement from the network, for an answer nothing keeps live. */
export function readDatabaseSql(
statement: DatabaseSqlStatement,
- capabilities: DatabaseSqlQueryCapabilities = productionDatabaseSqlCapabilities()
+ capabilities: DatabaseSqlQueryCapabilities = productionDatabaseSqlCapabilities(),
+ reason: DatabaseSqlReadReason = 'read'
): ResultAsync<{ catalog: Catalog; outcome: Outcome }, DatabaseSqlFailure> {
return statementCatalog(statement, capabilities).andThen((catalog) =>
runStatement(
@@ -321,7 +346,8 @@ export function readDatabaseSql(
requestPolicy: 'network-only',
people: capabilities.people,
}),
- capabilities
+ capabilities,
+ { reason, scope: statement.scope, requestPolicy: 'network-only' }
).map((outcome) => ({ catalog, outcome }))
);
}