gen-jhipster/dist/lib/jhipster/deployment-options.js

VHipster - Spring Boot + Angular/React/Vue in one handy generator

import kubernetesPlatformTypes from "./kubernetes-platform-types.js";
import monitoringTypes from "./monitoring-types.js";
import serviceDiscoveryTypes from "./service-discovery-types.js";
const { LOAD_BALANCER, NODE_PORT, INGRESS } = kubernetesPlatformTypes.ServiceTypes;
const { NGINX, GKE } = kubernetesPlatformTypes.IngressTypes;
const { EUREKA, CONSUL } = serviceDiscoveryTypes;
const NO_SERVICE_DISCOVERY = serviceDiscoveryTypes.NO;
const NO_MONITORING = monitoringTypes.NO;
const { PROMETHEUS } = monitoringTypes;
const DeploymentTypesOptions = {
    DOCKERCOMPOSE: 'docker-compose',
    KUBERNETES: 'kubernetes',
};
export const DeploymentTypes = {
    ...DeploymentTypesOptions,
    exists: (deploymentType) => !!deploymentType && !!DeploymentTypesOptions[deploymentType.toUpperCase().replace('-', '')],
};
const kubernetesServiceType = {
    loadBalancer: LOAD_BALANCER,
    nodePort: NODE_PORT,
    ingress: INGRESS,
};
const kubernetesRelatedOptions = {
    kubernetesNamespace: 'default',
    kubernetesStorageClassName: '',
    kubernetesServiceType,
    kubernetesUseDynamicStorage: {
        false: false,
        true: true,
    },
    ingressDomain: '',
    ingressType: {
        nginx: NGINX,
        gke: GKE,
    },
    istio: {
        false: false,
        true: true,
    },
};
const dockerComposeRelatedOptions = {
    gatewayType: {
        springCloudGateway: 'SpringCloudGateway',
    },
    /** Use APISIX as API Gateway (VHipster) */
    apisixGateway: {
        false: false,
        true: true,
    },
};
const baseOptions = {
    appsFolders: [],
    clusteredDbApps: [],
    directoryPath: '../',
    monitoring: {
        no: NO_MONITORING,
        prometheus: PROMETHEUS,
    },
    serviceDiscoveryType: {
        eureka: EUREKA,
        consul: CONSUL,
        no: NO_SERVICE_DISCOVERY,
    },
};
const deploymentType = {
    dockerCompose: DeploymentTypes.DOCKERCOMPOSE,
    kubernetes: DeploymentTypes.KUBERNETES,
};
const Options = {
    ...baseOptions,
    dockerPushCommand: 'docker push',
    dockerRepositoryName: '',
    deploymentType,
    ...dockerComposeRelatedOptions,
    ...kubernetesRelatedOptions,
    defaults(deploymentType) {
        if (!deploymentType) {
            throw new Error('Deployment type is required');
        }
        if (deploymentType === this.deploymentType.kubernetes) {
            return {
                appsFolders: [],
                directoryPath: this.directoryPath,
                clusteredDbApps: [],
                serviceDiscoveryType: this.serviceDiscoveryType.consul,
                dockerRepositoryName: this.dockerRepositoryName,
                dockerPushCommand: this.dockerPushCommand,
                kubernetesNamespace: this.kubernetesNamespace,
                kubernetesServiceType: this.kubernetesServiceType.loadBalancer,
                kubernetesUseDynamicStorage: this.kubernetesUseDynamicStorage.false,
                kubernetesStorageClassName: this.kubernetesStorageClassName,
                ingressDomain: this.ingressDomain,
                monitoring: this.monitoring.no,
                istio: this.istio.false,
                ingressType: NGINX,
            };
        }
        if (deploymentType === this.deploymentType.dockerCompose) {
            return {
                appsFolders: [],
                directoryPath: this.directoryPath,
                gatewayType: this.gatewayType.springCloudGateway,
                apisixGateway: this.apisixGateway.false,
                clusteredDbApps: [],
                monitoring: this.monitoring.no,
                serviceDiscoveryType: this.serviceDiscoveryType.consul,
            };
        }
        return {
            appsFolders: [],
            directoryPath: './',
        };
    },
};
export { Options };
export default {
    Options,
    DeploymentTypes,
};