@zohodesk/library-platform 1.0.0-exp.1

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

@@ -0,0 +1,22 @@
+import { FetchFailureInputModel } from '../interfaces/input/FetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchFailureUseCase extends AbstractUseCase<FetchFailureInputModel> {
+  execute(input: FetchFailureInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { error, dispatch, metaData, apiName } = input;
+    const fieldManager = repository.getFieldManager();
+
+    if (!fieldManager.isFieldFailureFetching(metaData, apiName)) {
+      return;
+    }
+
+    const fields = fieldManager.getTransformedFields(error, apiName);
+    fieldManager.stopFetching(apiName);
+    presenter.updateFields(fieldManager.toObject());
+
+    dispatch(fieldManager.createFailureAction(fields, metaData));
+  }
+}
+
+export default FetchFailureUseCase;

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

@@ -0,0 +1,21 @@
+import { FetchNoContentInputModel } from '../interfaces/input/FetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchNoContentUseCase extends AbstractUseCase<FetchNoContentInputModel> {
+  execute(input: FetchNoContentInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { dispatch, metaData, apiName } = input;
+    const fieldManager = repository.getFieldManager();
+
+    if (! fieldManager.isFieldNoContentFetching(metaData, apiName)) {
+      return;
+    }
+
+    fieldManager.stopFetching(apiName);
+    presenter.updateFields(fieldManager.toObject());
+
+    dispatch(fieldManager.createNoContentAction(metaData));
+  }
+}
+
+export default FetchNoContentUseCase;

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

@@ -0,0 +1,23 @@
+import { FetchSuccessInputModel } from '../interfaces/input/FetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchSuccessUseCase extends AbstractUseCase<FetchSuccessInputModel> {
+  execute(input: FetchSuccessInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { response, dispatch, metaData } = input;
+    const { apiName } = metaData;
+    const fieldManager = repository.getFieldManager();
+
+    if (!fieldManager.isFieldSuccessFetching(metaData, apiName)) {
+      return;
+    }
+
+    const fields = fieldManager.getTransformedFields(response, apiName);
+    fieldManager.stopFetching(apiName);
+    presenter.updateFields(fieldManager.toObject());
+
+    dispatch(fieldManager.createSuccessAction(fields, metaData));
+  }
+}
+
+export default FetchSuccessUseCase;

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

@@ -0,0 +1,13 @@
+import InitialInputModel from "../interfaces/input/InitialInputModel";
+import AbstractUseCase from "./AbstractUseCase";
+
+class InitializeUseCase extends AbstractUseCase<InitialInputModel> {
+  execute(input: InitialInputModel): void {
+    const { apiTemplates } = input;
+    const { presenter } = this.dependencies;
+    
+    presenter.updateApiTemplate(apiTemplates);
+  }
+}
+
+export default InitializeUseCase;

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

@@ -0,0 +1,19 @@
+import RefetchInputModel from '../interfaces/input/RefetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class RefetchUseCase extends AbstractUseCase<RefetchInputModel> {
+  execute(input: RefetchInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { props, metaData, dispatch, actionName, apiName } = input;
+    const fieldManager = repository.getFieldManager();
+
+    if (! fieldManager.isFieldFetching(metaData, apiName)) {
+      return;
+    }
+
+    fieldManager.startFetching(apiName);
+    dispatch(fieldManager.createFetchAction(props, metaData, apiName));
+  }
+}
+
+export default RefetchUseCase;

package/src/platform/zfield/usecases/interfaces/UsecaseDependencies.ts

@@ -0,0 +1,10 @@
+import IRepository from './gateways/IRepository';
+import { ITemplateHelpers } from './gateways/ITemplateHelpers';
+import IPresenter from './output/IPresenter';
+
+type UsecaseDependencies = {
+  repository: IRepository;
+  templateHelpers: ITemplateHelpers;
+  presenter: IPresenter;
+};
+export default UsecaseDependencies;

package/src/platform/zfield/usecases/interfaces/gateways/IRepository.ts

@@ -0,0 +1,8 @@
+import FieldsManager from "../../../entities/fields-manager/FieldsManager";
+
+interface IRepository {
+  init(state: any): void;
+  getFieldManager(): FieldsManager;
+}
+
+export default IRepository;

package/src/platform/zfield/usecases/interfaces/gateways/IRestApi.ts

