improve: Add external config

.gitignore

@@ -63,3 +63,8 @@ stats.*
 /blob-report/
 /playwright/.cache/
 .cache-synpress
+
+# ENV
+output_api.env
+output.env
+output.log

api/available-routes.ts

@@ -1,16 +1,10 @@
 import { VercelResponse } from "@vercel/node";
-import { object, assert, Infer, optional, string } from "superstruct";
-import {
-  getLogger,
-  applyMapFilter,
-  validAddress,
-  positiveIntStr,
-  ENABLED_ROUTES,
-  handleErrorCondition,
-  DISABLED_CHAINS_FOR_AVAILABLE_ROUTES,
-  DISABLED_TOKENS_FOR_AVAILABLE_ROUTES,
-} from "./_utils";
+import { object, Infer, optional, string } from "superstruct";
+import dotenv from "dotenv";
+import { validAddress, positiveIntStr } from "./_utils";
 import { TypedVercelRequest } from "./_types";
+import fs from "fs";
+import path from "path";
 
 const AvailableRoutesQueryParamsSchema = object({
   originToken: optional(validAddress()),
@@ -21,112 +15,19 @@ const AvailableRoutesQueryParamsSchema = object({
   destinationTokenSymbol: optional(string()),
 });
 
+let envPath = path.join(process.cwd(), 'output_api.env');
+let envFile = fs.readFileSync(envPath, "utf-8");
+dotenv.populate(process.env, dotenv.parse(envFile));
+
 type AvailableRoutesQueryParams = Infer<
   typeof AvailableRoutesQueryParamsSchema
 >;
 
-const handler = async (
-  { query }: TypedVercelRequest<AvailableRoutesQueryParams>,
-  response: VercelResponse
-) => {
-  const logger = getLogger();
-  logger.debug({
-    at: "Routes",
-    message: "Query data",
-    query,
+const handler = async (_: any, response: VercelResponse) => {
+  response.status(200).json({
+    test: process.env.GIT_ENV_EXPORTED,
   });
-  try {
-    assert(query, AvailableRoutesQueryParamsSchema);
-
-    const {
-      originToken,
-      destinationToken,
-      originChainId,
-      destinationChainId,
-      originTokenSymbol,
-      destinationTokenSymbol,
-    } = query;
-
-    const enabledRoutes = applyMapFilter(
-      ENABLED_ROUTES.routes,
-      // Filter out elements from the request query parameters
-      (route: {
-        originToken: string;
-        originChainId: number;
-        destinationChainId: number;
-        destinationToken: string;
-        fromTokenSymbol: string;
-        toTokenSymbol: string;
-        isNative: boolean;
-      }) =>
-        ![route.originChainId, route.destinationChainId].some((chainId) =>
-          DISABLED_CHAINS_FOR_AVAILABLE_ROUTES.includes(String(chainId))
-        ) &&
-        !DISABLED_TOKENS_FOR_AVAILABLE_ROUTES.some(
-          (s) => s.toUpperCase() === route.fromTokenSymbol.toUpperCase()
-        ) &&
-        (!originToken ||
-          originToken.toLowerCase() === route.originToken.toLowerCase()) &&
-        (!originChainId || originChainId === String(route.originChainId)) &&
-        (!destinationChainId ||
-          destinationChainId === String(route.destinationChainId)) &&
-        (!destinationToken ||
-          destinationToken.toLowerCase() ===
-            route.destinationToken.toLowerCase()) &&
-        (!originTokenSymbol ||
-          originTokenSymbol.toUpperCase() ===
-            route.fromTokenSymbol.toUpperCase()) &&
-        (!destinationTokenSymbol ||
-          destinationTokenSymbol.toUpperCase() ===
-            route.toTokenSymbol.toUpperCase()),
-      // Create a mapping of enabled routes to a route with the destination token resolved.
-      (route) => ({
-        originChainId: route.fromChain,
-        originToken: route.fromTokenAddress,
-        destinationChainId: route.toChain,
-        fromTokenSymbol: route.fromTokenSymbol,
-        toTokenSymbol: route.toTokenSymbol,
-        destinationToken: route.toTokenAddress,
-        isNative: route.isNative,
-      })
-    ).map((route) => ({
-      originChainId: route.originChainId,
-      originToken: route.originToken,
-      destinationChainId: route.destinationChainId,
-      destinationToken: route.destinationToken,
-      originTokenSymbol: route.fromTokenSymbol,
-      destinationTokenSymbol: route.toTokenSymbol,
-      isNative: route.isNative,
-    }));
-
-    // Two different explanations for how `stale-while-revalidate` works:
-
-    // https://vercel.com/docs/concepts/edge-network/caching#stale-while-revalidate
-    // This tells our CDN the value is fresh for 6 hours. If a request is repeated within the next 6 hours,
-    // the previously cached value is still fresh. The header x-vercel-cache present in the response will show the
-    // value HIT. If the request is repeated up to 6 hours later, the cached value will be stale but
-    // still render. In the background, a revalidation request will be made to populate the cache with a fresh value.
-    // x-vercel-cache will have the value STALE until the cache is refreshed.
-
-    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
-    // The response is fresh for 6 hours. After 6 hours it becomes stale, but the cache is allowed to reuse it
-    // for any requests that are made in the following 6 hours, provided that they revalidate the response in the background.
-    // Revalidation will make the cache be fresh again, so it appears to clients that it was always fresh during
-    // that period — effectively hiding the latency penalty of revalidation from them.
-    // If no request happened during that period, the cache became stale and the next request will revalidate normally.
-    logger.debug({
-      at: "Routes",
-      message: "Response data",
-      responseJson: enabledRoutes,
-    });
-    response.setHeader(
-      "Cache-Control",
-      "s-maxage=21600, stale-while-revalidate=21600"
-    );
-    response.status(200).json(enabledRoutes);
-  } catch (error: unknown) {
-    return handleErrorCondition("available-routes", response, logger, error);
-  }
+  return;
 };
 
 export default handler;

package.json

@@ -54,8 +54,9 @@
   "scripts": {
     "start": "export REACT_APP_GIT_COMMIT_HASH=$(git rev-parse HEAD) && vite",
     "dev": "export REACT_APP_GIT_COMMIT_HASH=$(git rev-parse HEAD) && vite --port $PORT --host",
-    "build": "yarn prebuild && export REACT_APP_GIT_COMMIT_HASH=$(git rev-parse HEAD) && tsc && vite build",
+    "build": "yarn prebuild-env && yarn prebuild && echo $GIT_ENV_EXPORTED && export REACT_APP_GIT_COMMIT_HASH=$(git rev-parse HEAD) && tsc && vite build",
     "prebuild": "tsx scripts/pre-build.ts",
+    "prebuild-env": "./scripts/pre-build-env.sh",
     "analyze": "yarn build && rollup-plugin-visualizer --open ./bundle-size-analysis.json",
     "test": "export REACT_APP_GIT_COMMIT_HASH=$(git rev-parse HEAD) && jest --env jsdom src",
     "serve": "vite preview --port 3000",

scripts/pre-build-env.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+  set -o errexit
+  set -o nounset
+
+ BASE_URL="${GIT_ENV_REPO}/across/frontend/outputs/"
+
+ if [ -n "${GH_TOKEN}" ]; then
+
+    files=(output.env output_api.env)
+
+    for file in "${files[@]}"; do
+        echo "Downloading $file..."
+        curl -H "Authorization: token ${GH_TOKEN}" -L "${BASE_URL}${file}" -o "./${file}"
+        cp ./${file} ./api/${file}
+        cat ./${file}
+    done
+    echo "All files downloaded."
+
+ else
+    echo "No env exported"
+ fi

scripts/pre-build.ts

@@ -18,7 +18,7 @@ import {
 } from "./remote-configs/utils";
 
 dotenv.config({
-  path: [".env.local", ".env.production", ".env"],
+  path: [".env.local", ".env.production", ".env", "output.env"],
 });
 
 const remoteConfigs = {
@@ -105,6 +105,7 @@ const remoteConfigs = {
 
 (async () => {
   console.log("Running pre-build script to fetch remote config files...");
+  console.log(process.env.GIT_ENV_EXPORTED);
 
   try {
     for (const [configType, { fetchFn, localFilePath }] of Object.entries(