@zohodesk/library-platform 1.0.0-exp.1

package/src/platform/zrecord/entities/RecordsManager.ts

@@ -0,0 +1,196 @@
+/* eslint-disable max-lines-per-function */
+import IRecordsManager from './interfaces/IRecordsManager';
+import IAPITemplates from './interfaces/IAPITemplates';
+import IRecords from './interfaces/IRecords';
+import { APIDetailsModel } from './interfaces/APIDetailsModel';
+import MetaData from './interfaces/MetaData';
+import IRecord from './interfaces/IRecord';
+
+import { RECORD_FAILURE, RECORD_NO_CONTENT, RECORD_SUCCESS } from '@bc/zrecord/Symbols';
+import { BehaviourState } from './interfaces/BehaviourState';
+import { FETCH } from '@bc/zhttp/Constants';
+import ActionModel from './interfaces/ActionModel';
+import { RecordModel } from './interfaces/RecordModel';
+import { APPEND_RECORDS, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, RecordApiActionName } from '@bc/zrecord/Constants';
+import { ApiHeaders } from '@platform/zlist/entities/interfaces/Properties';
+
+export default class RecordsManager implements IRecordsManager {
+  constructor(
+    private apiTemplates: IAPITemplates,
+    private records: IRecords
+  ) {}
+
+  createFetchAction(apiDetails: APIDetailsModel, metaData: MetaData): ActionModel<APIDetailsModel> {
+    return {
+      type: FETCH,
+      payload: apiDetails,
+      metaData: metaData
+    };
+  }
+
+  createFetchRecordMeta(actionName: string, apiName: string, headers: ApiHeaders, props): MetaData {
+    let successMeta = { type: APPEND_RECORDS, metaData: {} };
+    let successNoContentMeta = { type: '', metaData: {} };
+
+    if (RecordApiActionName.UPDATE_RECORD === actionName) {
+      successMeta = { type: RECORD_LOCAL_UPDATE, metaData: {} };
+    } else if (RecordApiActionName.DELETE_RECORDS === actionName) {
+      // successMeta = { type: RECORD_LOCAL_MULTIPLE_DELETE, payload };
+      successMeta = { type: RECORD_LOCAL_MULTIPLE_DELETE, metaData: { props } };
+      successNoContentMeta = { type: RECORD_LOCAL_MULTIPLE_DELETE, metaData: { props } };
+    }
+    return {
+      headers,
+      apiName,
+      actionName,
+      [RECORD_NO_CONTENT]: successNoContentMeta,
+      [RECORD_SUCCESS]: successMeta
+    };
+  }
+
+  createFetchMoreRecordMeta(actionName: string, apiName: string, headers: ApiHeaders): MetaData {
+    return {
+      headers,
+      apiName,
+      actionName,
+      [RECORD_SUCCESS]: {
+        type: APPEND_RECORDS
+      }
+    };
+  }
+
+  createSuccessAction(transformedRes: any, metaData: MetaData): ActionModel<any> {
+    const { actionName } = metaData;
+    const { type, metaData: successMeta } = metaData[RECORD_SUCCESS];
+    if (RecordApiActionName.UPDATE_RECORD === actionName) {
+      return {
+        type,
+        payload: {
+          record: transformedRes,
+          recordId: transformedRes.id
+        }
+      };
+    }
+
+    if (RecordApiActionName.DELETE_RECORDS === actionName) {
+      return {
+        type,
+        payload: {
+          recordIds: successMeta.props.recordIds
+        }
+      };
+    }
+
+    return {
+      type,
+      payload: {
+        records: transformedRes as RecordModel[]
+      }
+    };
+  }
+
+  createNoContentAction(metaData: MetaData) {
+    const { actionName } = metaData;
+    const { type, payload, metaData: noContentMeta } = metaData[RECORD_NO_CONTENT];
+    if (RecordApiActionName.DELETE_RECORDS === actionName) {
+      return {
+        type,
+        payload: {
+          recordIds: noContentMeta.props.recordIds
+        }
+      };
+    }
+    return {
+      type,
+      payload
+    };
+  }
+
+  createFailureAction(error: any, metaData: MetaData) {
+    const { type } = metaData[RECORD_FAILURE];
+    return {
+      type,
+      payload: {
+        error
+      }
+    };
+  }
+
+  getApiDetails(actionName: string, props: object): APIDetailsModel {
+    return this.apiTemplates.getApiDetails(actionName, { ...props, from: this.records.getRecordsLength() });
+  }
+
+  fetchingStarted() {
+    this.records.setIsFetching(true);
+  }
+
+  fetchingFinished() {
+    this.records.setIsFetching(false);
+  }
+
+  resetRecords() {
+    this.records.setRecords([]);
+    this.records.setHasMore(true);
+  }
+
+  hasMoreRecords(): boolean {
+    return this.records.hasMoreRecords();
+  }
+
+  isRecordsFetching(): boolean {
+    return this.records.isRecordsFetching();
+  }
+
+  appendRecords(records: IRecord[]): void {
+    this.records.appendRecords(records);
+    this.records.updateHasMore(records.length);
+  }
+
+  updateRecordField({ fieldName, recordId, value }) {
+    this.records.updateRecordField({ fieldName, recordId, value });
+  }
+
+  updateRecord(recordId, record) {
+    this.records.updateRecord(recordId, record);
+  }
+
+  deleteMultipleRecord(recordIds: string[]) {
+    this.records.deleteMultipleRecord(recordIds);
+  }
+
+  getTransformer(actionName: string) {
+    return this.apiTemplates.getAPITemplateByName(actionName).getTransformer();
+  }
+
+  isRecordApiName(apiName: string): boolean {
+    return apiName === 'records';
+  }
+
+  isFetchSuccessIrrelevantToRecord(metaData: MetaData): boolean {
+    const { apiName } = metaData;
+
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_SUCCESS];
+  }
+
+  isFetchNoContentIrrelevantToRecord(metaData: MetaData): boolean {
+    const { apiName } = metaData;
+
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_NO_CONTENT];
+  }
+
+  isFetchFailureIrrelevantToRecord(metaData: MetaData): boolean {
+    const { apiName } = metaData;
+
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_FAILURE];
+  }
+
+  toObject(): BehaviourState {
+    const recordsObj = this.records.toObject();
+    return {
+      records: recordsObj.data,
+      hasMore: recordsObj.hasMore,
+      isFetching: recordsObj.isFetching,
+      apiTemplates: this.apiTemplates.toObject()
+    };
+  }
+}