@@ -0,0 +1,7 @@
+import IAPIDetailsModel from '../../../entities/interfaces/api-template/APIModels';
+
+interface IRestApi {
+  makeRequest(payload: IAPIDetailsModel): void;
+}
+
+export default IRestApi;

package/src/platform/zfield/usecases/interfaces/gateways/IService.ts

@@ -0,0 +1,17 @@
+import ExecuteActionUseCase from "../../interactors/ExecuteActionUseCase";
+import FetchFailureUseCase from "../../interactors/FetchFailureUseCase";
+import FetchNoContentUseCase from "../../interactors/FetchNoContentUseCase";
+import FetchSuccessUseCase from "../../interactors/FetchSuccessUseCase";
+import InitializeUseCase from "../../interactors/InitializeUseCase";
+import RefetchUseCase from "../../interactors/RefetchUseCase";
+
+interface IService {
+  initializeUseCase: InitializeUseCase;
+  executeUseCase: ExecuteActionUseCase;
+  fetchSuccessUseCase: FetchSuccessUseCase;
+  fetchFailureUseCase: FetchFailureUseCase;
+  fetchNoContentUseCase: FetchNoContentUseCase;
+  refetchUseCase: RefetchUseCase;
+}
+
+export default IService;

package/src/platform/zfield/usecases/interfaces/gateways/ITemplateHelpers.ts

@@ -0,0 +1 @@
+export { ITemplateHelpers } from '../../../entities/interfaces/api-template/ITemplateHelpers';

package/src/platform/zfield/usecases/interfaces/input/ExecuteActionInputModel.ts

@@ -0,0 +1,12 @@
+import MetaData from "../../../entities/interfaces/MetaData";
+import { FieldApiName } from "./FetchInputModel";
+
+type ExecuteActionInputModel = {
+  props: any;
+  dispatch: Function;
+  apiName: FieldApiName;
+  actionName: string;
+  metaData: MetaData
+};
+
+export default ExecuteActionInputModel;

package/src/platform/zfield/usecases/interfaces/input/FetchInputModel.ts

@@ -0,0 +1,18 @@
+import MetaData from '../../../entities/interfaces/MetaData';
+
+enum FieldApiName {
+  AVAILABLE_FIELDS = 'availableFields',
+  SELECTED_FIELDS = 'selectedFields'
+};
+
+type FetchInputModel = {
+  dispatch: Function;
+  metaData: MetaData;
+  apiName: FieldApiName;
+};
+
+type FetchSuccessInputModel = FetchInputModel & { response: any };
+type FetchFailureInputModel = FetchInputModel & { error: any };
+type FetchNoContentInputModel = FetchInputModel;
+
+export { FieldApiName, FetchSuccessInputModel, FetchFailureInputModel, FetchNoContentInputModel };

package/src/platform/zfield/usecases/interfaces/input/InitialInputModel.ts

@@ -0,0 +1,5 @@
+type InitialInputModel = {
+  apiTemplates: any;
+};
+
+export default InitialInputModel;

package/src/platform/zfield/usecases/interfaces/input/InputModel.ts

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

package/src/platform/zfield/usecases/interfaces/input/RefetchInputModel.ts

@@ -0,0 +1,12 @@
+import MetaData from '../../../entities/interfaces/MetaData';
+import { FieldApiName } from './FetchInputModel';
+
+type RefetchInputModel = {
+  apiName: FieldApiName;
+  dispatch: Function;
+  metaData: MetaData;
+  actionName?: string;
+  props?: any;
+};
+
+export default RefetchInputModel;

package/src/platform/zfield/usecases/interfaces/input/SetValueInputModel.ts

@@ -0,0 +1,6 @@
+type SetValueInputModel = {
+  id: string;
+  value: any;
+};
+
+export default SetValueInputModel;

package/src/platform/zfield/usecases/interfaces/output/IPresenter.ts

@@ -0,0 +1,9 @@
+import State from "../../../entities/interfaces/BehaviourState";
+
+interface IPresenter {
+  updateDependencies(state, updateState): void;
+  updateApiTemplate(apiTemplate: any): void;
+  updateFields(fields: State): void;
+}
+
+export default IPresenter;

package/src/platform/zhttp/adapters/controllers/FetchController.ts

