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

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActions/RowActionsRendererView.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import Flex from '@zohodesk/layout/es/Flex/Flex';
+import { ActionViewGap } from "../../../../interfaces/ActionViewModel";
+// @ts-ignore
+import style from "./RowActionsRenderer.module.css";
+import ActionEventMediator from "../../../../action-event-mediator/frameworks/ui/ActionEventMediator";
+import { findMappedClientScripts } from "../../../../../../client-scripts/behaviour/zclient-scripts-execution/frameworks/ClientScriptsUtils";
+
+function RowActionsRendererView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    actions,
+    gap,
+    clientScripts,
+    testId
+  } = state.properties;
+  return /*#__PURE__*/React.createElement(Flex, {
+    ref: ref,
+    testId: testId ? testId : "",
+    $ui_displayMode: "inline",
+    $ui_alignItems: "center",
+    $ui_className: `${gap !== ActionViewGap.NONE ? style[`gap_${gap}`] : ''}`
+  }, actions.map((action, index) => {
+    // @ts-ignore
+    return /*#__PURE__*/React.createElement(ActionEventMediator, {
+      action: action,
+      clientScripts: findMappedClientScripts(action, clientScripts),
+      key: index,
+      instanceName: action.instanceName
+    });
+  }));
+}
+
+;
+export default RowActionsRendererView;

package/es/platform/client-actions/translators/client-actions-translator/index.js