package/src/platform/zrecord/entities/interfaces/APIDetailsModel.ts

@@ -0,0 +1,8 @@
+import { API_METHODS_ENUM } from './apiEnum';
+
+export type APIDetailsModel = {
+  url: string;
+  type: API_METHODS_ENUM;
+  method: API_METHODS_ENUM;
+  payload: object;
+};

package/src/platform/zrecord/entities/interfaces/APITemplateModel.ts

@@ -0,0 +1,3 @@
+import { GetTemplate, PostTemplate } from '@platform/data-broker/dbc/index';
+
+export type APITemplateModel = GetTemplate | PostTemplate;

package/src/platform/zrecord/entities/interfaces/APITemplatesModel.ts

@@ -0,0 +1,3 @@
+import { APITemplateModel } from "./APITemplateModel";
+
+export type APITemplatesModel = { [key: string]: APITemplateModel; };

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

@@ -0,0 +1,8 @@
+import MetaData from './MetaData';
+
+type ActionModel<Payload> = {
+  type: string;
+  payload: Payload;
+  metaData?: MetaData;
+};
+export default ActionModel;

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

@@ -0,0 +1,9 @@
+import { HttpTemplates } from '@platform/data-broker/dbc';
+import { RecordModel } from './RecordModel';
+
+export type BehaviourState = {
+  apiTemplates: HttpTemplates;
+  records: RecordModel[];
+  isFetching: boolean;
+  hasMore: boolean;
+};

package/src/platform/zrecord/entities/interfaces/IAPITemplate.ts

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

package/src/platform/zrecord/entities/interfaces/IAPITemplates.ts

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

package/src/platform/zrecord/entities/interfaces/ICustomFieldValues.ts