@@ -0,0 +1,18 @@
+import FetchUseCase from '../../usecases/interactors/FetchUseCase';
+
+class FetchController {
+  constructor(private fetchUseCase: FetchUseCase) {
+    this.fetchUseCase = fetchUseCase;
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(event) {
+    const { action, dispatch } = event;
+    const { payload, metaData } = action;
+    const { url, method, headers } = payload;
+
+    this.fetchUseCase.execute({ url, method, headers, metaData, dispatch, payload: payload.payload });
+  }
+}
+
+export default FetchController;

package/src/platform/zhttp/adapters/gateway/FetchGateWay.ts

@@ -0,0 +1,15 @@
+import {
+  FetchFunction,
+  FetchOptions,
+  IFetchGateWay
+} from '../../usecases/interfaces/gateway/IFetchGateWay';
+
+class FetchGateWay implements IFetchGateWay {
+  constructor(private fetchFunction: FetchFunction) {}
+  async fetch(url: string, options: FetchOptions): Promise<Response> {
+    const response = await this.fetchFunction(url, options);
+    return response;
+  }
+}
+
+export default FetchGateWay;

package/src/platform/zhttp/frameworks/ActionsHandlerFactory.ts

@@ -0,0 +1,19 @@
+import { FETCH } from '@bc/zhttp/Constants';
+import ZHttpActionHandlers from '@bc/zhttp/ActionHandlers';
+import FetchController from '../adapters/controllers/FetchController';
+import FetchUseCase from '../usecases/interactors/FetchUseCase';
+import FetchGateWay from '../adapters/gateway/FetchGateWay';
+
+class ActionsHandlersFactory {
+  static create(windowFetch): ZHttpActionHandlers {
+    const fetchGateWay = new FetchGateWay(windowFetch);
+    const fetchUseCase = new FetchUseCase({ fetchGateWay: fetchGateWay });
+
+    const fetchController = new FetchController(fetchUseCase);
+
+    return {
+      [FETCH]: fetchController.handle
+    };
+  }
+}
+export default ActionsHandlersFactory;

package/src/platform/zhttp/frameworks/ZHttpBehaviourFactory.ts

@@ -0,0 +1,15 @@
+import Behaviour from '@cc/component/Behaviour';
+import ActionsHandlersFactory from './ActionsHandlerFactory';
+
+export default class ZHttpBehaviourFactory {
+  static create(): Behaviour {
+    const behaviour: Behaviour = {
+      name: 'zhttp',
+      properties: {},
+      setInitialState: () => ({}),
+      eventHandlers: ActionsHandlersFactory.create(window.fetch.bind(window)),
+    };
+
+    return behaviour;
+  }
+}

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

@@ -0,0 +1,8 @@
+import InputDependencies from "../interfaces/InputDependencies";
+import UseCase from "../interfaces/UseCase";
+
+abstract class AbstractUseCase<InputModel> implements UseCase<InputModel> {
+  constructor(protected dependencies: InputDependencies) {}
+  abstract execute(inputModel: InputModel): void;
+}
+export default AbstractUseCase;

package/src/platform/zhttp/usecases/interactors/FetchUseCase.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @zohodesk/architecturerules/no-returnStatement-rule */
+/* eslint-disable max-lines-per-function */
+import { FETCH_FAILED, FETCH_SUCCESS_NO_CONTENT, FETCH_REQUESTED, FETCH_SUCCESS } from '@bc/zhttp/Constants';
+import FetchInputModel from '../interfaces/input/FetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchUseCase extends AbstractUseCase<FetchInputModel> {
+  async execute(inputModel: FetchInputModel): Promise<void> {
+    const { fetchGateWay } = this.dependencies;
+    const { url, method = 'GET' } = inputModel;
+    const { metaData, dispatch, payload } = inputModel;
+    const { headers } = metaData;
+
+    dispatch({
+      type: FETCH_REQUESTED,
+      payload: {
+        url,
+        method,
+        headers,
+        metaData
+      }
+    });
+
+    try {
+      const response = await fetchGateWay.fetch(url, { headers, method, body: method === "GET"? null: payload  });
+
+      if (response.status === 204) {
+        dispatch({ type: FETCH_SUCCESS_NO_CONTENT, payload: {}, metaData });
+      } else {
+        const data = await response.json();
+
+        dispatch({
+          type: FETCH_SUCCESS,
+          payload: { response: data },
+          metaData
+        });
+      }
+    } catch (e) {
+      dispatch({ type: FETCH_FAILED, payload: { error: e }, metaData });
+    }
+  }
+}
+
+export default FetchUseCase;

