@zohodesk/library-platform 1.0.0-exp.1

package/src/platform/zfield/entities/fields-manager/FieldsManager.ts

@@ -0,0 +1,117 @@
+import IField from '../interfaces/IField';
+import { FIELD_FETCH, FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS } from '@bc/zfield/Constants';
+import { FieldApiName } from '../../usecases/interfaces/input/FetchInputModel';
+import State, { ApiTemplate, SelectedFields } from '../interfaces/BehaviourState';
+import IFieldManager from '../interfaces/IFieldManger';
+import MetaData from '../interfaces/MetaData';
+import { FETCH } from '@bc/zhttp/Constants';
+import { APIDetailsModel } from '../interfaces/api-template/APIModels';
+import APITemplate from '../api-template/APITemplate';
+import { ITemplateHelpers } from '../interfaces/api-template/ITemplateHelpers';
+
+class FieldManager implements IFieldManager {
+  constructor(
+    private fields: IField[],
+    private selectedFields: SelectedFields,
+    private isFieldsFetching: boolean,
+    private isSelectedFieldsFetching: boolean,
+    private apiTemplate: ApiTemplate
+  ) {}
+
+  createSuccessAction(fields: IField[], metaData: MetaData) {
+    return {
+      type: metaData[FIELD_FETCH_SUCCESS].type,
+      payload: {
+        payloadFromMeta: metaData[FIELD_FETCH_SUCCESS].payload,
+        fields
+      }
+    };
+  }
+
+  createFailureAction(error: any, metaData: MetaData) {
+    return {
+      type: metaData[FIELD_FETCH_FAILURE].type,
+      payload: {
+        payloadFromMeta: metaData[FIELD_FETCH_FAILURE].payload,
+        error
+      }
+    };
+  }
+
+  createNoContentAction(metaData: MetaData) {
+    return {
+      type: metaData[FIELD_FETCH_NO_CONTENT].type
+    };
+  }
+
+  createFetchAction(apiDetails: any, metaData: MetaData, apiName: FieldApiName) {
+    return {
+      type: FETCH,
+      payload: apiDetails,
+      metaData: { ...metaData, apiName, [FIELD_FETCH_SUCCESS]: {} }
+    };
+  }
+
+  isFieldFetching(metaData: MetaData, apiName: FieldApiName): boolean {
+    return metaData.apiName === apiName;
+  }
+
+  isFieldSuccessFetching(metaData: MetaData, apiName: FieldApiName) {
+    return metaData[FIELD_FETCH_SUCCESS] && metaData.apiName === apiName;
+  }
+
+  isFieldFailureFetching(metaData: MetaData, apiName: FieldApiName) {
+    return metaData[FIELD_FETCH_FAILURE] && metaData.apiName === apiName;
+  }
+
+  isFieldNoContentFetching(metaData: MetaData, apiName: FieldApiName) {
+    return metaData[FIELD_FETCH_NO_CONTENT] && metaData.apiName === apiName;
+  }
+
+  startFetching(apiName: FieldApiName) {
+    if (apiName === 'availableFields') {
+      this.isFieldsFetching = true;
+    } else if (apiName === 'selectedFields') {
+      this.isSelectedFieldsFetching = true;
+    }
+  }
+
+  stopFetching(apiName: FieldApiName) {
+    if (apiName === 'availableFields') {
+      this.isFieldsFetching = false;
+    } else if (apiName === 'selectedFields') {
+      this.isSelectedFieldsFetching = false;
+    }
+  }
+
+  getTransformedFields(response: any, apiName: FieldApiName): IField[] {
+    // TODO: This is a temporary fix. After data-broker-contract is updated
+    const data = this.apiTemplate[apiName].transformer(response);
+    if (apiName === FieldApiName.AVAILABLE_FIELDS) {
+      this.fields = data;
+    } else if (apiName === FieldApiName.SELECTED_FIELDS) {
+      this.selectedFields = data;
+    }
+    return data;
+  }
+
+  getApiDetails(props: any, apiName: FieldApiName, templateHelpers: ITemplateHelpers): APIDetailsModel {
+    const apiTemplateObj = this.apiTemplate[apiName];
+    const apiTemplate = new APITemplate(apiTemplateObj, templateHelpers);
+    const apiDetails = apiTemplate.getApiDetails(props);
+
+    return apiDetails;
+  }
+
+  toObject(): State {
+    return {
+      fields: this.fields,
+      selectedFields: this.selectedFields,
+      isFieldsFetching: this.isFieldsFetching,
+      isSelectedFieldsFetching: this.isSelectedFieldsFetching,
+      apiTemplate: this.apiTemplate
+    };
+  }
+}
+
+export default FieldManager;

