Feat/study registration form

packages/core/src/features/cedar/cedarApi.ts

@@ -0,0 +1,44 @@
+import { gen3Api } from '../gen3';
+
+export interface CreateCedarPayload {
+  cedar_user_uuid: string;
+  metadata: {
+    study_metadata: {
+      metadata_location: {
+        nih_application_id?: string;
+      };
+      minimal_info: {
+        study_name?: string;
+        study_description?: string;
+      };
+    };
+    clinicaltrials_gov?: string;
+  };
+}
+
+export interface CreateCedarResponse {
+  cedar_instance_id?: string;
+}
+
+export const cedarApi = gen3Api.injectEndpoints({
+  endpoints: (builder) => ({
+    createCedarInstance: builder.mutation<
+      CreateCedarResponse,
+      { cedarWrapperURL: string; payload: CreateCedarPayload }
+    >({
+      query: ({ cedarWrapperURL, payload }) => ({
+        url: `${cedarWrapperURL}/create`,
+        method: 'POST',
+        body: payload,
+      }),
+    }),
+  }),
+});
+
+export const { useCreateCedarInstanceMutation } = cedarApi;
+
+// Export mutation trigger function type
+type CreateCedarMutationResult = ReturnType<
+  typeof useCreateCedarInstanceMutation
+>;
+export type CreateCedarMutationTriggerType = CreateCedarMutationResult[0];

packages/core/src/features/cedar/createCedarInstance.ts

@@ -0,0 +1,58 @@
+import type { CreateCedarMutationTriggerType, CreateCedarPayload } from './cedarApi';
+import type { MetadataToRegister } from './types';
+
+export const createCEDARInstance = async (
+  cedarWrapperURL: string,
+  cedarUserUUID: string,
+  metadataToRegister: MetadataToRegister,
+  createCedarQuery: CreateCedarMutationTriggerType,
+): Promise<unknown> => {
+  const STUDY_DATA_FIELD = 'gen3_discovery';
+
+  // Deep clone to prevent mutating original metadata
+  let updatedMetadataToRegister = JSON.parse(
+    JSON.stringify(metadataToRegister),
+  );
+
+  const payload: CreateCedarPayload = {
+    cedar_user_uuid: cedarUserUUID,
+    metadata: {
+      study_metadata: {
+        metadata_location: {
+          nih_application_id:
+            metadataToRegister[STUDY_DATA_FIELD]?.study_metadata
+              ?.metadata_location?.nih_application_id,
+        },
+        minimal_info: {
+          study_name:
+            metadataToRegister[STUDY_DATA_FIELD]?.study_metadata?.minimal_info
+              ?.study_name,
+          study_description:
+            metadataToRegister[STUDY_DATA_FIELD]?.study_metadata?.minimal_info
+              ?.study_description,
+        },
+      },
+      clinicaltrials_gov: metadataToRegister.clinicaltrials_gov,
+    },
+  };
+
+  try {
+    // Call the mutation trigger passed in from the component
+    const data = await createCedarQuery({
+      cedarWrapperURL,
+      payload,
+    }).unwrap();
+
+    updatedMetadataToRegister[
+      STUDY_DATA_FIELD
+    ].study_metadata.metadata_location.cedar_study_level_metadata_template_instance_ID =
+      data.cedar_instance_id || '';
+
+    return updatedMetadataToRegister;
+  } catch (err: unknown) {
+    const errorMsg = JSON.stringify(err);
+    return {
+      error: `Request to create CEDAR instance failed: ${errorMsg}`,
+    };
+  }
+};

packages/core/src/features/cedar/index.ts

@@ -0,0 +1,2 @@
+export { createCEDARInstance } from './createCedarInstance';
+export { cedarApi } from './cedarApi';

packages/core/src/features/cedar/types.ts

@@ -0,0 +1,28 @@
+export interface StudyMetadataLocation {
+  nih_application_id?: string;
+  cedar_study_level_metadata_template_instance_ID?: string;
+}
+
+export interface MinimalInfo {
+  study_name?: string;
+  study_description?: string;
+}
+
+export interface StudyMetadata {
+  metadata_location?: StudyMetadataLocation;
+  minimal_info?: MinimalInfo;
+}
+
+export interface Gen3DiscoveryField {
+  study_metadata: {
+    metadata_location: StudyMetadataLocation;
+    minimal_info?: MinimalInfo;
+  };
+  [key: string]: unknown;
+}
+
+export interface MetadataToRegister {
+  gen3_discovery: Gen3DiscoveryField;
+  clinicaltrials_gov?: string | undefined;
+  [key: string]: unknown;
+}

packages/core/src/features/updateStudyInMDS/index.ts

@@ -0,0 +1,6 @@
+export { updateStudyInMDS } from './updateStudyInMDS';
+export { mdsApi, useUpdateStudyInMDSMutation } from './mdsApi';
+export type {
+  UpdateStudyInMdsMutationTriggerType,
+  UpdateMdsStudyArgs,
+} from './mdsApi';

packages/core/src/features/updateStudyInMDS/mdsApi.ts

@@ -0,0 +1,27 @@
+import { gen3Api } from '../gen3';
+
+export interface UpdateMdsStudyArgs {
+  mdsURL: string;
+  metadataID: string;
+  metadataToUpdate: Record<string, unknown>;
+}
+
+export const mdsApi = gen3Api.injectEndpoints({
+  endpoints: (builder) => ({
+    updateStudyInMDS: builder.mutation<void, UpdateMdsStudyArgs>({
+      query: ({ mdsURL, metadataID, metadataToUpdate }) => ({
+        url: `${mdsURL}/metadata/${metadataID}?overwrite=true`,
+        method: 'POST',
+        body: metadataToUpdate,
+      }),
+    }),
+  }),
+});
+
+export const { useUpdateStudyInMDSMutation } = mdsApi;
+
+type UpdateMdsStudyMutationResult = ReturnType<
+  typeof useUpdateStudyInMDSMutation
+>;
+export type UpdateStudyInMdsMutationTriggerType =
+  UpdateMdsStudyMutationResult[0];

