@veecode-platform/plugin-kong-service-manager/dist/context/KongServiceManagerProvider.esm.js

import React from 'react';
import { KongServiceManagerContext } from './KongServiceManagerContext.esm.js';
import { useEntity } from '@backstage/plugin-catalog-react';
import { useEntityAnnotation } from '../hooks/useEntityAnnotation.esm.js';
import { removePluginAssociated, addPluginsAssociated } from './state/allAssociatedPluginsState/actions.esm.js';
import { AssociatedPluginsReducer, initialAssociatedPluginsState } from './state/allAssociatedPluginsState/reducer.esm.js';
import { addPluginsPerCategory } from './state/pluginsPerCategoryState/actions.esm.js';
import { PluginsPerCategoryReducer, initialPluginsPerCategoryState } from './state/pluginsPerCategoryState/reducer.esm.js';
import { addSelectedPlugin } from './state/selectedPluginState/actions.esm.js';
import { SelectedPluginReducer, initialSelectedPluginState } from './state/selectedPluginState/reducer.esm.js';
import { PluginsToSpecReducer, initialPluginsToSpecState } from './state/pluginsToSpecState/reducer.esm.js';
import { SelectedSpecReducer, initialSelectedSpecState } from './state/selectedSpecState/reducer.esm.js';
import { removeRoutePluginAssociated, addRoutePluginsAssociated } from './state/allAssociatedRoutePluginsState/actions.esm.js';
import { AssociatedRoutePluginsReducer, initialAssociatedRoutePluginsState } from './state/allAssociatedRoutePluginsState/reducer.esm.js';
import { kongServiceManagerApiRef } from '../api/KongServiceManagerApi.esm.js';
import '@backstage/integration';
import '@octokit/rest';
import 'js-base64';
import 'js-yaml';
import { useApi, errorApiRef, alertApiRef } from '@backstage/core-plugin-api';
import { ANNOTATION_LOCATION } from '@backstage/catalog-model';
import { removePropsNull } from '../utils/helpers/removePropsNull.esm.js';
import { formatObject } from '../utils/helpers/formactObject.esm.js';
import { transformPath } from '../utils/helpers/transformPath.esm.js';

