feat: create custom fields for projects

frontend/common/services/useMetadataField.ts

@@ -1,17 +1,19 @@
+import { sortBy } from 'lodash'
+
 import { Res } from 'common/types/responses'
 import { Req } from 'common/types/requests'
 import { service } from 'common/service'
+import transformCorePaging from 'common/transformCorePaging'
 import Utils from 'common/utils/utils'
 import { CustomMetadataField } from 'common/types/metadata-field'
 import {
   Environment,
+  Metadata,
   MetadataField,
-  MetadataModelField,
   PagedResponse,
   ProjectFlag,
   Segment,
 } from 'common/types/responses'
-import { mergeMetadataFields } from 'common/utils/mergeMetadataFields'
 
 type EntityType = 'feature' | 'segment' | 'environment'
 
@@ -25,13 +27,13 @@ type EntityMetadataParams = {
 
 type EntityData = ProjectFlag | Segment | Environment
 
+type EntityWithMetadata = {
+  metadata?: Metadata[]
+}
+
 function getEntityUrl(params: EntityMetadataParams): string | null {
   const { entityId, entityType, projectId } = params
 
-  if (!entityId) {
-    return null
-  }
-
   switch (entityType) {
     case 'feature':
       return `projects/${projectId}/features/${entityId}/`
@@ -87,13 +89,12 @@ export const metadataService = service
           // Build queries to run in parallel
           const queries: Promise<{ data?: unknown; error?: unknown }>[] = [
             baseQuery({
-              url: `metadata/fields/?${Utils.toParam({
-                organisation: arg.organisationId,
+              url: `projects/${arg.projectId}/metadata/fields/?${Utils.toParam({
+                entity: arg.entityType,
+                include_organisation: true,
+                page_size: 100,
               })}`,
             }),
-            baseQuery({
-              url: `organisations/${arg.organisationId}/metadata-model-fields/`,
-            }),
           ]
 
           // Only fetch entity data if we have an entityId
@@ -104,30 +105,54 @@ export const metadataService = service
           // Fetch all in parallel
           const results = await Promise.all(queries)
 
-          const [fieldsRes, modelFieldsRes, entityRes] = results
+          const [fieldsRes, entityRes] = results
 
           // Handle errors
           if (fieldsRes.error) {
             return { error: fieldsRes.error as Res['metadataList'] }
           }
-          if (modelFieldsRes.error) {
-            return {
-              error: modelFieldsRes.error as Res['metadataModelFieldList'],
-            }
-          }
+
           if (entityRes?.error) {
             return { error: entityRes.error as EntityData }
           }
 
-          // Merge and return
-          const mergedMetadata = mergeMetadataFields(
-            fieldsRes.data as PagedResponse<MetadataField>,
-            modelFieldsRes.data as PagedResponse<MetadataModelField>,
-            entityRes?.data as EntityData | null,
-            arg.entityContentType,
-          )
+          const fieldList = fieldsRes.data as PagedResponse<MetadataField>
+          const entityData = (entityRes?.data ??
+            null) as EntityWithMetadata | null
+
+          // Map fields to custom metadata fields with required status
+          const fieldsForContentType: CustomMetadataField[] =
+            fieldList.results.map((meta) => {
+              const matchingModelField = meta.model_fields.find(
+                (mf) => mf.content_type === arg.entityContentType,
+              )
+              return {
+                ...meta,
+                isRequiredFor: !!matchingModelField?.is_required_for.length,
+                metadataModelFieldId: matchingModelField
+                  ? matchingModelField.id
+                  : null,
+              }
+            })
+
+          // Get existing values from the entity
+          const existingValues: Metadata[] = entityData?.metadata ?? []
+
+          // Merge field definitions with existing values
+          const mergedMetadata = fieldsForContentType.map((field) => {
+            const existingValue = existingValues.find(
+              (v) => v.model_field === field.metadataModelFieldId,
+            )
+            return {
+              ...field,
+              field_value: existingValue?.field_value ?? '',
+              hasValue: !!existingValue,
+            }
+          })
 
-          return { data: mergedMetadata }
+          return {
+            data: sortBy(mergedMetadata, (m) => (m.isRequiredFor ? -1 : 1)),
+          }
         },
       }),
       getMetadataField: builder.query<
@@ -147,6 +172,25 @@ export const metadataService = service
         query: (query: Req['getMetadataList']) => ({
           url: `metadata/fields/?${Utils.toParam(query)}`,
         }),
+        transformResponse: (res: Res['metadataList'], _, req) =>
+          transformCorePaging(req, res),
+      }),
+      getProjectMetadataFieldList: builder.query<
+        Res['projectMetadataFieldList'],
+        Req['getProjectMetadataFieldList']
+      >({
+        providesTags: [{ id: 'LIST', type: 'Metadata' }],
+        query: (query: Req['getProjectMetadataFieldList']) => ({
+          url: `projects/${query.project_id}/metadata/fields/?${Utils.toParam({
+            ...(query.include_organisation
+              ? { include_organisation: true }
+              : {}),
+            page: query.page,
+            page_size: query.page_size,
+          })}`,
+        }),
+        transformResponse: (res: Res['projectMetadataFieldList'], _, req) =>
+          transformCorePaging(req, res),
       }),
       updateMetadataField: builder.mutation<
         Res['metadataField'],
@@ -229,6 +273,20 @@ export async function getEntityMetadataFields(
     metadataService.endpoints.getEntityMetadataFields.initiate(data, options),
   )
 }
+export async function getProjectMetadataFieldList(
+  store: any,
+  data: Req['getProjectMetadataFieldList'],
+  options?: Parameters<
+    typeof metadataService.endpoints.getProjectMetadataFieldList.initiate
+  >[1],
+) {
+  return store.dispatch(
+    metadataService.endpoints.getProjectMetadataFieldList.initiate(
+      data,
+      options,
+    ),
+  )
+}
 // END OF FUNCTION_EXPORTS
 
 export const {
@@ -237,6 +295,7 @@ export const {
   useGetEntityMetadataFieldsQuery,
   useGetMetadataFieldListQuery,
   useGetMetadataFieldQuery,
+  useGetProjectMetadataFieldListQuery,
   useUpdateMetadataFieldMutation,
   // END OF EXPORTS
 } = metadataService

frontend/common/stores/project-store.js

@@ -27,10 +27,12 @@ const controller = {
       ? data.post(`${Project.api}environments/${cloneId}/clone/`, {
           clone_feature_states_async: cloneFeatureStatesAsync,
           description,
+          metadata: metadata || [],
           name,
         })
       : data.post(`${Project.api}environments/`, {
           description,
+          metadata: metadata || [],
           name,
           project: projectId,
         })

frontend/common/types/requests.ts

@@ -425,14 +425,19 @@ export type Req = {
     }
   }
   getMetadataField: { organisation_id: number }
-  getMetadataList: { organisation: number }
+  getMetadataList: PagedRequest<{ organisation: number }>
+  getProjectMetadataFieldList: PagedRequest<{
+    project_id: number
+    include_organisation?: boolean
+  }>
   updateMetadataField: {
     id: number
     body: {
       name: string
       type: string
       description: string
       organisation: number
+      project?: number | null
     }
   }
   deleteMetadataField: { id: number }
@@ -442,6 +447,7 @@ export type Req = {
       name: string
       organisation: number
       type: string
+      project?: number | null
     }
   }
 

frontend/common/types/responses.ts

@@ -772,12 +772,20 @@ export type Metadata = {
   field_value: string
 }
 
+export type MetadataFieldModelField = {
+  id: number
+  content_type: number
+  is_required_for: isRequiredFor[]
+}
+
 export type MetadataField = {
   id: number
   name: string
   type: string
   description: string
   organisation: number
+  project: number | null
+  model_fields: MetadataFieldModelField[]
 }
 
 export type ContentType = {
@@ -789,6 +797,7 @@ export type ContentType = {
 
 export type isRequiredFor = {
   content_type: number
+  object_id: number
 }
 
 export type MetadataModelField = {
@@ -1120,6 +1129,7 @@ export type Res = {
   metadataModelFieldList: PagedResponse<MetadataModelField>
   metadataModelField: MetadataModelField
   metadataList: PagedResponse<MetadataField>
+  projectMetadataFieldList: PagedResponse<MetadataField>
   metadataField: MetadataField
   launchDarklyProjectImport: LaunchDarklyProjectImport
   launchDarklyProjectsImport: LaunchDarklyProjectImport[]