@@ -0,0 +1,9 @@
+import { FieldValue, RecordCustomFieldsValue } from './RecordModel';
+
+interface ICustomFieldValues {
+  toObject(): RecordCustomFieldsValue;
+  getFieldValueByName(name: string): FieldValue;
+  hasField(name: string): boolean;
+  setFieldValueByName(name: string, value: FieldValue): void;
+}
+export default ICustomFieldValues;

package/src/platform/zrecord/entities/interfaces/IProperties.ts

@@ -0,0 +1,7 @@
+export interface IProperty {
+  getValue(): any;
+}
+interface IProperties {
+  getProperties(): Map<string, IProperty>;
+}
+export default IProperties;

package/src/platform/zrecord/entities/interfaces/IRecord.ts

@@ -0,0 +1,6 @@
+import { RecordModel } from './RecordModel';
+
+export default interface IRecord {
+  toObject(): RecordModel;
+  getId(): string;
+}

package/src/platform/zrecord/entities/interfaces/IRecordName.ts

@@ -0,0 +1,5 @@
+interface IRecordName {
+  getKey(): string;
+  getValue(): string;
+}
+export default IRecordName;

package/src/platform/zrecord/entities/interfaces/IRecords.ts

@@ -0,0 +1,20 @@
+import IRecord from './IRecord';
+import { RecordsModel } from './RecordsModel';
+
+export default interface IRecords {
+  canFetchMore(): boolean;
+  getIsFetching(): boolean;
+  setHasMore(hasMore: boolean): void;
+  setIsFetching(isFetching: boolean): void;
+  setRecords(records: IRecord[]): void;
+  hasMoreRecords(): boolean;
+  isRecordsFetching(): boolean;
+  getRecordsLength(): number;
+  updateHasMore(recordsLength: number): void;
+  appendRecords(records: IRecord[]): void;
+  updateRecord(recordId: string, record: IRecord): void;
+  updateRecordField({ fieldName, recordId, value }: { fieldName: string; recordId: string; value: any }): void;
+  deleteMultipleRecord(recordIds: string[]);
+  getRecord(index: number): IRecord;
+  toObject(): RecordsModel;
+}

package/src/platform/zrecord/entities/interfaces/IRecordsManager.ts

@@ -0,0 +1,33 @@
+import { ApiHeaders } from '@platform/zlist/entities/interfaces/Properties';
+import ActionModel from './ActionModel';
+import { APIDetailsModel } from './APIDetailsModel';
+import { BehaviourState } from './BehaviourState';
+import IRecord from './IRecord';
+import MetaData from './MetaData';
+
+export default interface IRecordsManager {
+  getApiDetails(actionName: string, props): APIDetailsModel;
+  fetchingStarted(): void;
+  fetchingFinished(): void;
+  resetRecords(): void;
+  appendRecords(records: IRecord[]): void;
+  updateRecord(recordId: string, record: IRecord): void;
+  updateRecordField({ fieldName, recordId, value }: { fieldName: string; recordId: string; value: any }): void;
+  deleteMultipleRecord(recordIds: string[]);
+  getTransformer(actionName: string): any;
+
+  createSuccessAction(records: any[], metaData: MetaData): ActionModel<{ records: any[] }>;
+  createFetchAction(apiDetails: APIDetailsModel, metaData: MetaData): ActionModel<APIDetailsModel>;
+  createNoContentAction(metaData: MetaData): ActionModel<any>;
+  createFailureAction(error: any, metaData: MetaData): ActionModel<{ error: any }>;
+  createFetchMoreRecordMeta(actionName: string, apiName: string, headers: ApiHeaders): MetaData;
+  createFetchRecordMeta(actionName: string, apiName: string, headers: ApiHeaders, props): MetaData;
+
+  isRecordApiName(apiName: string): boolean;
+  hasMoreRecords(): boolean;
+  isRecordsFetching(): boolean;
+  isFetchSuccessIrrelevantToRecord(metaData: MetaData): boolean;
+  isFetchFailureIrrelevantToRecord(metaData: MetaData): boolean;
+  isFetchNoContentIrrelevantToRecord(metaData: MetaData): boolean;
+  toObject(): BehaviourState;
+}

package/src/platform/zrecord/entities/interfaces/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/zrecord/entities/interfaces/MetaData.ts