package/src/platform/zfield/entities/fields-manager/SelectedFieldsManager.ts

@@ -0,0 +1,87 @@
+import { FIELD_FETCH, FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS, FIELD_REFETCH } from "@bc/zfield/Constants";
+import { SelectedFieldsState } from "../interfaces/BehaviourState";
+import IFieldsManager from "../interfaces/IFieldManger";
+import MetaData from "../interfaces/MetaData";
+import { FETCH } from "@bc/zhttp/Constants";
+
+class SelectedFieldsManager implements IFieldsManager<SelectedFieldsState> {
+  constructor(
+    private selectedFields: any,
+    private isSelectedFieldsFetching: boolean
+  ) {}
+
+  startFetching(): void {
+    this.isSelectedFieldsFetching = true;
+  }
+  stopFetching(): void {
+    this.isSelectedFieldsFetching = false;
+  }
+  resetFields(): void {
+    this.selectedFields = [];
+  }
+
+  isFieldFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH] && metaData.apiName === 'selectedFields';
+  }
+  isFieldRefetching(metaData: MetaData): boolean {
+    return metaData[FIELD_REFETCH] && metaData.apiName === 'selectedFields';
+  }
+  isFieldSuccessFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_SUCCESS] && metaData.apiName === 'selectedFields';
+  }
+  isFieldFailureFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_FAILURE] && metaData.apiName === 'selectedFields';
+  }
+  isFieldNoContentFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_NO_CONTENT] && metaData.apiName === 'selectedFields';
+  }
+  mergeMetaData(metaData: MetaData, apiName: string, actionName: string): MetaData {
+    return {
+      ...metaData,
+      apiName,
+      actionName
+    };
+  }
+  createFieldsSuccessAction(metaData: MetaData, selectedFields: any): any {
+    const { type, payload } = metaData[FIELD_FETCH_SUCCESS];
+    return {
+      type,
+      payload: {
+        payloadFromMeta: payload,
+        fields: selectedFields
+      }
+    };
+  }
+  createFieldsFailureAction(metaData: MetaData, error): any {
+    const { type, payload } = metaData[FIELD_FETCH_FAILURE];
+    return {
+      type,
+      payload: {
+        payloadFromMeta: payload,
+        error
+      }
+    };
+  }
+  createFieldsNoContentAction(metaData: MetaData): any {
+    const { type, payload } = metaData[FIELD_FETCH_NO_CONTENT];
+    return {
+      type,
+      payload
+    };
+  }
+  createFieldsFetchingAction(metaData: MetaData, apiDetails): any {
+    return {
+      type: FETCH,
+      payload: apiDetails,
+      metaData
+    }
+  }
+  toObject(): SelectedFieldsState {
+    return {
+      selectedFields: this.selectedFields,
+      isSelectedFieldsFetching: this.isSelectedFieldsFetching
+    }
+  }
+}
+
+export default SelectedFieldsManager;

package/src/platform/zfield/entities/index.ts

@@ -0,0 +1,15 @@
+export { default as Field } from './Field';
+
+export { default as BooleanField } from './BooleanField';
+export { default as SingleLineField } from './SingleLineField';
+export { default as MultiLineField } from './MultiLineField';
+export { default as URLField } from './URLField';
+export { default as EmailField } from './EmailField';
+export { default as PhoneField } from './PhoneField';
+export { default as CurrencyField } from './CurrencyField';
+export { default as PercentageField } from './PercentageField';
+export { default as DateField } from './DateField';
+export { default as DateTimeField } from './DateTimeField';
+export { default as PickListField } from './PickListField';
+export { default as MultiSelectField } from './MultiSelectField';
+export { default as LookupField } from './LookupField';

package/src/platform/zfield/entities/interfaces/ActionModel.ts