package/src/platform/zhttp/usecases/interfaces/InputDependencies.ts

@@ -0,0 +1,6 @@
+import { IFetchGateWay } from './gateway/IFetchGateWay';
+
+type InputDependencies = {
+  fetchGateWay: IFetchGateWay;
+};
+export default InputDependencies;

package/src/platform/zhttp/usecases/interfaces/UseCase.ts

@@ -0,0 +1,4 @@
+interface UseCase<T> {
+  execute(input: T): void;
+}
+export default UseCase;

package/src/platform/zhttp/usecases/interfaces/gateway/IFetchGateWay.ts

@@ -0,0 +1,15 @@
+type FetchHeader = {} | { [key: string]: string };
+//   type  FetchOptions =  RequestInit
+export type FetchOptions = {
+  headers: FetchHeader;
+  method: string;
+};
+
+export type FetchFunction = (
+  url: string,
+  options: FetchOptions
+) => Promise<Response>;
+
+export interface IFetchGateWay {
+  fetch(url: string, options: FetchOptions): Promise<Response>;
+}

package/src/platform/zhttp/usecases/interfaces/input/FetchInputModel.ts

@@ -0,0 +1,8 @@
+type FetchInputModel = {
+  dispatch: Function;
+  url: string;
+  method: string;
+  headers: object;
+  metaData: object;
+};
+export default FetchInputModel;

package/src/platform/zlist/adapters/controllers/AbstractController.ts

@@ -0,0 +1,12 @@
+import IService from '../../usecases/interfaces/gateways/IService';
+
+abstract class AbstractController {
+  constructor(protected service: IService) {
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  }
+
+  abstract handle(event): void;
+}
+
+export default AbstractController;

package/src/platform/zlist/adapters/controllers/DeleteMultipleRecordController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class DeleteMultipleRecordController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { recordIds } = action.payload;
+    const { deleteMultipleRecordUseCase } = this.service;
+
+    deleteMultipleRecordUseCase.updateDependency(state, updateState);
+    deleteMultipleRecordUseCase.execute({ dispatch, recordIds });
+  }
+}

package/src/platform/zlist/adapters/controllers/FetchMoreController.ts

@@ -0,0 +1,11 @@
+import AbstractController from './AbstractController';
+
+export default class FetchMoreController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch } = event;
+    const { fetchMoreUseCase } = this.service;
+
+    fetchMoreUseCase.updateDependency(state, updateState);
+    fetchMoreUseCase.execute({ dispatch });
+  }
+}

package/src/platform/zlist/adapters/controllers/FieldChangeController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class FieldChangeController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { fieldName, rowId, value } = action.payload;
+    const { fieldChangeUseCase } = this.service;
+
+    fieldChangeUseCase.updateDependency(state, updateState);
+    fieldChangeUseCase.execute({ dispatch, fieldName, rowId, value });
+  }
+}

package/src/platform/zlist/adapters/controllers/MountController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+class MountController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch } = event;
+    const { initializeUseCase } = this.service;
+    initializeUseCase.updateDependency(state, updateState);
+    initializeUseCase.execute({ dispatch });
+  }
+}
+
+export default MountController;

package/src/platform/zlist/adapters/controllers/PropertiesChangeController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class PropertiesChangeController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch, action } = event;
+    const { currentProperties, previousProperties } = action.payload;
+    const { propertiesChangeUseCase } = this.service;
+
+    propertiesChangeUseCase.updateDependency(state, updateState);
+    propertiesChangeUseCase.execute({ dispatch, currentProperties, previousProperties });
+  }
+}
+
+export default PropertiesChangeController;

package/src/platform/zlist/adapters/controllers/RecordUpdateController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class RecordUpdateController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { recordId, record } = action.payload;
+    const { recordUpdateUseCase } = this.service;
+
+    recordUpdateUseCase.updateDependency(state, updateState);
+    recordUpdateUseCase.execute({ dispatch, recordId, record });
+  }
+}

