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.5 KB
Raw Blame
import { ListSkeleton } from '@app/components/view-shell/ListSkeleton';
import { openChatWithInput } from '@app/features/chat/ChatWithAgentButton';
import { toQuerySchema } from '@app/features/database-query/queries/query-source';
import { useFeatureFlag } from '@app/lib/analytics/posthog';
import { usePending } from '@app/observability/flow';
import { useGlobalBlockOrchestrator } from '@components/app/GlobalAppState';
import { useSplitLayout } from '@components/app/split-layout/layout';
import {
  returnSplitToRecentListView,
  useSplitPanelOrThrow,
} from '@components/app/split-layout/layoutUtils';
import { useHasPaidAccess } from '@core/auth/license';
import { useBlockId } from '@core/block';
import { DATABASE_MODEL, modelsForPlan } from '@core/component/AI/constant';
import { DocumentBlockContainer } from '@core/component/DocumentBlockContainer';
import { toast } from '@core/component/Toast/Toast';
import { enableDatabases } from '@core/constant/featureFlags';
import { PaywallKey, usePaywallState } from '@core/constant/PaywallState';
import { useUserId } from '@core/context/user';
import { registerHotkey } from '@core/hotkey/hotkeys';
import { TOKENS } from '@core/hotkey/tokens';
import { createMethodRegistration } from '@core/orchestrator';
import { blockHandleSignal } from '@core/signal/load';
import { fireAndForget } from '@core/util/fireAndForget';
import { createUserScopedStorage } from '@core/util/userScopedStorage';
import {
  onDatabaseBatchCommitted,
  undoDatabaseChange,
  useDatabaseDetailQuery,
} from '@queries/storage/databases';
import { useDatabaseTableChangedSync } from '@queries/storage/databases-sync';
import type { DatabaseView } from '@service-storage/generated/schemas/databaseView';
import { getEntityGraphqlClient } from '@service-storage/graphql-soup';
import { Button } from '@ui';
import { okAsync } from 'neverthrow';
import {
  type Component,
  createMemo,
  createSignal,
  ErrorBoundary,
  For,
  onCleanup,
  Show,
} from 'solid-js';
import { match } from 'ts-pattern';
import { DatabaseSearch } from '../../database/components/database-search';
import type { ShownLayout } from '../../database/components/database-toolbar';
import { DatabaseToolbar } from '../../database/components/database-toolbar';
import type { DatabaseRelatedDestination } from '../../database/core/database-relations';
import type { NewView } from '../../database/core/view-creation';
import type { ViewChange } from '../../database/core/view-state';
import {
  allRecordsView,
  boardLayout,
  timelineLayout,
} from '../../database/core/views';
import { databaseOpMessage } from '../../database/core/write-failure';
import { createDatabaseSearch } from '../../database/primitives/database-search';
import { createDatabaseUndo } from '../../database/primitives/undo-controller';
import { createViewCreation } from '../../database/primitives/view-creation';
import { databaseChat } from '../core/chat-context';
import { createDatabaseViewSelection } from '../primitives/view-selection';
import { searchDatabase } from '../queries/database-search';
import { toViewColumn } from '../queries/table-rows';
import { trashDatabase } from '../queries/trash-database';
import { prepareViewCreation } from '../queries/view-creation';
import {
  deleteDatabaseView,
  reorderDatabaseViews,
  showAsBoardWithStatusColumn,
  showAsTimelineWithTimeRangeColumn,
  updateDatabaseView,
} from '../queries/views';
import { DatabaseGrid } from './DatabaseGrid';
import { DatabasePageShell } from './DatabasePageShell';
import { DatabaseSidePanelSections } from './sidepanel/DatabaseSidePanelSections';
import { TopBar } from './TopBar';

