Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import {
type AnyVariables,
type Client,
type CombinedError,
createRequest,
type OperationContext,
type OperationResult,
type OperationResultSource,
} from '@urql/core';
import { onEnd, pipe, type Subscription, subscribe } from 'wonka';
import { liveQueryData } from '../graphql-cache/exchange/live-query';
import type { ObserverEndReason, UrqlObserver } from './observer';
import {
createReactiveSelection,
type ReactiveSelection,
} from './reactive-selection';
import type {
UrqlQueryOptions,
UrqlQueryRefetchOptions,
UrqlQueryResult,
} from './types';
import { getQueryStatus, ObserverResult, toCombinedError } from './utils';
type PendingRefetch<QueryData, Variables extends AnyVariables, Data> = {
resolve: (result: UrqlQueryResult<Data, Variables, QueryData>) => void;
reject: (error: unknown) => void;
throwOnError: boolean;
};
type QueryExecution<QueryData, Variables extends AnyVariables, Data> = {
options: UrqlQueryOptions<QueryData, Variables, Data>;
source: OperationResultSource<OperationResult<QueryData, Variables>>;
subscription?: Subscription;
pending?: PendingRefetch<QueryData, Variables, Data>;
lastError?: CombinedError;
};
type QueryObserverState<QueryData, Variables extends AnyVariables, Data> = {
data: Data | undefined;
error: CombinedError | null;
fetching: boolean;
stale: boolean;
hasNext: boolean;
operation: OperationResult<QueryData, Variables>['operation'] | undefined;
extensions: Record<string, unknown> | undefined;
enabled: boolean;
fetched: boolean;
};
/** Observer for one live urql query source. */
export class QueryObserver<
QueryData,
Variables extends AnyVariables,
Data = QueryData,
> implements
UrqlObserver<
UrqlQueryOptions<QueryData, Variables, Data>,
UrqlQueryResult<Data, Variables, QueryData>
>
{
private client: Client;
private options: UrqlQueryOptions<QueryData, Variables, Data>;
private execution: QueryExecution<QueryData, Variables, Data> | undefined;
// Distinguishes a new query/variables pair from a same-request refetch when
// keepPreviousData is disabled. Client changes create a new observer.
private lastRequestKey: number | undefined;
private state: QueryObserverState<QueryData, Variables, Data> = {
data: undefined,
error: null,
fetching: false,
stale: false,
hasNext: false,
operation: undefined,
extensions: undefined,
enabled: true,
fetched: false,
};
private readonly result = new ObserverResult(() => this.getCurrentResult());
private destroyed = false;
private selection?: ReactiveSelection<Data>;
private selectionInput?: QueryData;
private select?: (data: QueryData) => Data;
private selectionNetworkError: CombinedError | null = null;
private clearSelection(): void {
this.selection?.dispose();
this.selection = undefined;
this.selectionInput = undefined;
this.select = undefined;
}
constructor(
client: Client,
options: UrqlQueryOptions<QueryData, Variables, Data>,
executeImmediately = true
) {
this.client = client;
this.options = options;
if (executeImmediately) {
this.setOptions(options, client);
} else {
this.setState({ enabled: options.enabled !== false });
}
}
getCurrentResult(): UrqlQueryResult<Data, Variables, QueryData> {
const status = getQueryStatus(this.state.error, this.state.fetched);
const isFetching =
this.state.fetching || this.state.stale || this.state.hasNext;
return {
data: this.state.data,
error: this.state.error,
fetching: this.state.fetching,
status,
fetchStatus: isFetching ? 'fetching' : 'idle',
isPending: status === 'pending',
isLoading: status === 'pending' && isFetching,
isInitialLoading: status === 'pending' && isFetching,
isFetching,
isRefetching: status !== 'pending' && isFetching,
isSuccess: status === 'success',
isError: status === 'error',
isEnabled: this.state.enabled,
isFetched: this.state.fetched,
stale: this.state.stale,
hasNext: this.state.hasNext,
operation: this.state.operation,
extensions: this.state.extensions,
refetch: this.refetch,
};
}
setReference(result: UrqlQueryResult<Data, Variables, QueryData>): void {
this.result.setReference(result);
}
setOptions(
options: UrqlQueryOptions<QueryData, Variables, Data>,
client: Client
): void {
if (this.destroyed) return;
this.options = options;
this.client = client;
if (options.enabled === false) {
if (this.execution) {
this.onEnd(this.execution, 'cancelled');
}
this.setState({
enabled: false,
fetching: false,
stale: false,
hasNext: false,
});
this.result.notify();
return;
}
this.execute(options, client);
}
subscribe(
listener: (result: UrqlQueryResult<Data, Variables, QueryData>) => void
): () => void {
return this.result.subscribe(listener);
}
destroy(): void {
if (this.destroyed) return;
this.destroyed = true;
this.clearSelection();
if (this.execution) {
this.onEnd(this.execution, 'cancelled');
}
this.result.clear();
}
readonly refetch = (
refetchOptions: UrqlQueryRefetchOptions = {}
): Promise<UrqlQueryResult<Data, Variables, QueryData>> => {
if (this.destroyed) {
return Promise.resolve(this.result.getActionResult());
}
if (
this.options.enabled === false &&
this.options.variables === undefined
) {
return Promise.resolve(this.result.getActionResult());
}
return new Promise((resolve, reject) => {
this.execute(this.options, this.client, refetchOptions, {
resolve,
reject,
throwOnError: refetchOptions.throwOnError === true,
});
});
};
private execute(
options: UrqlQueryOptions<QueryData, Variables, Data>,
client: Client,
refetchOptions?: UrqlQueryRefetchOptions,
pending?: PendingRefetch<QueryData, Variables, Data>
): void {
if (this.execution) {
this.onEnd(this.execution, 'cancelled');
}
let execution: QueryExecution<QueryData, Variables, Data> | undefined;
try {
const variables = options.variables as Variables;
const request = createRequest<QueryData, Variables>(
options.query,
variables
);
const context: Partial<OperationContext> = {
requestPolicy: options.requestPolicy,
...options.context,
...refetchOptions?.context,
...(refetchOptions?.requestPolicy
? { requestPolicy: refetchOptions.requestPolicy }
: {}),
};
const requestChanged =
this.lastRequestKey !== undefined &&
this.lastRequestKey !== request.key;
this.lastRequestKey = request.key;
if (options.keepPreviousData === false && requestChanged) {
this.setState({
data: undefined,
error: null,
operation: undefined,
extensions: undefined,
fetched: false,
});
}
const currentExecution: QueryExecution<QueryData, Variables, Data> = {
options,
source: client.executeQuery<QueryData, Variables>(request, context),
pending,
};
execution = currentExecution;
this.execution = currentExecution;
this.setState({
enabled: options.enabled !== false,
fetching: true,
stale: false,
hasNext: false,
});
this.result.notify();
const subscription = pipe(
currentExecution.source,
onEnd(() => this.onEnd(currentExecution, 'completed')),
subscribe((nextResult) =>
this.handleResult(currentExecution, nextResult)
)
);
if (this.execution === currentExecution) {
currentExecution.subscription = subscription;
} else {
subscription.unsubscribe();
}
} catch (cause) {
if (execution && this.execution === execution) {
this.execution = undefined;
execution.subscription?.unsubscribe();
}
const error = toCombinedError(cause);
this.setState({
error,
enabled: options.enabled !== false,
fetching: false,
stale: false,
hasNext: false,
fetched: true,
});
if (pending?.throwOnError) pending.reject(error);
else pending?.resolve(this.result.getActionResult());
this.result.notify();
}
}
private onEnd(
execution: QueryExecution<QueryData, Variables, Data>,
reason: ObserverEndReason
): void {
if (this.execution !== execution) return;
this.execution = undefined;
if (reason === 'cancelled') {
this.clearSelection();
this.settle(execution, reason);
execution.subscription?.unsubscribe();
return;
}
this.setState({
fetching: false,
stale: false,
hasNext: false,
});
this.settle(execution, reason);
this.result.notify();
}
private handleResult(
execution: QueryExecution<QueryData, Variables, Data>,
nextResult: OperationResult<QueryData, Variables>
): void {
if (this.execution !== execution) return;
const stale = nextResult.stale === true;
const hasNext = nextResult.hasNext === true;
let data: Data | undefined;
let error = nextResult.error ?? null;
this.selectionNetworkError = error;
if (nextResult.data != null) {
try {
const queryData = liveQueryData(nextResult) as QueryData;
const select = execution.options.select;
if (select) {
if (
!this.selection ||
this.selectionInput !== queryData ||
this.select !== select
) {
this.clearSelection();
const input = queryData;
this.selectionInput = input;
this.select = select;
this.selection = createReactiveSelection(
() => select(input),
() => {
const selected = this.selection?.current();
if (!selected || this.destroyed) return;
this.setState({
...(selected.data !== undefined
? { data: selected.data }
: {}),
error: selected.error ?? this.selectionNetworkError,
});
this.result.notify();
}
);
}
const selected = this.selection.current();
data = selected.data;
error = selected.error ?? error;
} else {
this.clearSelection();
data = queryData as unknown as Data;
}
} catch (cause) {
error = toCombinedError(cause);
}
}
execution.lastError = error ?? undefined;
this.setState({
...(data !== undefined ? { data } : {}),
error,
fetching: false,
stale,
hasNext,
operation: nextResult.operation,
extensions: nextResult.extensions,
fetched: true,
});
this.result.notify();
if (!stale && !hasNext) {
this.settle(execution, 'completed');
}
try {
execution.options.onResult?.(nextResult);
} catch (cause) {
console.error('urql query result observer failed', cause);
}
}
private settle(
execution: QueryExecution<QueryData, Variables, Data>,
reason: ObserverEndReason
): void {
const pending = execution.pending;
execution.pending = undefined;
if (
reason === 'completed' &&
pending?.throwOnError &&
execution.lastError
) {
pending.reject(execution.lastError);
} else {
pending?.resolve(this.result.getActionResult());
}
}
private setState(
nextState: Partial<QueryObserverState<QueryData, Variables, Data>>
): void {
this.state = { ...this.state, ...nextState };
}
}
/** Creates an observer for {@link createUrqlQuery}. */
export function createQueryObserver<
QueryData,
Variables extends AnyVariables,
Data = QueryData,
>(
client: Client,
options: UrqlQueryOptions<QueryData, Variables, Data>
): QueryObserver<QueryData, Variables, Data> {
return new QueryObserver(client, options);
}