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 { ListDataSource } from '@app/components/list';
import {
buildFlatSoupRows,
buildGroupedSoupRows,
createSearchState,
createSoupRowStore,
createTagFacetContext,
deduplicateSoupEntities,
isSoupRowVisible,
type SoupGroup,
type SoupRow,
tagFacetReady,
useSearchContext,
} from '@app/features/soup';
import { withEntityNotifications } from '@app/features/soup/entity-notifications';
import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
import {
type EntityData,
getTaskReferencedEntityIds,
isTaskEntity,
type TaskEntityWithProperties,
} from '@entity';
import { SYSTEM_PROPERTY_IDS } from '@property/constants';
import { toPropertyDefinitionDomain } from '@property/utils/transforms';
import { useListPropertiesQuery } from '@queries/properties/definitions';
import { createGroupedSoupQueries } from '@queries/soup/grouped/create-grouped-soup-queries';
import {
type SoupApiItemFilter,
useSoupAstItemsQuery,
} from '@queries/soup/items';
import { mapApiSoupItemToEntity } from '@queries/soup/transform-utils';
import type { TagSetResponse } from '@service-properties/generated/schemas/tagSetResponse';
import { type Accessor, createMemo } from 'solid-js';
import { sortTasks } from '../constants';
import {
type DateBucketBoundaries,
TASK_DUE_DATE_BUCKETS,
taskDueDatePredicate,
} from '../core/task-due-date';
import { isProjectTab } from '../core/task-navigation';
import type { TaskFacetContext } from '../filters/task-facets';
import {
type TaskViewContext,
taskMatchesView,
} from '../filters/task-predicates';
import { createDateBucketBoundariesSignal } from '../primitives/create-date-bucket-boundaries';
import type {
TaskCrmScope,
TaskReferenceScope,
TasksViewState,
} from '../types';
import { createScopedTaskSearch } from './scoped-task-search';
import { buildTaskQuery } from './task-query';
import { buildTaskSearchRequest } from './task-search';
export type TasksDataSourceInput = Pick<
TasksViewState,
| 'tab'
| 'search'
| 'groupBy'
| 'sort'
| 'facets'
| 'dueDate'
| 'savedViewActive'
>;
export type UseTasksDataSourceOptions = {
userId: Accessor<string | undefined>;
tagSets: Accessor<readonly TagSetResponse[]>;
tagSetsReady: Accessor<boolean>;
/** Saved definitions supply stable tag bindings and viewer-relative people. */
facetContext?: Accessor<TaskFacetContext>;
isGroupExpanded: (groupId: string) => boolean;
/** Only tasks whose property references this entity. */
reference?: Accessor<TaskReferenceScope>;
/**
* Only tasks associated with this CRM record. The server resolves the
* membership, so fetched rows are not re-filtered by their properties.
*/
crm?: Accessor<TaskCrmScope>;
enabled?: Accessor<boolean>;
networkPaused?: Accessor<boolean>;
board?: Accessor<boolean>;
calendar?: Accessor<DateBucketBoundaries>;
};
export type TasksDataSourceItem = SoupRow<TaskEntityWithProperties>;
export type TasksDataSource = ListDataSource<TasksDataSourceItem> & {
loadMoreGroup: (groupId: string) => Promise<void>;
/** Uncollapsed rows for alternative layouts; the query owner is shared. */
boardRows?: Accessor<TasksDataSourceItem[]>;
boardSearching?: Accessor<boolean>;
boardLoading?: Accessor<boolean>;
groupError?: (groupId: string) => unknown;
};
type TaskGroupContinuationReader = {
entities: (groupId: string) => TaskEntityWithProperties[];
hasMore: (groupId: string) => boolean;
isLoading: (groupId: string) => boolean;
loadMore: (groupId: string) => Promise<void>;
};
function referencesEntity(
task: TaskEntityWithProperties,
reference: TaskReferenceScope
) {
return getTaskReferencedEntityIds(
task,
reference.propertyDefinitionId
).includes(reference.entityId);
}
/**
* Whether a task known only locally (an optimistic insert) is associated with
* the record through its own property. Mention and contact-company matches
* are known only to the server and arrive with the next fetch.
*/
function namesCrmRecord(task: TaskEntityWithProperties, crm: TaskCrmScope) {
if (crm.type === 'activity') return false;
return getTaskReferencedEntityIds(
task,
crm.type === 'company'
? SYSTEM_PROPERTY_IDS.COMPANIES
: SYSTEM_PROPERTY_IDS.CONTACTS
).includes(crm.id);
}
/** A plain copy of the view's facet store, safe to keep in cached options. */
function copyFacets(
facets: TaskViewContext['facets']
): TaskViewContext['facets'] {
return Object.fromEntries(
Object.entries(facets).map(([facet, values]) => [facet, [...values]])
);
}
/** Admits an optimistic row only where this scoped view shows it. */
function taskInsertFilter(
context: TaskViewContext,
reference: TaskReferenceScope | undefined,
crm: TaskCrmScope | undefined
): SoupApiItemFilter {
return (item) => {
const entity = mapApiSoupItemToEntity(item);
return (
isTaskEntity(entity) &&
taskMatchesView(entity, context) &&
(!reference || referencesEntity(entity, reference)) &&
(!crm || namesCrmRecord(entity, crm))
);
};
}
/** Query, service search, and row assembly owned by the production Tasks view. */
export function useTasksDataSource(
state: TasksDataSourceInput,
options: UseTasksDataSourceOptions
): TasksDataSource {
const notificationSource = useGlobalNotificationSource();
const calendar = options.calendar ?? createDateBucketBoundariesSignal();
const dueDate = () => taskDueDatePredicate(state.dueDate, calendar());
const attachNotifications = (entity: TaskEntityWithProperties) =>
withEntityNotifications(entity, notificationSource);
const facetContext = createMemo(
(): TaskFacetContext =>
options.facetContext?.() ?? {
...createTagFacetContext(options.tagSets()),
viewerId: options.userId(),
}
);
const facetOptionsReady = () =>
(options.enabled?.() ?? true) &&
!isProjectTab(state.tab) &&
(state.savedViewActive
? Boolean(options.userId())
: tagFacetReady(state.facets, options.tagSetsReady()));
const queryArgsFor = (nameContains?: string) =>
buildTaskQuery({
tab: state.tab,
userId: options.userId(),
facets: state.facets,
facetContext: facetContext(),
groupBy: state.groupBy,
sort: state.sort,
reference: options.reference?.(),
crm: options.crm?.(),
nameContains,
board: options.board?.(),
dueDate: dueDate(),
calendar: calendar(),
searching: !!state.search.trim(),
});
const queryArgs = () => queryArgsFor();
const scoped = Boolean(options.reference || options.crm);
const viewContext = (): TaskViewContext => ({
tab: state.tab,
userId: options.userId(),
facets: state.facets,
facetContext: facetContext(),
dueDate: dueDate(),
});
const query = useSoupAstItemsQuery(queryArgs, () => ({
enabled: facetOptionsReady(),
networkPaused: options.networkPaused?.(),
keepPreviousData: scoped,
onBeforeGraphqlRefresh: () => groupedQueries.resetToInitialPage(),
meta: scoped
? {
insertFilter: taskInsertFilter(
{ ...viewContext(), facets: copyFacets(state.facets) },
options.reference?.(),
options.crm?.()
),
}
: undefined,
}));
const transformEntities = (entities: EntityData[]) => {
const selected: TaskEntityWithProperties[] = [];
const context = viewContext();
const reference = options.reference?.();
for (const entity of entities) {
if (!isTaskEntity(entity)) continue;
if (reference && !referencesEntity(entity, reference)) continue;
if (!taskMatchesView(entity, context)) continue;
selected.push(attachNotifications(entity));
}
return selected;
};
const definitions = useListPropertiesQuery(
() => ({ scope: 'system', includeOptions: true }),
() =>
facetOptionsReady() && ['status', 'priority'].includes(state.sort[0]?.id)
);
const propertyDefinitions = createMemo(
() =>
new Map(
(definitions.isSuccess ? definitions.data : []).map((item) => {
const definition = 'definition' in item ? item.definition : item;
const options =
'property_options' in item ? item.property_options : [];
return [
definition.id,
toPropertyDefinitionDomain(definition, options),
];
})
)
);
const baseTasks = createMemo<TaskEntityWithProperties[]>((previous) => {
if (query.isLoading) return previous;
if (query.isPlaceholderData && previous.length > 0) return previous;
return sortTasks(
transformEntities(query.data?.entities ?? []),
state.sort,
propertyDefinitions()
);
}, []);
const { entityPool } = useSearchContext();
const localPool = createMemo(() => {
if (!state.search.trim()) return [];
const pool = entityPool();
const matchingIds = new Set(
transformEntities(pool.map((item) => item.data)).map(
(entity) => entity.id
)
);
return pool.filter((item) => matchingIds.has(item.data.id));
});
// CRM membership includes references and a company's contacts, which the
// search service cannot express: search the scoped Soup query by name.
const search = options.crm
? createScopedTaskSearch({
text: () => state.search,
args: queryArgsFor,
enabled: facetOptionsReady,
})
: createSearchState({
surface: () => 'tasks',
text: () => state.search,
localPool,
enabled: facetOptionsReady,
buildRequest: ({ query, matchType }) =>
buildTaskSearchRequest({
query,
matchType,
tab: state.tab,
userId: options.userId(),
facets: state.facets,
facetContext: facetContext(),
reference: options.reference?.(),
dueDate: dueDate(),
}),
});
const groupedQueries = createGroupedSoupQueries({
groupedPaging: () => query.groupedPaging,
initialPage: createMemo(() => {
if (search.isSearching() || query.isLoading || query.isPlaceholderData) {
return;
}
const groups = query.data?.groups;
const items = query.data?.itemsById;
if (!groups || !items) return;
return { groups, items };
}),
groupByField: () => queryArgs().groupBy,
soupParams: () => queryArgs().params,
soupBody: () => queryArgs().body,
transport: () => query.transport,
queryOptions: () => ({
enabled: !search.isSearching() && facetOptionsReady(),
}),
});
const groupQueryFor = (groupKey: string) =>
groupedQueries.map().get(groupKey);
const continuations: TaskGroupContinuationReader = {
entities: (groupKey) =>
(groupQueryFor(groupKey)?.data()?.entities ?? []).flatMap((entity) =>
isTaskEntity(entity) ? [attachNotifications(entity)] : []
),
hasMore: (groupKey) => groupQueryFor(groupKey)?.hasNextPage() ?? false,
isLoading: (groupKey) =>
groupQueryFor(groupKey)?.isFetchingNextPage() ?? false,
loadMore: async (groupKey) => {
await groupQueryFor(groupKey)?.fetchNextPage();
},
};
const tasks = createMemo<TaskEntityWithProperties[]>((previous) => {
if (!search.isSearching()) return baseTasks();
const results = transformEntities(search.data());
if (
results.length === 0 &&
previous.length > 0 &&
search.isLocalSearchSettling()
) {
return previous;
}
return results;
}, []);
const builtRows = createMemo<SoupRow<TaskEntityWithProperties>[]>(
(previous) => {
if (
!search.isSearching() &&
(query.isLoading || (query.isPlaceholderData && previous.length > 0))
) {
return previous;
}
const groups = search.isSearching() ? undefined : query.data?.groups;
const currentTasks = tasks();
if (!groups || state.groupBy === 'none') {
return buildFlatSoupRows(currentTasks);
}
const tasksById = new Map(currentTasks.map((task) => [task.id, task]));
const taskGroups: SoupGroup<TaskEntityWithProperties>[] = [];
for (const group of groups) {
const initialTasks = group.itemIds.flatMap((id) => {
const task = tasksById.get(id);
return task ? [task] : [];
});
const reference = options.reference?.();
const continuationTasks = continuations
.entities(group.key)
.filter(
(task) =>
(!reference || referencesEntity(task, reference)) &&
taskMatchesView(task, viewContext())
);
const entities = sortTasks(
deduplicateSoupEntities([...initialTasks, ...continuationTasks]),
state.sort,
propertyDefinitions()
);
const taskGroup: SoupGroup<TaskEntityWithProperties> = {
id: group.key,
label:
state.groupBy === 'due_date'
? (TASK_DUE_DATE_BUCKETS.find((bucket) => bucket.id === group.key)
?.label ?? group.label)
: group.label,
entities,
count: group.totalCount,
};
if (continuations.hasMore(group.key)) {
taskGroup.loadMore = {
scopeId: `tasks:${group.key}`,
isLoading: continuations.isLoading(group.key),
};
}
taskGroups.push(taskGroup);
}
return buildGroupedSoupRows(taskGroups);
},
[]
);
const rows = createSoupRowStore(builtRows);
const items = createMemo(() => {
if (options.enabled?.() === false) return [];
return rows().filter((row) =>
isSoupRowVisible(row, options.isGroupExpanded)
);
});
const usesServiceSearch = search.usesServiceSearch;
const isLoading = () => {
if (options.enabled?.() === false) return false;
if (!search.isSearching()) {
// A query held back for the tag sets is loading, not empty.
return (query.isLoading || !facetOptionsReady()) && rows().length === 0;
}
if (tasks().length > 0) return false;
if (usesServiceSearch()) return search.isLoading();
return query.isLoading;
};
const isFetching = () => {
if (search.isSettling()) return true;
if (usesServiceSearch()) return search.isFetching();
return query.isFetching;
};
const error = () => {
if (!usesServiceSearch()) return query.error ?? undefined;
return search.error();
};
const hasMore = () => {
if (usesServiceSearch()) return search.hasNextPage();
return query.hasNextPage;
};
const isLoadingMore = () => {
if (usesServiceSearch()) return search.isFetchingNextPage();
return query.isFetchingNextPage;
};
const loadMore = async () => {
if (usesServiceSearch()) {
await search.fetchNextPage();
return;
}
await query.fetchNextPage();
};
const refresh = async () => {
if (usesServiceSearch()) {
await search.refetch();
return;
}
if (query.transport !== 'graphql') groupedQueries.resetToInitialPage();
await query.refresh();
};
const boardRows = () => {
if (options.enabled?.() === false) {
return [];
}
if (search.isSearching()) {
return rows();
}
if (query.isPending || query.isPlaceholderData) {
return [];
}
return rows();
};
const boardLoading = () => {
if (search.isSearching()) {
return isLoading();
}
if (options.enabled?.() === false) {
return false;
}
return query.isPending || !facetOptionsReady();
};
return {
items,
boardRows,
boardLoading,
groupError: (id) => groupQueryFor(id)?.error(),
boardSearching: search.isSearching,
isLoading,
isFetching,
error,
hasMore,
isLoadingMore,
loadMoreGroup: continuations.loadMore,
loadMore,
refresh,
} satisfies TasksDataSource;
}