@@ -0,0 +1,7 @@
+type ActionModel<T> = {
+  type: string;
+  payload: T;
+  metaData?: any;
+}
+
+export default ActionModel;

package/src/platform/zfield/entities/interfaces/BehaviourState.ts

@@ -0,0 +1,16 @@
+import { HttpTemplates } from "@platform/data-broker/dbc";
+import IField from "./IField";
+
+type SelectedFields = string[];
+
+type ApiTemplate = HttpTemplates;
+
+type State = {
+  fields: IField[];
+  selectedFields: SelectedFields;
+  isFieldsFetching: boolean;
+  isSelectedFieldsFetching: boolean;
+  apiTemplate: HttpTemplates;
+}
+
+export { State as default, SelectedFields, ApiTemplate };

package/src/platform/zfield/entities/interfaces/FieldModel.ts

@@ -0,0 +1,18 @@
+type FieldModel = {
+  id: string;
+  type: string;
+  uiType?: string;
+  name: string;
+  displayLabel: string;
+  isCustomField: boolean;
+  i18NLabel: string;
+  isSortable: boolean;
+  isVisible: boolean;
+  isReadOnly: boolean;
+  isEncryptedField: boolean;
+  isPHI: boolean;
+  maxLength: number;
+  isMandatory: boolean;
+};
+
+export default FieldModel;

package/src/platform/zfield/entities/interfaces/FieldTypes.ts

@@ -0,0 +1,18 @@
+enum FieldTypes {
+  Boolean = 'CheckboxField',
+  SingleLine = 'SingleLineField',
+  MultiLine = 'MultiLineField',
+  URL = 'URLField',
+  Email = 'EmailField',
+  Phone = 'PhoneField',
+  Currency = 'CurrencyField',
+  Percentage = 'PercentageField',
+  Date = 'DateField',
+  DateTime = 'DateTimeField',
+  PickList = 'PickListField',
+  MultiSelect = 'MultiSelectField',
+  LookUp = 'LookUpField',
+  Number = 'NumberField',
+  Decimal = 'DecimalField',
+}
+export default FieldTypes;

package/src/platform/zfield/entities/interfaces/IField.ts

@@ -0,0 +1,6 @@
+interface IField {
+  getId(): string;
+  toObject(): any;
+};
+
+export default IField;

package/src/platform/zfield/entities/interfaces/IFieldManger.ts

@@ -0,0 +1,28 @@
+import { FieldApiName } from '../../usecases/interfaces/input/FetchInputModel';
+import IField from './IField';
+import MetaData from './MetaData';
+import State from './BehaviourState';
+import { APIDetailsModel } from './api-template/APIModels';
+import { ITemplateHelpers } from './api-template/ITemplateHelpers';
+
+interface IFieldManager {
+
+  getApiDetails(props: any, apiName: FieldApiName, templateHelpers: ITemplateHelpers): APIDetailsModel 
+  createSuccessAction(fields: IField[], metaData: MetaData): any;
+  createFailureAction(error: any, metaData: MetaData): any;
+  createNoContentAction(metaData: MetaData): any;
+  createFetchAction(apiDetails: any, metaData: MetaData, apiName: FieldApiName): any;
+  
+  isFieldFetching(metaData: MetaData, apiName: FieldApiName): boolean;
+  isFieldSuccessFetching(metaData: MetaData, apiName: FieldApiName): boolean;
+  isFieldFailureFetching(metaData: MetaData, apiName: FieldApiName): boolean;
+  isFieldNoContentFetching(metaData: MetaData, apiName: FieldApiName): boolean;
+  
+  startFetching(apiName: FieldApiName): void;
+  stopFetching(apiName: FieldApiName): void;
+  
+  getTransformedFields(response: any, apiName: FieldApiName): IField[];
+  toObject(): State;
+}
+
+export default IFieldManager;

package/src/platform/zfield/entities/interfaces/MetaData.ts

@@ -0,0 +1,20 @@
+import { FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS } from "@bc/zfield/Constants"
+
+type MetaData = {
+  apiName: string;
+  actionName: string;
+  [FIELD_FETCH_SUCCESS]: {
+    type: string;
+    payload: object;
+  };
+  [FIELD_FETCH_FAILURE]: {
+    type: string;
+    payload: object;
+  };
+  [FIELD_FETCH_NO_CONTENT]: {
+    type: string;
+    payload: object;
+  };
+}
+
+export default MetaData;