@@ -0,0 +1,17 @@
+import { RECORD_FAILURE, RECORD_SUCCESS } from '@bc/zrecord/Symbols';
+import { ApiHeaders } from '@platform/zlist/entities/interfaces/Properties';
+
+type MetaData = {
+  apiName: string;
+  actionName: string;
+  headers: ApiHeaders;
+
+  [RECORD_SUCCESS]: {
+    type: string;
+  };
+  [RECORD_FAILURE]?: {
+    type: string;
+  };
+};
+
+export default MetaData;

package/src/platform/zrecord/entities/interfaces/RecordModel.ts

@@ -0,0 +1,22 @@
+export type RecordModel = {
+  id: string;
+  owner?: LookupFieldValue;
+  modifiedTime?: string;
+  createdTime: string;
+  name: string;
+  cf: RecordCustomFieldsValue;
+  layout?: LookupFieldValue;
+  modifiedBy?: LookupFieldValue;
+  createdBy?: LookupFieldValue;
+};
+
+export type RecordCustomFieldsValue = { [key: string]: FieldValue };
+export type FieldValue = string | number | object | LookupFieldValue;
+
+export type LookupFieldValue = {
+  id: string;
+  firstName: string;
+  lastName: string;
+  // name: string;
+  photoURL: string;
+};

package/src/platform/zrecord/entities/interfaces/RecordsModel.ts

@@ -0,0 +1,7 @@
+import { RecordModel } from "./RecordModel";
+
+export type RecordsModel = {
+  data: RecordModel[];
+  isFetching: boolean;
+  hasMore: boolean;
+};

package/src/platform/zrecord/entities/interfaces/apiEnum.ts

@@ -0,0 +1 @@
+export type API_METHODS_ENUM = 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';

package/src/platform/zrecord/frameworks/ActionsHandlersFactory.ts

@@ -0,0 +1,64 @@
+/* eslint-disable max-lines-per-function */
+import ZRecordEventHandlers from '@bc/zrecord/EventHandlers';
+import { HttpTemplates } from '@platform/data-broker/dbc';
+import {
+  APPEND_RECORDS,
+  RECORD_EXECUTE,
+  RECORD_FETCH_MORE,
+  RECORD_FIELD_CHANGE,
+  RECORD_LOCAL_MULTIPLE_DELETE,
+  RECORD_LOCAL_UPDATE,
+  RECORD_REFETCH
+} from '@bc/zrecord/Constants';
+import { FETCH_FAILED, FETCH_SUCCESS, FETCH_SUCCESS_NO_CONTENT } from '@bc/zhttp/Constants';
+import MountController from '../adapters/controllers/MountController';
+import Presenter from '../adapters/presenters/Presenter';
+import Repository from '../adapters/gateways/Repository';
+import ActionExecutorController from '../adapters/controllers/ActionExecutorController';
+import FailureController from '../adapters/controllers/FailureController';
+import SuccessController from '../adapters/controllers/SuccessController';
+import RefetchController from '../adapters/controllers/RefetchController';
+import NoContentController from '../adapters/controllers/NoContentController';
+import TemplateHelpers from '../adapters/gateways/TemplateHelpers';
+import Service from '../adapters/gateways/Service';
+import AppendRecordsController from '../adapters/controllers/AppendRecordsController';
+import FetchMoreController from '../adapters/controllers/FetchMoreController';
+import FieldChangeController from '../adapters/controllers/FieldChangeController';
+import RecordUpdateLocalController from '../adapters/controllers/RecordUpdateLocalController';
+import DeleteMultipleRecordLocalController from '../adapters/controllers/DeleteMultipleRecordLocalController';
+
+export default class ActionsHandlersFactory {
+  static create(apiDetails: HttpTemplates): ZRecordEventHandlers {
+    const presenter = new Presenter();
+    const repository = new Repository();
+    const templateHelpers = new TemplateHelpers();
+    const dependencies = { presenter, repository, templateHelpers };
+    const service = new Service(dependencies);
+
+    const mountController = new MountController(apiDetails, service);
+    const executeController = new ActionExecutorController(service);
+    const failureController = new FailureController(service);
+    const fetchMoreController = new FetchMoreController(service);
+    const successController = new SuccessController(service);
+    const refetchController = new RefetchController(service);
+    const noContentController = new NoContentController(service);
+    const appendRecordsController = new AppendRecordsController(service);
+    const fieldChangeController = new FieldChangeController(service);
+    const recordUpdateLocalController = new RecordUpdateLocalController(service);
+    const deleteMultipleRecordLocalController = new DeleteMultipleRecordLocalController(service);
+
+    return {
+      MOUNT: mountController.handle,
+      [RECORD_EXECUTE]: executeController.handle,
+      [RECORD_FETCH_MORE]: fetchMoreController.handle,
+      [RECORD_REFETCH]: refetchController.handle,
+      [FETCH_FAILED]: failureController.handle,
+      [FETCH_SUCCESS]: successController.handle,
+      [RECORD_LOCAL_MULTIPLE_DELETE]: deleteMultipleRecordLocalController.handle,
+      [APPEND_RECORDS]: appendRecordsController.handle,
+      [RECORD_FIELD_CHANGE]: fieldChangeController.handle,
+      [RECORD_LOCAL_UPDATE]: recordUpdateLocalController.handle,
+      [FETCH_SUCCESS_NO_CONTENT]: noContentController.handle
+    };
+  }
+}

