2282 Rename components to use the new naming convention part 3 (#2296)

part 3 of the renaming

front/src/modules/metadata/components/MetadataObjectNavItems.tsx

@@ -1,38 +0,0 @@
-import { useNavigate } from 'react-router-dom';
-
-import { Icon123 } from '@/ui/input/constants/icons';
-import { useLazyLoadIcons } from '@/ui/input/hooks/useLazyLoadIcons';
-import NavItem from '@/ui/navigation/navbar/components/NavItem';
-
-import { useFindManyMetadataObjects } from '../hooks/useFindManyMetadataObjects';
-
-export const MetadataObjectNavItems = () => {
-  const { metadataObjects } = useFindManyMetadataObjects();
-
-  const navigate = useNavigate();
-  const { icons } = useLazyLoadIcons();
-
-  return (
-    <>
-      {metadataObjects
-        .filter(
-          (metadataObject) =>
-            metadataObject.isActive &&
-            !metadataObject.namePlural.endsWith('V2'),
-        )
-        .map((metadataObject) => {
-          return (
-            <NavItem
-              key={metadataObject.id}
-              label={metadataObject.labelPlural}
-              to={`/objects/${metadataObject.namePlural}`}
-              Icon={metadataObject.icon ? icons[metadataObject.icon] : Icon123}
-              onClick={() => {
-                navigate(`/objects/${metadataObject.namePlural}`);
-              }}
-            />
-          );
-        })}
-    </>
-  );
-};

front/src/modules/metadata/components/ObjectMetadataNavItems.tsx

@@ -0,0 +1,42 @@
+import { useNavigate } from 'react-router-dom';
+
+import { Icon123 } from '@/ui/input/constants/icons';
+import { useLazyLoadIcons } from '@/ui/input/hooks/useLazyLoadIcons';
+import NavItem from '@/ui/navigation/navbar/components/NavItem';
+
+import { useFindManyObjectMetadataItems } from '../hooks/useFindManyObjectMetadataItems';
+
+export const ObjectMetadataNavItems = () => {
+  const { objectMetadataItems } = useFindManyObjectMetadataItems();
+
+  const navigate = useNavigate();
+  const { icons } = useLazyLoadIcons();
+
+  return (
+    <>
+      {objectMetadataItems
+        .filter(
+          (objectMetadataItem) =>
+            objectMetadataItem.isActive &&
+            !objectMetadataItem.namePlural.endsWith('V2'),
+        )
+        .map((objectMetadataItem) => {
+          return (
+            <NavItem
+              key={objectMetadataItem.id}
+              label={objectMetadataItem.labelPlural}
+              to={`/objects/${objectMetadataItem.namePlural}`}
+              Icon={
+                objectMetadataItem.icon
+                  ? icons[objectMetadataItem.icon]
+                  : Icon123
+              }
+              onClick={() => {
+                navigate(`/objects/${objectMetadataItem.namePlural}`);
+              }}
+            />
+          );
+        })}
+    </>
+  );
+};

front/src/modules/metadata/components/ObjectTableEffect.tsx

@@ -5,7 +5,7 @@ import { availableTableColumnsScopedState } from '@/ui/object/record-table/state
 import { useView } from '@/views/hooks/useView';
 import { ViewType } from '@/views/types/ViewType';
 
-import { useMetadataObjectInContext } from '../hooks/useMetadataObjectInContext';
+import { useObjectMetadataItemInContext } from '../hooks/useObjectMetadataItemInContext';
 
 export const ObjectTableEffect = () => {
   const {
@@ -20,20 +20,20 @@ export const ObjectTableEffect = () => {
     columnDefinitions,
     filterDefinitions,
     sortDefinitions,
-    foundMetadataObject,
-  } = useMetadataObjectInContext();
+    foundObjectMetadataItem,
+  } = useObjectMetadataItemInContext();
 
-  const tableScopeId = foundMetadataObject?.namePlural ?? '';
+  const tableScopeId = foundObjectMetadataItem?.namePlural ?? '';
 
   const setAvailableTableColumns = useSetRecoilState(
     availableTableColumnsScopedState(tableScopeId),
   );
 
   useEffect(() => {
-    if (!foundMetadataObject) {
+    if (!foundObjectMetadataItem) {
       return;
     }
-    setViewObjectId?.(foundMetadataObject.id);
+    setViewObjectId?.(foundObjectMetadataItem.id);
     setViewType?.(ViewType.Table);
 
     setAvailableSortDefinitions?.(sortDefinitions);
@@ -49,7 +49,7 @@ export const ObjectTableEffect = () => {
     setAvailableSortDefinitions,
     setAvailableFilterDefinitions,
     setAvailableFieldDefinitions,
-    foundMetadataObject,
+    foundObjectMetadataItem,
     sortDefinitions,
     filterDefinitions,
   ]);

front/src/modules/metadata/components/RecordShowPage.tsx

@@ -23,8 +23,8 @@ import { InlineCellHotkeyScope } from '@/ui/object/record-inline-cell/types/Inli
 import { PageTitle } from '@/ui/utilities/page-title/PageTitle';
 import { RecoilScope } from '@/ui/utilities/recoil-scope/components/RecoilScope';
 
-import { useFindOneMetadataObject } from '../hooks/useFindOneMetadataObject';
 import { useFindOneObject } from '../hooks/useFindOneObject';
+import { useFindOneObjectMetadataItem } from '../hooks/useFindOneObjectMetadataItem';
 import { useUpdateOneObject } from '../hooks/useUpdateOneObject';
 import { formatMetadataFieldAsColumnDefinition } from '../utils/formatMetadataFieldAsColumnDefinition';
 
@@ -36,7 +36,7 @@ export const RecordShowPage = () => {
 
   const { icons } = useLazyLoadIcons();
 
-  const { foundMetadataObject } = useFindOneMetadataObject({
+  const { foundObjectMetadataItem } = useFindOneObjectMetadataItem({
     objectNameSingular,
   });
 
@@ -115,7 +115,7 @@ export const RecordShowPage = () => {
                 avatarType="squared"
               />
               <PropertyBox extraPadding={true}>
-                {foundMetadataObject?.fields
+                {foundObjectMetadataItem?.fields
                   .toSorted((a, b) =>
                     DateTime.fromISO(a.createdAt)
                       .diff(DateTime.fromISO(b.createdAt))
@@ -132,7 +132,7 @@ export const RecordShowPage = () => {
                             formatMetadataFieldAsColumnDefinition({
                               field: metadataField,
                               position: index,
-                              metadataObject: foundMetadataObject,
+                              objectMetadataItem: foundObjectMetadataItem,
                               icons,
                             }),
                           useUpdateEntityMutation: useUpdateOneObjectMutation,

front/src/modules/metadata/components/RecordTable.tsx

@@ -17,9 +17,9 @@ import { viewFieldsToColumnDefinitions } from '@/views/utils/viewFieldsToColumnD
 import { viewFiltersToFilters } from '@/views/utils/viewFiltersToFilters';
 import { viewSortsToSorts } from '@/views/utils/viewSortsToSorts';
 
-import { useMetadataObjectInContext } from '../hooks/useMetadataObjectInContext';
+import { useObjectMetadataItemInContext } from '../hooks/useObjectMetadataItemInContext';
 import { useUpdateOneObject } from '../hooks/useUpdateOneObject';
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
 import { ObjectTableEffect } from './ObjectTableEffect';
 import { ObjectRecordTableEffect } from './RecordTableEffect';
@@ -32,7 +32,7 @@ const StyledContainer = styled.div`
 `;
 
 export type ObjectTableProps = Pick<
-  MetadataObjectIdentifier,
+  ObjectMetadataItemIdentifier,
   'objectNamePlural'
 >;
 
@@ -40,9 +40,9 @@ export const ObjectTable = ({ objectNamePlural }: ObjectTableProps) => {
   const { updateOneObject } = useUpdateOneObject({
     objectNamePlural,
   });
-  const { columnDefinitions, foundMetadataObject } =
-    useMetadataObjectInContext();
-  const tableScopeId = foundMetadataObject?.namePlural ?? '';
+  const { columnDefinitions, foundObjectMetadataItem } =
+    useObjectMetadataItemInContext();
+  const tableScopeId = foundObjectMetadataItem?.namePlural ?? '';
   const viewScopeId = objectNamePlural ?? '';
 
   const { persistViewFields } = useViewFields(viewScopeId);

front/src/modules/metadata/components/RecordTableEffect.tsx

@@ -9,11 +9,11 @@ import { tableSortsScopedState } from '@/ui/object/record-table/states/tableSort
 import { useRecoilScopedValue } from '@/ui/utilities/recoil-scope/hooks/useRecoilScopedValue';
 
 import { useFindManyObjects } from '../hooks/useFindManyObjects';
-import { useMetadataObjectInContext } from '../hooks/useMetadataObjectInContext';
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { useObjectMetadataItemInContext } from '../hooks/useObjectMetadataItemInContext';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
 export type ObjectRecordTableEffectProps = Pick<
-  MetadataObjectIdentifier,
+  ObjectMetadataItemIdentifier,
   'objectNamePlural'
 >;
 
@@ -22,7 +22,7 @@ export const ObjectRecordTableEffect = ({
   objectNamePlural,
 }: ObjectRecordTableEffectProps) => {
   const setRecordTableData = useSetRecordTableData();
-  const { foundMetadataObject } = useMetadataObjectInContext();
+  const { foundObjectMetadataItem } = useObjectMetadataItemInContext();
 
   const tableFilters = useRecoilScopedValue(
     tableFiltersScopedState,
@@ -38,11 +38,11 @@ export const ObjectRecordTableEffect = ({
     objectNamePlural: objectNamePlural,
     filter: turnFiltersIntoWhereClauseV2(
       tableFilters,
-      foundMetadataObject?.fields ?? [],
+      foundObjectMetadataItem?.fields ?? [],
     ),
     orderBy: turnSortsIntoOrderByV2(
       tableSorts,
-      foundMetadataObject?.fields ?? [],
+      foundObjectMetadataItem?.fields ?? [],
     ),
   });
 

front/src/modules/metadata/components/RecordTablePage.tsx

@@ -3,7 +3,7 @@ import { useNavigate, useParams } from 'react-router-dom';
 import styled from '@emotion/styled';
 
 import { ObjectTable } from '@/metadata/components/RecordTable';
-import { MetadataObjectIdentifier } from '@/metadata/types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '@/metadata/types/ObjectMetadataItemIdentifier';
 import { IconBuildingSkyscraper } from '@/ui/display/icon';
 import { PageAddButton } from '@/ui/layout/page/PageAddButton';
 import { PageBody } from '@/ui/layout/page/PageBody';
@@ -16,8 +16,8 @@ import { TableRecoilScopeContext } from '@/ui/object/record-table/states/recoil-
 import { RecoilScope } from '@/ui/utilities/recoil-scope/components/RecoilScope';
 
 import { useCreateOneObject } from '../hooks/useCreateOneObject';
-import { useFindOneMetadataObject } from '../hooks/useFindOneMetadataObject';
-import { MetadataObjectScope } from '../scopes/MetadataObjectScope';
+import { useFindOneObjectMetadataItem } from '../hooks/useFindOneObjectMetadataItem';
+import { ObjectMetadataItemScope } from '../scopes/ObjectMetadataItemScope';
 
 const StyledTableContainer = styled.div`
   display: flex;
@@ -25,14 +25,14 @@ const StyledTableContainer = styled.div`
 `;
 
 export type RecordTablePageProps = Pick<
-  MetadataObjectIdentifier,
+  ObjectMetadataItemIdentifier,
   'objectNamePlural'
 >;
 
 export const RecordTablePage = () => {
   const objectNamePlural = useParams().objectNamePlural ?? '';
 
-  const { objectNotFoundInMetadata, loading } = useFindOneMetadataObject({
+  const { objectNotFoundInMetadata, loading } = useFindOneObjectMetadataItem({
     objectNamePlural,
   });
 
@@ -64,9 +64,11 @@ export const RecordTablePage = () => {
           CustomRecoilScopeContext={TableRecoilScopeContext}
         >
           <StyledTableContainer>
-            <MetadataObjectScope metadataObjectNamePlural={objectNamePlural}>
+            <ObjectMetadataItemScope
+              objectMetadataItemNamePlural={objectNamePlural}
+            >
               <ObjectTable objectNamePlural={objectNamePlural} />
-            </MetadataObjectScope>
+            </ObjectMetadataItemScope>
           </StyledTableContainer>
           <RecordTableActionBar />
           <RecordTableContextMenu />

front/src/modules/metadata/graphql/mutations.ts

@@ -1,7 +1,7 @@
 import { gql } from '@apollo/client';
 
 export const CREATE_ONE_METADATA_OBJECT = gql`
-  mutation CreateOneMetadataObject($input: CreateOneObjectInput!) {
+  mutation CreateOneObjectMetadataItem($input: CreateOneObjectInput!) {
     createOneObject(input: $input) {
       id
       dataSourceId
@@ -61,7 +61,7 @@ export const UPDATE_ONE_METADATA_FIELD = gql`
 `;
 
 export const UPDATE_ONE_METADATA_OBJECT = gql`
-  mutation UpdateOneMetadataObject(
+  mutation UpdateOneObjectMetadataItem(
     $idToUpdate: ID!
     $updatePayload: UpdateObjectInput!
   ) {
@@ -83,7 +83,7 @@ export const UPDATE_ONE_METADATA_OBJECT = gql`
 `;
 
 export const DELETE_ONE_METADATA_OBJECT = gql`
-  mutation DeleteOneMetadataObject($idToDelete: ID!) {
+  mutation DeleteOneObjectMetadataItem($idToDelete: ID!) {
     deleteOneObject(input: { id: $idToDelete }) {
       id
       dataSourceId

front/src/modules/metadata/graphql/queries.ts

@@ -1,7 +1,7 @@
 import { gql } from '@apollo/client';
 
 export const FIND_MANY_METADATA_OBJECTS = gql`
-  query MetadataObjects {
+  query ObjectMetadataItems {
     objects(paging: { first: 1000 }) {
       edges {
         node {

front/src/modules/metadata/hooks/useCreateOneObject.ts

@@ -1,26 +1,26 @@
 import { useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
 
 export const useCreateOneObject = ({
   objectNamePlural,
-}: Pick<MetadataObjectIdentifier, 'objectNamePlural'>) => {
+}: Pick<ObjectMetadataItemIdentifier, 'objectNamePlural'>) => {
   const {
-    foundMetadataObject,
+    foundObjectMetadataItem,
     objectNotFoundInMetadata,
     findManyQuery,
     createOneMutation,
-  } = useFindOneMetadataObject({
+  } = useFindOneObjectMetadataItem({
     objectNamePlural,
   });
 
   // TODO: type this with a minimal type at least with Record<string, any>
   const [mutate] = useMutation(createOneMutation);
 
-  const createOneObject = foundMetadataObject
+  const createOneObject = foundObjectMetadataItem
     ? (input: Record<string, any>) => {
         return mutate({
           variables: {

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

@@ -2,8 +2,8 @@ import { ApolloClient, useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
 import {
-  CreateOneMetadataObjectMutation,
-  CreateOneMetadataObjectMutationVariables,
+  CreateOneObjectMetadataItemMutation,
+  CreateOneObjectMetadataItemMutationVariables,
 } from '~/generated-metadata/graphql';
 
 import { CREATE_ONE_METADATA_OBJECT } from '../graphql/mutations';
@@ -11,18 +11,18 @@ import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
 
 import { useApolloMetadataClient } from './useApolloMetadataClient';
 
-export const useCreateOneMetadataObject = () => {
+export const useCreateOneObjectMetadataItem = () => {
   const apolloMetadataClient = useApolloMetadataClient();
 
   const [mutate] = useMutation<
-    CreateOneMetadataObjectMutation,
-    CreateOneMetadataObjectMutationVariables
+    CreateOneObjectMetadataItemMutation,
+    CreateOneObjectMetadataItemMutationVariables
   >(CREATE_ONE_METADATA_OBJECT, {
     client: apolloMetadataClient ?? ({} as ApolloClient<any>),
   });
 
-  const createOneMetadataObject = async (
-    input: CreateOneMetadataObjectMutationVariables['input']['object'],
+  const createOneObjectMetadataItem = async (
+    input: CreateOneObjectMetadataItemMutationVariables['input']['object'],
   ) => {
     return await mutate({
       variables: {
@@ -38,6 +38,6 @@ export const useCreateOneMetadataObject = () => {
   };
 
   return {
-    createOneMetadataObject,
+    createOneObjectMetadataItem,
   };
 };

front/src/modules/metadata/hooks/useDeleteOneObject.ts

@@ -1,26 +1,26 @@
 import { useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
 
 export const useDeleteOneObject = ({
   objectNamePlural,
-}: Pick<MetadataObjectIdentifier, 'objectNamePlural'>) => {
+}: Pick<ObjectMetadataItemIdentifier, 'objectNamePlural'>) => {
   const {
-    foundMetadataObject,
+    foundObjectMetadataItem,
     objectNotFoundInMetadata,
     findManyQuery,
     deleteOneMutation,
-  } = useFindOneMetadataObject({
+  } = useFindOneObjectMetadataItem({
     objectNamePlural,
   });
 
   // TODO: type this with a minimal type at least with Record<string, any>
   const [mutate] = useMutation(deleteOneMutation);
 
-  const deleteOneObject = foundMetadataObject
+  const deleteOneObject = foundObjectMetadataItem
     ? (input: Record<string, any>) => {
         return mutate({
           variables: {

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

@@ -2,8 +2,8 @@ import { ApolloClient, useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
 import {
-  DeleteOneMetadataObjectMutation,
-  DeleteOneMetadataObjectMutationVariables,
+  DeleteOneObjectMetadataItemMutation,
+  DeleteOneObjectMetadataItemMutationVariables,
 } from '~/generated-metadata/graphql';
 
 import { DELETE_ONE_METADATA_OBJECT } from '../graphql/mutations';
@@ -11,18 +11,18 @@ import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
 
 import { useApolloMetadataClient } from './useApolloMetadataClient';
 
-export const useDeleteOneMetadataObject = () => {
+export const useDeleteOneObjectMetadataItem = () => {
   const apolloMetadataClient = useApolloMetadataClient();
 
   const [mutate] = useMutation<
-    DeleteOneMetadataObjectMutation,
-    DeleteOneMetadataObjectMutationVariables
+    DeleteOneObjectMetadataItemMutation,
+    DeleteOneObjectMetadataItemMutationVariables
   >(DELETE_ONE_METADATA_OBJECT, {
     client: apolloMetadataClient ?? ({} as ApolloClient<any>),
   });
 
-  const deleteOneMetadataObject = async (
-    idToDelete: DeleteOneMetadataObjectMutationVariables['idToDelete'],
+  const deleteOneObjectMetadataItem = async (
+    idToDelete: DeleteOneObjectMetadataItemMutationVariables['idToDelete'],
   ) => {
     return await mutate({
       variables: {
@@ -34,6 +34,6 @@ export const useDeleteOneMetadataObject = () => {
   };
 
   return {
-    deleteOneMetadataObject,
+    deleteOneObjectMetadataItem,
   };
 };

front/src/modules/metadata/hooks/useFindAllMetadata.ts

@@ -2,12 +2,12 @@ import { useMemo } from 'react';
 import { useQuery } from '@apollo/client';
 
 import {
-  MetadataObjectsQuery,
-  MetadataObjectsQueryVariables,
+  ObjectMetadataItemsQuery,
+  ObjectMetadataItemsQueryVariables,
 } from '~/generated-metadata/graphql';
 
 import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
-import { formatPagedMetadataObjectsToMetadataObjects } from '../utils/formatPagedMetadataObjectsToMetadataObjects';
+import { formatPagedObjectMetadataItemsToObjectMetadataItems } from '../utils/formatPagedObjectMetadataItemsToObjectMetadataItems';
 
 import { useApolloMetadataClient } from './useApolloMetadataClient';
 
@@ -16,8 +16,8 @@ export const useFindAllMetadata = () => {
   const apolloMetadataClient = useApolloMetadataClient();
 
   const { data, fetchMore: fetchMoreInternal } = useQuery<
-    MetadataObjectsQuery,
-    MetadataObjectsQueryVariables
+    ObjectMetadataItemsQuery,
+    ObjectMetadataItemsQueryVariables
   >(FIND_MANY_METADATA_OBJECTS, {
     client: apolloMetadataClient ?? ({} as any),
     skip: !apolloMetadataClient,
@@ -32,14 +32,14 @@ export const useFindAllMetadata = () => {
       },
     });
 
-  const metadataObjects = useMemo(() => {
-    return formatPagedMetadataObjectsToMetadataObjects({
-      pagedMetadataObjects: data,
+  const objectMetadataItems = useMemo(() => {
+    return formatPagedObjectMetadataItemsToObjectMetadataItems({
+      pagedObjectMetadataItems: data,
     });
   }, [data]);
 
   return {
-    metadataObjects,
+    objectMetadataItems,
     hasMore,
     fetchMore,
   };

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

@@ -3,18 +3,18 @@ import { useQuery } from '@apollo/client';
 
 import { useSnackBar } from '@/ui/feedback/snack-bar/hooks/useSnackBar';
 import {
-  MetadataObjectsQuery,
-  MetadataObjectsQueryVariables,
+  ObjectMetadataItemsQuery,
+  ObjectMetadataItemsQueryVariables,
 } from '~/generated-metadata/graphql';
 import { logError } from '~/utils/logError';
 
 import { FIND_MANY_METADATA_OBJECTS } from '../graphql/queries';
-import { formatPagedMetadataObjectsToMetadataObjects } from '../utils/formatPagedMetadataObjectsToMetadataObjects';
+import { formatPagedObjectMetadataItemsToObjectMetadataItems } from '../utils/formatPagedObjectMetadataItemsToObjectMetadataItems';
 
 import { useApolloMetadataClient } from './useApolloMetadataClient';
 
 // TODO: test fetchMore
-export const useFindManyMetadataObjects = () => {
+export const useFindManyObjectMetadataItems = () => {
   const apolloMetadataClient = useApolloMetadataClient();
 
   const { enqueueSnackBar } = useSnackBar();
@@ -24,15 +24,15 @@ export const useFindManyMetadataObjects = () => {
     fetchMore: fetchMoreInternal,
     loading,
     error,
-  } = useQuery<MetadataObjectsQuery, MetadataObjectsQueryVariables>(
+  } = useQuery<ObjectMetadataItemsQuery, ObjectMetadataItemsQueryVariables>(
     FIND_MANY_METADATA_OBJECTS,
     {
       client: apolloMetadataClient ?? undefined,
       skip: !apolloMetadataClient,
       onError: (error) => {
-        logError('useFindManyMetadataObjects error : ' + error);
+        logError('useFindManyObjectMetadataItems error : ' + error);
         enqueueSnackBar(
-          `Error during useFindManyMetadataObjects, ${error.message}`,
+          `Error during useFindManyObjectMetadataItems, ${error.message}`,
           {
             variant: 'error',
           },
@@ -51,14 +51,14 @@ export const useFindManyMetadataObjects = () => {
       },
     });
 
-  const metadataObjects = useMemo(() => {
-    return formatPagedMetadataObjectsToMetadataObjects({
-      pagedMetadataObjects: data,
+  const objectMetadataItems = useMemo(() => {
+    return formatPagedObjectMetadataItemsToObjectMetadataItems({
+      pagedObjectMetadataItems: data,
     });
   }, [data]);
 
   return {
-    metadataObjects,
+    objectMetadataItems,
     hasMore,
     fetchMore,
     loading,

front/src/modules/metadata/hooks/useFindManyObjects.ts

@@ -4,11 +4,11 @@ import { useQuery } from '@apollo/client';
 import { useSnackBar } from '@/ui/feedback/snack-bar/hooks/useSnackBar';
 import { logError } from '~/utils/logError';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 import { PaginatedObjectType } from '../types/PaginatedObjectType';
 import { formatPagedObjectsToObjects } from '../utils/formatPagedObjectsToObjects';
 
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
 
 // TODO: test with a wrong name
 // TODO: add zod to validate that we have at least id on each object
@@ -19,13 +19,13 @@ export const useFindManyObjects = <
   filter,
   orderBy,
   onCompleted,
-}: Pick<MetadataObjectIdentifier, 'objectNamePlural'> & {
+}: Pick<ObjectMetadataItemIdentifier, 'objectNamePlural'> & {
   filter?: any;
   orderBy?: any;
   onCompleted?: (data: any) => void;
 }) => {
-  const { foundMetadataObject, objectNotFoundInMetadata, findManyQuery } =
-    useFindOneMetadataObject({
+  const { foundObjectMetadataItem, objectNotFoundInMetadata, findManyQuery } =
+    useFindOneObjectMetadataItem({
       objectNamePlural,
     });
 
@@ -34,7 +34,7 @@ export const useFindManyObjects = <
   const { data, loading, error } = useQuery<PaginatedObjectType<ObjectType>>(
     findManyQuery,
     {
-      skip: !foundMetadataObject,
+      skip: !foundObjectMetadataItem,
       variables: {
         filter: filter ?? {},
         orderBy: orderBy ?? {},

front/src/modules/metadata/hooks/useFindOneObject.ts

@@ -1,8 +1,8 @@
 import { useQuery } from '@apollo/client';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
 
 export const useFindOneObject = <
   ObjectType extends { id: string } & Record<string, any>,
@@ -10,12 +10,12 @@ export const useFindOneObject = <
   objectNameSingular,
   objectId,
   onCompleted,
-}: Pick<MetadataObjectIdentifier, 'objectNameSingular'> & {
+}: Pick<ObjectMetadataItemIdentifier, 'objectNameSingular'> & {
   objectId: string | undefined;
   onCompleted?: (data: ObjectType) => void;
 }) => {
-  const { foundMetadataObject, objectNotFoundInMetadata, findOneQuery } =
-    useFindOneMetadataObject({
+  const { foundObjectMetadataItem, objectNotFoundInMetadata, findOneQuery } =
+    useFindOneObjectMetadataItem({
       objectNameSingular,
     });
 
@@ -23,7 +23,7 @@ export const useFindOneObject = <
     { [nameSingular: string]: ObjectType },
     { objectId: string }
   >(findOneQuery, {
-    skip: !foundMetadataObject || !objectId,
+    skip: !foundObjectMetadataItem || !objectId,
     variables: {
       objectId: objectId ?? '',
     },

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

@@ -6,7 +6,7 @@ import { FilterDefinition } from '@/ui/object/object-filter-dropdown/types/Filte
 import { SortDefinition } from '@/ui/object/object-sort-dropdown/types/SortDefinition';
 import { ColumnDefinition } from '@/ui/object/record-table/types/ColumnDefinition';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 import { formatMetadataFieldAsColumnDefinition } from '../utils/formatMetadataFieldAsColumnDefinition';
 import { formatMetadataFieldAsFilterDefinition } from '../utils/formatMetadataFieldAsFilterDefinition';
 import { formatMetadataFieldAsSortDefinition } from '../utils/formatMetadataFieldAsSortDefinition';
@@ -16,15 +16,15 @@ import { generateFindManyCustomObjectsQuery } from '../utils/generateFindManyCus
 import { generateFindOneCustomObjectQuery } from '../utils/generateFindOneCustomObjectQuery';
 import { generateUpdateOneObjectMutation } from '../utils/generateUpdateOneObjectMutation';
 
-import { useFindManyMetadataObjects } from './useFindManyMetadataObjects';
+import { useFindManyObjectMetadataItems } from './useFindManyObjectMetadataItems';
 
-export const useFindOneMetadataObject = ({
+export const useFindOneObjectMetadataItem = ({
   objectNamePlural,
   objectNameSingular,
-}: MetadataObjectIdentifier) => {
-  const { metadataObjects, loading } = useFindManyMetadataObjects();
+}: ObjectMetadataItemIdentifier) => {
+  const { objectMetadataItems, loading } = useFindManyObjectMetadataItems();
 
-  const foundMetadataObject = metadataObjects.find(
+  const foundObjectMetadataItem = objectMetadataItems.find(
     (object) =>
       object.namePlural === objectNamePlural ||
       object.nameSingular === objectNameSingular,
@@ -33,21 +33,21 @@ export const useFindOneMetadataObject = ({
   const { icons } = useLazyLoadIcons();
 
   const objectNotFoundInMetadata =
-    metadataObjects.length === 0 ||
-    (metadataObjects.length > 0 && !foundMetadataObject);
+    objectMetadataItems.length === 0 ||
+    (objectMetadataItems.length > 0 && !foundObjectMetadataItem);
 
   const columnDefinitions: ColumnDefinition<FieldMetadata>[] =
-    foundMetadataObject?.fields.map((field, index) =>
+    foundObjectMetadataItem?.fields.map((field, index) =>
       formatMetadataFieldAsColumnDefinition({
         position: index,
         field,
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
         icons,
       }),
     ) ?? [];
 
   const filterDefinitions: FilterDefinition[] =
-    foundMetadataObject?.fields.map((field) =>
+    foundObjectMetadataItem?.fields.map((field) =>
       formatMetadataFieldAsFilterDefinition({
         field,
         icons,
@@ -55,16 +55,16 @@ export const useFindOneMetadataObject = ({
     ) ?? [];
 
   const sortDefinitions: SortDefinition[] =
-    foundMetadataObject?.fields.map((field) =>
+    foundObjectMetadataItem?.fields.map((field) =>
       formatMetadataFieldAsSortDefinition({
         field,
         icons,
       }),
     ) ?? [];
 
-  const findManyQuery = foundMetadataObject
+  const findManyQuery = foundObjectMetadataItem
     ? generateFindManyCustomObjectsQuery({
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
       })
     : gql`
         query EmptyQuery {
@@ -72,9 +72,9 @@ export const useFindOneMetadataObject = ({
         }
       `;
 
-  const findOneQuery = foundMetadataObject
+  const findOneQuery = foundObjectMetadataItem
     ? generateFindOneCustomObjectQuery({
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
       })
     : gql`
         query EmptyQuery {
@@ -82,9 +82,9 @@ export const useFindOneMetadataObject = ({
         }
       `;
 
-  const createOneMutation = foundMetadataObject
+  const createOneMutation = foundObjectMetadataItem
     ? generateCreateOneObjectMutation({
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
       })
     : gql`
         mutation EmptyMutation {
@@ -92,9 +92,9 @@ export const useFindOneMetadataObject = ({
         }
       `;
 
-  const updateOneMutation = foundMetadataObject
+  const updateOneMutation = foundObjectMetadataItem
     ? generateUpdateOneObjectMutation({
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
       })
     : gql`
         mutation EmptyMutation {
@@ -103,9 +103,9 @@ export const useFindOneMetadataObject = ({
       `;
 
   // TODO: implement backend delete
-  const deleteOneMutation = foundMetadataObject
+  const deleteOneMutation = foundObjectMetadataItem
     ? generateDeleteOneObjectMutation({
-        metadataObject: foundMetadataObject,
+        objectMetadataItem: foundObjectMetadataItem,
       })
     : gql`
         mutation EmptyMutation {
@@ -114,7 +114,7 @@ export const useFindOneMetadataObject = ({
       `;
 
   return {
-    foundMetadataObject,
+    foundObjectMetadataItem,
     objectNotFoundInMetadata,
     columnDefinitions,
     filterDefinitions,

front/src/modules/metadata/hooks/useMetadataObject.ts

@@ -1,18 +0,0 @@
-import { useAvailableScopeIdOrThrow } from '@/ui/utilities/recoil-scope/scopes-internal/hooks/useAvailableScopeId';
-
-import { MetadataObjectScopeInternalContext } from '../scopes/scope-internal-context/MetadataObjectScopeInternalContext';
-
-type UseMetadataObjectProps = {
-  metadataObjectNamePlural?: string;
-};
-
-export const useMetadataObject = (props?: UseMetadataObjectProps) => {
-  const scopeId = useAvailableScopeIdOrThrow(
-    MetadataObjectScopeInternalContext,
-    props?.metadataObjectNamePlural,
-  );
-
-  return {
-    scopeId,
-  };
-};

front/src/modules/metadata/hooks/useMetadataObjectForSettings.ts

@@ -1,73 +0,0 @@
-import { MetadataObject } from '../types/MetadataObject';
-import { formatMetadataObjectInput } from '../utils/formatMetadataObjectInput';
-import { getObjectSlug } from '../utils/getObjectSlug';
-
-import { useCreateOneMetadataObject } from './useCreateOneMetadataObject';
-import { useDeleteOneMetadataObject } from './useDeleteOneMetadataObject';
-import { useFindManyMetadataObjects } from './useFindManyMetadataObjects';
-import { useUpdateOneMetadataObject } from './useUpdateOneMetadataObject';
-
-export const useMetadataObjectForSettings = () => {
-  const { metadataObjects, loading } = useFindManyMetadataObjects();
-
-  const activeMetadataObjects = metadataObjects.filter(
-    ({ isActive }) => isActive,
-  );
-  const disabledMetadataObjects = metadataObjects.filter(
-    ({ isActive }) => !isActive,
-  );
-
-  const findActiveMetadataObjectBySlug = (slug: string) =>
-    activeMetadataObjects.find(
-      (activeMetadataObject) => getObjectSlug(activeMetadataObject) === slug,
-    );
-
-  const { createOneMetadataObject } = useCreateOneMetadataObject();
-  const { updateOneMetadataObject } = useUpdateOneMetadataObject();
-  const { deleteOneMetadataObject } = useDeleteOneMetadataObject();
-
-  const createMetadataObject = (
-    input: Pick<
-      MetadataObject,
-      'labelPlural' | 'labelSingular' | 'icon' | 'description'
-    >,
-  ) => createOneMetadataObject(formatMetadataObjectInput(input));
-
-  const editMetadataObject = (
-    input: Pick<
-      MetadataObject,
-      'id' | 'labelPlural' | 'labelSingular' | 'icon' | 'description'
-    >,
-  ) =>
-    updateOneMetadataObject({
-      idToUpdate: input.id,
-      updatePayload: formatMetadataObjectInput(input),
-    });
-
-  const activateMetadataObject = (metadataObject: Pick<MetadataObject, 'id'>) =>
-    updateOneMetadataObject({
-      idToUpdate: metadataObject.id,
-      updatePayload: { isActive: true },
-    });
-
-  const disableMetadataObject = (metadataObject: Pick<MetadataObject, 'id'>) =>
-    updateOneMetadataObject({
-      idToUpdate: metadataObject.id,
-      updatePayload: { isActive: false },
-    });
-
-  const eraseMetadataObject = (metadataObject: Pick<MetadataObject, 'id'>) =>
-    deleteOneMetadataObject(metadataObject.id);
-
-  return {
-    activateMetadataObject,
-    activeMetadataObjects,
-    createMetadataObject,
-    disabledMetadataObjects,
-    disableMetadataObject,
-    editMetadataObject,
-    eraseMetadataObject,
-    findActiveMetadataObjectBySlug,
-    loading,
-  };
-};

front/src/modules/metadata/hooks/useMetadataObjectInContext.ts

@@ -1,34 +0,0 @@
-import { useContext } from 'react';
-
-import { MetadataObjectScopeInternalContext } from '../scopes/scope-internal-context/MetadataObjectScopeInternalContext';
-
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
-
-export const useMetadataObjectInContext = () => {
-  const context = useContext(MetadataObjectScopeInternalContext);
-
-  if (!context) {
-    throw new Error(
-      'Could not find MetadataObjectScopeInternalContext while in useMetadataObjectInContext',
-    );
-  }
-
-  const {
-    foundMetadataObject,
-    loading,
-    columnDefinitions,
-    filterDefinitions,
-    sortDefinitions,
-  } = useFindOneMetadataObject({
-    objectNamePlural: context.objectNamePlural,
-  });
-
-  return {
-    ...context,
-    foundMetadataObject,
-    loading,
-    columnDefinitions,
-    filterDefinitions,
-    sortDefinitions,
-  };
-};

front/src/modules/metadata/hooks/useObjectMetadataItem.ts

@@ -0,0 +1,18 @@
+import { useAvailableScopeIdOrThrow } from '@/ui/utilities/recoil-scope/scopes-internal/hooks/useAvailableScopeId';
+
+import { ObjectMetadataItemScopeInternalContext } from '../scopes/scope-internal-context/ObjectMetadataItemScopeInternalContext';
+
+type UseObjectMetadataItemProps = {
+  objectMetadataItemNamePlural?: string;
+};
+
+export const useObjectMetadataItem = (props?: UseObjectMetadataItemProps) => {
+  const scopeId = useAvailableScopeIdOrThrow(
+    ObjectMetadataItemScopeInternalContext,
+    props?.objectMetadataItemNamePlural,
+  );
+
+  return {
+    scopeId,
+  };
+};

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

@@ -0,0 +1,79 @@
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
+import { formatObjectMetadataItemInput } from '../utils/formatObjectMetadataItemInput';
+import { getObjectSlug } from '../utils/getObjectSlug';
+
+import { useCreateOneObjectMetadataItem } 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 } = useCreateOneObjectMetadataItem();
+  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/metadata/hooks/useObjectMetadataItemInContext.ts

@@ -0,0 +1,34 @@
+import { useContext } from 'react';
+
+import { ObjectMetadataItemScopeInternalContext } from '../scopes/scope-internal-context/ObjectMetadataItemScopeInternalContext';
+
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
+
+export const useObjectMetadataItemInContext = () => {
+  const context = useContext(ObjectMetadataItemScopeInternalContext);
+
+  if (!context) {
+    throw new Error(
+      'Could not find ObjectMetadataItemScopeInternalContext while in useObjectMetadataItemInContext',
+    );
+  }
+
+  const {
+    foundObjectMetadataItem,
+    loading,
+    columnDefinitions,
+    filterDefinitions,
+    sortDefinitions,
+  } = useFindOneObjectMetadataItem({
+    objectNamePlural: context.objectNamePlural,
+  });
+
+  return {
+    ...context,
+    foundObjectMetadataItem,
+    loading,
+    columnDefinitions,
+    filterDefinitions,
+    sortDefinitions,
+  };
+};

front/src/modules/metadata/hooks/useSeedCustomObjectsTemp.ts

@@ -1,15 +1,15 @@
 import { isNonEmptyArray } from '~/utils/isNonEmptyArray';
 
 import { useCreateOneMetadataField } from './useCreateOneMetadataField';
-import { useCreateOneMetadataObject } from './useCreateOneMetadataObject';
+import { useCreateOneObjectMetadataItem } from './useCreateOneObjectMetadataItem';
 
 export const useSeedCustomObjectsTemp = () => {
-  const { createOneMetadataObject } = useCreateOneMetadataObject();
+  const { createOneObjectMetadataItem } = useCreateOneObjectMetadataItem();
   const { createOneMetadataField } = useCreateOneMetadataField();
 
   return async () => {
-    const { data: createdMetadataObject, errors } =
-      await createOneMetadataObject({
+    const { data: createdObjectMetadataItem, errors } =
+      await createOneObjectMetadataItem({
         labelPlural: 'Suppliers',
         labelSingular: 'Supplier',
         nameSingular: 'supplier',
@@ -19,7 +19,8 @@ export const useSeedCustomObjectsTemp = () => {
       });
 
     if (!isNonEmptyArray(errors)) {
-      const supplierObjectId = createdMetadataObject?.createOneObject?.id ?? '';
+      const supplierObjectId =
+        createdObjectMetadataItem?.createOneObject?.id ?? '';
 
       await createOneMetadataField({
         objectId: supplierObjectId,

front/src/modules/metadata/hooks/useUpdateOneObject.ts

@@ -1,20 +1,20 @@
 import { useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
-import { MetadataObjectIdentifier } from '../types/MetadataObjectIdentifier';
+import { ObjectMetadataItemIdentifier } from '../types/ObjectMetadataItemIdentifier';
 
-import { useFindOneMetadataObject } from './useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from './useFindOneObjectMetadataItem';
 
 export const useUpdateOneObject = ({
   objectNamePlural,
   objectNameSingular,
-}: MetadataObjectIdentifier) => {
+}: ObjectMetadataItemIdentifier) => {
   const {
-    foundMetadataObject,
+    foundObjectMetadataItem,
     objectNotFoundInMetadata,
     findManyQuery,
     updateOneMutation,
-  } = useFindOneMetadataObject({
+  } = useFindOneObjectMetadataItem({
     objectNamePlural,
     objectNameSingular,
   });
@@ -24,7 +24,7 @@ export const useUpdateOneObject = ({
     refetchQueries: [getOperationName(findManyQuery) ?? ''],
   });
 
-  const updateOneObject = foundMetadataObject
+  const updateOneObject = foundObjectMetadataItem
     ? ({
         idToUpdate,
         input,

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

@@ -2,8 +2,8 @@ import { useMutation } from '@apollo/client';
 import { getOperationName } from '@apollo/client/utilities';
 
 import {
-  UpdateOneMetadataObjectMutation,
-  UpdateOneMetadataObjectMutationVariables,
+  UpdateOneObjectMetadataItemMutation,
+  UpdateOneObjectMetadataItemMutationVariables,
 } from '~/generated-metadata/graphql';
 
 import { UPDATE_ONE_METADATA_OBJECT } from '../graphql/mutations';
@@ -12,23 +12,23 @@ 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 useUpdateOneMetadataObject = () => {
+export const useUpdateOneObjectMetadataItem = () => {
   const apolloClientMetadata = useApolloMetadataClient();
 
   const [mutate] = useMutation<
-    UpdateOneMetadataObjectMutation,
-    UpdateOneMetadataObjectMutationVariables
+    UpdateOneObjectMetadataItemMutation,
+    UpdateOneObjectMetadataItemMutationVariables
   >(UPDATE_ONE_METADATA_OBJECT, {
     client: apolloClientMetadata ?? undefined,
   });
 
-  const updateOneMetadataObject = async ({
+  const updateOneObjectMetadataItem = async ({
     idToUpdate,
     updatePayload,
   }: {
-    idToUpdate: UpdateOneMetadataObjectMutationVariables['idToUpdate'];
+    idToUpdate: UpdateOneObjectMetadataItemMutationVariables['idToUpdate'];
     updatePayload: Pick<
-      UpdateOneMetadataObjectMutationVariables['updatePayload'],
+      UpdateOneObjectMetadataItemMutationVariables['updatePayload'],
       | 'description'
       | 'icon'
       | 'isActive'
@@ -49,6 +49,6 @@ export const useUpdateOneMetadataObject = () => {
   };
 
   return {
-    updateOneMetadataObject,
+    updateOneObjectMetadataItem,
   };
 };

front/src/modules/metadata/scopes/MetadataObjectScope.tsx

@@ -1,24 +0,0 @@
-import { ReactNode } from 'react';
-
-import { MetadataObjectScopeInternalContext } from './scope-internal-context/MetadataObjectScopeInternalContext';
-
-type MetadataObjectScopeProps = {
-  children: ReactNode;
-  metadataObjectNamePlural: string;
-};
-
-export const MetadataObjectScope = ({
-  children,
-  metadataObjectNamePlural,
-}: MetadataObjectScopeProps) => {
-  return (
-    <MetadataObjectScopeInternalContext.Provider
-      value={{
-        scopeId: metadataObjectNamePlural,
-        objectNamePlural: metadataObjectNamePlural,
-      }}
-    >
-      {children}
-    </MetadataObjectScopeInternalContext.Provider>
-  );
-};

front/src/modules/metadata/scopes/ObjectMetadataItemScope.tsx

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+
+import { ObjectMetadataItemScopeInternalContext } from './scope-internal-context/ObjectMetadataItemScopeInternalContext';
+
+type ObjectMetadataItemScopeProps = {
+  children: ReactNode;
+  objectMetadataItemNamePlural: string;
+};
+
+export const ObjectMetadataItemScope = ({
+  children,
+  objectMetadataItemNamePlural,
+}: ObjectMetadataItemScopeProps) => {
+  return (
+    <ObjectMetadataItemScopeInternalContext.Provider
+      value={{
+        scopeId: objectMetadataItemNamePlural,
+        objectNamePlural: objectMetadataItemNamePlural,
+      }}
+    >
+      {children}
+    </ObjectMetadataItemScopeInternalContext.Provider>
+  );
+};

front/src/modules/metadata/scopes/scope-internal-context/ObjectMetadataItemScopeInternalContext.ts

@@ -1,9 +1,9 @@
 import { ScopedStateKey } from '@/ui/utilities/recoil-scope/scopes-internal/types/ScopedStateKey';
 import { createScopeInternalContext } from '@/ui/utilities/recoil-scope/scopes-internal/utils/createScopeInternalContext';
 
-type MetadataObjectScopeInternalContextProps = ScopedStateKey & {
+type ObjectMetadataItemScopeInternalContextProps = ScopedStateKey & {
   objectNamePlural: string;
 };
 
-export const MetadataObjectScopeInternalContext =
-  createScopeInternalContext<MetadataObjectScopeInternalContextProps>();
+export const ObjectMetadataItemScopeInternalContext =
+  createScopeInternalContext<ObjectMetadataItemScopeInternalContextProps>();

front/src/modules/metadata/states/metadataObjectsState.ts

@@ -1,11 +0,0 @@
-import { atom } from 'recoil';
-
-import { MetadataObject } from '../types/MetadataObject';
-
-/**
- * @deprecated Use `useFindManyMetadataObjects` instead.
- */
-export const metadataObjectsState = atom<MetadataObject[]>({
-  key: 'metadataObjectsState',
-  default: [],
-});

front/src/modules/metadata/states/objectMetadataItemsState.ts

@@ -0,0 +1,11 @@
+import { atom } from 'recoil';
+
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
+
+/**
+ * @deprecated Use `useFindManyObjectMetadataItems` instead.
+ */
+export const objectMetadataItemsState = atom<ObjectMetadataItem[]>({
+  key: 'objectMetadataItemsState',
+  default: [],
+});

front/src/modules/metadata/states/selectors/activeMetadataObjectsSelector.ts

@@ -1,10 +0,0 @@
-import { selector } from 'recoil';
-
-import { MetadataObject } from '../../types/MetadataObject';
-import { metadataObjectsState } from '../metadataObjectsState';
-
-export const activeMetadataObjectsSelector = selector<MetadataObject[]>({
-  key: 'activeMetadataObjectsSelector',
-  get: ({ get }) =>
-    get(metadataObjectsState).filter(({ isActive }) => isActive),
-});

front/src/modules/metadata/states/selectors/activeObjectMetadataItemsSelector.ts

@@ -0,0 +1,12 @@
+import { selector } from 'recoil';
+
+import { ObjectMetadataItem } from '../../types/ObjectMetadataItem';
+import { objectMetadataItemsState } from '../objectMetadataItemsState';
+
+export const activeObjectMetadataItemsSelector = selector<ObjectMetadataItem[]>(
+  {
+    key: 'activeObjectMetadataItemsSelector',
+    get: ({ get }) =>
+      get(objectMetadataItemsState).filter(({ isActive }) => isActive),
+  },
+);

front/src/modules/metadata/states/selectors/disabledMetadataObjectsSelector.ts

@@ -1,10 +0,0 @@
-import { selector } from 'recoil';
-
-import { MetadataObject } from '../../types/MetadataObject';
-import { metadataObjectsState } from '../metadataObjectsState';
-
-export const disabledMetadataObjectsSelector = selector<MetadataObject[]>({
-  key: 'disabledMetadataObjectsSelector',
-  get: ({ get }) =>
-    get(metadataObjectsState).filter(({ isActive }) => !isActive),
-});

front/src/modules/metadata/states/selectors/disabledObjectMetadataItemsSelector.ts

@@ -0,0 +1,12 @@
+import { selector } from 'recoil';
+
+import { ObjectMetadataItem } from '../../types/ObjectMetadataItem';
+import { objectMetadataItemsState } from '../objectMetadataItemsState';
+
+export const disabledObjectMetadataItemsSelector = selector<
+  ObjectMetadataItem[]
+>({
+  key: 'disabledObjectMetadataItemsSelector',
+  get: ({ get }) =>
+    get(objectMetadataItemsState).filter(({ isActive }) => !isActive),
+});

front/src/modules/metadata/types/ObjectMetadataItem.ts

@@ -1,6 +1,6 @@
 import { Field, Object as GeneratedObject } from '~/generated-metadata/graphql';
 
-export type MetadataObject = Omit<
+export type ObjectMetadataItem = Omit<
   GeneratedObject,
   'fields' | 'dataSourceId'
 > & {

front/src/modules/metadata/types/ObjectMetadataItemIdentifier.ts

@@ -1,4 +1,4 @@
-export type MetadataObjectIdentifier = {
+export type ObjectMetadataItemIdentifier = {
   objectNamePlural?: string;
   objectNameSingular?: string;
 };

front/src/modules/metadata/utils/formatMetadataFieldAsColumnDefinition.ts

@@ -1,19 +1,19 @@
 import { FieldMetadata } from '@/ui/object/field/types/FieldMetadata';
 import { ColumnDefinition } from '@/ui/object/record-table/types/ColumnDefinition';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 import { parseFieldType } from './parseFieldType';
 
 export const formatMetadataFieldAsColumnDefinition = ({
   position,
   field,
-  metadataObject,
+  objectMetadataItem,
   icons,
 }: {
   position: number;
-  field: MetadataObject['fields'][0];
-  metadataObject: Omit<MetadataObject, 'fields'>;
+  field: ObjectMetadataItem['fields'][0];
+  objectMetadataItem: Omit<ObjectMetadataItem, 'fields'>;
   icons: Record<string, any>;
 }): ColumnDefinition<FieldMetadata> => ({
   position,
@@ -27,5 +27,5 @@ export const formatMetadataFieldAsColumnDefinition = ({
   },
   Icon: icons[field.icon ?? 'Icon123'],
   isVisible: true,
-  basePathToShowPage: `/object/${metadataObject.nameSingular}/`,
+  basePathToShowPage: `/object/${objectMetadataItem.nameSingular}/`,
 });

front/src/modules/metadata/utils/formatMetadataFieldAsFilterDefinition.ts

@@ -1,12 +1,12 @@
 import { FilterDefinition } from '@/ui/object/object-filter-dropdown/types/FilterDefinition';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 export const formatMetadataFieldAsFilterDefinition = ({
   field,
   icons,
 }: {
-  field: MetadataObject['fields'][0];
+  field: ObjectMetadataItem['fields'][0];
   icons: Record<string, any>;
 }): FilterDefinition => ({
   fieldId: field.id,

front/src/modules/metadata/utils/formatMetadataFieldAsSortDefinition.ts

@@ -1,12 +1,12 @@
 import { SortDefinition } from '@/ui/object/object-sort-dropdown/types/SortDefinition';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 export const formatMetadataFieldAsSortDefinition = ({
   field,
   icons,
 }: {
-  field: MetadataObject['fields'][0];
+  field: ObjectMetadataItem['fields'][0];
   icons: Record<string, any>;
 }): SortDefinition => ({
   fieldId: field.id,

front/src/modules/metadata/utils/formatObjectMetadataItemInput.ts

@@ -1,10 +1,10 @@
 import toCamelCase from 'lodash.camelcase';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
-export const formatMetadataObjectInput = (
+export const formatObjectMetadataItemInput = (
   input: Pick<
-    MetadataObject,
+    ObjectMetadataItem,
     'labelPlural' | 'labelSingular' | 'icon' | 'description'
   >,
 ) => ({

front/src/modules/metadata/utils/formatPagedMetadataObjectsToMetadataObjects.ts

@@ -1,17 +0,0 @@
-import { MetadataObjectsQuery } from '~/generated-metadata/graphql';
-
-import { MetadataObject } from '../types/MetadataObject';
-
-export const formatPagedMetadataObjectsToMetadataObjects = ({
-  pagedMetadataObjects: pagedMetadataObjects,
-}: {
-  pagedMetadataObjects: MetadataObjectsQuery | undefined;
-}) => {
-  const formattedObjects: MetadataObject[] =
-    pagedMetadataObjects?.objects.edges.map((object) => ({
-      ...object.node,
-      fields: object.node.fields.edges.map((field) => field.node),
-    })) ?? [];
-
-  return formattedObjects;
-};

front/src/modules/metadata/utils/formatPagedObjectMetadataItemsToObjectMetadataItems.ts

@@ -0,0 +1,17 @@
+import { ObjectMetadataItemsQuery } from '~/generated-metadata/graphql';
+
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
+
+export const formatPagedObjectMetadataItemsToObjectMetadataItems = ({
+  pagedObjectMetadataItems: pagedObjectMetadataItems,
+}: {
+  pagedObjectMetadataItems: ObjectMetadataItemsQuery | undefined;
+}) => {
+  const formattedObjects: ObjectMetadataItem[] =
+    pagedObjectMetadataItems?.objects.edges.map((object) => ({
+      ...object.node,
+      fields: object.node.fields.edges.map((field) => field.node),
+    })) ?? [];
+
+  return formattedObjects;
+};

front/src/modules/metadata/utils/generateCreateOneObjectMutation.ts

@@ -2,14 +2,14 @@ import { gql } from '@apollo/client';
 
 import { capitalize } from '~/utils/string/capitalize';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 export const generateCreateOneObjectMutation = ({
-  metadataObject,
+  objectMetadataItem,
 }: {
-  metadataObject: MetadataObject;
+  objectMetadataItem: ObjectMetadataItem;
 }) => {
-  const capitalizedObjectName = capitalize(metadataObject.nameSingular);
+  const capitalizedObjectName = capitalize(objectMetadataItem.nameSingular);
 
   return gql`
     mutation CreateOne${capitalizedObjectName}($input: ${capitalizedObjectName}CreateInput!)  {

front/src/modules/metadata/utils/generateDeleteOneObjectMutation.ts

@@ -2,15 +2,15 @@ import { gql } from '@apollo/client';
 
 import { capitalize } from '~/utils/string/capitalize';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 // TODO: implement
 export const generateDeleteOneObjectMutation = ({
-  metadataObject,
+  objectMetadataItem,
 }: {
-  metadataObject: MetadataObject;
+  objectMetadataItem: ObjectMetadataItem;
 }) => {
-  const capitalizedObjectName = capitalize(metadataObject.nameSingular);
+  const capitalizedObjectName = capitalize(objectMetadataItem.nameSingular);
 
   return gql`
     mutation DeleteOne${capitalizedObjectName}($input: ${capitalizedObjectName}DeleteInput!)  {

front/src/modules/metadata/utils/generateFindManyCustomObjectsQuery.ts

@@ -2,26 +2,28 @@ import { gql } from '@apollo/client';
 
 import { capitalize } from '~/utils/string/capitalize';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 import { mapFieldMetadataToGraphQLQuery } from './mapFieldMetadataToGraphQLQuery';
 
 export const generateFindManyCustomObjectsQuery = ({
-  metadataObject,
+  objectMetadataItem,
   _fromCursor,
 }: {
-  metadataObject: MetadataObject;
+  objectMetadataItem: ObjectMetadataItem;
   _fromCursor?: string;
 }) => {
   return gql`
-    query FindMany${metadataObject.namePlural}($filter: ${capitalize(
-    metadataObject.nameSingular,
-  )}FilterInput, $orderBy: ${capitalize(metadataObject.nameSingular)}OrderBy) {
-      ${metadataObject.namePlural}(filter: $filter, orderBy: $orderBy){
+    query FindMany${objectMetadataItem.namePlural}($filter: ${capitalize(
+    objectMetadataItem.nameSingular,
+  )}FilterInput, $orderBy: ${capitalize(
+    objectMetadataItem.nameSingular,
+  )}OrderBy) {
+      ${objectMetadataItem.namePlural}(filter: $filter, orderBy: $orderBy){
         edges {
           node {
             id
-            ${metadataObject.fields
+            ${objectMetadataItem.fields
               .map(mapFieldMetadataToGraphQLQuery)
               .join('\n')}
           }

front/src/modules/metadata/utils/generateFindOneCustomObjectQuery.ts

@@ -1,23 +1,25 @@
 import { gql } from '@apollo/client';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 import { mapFieldMetadataToGraphQLQuery } from './mapFieldMetadataToGraphQLQuery';
 
 export const generateFindOneCustomObjectQuery = ({
-  metadataObject,
+  objectMetadataItem,
 }: {
-  metadataObject: MetadataObject;
+  objectMetadataItem: ObjectMetadataItem;
 }) => {
   return gql`
-    query FindOne${metadataObject.nameSingular}($objectId: UUID!) {
-      ${metadataObject.nameSingular}(filter: {
+    query FindOne${objectMetadataItem.nameSingular}($objectId: UUID!) {
+      ${objectMetadataItem.nameSingular}(filter: {
         id: {
           eq: $objectId
         }
       }){
         id
-        ${metadataObject.fields.map(mapFieldMetadataToGraphQLQuery).join('\n')}
+        ${objectMetadataItem.fields
+          .map(mapFieldMetadataToGraphQLQuery)
+          .join('\n')}
       }
     }
   `;

front/src/modules/metadata/utils/generateUpdateOneObjectMutation.ts

@@ -2,14 +2,14 @@ import { gql } from '@apollo/client';
 
 import { capitalize } from '~/utils/string/capitalize';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 export const generateUpdateOneObjectMutation = ({
-  metadataObject,
+  objectMetadataItem,
 }: {
-  metadataObject: MetadataObject;
+  objectMetadataItem: ObjectMetadataItem;
 }) => {
-  const capitalizedObjectName = capitalize(metadataObject.nameSingular);
+  const capitalizedObjectName = capitalize(objectMetadataItem.nameSingular);
 
   return gql`
     mutation UpdateOne${capitalizedObjectName}($idToUpdate: ID!, $input: ${capitalizedObjectName}UpdateInput!)  {

front/src/modules/metadata/utils/getObjectSlug.ts

@@ -1,7 +1,7 @@
 import toKebabCase from 'lodash.kebabcase';
 
-import { MetadataObject } from '../types/MetadataObject';
+import { ObjectMetadataItem } from '../types/ObjectMetadataItem';
 
 export const getObjectSlug = (
-  metadataObject: Pick<MetadataObject, 'labelPlural'>,
-) => toKebabCase(metadataObject.labelPlural);
+  objectMetadataItem: Pick<ObjectMetadataItem, 'labelPlural'>,
+) => toKebabCase(objectMetadataItem.labelPlural);

front/src/modules/settings/data-model/new-object/components/SettingsAvailableStandardObjectItemTableRow.tsx

@@ -1,7 +1,7 @@
 import { useTheme } from '@emotion/react';
 import styled from '@emotion/styled';
 
-import { MetadataObject } from '@/metadata/types/MetadataObject';
+import { ObjectMetadataItem } from '@/metadata/types/ObjectMetadataItem';
 import { Checkbox } from '@/ui/input/components/Checkbox';
 import { useLazyLoadIcon } from '@/ui/input/hooks/useLazyLoadIcon';
 import { TableCell } from '@/ui/layout/table/components/TableCell';
@@ -9,7 +9,7 @@ import { TableRow } from '@/ui/layout/table/components/TableRow';
 
 type SettingsAvailableStandardObjectItemTableRowProps = {
   isSelected?: boolean;
-  objectItem: MetadataObject;
+  objectItem: ObjectMetadataItem;
   onClick?: () => void;
 };
 

front/src/modules/settings/data-model/new-object/components/SettingsAvailableStandardObjectsSection.tsx

@@ -1,4 +1,4 @@
-import { MetadataObject } from '@/metadata/types/MetadataObject';
+import { ObjectMetadataItem } from '@/metadata/types/ObjectMetadataItem';
 import { H2Title } from '@/ui/display/typography/components/H2Title';
 import { Section } from '@/ui/layout/section/components/Section';
 import { Table } from '@/ui/layout/table/components/Table';
@@ -11,7 +11,7 @@ import {
 } from './SettingsAvailableStandardObjectItemTableRow';
 
 type SettingsAvailableStandardObjectsSectionProps = {
-  objectItems: MetadataObject[];
+  objectItems: ObjectMetadataItem[];
   onChange: (selectedIds: Record<string, boolean>) => void;
   selectedIds: Record<string, boolean>;
 };

front/src/modules/settings/data-model/object-details/components/SettingsObjectItemTableRow.tsx

@@ -3,7 +3,7 @@ import { useTheme } from '@emotion/react';
 import styled from '@emotion/styled';
 
 import { useFindManyObjects } from '@/metadata/hooks/useFindManyObjects';
-import { MetadataObject } from '@/metadata/types/MetadataObject';
+import { ObjectMetadataItem } from '@/metadata/types/ObjectMetadataItem';
 import { Tag } from '@/ui/display/tag/components/Tag';
 import { useLazyLoadIcon } from '@/ui/input/hooks/useLazyLoadIcon';
 import { TableCell } from '@/ui/layout/table/components/TableCell';
@@ -11,7 +11,7 @@ import { TableRow } from '@/ui/layout/table/components/TableRow';
 
 type SettingsObjectItemTableRowProps = {
   action: ReactNode;
-  objectItem: MetadataObject;
+  objectItem: ObjectMetadataItem;
   onClick?: () => void;
 };
 

front/src/modules/views/hooks/internal/useViewFields.ts

@@ -1,7 +1,7 @@
 import { useApolloClient } from '@apollo/client';
 import { useRecoilCallback } from 'recoil';
 
-import { useFindOneMetadataObject } from '@/metadata/hooks/useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from '@/metadata/hooks/useFindOneObjectMetadataItem';
 import { currentViewIdScopedState } from '@/views/states/currentViewIdScopedState';
 import { savedViewFieldByKeyScopedFamilySelector } from '@/views/states/selectors/savedViewFieldByKeyScopedFamilySelector';
 import { viewObjectIdScopeState } from '@/views/states/viewObjectIdScopeState';
@@ -9,7 +9,7 @@ import { ViewField } from '@/views/types/ViewField';
 
 export const useViewFields = (viewScopeId: string) => {
   const { updateOneMutation, createOneMutation, findManyQuery } =
-    useFindOneMetadataObject({
+    useFindOneObjectMetadataItem({
       objectNameSingular: 'viewFieldV2',
     });
   const apolloClient = useApolloClient();

front/src/modules/views/hooks/internal/useViewFilters.ts

@@ -2,7 +2,7 @@ import { useApolloClient } from '@apollo/client';
 import { produce } from 'immer';
 import { useRecoilCallback } from 'recoil';
 
-import { useFindOneMetadataObject } from '@/metadata/hooks/useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from '@/metadata/hooks/useFindOneObjectMetadataItem';
 import { Filter } from '@/ui/object/object-filter-dropdown/types/Filter';
 import { currentViewFiltersScopedFamilyState } from '@/views/states/currentViewFiltersScopedFamilyState';
 import { currentViewIdScopedState } from '@/views/states/currentViewIdScopedState';
@@ -15,7 +15,7 @@ import { useViewSetStates } from '../useViewSetStates';
 
 export const useViewFilters = (viewScopeId: string) => {
   const { updateOneMutation, createOneMutation, findManyQuery } =
-    useFindOneMetadataObject({
+    useFindOneObjectMetadataItem({
       objectNameSingular: 'viewFilterV2',
     });
   const apolloClient = useApolloClient();

front/src/modules/views/hooks/internal/useViewSorts.ts

@@ -2,7 +2,7 @@ import { useApolloClient } from '@apollo/client';
 import { produce } from 'immer';
 import { useRecoilCallback } from 'recoil';
 
-import { useFindOneMetadataObject } from '@/metadata/hooks/useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from '@/metadata/hooks/useFindOneObjectMetadataItem';
 import { Sort } from '@/ui/object/object-sort-dropdown/types/Sort';
 import { currentViewIdScopedState } from '@/views/states/currentViewIdScopedState';
 import { currentViewSortsScopedFamilyState } from '@/views/states/currentViewSortsScopedFamilyState';
@@ -15,7 +15,7 @@ import { useViewSetStates } from '../useViewSetStates';
 
 export const useViewSorts = (viewScopeId: string) => {
   const { updateOneMutation, createOneMutation, findManyQuery } =
-    useFindOneMetadataObject({
+    useFindOneObjectMetadataItem({
       objectNameSingular: 'viewSortV2',
     });
   const apolloClient = useApolloClient();

front/src/modules/views/hooks/internal/useViews.ts

@@ -1,14 +1,14 @@
 import { useApolloClient } from '@apollo/client';
 import { useRecoilCallback } from 'recoil';
 
-import { useFindOneMetadataObject } from '@/metadata/hooks/useFindOneMetadataObject';
+import { useFindOneObjectMetadataItem } from '@/metadata/hooks/useFindOneObjectMetadataItem';
 import { viewObjectIdScopeState } from '@/views/states/viewObjectIdScopeState';
 import { viewTypeScopedState } from '@/views/states/viewTypeScopedState';
 import { View } from '@/views/types/View';
 
 export const useViews = (scopeId: string) => {
   const { updateOneMutation, createOneMutation, findManyQuery } =
-    useFindOneMetadataObject({
+    useFindOneObjectMetadataItem({
       objectNameSingular: 'viewV2',
     });
   const apolloClient = useApolloClient();