feat: database as plugin

cli/list.go

@@ -14,7 +14,7 @@ var listCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		proxy := getProxy(func() (npmproxy.Options, error) {
 			return npmproxy.Options{
-				RedisPrefix: persistentOptions.RedisPrefix,
+				DatabasePrefix: persistentOptions.RedisPrefix,
 			}, nil
 		})
 

cli/main.go

@@ -27,11 +27,13 @@ func init() {
 
 func getProxy(getOptions func() (npmproxy.Options, error)) *npmproxy.Proxy {
 	return &npmproxy.Proxy{
-		RedisClient: redis.NewClient(&redis.Options{
+		Database: npmproxy.DatabaseRedis{
-			Addr:     persistentOptions.RedisAddress,
+			Client: redis.NewClient(&redis.Options{
-			DB:       persistentOptions.RedisDatabase,
+				Addr:     persistentOptions.RedisAddress,
-			Password: persistentOptions.RedisPassword,
+				DB:       persistentOptions.RedisDatabase,
-		}),
+				Password: persistentOptions.RedisPassword,
+			}),
+		},
 		HttpClient: &http.Client{
 			Transport: http.DefaultTransport,
 		},

cli/purge.go

@@ -12,7 +12,7 @@ var purgeCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		proxy := getProxy(func() (npmproxy.Options, error) {
 			return npmproxy.Options{
-				RedisPrefix: persistentOptions.RedisPrefix,
+				DatabasePrefix: persistentOptions.RedisPrefix,
 			}, nil
 		})
 

cli/root.go

@@ -31,8 +31,8 @@ func init() {
 func run(cmd *cobra.Command, args []string) {
 	proxy := getProxy(func() (npmproxy.Options, error) {
 		return npmproxy.Options{
-			RedisPrefix:        persistentOptions.RedisPrefix,
+			DatabasePrefix:     persistentOptions.RedisPrefix,
-			RedisExpireTimeout: time.Duration(rootOptions.CacheTTL) * time.Second,
+			DatabaseExpiration: time.Duration(rootOptions.CacheTTL) * time.Second,
 			UpstreamAddress:    rootOptions.UpstreamAddress,
 		}, nil
 	})

example/main.go

@@ -10,16 +10,18 @@ import (
 
 func main() {
 	proxy := npmproxy.Proxy{
-		RedisClient: redis.NewClient(&redis.Options{
+		Database: npmproxy.DatabaseRedis{
-			Addr:     "localhost:6379",
+			Client: redis.NewClient(&redis.Options{
-			DB:       0,
+				Addr:     "localhost:6379",
-			Password: "",
+				DB:       0,
-		}),
+				Password: "",
+			}),
+		},
 		HttpClient: &http.Client{},
 		GetOptions: func() (npmproxy.Options, error) {
 			return npmproxy.Options{
-				RedisPrefix:        "ncp-",
+				DatabasePrefix:     "ncp-",
-				RedisExpireTimeout: 1 * time.Hour,
+				DatabaseExpiration: 1 * time.Hour,
 				UpstreamAddress:    "https://registry.npmjs.org",
 			}, nil
 		},

proxy/cache.go

@@ -13,8 +13,8 @@ func (proxy Proxy) GetMetadata(name string, originalPath string, header http.Hea
 		return nil, err
 	}
 
-	// get package from redis
+	// get package from database
-	pkg, err := proxy.RedisClient.Get(options.RedisPrefix + name).Result()
+	pkg, err := proxy.Database.Get(options.DatabasePrefix + name)
 
 	// either package doesn't exist or there's some other problem
 	if err != nil {
@@ -50,11 +50,11 @@ func (proxy Proxy) GetMetadata(name string, originalPath string, header http.Hea
 		pkg = string(body)
 
 		// save to redis
-		_, err = proxy.RedisClient.Set(
+		err = proxy.Database.Set(
-			options.RedisPrefix+name,
+			options.DatabasePrefix+name,
 			pkg,
-			options.RedisExpireTimeout,
+			options.DatabaseExpiration,
-		).Result()
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -74,14 +74,14 @@ func (proxy Proxy) ListMetadata() ([]string, error) {
 		return nil, err
 	}
 
-	metadata, err := proxy.RedisClient.Keys(options.RedisPrefix + "*").Result()
+	metadata, err := proxy.Database.Keys(options.DatabasePrefix)
 	if err != nil {
 		return nil, err
 	}
 
 	deprefixedMetadata := make([]string, 0)
 	for _, record := range metadata {
-		deprefixedMetadata = append(deprefixedMetadata, strings.Replace(record, options.RedisPrefix, "", 1))
+		deprefixedMetadata = append(deprefixedMetadata, strings.Replace(record, options.DatabasePrefix, "", 1))
 	}
 
 	return deprefixedMetadata, nil
@@ -94,13 +94,13 @@ func (proxy Proxy) PurgeMetadata() error {
 		return err
 	}
 
-	metadata, err := proxy.RedisClient.Keys(options.RedisPrefix + "*").Result()
+	metadata, err := proxy.Database.Keys(options.DatabasePrefix)
 	if err != nil {
 		return err
 	}
 
 	for _, record := range metadata {
-		_, err := proxy.RedisClient.Del(record).Result()
+		err := proxy.Database.Delete(record)
 		if err != nil {
 			return err
 		}

proxy/database_redis.go

@@ -0,0 +1,31 @@
+package proxy
+
+import (
+	"time"
+
+	"github.com/go-redis/redis"
+)
+
+type DatabaseRedis struct {
+	Client *redis.Client
+}
+
+func (db DatabaseRedis) Get(key string) (string, error) {
+	return db.Client.Get(key).Result()
+}
+
+func (db DatabaseRedis) Set(key string, value string, expiration time.Duration) error {
+	return db.Client.Set(key, value, expiration).Err()
+}
+
+func (db DatabaseRedis) Delete(key string) error {
+	return db.Client.Del(key).Err()
+}
+
+func (db DatabaseRedis) Keys(prefix string) ([]string, error) {
+	return db.Client.Keys(prefix + "*").Result()
+}
+
+func (db DatabaseRedis) Health() error {
+	return db.Client.Ping().Err()
+}

proxy/main.go

@@ -3,19 +3,25 @@ package proxy
 import (
 	"net/http"
 	"time"
-
-	"github.com/go-redis/redis"
 )
 
 type Proxy struct {
-	RedisClient *redis.Client
+	Database   Database
-	HttpClient  *http.Client
+	HttpClient *http.Client
 
 	GetOptions func() (Options, error)
 }
 
 type Options struct {
-	RedisPrefix        string
+	DatabasePrefix     string
-	RedisExpireTimeout time.Duration
+	DatabaseExpiration time.Duration
 	UpstreamAddress    string
 }
+
+type Database interface {
+	Get(key string) (string, error)
+	Set(key string, value string, ttl time.Duration) error
+	Delete(key string) error
+	Keys(prefix string) ([]string, error)
+	Health() error
+}

proxy/server.go

@@ -52,7 +52,7 @@ func (proxy Proxy) NoRouteHandler(c *gin.Context) {
 	// } else
 
 	if c.Request.URL.Path == "/" {
-		_, err := proxy.RedisClient.Ping().Result()
+		err := proxy.Database.Health()
 
 		if err != nil {
 			c.AbortWithStatusJSON(503, err)

readme.md

@@ -28,7 +28,7 @@ Start proxy server.
 | `--cache-ttl <timeout>`       | `CACHE_TTL`        | `3600`                       | Cache expiration timeout in seconds |
 | `--redis-address <address>`   | `REDIS_ADDRESS`    | `http://localhost:6379`      | Redis address                       |
 | `--redis-database <database>` | `REDIS_DATABASE`   | `0`                          | Redis database                      |
-| `--redis-password <password>` | `REDIS_PASSWORD`       | -                            | Redis password                      |
+| `--redis-password <password>` | `REDIS_PASSWORD`   | -                            | Redis password                      |
 | `--redis-prefix <prefix>`     | `REDIS_PREFIX`     | `ncp-`                       | Redis keys prefix                   |
 
 ### `ncp list`
@@ -54,16 +54,16 @@ import (
 
 func main() {
 	proxy := npmproxy.Proxy{
-		RedisClient: redis.NewClient(&redis.Options{
+		Database: npmproxy.DatabaseRedis{
-			Addr:     "localhost:6379",
+			Client: redis.NewClient(&redis.Options{
-			DB:       0,
+				Addr:     "localhost:6379",
-			Password: "",
+			}),
-		}),
+		},
 		HttpClient: &http.Client{},
 		GetOptions: func() (npmproxy.Options, error) {
 			return npmproxy.Options{
-				RedisPrefix:        "ncp-",
+				DatabasePrefix:     "ncp-",
-				RedisExpireTimeout: 1 * time.Hour,
+				DatabaseExpiration: 1 * time.Hour,
 				UpstreamAddress:    "https://registry.npmjs.org",
 			}, nil
 		},