const KongServiceManagerProvider = ({ children }) => {
  const [allAssociatedPluginsState, associatedPluginsDispatch] = React.useReducer(AssociatedPluginsReducer, initialAssociatedPluginsState);
  const [allAssociatedRoutePluginsState, associatedRoutePluginsDispatch] = React.useReducer(
    AssociatedRoutePluginsReducer,
    initialAssociatedRoutePluginsState
  );
  const [openDrawer, setOpenDrawer] = React.useState(false);
  const [selectedPluginState, selectedPluginDispatch] = React.useReducer(
    SelectedPluginReducer,
    initialSelectedPluginState
  );
  const [associatedPluginsName, setAssociatedPluginsName] = React.useState([]);
  const [associatedRoutePluginsName, setAssociatedRoutePluginsName] = React.useState([]);
  const [pluginsPerCategoryState, pluginsPerCategoryDispatch] = React.useReducer(PluginsPerCategoryReducer, initialPluginsPerCategoryState);
  const [configState, setConfigState] = React.useState(null);
  const [searchTerm, setSeachTerm] = React.useState("");
  const [routeId, setRouteId] = React.useState(null);
  const [isRoute, setIsRoute] = React.useState(false);
  const { entity } = useEntity();
  const { serviceName, kongInstances, kongSpecs } = useEntityAnnotation(entity);
  const [instance, setInstance] = React.useState(
    kongInstances ? kongInstances[0] : ""
  );
  const [selectedSpecState, selectedSpecDispatch] = React.useReducer(
    SelectedSpecReducer,
    initialSelectedSpecState
  );
  const [pluginsToSpecState, pluginsToSpecDispatch] = React.useReducer(
    PluginsToSpecReducer,
    initialPluginsToSpecState
  );
  const api = useApi(kongServiceManagerApiRef);
  const errorApi = useApi(errorApiRef);
  const alertApi = useApi(alertApiRef);
  const setInstanceState = (instanceState) => {
    setInstance(instanceState);
  };
  const setSearchState = (search) => {
    setSeachTerm(search);
  };
  const handleToggleDrawer = () => {
    if (!openDrawer) setConfigState(null);
    setOpenDrawer(!openDrawer);
  };
  const setPluginState = (data) => selectedPluginDispatch(addSelectedPlugin(data));
  const getAssociatedPuginsName = (pluginsParams) => {
    const newData = [];
    pluginsParams.map((p) => {
      newData.push(p.name);
    });
    setAssociatedPluginsName(newData);
  };
  const getAssociatedRoutePuginsName = (pluginsParams) => {
    const newData = [];
    pluginsParams.map((p) => {
      newData.push(p.name);
    });
    setAssociatedRoutePluginsName(newData);
  };
  const getServiceDetails = async () => {
    try {
      if (instance && serviceName) {
        const details = await api.getServiceInfo(instance, serviceName);
        setIsRoute(false);
        if (details) return details;
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const listAllEnabledPlugins = async () => {
    try {
      if (instance && serviceName) {
        const plugins = await api.getEnabledPlugins(
          instance,
          serviceName,
          searchTerm
        );
        if (plugins) {
          pluginsPerCategoryDispatch(addPluginsPerCategory(plugins));
          return plugins;
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const listAssociatedPlugins = async () => {
    try {
      if (instance && serviceName) {
        const plugins = await api.getServiceAssociatedPlugins(
          instance,
          serviceName
        );
        if (plugins !== null && plugins !== void 0) {
          associatedPluginsDispatch(addPluginsAssociated(plugins));
          return plugins;
        }
      }
      return [];
    } catch (e) {
      errorApi.post(e);
      return [];
    }
  };
  const enablePlugin = async (config) => {
    try {
      if (instance && serviceName) {
        const response = await api.createServicePlugin(
          instance,
          serviceName,
          config
        );
        if (response) {
          await listAssociatedPlugins();
          return alertApi.post({
            message: "Plugin successfully enabled!",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const editPlugin = async (pluginId, config) => {
    try {
      if (instance && serviceName) {
        const response = await api.editServicePlugin(
          instance,
          serviceName,
          pluginId,
          config
        );
        if (response) {
          await listAssociatedPlugins();
          return alertApi.post({
            message: "Plugin successfully edited!",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const disablePlugin = async (pluginId) => {
    try {
      if (instance && serviceName) {
        const response = await api.removeServicePlugin(
          instance,
          serviceName,
          pluginId
        );
        if (response && allAssociatedPluginsState) {
          associatedPluginsDispatch(removePluginAssociated(pluginId));
          await listAllEnabledPlugins();
          return alertApi.post({
            message: "Plugin successfully disabled",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const getPluginFields = async (pluginName) => {
    try {
      if (instance) {
        const fields = await api.getPluginFields(instance, pluginName);
        if (fields) {
          return fields;
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const getRoutesList = async () => {
    try {
      if (instance && serviceName) {
        const routes = await api.getRoutesFromService(instance, serviceName);
        if (routes) return routes;
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const getRoute = async (routeNameOrId) => {
    try {
      if (instance && serviceName && routeNameOrId) {
        const route = await api.getRouteFromService(
          instance,
          serviceName,
          routeNameOrId
        );
        setIsRoute(true);
        setRouteId(routeNameOrId);
        if (route) return route;
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const createRoute = async (config) => {
    try {
      if (instance && serviceName) {
        const response = await api.createRouteFromService(
          instance,
          serviceName,
          config
        );
        if (response) {
          return response;
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const editRoute = async (config) => {
    try {
      if (instance && serviceName && routeId) {
        const response = await api.editRouteFromService(
          instance,
          serviceName,
          routeId,
          config
        );
        if (response) {
          await getRoutesList();
          return alertApi.post({
            message: "Route successfully update!",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const removeRoute = async () => {
    try {
      if (instance && serviceName && routeId) {
        const response = await api.removeRouteFromService(
          instance,
          serviceName,
          routeId
        );
        if (response) {
          await getRoutesList();
          return alertApi.post({
            message: "Route successfully delete!",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const listAllEnabledRoutePlugins = async () => {
    try {
      if (instance && serviceName && routeId) {
        const plugins = await api.getEnabledRoutePlugins(
          instance,
          routeId,
          searchTerm
        );
        if (plugins) {
          pluginsPerCategoryDispatch(addPluginsPerCategory(plugins));
          return plugins;
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const listAssociatedRoutePlugins = async () => {
    try {
      if (instance && routeId) {
        const plugins = await api.getRouteAssociatedPlugins(instance, routeId);
        if (plugins !== null && plugins !== void 0) {
          associatedRoutePluginsDispatch(addRoutePluginsAssociated(plugins));
          return plugins;
        }
      }
      return [];
    } catch (e) {
      errorApi.post(e);
      return [];
    }
  };
  const enablePluginToRoute = async (config) => {
    try {
      if (instance && routeId) {
        const response = await api.addRoutePlugin(instance, routeId, config);
        if (response) {
          await listAssociatedRoutePlugins();
          alertApi.post({
            message: "Plugin successfully enabled!",
            severity: "success",
            display: "transient"
          });
          return response;
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const editPluginFromRoute = async (pluginId, config) => {
    try {
      if (instance && routeId && pluginId) {
        const response = await api.editRoutePlugin(
          instance,
          routeId,
          pluginId,
          config
        );
        if (response) {
          await listAssociatedRoutePlugins();
          return alertApi.post({
            message: "Plugin successfully edited!",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const disabledPluginFromRoute = async (pluginId) => {
    try {
      if (instance && routeId && pluginId) {
        const response = await api.removeRoutePlugin(
          instance,
          routeId,
          pluginId
        );
        if (response && allAssociatedPluginsState) {
          associatedRoutePluginsDispatch(removeRoutePluginAssociated(pluginId));
          return alertApi.post({
            message: "Plugin successfully disabled",
            severity: "success",
            display: "transient"
          });
        }
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const getSpecs = async () => {
    try {
      if (kongSpecs && entity) {
        const response = await api.getAllSpecs(
          entity.metadata?.annotations?.[ANNOTATION_LOCATION],
          kongSpecs
        );
        if (response) return response;
      }
      return null;
    } catch (e) {
      errorApi.post(e);
      return null;
    }
  };
  const getConfigFromService = async (pluginName) => {
    const asociatedPlugins = await listAssociatedPlugins();
    if (asociatedPlugins) {
      const data = asociatedPlugins.find(
        (associatedPlugin) => associatedPlugin.name === pluginName && associatedPlugin.config
      );
      if (data) {
        const filteredConfig = removePropsNull(data.config);
        return { ...filteredConfig };
      }
    }
    return {};
  };
  const listAllServicePluginsForSpec = async () => {
    if (!selectedSpecState) return [];
    const pluginsInSpec = Object.keys(selectedSpecState).filter((key) => key.startsWith("x-kong")).map((key) => selectedSpecState[key]);
    if (allAssociatedPluginsState && pluginsInSpec) {
      const enableServicePlugins = await listAllEnabledPlugins();
      if (enableServicePlugins) {
        const pluginsList = await Promise.all(
          enableServicePlugins.flatMap(
            (category) => category.plugins.filter((plugin) => plugin.associated).map(async (plugin) => ({
              // image: plugin.image,
              name: plugin.name,
              slug: plugin.slug,
              description: plugin.description,
              config: await getConfigFromService(plugin.slug),
              enabledToSpec: !!pluginsInSpec.find(
                (p) => p.name === plugin.slug
              )
            }))
          )
        );
        return pluginsList;
      }
    }
    return [];
  };
  const applyKongServicePluginsToSpec = async (specName, title, message, location, plugins) => {
    try {
      if (selectedSpecState) {
        for (const key in selectedSpecState) {
          if (key.startsWith("x-kong")) {
            delete selectedSpecState[key];
          }
        }
        const pluginsWithPrefix = {};
        plugins.map((plugin) => {
          const pluginKey = `x-kong-${plugin.name.replace(" ", "-").toLowerCase()}`;
          const newData = {
            name: plugin.name,
            enabled: plugin.enabled,
            config: plugin.config
          };
          pluginsWithPrefix[`${pluginKey}`] = newData;
        });
        const definitionUpdated = {
          openapi: selectedSpecState.openapi,
          info: selectedSpecState.info,
          externalDocs: selectedSpecState.externalDocs,
          servers: selectedSpecState.servers,
          tags: selectedSpecState.tags,
          ...pluginsWithPrefix,
          paths: selectedSpecState.paths,
          components: selectedSpecState.components
        };
        const fileContent = formatObject(definitionUpdated);
        const response = await api.applyPluginsToSpec(
          specName,
          location,
          fileContent,
          title,
          message
        );
        return response;
      }
      return {
        status: 400,
        message: "Pull Request aborted"
      };
    } catch (e) {
      errorApi.post(e);
      return {
        status: 400,
        message: "Pull Request aborted"
      };
    }
  };
  const getConfigFromRoute = async (pluginName) => {
    const associatedPlugins = await listAssociatedRoutePlugins();
    if (associatedPlugins) {
      const data = associatedPlugins.find(
        (associatedPlugin) => associatedPlugin.name === pluginName && associatedPlugin.config
      );
      if (data) {
        const filteredConfig = removePropsNull(data.config);
        return { ...filteredConfig };
      }
    }
    return {};
  };
  const listAllRoutePluginsForSpec = async (path, method) => {
    if (!selectedSpecState) return [];
    const formattedPath = transformPath(path);
    const specPath = selectedSpecState.paths;
    const pathResult = specPath[formattedPath][method];
    const pluginsInPath = Object.keys(pathResult).filter((key) => key.startsWith("x-kong")).map((key) => pathResult[key]);
    if (allAssociatedRoutePluginsState && pluginsInPath) {
      const enableRoutePlugins = await listAllEnabledRoutePlugins();
      if (enableRoutePlugins) {
        const pluginsList = await Promise.all(
          enableRoutePlugins.flatMap(
            (category) => category.plugins.filter((plugin) => plugin.associated).map(async (plugin) => ({
              // image: plugin.image,
              name: plugin.name,
              slug: plugin.slug,
              description: plugin.description,
              config: await getConfigFromRoute(plugin.slug),
              enabledToSpec: !!pluginsInPath.find(
                (p) => p.name === plugin.slug
              )
            }))
          )
        );
        return pluginsList;
      }
    }
    return [];
  };
  const applyKongRoutePluginsToSpec = async (specName, title, message, location, path, method, plugins) => {
    try {
      if (selectedSpecState) {
        const formattedPath = transformPath(path);
        const specPaths = selectedSpecState.paths;
        const pathSelected = specPaths[formattedPath][method];
        for (const key in pathSelected) {
          if (key.startsWith("x-kong")) {
            delete pathSelected[key];
          }
        }
        const pluginsWithPrefix = {};
        plugins.map((plugin) => {
          const pluginKey = `x-kong-${plugin.name.replace(" ", "-").toLowerCase()}`;
          const newData = {
            name: plugin.name,
            enabled: plugin.enabled,
            config: plugin.config
          };
          pluginsWithPrefix[`${pluginKey}`] = newData;
        });
        const updatedMethod = { ...pathSelected, ...pluginsWithPrefix };
        const definitionUpdated = {
          ...selectedSpecState,
          paths: {
            ...specPaths,
            [formattedPath]: {
              ...specPaths[formattedPath],
              [method]: updatedMethod
            }
          }
        };
        const fileContent = formatObject(definitionUpdated);
        const response = await api.applyPluginsToSpec(
          specName,
          location,
          fileContent,
          title,
          message
        );
        return response;
      }
      return {
        status: 400,
        message: "Pull Request aborted"
      };
    } catch (e) {
      errorApi.post(e);
      return {
        status: 400,
        message: "Pull Request aborted"
      };
    }
  };
  React.useEffect(() => {
    if (allAssociatedPluginsState) {
      getAssociatedPuginsName(allAssociatedPluginsState);
    }
  }, [allAssociatedPluginsState]);
  React.useEffect(() => {
    if (allAssociatedRoutePluginsState) {
      getAssociatedRoutePuginsName(allAssociatedRoutePluginsState);
    }
  }, [allAssociatedRoutePluginsState]);
  React.useEffect(() => {
    if (isRoute && routeId) {
      listAllEnabledRoutePlugins();
    }
    if (!isRoute && serviceName) {
      listAllEnabledPlugins();
    }
  }, [searchTerm]);
  React.useEffect(() => {
    if (instance) {
      getServiceDetails();
      getRoutesList();
    }
  }, [instance]);
  return /* @__PURE__ */ React.createElement(
    KongServiceManagerContext.Provider,
    {
      value: {
        entity,
        serviceName,
        instance,
        kongSpecs,
        routeId,
        setRouteId,
        isRoute,
        setIsRoute,
        setInstanceState,
        allAssociatedPluginsState,
        associatedPluginsDispatch,
        allAssociatedRoutePluginsState,
        associatedRoutePluginsDispatch,
        associatedPluginsName,
        associatedRoutePluginsName,
        handleToggleDrawer,
        openDrawer,
        setPluginState,
        selectedPluginState,
        pluginsPerCategoryState,
        pluginsPerCategoryDispatch,
        configState,
        setConfigState,
        setSearchState,
        searchTerm,
        selectedSpecState,
        selectedSpecDispatch,
        pluginsToSpecState,
        pluginsToSpecDispatch,
        getServiceDetails,
        listAllEnabledPlugins,
        listAssociatedPlugins,
        enablePlugin,
        editPlugin,
        disablePlugin,
        getPluginFields,
        getRoutesList,
        getRoute,
        createRoute,
        editRoute,
        removeRoute,
        listAllEnabledRoutePlugins,
        listAssociatedRoutePlugins,
        enablePluginToRoute,
        editPluginFromRoute,
        disabledPluginFromRoute,
        getSpecs,
        listAllServicePluginsForSpec,
        applyKongServicePluginsToSpec,
        listAllRoutePluginsForSpec,
        applyKongRoutePluginsToSpec
      }
    },
    children
  );
};
const useKongServiceManagerContext = () => React.useContext(KongServiceManagerContext);

export { KongServiceManagerProvider, useKongServiceManagerContext };
//# sourceMappingURL=KongServiceManagerProvider.esm.js.map