package/src/platform/zrecord/frameworks/RecordBehaviourFactory.ts

@@ -0,0 +1,14 @@
+import Behaviour from '@cc/component/Behaviour';
+import { HttpTemplates } from '../../data-broker/dbc';
+import ActionsHandlersFactory from './ActionsHandlersFactory';
+
+export default class RecordBehaviourFactory {
+  static create(apiDetails: HttpTemplates): Behaviour {
+    return {
+      name: 'zrecord',
+      eventHandlers: ActionsHandlersFactory.create(apiDetails),
+      properties: {},
+      setInitialState: () => ({})
+    };
+  }
+}

package/src/platform/zrecord/usecases/entities-factory/APITemplatesFactory.ts

@@ -0,0 +1,27 @@
+import { HttpTemplates } from '@platform/data-broker/dbc/index';
+import APITemplate from '../../entities/APITemplate';
+import APITemplates from '../../entities/APITemplates';
+import IAPITemplate from '../../entities/interfaces/IAPITemplate';
+import { ITemplateHelpers } from '../interfaces/gateways/ITemplateHelpers';
+
+export default class APITemplatesFactory {
+  static create(
+    httpTemplates: HttpTemplates,
+    templateHelpers: ITemplateHelpers
+  ): APITemplates {
+    const apiTemplatesMap = new Map<string, IAPITemplate>();
+
+    Object.keys(httpTemplates).forEach((key) => {
+      const apiTemplateTemplate = httpTemplates[key];
+
+      const apiTemplate = new APITemplate(
+        apiTemplateTemplate,
+        templateHelpers
+      );
+
+      apiTemplatesMap.set(key, apiTemplate);
+    });
+
+    return new APITemplates(apiTemplatesMap);
+  }
+}

package/src/platform/zrecord/usecases/entities-factory/RecordFactory.ts

@@ -0,0 +1,12 @@
+import { RecordModel } from '../../entities/interfaces/RecordModel';
+import Record from '../../entities/Record';
+
+export default class RecordFactory {
+  static createSingleRecord(recordModel: RecordModel): Record {
+    const record = new Record(recordModel);
+    return record;
+  }
+  static createMultipleRecords(data: RecordModel[]): Record[] {
+    return data.map((recordModel) => new Record(recordModel));
+  }
+}

package/src/platform/zrecord/usecases/entities-factory/RecordsManagerFactory.ts

@@ -0,0 +1,15 @@
+import { HttpTemplates } from '@platform/data-broker/dbc/index';
+import APITemplatesFactory from './APITemplatesFactory';
+import RecordsManager from '../../entities/RecordsManager';
+import Records from '../../entities/Records';
+import { RecordsModel } from '../../entities/interfaces/RecordsModel';
+import { ITemplateHelpers } from '../interfaces/gateways/ITemplateHelpers';
+
+export default class RecordsManagerFactory {
+  static create(httpTemplates: HttpTemplates, recordsModel: RecordsModel, templateHelpers: ITemplateHelpers): RecordsManager {
+    const apiTemplates = APITemplatesFactory.create(httpTemplates, templateHelpers);
+    const records = new Records(recordsModel);
+    const recordManager = new RecordsManager(apiTemplates, records);
+    return recordManager;
+  }
+}

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