packages/core/src/features/updateStudyInMDS/updateStudyInMDS.ts

@@ -0,0 +1,23 @@
+import { toString } from 'lodash';
+import type { UpdateStudyInMdsMutationTriggerType } from './mdsApi';
+
+export const updateStudyInMDS = async (
+  mdsURL: string,
+  metadataID: string,
+  metadataToUpdate: Record<string, unknown> = {},
+  updateMdsQuery: UpdateStudyInMdsMutationTriggerType,
+): Promise<unknown> => {
+  try {
+    const response = await updateMdsQuery({
+      mdsURL,
+      metadataID,
+      metadataToUpdate,
+    }).unwrap();
+
+    return response;
+  } catch (error: unknown) {
+    throw new Error(
+      `Request for update study data failed: ${(error instanceof Error && error.message) || toString(error)}`,
+    );
+  }
+};

packages/core/src/index.ts

@@ -34,6 +34,8 @@ export * from './dataAccess';
 // Gen3 services API's
 export * from './features/aiSearch';
 export * from './features/authz';
+export * from './features/cedar';
+export * from './features/updateStudyInMDS';
 export * from './features/cohort';
 export * from './features/dataLibrary';
 export * from './features/drsResolver';

packages/frontend/src/components/Content/Form.tsx

@@ -1,13 +1,18 @@
 import React from 'react';
-
-import FormContent, { FormContentProps, FormContentType } from './FormContent';
+import type { FormContentProps } from './FormContent';
+import FormContent, { FormContentType } from './FormContent';
 import { Button, Text } from '@mantine/core';
-import { useForm, FormValidateInput, isEmail, isNotEmpty } from '@mantine/form';
+import type { FormValidateInput, UseFormReturnType } from '@mantine/form';
+import { useForm, isEmail, isNotEmpty } from '@mantine/form';
+import { isCedarUUIDValid, isClinicalTrialIDValid } from './formValidators';
 
-interface FormPropsBody extends Omit<FormContentProps, 'keyString' | 'form'> {
-  readonly errorText: string; // text to display on error
+export interface FormPropsBody extends Omit<
+  FormContentProps,
+  'keyString' | 'form'
+> {
+  readonly errorText?: string; // text to display on error
   readonly variable?: string; // form feild variable name
-  readonly initialValue?: string | boolean; // optional starting value
+  readonly required?: boolean;
 }
 
 export interface FormOnSubmitReturnProps {
@@ -22,7 +27,9 @@ export interface FormProps {
   readonly submitButtonText?: string; // submit Button Text defalts to Submit
   readonly showResetButton?: boolean; // Determines if the reset button should be visible
   readonly body: FormPropsBody[]; // array of FormContent
-  readonly onSubmit: (values: FormOnSubmitReturnProps) => void | Promise<any>; // function to trigger on form submit
+  readonly onSubmit: (
+    values: FormOnSubmitReturnProps,
+  ) => void | Promise<unknown>; // function to trigger on form submit
   readonly errorMessage?: string; // error messaage to display above submit button
 }
 
@@ -45,10 +52,10 @@ const Form = ({
   onSubmit,
   errorMessage,
 }: FormProps) => {
-  const initialValues: { [key: string]: string | boolean } = {};
-  const validate: FormValidateInput<any> = {};
+  const initialValues: FormOnSubmitReturnProps = {};
+  const validate: FormValidateInput<FormOnSubmitReturnProps> = {};
 
-  const bodyWithKey: Omit<FormContentProps, 'form'>[] = body.map(
+  const bodyWithKey: (FormPropsBody & { keyString: string })[] = body.map(
     (item, index) => {
       const itemKey =
         item.variable ||
@@ -65,8 +72,19 @@ const Form = ({
           const isvalidEmail = item.errorText || 'Invalid email';
           validate[itemKey] = isEmail(isvalidEmail);
         }
+        if (item.type === FormContentType.ClinicalTrialID) {
+          validate[itemKey] = isClinicalTrialIDValid(item.errorText);
+        }
         if (item.required) {
           switch (item.type) {
+            case FormContentType.CedarUserUUID: {
+              validate[itemKey] = isCedarUUIDValid(item.errorText);
+              break;
+            }
+            case FormContentType.ClinicalTrialID: {
+              validate[itemKey] = isClinicalTrialIDValid(item.errorText);
+              break;
+            }
             case FormContentType.Email: {
               const isValidEmail = item.errorText || 'Invalid email';
               validate[itemKey] = isEmail(isValidEmail);
@@ -89,7 +107,7 @@ const Form = ({
     },
   );
 
-  const form = useForm({
+  const form = useForm<FormOnSubmitReturnProps>({
     mode: 'uncontrolled',
     validateInputOnBlur: true,
     initialValues,
@@ -98,8 +116,17 @@ const Form = ({
 
   return (
     <form onSubmit={form.onSubmit(onSubmit)} className={className}>
-      {bodyWithKey?.map((content, index) => (
-        <FormContent {...content} form={form} key={index} />
+      {bodyWithKey.map((content, index) => (
+        <FormContent
+          {...content}
+          form={
+            form as unknown as UseFormReturnType<
+              Record<string, unknown>,
+              (values: Record<string, unknown>) => Record<string, unknown>
+            >
+          }
+          key={index}
+        />
       ))}
       {errorMessage && <Text c="red">{errorMessage}</Text>}
       <Button