Split components into object-metadata and object-record (#2425)

* Split components into object-metadata and object-record

* Fix seed

front/src/modules/object-metadata/hooks/useApolloMetadataClient.ts

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+
+import { ApolloMetadataClientContext } from '../context/ApolloClientMetadataContext';
+
+export const useApolloMetadataClient = () => {
+  const apolloMetadataClient = useContext(ApolloMetadataClientContext);
+
+  return apolloMetadataClient;
+};

front/src/modules/object-metadata/hooks/useCreateOneFieldMetadataItem.ts

@@ -0,0 +1,53 @@
+import { ApolloClient, useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import { FieldType } from '@/ui/object/field/types/FieldType';
+import { FieldMetadataType } from '~/generated/graphql';
+import {
+  CreateOneFieldMetadataItemMutation,
+  CreateOneFieldMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { CREATE_ONE_METADATA_FIELD } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+type CreateOneFieldMetadataItemArgs = Omit<
+  CreateOneFieldMetadataItemMutationVariables['input']['field'],
+  'type'
+> & {
+  type: FieldType;
+};
+
+export const useCreateOneFieldMetadataItem = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    CreateOneFieldMetadataItemMutation,
+    CreateOneFieldMetadataItemMutationVariables
+  >(CREATE_ONE_METADATA_FIELD, {
+    client: apolloMetadataClient ?? ({} as ApolloClient<any>),
+  });
+
+  const createOneFieldMetadataItem = async (
+    input: CreateOneFieldMetadataItemArgs,
+  ) => {
+    return await mutate({
+      variables: {
+        input: {
+          field: {
+            ...input,
+            type: input.type as FieldMetadataType, // Todo improve typing once we have aligned backend and frontend
+          },
+        },
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    createOneFieldMetadataItem,
+  };
+};

front/src/modules/object-metadata/hooks/useCreateOneObjectMetadataItem.ts

@@ -0,0 +1,43 @@
+import { ApolloClient, useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import {
+  CreateOneObjectMetadataItemMutation,
+  CreateOneObjectMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { CREATE_ONE_METADATA_OBJECT } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+export const useCreateOneObjectRecordMetadataItem = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    CreateOneObjectMetadataItemMutation,
+    CreateOneObjectMetadataItemMutationVariables
+  >(CREATE_ONE_METADATA_OBJECT, {
+    client: apolloMetadataClient ?? ({} as ApolloClient<any>),
+  });
+
+  const createOneObjectMetadataItem = async (
+    input: CreateOneObjectMetadataItemMutationVariables['input']['object'],
+  ) => {
+    return await mutate({
+      variables: {
+        input: {
+          object: {
+            ...input,
+          },
+        },
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    createOneObjectMetadataItem,
+  };
+};

front/src/modules/object-metadata/hooks/useDeleteOneFieldMetadataItem.ts

@@ -0,0 +1,39 @@
+import { ApolloClient, useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import {
+  DeleteOneFieldMetadataItemMutation,
+  DeleteOneFieldMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { DELETE_ONE_METADATA_FIELD } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+export const useDeleteOneFieldMetadataItem = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    DeleteOneFieldMetadataItemMutation,
+    DeleteOneFieldMetadataItemMutationVariables
+  >(DELETE_ONE_METADATA_FIELD, {
+    client: apolloMetadataClient ?? ({} as ApolloClient<any>),
+  });
+
+  const deleteOneFieldMetadataItem = async (
+    idToDelete: DeleteOneFieldMetadataItemMutationVariables['idToDelete'],
+  ) => {
+    return await mutate({
+      variables: {
+        idToDelete,
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    deleteOneFieldMetadataItem,
+  };
+};

front/src/modules/object-metadata/hooks/useDeleteOneObjectMetadataItem.ts

@@ -0,0 +1,39 @@
+import { ApolloClient, useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import {
+  DeleteOneObjectMetadataItemMutation,
+  DeleteOneObjectMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { DELETE_ONE_METADATA_OBJECT } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+export const useDeleteOneObjectMetadataItem = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    DeleteOneObjectMetadataItemMutation,
+    DeleteOneObjectMetadataItemMutationVariables
+  >(DELETE_ONE_METADATA_OBJECT, {
+    client: apolloMetadataClient ?? ({} as ApolloClient<any>),
+  });
+
+  const deleteOneObjectMetadataItem = async (
+    idToDelete: DeleteOneObjectMetadataItemMutationVariables['idToDelete'],
+  ) => {
+    return await mutate({
+      variables: {
+        idToDelete,
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    deleteOneObjectMetadataItem,
+  };
+};

front/src/modules/object-metadata/hooks/useFieldMetadataItem.ts

@@ -0,0 +1,57 @@
+import { MetadataFieldDataType } from '@/settings/data-model/types/ObjectFieldDataType';
+import { Field } from '~/generated/graphql';
+
+import { formatFieldMetadataItemInput } from '../utils/formatFieldMetadataItemInput';
+
+import { useCreateOneFieldMetadataItem } from './useCreateOneFieldMetadataItem';
+import { useDeleteOneFieldMetadataItem } from './useDeleteOneFieldMetadataItem';
+import { useUpdateOneFieldMetadataItem } from './useUpdateOneFieldMetadataItem';
+
+export const useFieldMetadataItem = () => {
+  const { createOneFieldMetadataItem } = useCreateOneFieldMetadataItem();
+  const { updateOneFieldMetadataItem } = useUpdateOneFieldMetadataItem();
+  const { deleteOneFieldMetadataItem } = useDeleteOneFieldMetadataItem();
+
+  const createMetadataField = (
+    input: Pick<Field, 'label' | 'icon' | 'description'> & {
+      objectMetadataId: string;
+      type: MetadataFieldDataType;
+    },
+  ) =>
+    createOneFieldMetadataItem({
+      ...formatFieldMetadataItemInput(input),
+      objectMetadataId: input.objectMetadataId,
+      type: input.type,
+    });
+
+  const editMetadataField = (
+    input: Pick<Field, 'id' | 'label' | 'icon' | 'description'>,
+  ) =>
+    updateOneFieldMetadataItem({
+      fieldMetadataIdToUpdate: input.id,
+      updatePayload: formatFieldMetadataItemInput(input),
+    });
+
+  const activateMetadataField = (metadataField: Field) =>
+    updateOneFieldMetadataItem({
+      fieldMetadataIdToUpdate: metadataField.id,
+      updatePayload: { isActive: true },
+    });
+
+  const disableMetadataField = (metadataField: Field) =>
+    updateOneFieldMetadataItem({
+      fieldMetadataIdToUpdate: metadataField.id,
+      updatePayload: { isActive: false },
+    });
+
+  const eraseMetadataField = (metadataField: Field) =>
+    deleteOneFieldMetadataItem(metadataField.id);
+
+  return {
+    activateMetadataField,
+    createMetadataField,
+    disableMetadataField,
+    eraseMetadataField,
+    editMetadataField,
+  };
+};

front/src/modules/object-metadata/hooks/useFindManyObjectMetadataItems.ts

@@ -0,0 +1,69 @@
+import { useMemo } from 'react';
+import { useQuery } from '@apollo/client';
+
+import { useSnackBar } from '@/ui/feedback/snack-bar/hooks/useSnackBar';
+import {
+  ObjectMetadataItemsQuery,
+  ObjectMetadataItemsQueryVariables,
+} from '~/generated-metadata/graphql';
+import { logError } from '~/utils/logError';
+
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+import { formatPagedObjectMetadataItemsToObjectMetadataItems } from '../utils/formatPagedObjectMetadataItemsToObjectMetadataItems';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+// TODO: test fetchMore
+export const useFindManyObjectMetadataItems = ({
+  skip,
+}: { skip?: boolean } = {}) => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const { enqueueSnackBar } = useSnackBar();
+
+  const {
+    data,
+    fetchMore: fetchMoreInternal,
+    loading,
+    error,
+  } = useQuery<ObjectMetadataItemsQuery, ObjectMetadataItemsQueryVariables>(
+    FIND_MANY_METADATA_OBJECTS,
+    {
+      client: apolloMetadataClient ?? undefined,
+      skip: skip || !apolloMetadataClient,
+      onError: (error) => {
+        logError('useFindManyObjectMetadataItems error : ' + error);
+        enqueueSnackBar(
+          `Error during useFindManyObjectMetadataItems, ${error.message}`,
+          {
+            variant: 'error',
+          },
+        );
+      },
+      onCompleted: () => {},
+    },
+  );
+
+  const hasMore = data?.objects?.pageInfo?.hasNextPage;
+
+  const fetchMore = () =>
+    fetchMoreInternal({
+      variables: {
+        afterCursor: data?.objects?.pageInfo?.endCursor,
+      },
+    });
+
+  const objectMetadataItems = useMemo(() => {
+    return formatPagedObjectMetadataItemsToObjectMetadataItems({
+      pagedObjectMetadataItems: data,
+    });
+  }, [data]);
+
+  return {
+    objectMetadataItems,
+    hasMore,
+    fetchMore,
+    loading,
+    error,
+  };
+};

front/src/modules/object-metadata/hooks/useFindOneObjectMetadataItem.ts

@@ -0,0 +1,126 @@
+import { gql } from '@apollo/client';
+
+import { generateCreateOneObjectMutation } from '@/object-record/utils/generateCreateOneObjectMutation';
+import { generateDeleteOneObjectMutation } from '@/object-record/utils/generateDeleteOneObjectMutation';
+import { generateFindManyCustomObjectsQuery } from '@/object-record/utils/generateFindManyCustomObjectsQuery';
+import { generateFindOneCustomObjectQuery } from '@/object-record/utils/generateFindOneCustomObjectQuery';
+import { generateUpdateOneObjectMutation } from '@/object-record/utils/generateUpdateOneObjectMutation';
+import { useLazyLoadIcons } from '@/ui/input/hooks/useLazyLoadIcons';
+import { FieldMetadata } from '@/ui/object/field/types/FieldMetadata';
+import { FilterDefinition } from '@/ui/object/object-filter-dropdown/types/FilterDefinition';
+import { SortDefinition } from '@/ui/object/object-sort-dropdown/types/SortDefinition';
+import { ColumnDefinition } from '@/ui/object/record-table/types/ColumnDefinition';
+
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
+import { formatFieldMetadataItemAsColumnDefinition } from '../utils/formatFieldMetadataItemAsColumnDefinition';
+import { formatFieldMetadataItemAsFilterDefinition } from '../utils/formatFieldMetadataItemAsFilterDefinition';
+import { formatFieldMetadataItemAsSortDefinition } from '../utils/formatFieldMetadataItemAsSortDefinition';
+
+import { useFindManyObjectMetadataItems } from './useFindManyObjectMetadataItems';
+
+const EMPTY_QUERY = gql`
+  query EmptyQuery {
+    empty
+  }
+`;
+
+const EMPTY_MUTATION = gql`
+  mutation EmptyMutation {
+    empty
+  }
+`;
+
+export const useFindOneObjectMetadataItem = ({
+  objectNamePlural,
+  objectNameSingular,
+  skip,
+}: ObjectMetadataItemIdentifier & { skip?: boolean }) => {
+  const { objectMetadataItems, loading } = useFindManyObjectMetadataItems({
+    skip,
+  });
+
+  const foundObjectMetadataItem = objectMetadataItems.find(
+    (object) =>
+      object.namePlural === objectNamePlural ||
+      object.nameSingular === objectNameSingular,
+  );
+
+  const { icons } = useLazyLoadIcons();
+
+  const objectNotFoundInMetadata =
+    objectMetadataItems.length === 0 ||
+    (objectMetadataItems.length > 0 && !foundObjectMetadataItem);
+
+  const activeFields =
+    foundObjectMetadataItem?.fields.filter(({ isActive }) => isActive) ?? [];
+
+  const columnDefinitions: ColumnDefinition<FieldMetadata>[] =
+    foundObjectMetadataItem
+      ? activeFields.map((field, index) =>
+          formatFieldMetadataItemAsColumnDefinition({
+            position: index,
+            field,
+            objectMetadataItem: foundObjectMetadataItem,
+            icons,
+          }),
+        )
+      : [];
+
+  const filterDefinitions: FilterDefinition[] = activeFields.map((field) =>
+    formatFieldMetadataItemAsFilterDefinition({
+      field,
+      icons,
+    }),
+  );
+
+  const sortDefinitions: SortDefinition[] = activeFields.map((field) =>
+    formatFieldMetadataItemAsSortDefinition({
+      field,
+      icons,
+    }),
+  );
+
+  const findManyQuery = foundObjectMetadataItem
+    ? generateFindManyCustomObjectsQuery({
+        objectMetadataItem: foundObjectMetadataItem,
+      })
+    : EMPTY_QUERY;
+
+  const findOneQuery = foundObjectMetadataItem
+    ? generateFindOneCustomObjectQuery({
+        objectMetadataItem: foundObjectMetadataItem,
+      })
+    : EMPTY_QUERY;
+
+  const createOneMutation = foundObjectMetadataItem
+    ? generateCreateOneObjectMutation({
+        objectMetadataItem: foundObjectMetadataItem,
+      })
+    : EMPTY_MUTATION;
+
+  const updateOneMutation = foundObjectMetadataItem
+    ? generateUpdateOneObjectMutation({
+        objectMetadataItem: foundObjectMetadataItem,
+      })
+    : EMPTY_MUTATION;
+
+  const deleteOneMutation = foundObjectMetadataItem
+    ? generateDeleteOneObjectMutation({
+        objectMetadataItem: foundObjectMetadataItem,
+      })
+    : EMPTY_MUTATION;
+
+  return {
+    foundObjectMetadataItem,
+    objectNotFoundInMetadata,
+    columnDefinitions,
+    filterDefinitions,
+    sortDefinitions,
+    findManyQuery,
+    findOneQuery,
+    createOneMutation,
+    updateOneMutation,
+    deleteOneMutation,
+    loading,
+  };
+};

front/src/modules/object-metadata/hooks/useObjectMetadataItemForSettings.ts

@@ -0,0 +1,80 @@
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
+import { formatObjectMetadataItemInput } from '../utils/formatObjectMetadataItemInput';
+import { getObjectSlug } from '../utils/getObjectSlug';
+
+import { useCreateOneObjectRecordMetadataItem } from './useCreateOneObjectMetadataItem';
+import { useDeleteOneObjectMetadataItem } from './useDeleteOneObjectMetadataItem';
+import { useFindManyObjectMetadataItems } from './useFindManyObjectMetadataItems';
+import { useUpdateOneObjectMetadataItem } from './useUpdateOneObjectMetadataItem';
+
+export const useObjectMetadataItemForSettings = () => {
+  const { objectMetadataItems, loading } = useFindManyObjectMetadataItems();
+
+  const activeObjectMetadataItems = objectMetadataItems.filter(
+    ({ isActive }) => isActive,
+  );
+  const disabledObjectMetadataItems = objectMetadataItems.filter(
+    ({ isActive }) => !isActive,
+  );
+
+  const findActiveObjectMetadataItemBySlug = (slug: string) =>
+    activeObjectMetadataItems.find(
+      (activeObjectMetadataItem) =>
+        getObjectSlug(activeObjectMetadataItem) === slug,
+    );
+
+  const { createOneObjectMetadataItem } =
+    useCreateOneObjectRecordMetadataItem();
+  const { updateOneObjectMetadataItem } = useUpdateOneObjectMetadataItem();
+  const { deleteOneObjectMetadataItem } = useDeleteOneObjectMetadataItem();
+
+  const createObjectMetadataItem = (
+    input: Pick<
+      ObjectMetadataItem,
+      'labelPlural' | 'labelSingular' | 'icon' | 'description'
+    >,
+  ) => createOneObjectMetadataItem(formatObjectMetadataItemInput(input));
+
+  const editObjectMetadataItem = (
+    input: Pick<
+      ObjectMetadataItem,
+      'id' | 'labelPlural' | 'labelSingular' | 'icon' | 'description'
+    >,
+  ) =>
+    updateOneObjectMetadataItem({
+      idToUpdate: input.id,
+      updatePayload: formatObjectMetadataItemInput(input),
+    });
+
+  const activateObjectMetadataItem = (
+    objectMetadataItem: Pick<ObjectMetadataItem, 'id'>,
+  ) =>
+    updateOneObjectMetadataItem({
+      idToUpdate: objectMetadataItem.id,
+      updatePayload: { isActive: true },
+    });
+
+  const disableObjectMetadataItem = (
+    objectMetadataItem: Pick<ObjectMetadataItem, 'id'>,
+  ) =>
+    updateOneObjectMetadataItem({
+      idToUpdate: objectMetadataItem.id,
+      updatePayload: { isActive: false },
+    });
+
+  const eraseObjectMetadataItem = (
+    objectMetadataItem: Pick<ObjectMetadataItem, 'id'>,
+  ) => deleteOneObjectMetadataItem(objectMetadataItem.id);
+
+  return {
+    activateObjectMetadataItem,
+    activeObjectMetadataItems,
+    createObjectMetadataItem,
+    disabledObjectMetadataItems,
+    disableObjectMetadataItem,
+    editObjectMetadataItem,
+    eraseObjectMetadataItem,
+    findActiveObjectMetadataItemBySlug,
+    loading,
+  };
+};

front/src/modules/object-metadata/hooks/useUpdateOneFieldMetadataItem.ts

@@ -0,0 +1,50 @@
+import { useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import {
+  UpdateOneFieldMetadataItemMutation,
+  UpdateOneFieldMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { UPDATE_ONE_METADATA_FIELD } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+export const useUpdateOneFieldMetadataItem = () => {
+  const apolloMetadataClient = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    UpdateOneFieldMetadataItemMutation,
+    UpdateOneFieldMetadataItemMutationVariables
+  >(UPDATE_ONE_METADATA_FIELD, {
+    client: apolloMetadataClient ?? undefined,
+  });
+
+  const updateOneFieldMetadataItem = async ({
+    fieldMetadataIdToUpdate,
+    updatePayload,
+  }: {
+    fieldMetadataIdToUpdate: UpdateOneFieldMetadataItemMutationVariables['idToUpdate'];
+    updatePayload: Pick<
+      UpdateOneFieldMetadataItemMutationVariables['updatePayload'],
+      'description' | 'icon' | 'isActive' | 'label' | 'name'
+    >;
+  }) => {
+    return await mutate({
+      variables: {
+        idToUpdate: fieldMetadataIdToUpdate,
+        updatePayload: {
+          ...updatePayload,
+          label: updatePayload.label ?? undefined,
+        },
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    updateOneFieldMetadataItem,
+  };
+};

front/src/modules/object-metadata/hooks/useUpdateOneObjectMetadataItem.ts

@@ -0,0 +1,54 @@
+import { useMutation } from '@apollo/client';
+import { getOperationName } from '@apollo/client/utilities';
+
+import {
+  UpdateOneObjectMetadataItemMutation,
+  UpdateOneObjectMetadataItemMutationVariables,
+} from '~/generated-metadata/graphql';
+
+import { UPDATE_ONE_METADATA_OBJECT } from '../graphql/mutations';
+import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
+
+import { useApolloMetadataClient } from './useApolloMetadataClient';
+
+// TODO: Slice the Apollo store synchronously in the update function instead of subscribing, so we can use update after read in the same function call
+export const useUpdateOneObjectMetadataItem = () => {
+  const apolloClientMetadata = useApolloMetadataClient();
+
+  const [mutate] = useMutation<
+    UpdateOneObjectMetadataItemMutation,
+    UpdateOneObjectMetadataItemMutationVariables
+  >(UPDATE_ONE_METADATA_OBJECT, {
+    client: apolloClientMetadata ?? undefined,
+  });
+
+  const updateOneObjectMetadataItem = async ({
+    idToUpdate,
+    updatePayload,
+  }: {
+    idToUpdate: UpdateOneObjectMetadataItemMutationVariables['idToUpdate'];
+    updatePayload: Pick<
+      UpdateOneObjectMetadataItemMutationVariables['updatePayload'],
+      | 'description'
+      | 'icon'
+      | 'isActive'
+      | 'labelPlural'
+      | 'labelSingular'
+      | 'namePlural'
+      | 'nameSingular'
+    >;
+  }) => {
+    return await mutate({
+      variables: {
+        idToUpdate,
+        updatePayload,
+      },
+      awaitRefetchQueries: true,
+      refetchQueries: [getOperationName(FIND_MANY_METADATA_OBJECTS) ?? ''],
+    });
+  };
+
+  return {
+    updateOneObjectMetadataItem,
+  };
+};