fix(clients): support the rest of the languages

generators/src/main/java/com/algolia/codegen/AlgoliaPhpGenerator.java

@@ -48,7 +48,9 @@ public void processOpts() {
     supportingFiles.add(new SupportingFile("client_config.mustache", "lib/Configuration", getClientName(client) + "Config.php"));
     supportingFiles.add(new SupportingFile("Algolia.mustache", "lib", "Algolia.php"));
 
-    setDefaultGeneratorOptions(client);
+    additionalProperties.put("isSearchClient", client.equals("search"));
+    additionalProperties.put("configClassname", getClientName(client) + "Config");
+
     try {
       additionalProperties.put("packageVersion", Helpers.getClientConfigField("php", "packageVersion"));
     } catch (GeneratorException e) {
@@ -68,15 +70,7 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
     return Helpers.specifyCustomRequest(super.fromOperation(path, httpMethod, operation, servers));
   }
 
-  /** Set default generator options */
-  public void setDefaultGeneratorOptions(String client) {
-    if (client.equals("search") || client.equals("recommend")) {
-      additionalProperties.put("useCache", true);
-    }
-    additionalProperties.put("isSearchClient", client.equals("search"));
-    additionalProperties.put("configClassname", getClientName(client) + "Config");
-  }
-
+  @Override
   public String getComposerPackageName() {
     return "algolia/algoliasearch-client-php";
   }

generators/src/main/java/com/algolia/codegen/utils/Helpers.java

@@ -131,9 +131,13 @@ public static void generateServers(List<CodegenServer> servers, Map<String, Obje
         regionalHost = url.getHost();
       }
 
-      if (servers.size() == 1 && hostWithFallback.isEmpty() && !hasRegionalHost) {
-        URL url = new URL(servers.get(0).url);
-        bundle.put("uniqueHost", url.getHost());
+      if (!hasRegionalHost) {
+        if (servers.size() == 1 && hostWithFallback.isEmpty()) {
+          URL url = new URL(servers.get(0).url);
+          bundle.put("uniqueHost", url.getHost());
+        } else {
+          bundle.put("hostWithAppID", true);
+        }
       }
 
       bundle.put("hostWithFallback", hostWithFallback);

templates/csharp/Configuration.mustache

@@ -36,11 +36,11 @@ namespace Algolia.Search.Clients
     /// <param name="apiKey">Your API Key</param>
     public {{packageName}}Config(string appId, string apiKey)  : base(appId, apiKey, "{{packageName}}")
     {
-      DefaultHosts = GetDefaultHosts({{^uniqueHost}}appId{{/uniqueHost}});
+      DefaultHosts = GetDefaultHosts({{#hostWithAppID}}appId{{/hostWithAppID}});
       Compression = CompressionType.NONE;
     }
   {{/hasRegionalHost}}
-  {{^hasRegionalHost}}{{^uniqueHost}}
+  {{#hostWithAppID}}
   private static List<StatefulHost> GetDefaultHosts(string appId)
   {
     List<StatefulHost> hosts = new List<StatefulHost>
@@ -86,8 +86,7 @@ namespace Algolia.Search.Clients
     hosts.AddRange(commonHosts);
     return hosts;
   }
-  {{/uniqueHost}}
-  {{/hasRegionalHost}}
+  {{/hostWithAppID}}
   {{#hasRegionalHost}}
   private static List<StatefulHost> GetDefaultHosts(string region)
   {
@@ -124,7 +123,7 @@ namespace Algolia.Search.Clients
     {
       new StatefulHost
       {
-        Url = "{{{uniqueHost}}}",
+        Url = "{{{.}}}",
         Up = true,
         LastUse = DateTime.UtcNow,
         Accept =  CallType.Read | CallType.Write
@@ -133,4 +132,4 @@ namespace Algolia.Search.Clients
   }
   {{/uniqueHost}}
 }
-}
+}

templates/dart/api.mustache

@@ -40,7 +40,7 @@ final class {{classname}} implements ApiClient {
             appId: appId,
             apiKey: apiKey,
             options: options,
-            {{^hasRegionalHost}}
+            {{#hostWithAppID}}
             defaultHosts: () => [
               Host(url: '$appId-dsn.algolia.net', callType: CallType.read),
               Host(url: '$appId.algolia.net', callType: CallType.write),
@@ -52,7 +52,7 @@ final class {{classname}} implements ApiClient {
                   Host(url: '$appId-3.algolianet.com'),
                 ]..shuffle()
             ),
-            {{/hasRegionalHost}}
+            {{/hostWithAppID}}
             {{#hasRegionalHost}}
             defaultHosts: () {
               final allowedRegions = [{{#allowedRegions}}'{{.}}'{{^-last}},{{/-last}}{{/allowedRegions}}];
@@ -66,6 +66,9 @@ final class {{classname}} implements ApiClient {
               return [Host(url: url)];
             }  
             {{/hasRegionalHost}}
+            {{#uniqueHost}}
+            defaultHosts: () => [Host(url: '{{{.}}}')],
+            {{/uniqueHost}}
             ) {
     assert(appId.isNotEmpty, '`appId` is missing.');
     assert(apiKey.isNotEmpty, '`apiKey` is missing.');

templates/go/client.mustache

@@ -66,7 +66,7 @@ func NewClientWithConfig(cfg Configuration) (*APIClient, error) {
     if {{^fallbackToAliasHost}}cfg.Region == "" || {{/fallbackToAliasHost}}(cfg.Region != "" && !slices.Contains(allowedRegions[:], string(cfg.Region))) {
       return nil, fmt.Errorf("`region` {{^fallbackToAliasHost}}is required and {{/fallbackToAliasHost}}must be one of the following: %s", strings.Join(allowedRegions[:], ", "))
     }{{/hasRegionalHost}}
-    hosts = getDefaultHosts({{#hasRegionalHost}}cfg.Region{{/hasRegionalHost}}{{^hasRegionalHost}}cfg.AppID{{/hasRegionalHost}})
+    hosts = getDefaultHosts({{#hasRegionalHost}}cfg.Region{{/hasRegionalHost}}{{#hostWithAppID}}cfg.AppID{{/hostWithAppID}})
   } else {
     for _, h := range cfg.Hosts {
       hosts = append(hosts, transport.NewStatefulHost(h, call.IsReadWrite))
@@ -103,7 +103,7 @@ func getDefaultHosts(r Region) []*transport.StatefulHost {
   return []*transport.StatefulHost{transport.NewStatefulHost(strings.ReplaceAll("{{{regionalHost}}}", "{region}", string(r)), call.IsReadWrite)}
 }
 {{/hasRegionalHost}}
-{{^hasRegionalHost}}
+{{#hostWithAppID}}
 func getDefaultHosts(appID string) []*transport.StatefulHost {
 	hosts := []*transport.StatefulHost{
 		transport.NewStatefulHost(appID + "-dsn.algolia.net", call.IsRead),
@@ -118,7 +118,13 @@ func getDefaultHosts(appID string) []*transport.StatefulHost {
 	)...)
 	return hosts
 }
-{{/hasRegionalHost}}
+{{/hostWithAppID}}
+{{#uniqueHost}}
+func getDefaultHosts() []*transport.StatefulHost {
+  return []*transport.StatefulHost{transport.NewStatefulHost("{{{.}}}", call.IsReadWrite)}
+}
+{{/uniqueHost}}
+
 func getUserAgent() string {
   return fmt.Sprintf("Algolia for Go ({{{packageVersion}}}); Go (%s); {{#lambda.titlecase}}{{#lambda.camelcase}}{{client}}{{/lambda.camelcase}}{{/lambda.titlecase}} ({{{packageVersion}}})", runtime.Version())
 }

templates/java/api.mustache

@@ -59,11 +59,11 @@ public class {{classname}} extends ApiClient {
     }
 
     public {{classname}}(String appId, String apiKey, ClientOptions options) {
-      super(appId, apiKey, "{{{baseName}}}", options, getDefaultHosts({{^uniqueHost}}appId{{/uniqueHost}}));
+      super(appId, apiKey, "{{{baseName}}}", options, getDefaultHosts({{#hostWithAppID}}appId{{/hostWithAppID}}));
     }
     {{/hasRegionalHost}}
 
-    {{^uniqueHost}}{{^hasRegionalHost}}
+    {{#hostWithAppID}}
     private static List<Host> getDefaultHosts(String appId) {
       List<Host> hosts = new ArrayList<>();
       hosts.add(new Host(appId + "-dsn.algolia.net", EnumSet.of(CallType.READ)));
@@ -78,7 +78,7 @@ public class {{classname}} extends ApiClient {
 
       return Stream.concat(hosts.stream(), commonHosts.stream()).collect(Collectors.toList());
     }
-    {{/hasRegionalHost}}
+    {{/hostWithAppID}}
 
     {{#hasRegionalHost}}
     private static List<Host> getDefaultHosts(String region) throws AlgoliaRuntimeException {
@@ -103,7 +103,7 @@ public class {{classname}} extends ApiClient {
       hosts.add(new Host(url, EnumSet.of(CallType.READ, CallType.WRITE)));
       return hosts;
     }
-    {{/hasRegionalHost}}{{/uniqueHost}}
+    {{/hasRegionalHost}}
 
     {{#uniqueHost}}
     private static List<Host> getDefaultHosts() {

templates/javascript/clients/api-single.mustache

@@ -22,7 +22,7 @@ export function create{{#lambda.titlecase}}{{apiName}}{{/lambda.titlecase}}({
   }: CreateClientOptions{{#hasRegionalHost}} & {region{{#fallbackToAliasHost}}?{{/fallbackToAliasHost}}: Region }{{/hasRegionalHost}}) {
   const auth = createAuth(appIdOption, apiKeyOption, authMode);
   const transporter = createTransporter({
-    hosts: getDefaultHosts({{^hasRegionalHost}}{{^uniqueHost}}appIdOption{{/uniqueHost}}{{/hasRegionalHost}}{{#hasRegionalHost}}regionOption{{/hasRegionalHost}}),
+    hosts: getDefaultHosts({{#hostWithAppID}}appIdOption{{/hostWithAppID}}{{#hasRegionalHost}}regionOption{{/hasRegionalHost}}),
     ...options,
     algoliaAgent: getAlgoliaAgent({
       algoliaAgents,

templates/javascript/clients/client/api/hosts.mustache

@@ -4,11 +4,11 @@ export type Region = (typeof REGIONS)[number];
 {{/hasRegionalHost}}
 
 {{^hasRegionalHost}}
-function getDefaultHosts({{^uniqueHost}}appId: string{{/uniqueHost}}): Host[] {
+function getDefaultHosts({{#hostWithAppID}}appId: string{{/hostWithAppID}}): Host[] {
   {{#uniqueHost}}
-  return [{url: "{{{uniqueHost}}}", accept: 'readWrite', protocol: 'https' }];
+  return [{url: "{{{.}}}", accept: 'readWrite', protocol: 'https' }];
   {{/uniqueHost}}
-  {{^uniqueHost}}
+  {{#hostWithAppID}}
   return (
     [
       {
@@ -41,7 +41,7 @@ function getDefaultHosts({{^uniqueHost}}appId: string{{/uniqueHost}}): Host[] {
       },
     ])
   );
-  {{/uniqueHost}}
+  {{/hostWithAppID}}
 }
 {{/hasRegionalHost}}
 

templates/kotlin/api.mustache

@@ -25,7 +25,7 @@ public class {{classname}}(
   }
 
   override val requester: Requester = requesterOf(clientName = "{{{baseName}}}", appId = appId, apiKey = apiKey, options = options) {
-  {{^hasRegionalHost}}
+  {{#hostWithAppID}}
     listOf(
       Host("$appId-dsn.algolia.net", CallType.Read),
       Host("$appId.algolia.net", CallType.Write),
@@ -34,7 +34,7 @@ public class {{classname}}(
       Host("$appId-2.algolianet.com"),
       Host("$appId-3.algolianet.com")
     ).apply { shuffle() }
-  {{/hasRegionalHost}}
+  {{/hostWithAppID}}
   {{#hasRegionalHost}}
     val allowedRegions = listOf({{#allowedRegions}}"{{.}}"{{^-last}},{{/-last}}{{/allowedRegions}})
     {{^fallbackToAliasHost}}
@@ -46,6 +46,9 @@ public class {{classname}}(
     val url = {{#fallbackToAliasHost}}if (region == null) "{{{hostWithFallback}}}" else {{/fallbackToAliasHost}} "{{{hostForKotlin}}}"
     listOf(Host(url)) 
   {{/hasRegionalHost}}
+  {{#uniqueHost}}
+  listOf(Host("{{.}}"))
+  {{/uniqueHost}}
   }
 
   {{#operation}}

templates/kotlin/snippets/method.mustache

@@ -11,7 +11,7 @@ class Snippet{{client}} {
   {{#snippet}}
   suspend fun snippetFor{{#lambda.pascalcase}}{{method}}{{/lambda.pascalcase}}() {
       // Initialize the client
-      val client = {{client}}(appId = "YOUR_APP_ID", apiKey = "YOUR_API_KEY"{{#hasRegionalHost}}, region = "YOUR_APP_ID_REGION"{{/hasRegionalHost}})
+      val client = {{client}}(appId = "YOUR_APP_ID", apiKey = "YOUR_API_KEY"{{#hasRegionalHost}}, region = "YOUR_REGION"{{/hasRegionalHost}})
 
       // Call the API
       var response = client.{{method}}(
@@ -46,4 +46,4 @@ class Snippet{{client}} {
 
   {{/snippet}}
   {{/blocksRequests}}
-}
+}

templates/php/api.mustache

@@ -113,7 +113,7 @@ use {{invokerPackage}}\Support\Helpers;
      */
     public static function getClusterHosts({{configClassname}} $config)
     {
-        {{#useCache}}
+        {{#hostWithAppID}}
         $cacheKey = sprintf('%s-clusterHosts-%s', __CLASS__, $config->getAppId());
 
         if ($hosts = $config->getHosts()) {
@@ -125,9 +125,9 @@ use {{invokerPackage}}\Support\Helpers;
             $clusterHosts = ClusterHosts::createFromAppId($config->getAppId())
                 ->setCacheKey($cacheKey);
         }
-        {{/useCache}}
+        {{/hostWithAppID}}
 
-        {{^useCache}}
+        {{#hasRegionalHost}}
         if ($hosts = $config->getHosts()) {
             // If a list of hosts was passed, we ignore the cache
             $clusterHosts = ClusterHosts::create($hosts);
@@ -137,7 +137,16 @@ use {{invokerPackage}}\Support\Helpers;
                 '{{{hostWithFallback}}}';
             $clusterHosts = ClusterHosts::create($url);
         }
-        {{/useCache}}
+        {{/hasRegionalHost}}
+
+        {{#uniqueHost}}
+        if ($hosts = $config->getHosts()) {
+            // If a list of hosts was passed, we ignore the cache
+            $clusterHosts = ClusterHosts::create($hosts);
+        } else {
+            $clusterHosts = ClusterHosts::create('{{.}}');
+        }
+        {{/uniqueHost}}
 
         return $clusterHosts;
     }
@@ -430,4 +439,4 @@ use {{invokerPackage}}\Support\Helpers;
         );
     }
 }
-{{/operations}}
+{{/operations}}

templates/python/config.mustache

@@ -60,17 +60,17 @@ class {{#lambda.pascalcase}}{{client}}{{/lambda.pascalcase}}Config(BaseConfig):
         self.hosts = HostsCollection(
             {{#uniqueHost}}
             [
-                Host("{{{uniqueHost}}}"),
+                Host("{{{.}}}"),
             ]
             {{/uniqueHost}}
-            {{^uniqueHost}}
+            {{#hostWithAppID}}
             [
                 Host("{}-dsn.algolia.net".format(self.app_id), 10, CallType.READ),
                 Host("{}.algolia.net".format(self.app_id), 10, CallType.WRITE),
                 Host("{}-1.algolianet.com".format(self.app_id)),
                 Host("{}-2.algolianet.com".format(self.app_id)),
                 Host("{}-3.algolianet.com".format(self.app_id)),
             ]
-            {{/uniqueHost}}
+            {{/hostWithAppID}}
         )
-        {{/hasRegionalHost}}
+        {{/hasRegionalHost}}

templates/ruby/api.mustache

@@ -31,14 +31,18 @@ module {{moduleName}}
       {{/fallbackToAliasHost}}
 
       hosts << Transport::StatefulHost.new({{#fallbackToAliasHost}}region.nil? ? '{{{hostWithFallback}}}' : {{/fallbackToAliasHost}} '{{{regionalHost}}}'.sub!('{region}', region), accept: CallType::READ | CallType::WRITE)
-      {{/hasRegionalHost}}{{^hasRegionalHost}}
+      {{/hasRegionalHost}}
+      {{#hostWithAppID}}
       hosts << Transport::StatefulHost.new("#{app_id}-dsn.algolia.net", accept: CallType::READ)
       hosts << Transport::StatefulHost.new("#{app_id}.algolia.net", accept: CallType::WRITE)
 
       hosts += 1.upto(3).map do |i|
         Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: CallType::READ | CallType::WRITE)
       end.shuffle
-      {{/hasRegionalHost}}
+      {{/hostWithAppID}}
+      {{#uniqueHost}}
+      hosts << Transport::StatefulHost.new('{{.}}', accept: CallType::READ | CallType::WRITE)
+      {{/uniqueHost}}
 
       config = Algolia::Configuration.new(app_id, api_key, hosts, '{{{baseName}}}', opts)
       create_with_config(config)

templates/scala/api.mustache

@@ -60,7 +60,7 @@ object {{classname}} {
     Seq(Host(url = url, callTypes = Set(CallType.Read, CallType.Write)))
   }
   {{/hasRegionalHost}}
-  {{^hasRegionalHost}}
+  {{#hostWithAppID}}
   private def hosts(appId: String): Seq[Host] = {
     val commonHosts = Random.shuffle(
       List(
@@ -74,7 +74,12 @@ object {{classname}} {
       Host(appId + ".algolia.net", Set(CallType.Write))
     ) ++ commonHosts
   }
-  {{/hasRegionalHost}}
+  {{/hostWithAppID}}
+  {{#uniqueHost}}
+  private def hosts(): Seq[Host] = {
+    List(Host("{{.}}", Set(CallType.Read, CallType.Write)))
+  }
+  {{/uniqueHost}}
 }
 
 class {{classname}}(
@@ -86,7 +91,7 @@ class {{classname}}(
       appId = appId,
       apiKey = apiKey,
       clientName = "{{{baseName}}}",
-      defaultHosts = {{^hasRegionalHost}}hosts(appId){{/hasRegionalHost}}{{#hasRegionalHost}}hosts(region){{/hasRegionalHost}},
+      defaultHosts = hosts({{#hostWithAppID}}appId{{/hostWithAppID}}{{#hasRegionalHost}}region{{/hasRegionalHost}}),
       formats = JsonSupport.format,
       options = clientOptions
     ) {