package/src/platform/zfield/entities/interfaces/api-template/APIModels.ts

@@ -0,0 +1,12 @@
+import { GetTemplate, PostTemplate } from '@platform/data-broker/dbc';
+
+export enum API_METHODS {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  DELETE = 'DELETE',
+  PATCH = 'PATCH'
+}
+export type APIDetailsModel = { url: string; type: API_METHODS; payload: object };
+export type APITemplateModel = GetTemplate;
+export type APITemplatesModel = { [key: string]: APITemplateModel; };

package/src/platform/zfield/entities/interfaces/api-template/IAPITemplate.ts

@@ -0,0 +1,9 @@
+import { APITemplateModel, APIDetailsModel } from './APIModels';
+
+interface IAPITemplate {
+  toObject: () => APITemplateModel;
+  getApiDetails: (obj: any) => APIDetailsModel;
+  getTransformer: () => (res: any) => any;
+}
+
+export default IAPITemplate;

package/src/platform/zfield/entities/interfaces/api-template/IAPITemplates.ts

@@ -0,0 +1,10 @@
+import { APIDetailsModel, APITemplatesModel } from './APIModels';
+import IAPITemplate from './IAPITemplate';
+
+interface IAPITemplates {
+  getApiDetails(actionName: string, props): APIDetailsModel;
+  getAPITemplateByName(name: string): IAPITemplate;
+  toObject(): APITemplatesModel;
+}
+
+export default IAPITemplates;

package/src/platform/zfield/entities/interfaces/api-template/ITemplateHelpers.ts

@@ -0,0 +1,5 @@
+export interface ITemplateHelpers {
+  replaceTemplateVariables(inputString: string, replacementObj: any): string;
+  objectToQueryString(obj: any): string;
+  constructQueryString(inputString: string, replacementObj: any): string;
+}

package/src/platform/zfield/frameworks/ActionHandlerFactory.ts

@@ -0,0 +1,43 @@
+import ZFieldActionHandlers from '@bc/zfield/ActionHandlers';
+import { FIELD_EXECUTE, FIELD_FETCH_FAILURE, FIELD_REFETCH } from '@bc/zfield/Constants';
+import { FETCH_FAILED, FETCH_SUCCESS, FETCH_SUCCESS_NO_CONTENT } from '@bc/zhttp/Constants';
+import { HttpTemplates } from '@platform/data-broker/dbc'; // Importing from a data-brokert-contract
+import Service from '../adapters/gateways/Service';
+import Repository from '../adapters/gateways/Repository';
+import TemplateHelpers from '../adapters/gateways/TemplateHelpers';
+import InitializeController from '../adapters/controllers/InitializeController';
+import ExecuteActionController from '../adapters/controllers/ExeucteActionController';
+import FetchSuccessController from '../adapters/controllers/FetchSuccessController';
+import FetchFailureController from '../adapters/controllers/FetchFailureController';
+import FetchNoContentController from '../adapters/controllers/FetchNoContentController';
+import RefetchController from '../adapters/controllers/RefetchController';
+import Presenter from '../adapters/presenters/Presenter';
+
+class ActionHandlerFactory {
+  static create(apiTemplates: HttpTemplates): ZFieldActionHandlers {
+    const repository = new Repository();
+    const presenter = new Presenter();
+    const templateHelpers = new TemplateHelpers();
+    const service = new Service({ repository, presenter, templateHelpers });
+    const controller = {
+      init: new InitializeController(service, apiTemplates).handle,
+      execute: new ExecuteActionController(service).handle,
+      fetchSuccess: new FetchSuccessController(service).handle,
+      fetchFailure: new FetchFailureController(service).handle,
+      fetchNoContent: new FetchNoContentController(service).handle,
+      refetch: new RefetchController(service).handle
+    };
+
+    return {
+      MOUNT: controller.init,
+      [FIELD_EXECUTE]: controller.execute,
+      [FIELD_REFETCH]: controller.refetch,
+      [FIELD_FETCH_FAILURE]: controller.fetchFailure,
+      [FETCH_SUCCESS]: controller.fetchSuccess,
+      [FETCH_FAILED]: controller.fetchFailure,
+      [FETCH_SUCCESS_NO_CONTENT]: controller.fetchNoContent
+    };
+  }
+}
+
+export default ActionHandlerFactory;