const Block: Component = () => {
  const databaseId = useBlockId();
  const panel = useSplitPanelOrThrow();
  const { replaceOrInsertSplit } = useSplitLayout();
  const orchestrator = useGlobalBlockOrchestrator();
  let requestedRecord: DatabaseRelatedDestination | undefined;
  const userId = useUserId();
  const storage = createUserScopedStorage(
    `database-view-selection:${databaseId}`
  );
  const [selection, setSelection] = createDatabaseViewSelection(
    userId,
    storage
  );
  useDatabaseTableChangedSync(() => databaseId);
  const detailQuery = useDatabaseDetailQuery(() => databaseId);
  usePending('database.detail', () => detailQuery.isLoading);
  let gridEntry:
    | {
        tableId: string;
        openRecord: (rowId: string) => void;
      }
    | undefined;
  function openRequestedRecord() {
    const target = requestedRecord;
    if (!target || !gridEntry || gridEntry.tableId !== target.tableId) return;
    requestedRecord = undefined;
    gridEntry.openRecord(target.rowId);
  }
  async function openRelated(target: DatabaseRelatedDestination) {
    if (target.databaseId !== databaseId) {
      replaceOrInsertSplit({
        type: 'database',
        id: target.databaseId,
      });
      try {
        const handle = await orchestrator.getBlockHandle(
          target.databaseId,
          'database'
        );
        await handle?.goToLocationFromParams({
          tableId: target.tableId,
          rowId: target.rowId,
        });
      } catch {
        toast.failure('This related record could not be opened.');
      }
      return;
    }
    requestedRecord = target;
    setSelection((current) => ({ ...current, tableId: target.tableId }));
    // Another table's grid takes the request when it mounts.
    openRequestedRecord();
  }
  createMethodRegistration(blockHandleSignal.get, {
    goToLocationFromParams: (params: Record<string, string>) => {
      if (params.tableId && params.viewId)
        setSelection((current) => ({
          ...current,
          tableId: params.tableId,
          views: { ...current.views, [params.tableId]: params.viewId },
        }));
      if (params.tableId && params.rowId)
        fireAndForget(
          openRelated({
            databaseId,
            tableId: params.tableId,
            rowId: params.rowId,
          }),
          'database-view'
        );
    },
  });
  const [openingChat, setOpeningChat] = createSignal(false);
  const hasPaidAccess = useHasPaidAccess();
  const { showPaywall } = usePaywallState();
  async function openDatabaseChat() {
    const current = detail();
    if (!current || openingChat()) return;
    setOpeningChat(true);
    // A locked model gets the picker's treatment: the chat opens on the plan's
    // model and the paywall says why.
    const canUseDatabaseModel = modelsForPlan(hasPaidAccess()).includes(
      DATABASE_MODEL
    );
    const chat = databaseChat(toQuerySchema(current, activeTableId()));
    try {
      await openChatWithInput(chat.input, {
        instructions: chat.instructions,
        ...(canUseDatabaseModel ? { model: DATABASE_MODEL } : {}),
      });
      if (!canUseDatabaseModel) showPaywall(PaywallKey.O1_LIMIT);
    } finally {
      setOpeningChat(false);
    }
  }
  // Reading data only after status resolves keeps the database shell mounted.
  const detail = () => (!detailQuery.isPending ? detailQuery.data : undefined);
  const tables = () => detail()?.tables ?? [];
  const activeTable = createMemo(
    () =>
      tables().find((table) => table.table.id === selection().tableId) ??
      tables()[0]
  );
  const activeTableId = () => activeTable()?.table.id;
  // A memo, so a refetched schema with the same grant wakes no cell.
  const canEdit = createMemo(
    () => detail()?.grant === 'edit' || detail()?.grant === 'owner'
  );
  const columns = () => activeTable()?.columns.map(toViewColumn) ?? [];
  const creations = createViewCreation();
  const storedViews = () => {
    const drafts = creations
      .drafts()
      .filter((item) => item.view.tableId === activeTableId());
    return [
      ...(activeTable()?.views ?? []).filter(
        (view) => !drafts.some((item) => item.view.id === view.id)
      ),
      ...drafts.map((item) => item.view),
    ];
  };
  const activeCreation = () =>
    creations.drafts().find((item) => item.view.id === selectedView()?.id);
  const selectedView = () => {
    const tableId = activeTableId();
    const id = tableId ? selection().views[tableId] : undefined;
    return storedViews().find((view) => view.id === id);
  };
  /** All records, as this viewer has filtered, sorted and laid it out, per table. */
  const [allRecords, setAllRecords] = createSignal<
    Record<string, DatabaseView>
  >({});
  const search = createDatabaseSearch({ detail, search: searchDatabase });
  registerHotkey({
    hotkey: 'cmd+f',
    hotkeyToken: TOKENS.database.search,
    scopeId: panel.splitHotkeyScope,
    description: 'Search database',
    runWithInputFocused: true,
    keyDownHandler: () => {
      search.open();
      return true;
    },
  });
  const databaseUndo = createDatabaseUndo({
    undoChange: (change) => undoDatabaseChange(databaseId, change),
    onCommitted: (listener) => {
      const stop = onDatabaseBatchCommitted((batch) => {
        if (batch.databaseId !== databaseId) return;
        listener({
          ops: batch.ops,
          changes: batch.changes.map(({ change }) => change),
        });
      });
      onCleanup(stop);
    },
    offer: (label, undo) =>
      toast.success(label, { actions: [{ label: 'Undo', onClick: undo }] }),
  });
  // Without input focus, so a cell editor keeps Ctrl+Z for its own text.
  registerHotkey({
    hotkey: 'cmd+z',
    hotkeyToken: TOKENS.database.undo,
    scopeId: panel.splitHotkeyScope,
    description: 'Undo your last edit',
    condition: databaseUndo.canUndo,
    keyDownHandler: () => {
      fireAndForget(databaseUndo.undo(), 'database-view');
      return true;
    },
  });
  registerHotkey({
    hotkey: 'shift+cmd+z',
    hotkeyToken: TOKENS.database.redo,
    scopeId: panel.splitHotkeyScope,
    description: 'Redo your last undo',
    condition: databaseUndo.canRedo,
    keyDownHandler: () => {
      fireAndForget(databaseUndo.redo(), 'database-view');
      return true;
    },
  });
  const view = (): DatabaseView | undefined => {
    const table = activeTable();
    if (!table) return undefined;
    return (
      selectedView() ??
      allRecords()[table.table.id] ??
      allRecordsView(table.table)
    );
  };
  function selectView(id?: string) {
    const tableId = activeTableId();
    if (!tableId) return;
    setSelection((current) => {
      const views = { ...current.views };
      if (id) views[tableId] = id;
      else delete views[tableId];
      return { ...current, views };
    });
  }
  function changeView(change: ViewChange) {
    if (activeCreation()) return;
    const current = view();
    if (!current) return;
    const stored = selectedView();
    if (stored) {
      void updateDatabaseView(stored, change).mapErr((failure) =>
        toast.failure(databaseOpMessage(failure, 'this view'))
      );
      return;
    }
    setAllRecords((views) => ({
      ...views,
      [current.tableId]: { ...current, ...change },
    }));
  }
  function createView(current: DatabaseView, created: NewView) {
    const creation = prepareViewCreation(current, created, columns());
    creations.start(creation);
    selectView(creation.view.id);
    return okAsync(undefined);
  }
  /** Lay a stored view out as a table, as a board grouped as asked, or as a timeline. */
  function showViewAs(target: DatabaseView, shown: ShownLayout) {
    return match(shown)
      .with({ kind: 'table' }, () =>
        updateDatabaseView(target, { layout: { kind: 'table', columns: [] } })
      )
      .with({ kind: 'board', groupBy: { kind: 'column' } }, ({ groupBy }) =>
        updateDatabaseView(target, {
          layout: boardLayout(groupBy.columnId, columns()),
        })
      )
      .with({ kind: 'board', groupBy: { kind: 'new-status' } }, () =>
        showAsBoardWithStatusColumn(target, columns())
      )
      .with({ kind: 'timeline', range: { kind: 'column' } }, ({ range }) =>
        updateDatabaseView(target, {
          layout: timelineLayout(range.columnId, columns()),
        })
      )
      .with({ kind: 'timeline', range: { kind: 'new-column' } }, () =>
        showAsTimelineWithTimeRangeColumn(target, columns())
      )
      .exhaustive()
      .map(() => undefined);
  }

  return (
    <DocumentBlockContainer>
      <DatabasePageShell>
        <DatabaseSidePanelSections
          databaseId={databaseId}
          database={detail()?.database}
        />
        <TopBar
          databaseId={databaseId}
          detail={detail()}
          canEdit={canEdit()}
          activeTable={activeTable()}
          onSelectTable={(tableId) =>
            setSelection((current) => ({ ...current, tableId }))
          }
          onDelete={() =>
            trashDatabase(getEntityGraphqlClient(), databaseId).map(() =>
              returnSplitToRecentListView(panel.handle)
            )
          }
          openingChat={openingChat()}
          onOpenChat={() => fireAndForget(openDatabaseChat(), 'database-view')}
        />
        <div
          class="@container/database flex size-full min-h-0 min-w-0 flex-col overflow-hidden bg-canvas-base text-ink"
          style={{ '--database-title-column-width': '18rem' }}
        >
          <ErrorBoundary
            fallback={(error: unknown, reset) => (
              <div
                class="flex flex-1 flex-col items-center justify-center gap-3 p-6 text-center"
                role="alert"
              >
                <p class="font-medium">This database could not be displayed</p>
                <p class="max-w-md text-sm text-ink-muted">
                  {error instanceof Error
                    ? error.message
                    : 'Please try opening it again.'}
                </p>
                <Button
                  variant="secondary"
                  onClick={() => {
                    reset();
                    fireAndForget(detailQuery.refetch(), 'database-view');
                  }}
                >
                  Try again
                </Button>
              </div>
            )}
          >
            <Show when={!detailQuery.isPending} fallback={<DatabaseSkeleton />}>
              <Show
                when={detail()}
                fallback={
                  <div
                    class="flex flex-1 flex-col items-center justify-center gap-3 p-6 text-center"
                    role="alert"
                  >
                    <p class="font-medium">Could not open this database</p>
                    <p class="max-w-md text-sm text-ink-muted">
                      It may be unavailable, or you may no longer have access.
                    </p>
                    <Button
                      variant="secondary"
                      onClick={() =>
                        fireAndForget(detailQuery.refetch(), 'database-view')
                      }
                    >
                      Try again
                    </Button>
                  </div>
                }
              >
                <Show
                  when={activeTable()}
                  fallback={
                    <div class="grid flex-1 place-items-center p-6 text-sm text-ink-muted">
                      Add a table to start organizing your data.
                    </div>
                  }
                >
                  <Show
                    when={
                      activeTable() && view()
                        ? { table: activeTable()!, view: view()! }
                        : undefined
                    }
                  >
                    {(shown) => {
                      const table = () => shown().table;
                      return (
                        <>
                          <Show when={activeCreation()?.failure}>
                            {(failure) => (
                              <div
                                role="alert"
                                class="flex items-center gap-3 px-5 py-2 text-sm text-failure-ink"
                              >
                                <span>
                                  {databaseOpMessage(failure(), 'this view')}
                                </span>
                                <Button
                                  variant="primary"
                                  size="sm"
                                  onClick={() =>
                                    creations.retry(shown().view.id)
                                  }
                                >
                                  Retry
                                </Button>
                                <Button
                                  variant="ghost"
                                  size="sm"
                                  onClick={() => {
                                    creations.discard(shown().view.id);
                                    selectView();
                                  }}
                                >
                                  Dismiss
                                </Button>
                              </div>
                            )}
                          </Show>
                          <DatabaseGrid
                            host="block"
                            databaseId={databaseId}
                            table={table()}
                            canEdit={canEdit() && !activeCreation()}
                            view={shown().view}
                            stored={!!selectedView() && !activeCreation()}
                            preparingView={!!activeCreation()?.needsColumn}
                            onViewChange={changeView}
                            onClearConstraints={() => {
                              changeView({
                                query: {
                                  ...shown().view.query,
                                  filter: null,
                                },
                              });
                            }}
                            onOpenRelated={openRelated}
                            actionsRef={(actions) => {
                              gridEntry = {
                                tableId: table().table.id,
                                openRecord: actions.openRecord,
                              };
                              openRequestedRecord();
                            }}
                            renderToolbar={(actions) => (
                              <DatabaseToolbar
                                columns={columns()}
                                views={storedViews()}
                                view={shown().view}
                                selectedViewId={selectedView()?.id}
                                canEdit={canEdit() && !activeCreation()}
                                search={
                                  <DatabaseSearch
                                    term={search.term()}
                                    isOpen={search.isOpen()}
                                    results={search.results()}
                                    onTermChange={search.setTerm}
                                    onOpen={search.open}
                                    onClose={search.close}
                                    inputRef={search.setInput}
                                    onChoose={(choice) =>
                                      fireAndForget(
                                        openRelated({
                                          databaseId,
                                          ...choice,
                                        }),
                                        'database-view'
                                      )
                                    }
                                  />
                                }
                                onSelectView={selectView}
                                onChangeView={changeView}
                                onCreateView={(created) =>
                                  createView(shown().view, created)
                                }
                                onRenameView={(target, name) =>
                                  updateDatabaseView(target, { name }).map(
                                    () => undefined
                                  )
                                }
                                onShowViewAs={showViewAs}
                                onDeleteView={(target) => {
                                  if (selectedView()?.id === target.id)
                                    selectView();
                                  return deleteDatabaseView(target);
                                }}
                                onReorderViews={(order) => {
                                  reorderDatabaseViews(
                                    databaseId,
                                    table().table.id,
                                    order
                                  ).mapErr((failure) =>
                                    toast.failure(
                                      databaseOpMessage(failure, 'these views')
                                    )
                                  );
                                }}
                                onCreateRecord={
                                  canEdit()
                                    ? () =>
                                        fireAndForget(
                                          actions.createRecord(),
                                          'database-view'
                                        )
                                    : undefined
                                }
                                canCreateRecord={columns().length > 0}
                                creating={actions.pending()}
                              />
                            )}
                          />
                        </>
                      );
                    }}
                  </Show>
                </Show>
              </Show>
            </Show>
          </ErrorBoundary>
        </div>
      </DatabasePageShell>
    </DocumentBlockContainer>
  );
};

function DatabaseSkeleton() {
  return (
    <div
      class="flex min-h-0 flex-1 flex-col gap-3 px-6 py-3"
      aria-busy="true"
      aria-label="Loading database"
    >
      <div class="mb-3 flex gap-2">
        <For each={[0, 1]}>{() => <ListSkeleton.Bar class="h-8 w-24" />}</For>
      </div>
      <For each={[0, 1, 2, 3, 4, 5]}>
        {() => <ListSkeleton.Bar class="h-9 w-full rounded-lg" />}
      </For>
    </div>
  );
}

const DatabaseBlock: Component = () => {
  const flag = useFeatureFlag(enableDatabases);
  return (
    <Show
      when={flag().enabled}
      fallback={
        <div class="grid size-full place-items-center p-6 text-sm text-ink-muted">
          Databases are not enabled for this account.
        </div>
      }
    >
      <Block />
    </Show>
  );
};

export default DatabaseBlock;