Replace current config with dynamic config (#798)

* get config api

* fix mock

* fix types for transfrom-config test

* use dynamic config

* fix docker env names

* use context for pages

* replace useQuery with page context in DomainsPageFiltersClusterName

* remove extra Fragment

Author: Assem-Hafez

.docker_env

@@ -1,7 +1,7 @@
 NODE_ENV=development
-NEXT_PUBLIC_CADENCE_CLUSTERS_NAMES=default
+CADENCE_CLUSTERS_NAMES=default
 CADENCE_GRPC_PEERS="127.0.0.1:7833"
-NEXT_PUBLIC_CADENCE_GRPC_SERVICES_NAMES=cadence-frontend
+CADENCE_GRPC_SERVICES_NAMES=cadence-frontend
 CADENCE_WEB_PORT=8088
 CADENCE_EXTERNAL_SCRIPTS=""
 CADENCE_ADMIN_SECURITY_TOKEN=""

src/config/auth/admin-security-token.ts

@@ -1,23 +1,28 @@
 import 'server-only';
 
 import type {
-  ConfigAsyncResolverDefinition,
   ConfigEnvDefinition,
   ConfigSyncResolverDefinition,
 } from '../../utils/config/config.types';
 
+import clusters from './resolvers/clusters';
+import clustersPublic from './resolvers/clusters-public';
+import { type PublicClustersConfigs } from './resolvers/clusters-public.types';
+import { type ClustersConfigs } from './resolvers/clusters.types';
+
 const dynamicConfigs: {
   CADENCE_WEB_PORT: ConfigEnvDefinition;
   ADMIN_SECURITY_TOKEN: ConfigEnvDefinition;
-  GRPC_PROTO_DIR_BASE_PATH: ConfigEnvDefinition;
-  GRPC_SERVICES_NAMES: ConfigEnvDefinition<true>;
-  DYNAMIC: ConfigAsyncResolverDefinition<undefined, number, 'serverStart'>;
-  DYNAMIC_WITH_ARG: ConfigAsyncResolverDefinition<number, number, 'request'>;
-  COMPUTED: ConfigSyncResolverDefinition<undefined, [string], 'request'>;
-  COMPUTED_WITH_ARG: ConfigSyncResolverDefinition<
-    [string],
-    [string],
-    'request'
+  CLUSTERS: ConfigSyncResolverDefinition<
+    undefined,
+    ClustersConfigs,
+    'serverStart'
+  >;
+  CLUSTERS_PUBLIC: ConfigSyncResolverDefinition<
+    undefined,
+    PublicClustersConfigs,
+    'serverStart',
+    true
   >;
 } = {
   CADENCE_WEB_PORT: {
@@ -29,39 +34,14 @@ const dynamicConfigs: {
     env: 'CADENCE_ADMIN_SECURITY_TOKEN',
     default: '',
   },
-  GRPC_PROTO_DIR_BASE_PATH: {
-    env: 'GRPC_PROTO_DIR_BASE_PATH',
-    default: 'src/__generated__/idl/proto',
-  },
-  GRPC_SERVICES_NAMES: {
-    env: 'NEXT_PUBLIC_CADENCE_GRPC_SERVICES_NAMES',
-    default: 'cadence-frontend',
-    isPublic: true,
-  },
-  // For testing purposes
-  DYNAMIC: {
-    resolver: async () => {
-      return 1;
-    },
+  CLUSTERS: {
+    resolver: clusters,
     evaluateOn: 'serverStart',
   },
-  DYNAMIC_WITH_ARG: {
-    resolver: async (value: number) => {
-      return value;
-    },
-    evaluateOn: 'request',
-  },
-  COMPUTED: {
-    resolver: () => {
-      return ['value'];
-    },
-    evaluateOn: 'request',
-  },
-  COMPUTED_WITH_ARG: {
-    resolver: (value: [string]) => {
-      return value;
-    },
-    evaluateOn: 'request',
+  CLUSTERS_PUBLIC: {
+    resolver: clustersPublic,
+    evaluateOn: 'serverStart',
+    isPublic: true,
   },
 } as const;
 

src/config/clusters/cluster-names.config.ts

@@ -0,0 +1,10 @@
+import clusters from './clusters';
+
+export default function clustersPublic() {
+  const originalClusters = clusters();
+  return originalClusters.map((cluster) => {
+    return {
+      clusterName: cluster.clusterName,
+    };
+  });
+}

src/config/clusters/clusters.config.ts

@@ -0,0 +1,5 @@
+import { type ClusterConfig } from './clusters.types';
+
+export type PublicClusterConfig = Pick<ClusterConfig, 'clusterName'>;
+
+export type PublicClustersConfigs = Array<PublicClusterConfig>;

src/config/dynamic/dynamic.config.ts

@@ -0,0 +1,40 @@
+import { type ClusterConfig } from './clusters.types';
+
+const getArrayFromCommaSeparatedString = (
+  str: string | undefined,
+  defaultValue: string[]
+) => {
+  return str?.trim()
+    ? str
+        .split(',')
+        .filter((c) => Boolean(c.trim()))
+        .map((c) => c.trim())
+    : defaultValue;
+};
+
+export default function clusters() {
+  const clusterNames = getArrayFromCommaSeparatedString(
+    process.env.CADENCE_CLUSTERS_NAMES,
+    ['default']
+  );
+  const peers = getArrayFromCommaSeparatedString(
+    process.env.CADENCE_GRPC_PEERS,
+    ['127.0.0.1:7933']
+  );
+
+  const serviceNames = getArrayFromCommaSeparatedString(
+    process.env.CADENCE_GRPC_SERVICES_NAMES,
+    ['cadence-frontend']
+  );
+
+  return clusterNames.map((clusterName, i) => {
+    return {
+      clusterName: clusterName,
+      grpc: {
+        peer: peers[i],
+        serviceName: serviceNames[i],
+        metadata: {},
+      },
+    } satisfies ClusterConfig;
+  });
+}

src/config/dynamic/resolvers/clusters-public.ts

@@ -2,23 +2,27 @@ import { z } from 'zod';
 
 import { type ResolverSchemas } from '../../../../utils/config/config.types';
 
-// Example usage:
 const resolverSchemas: ResolverSchemas = {
-  COMPUTED: {
+  CLUSTERS: {
     args: z.undefined(),
-    returnType: z.tuple([z.string()]),
+    returnType: z.array(
+      z.object({
+        clusterName: z.string(),
+        grpc: z.object({
+          serviceName: z.string(),
+          metadata: z.record(z.string(), z.string()).optional(),
+          peer: z.string(),
+        }),
+      })
+    ),
   },
-  COMPUTED_WITH_ARG: {
-    args: z.tuple([z.string()]),
-    returnType: z.tuple([z.string()]),
-  },
-  DYNAMIC: {
+  CLUSTERS_PUBLIC: {
     args: z.undefined(),
-    returnType: z.number(),
-  },
-  DYNAMIC_WITH_ARG: {
-    args: z.number(),
-    returnType: z.number(),
+    returnType: z.array(
+      z.object({
+        clusterName: z.string(),
+      })
+    ),
   },
 };