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.

22.1 KB
Raw Blame
import {
  compileToAst,
  type DocumentFieldFilters,
  type DocumentFilterExpression,
  type Query,
  queryStateFrom,
} from '@app/features/next-soup/filters/filter-store';
import { throwOnErr } from '@core/util/result';
import {
  ListEntity,
  ListEntityMetadataQueryProvider,
  ListLayoutProvider,
} from '@entity';
import {
  isDisplayableSoupItem,
  mapApiSoupItemToEntity,
} from '@queries/soup/transform-utils';
import { storageServiceClient } from '@service-storage/client';
import type {
  PostSoupRequest,
  SoupApiItem,
  SoupPage,
} from '@service-storage/generated/schemas';
import { Button, InlineCheckbox, Tabs } from '@ui';
import { createMemo, createSignal, For, Show } from 'solid-js';

type FilterTokenId =
  | 'pdf'
  | 'docx'
  | 'canvas'
  | 'image-assoc'
  | 'code-assoc'
  | 'md'
  | 'snippet'
  | 'task'
  | 'plain-md'
  | 'email-attachment'
  | 'not-email-attachment'
  | 'unseen'
  | 'seen'
  | 'not-done'
  | 'done'
  | 'updated-this-year';
type ExpressionMode = 'or' | 'and' | 'nested-md' | 'not-selected';
type EndpointMode = 'ast' | 'simple';

const NIL_UUID = '00000000-0000-0000-0000-000000000000';

const FILTER_TOKENS: {
  id: FilterTokenId;
  label: string;
  detail: string;
  expression: DocumentFilterExpression;
}[] = [
  {
    id: 'pdf',
    label: 'PDF',
    detail: 'fileType = pdf',
    expression: { include: { fileType: ['pdf'] } },
  },
  {
    id: 'docx',
    label: 'DOCX',
    detail: 'fileType = docx',
    expression: { include: { fileType: ['docx'] } },
  },
  {
    id: 'canvas',
    label: 'Canvas',
    detail: 'fileType = canvas',
    expression: { include: { fileType: ['canvas'] } },
  },
  {
    id: 'image-assoc',
    label: 'Images',
    detail: 'fileAssoc = assoc:image',
    expression: { include: { fileAssoc: ['assoc:image'] } },
  },
  {
    id: 'code-assoc',
    label: 'Code',
    detail: 'fileAssoc = assoc:code',
    expression: { include: { fileAssoc: ['assoc:code'] } },
  },
  {
    id: 'md',
    label: 'Any markdown',
    detail: 'fileType = md',
    expression: { include: { fileType: ['md'] } },
  },
  {
    id: 'snippet',
    label: 'Snippet',
    detail: 'fileType = md AND subType = snippet',
    expression: {
      op: 'and',
      clauses: [
        { include: { fileType: ['md'] } },
        { include: { subType: ['snippet'] } },
      ],
    },
  },
  {
    id: 'task',
    label: 'Task',
    detail: 'fileType = md AND subType = task',
    expression: {
      op: 'and',
      clauses: [
        { include: { fileType: ['md'] } },
        { include: { subType: ['task'] } },
      ],
    },
  },
  {
    id: 'plain-md',
    label: 'Plain markdown',
    detail: 'fileType = md AND NOT subType in snippet/task',
    expression: {
      op: 'and',
      clauses: [
        { include: { fileType: ['md'] } },
        { exclude: { subType: ['snippet', 'task'] } },
      ],
    },
  },
  {
    id: 'email-attachment',
    label: 'Email attachments',
    detail: 'isEmailAttachment = true',
    expression: { include: { isEmailAttachment: true } },
  },
  {
    id: 'not-email-attachment',
    label: 'Not email attachments',
    detail: 'isEmailAttachment = false',
    expression: { include: { isEmailAttachment: false } },
  },
  {
    id: 'unseen',
    label: 'Unseen',
    detail: 'documentSeen = false',
    expression: { include: { documentSeen: false } },
  },
  {
    id: 'seen',
    label: 'Seen',
    detail: 'documentSeen = true',
    expression: { include: { documentSeen: true } },
  },
  {
    id: 'not-done',
    label: 'Not done',
    detail: 'documentDone = false',
    expression: { include: { documentDone: false } },
  },
  {
    id: 'done',
    label: 'Done',
    detail: 'documentDone = true',
    expression: { include: { documentDone: true } },
  },
  {
    id: 'updated-this-year',
    label: 'Updated this year',
    detail: 'documentUpdatedAt >= Jan 1 of the current year',
    expression: {
      include: {
        documentUpdatedAt: {
          gte: `${new Date().getFullYear()}-01-01T00:00:00.000Z`,
        },
      },
    },
  },
];