package/src/platform/zlist/adapters/controllers/SortController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class SortController extends AbstractController {
+  handle(event) {
+    const { sortUseCase } = this.service;
+    const { state, updateState, action, dispatch } = event;
+    const { sortBy } = action.payload;
+
+    sortUseCase.updateDependency(state, updateState);
+    sortUseCase.execute({ sortBy, dispatch });
+  }
+}
+
+export default SortController;

package/src/platform/zlist/adapters/gateways/Repository.ts

@@ -0,0 +1,30 @@
+import ListFactory from '../../usecases/entities-factory/ListFactory';
+import IRepository from '../../usecases/interfaces/gateways/IRepository';
+import IList from '../../entities/interfaces/IList';
+
+class Repository implements IRepository {
+  private state;
+
+  init(state) {
+    this.state = state;
+  }
+
+  getList(): IList {
+    const { limit, sortBy, filter, moduleName, headers } = this.state.properties;
+    const list = ListFactory.createList({
+      headers,
+      filter: {
+        ...filter,
+        departmentId: filter.departmentId,
+        viewId: filter.viewId,
+        orgId: filter.orgId,
+        moduleName
+      },
+      sortBy,
+      limit
+    });
+    return list;
+  }
+}
+
+export default Repository;

package/src/platform/zlist/adapters/gateways/Service.ts

@@ -0,0 +1,31 @@
+import IService from '../../usecases/interfaces/gateways/IService';
+import UseCaseDependencies from '../../usecases/interfaces/UseCaseDependencies';
+
+import InitializeUseCase from '../../usecases/interactors/InitializeUseCase';
+import PropertiesChangeUseCase from '../../usecases/interactors/PropertiesChangeUseCase';
+import FetchMoreUseCase from '../../usecases/interactors/FetchMoreUseCase';
+import FieldChangeUseCase from '../../usecases/interactors/FieldChangeUseCase';
+import DeleteMultipleRecordUseCase from '../../usecases/interactors/DeleteMultipleRecordUseCase';
+import SortUseCase from '../../usecases/interactors/SortUseCase';
+import RecordUpdateUseCase from '../../usecases/interactors/RecordUpdateUseCase';
+
+class Service implements IService {
+  initializeUseCase: InitializeUseCase;
+  propertiesChangeUseCase: PropertiesChangeUseCase;
+  fieldChangeUseCase: FieldChangeUseCase;
+  fetchMoreUseCase: FetchMoreUseCase;
+  deleteMultipleRecordUseCase: DeleteMultipleRecordUseCase;
+  sortUseCase: SortUseCase;
+  recordUpdateUseCase: RecordUpdateUseCase;
+
+  constructor(private dependencies: UseCaseDependencies) {
+    this.initializeUseCase = new InitializeUseCase(this.dependencies);
+    this.propertiesChangeUseCase = new PropertiesChangeUseCase(this.dependencies);
+    this.fetchMoreUseCase = new FetchMoreUseCase(this.dependencies);
+    this.fieldChangeUseCase = new FieldChangeUseCase(this.dependencies);
+    this.sortUseCase = new SortUseCase(this.dependencies);
+    this.deleteMultipleRecordUseCase = new DeleteMultipleRecordUseCase(this.dependencies);
+    this.recordUpdateUseCase = new RecordUpdateUseCase(this.dependencies);
+  }
+}
+export default Service;

package/src/platform/zlist/adapters/gateways/SortBy.ts

@@ -0,0 +1,27 @@
+import SortByOutputModel from '@library/behaviours/sort-by/usecases/interfaces/output/SortByOutputModel';
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+import ISortBy from '../../usecases/interfaces/gateways/ISortBy';
+
+class SortBy implements ISortBy {
+  toQueryString(sortBy: SortByOutputModel): string {
+    const { name, order } = sortBy;
+    let sortQueryString = '';
+    if (order === SortOrder.ASC) {
+      sortQueryString = name;
+    } else if (order === SortOrder.DES) {
+      sortQueryString = `-${name}`;
+    }
+    return sortQueryString;
+  }
+
+  toObject(sortBy: string): { name: string; order: SortOrder } {
+    let sortByParsed = sortBy.split('-');
+    if (sortByParsed[0] === '-') {
+      return { name: sortByParsed[1], order: SortOrder.DES };
+    } else {
+      return { name: sortByParsed[0], order: SortOrder.ASC };
+    }
+  }
+}
+
+export default SortBy;