@olaboot/esm-form-engine-lib 4.1.0

package/src/registry/registry.ts

@@ -0,0 +1,290 @@
+import {
+  type FormField,
+  type DataSource,
+  type FormFieldInputProps,
+  type FormFieldValidator,
+  type FormFieldValueAdapter,
+  type FormSchemaTransformer,
+  type PostSubmissionAction,
+} from '../types';
+import { getGlobalStore } from '@openmrs/esm-framework';
+import { FormsStore } from '../constants';
+import { inbuiltControls } from './inbuilt-components/inbuiltControls';
+import { inbuiltValidators } from './inbuilt-components/inbuiltValidators';
+import { inbuiltDataSources } from './inbuilt-components/inbuiltDataSources';
+import { getControlTemplate } from './inbuilt-components/control-templates';
+import { inbuiltPostSubmissionActions } from './inbuilt-components/InbuiltPostSubmissionActions';
+import { inbuiltFormTransformers } from './inbuilt-components/inbuiltTransformers';
+import { inbuiltFieldValueAdapters } from './inbuilt-components/inbuiltFieldValueAdapters';
+import { hasRendering } from '../utils/common-utils';
+
+/**
+ * @internal
+ */
+export interface RegistryItem<T> {
+  // Do we need this?
+  name?: string;
+  component: T;
+  type?: string;
+  /**
+   * @deprecated
+   */
+  alias?: string;
+}
+
+export interface ComponentRegistration<T> {
+  name: string;
+  load: () => Promise<{ default: T }>;
+}
+
+export interface CustomControlRegistration extends ComponentRegistration<React.ComponentType<FormFieldInputProps>> {
+  type: string;
+  alias?: string;
+}
+
+export interface FieldValueAdapterRegistration extends ComponentRegistration<FormFieldValueAdapter> {
+  type: string;
+}
+
+export interface FormsRegistryStoreState {
+  controls: CustomControlRegistration[];
+  fieldValidators: ComponentRegistration<FormFieldValidator>[];
+  fieldValueAdapters: FieldValueAdapterRegistration[];
+  postSubmissionActions: ComponentRegistration<PostSubmissionAction>[];
+  dataSources: ComponentRegistration<DataSource<any>>[];
+  expressionHelpers: Record<string, Function>;
+  formSchemaTransformers: ComponentRegistration<FormSchemaTransformer>[];
+}
+
+interface FormRegistryCache {
+  validators: Record<string, FormFieldValidator>;
+  controls: Record<string, React.ComponentType<FormFieldInputProps>>;
+  fieldValueAdapters: Record<string, FormFieldValueAdapter>;
+  postSubmissionActions: Record<string, PostSubmissionAction>;
+  dataSources: Record<string, DataSource<any>>;
+  formSchemaTransformers: Record<string, FormSchemaTransformer>;
+}
+
+const registryCache: FormRegistryCache = {
+  validators: {},
+  controls: {},
+  fieldValueAdapters: {},
+  postSubmissionActions: {},
+  dataSources: {},
+  formSchemaTransformers: {},
+};
+
+// Registers
+
+export function registerControl(registration: CustomControlRegistration) {
+  getFormsStore().controls.push(registration);
+}
+
+export function registerPostSubmissionAction(registration: ComponentRegistration<PostSubmissionAction>) {
+  getFormsStore().postSubmissionActions.push(registration);
+}
+
+export function registerFieldValueAdapter(registration: FieldValueAdapterRegistration) {
+  getFormsStore().fieldValueAdapters.push(registration);
+}
+
+export function registerFieldValidator(registration: ComponentRegistration<FormFieldValidator>) {
+  getFormsStore().fieldValidators.push(registration);
+}
+
+export function registerCustomDataSource(registration: ComponentRegistration<DataSource<any>>) {
+  getFormsStore().dataSources.push(registration);
+}
+
+export function registerExpressionHelper(name: string, fn: Function) {
+  getFormsStore().expressionHelpers[name] = fn;
+}
+
+export function registerFormSchemaTransformers(registration: ComponentRegistration<FormSchemaTransformer>) {
+  const store = getFormsStore();
+  const existingIndex = store.formSchemaTransformers.findIndex((reg) => reg.name === registration.name);
+
+  if (existingIndex !== -1) {
+    // If registration with the same name exists, override it
+    store.formSchemaTransformers[existingIndex] = registration;
+  } else {
+    store.formSchemaTransformers.push(registration);
+  }
+}
+
+// Getters
+
+/**
+ * A convenience function that returns the appropriate control for a given rendering type.
+ */
+export async function getRegisteredControl(renderType: string) {
+  if (registryCache.controls[renderType]) {
+    return registryCache.controls[renderType];
+  }
+  let component = inbuiltControls.find(
+    (control) => control.name === renderType || control?.alias === renderType,
+  )?.component;
+  // if undefined, try searching through the registered custom controls
+  if (!component) {
+    const importedControl = await getFormsStore()
+      .controls.find((control) => control.name === renderType || control?.alias === renderType)
+      ?.load?.();
+    component = importedControl?.default;
+  }
+  registryCache.controls[renderType] = component;
+  return component;
+}
+
+/**
+ * Retrieves the appropriate field control for a question, considering missing concepts.
+ * If the question is of type 'obs' and has a missing concept, it falls back to a disabled text input.
+ * Otherwise, it retrieves the registered control based on the rendering specified in the question.
+ * @param question - The FormField representing the question.
+ * @returns The field control to be used for rendering the question.
+ */
+export function getFieldControlWithFallback(question: FormField) {
+  // Check if the question has a missing concept
+  if (hasMissingConcept(question) && !hasRendering(question, 'file')) {
+    // If so, render a disabled text input
+    question.disabled = true;
+    question.isDisabled = true;
+    return getRegisteredControl('text');
+  }
+
+  // Retrieve the registered control based on the specified rendering
+  return getRegisteredControl(question.questionOptions.rendering);
+}
+
+export async function getRegisteredFieldValueAdapter(type: string): Promise<FormFieldValueAdapter> {
+  if (registryCache.fieldValueAdapters[type]) {
+    return registryCache.fieldValueAdapters[type];
+  }
+  let adapter = inbuiltFieldValueAdapters.find((adapter) => adapter.type === type)?.component;
+  // if undefined, try searching through the registered custom handlers
+  if (!adapter) {
+    const adapterImport = await getFormsStore()
+      .fieldValueAdapters.find((adapter) => adapter.type === type)
+      ?.load?.();
+    adapter = adapterImport?.default;
+  }
+  registryCache.fieldValueAdapters[type] = adapter;
+  return adapter;
+}
+
+export async function getRegisteredFormSchemaTransformers(): Promise<FormSchemaTransformer[]> {
+  const transformers = [];
+
+  const cachedTransformers = registryCache.formSchemaTransformers;
+  if (Object.keys(cachedTransformers).length) {
+    return Object.values(cachedTransformers);
+  }
+
+  const formTransformersFromStore = getFormsStore().formSchemaTransformers || [];
+  const customTransformers = await Promise.all(
+    formTransformersFromStore.map(async (transformer) => {
+      const transformerImport = await transformer.load?.();
+      return transformerImport?.default;
+    }),
+  );
+  transformers.push(...customTransformers.filter((transformer) => transformer !== undefined));
+
+  transformers.push(...inbuiltFormTransformers.map((inbuiltTransformer) => inbuiltTransformer.component));
+
+  transformers.forEach((transformer) => {
+    const inbuiltTransformer = inbuiltFormTransformers.find((t) => t.component === transformer);
+    registryCache.formSchemaTransformers[inbuiltTransformer.name] = transformer;
+  });
+
+  return transformers;
+}
+
+export async function getRegisteredPostSubmissionAction(actionId: string) {
+  const cachedAction = registryCache.postSubmissionActions[actionId];
+  if (cachedAction) {
+    return cachedAction;
+  }
+
+  const inbuiltRegistration = inbuiltPostSubmissionActions.find((registration) => registration.name === actionId);
+
+  if (inbuiltRegistration) {
+    const lazy = inbuiltRegistration.load;
+    const actionImport = await lazy();
+    registryCache.postSubmissionActions[actionId] = actionImport.default;
+    return actionImport.default;
+  }
+
+  const formsStoreRegistration = getFormsStore().postSubmissionActions.find(
+    (registration) => registration.name === actionId,
+  );
+
+  if (formsStoreRegistration) {
+    const lazy = formsStoreRegistration.load;
+    const actionImport = await lazy();
+    registryCache.postSubmissionActions[actionId] = actionImport.default;
+    return actionImport.default;
+  } else {
+    console.error(`No loader found for PostSubmissionAction registration of id: ${actionId}`);
+  }
+
+  return null;
+}
+
+export async function getRegisteredValidator(name: string): Promise<FormFieldValidator> {
+  if (registryCache.validators[name]) {
+    return registryCache.validators[name];
+  }
+  let validator = inbuiltValidators.find((validator) => validator.name === name)?.component;
+  if (!validator) {
+    const validatorImport = await getFormsStore()
+      .fieldValidators.find((validator) => validator.name === name)
+      ?.load?.();
+    validator = validatorImport?.default;
+  }
+  registryCache.validators[name] = validator;
+  return validator;
+}
+
+export async function getRegisteredDataSource(name: string): Promise<DataSource<any>> {
+  if (registryCache.dataSources[name]) {
+    return registryCache.dataSources[name];
+  }
+  let ds = inbuiltDataSources.find((dataSource) => dataSource.name === name)?.component;
+  if (!ds) {
+    const template = getControlTemplate(name);
+    if (template) {
+      ds = inbuiltDataSources.find((dataSource) => dataSource.name === template.datasource.name)?.component;
+    } else {
+      const dataSourceImport = await getFormsStore()
+        .dataSources.find((ds) => ds.name === name)
+        ?.load?.();
+      if (!dataSourceImport) {
+        throw new Error('Datasource not found');
+      }
+      ds = dataSourceImport.default;
+    }
+  }
+  registryCache.dataSources[name] = ds;
+  return ds;
+}
+
+export function getRegisteredExpressionHelpers() {
+  return getFormsStore().expressionHelpers;
+}
+
+function getFormsStore(): FormsRegistryStoreState {
+  return getGlobalStore<FormsRegistryStoreState>(FormsStore, {
+    controls: [],
+    postSubmissionActions: [],
+    expressionHelpers: {},
+    fieldValidators: [],
+    fieldValueAdapters: [],
+    dataSources: [],
+    formSchemaTransformers: [],
+  }).getState();
+}
+
+function hasMissingConcept(question: FormField) {
+  return (
+    question.type == 'obs' && !question.questionOptions.concept && question.questionOptions.rendering !== 'fixed-value'
+  );
+}