package/src/platform/zfield/frameworks/ZFieldBehaviourFactory.ts

@@ -0,0 +1,17 @@
+import Behaviour from '@cc/component/Behaviour';
+import ActionHandlerFactory from './ActionHandlerFactory';
+import { HttpTemplates } from '@platform/data-broker/dbc';
+
+class ZFieldBehaviourFactory {
+  // TODO: Add return type
+  static create(apiTemplates: HttpTemplates): Behaviour {
+    return {
+      name: 'zfield',
+      setInitialState: ({ properties }: any): any => null,
+      eventHandlers: ActionHandlerFactory.create(apiTemplates),
+      properties: {}
+    };
+  }
+}
+
+export default ZFieldBehaviourFactory;

package/src/platform/zfield/usecases/entity-factory/FieldBuilder.ts

@@ -0,0 +1,106 @@
+import IField from '../../entities/interfaces/IField';
+import * as FieldEntities from '../../entities';
+
+class FieldBuilder {
+  private id: string;
+  private type: string;
+  private name: string;
+  private displayLabel: string;
+  private isCustomField: boolean;
+  private i18NLabel: string;
+  private isSortable: boolean;
+  private isVisible: boolean;
+  private isReadOnly: boolean;
+  private isEncryptedField: boolean;
+  private isPHI: boolean;
+  private maxLength: number;
+  private isMandatory: boolean;
+
+  setId(id: string): FieldBuilder {
+    this.id = id;
+    return this;
+  }
+
+  setType(type: string): FieldBuilder {
+    if (!FieldEntities[type]) {
+      throw new Error(`Invalid field type: ${type}`);
+    }
+    this.type = type;
+    return this;
+  }
+
+  setName(name: string): FieldBuilder {
+    this.name = name;
+    return this;
+  }
+
+  setDisplayLabel(displayLabel: string): FieldBuilder {
+    this.displayLabel = displayLabel;
+    return this;
+  }
+
+  setIsCustomField(isCustomField: boolean): FieldBuilder {
+    this.isCustomField = isCustomField;
+    return this;
+  }
+
+  setI18NLabel(i18NLabel: string): FieldBuilder {
+    this.i18NLabel = i18NLabel;
+    return this;
+  }
+
+  setIsSortable(isSortable: boolean): FieldBuilder {
+    this.isSortable = isSortable;
+    return this;
+  }
+
+  setIsVisible(isVisible: boolean): FieldBuilder {
+    this.isVisible = isVisible;
+    return this;
+  }
+
+  setIsReadOnly(isReadOnly: boolean): FieldBuilder {
+    this.isReadOnly = isReadOnly;
+    return this;
+  }
+
+  setIsEncryptedField(isEncryptedField: boolean): FieldBuilder {
+    this.isEncryptedField = isEncryptedField;
+    return this;
+  }
+
+  setIsPHI(isPHI: boolean): FieldBuilder {
+    this.isPHI = isPHI;
+    return this;
+  }
+
+  setMaxLength(maxLength: number): FieldBuilder {
+    this.maxLength = maxLength;
+    return this;
+  }
+
+  setIsMandatory(isMandatory: boolean): FieldBuilder {
+    this.isMandatory = isMandatory;
+    return this;
+  }
+
+  build(): IField {
+    return new FieldEntities[this.type](
+      this.id,
+      this.type,
+      this.name,
+      this.displayLabel,
+      this.isCustomField,
+      this.i18NLabel,
+      this.isSortable,
+      this.isVisible,
+      this.isReadOnly,
+      this.isEncryptedField,
+      this.isPHI,
+      this.maxLength,
+      this.isMandatory
+    );
+  }
+}
+
+export default FieldBuilder;

package/src/platform/zfield/usecases/entity-factory/FieldFactory.ts