const EXAMPLES: {
  label: string;
  mode: ExpressionMode;
  tokens: FilterTokenId[];
}[] = [
  {
    label: 'PDF OR markdown snippets/tasks',
    mode: 'nested-md',
    tokens: ['pdf', 'snippet', 'task'],
  },
  {
    label: 'Documents: md/canvas but not tasks',
    mode: 'and',
    tokens: ['md', 'plain-md'],
  },
  {
    label: 'Unread PDF attachments',
    mode: 'and',
    tokens: ['pdf', 'email-attachment', 'unseen'],
  },
  {
    label: 'Everything except selected types',
    mode: 'not-selected',
    tokens: ['task', 'snippet'],
  },
];

const SIMPLE_SOUP_NON_DOCUMENT_FILTERS: Pick<
  PostSoupRequest,
  | 'calendar_event_filters'
  | 'call_filters'
  | 'channel_filters'
  | 'channel_thread_filters'
  | 'chat_filters'
  | 'crm_company_filters'
  | 'email_filters'
  | 'foreign_entity_filters'
  | 'project_filters'
> = {
  calendar_event_filters: { calendar_event_ids: [NIL_UUID] },
  call_filters: { call_ids: [NIL_UUID] },
  channel_filters: { channel_ids: [NIL_UUID] },
  channel_thread_filters: { thread_ids: [NIL_UUID] },
  chat_filters: { chat_ids: [NIL_UUID] },
  crm_company_filters: { company_ids: [NIL_UUID] },
  email_filters: { email_thread_ids: [NIL_UUID] },
  foreign_entity_filters: { ids: [NIL_UUID] },
  project_filters: { project_ids: [NIL_UUID] },
};

const AST_SOUP_DOCUMENT_ONLY_FILTERS: Query['include'] = {
  calendarEventId: [NIL_UUID],
  callId: [NIL_UUID],
  channelId: [NIL_UUID],
  channelThreadId: [NIL_UUID],
  chatId: [NIL_UUID],
  crmCompanyId: [NIL_UUID],
  foreignEntityRecordId: [NIL_UUID],
  folderId: [NIL_UUID],
  threadId: [NIL_UUID],
};

function tokenExpression(id: FilterTokenId): DocumentFilterExpression {
  return FILTER_TOKENS.find((token) => token.id === id)?.expression ?? {};
}

function expressionFromTokens(
  selected: Set<FilterTokenId>,
  mode: ExpressionMode,
  customClause: DocumentFilterExpression | undefined
): DocumentFilterExpression {
  const clauses = [...selected].map(tokenExpression);
  if (customClause) clauses.push(customClause);

  if (clauses.length === 0) return { include: { documentId: [NIL_UUID] } };
  if (clauses.length === 1 && mode !== 'not-selected') return clauses[0];

  if (mode === 'and') return { op: 'and', clauses };
  if (mode === 'not-selected')
    return { op: 'not', clause: { op: 'or', clauses } };
  if (mode === 'nested-md') {
    const markdownClauses = [...selected]
      .filter((id) => ['md', 'snippet', 'task', 'plain-md'].includes(id))
      .map(tokenExpression);
    const nonMarkdownClauses = [...selected]
      .filter((id) => !['md', 'snippet', 'task', 'plain-md'].includes(id))
      .map(tokenExpression);
    const groupedClauses = [
      ...nonMarkdownClauses,
      ...(markdownClauses.length
        ? [{ op: 'or', clauses: markdownClauses } as DocumentFilterExpression]
        : []),
      ...(customClause ? [customClause] : []),
    ];

    if (groupedClauses.length === 1) return groupedClauses[0];
    return { op: 'or', clauses: groupedClauses };
  }

  return { op: 'or', clauses };
}

