@zohodesk/library-platform 1.0.0-exp.1 → 1.0.0-exp.3

package/es/platform/zrecord/entities/Records.js

@@ -0,0 +1,98 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import Record from "./Record";
+export default class Records {
+  constructor(_ref) {
+    let {
+      data,
+      isFetching,
+      hasMore
+    } = _ref;
+    let fetchLimit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 25;
+
+    _defineProperty(this, "records", void 0);
+
+    _defineProperty(this, "isFetching", void 0);
+
+    _defineProperty(this, "hasMore", void 0);
+
+    _defineProperty(this, "fetchLimit", void 0);
+
+    this.records = data.map(obj => new Record(obj));
+    this.hasMore = hasMore;
+    this.fetchLimit = fetchLimit;
+    this.isFetching = isFetching;
+  }
+
+  canFetchMore() {
+    return this.hasMore;
+  }
+
+  getIsFetching() {
+    return this.isFetching;
+  }
+
+  setHasMore(hasMore) {
+    this.hasMore = hasMore;
+  }
+
+  setIsFetching(isFetching) {
+    this.isFetching = isFetching;
+  }
+
+  setRecords(records) {
+    this.records = records;
+  }
+
+  updateHasMore(recordsLength) {
+    this.hasMore = recordsLength >= this.fetchLimit;
+  }
+
+  getRecordsLength() {
+    return this.records.length;
+  }
+
+  hasMoreRecords() {
+    return this.hasMore;
+  }
+
+  isRecordsFetching() {
+    return this.isFetching;
+  }
+
+  appendRecords(records) {
+    this.records = [...this.records, ...records];
+  }
+
+  updateRecordField(_ref2) {
+    let {
+      fieldName,
+      recordId,
+      value
+    } = _ref2;
+    const record = this.records.find(record => record.getId() === recordId);
+    if (!record) return;
+    record.updateField(fieldName, value);
+  }
+
+  deleteMultipleRecord(recordIds) {
+    this.records = this.records.filter(r => !recordIds.includes(r.getId()));
+  }
+
+  updateRecord(recordId, record) {
+    this.records = this.records.map(r => r.getId() === recordId ? record : r);
+  }
+
+  getRecord(index) {
+    return this.records[index];
+  }
+
+  toObject() {
+    return {
+      data: this.records.map(record => record.toObject()),
+      hasMore: this.hasMore,
+      isFetching: this.isFetching
+    };
+  }
+
+}

package/es/platform/zrecord/entities/RecordsManager.js

@@ -0,0 +1,235 @@
+/* eslint-disable max-lines-per-function */
+import { RECORD_FAILURE, RECORD_NO_CONTENT, RECORD_SUCCESS } from "../../../bc/zrecord/Symbols";
+import { FETCH } from "../../../bc/zhttp/Constants";
+import { APPEND_RECORDS, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, RecordApiActionName } from "../../../bc/zrecord/Constants";
+export default class RecordsManager {
+  constructor(apiTemplates, records) {
+    this.apiTemplates = apiTemplates;
+    this.records = records;
+  }
+
+  createFetchAction(apiDetails, metaData) {
+    return {
+      type: FETCH,
+      payload: apiDetails,
+      metaData: metaData
+    };
+  }
+
+  createFetchRecordMeta(actionName, apiName, headers, props) {
+    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, apiName, headers) {
+    return {
+      headers,
+      apiName,
+      actionName,
+      [RECORD_SUCCESS]: {
+        type: APPEND_RECORDS
+      }
+    };
+  }
+
+  createSuccessAction(transformedRes, metaData) {
+    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
+      }
+    };
+  }
+
+  createNoContentAction(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, metaData) {
+    const {
+      type
+    } = metaData[RECORD_FAILURE];
+    return {
+      type,
+      payload: {
+        error
+      }
+    };
+  }
+
+  getApiDetails(actionName, props) {
+    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() {
+    return this.records.hasMoreRecords();
+  }
+
+  isRecordsFetching() {
+    return this.records.isRecordsFetching();
+  }
+
+  appendRecords(records) {
+    this.records.appendRecords(records);
+    this.records.updateHasMore(records.length);
+  }
+
+  updateRecordField(_ref) {
+    let {
+      fieldName,
+      recordId,
+      value
+    } = _ref;
+    this.records.updateRecordField({
+      fieldName,
+      recordId,
+      value
+    });
+  }
+
+  updateRecord(recordId, record) {
+    this.records.updateRecord(recordId, record);
+  }
+
+  deleteMultipleRecord(recordIds) {
+    this.records.deleteMultipleRecord(recordIds);
+  }
+
+  getTransformer(actionName) {
+    return this.apiTemplates.getAPITemplateByName(actionName).getTransformer();
+  }
+
+  isRecordApiName(apiName) {
+    return apiName === 'records';
+  }
+
+  isFetchSuccessIrrelevantToRecord(metaData) {
+    const {
+      apiName
+    } = metaData;
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_SUCCESS];
+  }
+
+  isFetchNoContentIrrelevantToRecord(metaData) {
+    const {
+      apiName
+    } = metaData;
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_NO_CONTENT];
+  }
+
+  isFetchFailureIrrelevantToRecord(metaData) {
+    const {
+      apiName
+    } = metaData;
+    return !this.isRecordApiName(apiName) || !metaData[RECORD_FAILURE];
+  }
+
+  toObject() {
+    const recordsObj = this.records.toObject();
+    return {
+      records: recordsObj.data,
+      hasMore: recordsObj.hasMore,
+      isFetching: recordsObj.isFetching,
+      apiTemplates: this.apiTemplates.toObject()
+    };
+  }
+
+}

