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.

2.6 KB
Raw Blame
import { createUrqlQuery } from '@app/lib/urql-solid/create-urql-query';
import { buildGraphqlEntitySoupInput } from '@queries/soup/graphql/entity-input';
import type { EntityType } from '@service-properties/generated/schemas/entityType';
import {
  EntityActivityDocument,
  type EntityActivityQuery,
  type EntityActivityQueryVariables,
} from '@service-storage/graphql/generated/graphql';
import { type Accessor, createMemo, onCleanup } from 'solid-js';
import { registerActivityRevalidator } from '../../../lib/queries/activity/push-registry';
import type { ActivityContext } from '../context/activity-context';
import {
  type EntityActivityResult,
  selectEntityActivity,
} from './select-entity-activity';

/** Rows shown in an entity activity preview. */
export const ENTITY_ACTIVITY_PREVIEW_LIMIT = 20;

type EntityActivityQueryOptions = {
  entityType: Accessor<EntityType>;
  entityId: Accessor<string>;
  enabled: Accessor<boolean>;
  limit?: number;
};

/**
 * Live urql query for one Soup-backed entity's recent activity, newest
 * first. Reuses the exact-single-entity Soup input builder, so the same
 * entity types are supported (everything but `USER`) and the query pauses
 * (`isEnabled` false) for the rest.
 */
export function createEntityActivityQuery(
  context: Pick<ActivityContext, 'graphql'>,
  options: EntityActivityQueryOptions
) {
  const input = createMemo(() => {
    const entityId = options.entityId();
    if (!options.enabled() || entityId.length === 0) return undefined;
    return buildGraphqlEntitySoupInput(options.entityType(), entityId);
  });

  const client = createMemo(context.graphql);
  const result = createUrqlQuery<
    EntityActivityQuery,
    EntityActivityQueryVariables,
    EntityActivityResult
  >(() => {
    const currentInput = input();
    const entityId = options.entityId();

    return {
      query: EntityActivityDocument,
      client: client(),
      variables: {
        input: currentInput!,
        limit: options.limit ?? ENTITY_ACTIVITY_PREVIEW_LIMIT,
      },
      enabled: currentInput !== undefined,
      requestPolicy: 'cache-and-network',
      keepPreviousData: false,
      select: (data) => selectEntityActivity(data, entityId),
    };
  });

  onCleanup(
    registerActivityRevalidator({
      client,
      refresh: (entities) => {
        if (
          input() === undefined ||
          (entities !== null && !entities.has(options.entityId()))
        )
          return;
        return result.refetch({ requestPolicy: 'network-only' });
      },
    })
  );

  return {
    result,
    isEnabled: () => input() !== undefined,
  };
}