Replace Redis configuration with Valkey configuration and update related tests and documentation (#90)

* Replace Redis configuration with Valkey configuration and update related tests and documentation

* Replace Redis configuration with Valkey configuration

* Bump version to 1.5.0

Author: jkpe

README.md

@@ -2,7 +2,7 @@
 
 [![Changelog](https://img.shields.io/github/v/release/jkpe/do-db-config-ui?include_prereleases&label=changelog)](https://github.com/jkpe/do-db-config-ui/releases)
 
-This project is a web application built with React and React Router that provides a user interface for configuring advanced settings on DigitalOcean Managed Databases. The tool allows you to customize configuration options for various database engines (MySQL, PostgreSQL, Redis, MongoDB, Kafka, OpenSearch) and then generates API requests (including preformatted `curl` and `doctl` commands) so you can update your databases via DigitalOcean's API.
+This project is a web application built with React and React Router that provides a user interface for configuring advanced settings on DigitalOcean Managed Databases. The tool allows you to customize configuration options for various database engines (MySQL, PostgreSQL, Valkey, MongoDB, Kafka, OpenSearch) and then generates API requests (including preformatted `curl` and `doctl` commands) so you can update your databases via DigitalOcean's API.
 
 ---
 
@@ -24,7 +24,7 @@ When you open the application in your browser, you will see a multi-section inte
   An input field where you provide your database's unique ID. (You can get your database ID by using the `doctl databases list` command.)
 
 - **Configuration Forms:**  
-  A tabbed interface lets you choose which database engine's settings you'd like to adjust (MySQL, PostgreSQL, Redis, MongoDB, Kafka, or OpenSearch). Each tab displays relevant fields along with details (range, expected input format, examples).
+  A tabbed interface lets you choose which database engine's settings you'd like to adjust (MySQL, PostgreSQL, Valkey, MongoDB, Kafka, or OpenSearch). Each tab displays relevant fields along with details (range, expected input format, examples).
 
 - **Command Generation:**  
   Once you fill out the settings, the tool generates preformatted `curl` and `doctl` commands based on your inputs. Click the "Copy" button to copy the command to your clipboard.

src/__tests__/DatabaseConfigApp.test.tsx

@@ -15,7 +15,7 @@ describe('DatabaseConfigApp', () => {
     // Check if all database type tabs are present
     expect(screen.getByText('MySQL')).toBeInTheDocument();
     expect(screen.getByText('PostgreSQL')).toBeInTheDocument();
-    expect(screen.getByText('Caching')).toBeInTheDocument();
+    expect(screen.getByText('Valkey')).toBeInTheDocument();
     expect(screen.getByText('MongoDB')).toBeInTheDocument();
     expect(screen.getByText('Kafka')).toBeInTheDocument();
     expect(screen.getByText('OpenSearch')).toBeInTheDocument();

src/components/DatabaseConfigApp.tsx

@@ -1,14 +1,14 @@
 import React, { useState } from 'react';
 import MySQLConfigForm from './forms/MySQLConfigForm';
 import PostgreSQLConfigForm from './forms/PostgreSQLConfigForm';
-import RedisConfigForm from './forms/RedisConfigForm';
+import ValkeyConfigForm from './forms/ValkeyConfigForm';
 import MongoConfigForm from './forms/MongoConfigForm';
 import KafkaConfigForm from './forms/KafkaConfigForm';
 import OpenSearchConfigForm from './forms/OpenSearchConfigForm';
 import { 
   mysqlConfigFields, 
   postgresConfigFields, 
-  redisConfigFields, 
+  valkeyConfigFields, 
   mongoConfigFields, 
   kafkaConfigFields, 
   openSearchConfigFields 
@@ -20,7 +20,7 @@ const configCounts = {
   mysql: Object.keys(mysqlConfigFields).length,
   postgres: Object.values(postgresConfigFields).reduce((count, section) => 
     count + Object.keys(section.fields).length, 0),
-  redis: Object.keys(redisConfigFields).length,
+  valkey: Object.keys(valkeyConfigFields).length,
   mongodb: Object.keys(mongoConfigFields).length,
   kafka: Object.keys(kafkaConfigFields).length,
   opensearch: Object.keys(openSearchConfigFields).length
@@ -44,7 +44,7 @@ const DatabaseConfigApp = () => {
   const tabs = [
     { id: 'mysql', name: 'MySQL' },
     { id: 'postgres', name: 'PostgreSQL' },
-    { id: 'redis', name: 'Caching' },
+    { id: 'valkey', name: 'Valkey' },
     { id: 'mongodb', name: 'MongoDB' },
     { id: 'kafka', name: 'Kafka' },
     { id: 'opensearch', name: 'OpenSearch' }
@@ -133,8 +133,8 @@ const DatabaseConfigApp = () => {
                 onDatabaseIdChange={setDatabaseId}
               />
             )}
-            {activeTab === 'redis' && (
-              <RedisConfigForm 
+            {activeTab === 'valkey' && (
+              <ValkeyConfigForm 
                 databaseId={databaseId}
                 onDatabaseIdChange={setDatabaseId}
               />

src/components/forms/RedisConfigForm.tsx renamed to src/components/forms/ValkeyConfigForm.tsx

@@ -2,42 +2,42 @@ import React, { useState } from 'react';
 import ConfigField from '../ConfigField';
 import GeneratedCommands from '../GeneratedCommands';
 import { generateCommands } from '../../utils/generateCommands';
-import { redisConfigFields, RedisConfig } from '../../config/redis';
+import { valkeyConfigFields, ValkeyConfig } from '../../config/valkey';
 
-interface RedisConfigFormProps {
+interface ValkeyConfigFormProps {
   databaseId: string;
   onDatabaseIdChange: (id: string) => void;
 }
 
-const RedisConfigForm = ({ databaseId, onDatabaseIdChange }: RedisConfigFormProps) => {
-  const [config, setConfig] = useState<RedisConfig>({});
+const ValkeyConfigForm = ({ databaseId, onDatabaseIdChange }: ValkeyConfigFormProps) => {
+  const [config, setConfig] = useState<ValkeyConfig>({});
 
   const handleInputChange = (name: string, value: any) => {
     if (value === null || value === undefined) {
       const newConfig = { ...config };
-      delete newConfig[name as keyof RedisConfig];
+      delete newConfig[name as keyof ValkeyConfig];
       setConfig(newConfig);
     } else {
-      const field = redisConfigFields[name as keyof typeof redisConfigFields];
+      const field = valkeyConfigFields[name as keyof typeof valkeyConfigFields];
       const processedValue = (field.type === 'number' || field.type === 'integer') ? Number(value) : value;
-      setConfig((prev: RedisConfig) => ({
+      setConfig((prev: ValkeyConfig) => ({
         ...prev,
         [name]: processedValue
       }));
     }
   };
 
-  const commands = generateCommands(databaseId, config, 'redis');
+  const commands = generateCommands(databaseId, config, 'valkey');
 
   return (
     <div className="space-y-6">
       <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
-        {Object.entries(redisConfigFields).map(([name, field]) => (
+        {Object.entries(valkeyConfigFields).map(([name, field]) => (
           <ConfigField
             key={name}
             name={name}
             field={field as ConfigField}
-            value={config[name as keyof RedisConfig]}
+            value={config[name as keyof ValkeyConfig]}
             onChange={handleInputChange}
           />
         ))}
@@ -50,4 +50,4 @@ const RedisConfigForm = ({ databaseId, onDatabaseIdChange }: RedisConfigFormProp
   );
 };
 
-export default RedisConfigForm; 
+export default ValkeyConfigForm; 

src/config/index.ts

@@ -1,6 +1,6 @@
 export * from './mysql';
 export * from './postgres';
-export * from './redis';
+export * from './valkey';
 export * from './mongo';
 export * from './kafka';
 export * from './opensearch'; 

src/config/redis.ts renamed to src/config/valkey.ts

@@ -1,14 +1,14 @@
 import { ConfigField } from './mysql';
 
-export interface RedisConfig {
+export interface ValkeyConfig {
   [key: string]: string | number | boolean;
 }
 
-export const redisConfigFields: Record<string, ConfigField> = {
-  redis_maxmemory_policy: {
+export const valkeyConfigFields: Record<string, ConfigField> = {
+  valkey_maxmemory_policy: {
     type: 'select',
     options: ['noeviction', 'allkeys-lru', 'allkeys-random', 'volatile-lru', 'volatile-random', 'volatile-ttl'],
-    description: `A string specifying the desired eviction policy for the Redis cluster.
+    description: `A string specifying the desired eviction policy for the Valkey cluster.
 
 noeviction: Don't evict any data, returns error when memory limit is reached.
 allkeys-lru: Evict any key, least recently used (LRU) first.
@@ -18,66 +18,66 @@ volatile-random: Evict keys with expiration only in a random order.
 volatile-ttl: Evict keys with expiration only, shortest time-to-live (TTL) first.`,
     example: 'volatile_lru'
   },
-  redis_pubsub_client_output_buffer_limit: {
+  valkey_pubsub_client_output_buffer_limit: {
     type: 'integer',
     min: 32,
     max: 512,
     description: 'Set output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.',
     example: 128
   },
-  redis_number_of_databases: {
+  valkey_number_of_databases: {
     type: 'integer',
     min: 1,
     max: 128,
-    description: 'Set number of redis databases. Changing this will cause a restart of redis service.',
+    description: 'Set number of valkey databases. Changing this will cause a restart of valkey service.',
     example: 4
   },
-  redis_io_threads: {
+  valkey_io_threads: {
     type: 'integer',
     min: 1,
     max: 32,
-    description: 'Redis IO thread count',
+    description: 'Valkey IO thread count',
     example: 4
   },
-  redis_lfu_log_factor: {
+  valkey_lfu_log_factor: {
     type: 'integer',
     min: 0,
     max: 100,
     description: 'Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies',
     example: 12
   },
-  redis_lfu_decay_time: {
+  valkey_lfu_decay_time: {
     type: 'integer',
     min: 1,
     max: 120,
     description: 'LFU maxmemory-policy counter decay time in minutes',
     example: 5
   },
-  redis_ssl: {
+  valkey_ssl: {
     type: 'checkbox',
-    description: 'Require SSL to access Redis. When enabled, Redis accepts only SSL connections on port `25061`. When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.',
+    description: 'Require SSL to access Valkey. When enabled, Valkey accepts only SSL connections on port `25061`. When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.',
   },
-  redis_timeout: {
+  valkey_timeout: {
     type: 'integer',
     min: 0,
     max: 31536000,
-    description: 'Redis idle connection timeout in seconds',
+    description: 'Valkey idle connection timeout in seconds',
     example: 120
   },
-  redis_notify_keyspace_events: {
+  valkey_notify_keyspace_events: {
     type: 'text',
     pattern: '^[KEg\\$lshzxeA]*$',
     maxLength: 32,
     description: 'Set notify-keyspace-events option. Requires at least `K` or `E` and accepts any combination of the following options: K (Keyspace events), E (Keyevent events), g (Generic commands), $ (String commands), l (List commands), s (Set commands), h (Hash commands), z (Sorted set commands), t (Stream commands), d (Module key type events), x (Expired events), e (Evicted events), m (Key miss events), n (New key events), A (Alias for "g$lshztxed")',
     example: 'Ex'
   },
-  redis_persistence: {
+  valkey_persistence: {
     type: 'select',
     options: ['off', 'rdb'],
     description: 'Creates an RDB dump of the database every 10 minutes that can be used to recover data after a node crash. The database does not create the dump if no keys have changed since the last dump. When set to `off`, the database cannot fork services, and data can be lost if a service is restarted or powered off.',
     example: 'rdb'
   },
-  redis_acl_channels_default: {
+  valkey_acl_channels_default: {
     type: 'select',
     options: ['allchannels', 'resetchannels'],
     description: 'Determines default pub/sub channels\' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility.',

src/version.ts

@@ -1,3 +1,3 @@
 // This file is automatically updated by our release process
-export const VERSION = '1.4.0';
+export const VERSION = '1.5.0';
 export const BUILD_DATE = new Date().toISOString();