[FE] Update remote table schema + refactor Tables list

packages/twenty-front/src/modules/apollo/hooks/useApolloFactory.ts

@@ -30,7 +30,13 @@ export const useApolloFactory = (options: Partial<Options<any>> = {}) => {
   const apolloClient = useMemo(() => {
     apolloRef.current = new ApolloFactory({
       uri: `${REACT_APP_SERVER_BASE_URL}/graphql`,
-      cache: new InMemoryCache(),
+      cache: new InMemoryCache({
+        typePolicies: {
+          RemoteTable: {
+            keyFields: ['name'],
+          },
+        },
+      }),
       headers: {
         ...(currentWorkspace?.currentCacheVersion && {
           'X-Schema-Version': currentWorkspace.currentCacheVersion,

packages/twenty-front/src/modules/databases/graphql/mutations/syncRemoteTableSchemaChanges.ts

@@ -0,0 +1,12 @@
+import { gql } from '@apollo/client';
+
+import { REMOTE_TABLE_FRAGMENT } from '@/databases/graphql/fragments/remoteTableFragment';
+
+export const SYNC_REMOTE_TABLE_SCHEMA_CHANGES = gql`
+  ${REMOTE_TABLE_FRAGMENT}
+  mutation syncRemoteTable($input: RemoteTableInput!) {
+    syncRemoteTableSchemaChanges(input: $input) {
+      ...RemoteTableFields
+    }
+  }
+`;

packages/twenty-front/src/modules/databases/hooks/useSyncRemoteTable.ts

@@ -2,11 +2,12 @@ import { useCallback } from 'react';
 import { ApolloClient, useApolloClient, useMutation } from '@apollo/client';
 
 import { SYNC_REMOTE_TABLE } from '@/databases/graphql/mutations/syncRemoteTable';
-import { GET_MANY_REMOTE_TABLES } from '@/databases/graphql/queries/findManyRemoteTables';
+import { modifyRemoteTableFromCache } from '@/databases/utils/modifyRecordTableFromCache';
 import { useApolloMetadataClient } from '@/object-metadata/hooks/useApolloMetadataClient';
 import { useFindManyObjectMetadataItems } from '@/object-metadata/hooks/useFindManyObjectMetadataItems';
 import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
 import { useFindManyRecordsQuery } from '@/object-record/hooks/useFindManyRecordsQuery';
+import { RemoteTableStatus } from '~/generated/graphql';
 import {
   RemoteTableInput,
   SyncRemoteTableMutation,
@@ -23,7 +24,6 @@ export const useSyncRemoteTable = () => {
   const { findManyRecordsQuery: findManyViewsQuery } = useFindManyRecordsQuery({
     objectNameSingular: CoreObjectNameSingular.View,
   });
-
   const [mutate] = useMutation<
     SyncRemoteTableMutation,
     SyncRemoteTableMutationVariables
@@ -37,20 +37,17 @@ export const useSyncRemoteTable = () => {
         variables: {
           input,
         },
-        awaitRefetchQueries: true,
-        refetchQueries: [
-          {
-            query: GET_MANY_REMOTE_TABLES,
-            variables: {
-              input: {
-                id: input.remoteServerId,
-              },
+        update: (cache) => {
+          modifyRemoteTableFromCache({
+            cache: cache,
+            remoteTableName: input.name,
+            fieldModifiers: {
+              status: () => RemoteTableStatus.Synced,
             },
-          },
-        ],
+          });
+        },
       });
 
-      // TODO: we should return the tables with the columns and store in cache instead of refetching
       await refetchObjectMetadataItems();
       await apolloClient.query({
         query: findManyViewsQuery,

packages/twenty-front/src/modules/databases/hooks/useSyncRemoteTableSchemaChanges.ts

@@ -0,0 +1,48 @@
+import { useCallback } from 'react';
+import { ApolloClient, useMutation } from '@apollo/client';
+
+import { SYNC_REMOTE_TABLE_SCHEMA_CHANGES } from '@/databases/graphql/mutations/syncRemoteTableSchemaChanges';
+import { modifyRemoteTableFromCache } from '@/databases/utils/modifyRecordTableFromCache';
+import { useApolloMetadataClient } from '@/object-metadata/hooks/useApolloMetadataClient';
+import {
+  RemoteTableInput,
+  SyncRemoteTableMutation,
+  SyncRemoteTableMutationVariables,
+} from '~/generated-metadata/graphql';
+
+export const useSyncRemoteTableSchemaChanges = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    SyncRemoteTableMutation,
+    SyncRemoteTableMutationVariables
+  >(SYNC_REMOTE_TABLE_SCHEMA_CHANGES, {
+    client: apolloMetadataClient ?? ({} as ApolloClient<any>),
+  });
+
+  const syncRemoteTableSchemaChanges = useCallback(
+    async (input: RemoteTableInput) => {
+      const remoteTable = await mutate({
+        variables: {
+          input,
+        },
+        update: (cache) => {
+          modifyRemoteTableFromCache({
+            cache: cache,
+            remoteTableName: input.name,
+            fieldModifiers: {
+              schemaPendingUpdates: () => [],
+            },
+          });
+        },
+      });
+
+      return remoteTable;
+    },
+    [mutate],
+  );
+
+  return {
+    syncRemoteTableSchemaChanges,
+  };
+};

packages/twenty-front/src/modules/databases/hooks/useUnsyncRemoteTable.ts

@@ -2,11 +2,12 @@ import { useCallback } from 'react';
 import { ApolloClient, useMutation } from '@apollo/client';
 
 import { UNSYNC_REMOTE_TABLE } from '@/databases/graphql/mutations/unsyncRemoteTable';
-import { GET_MANY_REMOTE_TABLES } from '@/databases/graphql/queries/findManyRemoteTables';
+import { modifyRemoteTableFromCache } from '@/databases/utils/modifyRecordTableFromCache';
 import { useApolloMetadataClient } from '@/object-metadata/hooks/useApolloMetadataClient';
 import { useFindManyObjectMetadataItems } from '@/object-metadata/hooks/useFindManyObjectMetadataItems';
 import {
   RemoteTableInput,
+  RemoteTableStatus,
   UnsyncRemoteTableMutation,
   UnsyncRemoteTableMutationVariables,
 } from '~/generated-metadata/graphql';
@@ -29,17 +30,15 @@ export const useUnsyncRemoteTable = () => {
         variables: {
           input,
         },
-        awaitRefetchQueries: true,
-        refetchQueries: [
-          {
-            query: GET_MANY_REMOTE_TABLES,
-            variables: {
-              input: {
-                id: input.remoteServerId,
-              },
+        update: (cache) => {
+          modifyRemoteTableFromCache({
+            cache: cache,
+            remoteTableName: input.name,
+            fieldModifiers: {
+              status: () => RemoteTableStatus.NotSynced,
             },
-          },
-        ],
+          });
+        },
       });
 
       await refetchObjectMetadataItems();

packages/twenty-front/src/modules/databases/utils/modifyRecordTableFromCache.ts

@@ -0,0 +1,22 @@
+import { ApolloCache } from '@apollo/client';
+import { Modifiers } from '@apollo/client/cache';
+
+import { RemoteTable } from '~/generated-metadata/graphql';
+
+export const modifyRemoteTableFromCache = ({
+  cache,
+  fieldModifiers,
+  remoteTableName,
+}: {
+  cache: ApolloCache<object>;
+  fieldModifiers: Modifiers<RemoteTable>;
+  remoteTableName: string;
+}) => {
+  const remoteTableCacheId = `RemoteTable:{"name":"${remoteTableName}"}`;
+
+  cache.modify({
+    id: remoteTableCacheId,
+    fields: fieldModifiers,
+    optimistic: true,
+  });
+};

packages/twenty-front/src/modules/settings/integrations/components/SettingsIntegrationRemoteTableSyncStatusToggle.tsx

@@ -4,24 +4,26 @@ import { Toggle } from '@/ui/input/components/Toggle';
 import { RemoteTableStatus } from '~/generated-metadata/graphql';
 
 export const SettingsIntegrationRemoteTableSyncStatusToggle = ({
-  table,
+  tableName,
+  tableStatus,
   onSyncUpdate,
 }: {
-  table: { id: string; name: string; status: RemoteTableStatus };
+  tableName: string;
+  tableStatus: RemoteTableStatus;
   onSyncUpdate: (value: boolean, tableName: string) => Promise<void>;
 }) => {
   const [isToggleLoading, setIsToggleLoading] = useState(false);
 
   const onChange = async (newValue: boolean) => {
     if (isToggleLoading) return;
     setIsToggleLoading(true);
-    await onSyncUpdate(newValue, table.name);
+    await onSyncUpdate(newValue, tableName);
     setIsToggleLoading(false);
   };
 
   return (
     <Toggle
-      value={table.status === RemoteTableStatus.Synced}
+      value={tableStatus === RemoteTableStatus.Synced}
       disabled={isToggleLoading}
       onChange={onChange}
     />

packages/twenty-front/src/modules/settings/integrations/database-connection/components/SettingsIntegrationDatabaseTablesListCard.tsx

@@ -1,8 +1,9 @@
-import { useCallback, useState } from 'react';
+import { useCallback } from 'react';
 import styled from '@emotion/styled';
 import { z } from 'zod';
 
 import { useSyncRemoteTable } from '@/databases/hooks/useSyncRemoteTable';
+import { useSyncRemoteTableSchemaChanges } from '@/databases/hooks/useSyncRemoteTableSchemaChanges';
 import { useUnsyncRemoteTable } from '@/databases/hooks/useUnsyncRemoteTable';
 import { SettingsListCard } from '@/settings/components/SettingsListCard';
 import { SettingsIntegrationRemoteTableSyncStatusToggle } from '@/settings/integrations/components/SettingsIntegrationRemoteTableSyncStatusToggle';
@@ -11,7 +12,6 @@ import {
   RemoteTable,
   RemoteTableStatus,
 } from '~/generated-metadata/graphql';
-import { isDefined } from '~/utils/isDefined';
 
 export const settingsIntegrationsDatabaseTablesSchema = z.object({
   syncedTablesByName: z.record(z.boolean()),
@@ -32,13 +32,6 @@ const StyledRowRightContainer = styled.div`
   gap: ${({ theme }) => theme.spacing(1)};
 `;
 
-const StyledText = styled.h3`
-  color: ${({ theme }) => theme.font.color.tertiary};
-  font-size: ${({ theme }) => theme.font.size.md};
-  font-weight: ${({ theme }) => theme.font.weight.regular};
-  margin: 0;
-`;
-
 const getDistantTableUpdatesText = (
   schemaPendingUpdates: DistantTableUpdate[],
 ) => {
@@ -66,24 +59,19 @@ export const SettingsIntegrationDatabaseTablesListCard = ({
 }: SettingsIntegrationDatabaseTablesListCardProps) => {
   const { syncRemoteTable } = useSyncRemoteTable();
   const { unsyncRemoteTable } = useUnsyncRemoteTable();
+  const { syncRemoteTableSchemaChanges, isLoading } =
+    useSyncRemoteTableSchemaChanges();
 
-  // We need to use a state because the table status update re-render the whole list of toggles
-  const [items] = useState(
-    tables.map((table) => ({
-      ...table,
-      id: table.name,
-      updatesText: table.schemaPendingUpdates
-        ? getDistantTableUpdatesText(table.schemaPendingUpdates)
-        : null,
-    })),
-  );
+  const items = tables.map((table) => ({
+    ...table,
+    id: table.name,
+    updatesText: table.schemaPendingUpdates
+      ? getDistantTableUpdatesText(table.schemaPendingUpdates)
+      : null,
+  }));
 
   const onSyncUpdate = useCallback(
     async (isSynced: boolean, tableName: string) => {
-      const table = items.find((table) => table.name === tableName);
-
-      if (!isDefined(table)) return;
-
       if (isSynced) {
         await syncRemoteTable({
           remoteServerId: connectionId,
@@ -96,7 +84,7 @@ export const SettingsIntegrationDatabaseTablesListCard = ({
         });
       }
     },
-    [items, syncRemoteTable, connectionId, unsyncRemoteTable],
+    [syncRemoteTable, connectionId, unsyncRemoteTable],
   );
 
   const rowRightComponent = useCallback(
@@ -111,9 +99,9 @@ export const SettingsIntegrationDatabaseTablesListCard = ({
       };
     }) => (
       <StyledRowRightContainer>
-        {item.updatesText && <StyledText>{item.updatesText}</StyledText>}
         <SettingsIntegrationRemoteTableSyncStatusToggle
-          table={item}
+          tableName={item.name}
+          tableStatus={item.status}
           onSyncUpdate={onSyncUpdate}
         />
       </StyledRowRightContainer>