generator-jhipster 7.1.0 → 7.4.0

package/generators/server/needle-api/needle-server-cache.js

@@ -19,21 +19,20 @@
 const chalk = require('chalk');
 const needleServer = require('./needle-server');
 const constants = require('../../generator-constants');
+const { CAFFEINE, EHCACHE, REDIS } = require('../../../jdl/jhipster/cache-types');
 
 const SERVER_MAIN_SRC_DIR = constants.SERVER_MAIN_SRC_DIR;
 
 module.exports = class extends needleServer {
   addEntityToCache(entityClass, relationships, packageName, packageFolder, cacheProvider) {
-    this.addEntryToCache(`${packageName}.domain.${entityClass}.class.getName()`, packageFolder, cacheProvider);
+    const entityAbsoluteClass = entityClass.includes('.') ? entityClass : `${packageName}.domain.${entityClass}`;
+    const entityClassNameGetter = `${entityAbsoluteClass}.class.getName()`;
+    this.addEntryToCache(entityClassNameGetter, packageFolder, cacheProvider);
     // Add the collections linked to that entity to cache
     relationships.forEach(relationship => {
       const relationshipType = relationship.relationshipType;
       if (relationshipType === 'one-to-many' || relationshipType === 'many-to-many') {
-        this.addEntryToCache(
-          `${packageName}.domain.${entityClass}.class.getName() + ".${relationship.relationshipFieldNamePlural}"`,
-          packageFolder,
-          cacheProvider
-        );
+        this.addEntryToCache(`${entityClassNameGetter} + ".${relationship.relationshipFieldNamePlural}"`, packageFolder, cacheProvider);
       }
     });
   }
@@ -42,12 +41,12 @@ module.exports = class extends needleServer {
     const errorMessage = chalk.yellow(`\nUnable to add ${entry} to CacheConfiguration.java file.`);
     const cachePath = `${SERVER_MAIN_SRC_DIR}${packageFolder}/config/CacheConfiguration.java`;
 
-    if (cacheProvider === 'ehcache' || cacheProvider === 'caffeine') {
+    if (cacheProvider === EHCACHE || cacheProvider === CAFFEINE) {
       const needle = `jhipster-needle-${cacheProvider}-add-entry`;
       const content = `createCache(cm, ${entry});`;
 
       this._doAddBlockContentToFile(cachePath, needle, content, errorMessage);
-    } else if (cacheProvider === 'redis') {
+    } else if (cacheProvider === REDIS) {
       const needle = 'jhipster-needle-redis-add-entry';
       const content = `createCache(cm, ${entry}, jcacheConfiguration);`;
 

package/generators/server/prompts.js

@@ -21,6 +21,32 @@ const chalk = require('chalk');
 
 const constants = require('../generator-constants');
 const { serverDefaultConfig } = require('../generator-defaults');
+const { GATEWAY, MICROSERVICE, MONOLITH } = require('../../jdl/jhipster/application-types');
+const { CAFFEINE, EHCACHE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS } = require('../../jdl/jhipster/cache-types');
+const cacheProviderTypes = require('../../jdl/jhipster/cache-types');
+const { JWT, OAUTH2, SESSION } = require('../../jdl/jhipster/authentication-types');
+const { GRADLE, MAVEN } = require('../../jdl/jhipster/build-tool-types');
+const { CASSANDRA, H2_DISK, H2_MEMORY, MONGODB, NEO4J, SQL, COUCHBASE } = require('../../jdl/jhipster/database-types');
+const databaseTypes = require('../../jdl/jhipster/database-types');
+const { CONSUL, EUREKA } = require('../../jdl/jhipster/service-discovery-types');
+const serviceDiscoveryTypes = require('../../jdl/jhipster/service-discovery-types');
+const { OptionNames } = require('../../jdl/jhipster/application-options');
+
+const {
+  AUTHENTICATION_TYPE,
+  BUILD_TOOL,
+  CACHE_PROVIDER,
+  DATABASE_TYPE,
+  PACKAGE_NAME,
+  DEV_DATABASE_TYPE,
+  PROD_DATABASE_TYPE,
+  REACTIVE,
+  SERVER_PORT,
+  SERVICE_DISCOVERY_TYPE,
+} = OptionNames;
+const NO_SERVICE_DISCOVERY = serviceDiscoveryTypes.NO;
+const NO_DATABASE = databaseTypes.NO;
+const NO_CACHE_PROVIDER = cacheProviderTypes.NO;
 
 module.exports = {
   askForModuleName,
@@ -38,19 +64,19 @@ function askForServerSideOpts() {
   if (this.existingProject) return undefined;
 
   const applicationType = this.jhipsterConfig.applicationType;
-  const defaultPort = applicationType === 'gateway' ? '8080' : '8081';
+  const defaultPort = applicationType === GATEWAY ? '8080' : '8081';
   const prompts = [
     {
-      when: () => ['monolith', 'microservice'].includes(applicationType),
+      when: () => [MONOLITH, MICROSERVICE].includes(applicationType),
       type: 'confirm',
-      name: 'reactive',
+      name: REACTIVE,
       message: 'Do you want to make it reactive with Spring WebFlux?',
       default: serverDefaultConfig.reactive,
     },
     {
-      when: () => applicationType === 'gateway' || applicationType === 'microservice',
+      when: () => applicationType === GATEWAY || applicationType === MICROSERVICE,
       type: 'input',
-      name: 'serverPort',
+      name: SERVER_PORT,
       validate: input => (/^([0-9]*)$/.test(input) ? true : 'This is not a valid port number.'),
       message:
         'As you are running in a microservice architecture, on which port would like your server to run? It should be unique to avoid port conflicts.',
@@ -58,7 +84,7 @@ function askForServerSideOpts() {
     },
     {
       type: 'input',
-      name: 'packageName',
+      name: PACKAGE_NAME,
       validate: input =>
         /^([a-z_]{1}[a-z0-9_]*(\.[a-z_]{1}[a-z0-9_]*)*)$/.test(input)
           ? true
@@ -70,45 +96,44 @@ function askForServerSideOpts() {
     {
       when: () => applicationType === 'gateway' || applicationType === 'microservice',
       type: 'list',
-      name: 'serviceDiscoveryType',
+      name: SERVICE_DISCOVERY_TYPE,
       message: 'Which service discovery server do you want to use?',
       choices: [
         {
-          value: 'eureka',
+          value: EUREKA,
           name: 'JHipster Registry (uses Eureka, provides Spring Cloud Config support and monitoring dashboards)',
         },
         {
-          value: 'consul',
+          value: CONSUL,
           name: 'Consul',
         },
         {
-          value: false,
+          value: NO_SERVICE_DISCOVERY,
           name: 'No service discovery',
         },
       ],
-      default: 'eureka',
+      default: EUREKA,
     },
     {
       when: answers =>
-        (applicationType === 'monolith' && answers.serviceDiscoveryType !== 'eureka') ||
-        ['gateway', 'microservice'].includes(applicationType),
+        (applicationType === MONOLITH && answers.serviceDiscoveryType !== EUREKA) || [GATEWAY, MICROSERVICE].includes(applicationType),
       type: 'list',
-      name: 'authenticationType',
+      name: AUTHENTICATION_TYPE,
       message: `Which ${chalk.yellow('*type*')} of authentication would you like to use?`,
       choices: answers => {
         const opts = [
           {
-            value: 'jwt',
+            value: JWT,
             name: 'JWT authentication (stateless, with a token)',
           },
         ];
         opts.push({
-          value: 'oauth2',
+          value: OAUTH2,
           name: 'OAuth 2.0 / OIDC Authentication (stateful, works with Keycloak and Okta)',
         });
-        if (applicationType === 'monolith' && answers.serviceDiscoveryType !== 'eureka') {
+        if (applicationType === MONOLITH && answers.serviceDiscoveryType !== EUREKA) {
           opts.push({
-            value: 'session',
+            value: SESSION,
             name: 'HTTP Session Authentication (stateful, default Spring Security mechanism)',
           });
         }
@@ -118,42 +143,41 @@ function askForServerSideOpts() {
     },
     {
       type: 'list',
-      name: 'databaseType',
+      name: DATABASE_TYPE,
       message: `Which ${chalk.yellow('*type*')} of database would you like to use?`,
       choices: answers => {
         const opts = [];
         if (!answers.reactive) {
           opts.push({
-            value: 'sql',
+            value: SQL,
             name: 'SQL (H2, PostgreSQL, MySQL, MariaDB, Oracle, MSSQL)',
           });
         } else {
           opts.push({
-            value: 'sql',
+            value: SQL,
             name: 'SQL (H2, PostgreSQL, MySQL, MariaDB, MSSQL)',
           });
         }
         opts.push({
-          value: 'mongodb',
+          value: MONGODB,
           name: 'MongoDB',
         });
-        if (answers.authenticationType !== 'oauth2') {
+        if (answers.authenticationType !== OAUTH2) {
           opts.push({
-            value: 'cassandra',
+            value: CASSANDRA,
             name: 'Cassandra',
           });
         }
-        // Couchbase is broken, see https://github.com/jhipster/generator-jhipster/pull/14184 for more information.
-        /* opts.push({
+        opts.push({
           value: 'couchbase',
-          name: 'Couchbase',
-        }); */
+          name: '[BETA] Couchbase',
+        });
         opts.push({
-          value: 'neo4j',
+          value: NEO4J,
           name: '[BETA] Neo4j',
         });
         opts.push({
-          value: 'no',
+          value: NO_DATABASE,
           name: 'No database',
         });
         return opts;
@@ -161,26 +185,26 @@ function askForServerSideOpts() {
       default: serverDefaultConfig.databaseType,
     },
     {
-      when: response => response.databaseType === 'sql',
+      when: response => response.databaseType === SQL,
       type: 'list',
-      name: 'prodDatabaseType',
+      name: PROD_DATABASE_TYPE,
       message: `Which ${chalk.yellow('*production*')} database would you like to use?`,
       choices: answers => (answers.reactive ? constants.R2DBC_DB_OPTIONS : constants.SQL_DB_OPTIONS),
       default: serverDefaultConfig.prodDatabaseType,
     },
     {
-      when: response => response.databaseType === 'sql',
+      when: response => response.databaseType === SQL,
       type: 'list',
-      name: 'devDatabaseType',
+      name: DEV_DATABASE_TYPE,
       message: `Which ${chalk.yellow('*development*')} database would you like to use?`,
       choices: response =>
         [
           {
-            value: 'h2Disk',
+            value: H2_DISK,
             name: 'H2 with disk-based persistence',
           },
           {
-            value: 'h2Memory',
+            value: H2_MEMORY,
             name: 'H2 with in-memory persistence',
           },
         ].concat(constants.SQL_DB_OPTIONS.find(it => it.value === response.prodDatabaseType)),
@@ -189,44 +213,44 @@ function askForServerSideOpts() {
     {
       when: answers => !answers.reactive,
       type: 'list',
-      name: 'cacheProvider',
+      name: CACHE_PROVIDER,
       message: 'Which cache do you want to use? (Spring cache abstraction)',
       choices: [
         {
-          value: 'ehcache',
+          value: EHCACHE,
           name: 'Ehcache (local cache, for a single node)',
         },
         {
-          value: 'caffeine',
+          value: CAFFEINE,
           name: 'Caffeine (local cache, for a single node)',
         },
         {
-          value: 'hazelcast',
+          value: HAZELCAST,
           name: 'Hazelcast (distributed cache, for multiple nodes, supports rate-limiting for gateway applications)',
         },
         {
-          value: 'infinispan',
+          value: INFINISPAN,
           name: 'Infinispan (hybrid cache, for multiple nodes)',
         },
         {
-          value: 'memcached',
+          value: MEMCACHED,
           name: 'Memcached (distributed cache) - Warning, when using an SQL database, this will disable the Hibernate 2nd level cache!',
         },
         {
-          value: 'redis',
+          value: REDIS,
           name: 'Redis (distributed cache)',
         },
         {
-          value: 'no',
+          value: NO_CACHE_PROVIDER,
           name: 'No cache - Warning, when using an SQL database, this will disable the Hibernate 2nd level cache!',
         },
       ],
-      default: applicationType === 'microservice' ? 2 : serverDefaultConfig.cacheProvider,
+      default: applicationType === MICROSERVICE ? 2 : serverDefaultConfig.cacheProvider,
     },
     {
       when: answers =>
-        ((answers.cacheProvider !== 'no' && answers.cacheProvider !== 'memcached') || applicationType === 'gateway') &&
-        answers.databaseType === 'sql' &&
+        ((answers.cacheProvider !== NO_CACHE_PROVIDER && answers.cacheProvider !== MEMCACHED) || applicationType === GATEWAY) &&
+        answers.databaseType === SQL &&
         !answers.reactive,
       type: 'confirm',
       name: 'enableHibernateCache',
@@ -235,32 +259,46 @@ function askForServerSideOpts() {
     },
     {
       type: 'list',
-      name: 'buildTool',
+      name: BUILD_TOOL,
       message: 'Would you like to use Maven or Gradle for building the backend?',
       choices: [
         {
-          value: 'maven',
+          value: MAVEN,
           name: 'Maven',
         },
         {
-          value: 'gradle',
+          value: GRADLE,
           name: 'Gradle',
         },
       ],
       default: serverDefaultConfig.buildTool,
     },
     {
-      when: applicationType === 'monolith',
+      when: answers => answers.buildTool === GRADLE && this.options.experimental,
+      type: 'confirm',
+      name: 'enableGradleEnterprise',
+      message: 'Do you want to enable Gradle Enterprise integration?',
+      default: serverDefaultConfig.enableGradleEnterprise,
+    },
+    {
+      when: answers => answers.enableGradleEnterprise,
+      type: 'input',
+      name: 'gradleEnterpriseHost',
+      message: 'Enter your Gradle Enterprise host',
+      validate: input => (input.length === 0 ? 'Please enter your Gradle Enterprise host' : true),
+    },
+    {
+      when: applicationType === MONOLITH,
       type: 'list',
-      name: 'serviceDiscoveryType',
+      name: SERVICE_DISCOVERY_TYPE,
       message: 'Do you want to use the JHipster Registry to configure, monitor and scale your application?',
       choices: [
         {
-          value: false,
+          value: NO_SERVICE_DISCOVERY,
           name: 'No',
         },
         {
-          value: 'eureka',
+          value: EUREKA,
           name: 'Yes',
         },
       ],
@@ -270,7 +308,7 @@ function askForServerSideOpts() {
 
   return this.prompt(prompts).then(answers => {
     this.serviceDiscoveryType = this.jhipsterConfig.serviceDiscoveryType = answers.serviceDiscoveryType;
-    if (this.jhipsterConfig.applicationType === 'gateway') {
+    if (this.jhipsterConfig.applicationType === GATEWAY) {
       this.reactive = this.jhipsterConfig.reactive = answers.reactive = true;
     } else {
       this.reactive = this.jhipsterConfig.reactive = answers.reactive;
@@ -279,13 +317,17 @@ function askForServerSideOpts() {
 
     this.packageName = this.jhipsterConfig.packageName = answers.packageName;
     this.serverPort = this.jhipsterConfig.serverPort = answers.serverPort || '8080';
-    this.cacheProvider = this.jhipsterConfig.cacheProvider = !answers.reactive ? answers.cacheProvider : 'no';
+    this.cacheProvider = this.jhipsterConfig.cacheProvider = !answers.reactive ? answers.cacheProvider : NO_CACHE_PROVIDER;
     this.enableHibernateCache = this.jhipsterConfig.enableHibernateCache = !!answers.enableHibernateCache;
-    this.databaseType = this.jhipsterConfig.databaseType = answers.databaseType;
-    this.devDatabaseType = this.jhipsterConfig.devDatabaseType = answers.devDatabaseType;
-    this.prodDatabaseType = this.jhipsterConfig.prodDatabaseType = answers.prodDatabaseType;
+
+    const { databaseType } = answers;
+    this.databaseType = this.jhipsterConfig.databaseType = databaseType;
+    this.devDatabaseType = this.jhipsterConfig.devDatabaseType = answers.devDatabaseType || databaseType;
+    this.prodDatabaseType = this.jhipsterConfig.prodDatabaseType = answers.prodDatabaseType || databaseType;
     this.searchEngine = this.jhipsterConfig.searchEngine = answers.searchEngine;
     this.buildTool = this.jhipsterConfig.buildTool = answers.buildTool;
+    this.enableGradleEnterprise = this.jhipsterConfig.enableGradleEnterprise = answers.enableGradleEnterprise;
+    this.gradleEnterpriseHost = this.jhipsterConfig.gradleEnterpriseHost = answers.gradleEnterpriseHost;
   });
 }
 
@@ -298,20 +340,20 @@ function askForOptionalItems() {
 
   const choices = [];
   const defaultChoice = [];
-  if (['sql', 'mongodb', 'neo4j'].includes(databaseType)) {
+  if ([SQL, MONGODB, NEO4J].includes(databaseType)) {
     choices.push({
       name: 'Elasticsearch as search engine',
       value: 'searchEngine:elasticsearch',
     });
   }
-  if (databaseType === 'couchbase') {
+  if (databaseType === COUCHBASE) {
     choices.push({
       name: 'Couchbase FTS as search engine',
       value: 'searchEngine:couchbase',
     });
   }
   if (!reactive) {
-    if (applicationType === 'monolith' || applicationType === 'gateway') {
+    if (applicationType === MONOLITH || applicationType === GATEWAY) {
       choices.push({
         name: 'WebSockets using Spring Websocket',
         value: 'websocket:spring-websocket',

package/generators/server/templates/.mvn/wrapper/MavenWrapperDownloader.java

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

package/generators/server/templates/.mvn/wrapper/maven-wrapper.properties

@@ -1,2 +1,2 @@
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.1/apache-maven-3.8.1-bin.zip
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.3/apache-maven-3.8.3-bin.zip
 wrapperUrl=https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar

package/generators/server/templates/build.gradle.ejs

@@ -34,17 +34,18 @@ plugins {
     id "org.springframework.boot"
     id "com.google.cloud.tools.jib"
     id "com.gorylenko.gradle-git-properties"
-    <%_ if (enableSwaggerCodegen) { _%>
+<%_ if (enableSwaggerCodegen) { _%>
     id "org.openapi.generator"
-    <%_ } _%>
-    <%_ if (!skipClient) { _%>
+<%_ } _%>
+<%_ if (!skipClient) { _%>
     id "com.github.node-gradle.node"
-    <%_ } _%>
-    <%_ if (databaseType === 'sql' && !reactive) { _%>
+<%_ } _%>
+<%_ if (databaseTypeSql && !reactive) { _%>
     id "org.liquibase.gradle"
-    <%_ } _%>
+<%_ } _%>
     id "org.sonarqube"
     id "io.spring.nohttp"
+    id "com.github.andygoossens.gradle-modernizer-plugin"
     //jhipster-needle-gradle-plugins - JHipster will add additional gradle plugins here
 }
 
@@ -55,7 +56,7 @@ description = ""
 
 sourceCompatibility=<%= JAVA_VERSION %>
 targetCompatibility=<%= JAVA_VERSION %>
-assert System.properties["java.specification.version"] == "1.8" || "1.9" || "10" || "11" || "12" || "13" || "14" || "15" || "16"
+assert System.properties["java.specification.version"] == <%- JAVA_COMPATIBLE_VERSIONS.map(ver => `"${ver}"`).join(' || '); %>
 
 apply from: "gradle/docker.gradle"
 apply from: "gradle/sonar.gradle"
@@ -126,9 +127,26 @@ test {
     // see https://github.com/jhipster/generator-jhipster/pull/2771 and https://github.com/jhipster/generator-jhipster/pull/4484
     // ignoreFailures true
     reports.html.enabled = false
+<%_ if (reactive) { _%>
+
+    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_13)) {
+        jvmArgs += [
+            "-XX:+AllowRedefinitionToAddDeleteMethods"
+        ]
+    }
+<%_ } _%>
+}
+
+modernizer {
+    failOnViolations = true
+    includeTestClasses = true
 }
 
 task integrationTest(type: Test) {
+<%_ if (databaseTypeCouchbase) { _%>
+    minHeapSize = "128m"
+    maxHeapSize = "512m"
+<%_ } _%>
     useJUnitPlatform()
     description = "Execute integration tests."
     group = "verification"
@@ -154,6 +172,14 @@ task integrationTest(type: Test) {
     // see https://github.com/jhipster/generator-jhipster/pull/2771 and https://github.com/jhipster/generator-jhipster/pull/4484
     // ignoreFailures true
     reports.html.enabled = false
+<%_ if (reactive) { _%>
+
+    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_13)) {
+        jvmArgs += [
+            "-XX:+AllowRedefinitionToAddDeleteMethods"
+        ]
+    }
+<%_ } _%>
 }
 <%_ if (cucumberTests) { _%>
 
@@ -454,7 +480,11 @@ dependencies {
     <%_ } _%>
     <%_ if (applicationType === 'microservice' || applicationType === 'gateway') { _%>
     implementation "org.springframework.cloud:spring-cloud-starter"
-    implementation "org.springframework.cloud:spring-cloud-starter-netflix-hystrix"
+    <%_ if (reactive) { _%>
+    implementation "org.springframework.cloud:spring-cloud-starter-circuitbreaker-reactor-resilience4j"
+    <%_ } else { _%>
+    implementation "org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j"
+    <%_ } _%>
     implementation "org.springframework.retry:spring-retry"
     <%_ } _%>
     <%_ if (serviceDiscoveryType) { _%>
@@ -474,6 +504,11 @@ dependencies {
     <%_ if (applicationType === 'microservice' || applicationType === 'gateway') { _%>
     implementation "org.springframework.cloud:spring-cloud-starter-openfeign"
     <%_ } _%>
+    <%_ if (applicationTypeGateway || (applicationTypeMicroservice && reactive)) { _%>
+    implementation "com.playtika.reactivefeign:feign-reactor-webclient"
+    implementation "com.playtika.reactivefeign:feign-reactor-cloud"
+    implementation "com.playtika.reactivefeign:feign-reactor-spring-configuration"
+    <%_ } _%>
     implementation "org.springframework.security:spring-security-config"
     <%_ if (!reactive) { _%><%# Can remove when Spring Security 5.5 is released https://github.com/spring-projects/spring-security/issues/8958 -%>
     implementation "org.springframework.security:spring-security-data"
@@ -503,7 +538,6 @@ dependencies {
     <%_ if (databaseType === 'couchbase') { _%>
     implementation "com.github.differentway:couchmove"
     implementation "com.couchbase.client:java-client"
-    implementation "com.couchbase.client:encryption"
     <%_ } _%>
     implementation ("io.springfox:springfox-oas")
     implementation ("io.springfox:springfox-swagger2")

package/generators/server/templates/checkstyle.xml.ejs

@@ -27,9 +27,9 @@
     <property name="fileExtensions" value=""/>
     <!-- For detailed checkstyle configuration, see https://github.com/spring-io/nohttp/tree/master/nohttp-checkstyle -->
     <module name="io.spring.nohttp.checkstyle.check.NoHttpCheck">
-        <%_ if (buildTool === 'maven') { _%>
+<%_ if (buildToolMaven) { _%>
         <property name="allowlist" value="^\Qhttp://maven.apache.org/POM/4.0.0&#10;^\Qhttp://www.w3.org/2001/XMLSchema-instance"/>
-        <%_ } _%>
+<%_ } _%>
     </module>
     <!-- Allow suppression with comments
        // CHECKSTYLE:OFF

package/generators/server/templates/{src → couchbase/src}/main/docker/couchbase/scripts/configure-node.sh.ejs

@@ -12,10 +12,10 @@ do
 done
 
 echo "Setup index and memory quota"
-curl -X POST http://127.0.0.1:8091/pools/default -d memoryQuota=300 -d indexMemoryQuota=300
+curl -X POST http://127.0.0.1:8091/pools/default -d memoryQuota=1000 -d indexMemoryQuota=1000
 
 echo "Setup services"
-curl http://127.0.0.1:8091/node/controller/setupServices -d services=kv%2Cn1ql%2Cindex<% if (searchEngine === 'couchbase') { %>%2Cfts<% } %>
+curl http://127.0.0.1:8091/node/controller/setupServices -d services=kv%2Cn1ql%2Cindex<% if (searchEngineCouchbase) { %>%2Cfts<% } %>
 
 echo "Setup credentials"
 curl http://127.0.0.1:8091/settings/web -d port=8091 -d username=Administrator -d password=password
@@ -24,7 +24,7 @@ echo "Setup Memory Optimized Indexes"
 curl -u Administrator:password -X POST http://127.0.0.1:8091/settings/indexes -d 'storageMode=memory_optimized'
 
 echo "Setup bucket $BUCKET"
-curl -u Administrator:password -X POST http://127.0.0.1:8091/pools/default/buckets -d name=$BUCKET -d bucketType=couchbase -d ramQuotaMB=300 -dauthType=sasl
+curl -u Administrator:password -X POST http://127.0.0.1:8091/pools/default/buckets -d name=$BUCKET -d bucketType=couchbase -d ramQuotaMB=600 -dauthType=sasl
 
 echo "Setup bucket $BUCKET admin user"
 curl -u Administrator:password -X PUT http://127.0.0.1:8091/settings/rbac/users/local/$BUCKET -d name=$BUCKET -d password=password -d roles="bucket_admin[$BUCKET],bucket_full_access[$BUCKET]"
@@ -46,7 +46,7 @@ if [ "$TYPE" = "WORKER" ]; then
     if [ "$AUTO_REBALANCE" = "true" ]; then
         couchbase-cli rebalance --cluster=$COUCHBASE_MASTER:8091 --user=Administrator --password=password
     else
-        couchbase-cli server-add --cluster=$COUCHBASE_MASTER:8091 --user=Administrator --password=password --server-add=$IP --server-add-username=Administrator --server-add-password=password --services=data,index,query<% if (searchEngine === 'couchbase') { %>,fts<% } %>
+        couchbase-cli server-add --cluster=$COUCHBASE_MASTER:8091 --user=Administrator --password=password --server-add=$IP --server-add-username=Administrator --server-add-password=password --services=data,index,query<% if (searchEngineCouchbase) { %>,fts<% } %>
     fi;
 fi;