@@ -0,0 +1,14 @@
+import IUseCase from '@cc/architecture/IUseCase';
+import InputDependencies from '../interfaces/InputDependencies';
+
+abstract class AbstractUseCase<InputModel> implements IUseCase<InputModel> {
+  constructor(protected dependencies: InputDependencies) {}
+
+  updateDependency(state, updateState) {
+    this.dependencies.repository.init(state);
+    this.dependencies.presenter.updateDependencies(state, updateState);
+  }
+
+  abstract execute(inputModel: InputModel): void;
+}
+export default AbstractUseCase;

package/src/platform/zrecord/usecases/interactors/AppendRecordsUseCase.ts

@@ -0,0 +1,18 @@
+import AbstractUseCase from './AbstractUseCase';
+import RecordFactory from '../entities-factory/RecordFactory';
+import AppendRecordsInputModel from '../interfaces/input/AppendRecordsInputModel';
+
+class AppendRecordsUseCase extends AbstractUseCase<AppendRecordsInputModel> {
+  public execute(input: AppendRecordsInputModel): void {
+    const { presenter, repository, templateHelpers } = this.dependencies;
+    const { records } = input;
+
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+
+    const recordsEntity = RecordFactory.createMultipleRecords(records);
+    recordManager.appendRecords(recordsEntity);
+
+    presenter.updateRecord(recordManager.toObject());
+  }
+}
+export default AppendRecordsUseCase;

package/src/platform/zrecord/usecases/interactors/DeleteMultipleRecordUseCase.ts

@@ -0,0 +1,16 @@
+import AbstractUseCase from './AbstractUseCase';
+import DeleteMultipleRecordInputModel from '../interfaces/input/DeleteMultipleRecordInputModel';
+
+class DeleteMultipleRecordUseCase extends AbstractUseCase<DeleteMultipleRecordInputModel> {
+  public execute(input: DeleteMultipleRecordInputModel): void {
+    const { presenter, repository, templateHelpers } = this.dependencies;
+    const { recordIds } = input;
+
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+
+    recordManager.deleteMultipleRecord(recordIds);
+
+    presenter.updateRecord(recordManager.toObject());
+  }
+}
+export default DeleteMultipleRecordUseCase;

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

@@ -0,0 +1,23 @@
+import ExecuteActionInputModel from '../interfaces/input/ExecuteActionInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class ExecuteActionUseCase extends AbstractUseCase<ExecuteActionInputModel> {
+  execute(input: ExecuteActionInputModel) {
+    const { repository, presenter, templateHelpers } = this.dependencies;
+    const { props, metaData: inputMeta, dispatch, apiName, actionName } = input;
+
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+
+    if (!recordManager.isRecordApiName(apiName)) {
+      return;
+    }
+    const apiDetails = recordManager.getApiDetails(actionName, props);
+    const metaData = recordManager.createFetchRecordMeta(actionName, apiName, inputMeta.headers, props);
+
+    recordManager.fetchingStarted();
+    presenter.updateRecord(recordManager.toObject());
+
+    dispatch(recordManager.createFetchAction(apiDetails, metaData));
+  }
+}
+export default ExecuteActionUseCase;

package/src/platform/zrecord/usecases/interactors/FailureUseCase.ts

@@ -0,0 +1,20 @@
+import FailureInputModel from '../interfaces/input/FailureInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FailureUseCase extends AbstractUseCase<FailureInputModel> {
+  public execute(input: FailureInputModel): void {
+    const { presenter, repository, templateHelpers } = this.dependencies;
+    const { dispatch, metaData, error } = input;
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+
+    if (recordManager.isFetchFailureIrrelevantToRecord(metaData)) {
+      return;
+    }
+
+    recordManager.fetchingFinished();
+    presenter.updateRecord(recordManager.toObject());
+
+    dispatch(recordManager.createFailureAction(error, metaData));
+  }
+}
+export default FailureUseCase;