@@ -0,0 +1,40 @@
+import IField from '../../entities/interfaces/IField';
+import InputModel from '../interfaces/input/InputModel';
+import FieldBuilder from './FieldBuilder';
+
+class FieldFactory {
+  static create(input: InputModel): IField {
+    const {
+      id,
+      type,
+      name,
+      displayLabel,
+      isCustomField,
+      i18NLabel,
+      isSortable,
+      isVisible,
+      isReadOnly,
+      isEncryptedField,
+      isPHI,
+      maxLength,
+      isMandatory
+    } = input;
+
+    return new FieldBuilder()
+      .setId(id)
+      .setType(type)
+      .setName(name)
+      .setDisplayLabel(displayLabel)
+      .setIsCustomField(isCustomField)
+      .setI18NLabel(i18NLabel)
+      .setIsSortable(isSortable)
+      .setIsVisible(isVisible)
+      .setIsReadOnly(isReadOnly)
+      .setIsEncryptedField(isEncryptedField)
+      .setIsPHI(isPHI)
+      .setMaxLength(maxLength)
+      .setIsMandatory(isMandatory)
+      .build();
+  }
+}
+export default FieldFactory;

package/src/platform/zfield/usecases/entity-factory/FieldsManagerBuilder.ts

@@ -0,0 +1,48 @@
+import IField from '../../entities/interfaces/IField';
+import FieldsManager from '../../entities/fields-manager/FieldsManager';
+import { ApiTemplate, SelectedFields } from '@platform/zfield/entities/interfaces/BehaviourState';
+
+class FieldsManagerBuilder {
+  private availableFields: IField[];
+  private selectedFields: SelectedFields;
+  private isAvailableFieldsFetching: boolean;
+  private isSelectedFieldsFetching: boolean;
+  private apiTemplate: ApiTemplate;
+
+  setAvailableFields(availableFields: IField[]) {
+    this.availableFields = availableFields;
+    return this;
+  }
+
+  setSelectedFields(selectedFields: SelectedFields) {
+    this.selectedFields = selectedFields;
+    return this;
+  }
+
+  setAvailableFieldsFetchingStatus(isAvailableFieldsFetching: boolean) {
+    this.isAvailableFieldsFetching = isAvailableFieldsFetching;
+    return this;
+  }
+
+  setSelectedFieldsFetchingStatus(isSelectedFieldsFetching: boolean) {
+    this.isSelectedFieldsFetching = isSelectedFieldsFetching;
+    return this;
+  }
+
+  setApiTemplate(apiTemplate: ApiTemplate) {
+    this.apiTemplate = apiTemplate;
+    return this;
+  }
+
+  build() {
+    return new FieldsManager(
+      this.availableFields,
+      this.selectedFields,
+      this.isAvailableFieldsFetching,
+      this.isSelectedFieldsFetching,
+      this.apiTemplate
+    );
+  }
+}
+
+export default FieldsManagerBuilder;

package/src/platform/zfield/usecases/interactors/AbstractUseCase.ts

@@ -0,0 +1,16 @@
+import UsecaseDependencies from '../interfaces/UsecaseDependencies';
+import IUseCase from '@cc/architecture/IUseCase';
+
+abstract class AbstractUseCase<T> implements IUseCase<T> {
+  constructor(protected dependencies: UsecaseDependencies) {}
+
+  abstract execute(input: T): void;
+
+  // TODO: Add type for state and updateState
+  updateDependencies(state, updateState): void {
+    const { repository, presenter } = this.dependencies;
+    repository.init(state);
+    presenter.updateDependencies(state, updateState);
+  }
+}
+export default AbstractUseCase;

package/src/platform/zfield/usecases/interactors/ExecuteActionUseCase.ts

@@ -0,0 +1,16 @@
+import ExecuteActionInputModel from '../interfaces/input/ExecuteActionInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class ExecuteActionUseCase extends AbstractUseCase<ExecuteActionInputModel> {
+  execute(input: ExecuteActionInputModel): void {
+    const { repository, templateHelpers } = this.dependencies;
+    const { dispatch, apiName, props, metaData } = input;
+    const fieldManager = repository.getFieldManager();
+
+    fieldManager.startFetching(apiName);
+    const apiDetails = fieldManager.getApiDetails(props, apiName, templateHelpers);
+    dispatch(fieldManager.createFetchAction(apiDetails, metaData, apiName));
+  }
+}
+
+export default ExecuteActionUseCase;