@@ -8,6 +8,8 @@ export default class ClientActionsTranslator {
       id: action.id,
       component: action.uiComponentMapping.component,
       properties: action.uiComponentMapping.propertiesValueMapping,
+      instanceName: action.instanceName,
+      moduleName: action.moduleName,
       eventMappings: action.uiComponentMapping.eventMappings.map(eventMapping => {
         return {
           sourceEvent: eventMapping.sourceEvent,
@@ -19,11 +21,21 @@ export default class ClientActionsTranslator {
     };
   }
 
-  static transform(actions, context) {
+  static appendComponentMetaToActions(actions, instanceName, moduleName) {
+    return actions.map(action => {
+      return { ...action,
+        instanceName,
+        moduleName
+      };
+    });
+  }
+
+  static transform(actions, instanceName, moduleName, context) {
     const replacementContext = {
       "@context": context
     };
-    const resolvedActions = ActionContextResolver.resolveActions(actions, replacementContext);
+    const actionsWithInstanceName = ClientActionsTranslator.appendComponentMetaToActions(actions, instanceName, moduleName);
+    const resolvedActions = ActionContextResolver.resolveActions(actionsWithInstanceName, replacementContext);
     const evaluatedActions = resolvedActions.filter(action => ConditionResolver.evaluateCondition(action.conditions, replacementContext, action.id));
     const finalTransformedActions = evaluatedActions.map(action => this.transformToActionViewModel(action));
     return finalTransformedActions;

package/es/platform/client-actions/translators/condition-resolver/index.js

@@ -3,6 +3,11 @@ import { evaluateConditionsFields } from "./field-evaluators";
 import { evaluateExpression, parse } from "./pattern-evaluator";
 export class ConditionResolver {
   static evaluateCondition(condition, context, id) {
+    if (!condition) {
+      console.warn(`Client Action : Invalid value '${condition}' passed as condition in client action id : ${id}`);
+      return false;
+    }
+
     const {
       fields = [],
       pattern = ''
@@ -16,7 +21,7 @@ export class ConditionResolver {
       } = patternValidate(pattern, fields.length);
 
       if (!isValid) {
-        console.error(`Error in client action id ${id} -  condition pattern`, errorMessage);
+        console.error(`Client Action : Error in client action id : ${id} -  condition pattern.\nError: `, errorMessage);
         return false;
       }
 

package/es/platform/client-scripts/bc/zclient-scripts-execution/Constants.js

@@ -0,0 +1,11 @@
+export const CLIENT_SCRIPT_TIMOUT_LIMIT = 10000;
+export const EXECUTE_CLIENT_SCRIPTS = 'EXECUTE_CLIENT_SCRIPTS';
+export const SET_CLIENT_SCRIPTS = 'SET_CLIENT_SCRIPTS';
+export const CLIENT_SCRIPT_ARGUMENT = 'context';
+export const CLIENT_SCRIPT_PREFIX = 'Client Script';
+export const CLIENT_SCRIPT_ERROR = 'Error';
+export const CLIENT_SCRIPT_RUNTIME_ERROR_MESSAGE = `${CLIENT_SCRIPT_PREFIX} : Script execution runtime error.\n${CLIENT_SCRIPT_ERROR}: `;
+export const CLIENT_SCRIPT_ERROR_MESSAGE = `${CLIENT_SCRIPT_PREFIX} : Script execution failed due to error in script.\n${CLIENT_SCRIPT_ERROR}:`;
+export const CLIENT_SCRIPT_EXECUTION_TIMED_OUT_ERROR_MESSAGE = `${CLIENT_SCRIPT_PREFIX} : Script execution exceeded ${CLIENT_SCRIPT_TIMOUT_LIMIT / 1000}s time limit.`;
+export const CLIENT_SCRIPT_INVALID_SCRIPT_ERROR_MESSAGE = `${CLIENT_SCRIPT_PREFIX} : Error while constructing client script function.\n${CLIENT_SCRIPT_ERROR}:`;
+export const CLIENT_SCRIPT_NO_MAPPING_FOUND_ERROR_MESSAGE = `${CLIENT_SCRIPT_PREFIX} : No client script mapping found for target event.Event handler support for defining client scripts will be removed in future versions.Please define client action event handlers as client script to avoid breakage.Warning shown for target event: `;

package/es/platform/client-scripts/bc/zclient-scripts-execution/EventHandlers.js

@@ -0,0 +1 @@
+;

package/es/platform/client-scripts/bc/zclient-scripts-fetch/Constants.js

@@ -0,0 +1,11 @@
+export const SET_CLIENTSCRIPTS = 'CLIENTSCRIPT#SET_CLIENTSCRIPTS';
+export const CLIENTSCRIPT_FETCH = 'CLIENTSCRIPT_BEHAVIOUR#EXECUTE';
+export const CLIENTSCRIPT_FETCH_SUCCESS = 'CLIENTSCRIPT#EXECUTE_SUCCEEDED';
+export const CLIENTSCRIPT_FETCH_FAILURE = 'CLIENTSCRIPT#EXECUTE_FAILED';
+export const CLIENTSCRIPT_FETCH_SUCCESS_NO_CONTENT = 'CLIENTSCRIPT#EXECUTE_SUCCEEDED_NO_CONTENT';
+export const CLIENTSCRIPT_FETCH_SUCCESS_CALLBACK = 'CLIENTSCRIPT#EXECUTE_SUCCESS_CALLBACK';
+export const CLIENTSCRIPT_FETCH_SUCCESS_NO_CONTENT_CALLBACK = 'CLIENTSCRIPT#EXECUTE_SUCCESS_NO_CONTENT_CALLBACK';
+export const CLIENTSCRIPT_FETCH_FAILURE_CALLBACK = 'CLIENTSCRIPT#EXECUTE_FAIL_CALLBACK';
+export const ClientScriptAPIs = {
+  GET_CLIENTSCRIPTS: "getClientScripts"
+};

package/es/platform/client-scripts/bc/zclient-scripts-fetch/EventHandlers.js

@@ -0,0 +1 @@
+;

package/es/platform/{app-context-behaviour → client-scripts/behaviour/zclient-scripts-execution}/adapters/controllers/AbstractController.js

@@ -1,5 +1,6 @@
-export class AbstractController {
+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-execution/adapters/controllers/ClientScriptExecutionController.js

@@ -0,0 +1,10 @@
+import AbstractController from "./AbstractController";
+export default class ClientScriptExecutionController extends AbstractController {
+  handle(input) {
+    const {
+      executeClientScriptsUseCase
+    } = this.service;
+    executeClientScriptsUseCase.execute(input);
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/adapters/controllers/SetClientScriptsMappingController.js

@@ -0,0 +1,10 @@
+import AbstractController from "./AbstractController";
+export default class SetClientScriptsMappingController extends AbstractController {
+  handle(input) {
+    const {
+      setClientScriptsMappingUseCase
+    } = this.service;
+    setClientScriptsMappingUseCase.execute(input);
+  }
+
+}

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

@@ -0,0 +1,24 @@
+import ClientScriptExecutor from "../../domain/entities/ClientScriptExecutor";
+export default class Repository {
+  init(state) {
+    this.state = state;
+    this.element = null;
+
+    this.dispatch = () => {};
+  }
+
+  updateDependencies(element, state, dispatch) {
+    this.element = element;
+    this.dispatch = dispatch;
+    this.state = state;
+  }
+
+  getClientScriptExecutor() {
+    const {
+      clientScriptsMapping,
+      context
+    } = this.state;
+    return new ClientScriptExecutor(clientScriptsMapping, context);
+  }
+
+}

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

@@ -0,0 +1,9 @@
+import ExecuteClientScriptsUseCase from "../../applications/usecases/ExecuteClientScriptsUseCase";
+import SetClientScriptsMappingUseCase from "../../applications/usecases/SetClientScriptsMappingUseCase";
+export default class Service {
+  constructor(dependencies) {
+    this.executeClientScriptsUseCase = new ExecuteClientScriptsUseCase(dependencies);
+    this.setClientScriptsMappingUseCase = new SetClientScriptsMappingUseCase(dependencies);
+  }
+
+}

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

@@ -0,0 +1,21 @@
+export default class Presenter {
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateClientScriptsMapping(clientScriptsMapping) {
+    this.state = { ...this.state,
+      clientScriptsMapping
+    };
+    this.updateState(this.state);
+  }
+
+  updateContext(context) {
+    this.state = { ...this.state,
+      context
+    };
+    this.updateState(this.state);
+  }
+
+}

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

@@ -0,0 +1,15 @@
+export class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+  updateDependencies(element, state, dispatch, updateState) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    repository.updateDependencies(element, state, dispatch);
+    presenter.updateDependencies(state, updateState);
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/applications/usecases/ExecuteClientScriptsUseCase.js

@@ -0,0 +1,23 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class ExecuteClientScriptsUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository
+    } = this.dependencies;
+    const {
+      host,
+      state,
+      dispatch
+    } = input;
+    const {
+      clientScripts
+    } = state.properties;
+    repository.updateDependencies(host, {
+      clientScriptsMapping: clientScripts,
+      context: input
+    }, dispatch);
+    const clientScriptExecutor = repository.getClientScriptExecutor();
+    clientScriptExecutor.executeTargetAction();
+  }
+
+}

package/es/platform/client-scripts/behaviour/zclient-scripts-execution/applications/usecases/SetClientScriptsMappingUseCase.js

@@ -0,0 +1,16 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class SetClientScriptsMappingUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter
+    } = this.dependencies;
+    const {
+      clientScripts,
+      state,
+      updateState
+    } = input;
+    presenter.updateDependencies(state, updateState);
+    presenter.updateClientScriptsMapping(clientScripts);
+  }
+
+}

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
+    });
+  };
+}