package/es/platform/zrecord/entities/interfaces/APIDetailsModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/APITemplateModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/APITemplatesModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/ActionModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/BehaviourState.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/IAPITemplate.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/IAPITemplates.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/ICustomFieldValues.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/IProperties.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/IRecordName.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/ITemplateHelpers.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/MetaData.js

@@ -0,0 +1 @@
+import { RECORD_FAILURE, RECORD_SUCCESS } from "../../../../bc/zrecord/Symbols";

package/es/platform/zrecord/entities/interfaces/RecordModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/RecordsModel.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/entities/interfaces/apiEnum.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zrecord/frameworks/ActionsHandlersFactory.js

@@ -0,0 +1,56 @@
+/* eslint-disable max-lines-per-function */
+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) {
+    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/es/platform/zrecord/frameworks/RecordBehaviourFactory.js

@@ -0,0 +1,12 @@
+import ActionsHandlersFactory from "./ActionsHandlersFactory";
+export default class RecordBehaviourFactory {
+  static create(apiDetails) {
+    return {
+      name: 'zrecord',
+      eventHandlers: ActionsHandlersFactory.create(apiDetails),
+      properties: {},
+      setInitialState: () => ({})
+    };
+  }
+
+}

package/es/platform/zrecord/usecases/entities-factory/APITemplatesFactory.js

@@ -0,0 +1,14 @@
+import APITemplate from "../../entities/APITemplate";
+import APITemplates from "../../entities/APITemplates";
+export default class APITemplatesFactory {
+  static create(httpTemplates, templateHelpers) {
+    const apiTemplatesMap = new Map();
+    Object.keys(httpTemplates).forEach(key => {
+      const apiTemplateTemplate = httpTemplates[key];
+      const apiTemplate = new APITemplate(apiTemplateTemplate, templateHelpers);
+      apiTemplatesMap.set(key, apiTemplate);
+    });
+    return new APITemplates(apiTemplatesMap);
+  }
+
+}

package/es/platform/zrecord/usecases/entities-factory/RecordFactory.js

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

package/es/platform/zrecord/usecases/entities-factory/RecordsManagerFactory.js

@@ -0,0 +1,12 @@
+import APITemplatesFactory from "./APITemplatesFactory";
+import RecordsManager from "../../entities/RecordsManager";
+import Records from "../../entities/Records";
+export default class RecordsManagerFactory {
+  static create(httpTemplates, recordsModel, templateHelpers) {
+    const apiTemplates = APITemplatesFactory.create(httpTemplates, templateHelpers);
+    const records = new Records(recordsModel);
+    const recordManager = new RecordsManager(apiTemplates, records);
+    return recordManager;
+  }
+
+}

package/es/platform/zrecord/usecases/interactors/AbstractUseCase.js

@@ -0,0 +1,13 @@
+class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+  updateDependency(state, updateState) {
+    this.dependencies.repository.init(state);
+    this.dependencies.presenter.updateDependencies(state, updateState);
+  }
+
+}
+
+export default AbstractUseCase;

package/es/platform/zrecord/usecases/interactors/AppendRecordsUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+import RecordFactory from "../entities-factory/RecordFactory";
+
+class AppendRecordsUseCase extends AbstractUseCase {
+  execute(input) {
+    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/es/platform/zrecord/usecases/interactors/DeleteMultipleRecordUseCase.js

@@ -0,0 +1,20 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class DeleteMultipleRecordUseCase extends AbstractUseCase {
+  execute(input) {
+    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/es/platform/zrecord/usecases/interactors/ExecuteActionUseCase.js

@@ -0,0 +1,32 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class ExecuteActionUseCase extends AbstractUseCase {
+  execute(input) {
+    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/es/platform/zrecord/usecases/interactors/FailureUseCase.js

@@ -0,0 +1,28 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FailureUseCase extends AbstractUseCase {
+  execute(input) {
+    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;

package/es/platform/zrecord/usecases/interactors/FetchMoreUseCase.js

@@ -0,0 +1,32 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchMoreUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter,
+      templateHelpers
+    } = this.dependencies;
+    const {
+      props,
+      metaData: inputMeta,
+      dispatch,
+      apiName,
+      actionName
+    } = input;
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+
+    if (!recordManager.isRecordApiName(apiName) || !recordManager.hasMoreRecords() || recordManager.isRecordsFetching()) {
+      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 FetchMoreUseCase;

package/es/platform/zrecord/usecases/interactors/FieldChangeUseCase.js

@@ -0,0 +1,26 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FieldChangeUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter,
+      repository,
+      templateHelpers
+    } = this.dependencies;
+    const {
+      fieldName,
+      recordId,
+      value
+    } = input;
+    const recordManager = repository.getRecordsManagerEntity(templateHelpers);
+    recordManager.updateRecordField({
+      fieldName,
+      recordId,
+      value
+    });
+    presenter.updateRecord(recordManager.toObject());
+  }
+
+}
+
+export default FieldChangeUseCase;