function simpleRequestFromClauses(
  selected: Set<FilterTokenId>,
  limit: number
): PostSoupRequest {
  const fileTypes = new Set<string>();
  const subTypes = new Set<string>();

  if (selected.has('pdf')) fileTypes.add('pdf');
  if (selected.has('docx')) fileTypes.add('docx');
  if (selected.has('canvas')) fileTypes.add('canvas');

  if (
    selected.has('md') ||
    selected.has('snippet') ||
    selected.has('task') ||
    selected.has('plain-md')
  ) {
    fileTypes.add('md');
  }

  if (selected.has('snippet')) subTypes.add('snippet');
  if (selected.has('task')) subTypes.add('task');

  return {
    ...SIMPLE_SOUP_NON_DOCUMENT_FILTERS,
    document_filters: {
      document_ids: selected.size === 0 ? [NIL_UUID] : undefined,
      file_types: fileTypes.size ? [...fileTypes] : undefined,
      sub_types: subTypes.size ? [...subTypes] : undefined,
    },
    limit,
    sort_method: 'viewed_updated',
  };
}

export default function DocumentWherePlayground() {
  const [resultsRef, setResultsRef] = createSignal<HTMLElement>();
  const [mode, setMode] = createSignal<EndpointMode>('ast');
  const [expressionMode, setExpressionMode] =
    createSignal<ExpressionMode>('nested-md');
  const [selected, setSelected] = createSignal<Set<FilterTokenId>>(
    new Set(['pdf', 'snippet', 'task'])
  );
  const [limit, setLimit] = createSignal(20);
  const [jsonText, setJsonText] = createSignal('');
  const [useJson, setUseJson] = createSignal(false);
  const [documentIds, setDocumentIds] = createSignal('');
  const [ownerIds, setOwnerIds] = createSignal('');
  const [projectIds, setProjectIds] = createSignal('');
  const [updatedAfter, setUpdatedAfter] = createSignal('');
  const [updatedBefore, setUpdatedBefore] = createSignal('');
  const [items, setItems] = createSignal<SoupApiItem[]>([]);
  const [nextCursor, setNextCursor] = createSignal<string | null>(null);
  const [loading, setLoading] = createSignal(false);
  const [error, setError] = createSignal<string | undefined>();

  const splitValues = (value: string) =>
    value
      .split(',')
      .map((part) => part.trim())
      .filter(Boolean);

  const customClause = createMemo<DocumentFilterExpression | undefined>(() => {
    const include: DocumentFieldFilters = {};
    const documentIdValues = splitValues(documentIds());
    const ownerValues = splitValues(ownerIds());
    const projectValues = splitValues(projectIds());
    const updatedAfterValue = updatedAfter().trim();
    const updatedBeforeValue = updatedBefore().trim();

    if (documentIdValues.length) include.documentId = documentIdValues;
    if (ownerValues.length) include.documentOwnerId = ownerValues;
    if (projectValues.length) include.projectId = projectValues;
    if (updatedAfterValue || updatedBeforeValue) {
      include.documentUpdatedAt = {
        ...(updatedAfterValue && { gte: updatedAfterValue }),
        ...(updatedBeforeValue && { lte: updatedBeforeValue }),
      };
    }

    return Object.keys(include).length ? { include } : undefined;
  });

  const selectedExpression = createMemo(() =>
    expressionFromTokens(selected(), expressionMode(), customClause())
  );

  const parsedExpression = createMemo<DocumentFilterExpression | undefined>(
    () => {
      if (!useJson()) return selectedExpression();
      try {
        return JSON.parse(jsonText()) as DocumentFilterExpression;
      } catch {
        return undefined;
      }
    }
  );

  const query = createMemo<Query>(() => ({
    include: AST_SOUP_DOCUMENT_ONLY_FILTERS,
    documentWhere: parsedExpression(),
  }));

  const compiled = createMemo(() => compileToAst(queryStateFrom(query())));
  const requestBody = createMemo(() => ({
    ...compiled(),
    limit: limit(),
    sort_method: 'viewed_updated' as const,
  }));
  const simpleRequestBody = createMemo(() =>
    simpleRequestFromClauses(selected(), limit())
  );
  const activeRequestBody = createMemo(() =>
    mode() === 'ast' ? requestBody() : simpleRequestBody()
  );
  const entities = createMemo(() =>
    items()
      .filter(isDisplayableSoupItem)
      .map((item) => mapApiSoupItemToEntity(item))
  );

  const run = async (cursor: string | null = null) => {
    setLoading(true);
    setError(undefined);

    try {
      if (!parsedExpression()) {
        throw new Error('Expression JSON is not valid');
      }

      const page = await throwOnErr(async () => {
        if (mode() === 'simple') {
          return await storageServiceClient.getSoupItems({
            params: { cursor },
            body: simpleRequestBody(),
          });
        }

        return await storageServiceClient.getSoupAstItems({
          params: { cursor },
          body: requestBody(),
        });
      });

      const soupPage = page as SoupPage;
      setItems((prev) =>
        cursor ? [...prev, ...soupPage.items] : soupPage.items
      );
      setNextCursor(soupPage.next_cursor ?? null);
    } catch (err) {
      setError(err instanceof Error ? err.message : String(err));
    } finally {
      setLoading(false);
    }
  };

  const toggleToken = (id: FilterTokenId) => {
    setUseJson(false);
    setSelected((prev) => {
      const next = new Set(prev);
      if (next.has(id)) {
        next.delete(id);
      } else {
        next.add(id);
      }
      return next;
    });
  };

  const loadJsonFromControls = () => {
    setJsonText(JSON.stringify(selectedExpression(), null, 2));
    setUseJson(true);
  };

  const applyExample = (example: (typeof EXAMPLES)[number]) => {
    setUseJson(false);
    setExpressionMode(example.mode);
    setSelected(new Set(example.tokens));
  };

  return (
    <div class="flex h-full flex-col bg-surface text-ink">
      <header class="flex h-10 shrink-0 items-center border-edge-muted border-b px-4">
        <div class="text-sm font-medium">Document AST Playground</div>
      </header>
      <div class="grid min-h-0 flex-1 grid-cols-[420px_1fr] overflow-hidden">
        <aside class="flex min-h-0 flex-col gap-4 border-edge-muted border-r p-4">
          <section class="space-y-2">
            <div class="text-sm font-medium">Endpoint</div>
            <Tabs
              aria-label="Endpoint"
              touch="segmented"
              fullWidth
              size="sm"
              value={mode()}
              options={[
                { value: 'ast', label: 'AST soup' },
                { value: 'simple', label: 'Simple soup' },
              ]}
              onChange={(value) => setMode(value)}
            />
          </section>

          <section class="space-y-3">
            <div class="text-sm font-medium">Expression shape</div>
            <select
              class="w-full rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
              value={expressionMode()}
              onChange={(event) =>
                setExpressionMode(event.currentTarget.value as ExpressionMode)
              }
            >
              <option value="or">OR selected clauses</option>
              <option value="and">AND selected clauses</option>
              <option value="nested-md">
                OR selected, grouping markdown subtypes
              </option>
              <option value="not-selected">NOT selected clauses</option>
            </select>
          </section>

          <section class="space-y-2">
            <div class="text-sm font-medium">Examples</div>
            <div class="grid grid-cols-1 gap-1">
              <For each={EXAMPLES}>
                {(example) => (
                  <Button
                    variant="secondary"
                    size="sm"
                    class="h-auto justify-start py-1.5"
                    onClick={() => applyExample(example)}
                  >
                    {example.label}
                  </Button>
                )}
              </For>
            </div>
          </section>

          <section class="min-h-0 space-y-3 overflow-auto">
            <div class="text-sm font-medium">Document clauses</div>
            <div class="grid grid-cols-2 gap-2">
              <For each={FILTER_TOKENS}>
                {(token) => (
                  <button
                    type="button"
                    class="flex min-h-14 items-start gap-2 rounded-sm border border-edge-muted bg-surface p-2 text-left text-sm hover:bg-hover"
                    classList={{
                      'border-accent/50 bg-accent-bg/30': selected().has(
                        token.id
                      ),
                    }}
                    onClick={() => toggleToken(token.id)}
                  >
                    <InlineCheckbox checked={selected().has(token.id)} />
                    <span class="min-w-0">
                      <span class="block">{token.label}</span>
                      <span class="block text-ink-muted text-xs">
                        {token.detail}
                      </span>
                    </span>
                  </button>
                )}
              </For>
            </div>
          </section>

          <section class="space-y-2">
            <div class="text-sm font-medium">Custom include fields</div>
            <input
              class="w-full rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
              placeholder="document ids, comma separated"
              value={documentIds()}
              onInput={(event) => setDocumentIds(event.currentTarget.value)}
            />
            <input
              class="w-full rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
              placeholder="owner ids, comma separated"
              value={ownerIds()}
              onInput={(event) => setOwnerIds(event.currentTarget.value)}
            />
            <input
              class="w-full rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
              placeholder="project ids, comma separated"
              value={projectIds()}
              onInput={(event) => setProjectIds(event.currentTarget.value)}
            />
            <div class="grid grid-cols-2 gap-2">
              <input
                class="rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
                placeholder="updated >= ISO"
                value={updatedAfter()}
                onInput={(event) => setUpdatedAfter(event.currentTarget.value)}
              />
              <input
                class="rounded-sm border border-edge-muted bg-surface p-1.5 text-sm outline-none focus:border-accent"
                placeholder="updated <= ISO"
                value={updatedBefore()}
                onInput={(event) => setUpdatedBefore(event.currentTarget.value)}
              />
            </div>
          </section>

          <section class="space-y-2">
            <div class="text-sm font-medium">Limit</div>
            <input
              class="w-24 rounded-sm border border-edge-muted bg-surface p-1 text-sm outline-none focus:border-accent"
              type="number"
              min="1"
              max="100"
              value={limit()}
              onInput={(event) =>
                setLimit(Number(event.currentTarget.value) || 20)
              }
            />
          </section>

          <section class="flex gap-2">
            <Button
              variant="secondary"
              size="sm"
              onClick={loadJsonFromControls}
            >
              Edit JSON
            </Button>
            <Button
              variant="primary"
              size="sm"
              disabled={loading()}
              onClick={() => run()}
            >
              Run
            </Button>
          </section>

          <Show when={useJson()}>
            <section class="min-h-0 flex-1 space-y-2">
              <div class="text-sm font-medium">documentWhere JSON</div>
              <textarea
                class="h-full min-h-48 w-full resize-none rounded-sm border border-edge-muted bg-surface p-2 font-mono text-xs outline-none focus:border-accent"
                value={jsonText()}
                onInput={(event) => setJsonText(event.currentTarget.value)}
              />
            </section>
          </Show>
        </aside>

        <main class="grid min-h-0 grid-cols-2 overflow-hidden">
          <section class="min-h-0 overflow-auto border-edge-muted border-r p-4">
            <div class="mb-2 text-sm font-medium">documentWhere expression</div>
            <pre class="mb-4 whitespace-pre-wrap rounded-sm border border-edge-muted bg-surface p-3 font-mono text-xs">
              {JSON.stringify(parsedExpression(), null, 2)}
            </pre>
            <div class="mb-2 text-sm font-medium">
              {mode() === 'ast'
                ? 'Compiled AST request body'
                : 'Simple soup request body'}
            </div>
            <pre class="whitespace-pre-wrap rounded-sm border border-edge-muted bg-surface p-3 font-mono text-xs">
              {JSON.stringify(activeRequestBody(), null, 2)}
            </pre>
            <Show when={mode() === 'simple' && selected().has('plain-md')}>
              <div class="mt-3 rounded-sm border border-edge-muted bg-surface p-2 text-ink-muted text-sm">
                Simple soup cannot express the plain-markdown exclusion for
                snippet/task. It requests markdown documents and shows the old
                flat-filter behavior.
              </div>
            </Show>
            <Show when={error()}>
              <div class="mt-3 rounded-sm border border-failure/50 bg-failure/10 p-2 text-failure text-sm">
                {error()}
              </div>
            </Show>
          </section>

          <section ref={setResultsRef} class="min-h-0 overflow-auto p-4">
            <div class="mb-3 flex items-center justify-between">
              <div class="text-sm font-medium">
                Soup entities ({entities().length})
              </div>
              <Show when={nextCursor()}>
                <Button
                  variant="secondary"
                  size="sm"
                  disabled={loading()}
                  onClick={() => run(nextCursor())}
                >
                  Load more
                </Button>
              </Show>
            </div>

            <Show when={loading()}>
              <div class="mb-3 text-ink-muted text-sm">Loading...</div>
            </Show>

            <Show when={items().length !== entities().length}>
              <div class="mb-3 rounded-sm border border-edge-muted bg-surface p-2 text-ink-muted text-sm">
                {items().length - entities().length} returned soup items were
                not displayable entity rows.
              </div>
            </Show>

            <ListEntityMetadataQueryProvider>
              <ListLayoutProvider ref={resultsRef}>
                <div class="space-y-1">
                  <For each={entities()}>
                    {(entity) => (
                      <ListEntity
                        entity={entity}
                        hideCheckbox
                        onClick={() => console.log('Soup entity:', entity)}
                      />
                    )}
                  </For>
                </div>
              </ListLayoutProvider>
            </ListEntityMetadataQueryProvider>
          </section>
        </main>
      </div>
    </div>
  );
}