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.

15.6 KB
Raw Blame
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;
}