@zohodesk/library-platform 1.1.10-exp.1 → 1.1.10-exp.2

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/domain/entities/ClientScriptExecutor.js

@@ -0,0 +1,142 @@
+import { CLIENT_SCRIPT_ARGUMENT, CLIENT_SCRIPT_ERROR_MESSAGE, CLIENT_SCRIPT_EXECUTION_TIMED_OUT_ERROR_MESSAGE, CLIENT_SCRIPT_INVALID_SCRIPT_ERROR_MESSAGE, CLIENT_SCRIPT_NO_MAPPING_FOUND_ERROR_MESSAGE, CLIENT_SCRIPT_RUNTIME_ERROR_MESSAGE, CLIENT_SCRIPT_TIMOUT_LIMIT } from "../../../../bc/zclient-scripts-execution/Constants";
+import { platformSDK } from "../../../../../sdk/frameworks/Sdk";
+import { ClientScriptExecutionStatus } from "./types/ClientScriptExectionTypeDefintions";
+export default class ClientScriptExecutor {
+  constructor(clientScriptsMapping, context) {
+    this.clientScriptsMapping = clientScriptsMapping;
+    this.context = context;
+  }
+
+  findClientScriptMapping(targetEvent) {
+    return this.clientScriptsMapping.find(clientScript => clientScript.targetEvent === targetEvent);
+  }
+
+  findClientActionPayload(targetEvent) {
+    const {
+      clientScriptsEventContext
+    } = this.context.action.payload;
+    const targetActionEventContext = clientScriptsEventContext.find(eventContext => eventContext.targetEvent === targetEvent);
+    return targetActionEventContext ? targetActionEventContext.resolvedPayload : {};
+  }
+
+  getClientScriptArguments(targetEvent) {
+    const payload = this.findClientActionPayload(targetEvent);
+    const action = {
+      metaData: { ...this.context.action.metaData,
+        targetEvent
+      },
+      payload
+    };
+    return { ...this.context,
+      platformSDK: platformSDK,
+      action
+    };
+  }
+
+  handleClientScriptExecutionResult(result) {
+    const {
+      status
+    } = result;
+
+    switch (status) {
+      case ClientScriptExecutionStatus.FAILURE:
+        const {
+          error: {
+            message
+          }
+        } = result;
+        console.error(CLIENT_SCRIPT_ERROR_MESSAGE, message);
+        break;
+
+      case ClientScriptExecutionStatus.TIMEDOUT:
+        console.error(CLIENT_SCRIPT_EXECUTION_TIMED_OUT_ERROR_MESSAGE);
+        break;
+    }
+  }
+
+  getClientScriptExecutionPromise(clientScript, clientScriptArguments) {
+    return new Promise((resolve, reject) => {
+      try {
+        clientScript(clientScriptArguments);
+        resolve({
+          status: ClientScriptExecutionStatus.SUCCESS
+        });
+      } catch (e) {
+        resolve({
+          status: ClientScriptExecutionStatus.FAILURE,
+          error: e
+        });
+      }
+    });
+  }
+
+  getClientScriptTimeoutPromise(timeout) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        resolve({
+          status: ClientScriptExecutionStatus.TIMEDOUT
+        });
+      }, timeout);
+    });
+  }
+
+  async executeClientScript(clientScript, clientScriptArguments, timeout) {
+    const clientScriptExecutionPromise = this.getClientScriptExecutionPromise(clientScript, clientScriptArguments);
+    const clientScriptTimeoutPromise = this.getClientScriptTimeoutPromise(timeout);
+    return Promise.race([clientScriptTimeoutPromise, clientScriptExecutionPromise]);
+  }
+
+  constructClientScriptFunction(clientScriptFnBody) {
+    try {
+      const clientScriptFn = new Function(CLIENT_SCRIPT_ARGUMENT, `${clientScriptFnBody}`);
+      return clientScriptFn;
+    } catch (e) {
+      console.error(CLIENT_SCRIPT_INVALID_SCRIPT_ERROR_MESSAGE, e.message);
+    }
+  }
+
+  handleClientScriptExecution(targetEvent, clientScript) {
+    if (!clientScript) return;
+    const dynamicFunction = this.constructClientScriptFunction(clientScript);
+    const clientScriptArguments = this.getClientScriptArguments(targetEvent);
+    this.executeClientScript(dynamicFunction, clientScriptArguments, CLIENT_SCRIPT_TIMOUT_LIMIT).then(result => {
+      this.handleClientScriptExecutionResult(result);
+    }).catch(error => {
+      console.error(CLIENT_SCRIPT_RUNTIME_ERROR_MESSAGE, error);
+    });
+  }
+
+  executeTargetAction() {
+    const {
+      clientScriptsEventContext
+    } = this.context.action.payload;
+    clientScriptsEventContext.forEach(clientScriptEventContext => {
+      const {
+        targetEvent
+      } = clientScriptEventContext;
+      const clientScriptMapping = this.findClientScriptMapping(targetEvent);
+
+      if (clientScriptMapping) {
+        const {
+          clientScript
+        } = clientScriptMapping;
+        this.handleClientScriptExecution(targetEvent, clientScript);
+      } else {
+        console.warn(CLIENT_SCRIPT_NO_MAPPING_FOUND_ERROR_MESSAGE, `'${targetEvent}'`);
+        const {
+          dispatch
+        } = this.context;
+        const {
+          payload,
+          metaData
+        } = this.getClientScriptArguments(targetEvent)?.action;
+        dispatch({
+          type: targetEvent,
+          payload,
+          metaData
+        });
+      }
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/domain/entities/types/ClientScriptExectionTypeDefintions.js

@@ -0,0 +1,7 @@
+export let ClientScriptExecutionStatus = /*#__PURE__*/function (ClientScriptExecutionStatus) {
+  ClientScriptExecutionStatus["SUCCESS"] = "CLIENTSCRIPT#EXECUTION_SUCCESS";
+  ClientScriptExecutionStatus["FAILURE"] = "CLIENTSCRIPT#EXECUTION_FAILURE";
+  ClientScriptExecutionStatus["TIMEDOUT"] = "CLIENTSCRIPT#EXECUTION_TIMEDOUT";
+  return ClientScriptExecutionStatus;
+}({});
+;

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/frameworks/ClientScriptsExecutionBehaviourFactory.js

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

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/frameworks/ClientScriptsExecutionHandlersFactory.js

@@ -0,0 +1,30 @@
+import { EXECUTE_CLIENT_SCRIPTS, SET_CLIENT_SCRIPTS } from "../../../bc/zclient-scripts-execution/Constants";
+import Service from "../adapters/gateways/Service";
+import Presenter from "../adapters/presenters/Presenter";
+import Repository from "../adapters/gateways/Repository";
+import ClientScriptExecutionController from "../adapters/controllers/ClientScriptExecutionController";
+import SetClientScriptsMappingController from "../adapters/controllers/SetClientScriptsMappingController";
+export default class ClientScriptsExecutionHandlersFactory {
+  static getClientScriptsControllerHandles(service) {
+    return {
+      executeClientScript: new ClientScriptExecutionController(service).handle,
+      setClientScriptsMapping: new SetClientScriptsMappingController(service).handle
+    };
+  }
+
+  static create() {
+    const presenter = new Presenter();
+    const repository = new Repository();
+    const dependencies = {
+      presenter,
+      repository
+    };
+    const service = new Service(dependencies);
+    const clientScriptControllerHandle = ClientScriptsExecutionHandlersFactory.getClientScriptsControllerHandles(service);
+    return {
+      [EXECUTE_CLIENT_SCRIPTS]: clientScriptControllerHandle.executeClientScript,
+      [SET_CLIENT_SCRIPTS]: clientScriptControllerHandle.setClientScriptsMapping
+    };
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/frameworks/ClientScriptsUtils.js

@@ -0,0 +1,25 @@
+export function findMappedClientScripts(action, clientScripts) {
+  if (!clientScripts || clientScripts.length === 0) return [];
+  const {
+    eventMappings
+  } = action;
+  const targetEvents = eventMappings.map(event => {
+    const {
+      targetEvent
+    } = event;
+    return targetEvent;
+  });
+  return clientScripts.filter(clientScript => clientScript.targetEvent && targetEvents.includes(clientScript.targetEvent));
+}
+export function getClientScriptMockInterceptorProperties() {
+  return {
+    name: 'uiActions',
+    api: `/supportapi/zd/{{orgName}}/api/v1/clientScripts`,
+    parameters: `{
+    "modules": "{{moduleName}}"
+    }`,
+    type: 'GET',
+    transformer: data => data,
+    properties: {}
+  };
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/AbstractController.js

@@ -0,0 +1,8 @@
+export default class AbstractController {
+  constructor(service) {
+    this.service = service;
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/FetchClientScriptsController.js

@@ -0,0 +1,27 @@
+import AbstractController from "./AbstractController";
+export default class FetchClientScriptsController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      actionName,
+      props,
+      apiName
+    } = action.payload;
+    const {
+      fetchClientScriptsUseCase
+    } = this.service;
+    fetchClientScriptsUseCase.updateDependency(state, updateState);
+    fetchClientScriptsUseCase.execute({
+      dispatch,
+      apiName,
+      actionName,
+      props
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/FetchClientScriptsFailureController.js

@@ -0,0 +1,28 @@
+import AbstractController from "./AbstractController";
+export default class FetchClientScriptsFailureController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      metaData,
+      payload
+    } = action;
+    const {
+      error
+    } = payload;
+    const {
+      fetchClientScriptsFailureUseCase
+    } = this.service;
+    fetchClientScriptsFailureUseCase.updateDependency(state, updateState);
+    fetchClientScriptsFailureUseCase.execute({
+      dispatch,
+      error,
+      metaData
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/FetchClientScriptsNoContentController.js

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+export default class FetchClientScriptsNoContentController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      metaData
+    } = action;
+    const {
+      fetchClientScriptsNoContentUseCase
+    } = this.service;
+    fetchClientScriptsNoContentUseCase.updateDependency(state, updateState);
+    fetchClientScriptsNoContentUseCase.execute({
+      dispatch,
+      metaData
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/FetchClientScriptsStopController.js

@@ -0,0 +1,21 @@
+import AbstractController from "./AbstractController";
+export default class FetchClientScriptsStopController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action
+    } = event;
+    const {
+      metaData
+    } = action;
+    const {
+      fetchClientScriptsStopUseCase
+    } = this.service;
+    fetchClientScriptsStopUseCase.updateDependency(state, updateState);
+    fetchClientScriptsStopUseCase.execute({
+      metaData
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/FetchClientScriptsSuccessController.js

@@ -0,0 +1,28 @@
+import AbstractController from "./AbstractController";
+export default class FetchClientScriptsSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      metaData,
+      payload
+    } = action;
+    const {
+      response
+    } = payload;
+    const {
+      fetchClientScriptsSuccessUseCase
+    } = this.service;
+    fetchClientScriptsSuccessUseCase.updateDependency(state, updateState);
+    fetchClientScriptsSuccessUseCase.execute({
+      dispatch,
+      response,
+      metaData
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/MountController.js

@@ -0,0 +1,22 @@
+export default class MountController {
+  constructor(recordApis, service) {
+    this.recordApis = recordApis;
+    this.service = service;
+  }
+
+  handle = event => {
+    const {
+      state,
+      updateState,
+      dispatch
+    } = event;
+    const {
+      initializeUseCase
+    } = this.service;
+    initializeUseCase.updateDependency(state, updateState);
+    initializeUseCase.execute({
+      dispatch,
+      apiTemplates: this.recordApis
+    });
+  };
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/controllers/SetClientScriptsController.js

@@ -0,0 +1,24 @@
+import AbstractController from "./AbstractController";
+export default class SetClientScriptsController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action
+    } = event;
+    const {
+      payload
+    } = action;
+    const {
+      clientScripts
+    } = payload;
+    const {
+      setClientScriptsUseCase
+    } = this.service;
+    setClientScriptsUseCase.updateDependency(state, updateState);
+    setClientScriptsUseCase.execute({
+      clientScripts
+    });
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/gateways/Repository.js

@@ -0,0 +1,22 @@
+import ClientScriptManagerFactory from "../../applications/entities-factory/ClientScriptsManagerFactory";
+export default class Repository {
+  init(state) {
+    this.state = state;
+  }
+
+  getClientScriptsManagerEntity() {
+    const {
+      zclientScriptsEventMapping
+    } = this.state.behaviours;
+    const {
+      clientScripts = [],
+      isFetching
+    } = zclientScriptsEventMapping;
+    const clientScriptManager = ClientScriptManagerFactory.create({
+      data: clientScripts,
+      isFetching
+    });
+    return clientScriptManager;
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/gateways/Service.js

@@ -0,0 +1,19 @@
+import InitializeUseCase from "../../applications/usecases/InitializeUseCase";
+import FetchClientScriptUseCase from "../../applications/usecases/FetchClientScriptUseCase";
+import FetchClientScriptsSuccessUseCase from "../../applications/usecases/FetchClientScriptsSuccessUseCase";
+import FetchClientScriptsStopUseCase from "../../applications/usecases/FetchClientScriptsStopUseCase";
+import FetchClientScriptsFailureUseCase from "../../applications/usecases/FetchClientScriptsFailureUseCase";
+import FetchClientScriptsNoContentUseCase from "../../applications/usecases/FetchClientScriptsNoContentUseCase";
+import SetClientScriptsUseCase from "../../applications/usecases/SetClientScriptsUseCase";
+export default class Service {
+  constructor(dependencies) {
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.fetchClientScriptsUseCase = new FetchClientScriptUseCase(dependencies);
+    this.fetchClientScriptsSuccessUseCase = new FetchClientScriptsSuccessUseCase(dependencies);
+    this.fetchClientScriptsStopUseCase = new FetchClientScriptsStopUseCase(dependencies);
+    this.fetchClientScriptsFailureUseCase = new FetchClientScriptsFailureUseCase(dependencies);
+    this.fetchClientScriptsNoContentUseCase = new FetchClientScriptsNoContentUseCase(dependencies);
+    this.setClientScriptsUseCase = new SetClientScriptsUseCase(dependencies);
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/presenters/Presenter.js

@@ -0,0 +1,16 @@
+export default class Presenter {
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateClientScript(zclientScriptsEventMapping) {
+    this.state = { ...this.state,
+      behaviours: { ...this.state.behaviours,
+        zclientScriptsEventMapping
+      }
+    };
+    this.updateState(this.state);
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/entities-factory/ClientScriptsFactory.js

@@ -0,0 +1,11 @@
+import ClientScript from "../../domain/entities/ClientScript";
+export default class ClientScriptsFactory {
+  static deSerializeClientScript(clientScriptModel) {
+    return new ClientScript(clientScriptModel);
+  }
+
+  static deSerializeClientScripts(clientScriptModels) {
+    return clientScriptModels.map(clientScriptModel => this.deSerializeClientScript(clientScriptModel));
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/entities-factory/ClientScriptsManagerFactory.js

@@ -0,0 +1,10 @@
+import ClientScripts from "../../domain/entities/ClientScripts";
+import ClientActionManager from "../../../../../client-actions/behaviour/zclient-actions/domain/entities/ClientActionManager";
+export default class ClientScriptsManagerFactory {
+  static create(clientScriptsModel) {
+    const clientScripts = new ClientScripts(clientScriptsModel);
+    const clientScriptManager = new ClientActionManager(clientScripts);
+    return clientScriptManager;
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/AbstractUseCase.js

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

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/FetchClientScriptUseCase.js

@@ -0,0 +1,33 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchClientScriptUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const {
+      props,
+      dispatch,
+      apiName,
+      actionName
+    } = input;
+    const recordManager = repository.getClientScriptsManagerEntity();
+
+    if (!recordManager.isClientScriptApiName(apiName)) {
+      return;
+    }
+
+    const metaData = recordManager.createFetchClientScriptMeta(actionName, apiName, props);
+
+    if (recordManager.isGetClientScriptsApi(actionName)) {
+      recordManager.fetchingStarted();
+      presenter.updateClientScript(recordManager.toObject());
+    }
+
+    dispatch(recordManager.createDataSourceExecuteEvent(props, actionName, metaData));
+  }
+
+}
+
+export default FetchClientScriptUseCase;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/FetchClientScriptsFailureUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchClientScriptsFailureUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository
+    } = this.dependencies;
+    const {
+      dispatch,
+      metaData,
+      error
+    } = input;
+    const recordManager = repository.getClientScriptsManagerEntity();
+    const events = recordManager.createFailureEvents(error, metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default FetchClientScriptsFailureUseCase;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/FetchClientScriptsNoContentUseCase.js

@@ -0,0 +1,27 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class NoContentUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter,
+      repository
+    } = this.dependencies;
+    const {
+      dispatch,
+      metaData
+    } = input;
+    const recordManager = repository.getClientScriptsManagerEntity();
+
+    if (recordManager.isGetClientScriptsApi(metaData.actionName)) {
+      presenter.updateClientScript(recordManager.toObject());
+    }
+
+    const events = recordManager.createNoContentEvents(metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default NoContentUseCase;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/FetchClientScriptsStopUseCase.js

@@ -0,0 +1,25 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchStateStopUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const {
+      metaData
+    } = input;
+    const {
+      actionName
+    } = metaData;
+    const recordManager = repository.getClientScriptsManagerEntity();
+
+    if (recordManager.isGetClientScriptsApi(actionName)) {
+      recordManager.fetchingFinished();
+      presenter.updateClientScript(recordManager.toObject());
+    }
+  }
+
+}
+
+export default FetchStateStopUseCase;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/FetchClientScriptsSuccessUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchClientScriptsSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository
+    } = this.dependencies;
+    const {
+      response,
+      metaData,
+      dispatch
+    } = input;
+    const recordManager = repository.getClientScriptsManagerEntity();
+    const events = recordManager.createSuccessEvents(response, metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default FetchClientScriptsSuccessUseCase;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/usecases/InitializeUseCase.js

@@ -0,0 +1,17 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { DATA_SOURCE_REGISTER } from "../../../../../../bc/zdata-source/Constants";
+export default class InitializeUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      apiTemplates,
+      dispatch
+    } = input;
+    dispatch({
+      type: DATA_SOURCE_REGISTER,
+      payload: {
+        apiTemplates
+      }
+    });
+  }
+
+}