SSRC Client Setup and Fetch Implementation (#680)

* Initial Fetch Implementation

* Adding atomic pointer and toJSON method

* Adding ToJson and other config changes

* Updating ServerConfig default and adding basic tests

* Updating headers and adding config options

---------

Co-authored-by: Pijush Chakraborty <[email protected]>

Author: pijushcs

firebase.go

@@ -31,6 +31,7 @@ import (
 	"firebase.google.com/go/v4/iid"
 	"firebase.google.com/go/v4/internal"
 	"firebase.google.com/go/v4/messaging"
+	"firebase.google.com/go/v4/remoteconfig"
 	"firebase.google.com/go/v4/storage"
 	"google.golang.org/api/option"
 	"google.golang.org/api/transport"
@@ -138,6 +139,16 @@ func (a *App) AppCheck(ctx context.Context) (*appcheck.Client, error) {
 	return appcheck.NewClient(ctx, conf)
 }
 
+// RemoteConfig returns an instance of remoteconfig.Client.
+func (a *App) RemoteConfig(ctx context.Context) (*remoteconfig.Client, error) {
+	conf := &internal.RemoteConfigClientConfig{
+		ProjectID: a.projectID,
+		Opts:      a.opts,
+		Version:   Version,
+	}
+	return remoteconfig.NewClient(ctx, conf)
+}
+
 // NewApp creates a new App from the provided config and client options.
 //
 // If the client options contain a valid credential (a service account file, a refresh token

internal/internal.go

@@ -74,6 +74,13 @@ type MessagingConfig struct {
 	Version   string
 }
 
+// RemoteConfigClientConfig represents the configuration of Firebase Remote Config
+type RemoteConfigClientConfig struct {
+	Opts      []option.ClientOption
+	ProjectID string
+	Version   string
+}
+
 // AppCheckConfig represents the configuration of App Check service.
 type AppCheckConfig struct {
 	ProjectID string

remoteconfig/remoteconfig.go

@@ -0,0 +1,117 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// 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
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package remoteconfig allows clients to use Firebase Remote Config with Go.
+package remoteconfig
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"firebase.google.com/go/v4/internal"
+)
+
+const (
+	defaultBaseURL       = "https://firebaseremoteconfig.googleapis.com"
+	firebaseClientHeader = "X-Firebase-Client"
+)
+
+// Client is the interface for the Remote Config Cloud service.
+type Client struct {
+	*rcClient
+}
+
+// NewClient initializes a RemoteConfigClient with app-specific detail and a returns a
+// client to be used by the user.
+func NewClient(ctx context.Context, c *internal.RemoteConfigClientConfig) (*Client, error) {
+	if c.ProjectID == "" {
+		return nil, errors.New("project ID is required to access Remote Conifg")
+	}
+
+	hc, _, err := internal.NewHTTPClient(ctx, c.Opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{
+		rcClient: newRcClient(hc, c),
+	}, nil
+}
+
+// RemoteConfigClient facilitates requests to the Firebase Remote Config backend.
+type rcClient struct {
+	httpClient *internal.HTTPClient
+	project    string
+	rcBaseURL  string
+	version    string
+}
+
+func newRcClient(client *internal.HTTPClient, conf *internal.RemoteConfigClientConfig) *rcClient {
+	version := fmt.Sprintf("fire-admin-go/%s", conf.Version)
+	client.Opts = []internal.HTTPOption{
+		internal.WithHeader(firebaseClientHeader, version),
+		internal.WithHeader("X-Firebase-ETag", "true"),
+		internal.WithHeader("x-goog-api-client", internal.GetMetricsHeader(conf.Version)),
+	}
+
+	client.CreateErrFn = handleRemoteConfigError
+
+	return &rcClient{
+		rcBaseURL:  defaultBaseURL,
+		project:    conf.ProjectID,
+		version:    version,
+		httpClient: client,
+	}
+}
+
+// GetServerTemplate Initializes a new ServerTemplate instance and fetches the server template.
+func (c *rcClient) GetServerTemplate(ctx context.Context,
+	defaultConfig map[string]any) (*ServerTemplate, error) {
+	template, err := c.InitServerTemplate(defaultConfig, "")
+
+	if err != nil {
+		return nil, err
+	}
+
+	err = template.Load(ctx)
+	return template, err
+}
+
+// InitServerTemplate initializes a new ServerTemplate with the default config and
+// an optional template data json.
+func (c *rcClient) InitServerTemplate(defaultConfig map[string]any,
+	templateDataJSON string) (*ServerTemplate, error) {
+	template, err := newServerTemplate(c, defaultConfig)
+
+	if templateDataJSON != "" && err == nil {
+		template.Set(templateDataJSON)
+	}
+
+	return template, nil
+}
+
+func handleRemoteConfigError(resp *internal.Response) error {
+	err := internal.NewFirebaseError(resp)
+	var p struct {
+		Error string `json:"error"`
+	}
+	json.Unmarshal(resp.Body, &p)
+	if p.Error != "" {
+		err.String = fmt.Sprintf("http error status: %d; reason: %s", resp.Status, p.Error)
+	}
+
+	return err
+}

remoteconfig/remoteconfig_test.go

@@ -0,0 +1,59 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// 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
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package remoteconfig
+
+import (
+	"context"
+	"testing"
+
+	"firebase.google.com/go/v4/internal"
+	"google.golang.org/api/option"
+)
+
+var (
+	client *Client
+
+	testOpts = []option.ClientOption{
+		option.WithTokenSource(&internal.MockTokenSource{AccessToken: "mock-token"}),
+	}
+)
+
+// Test NewClient with valid config
+func TestNewClientSuccess(t *testing.T) {
+	ctx := context.Background()
+	config := &internal.RemoteConfigClientConfig{
+		ProjectID: "test-project",
+		Opts:      testOpts,
+		Version:   "1.2.3",
+	}
+
+	client, err := NewClient(ctx, config)
+	if err != nil {
+		t.Fatalf("NewClient failed: %v", err)
+	}
+	if client == nil {
+		t.Error("NewClient returned nil client")
+	}
+}
+
+// Test NewClient with missing Project ID
+func TestNewClientMissingProjectID(t *testing.T) {
+	ctx := context.Background()
+	config := &internal.RemoteConfigClientConfig{}
+	_, err := NewClient(ctx, config)
+	if err == nil {
+		t.Fatal("NewClient should have failed with missing project ID")
+	}
+}

remoteconfig/server_config.go

@@ -0,0 +1,145 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// 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
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package remoteconfig
+
+import (
+	"strconv"
+	"strings"
+)
+
+// ValueSource represents the source of a value
+type ValueSource int
+
+// Constants for value source
+const (
+	sourceUnspecified ValueSource = iota
+	Static                        // Static represents a statically defined value.
+	Remote                        // Default represents a default value.
+	Default                       // Remote represents a value fetched from a remote source.
+)
+
+// Value defines the interface for configuration values.
+type value struct {
+	source ValueSource
+	value  string
+}
+
+// Default Values for config parameters.
+const (
+	DefaultValueForBoolean = false
+	DefaultValueForString  = ""
+	DefaultValueForNumber  = 0
+)
+
+var booleanTruthyValues = []string{"1", "true", "t", "yes", "y", "on"}
+
+// ServerConfig is the implementation of the ServerConfig interface.
+type ServerConfig struct {
+	ConfigValues map[string]value
+}
+
+// NewServerConfig creates a new ServerConfig instance.
+func NewServerConfig(configValues map[string]value) *ServerConfig {
+	return &ServerConfig{ConfigValues: configValues}
+}
+
+// GetBoolean returns the boolean value associated with the given key.
+func (s *ServerConfig) GetBoolean(key string) bool {
+	return s.getValue(key).asBoolean()
+}
+
+// GetInt returns the integer value associated with the given key.
+func (s *ServerConfig) GetInt(key string) int {
+	return s.getValue(key).asInt()
+}
+
+// GetFloat returns the float value associated with the given key.
+func (s *ServerConfig) GetFloat(key string) float64 {
+	return s.getValue(key).asFloat()
+}
+
+// GetString returns the string value associated with the given key.
+func (s *ServerConfig) GetString(key string) string {
+	return s.getValue(key).asString()
+}
+
+// GetValueSource returns the source of the value.
+func (s *ServerConfig) GetValueSource(key string) ValueSource {
+	return s.getValue(key).source
+}
+
+// getValue returns the value associated with the given key.
+func (s *ServerConfig) getValue(key string) *value {
+	if val, ok := s.ConfigValues[key]; ok {
+		return &val
+	}
+	return newValue(Static, "")
+}
+
+// newValue creates a new value instance.
+func newValue(source ValueSource, customValue string) *value {
+	if customValue == "" {
+		customValue = DefaultValueForString
+	}
+	return &value{source: source, value: customValue}
+}
+
+// asString returns the value as a string.
+func (v *value) asString() string {
+	return v.value
+}
+
+// asBoolean returns the value as a boolean.
+func (v *value) asBoolean() bool {
+	if v.source == Static {
+		return DefaultValueForBoolean
+	}
+
+	for _, truthyValue := range booleanTruthyValues {
+		if strings.ToLower(v.value) == truthyValue {
+			return true
+		}
+	}
+
+	return false
+}
+
+// asInt returns the value as an integer.
+func (v *value) asInt() int {
+	if v.source == Static {
+		return DefaultValueForNumber
+	}
+	num, err := strconv.Atoi(v.value)
+
+	if err != nil {
+		return DefaultValueForNumber
+	}
+
+	return num
+}
+
+// asFloat returns the value as an integer.
+func (v *value) asFloat() float64 {
+	if v.source == Static {
+		return DefaultValueForNumber
+	}
+	num, err := strconv.ParseFloat(v.value, 64)
+
+	if err != nil {
+		return DefaultValueForNumber
+	}
+
+	return num
+}