package/src/transformers/default-schema-transformer.ts

@@ -0,0 +1,340 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import {
+  type FormField,
+  type FormSchema,
+  type FormSchemaTransformer,
+  type RenderType,
+  type FormPage,
+  type PreFilledQuestions,
+} from '../types';
+import { isTrue } from '../utils/boolean-utils';
+import { hasRendering } from '../utils/common-utils';
+
+export type RenderTypeExtended = 'multiCheckbox' | 'numeric' | RenderType;
+
+export const DefaultFormSchemaTransformer: FormSchemaTransformer = {
+  transform: (form: FormSchema, preFilledQuestions?: PreFilledQuestions) => {
+    parseBooleanTokenIfPresent(form, 'readonly');
+    form.pages.forEach((page, index) => {
+      const label = page.label ?? '';
+      page.id = `page-${label.replace(/\s/g, '')}-${index}`;
+      parseBooleanTokenIfPresent(page, 'readonly');
+      if (page.sections) {
+        page.sections.forEach((section) => {
+          section.questions = handleQuestionsWithDateOptions(section.questions);
+          section.questions = handleQuestionsWithObsComments(section.questions);
+          parseBooleanTokenIfPresent(section, 'readonly');
+          parseBooleanTokenIfPresent(section, 'isExpanded');
+          section?.questions?.forEach((question, index) => handleQuestion(question, page, form));
+        });
+      }
+    });
+    if (preFilledQuestions && typeof preFilledQuestions === 'object') {
+      handlePreFilledQuestions(form, preFilledQuestions);
+    }
+    if (form.meta?.programs) {
+      handleProgramMetaTags(form);
+    }
+    return form;
+  },
+};
+
+function handleQuestion(question: FormField, page: FormPage, form: FormSchema) {
+  if (question.type === 'programState') {
+    const formMeta = form.meta ?? {};
+    formMeta.programs = formMeta.programs
+      ? { ...formMeta.programs, hasProgramFields: true }
+      : { hasProgramFields: true };
+    form.meta = formMeta;
+  }
+  try {
+    sanitizeQuestion(question);
+    setFieldValidators(question);
+    transformByType(question);
+    transformByRendering(question);
+
+    if (question.questions?.length) {
+      if (question.type === 'obsGroup' && question.questions.length) {
+        question.questions.forEach((nestedQuestion) => handleQuestion(nestedQuestion, page, form));
+      } else {
+        question.questions.forEach((nestedQuestion) => handleQuestion(nestedQuestion, page, form));
+      }
+    }
+    question.meta.pageId = page.id;
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+function handleQuestionsWithDateOptions(sectionQuestions: Array<FormField>): Array<FormField> {
+  const augmentedQuestions: Array<FormField> = [];
+
+  sectionQuestions?.forEach((question) => {
+    augmentedQuestions.push(question);
+    if (question.type !== 'inlineDate' && isTrue(question.questionOptions?.showDate)) {
+      const inlinedDate: FormField = {
+        id: `${question.id}_inline_date`,
+        label: `Date for ${question.label}`,
+        type: 'inlineDate',
+        questionOptions: {
+          rendering: 'date',
+          isTransient: true,
+        },
+        validators: question.questionOptions.shownDateOptions?.validators,
+        disabled: { disableWhenExpression: `isEmpty(${question.id})` },
+        hide: question.questionOptions.shownDateOptions?.hide || question.hide,
+        meta: {
+          targetField: question.id,
+          initialValue: {
+            omrsObject: (question.meta?.initialValue?.omrsObject as OpenmrsResource)?.obsDatetime,
+          },
+        },
+      };
+
+      augmentedQuestions.push(inlinedDate);
+    }
+  });
+
+  return augmentedQuestions;
+}
+
+function sanitizeQuestion(question: FormField) {
+  parseBooleanTokenIfPresent(question, 'readonly');
+  parseBooleanTokenIfPresent(question, 'required');
+  parseBooleanTokenIfPresent(question, 'unspecified');
+  parseBooleanTokenIfPresent(question.questionOptions, 'disallowDecimals');
+  parseBooleanTokenIfPresent(question.questionOptions, 'isSearchable');
+  parseBooleanTokenIfPresent(question.questionOptions, 'isTransient');
+  parseBooleanTokenIfPresent(question.questionOptions, 'enablePreviousValue');
+  parseBooleanTokenIfPresent(question.questionOptions, 'allowMultiple');
+  if (!question.meta) {
+    question.meta = {
+      submission: null,
+      initialValue: {
+        omrsObject: null,
+        refinedValue: null,
+      },
+    };
+  }
+}
+
+function parseBooleanTokenIfPresent(node: any, token: any) {
+  if (node && typeof node[token] === 'string') {
+    const trimmed = node[token].trim().toLowerCase();
+    if (trimmed === 'true' || trimmed === 'false') {
+      node[token] = trimmed === 'true';
+    }
+  }
+
+  return node;
+}
+
+function setFieldValidators(question: FormField) {
+  if (hasRendering(question, 'group')) {
+    return;
+  }
+  question.validators = question.validators || [];
+  if (question.validators.findIndex((v) => v.type === 'form_field') < 0) {
+    question.validators.push({ type: 'form_field' });
+  }
+  if (question.validators.findIndex((v) => v.type === 'default_value') < 0) {
+    question.validators.push({ type: 'default_value' });
+  }
+}
+
+function transformByType(question: FormField) {
+  switch (question.type) {
+    case 'encounterProvider':
+      question.questionOptions.rendering = 'encounter-provider';
+      break;
+    case 'encounterLocation':
+      question.questionOptions.rendering = 'encounter-location';
+      break;
+    case 'encounterRole':
+      question.questionOptions.rendering = 'encounter-role';
+      break;
+    case 'encounterDatetime':
+      question.questionOptions.rendering = hasRendering(question, 'ui-select-extended')
+        ? 'date'
+        : question.questionOptions.rendering;
+      break;
+    case 'diagnosis':
+      handleDiagnosis(question);
+      break;
+  }
+}
+
+function transformByRendering(question: FormField) {
+  switch (question.questionOptions.rendering as RenderTypeExtended) {
+    case 'checkbox-searchable':
+    case 'multiCheckbox':
+      handleCheckbox(question);
+      break;
+    case 'numeric':
+      question.questionOptions.rendering = 'number';
+      break;
+    case 'select-concept-answers':
+      handleSelectConceptAnswers(question);
+      break;
+    case 'repeating':
+    case 'group':
+      handleLabOrders(question);
+      break;
+    case 'date':
+      question.datePickerFormat = question.datePickerFormat ?? 'calendar';
+      break;
+    case 'datetime':
+      question.datePickerFormat = question.datePickerFormat ?? 'both';
+      break;
+    case 'workspace-launcher':
+      question.type = 'control';
+      break;
+    case 'markdown':
+      question.type = 'control';
+      break;
+    case 'drug':
+    case 'problem':
+      question.questionOptions.isSearchable = true;
+      break;
+  }
+  return question;
+}
+
+function handleCheckbox(question: FormField) {
+  if ((question.questionOptions.rendering as RenderTypeExtended) === 'multiCheckbox') {
+    question.questionOptions.rendering = 'checkbox-searchable';
+    if (isTrue(question.inlineMultiCheckbox)) {
+      question.questionOptions.rendering = 'checkbox';
+    }
+  }
+
+  if (hasRendering(question, 'checkbox-searchable')) {
+    question.questionOptions.rendering = 'checkbox';
+    question.questionOptions.isCheckboxSearchable = true;
+  }
+}
+
+function handleLabOrders(question: FormField) {
+  if (hasRendering(question, 'group') && question.questions?.length) {
+    question.questions.forEach(handleLabOrders);
+  }
+  if (question.type === 'testOrder' && question.questionOptions.selectableOrders?.length) {
+    question.questionOptions.answers = question.questionOptions.selectableOrders || [];
+    delete question.questionOptions.selectableOrders;
+  }
+}
+
+function handleSelectConceptAnswers(question: FormField) {
+  question.questionOptions.isSearchable = true;
+  if (!question.questionOptions.datasource?.config) {
+    question.questionOptions.datasource = {
+      name: 'select_concept_answers_datasource',
+      config: {
+        concept: question.questionOptions.concept,
+      },
+    };
+  }
+}
+
+function handleProgramMetaTags(form: FormSchema) {
+  if (form.meta.programs.isEnrollment || form.meta.programs.discontinuationDateQuestionId) {
+    const config = {
+      programUuid: form.meta.programs.uuid,
+    };
+
+    if (form.meta.programs.isEnrollment) {
+      config['enrollmentDate'] = '';
+    } else {
+      config['completionDate'] = form.meta.programs.discontinuationDateQuestionId;
+    }
+
+    form.postSubmissionActions = [
+      {
+        actionId: 'ProgramEnrollmentSubmissionAction',
+        enabled: 'true',
+        config,
+      },
+    ];
+  }
+}
+
+function handleQuestionsWithObsComments(sectionQuestions: Array<FormField>): Array<FormField> {
+  const augmentedQuestions: Array<FormField> = [];
+
+  sectionQuestions?.forEach((question) => {
+    augmentedQuestions.push(question);
+    if (question.type !== 'obsComment' && isTrue(question.questionOptions?.showComment)) {
+      const obsComment: FormField = {
+        id: `${question.id}_obs_comment`,
+        label: `Comment for ${question.label}`,
+        type: 'obsComment',
+        questionOptions: {
+          rendering: 'text',
+          isTransient: true,
+        },
+        validators: question.questionOptions.shownCommentOptions?.validators,
+        disabled: { disableWhenExpression: `isEmpty(${question.id})` },
+        hide: question.questionOptions.shownCommentOptions?.hide || question.hide,
+        meta: {
+          targetField: question.id,
+          initialValue: {
+            omrsObject: (question.meta?.initialValue?.omrsObject as OpenmrsResource)?.comment,
+          },
+        },
+      };
+
+      augmentedQuestions.push(obsComment);
+    }
+  });
+
+  return augmentedQuestions;
+}
+
+function handleDiagnosis(question: FormField) {
+  if (
+    ('dataSource' in question.questionOptions && question.questionOptions['dataSource'] === 'diagnoses') ||
+    question.type === 'diagnosis'
+  ) {
+    question.questionOptions.datasource = {
+      name: 'problem_datasource',
+      config: {
+        class: question.questionOptions.diagnosis?.conceptClasses,
+      },
+    };
+    if (question.questionOptions.diagnosis?.conceptSet) {
+      question.questionOptions = {
+        ...question.questionOptions,
+        concept: question.questionOptions.diagnosis?.conceptSet,
+        datasource: {
+          name: 'problem_datasource',
+          config: {
+            useSetMembersByConcept: true,
+          },
+        },
+      };
+    }
+    question.questionOptions.isSearchable = true;
+
+    delete question.questionOptions['dataSource'];
+  }
+}
+
+function handlePreFilledQuestions(form: FormSchema, preFilledQuestions: PreFilledQuestions) {
+  Object.entries(preFilledQuestions).forEach(([preFilledQnId, preFilledValue]) => {
+    form?.pages.forEach((page) => {
+      page.sections.forEach((section) => {
+        section.questions.forEach((question) => {
+          if (question.id === preFilledQnId) {
+            question.questionOptions.defaultValue = preFilledValue;
+          } else if (Array.isArray(question?.questions) && question.questions.length > 0) {
+            question.questions.forEach((question) => {
+              if (question.id === preFilledQnId) {
+                question.questionOptions.defaultValue = preFilledValue;
+              }
+            });
+          }
+        });
+      });
+    });
+  });
+}