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.

3.0 KB
Raw Blame
import { toast } from '@core/component/Toast/Toast';
import { applyDatabaseOps } from '@queries/storage/databases';
import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';
import { ResultAsync } from 'neverthrow';
import type { JSX } from 'solid-js';
import { TableNavigation } from '../../database/components/table-navigation';
import {
  tableDeleteMessage,
  tableOrderMessage,
} from '../../database/core/column-schema';
import { tableDeleteConsequence } from '../../database/core/forms-usage';
import { createTableWithName } from '../queries/create-table';
import { patchDetail, patchTable } from '../queries/detail-cache';
import { useFormsOverTables } from '../queries/forms-usage';
import { reorderDatabaseTables } from '../queries/reorder-tables';

export function TableTabs(props: {
  databaseId: string;
  tables: TableDetail[];
  activeTableId: string | undefined;
  canEdit: boolean;
  menuItems?: () => JSX.Element;
  onSelect: (tableId: string) => void;
}) {
  const formsOver = useFormsOverTables(() => props.databaseId);
  return (
    <TableNavigation
      deleteConsequence={(tableId) =>
        tableDeleteConsequence(formsOver(tableId))
      }
      tables={props.tables.map((table) => ({
        id: table.table.id,
        name: table.table.name,
      }))}
      activeTableId={props.activeTableId}
      canCreate={props.canEdit}
      menuItems={props.menuItems}
      onSelect={props.onSelect}
      onRename={(tableId, name, previousName) =>
        ResultAsync.fromSafePromise(
          patchTable(props.databaseId, tableId, (entry) => ({
            ...entry,
            table: { ...entry.table, name },
          }))
        )
          .andThen((rollback) =>
            applyDatabaseOps(props.databaseId, [
              {
                kind: 'table',
                table: tableId,
                change: { kind: 'rename', name, previousName },
              },
            ]).mapErr((error) => {
              rollback();
              return error;
            })
          )
          .map(() => undefined)
      }
      onReorder={(tableIds) => {
        reorderDatabaseTables({
          databaseId: props.databaseId,
          tableIds,
        }).mapErr((errors) => toast.failure(tableOrderMessage(errors)));
      }}
      onDelete={(tableId) => {
        ResultAsync.fromSafePromise(
          patchDetail(props.databaseId, (detail) => ({
            ...detail,
            tables: detail.tables.filter((entry) => entry.table.id !== tableId),
          }))
        )
          .andThen((rollback) =>
            applyDatabaseOps(props.databaseId, [
              { kind: 'table', table: tableId, change: { kind: 'delete' } },
            ]).mapErr((error) => {
              rollback();
              return error;
            })
          )
          .mapErr((error) => toast.failure(tableDeleteMessage(error)));
      }}
      onCreate={(name, existingTableId) =>
        createTableWithName({
          databaseId: props.databaseId,
          name,
          existingTableId,
        })
      }
    />
  );
}