@zohodesk/library-platform 1.0.0-exp.1

package/src/platform/zlist/entities/List.ts

@@ -0,0 +1,237 @@
+import ActionModel from './interfaces/ActionModel';
+import ApiPropsModel from './interfaces/ApiPropsModel';
+import IList from './interfaces/IList';
+import { Filter, Properties, ApiHeaders, SortByModel } from './interfaces/Properties';
+import { RECORD_EXECUTE, RECORD_FETCH_MORE, RECORD_REFETCH, RecordApiActionName } from '@bc/zrecord/Constants';
+import { FIELD_EXECUTE, FIELD_REFETCH } from '@bc/zfield/Constants';
+
+class List implements IList {
+  constructor(
+    private limit: number,
+    private sortBy: SortByModel,
+    private filter: Filter,
+    private headers: ApiHeaders
+  ) {}
+
+  private createApiProps(from = 1): ApiPropsModel {
+    const { filter, limit, sortBy } = this;
+    return {
+      from,
+      limit,
+      sortBy,
+      ...filter
+    };
+  }
+
+  public createSortByRefetchAction(sortBy: string): ActionModel {
+    this.sortBy = sortBy;
+    return this.createRecordsRefetchAction();
+  }
+
+  public getInitialMountFetchActions(): ActionModel[] {
+    return [
+      this.createRecordsFetchAction(),
+      this.createAvailableFieldsFetchAction(),
+      this.createSelectedFieldsFetchAction()
+      // this.createUIActionsFetchAction(),
+    ];
+  }
+
+  public getPropertiesChangeRefetchActions(previousProperties: Properties, currentProperties: Properties): ActionModel[] {
+    const { sortBy: prevSortBy, filter: prevFilter } = previousProperties;
+    const { sortBy: sortBy, filter: currentFilter } = currentProperties;
+
+    if (prevSortBy !== sortBy) {
+      return [this.createRecordsRefetchAction()];
+    }
+    if (prevFilter.departmentId !== currentFilter.departmentId || prevFilter.viewId !== currentFilter.viewId) {
+      return [
+        this.createRecordsRefetchAction(),
+        this.createAvailableFieldsFetchAction(),
+        this.createSelectedFieldsFetchAction()
+        //  this.createAvailableFieldsRefetchAction(),
+        //   this.createSelectedFieldsRefetchAction()
+      ];
+    }
+    return [];
+  }
+
+  private createRecordsFetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_EXECUTE,
+      payload: {
+        actionName: RecordApiActionName.GET_RECORDS,
+        props,
+        apiName: 'records'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  getFieldChangeFetchActions({ fieldName, rowId, value }): ActionModel {
+    const record = fieldName.startsWith('cf_') ? { cf: { [fieldName]: value } } : { [fieldName]: value };
+    return this.getUpdateRecordFetchActions(rowId, record);
+  }
+
+  getUpdateRecordFetchActions(recordId, record): ActionModel {
+    const props = this.createApiProps();
+
+    return {
+      type: RECORD_EXECUTE,
+      payload: {
+        actionName: RecordApiActionName.UPDATE_RECORD,
+        props: {
+          ...props,
+          recordId: recordId,
+          record: record
+        },
+        apiName: 'records'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  getDeleteMultipleRecordAction(recordIds): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_EXECUTE,
+      payload: {
+        actionName: RecordApiActionName.DELETE_RECORDS,
+        props: {
+          ...props,
+          recordIds
+        },
+        apiName: 'records'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  public createMoreRecordFetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_FETCH_MORE,
+      payload: {
+        actionName: RecordApiActionName.GET_RECORDS,
+        props,
+        apiName: 'records'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createAvailableFieldsFetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: FIELD_EXECUTE,
+      payload: {
+        actionName: 'getFields',
+        props,
+        apiName: 'availableFields'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createSelectedFieldsFetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: FIELD_EXECUTE,
+      payload: {
+        actionName: 'getSelectedFields',
+        props,
+        apiName: 'selectedFields'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createUIActionsFetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_EXECUTE,
+      payload: {
+        actionName: 'getUIActions',
+        props,
+        apiName: 'uiActions'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createRecordsRefetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_REFETCH,
+      payload: {
+        actionName: RecordApiActionName.GET_RECORDS,
+        props,
+        apiName: 'records'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createAvailableFieldsRefetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: FIELD_REFETCH,
+      payload: {
+        actionName: 'getAvailableFields',
+        props,
+        apiName: 'availableFields'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createSelectedFieldsRefetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: FIELD_REFETCH,
+      payload: {
+        actionName: 'getSelectedFields',
+        props,
+        apiName: 'selectedFields'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+
+  private createUIActionsRefetchAction(): ActionModel {
+    const props = this.createApiProps();
+    return {
+      type: RECORD_REFETCH,
+      payload: {
+        actionName: 'getUIActions',
+        props,
+        apiName: 'uiActions'
+      },
+      metaData: {
+        headers: this.headers
+      }
+    };
+  }
+}
+export default List;

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

@@ -0,0 +1,13 @@
+import ApiPropsModel from './ApiPropsModel';
+import { ApiHeaders } from './Properties';
+
+type ActionModel = {
+  type: string;
+  payload: { actionName: string; props: ApiPropsModel; apiName: string };
+  metaData?: {
+    headers: ApiHeaders;
+    [key: string]: any;
+  };
+};
+
+export default ActionModel;

package/src/platform/zlist/entities/interfaces/ApiPropsModel.ts

@@ -0,0 +1,10 @@
+import { SortByModel } from './Properties';
+
+type ApiPropsModel = {
+  from: number;
+  limit: number;
+  // moduleName: string;
+  sortBy: SortByModel;
+};
+
+export default ApiPropsModel;

package/src/platform/zlist/entities/interfaces/IList.ts

@@ -0,0 +1,13 @@
+import ActionModel from './ActionModel';
+import { Properties } from './Properties';
+
+interface IList {
+  getPropertiesChangeRefetchActions(previousProperties: Properties, currentProperties: Properties): ActionModel[];
+  getInitialMountFetchActions(): ActionModel[];
+  getFieldChangeFetchActions({ fieldName, rowId, value }: { fieldName: string; rowId: string; value: string }): ActionModel;
+  getUpdateRecordFetchActions(recordId: string, record: object): ActionModel;
+  getDeleteMultipleRecordAction(recordIds: string[]);
+  createMoreRecordFetchAction(): ActionModel;
+  createSortByRefetchAction(sortBy: string): ActionModel;
+}
+export default IList;

package/src/platform/zlist/entities/interfaces/Properties.ts

@@ -0,0 +1,18 @@
+export type Properties = {
+  limit: number;
+  headers: ApiHeaders;
+  sortBy: SortByModel;
+  moduleName: string;
+  filter: Filter;
+};
+
+export type ApiHeaders = { [key: string]: string };
+
+export type SortByModel = string;
+
+export type Filter = {
+  viewId: string;
+  orgId: string;
+  departmentId: string;
+  [key: string]: string;
+};

package/src/platform/zlist/frameworks/EventHandlersFactory.ts

@@ -0,0 +1,44 @@
+/* eslint-disable max-lines-per-function */
+import ZListEventHandlers from '@bc/zlist/EventHandlers';
+import { TableListConstants } from '@cc/table-list';
+
+import Service from '../adapters/gateways/Service';
+import Repository from '../adapters/gateways/Repository';
+import MountController from '../adapters/controllers/MountController';
+import PropertiesChangeController from '../adapters/controllers/PropertiesChangeController';
+import { ZLIST_DELETE_RECORDS, ZLIST_FETCH_MORE, ZLIST_FETCH_SORTED, ZLIST_RECORD_UPDATE } from '@bc/zlist/Constants';
+import FetchMoreController from '../adapters/controllers/FetchMoreController';
+import SortController from '../adapters/controllers/SortController';
+import FieldChangeController from '../adapters/controllers/FieldChangeController';
+import LifeCycleAction from '@cc/architecture/LifeCycleActionEnum';
+import SortBy from '../adapters/gateways/SortBy';
+import DeleteMultipleRecordController from '../adapters/controllers/DeleteMultipleRecordController';
+import RecordUpdateController from '../adapters/controllers/RecordUpdateController';
+
+export default class ActionHandlersFactory {
+  static create(): ZListEventHandlers {
+    const repository = new Repository();
+    const sortByGateway = new SortBy();
+    const service = new Service({ repository, sortBy: sortByGateway });
+
+    const controller = {
+      mount: new MountController(service).handle,
+      update: new PropertiesChangeController(service).handle,
+      fetchMore: new FetchMoreController(service).handle,
+      fieldChange: new FieldChangeController(service).handle,
+      recordUpdate: new RecordUpdateController(service).handle,
+      deleteMultipleRecord: new DeleteMultipleRecordController(service).handle,
+      sort: new SortController(service).handle
+    };
+
+    return {
+      [LifeCycleAction.MOUNT]: controller.mount,
+      [LifeCycleAction.UPDATE_PROPERTIES]: controller.update,
+      [ZLIST_DELETE_RECORDS]: controller.deleteMultipleRecord,
+      [ZLIST_FETCH_MORE]: controller.fetchMore,
+      [ZLIST_RECORD_UPDATE]: controller.recordUpdate,
+      [TableListConstants.TABLE_LIST_FIELD_CHANGED]: controller.fieldChange,
+      [ZLIST_FETCH_SORTED]: controller.sort
+    };
+  }
+}

package/src/platform/zlist/frameworks/ZListBehaviourFactory.ts

@@ -0,0 +1,14 @@
+import Behaviour from '@cc/component/Behaviour';
+import Properties from '@bc/zlist/Properties';
+import EventHandlersFactory from './EventHandlersFactory';
+
+export default class ZListBehaviourFactory {
+  static create(): Behaviour {
+    return {
+      name: 'zlist',
+      setInitialState: () => ({}),
+      eventHandlers: EventHandlersFactory.create(),
+      properties: Properties
+    };
+  }
+}

package/src/platform/zlist/usecases/entities-factory/ListFactory.ts

@@ -0,0 +1,11 @@
+import { Filter, ApiHeaders, SortByModel } from '../../entities/interfaces/Properties';
+import List from '../../entities/List';
+import IList from '../../entities/interfaces/IList';
+
+class ListFactory {
+  static createList(input: { limit: number; sortBy: SortByModel; filter: Filter; headers: ApiHeaders }): IList {
+    const { limit, sortBy, filter, headers } = input;
+    return new List(limit, sortBy, filter, headers);
+  }
+}
+export default ListFactory;

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

@@ -0,0 +1,18 @@
+import IUseCase from '@cc/architecture/IUseCase';
+import UseCaseDependencies from '../interfaces/UseCaseDependencies';
+import { State } from '../interfaces/State';
+
+abstract class AbstractUseCase<InputModel> implements IUseCase<InputModel> {
+  constructor(protected dependencies: UseCaseDependencies) {
+    this.execute = this.execute.bind(this);
+  }
+
+  updateDependency(state: State, updateState: Function) {
+    const { repository } = this.dependencies;
+    repository.init(state);
+  }
+
+  abstract execute(inputModel: InputModel): void;
+}
+
+export default AbstractUseCase;

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

@@ -0,0 +1,14 @@
+import DeleteMultipleRecordUseCaseInput from '../interfaces/input/DeleteMultipleRecordUseCaseInput';
+
+import AbstractUseCase from './AbstractUseCase';
+
+class DeleteMultipleRecordUseCase extends AbstractUseCase<DeleteMultipleRecordUseCaseInput> {
+  execute(input: DeleteMultipleRecordUseCaseInput): void {
+    const { dispatch, recordIds } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getDeleteMultipleRecordAction(recordIds);
+    dispatch(action);
+  }
+}
+export default DeleteMultipleRecordUseCase;

package/src/platform/zlist/usecases/interactors/FetchMoreUseCase.ts

@@ -0,0 +1,13 @@
+import FetchMoreInput from '../interfaces/input/FetchMoreInput';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchMoreUseCase extends AbstractUseCase<FetchMoreInput> {
+  execute(input: FetchMoreInput): void {
+    const { dispatch } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+
+    dispatch(list.createMoreRecordFetchAction());
+  }
+}
+export default FetchMoreUseCase;

package/src/platform/zlist/usecases/interactors/FieldChangeUseCase.ts

@@ -0,0 +1,14 @@
+import FieldChangeUseCaseInput from '../interfaces/input/FieldChangeUseCaseInput';
+
+import AbstractUseCase from './AbstractUseCase';
+
+class FieldChangeUseCase extends AbstractUseCase<FieldChangeUseCaseInput> {
+  execute(input: FieldChangeUseCaseInput): void {
+    const { dispatch, fieldName, rowId, value } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getFieldChangeFetchActions({ fieldName, rowId, value });
+    dispatch(action);
+  }
+}
+export default FieldChangeUseCase;

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

@@ -0,0 +1,13 @@
+import InitializeInput from '../interfaces/input/InitializeInput';
+import AbstractUseCase from './AbstractUseCase';
+
+class InitializeUseCase extends AbstractUseCase<InitializeInput> {
+  execute(input: InitializeInput): void {
+    const { dispatch } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+    const actions = list.getInitialMountFetchActions();
+    actions.forEach(action => dispatch(action));
+  }
+}
+export default InitializeUseCase;

package/src/platform/zlist/usecases/interactors/PropertiesChangeUseCase.ts

@@ -0,0 +1,14 @@
+import PropertiesChangeUseCaseInput from '../interfaces/input/PropertiesChangeUseCaseInput';
+
+import AbstractUseCase from './AbstractUseCase';
+
+class PropertiesChangeUseCase extends AbstractUseCase<PropertiesChangeUseCaseInput> {
+  execute(input: PropertiesChangeUseCaseInput): void {
+    const { dispatch, currentProperties, previousProperties } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+    const actions = list.getPropertiesChangeRefetchActions(previousProperties, currentProperties);
+    actions.forEach(action => dispatch(action));
+  }
+}
+export default PropertiesChangeUseCase;

package/src/platform/zlist/usecases/interactors/RecordUpdateUseCase.ts

@@ -0,0 +1,14 @@
+import RecordUpdateUseCaseInput from '../interfaces/input/RecordUpdateUseCaseInput';
+
+import AbstractUseCase from './AbstractUseCase';
+
+class RecordUpdateUseCase extends AbstractUseCase<RecordUpdateUseCaseInput> {
+  execute(input: RecordUpdateUseCaseInput): void {
+    const { dispatch, recordId, record } = input;
+    const { repository } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getUpdateRecordFetchActions(recordId, record); 
+    dispatch(action);
+  }
+}
+export default RecordUpdateUseCase;

package/src/platform/zlist/usecases/interactors/SortUseCase.ts

@@ -0,0 +1,15 @@
+import SortingInputModel from '../interfaces/input/SortingInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class SortUseCase extends AbstractUseCase<SortingInputModel> {
+  execute(input: SortingInputModel): void {
+    const { sortBy, dispatch } = input;
+    const { repository, sortBy: sortByGateway } = this.dependencies;
+    const list = repository.getList();
+    const sortByQueryString = sortByGateway.toQueryString(sortBy);
+
+    dispatch(list.createSortByRefetchAction(sortByQueryString));
+  }
+}
+
+export default SortUseCase;

package/src/platform/zlist/usecases/interfaces/State.ts

@@ -0,0 +1,5 @@
+import { Properties } from '../../entities/interfaces/Properties';
+
+export type State = {
+  properties: Properties;
+};

package/src/platform/zlist/usecases/interfaces/UseCaseDependencies.ts

@@ -0,0 +1,9 @@
+import IRepository from './gateways/IRepository';
+import ISortBy from './gateways/ISortBy';
+
+type UseCaseDependencies = {
+  repository: IRepository;
+  sortBy: ISortBy;
+};
+
+export default UseCaseDependencies;

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

@@ -0,0 +1,9 @@
+import IList from '../../../entities/interfaces/IList';
+import { State } from '../State';
+
+interface IRepository {
+  init(state: State): void;
+  getList: () => IList;
+}
+
+export default IRepository;

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

@@ -0,0 +1,19 @@
+import FetchMoreUseCase from '../../interactors/FetchMoreUseCase';
+import FieldChangeUseCase from '../../interactors/FieldChangeUseCase';
+import SortUseCase from '../../interactors/SortUseCase';
+import InitializeUseCase from '../../interactors/InitializeUseCase';
+import PropertiesChangeUseCase from '../../interactors/PropertiesChangeUseCase';
+import DeleteMultipleRecordUseCase from '../../interactors/DeleteMultipleRecordUseCase';
+import RecordUpdateUseCase from '../../interactors/RecordUpdateUseCase';
+
+interface IService {
+  initializeUseCase: InitializeUseCase;
+  propertiesChangeUseCase: PropertiesChangeUseCase;
+  fieldChangeUseCase: FieldChangeUseCase;
+  fetchMoreUseCase: FetchMoreUseCase;
+  deleteMultipleRecordUseCase: DeleteMultipleRecordUseCase;
+  recordUpdateUseCase: RecordUpdateUseCase;
+  sortUseCase: SortUseCase;
+}
+
+export default IService;

package/src/platform/zlist/usecases/interfaces/gateways/ISortBy.ts

@@ -0,0 +1,9 @@
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+import SortByOutputModel from '@library/behaviours/sort-by/usecases/interfaces/output/SortByOutputModel';
+
+interface ISortBy {
+  toQueryString(sortBy: SortByOutputModel): string;
+  toObject(sortBy: string): { name: string; order: SortOrder };
+}
+
+export default ISortBy;

package/src/platform/zlist/usecases/interfaces/input/DeleteMultipleRecordUseCaseInput.ts

@@ -0,0 +1,6 @@
+type DeleteMultipleRecordUseCaseInput = {
+  dispatch: Function;
+  recordIds: string[];
+};
+
+export default DeleteMultipleRecordUseCaseInput;

package/src/platform/zlist/usecases/interfaces/input/FetchMoreInput.ts

@@ -0,0 +1,5 @@
+type FetchMoreInput = {
+  dispatch: Function;
+};
+
+export default FetchMoreInput;

package/src/platform/zlist/usecases/interfaces/input/FieldChangeUseCaseInput.ts

@@ -0,0 +1,8 @@
+
+type FieldChangeUseCaseInput = {
+  rowId: string;
+  fieldName: string;
+  value: any;
+  dispatch: Function;
+};
+export default FieldChangeUseCaseInput;

package/src/platform/zlist/usecases/interfaces/input/InitializeInput.ts

@@ -0,0 +1,4 @@
+type InitializeInput = {
+  dispatch: Function;
+};
+export default InitializeInput;

package/src/platform/zlist/usecases/interfaces/input/PropertiesChangeUseCaseInput.ts

@@ -0,0 +1,8 @@
+import { Properties } from '../../../entities/interfaces/Properties';
+
+type PropertiesChangeUseCaseInput = {
+  currentProperties: Properties;
+  previousProperties: Properties;
+  dispatch: Function;
+};
+export default PropertiesChangeUseCaseInput;

package/src/platform/zlist/usecases/interfaces/input/RecordUpdateUseCaseInput.ts

@@ -0,0 +1,6 @@
+type RecordUpdateUseCaseInput = {
+  recordId: string;
+  record: any;
+  dispatch: Function;
+};
+export default RecordUpdateUseCaseInput;

package/src/platform/zlist/usecases/interfaces/input/SortingInputModel.ts

@@ -0,0 +1,12 @@
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+
+type SortingInputModel = {
+  sortBy: {
+    id: string;
+    name: string;
+    order: SortOrder;
+  };
+  dispatch: Function;
+};
+
+export default SortingInputModel;

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

@@ -0,0 +1,11 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default abstract class AbstractController<EventModel> implements IController<EventModel> {
+  constructor(protected service: IService) {
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  }
+
+  abstract handle(event: EventModel): void;
+}

package/src/platform/zrecord/adapters/controllers/ActionExecutorController.ts

@@ -0,0 +1,20 @@
+import AbstractController from './AbstractController';
+
+export default class ActionExecutorController extends AbstractController<any> {
+  handle(event) {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+    const { actionName, props, apiName } = action.payload;
+    const { metaData } = action;
+    const { executeUseCase } = this.service;
+
+    executeUseCase.updateDependency(state, updateState);
+    executeUseCase.execute({
+      dispatch,
+      apiName,
+      actionName,
+      props,
+      metaData
+    });
+  }
+}

package/src/platform/zrecord/adapters/controllers/AppendRecordsController.ts

@@ -0,0 +1,16 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class AppendRecordsController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState, action } = event;
+    const { payload } = action;
+    const { records } = payload;
+    const { appendRecordsUseCase } = this.service;
+
+    appendRecordsUseCase.updateDependency(state, updateState);
+    appendRecordsUseCase.execute({ records });
+  };
+}