Split ENSApi and ENSIndexer

apps/ensapi/.env.local.example

@@ -15,6 +15,16 @@ ENSINDEXER_URL=http://localhost:42069
 # NOTE that ENSApi does NOT need to define DATABASE_SCHEMA, as it is inferred from the connected ENSIndexer's Config.
 DATABASE_URL=postgresql://dbuser:abcd1234@localhost:5432/my_database
 
+# ENSDb: schema name
+# Required. This is a namespace for the tables that the ENSDbClient for ENSApi will apply to read ENSDb data.
+# Must be set to an existing namespace in the connected ENSDb at DATABASE_URL.
+DATABASE_SCHEMA=public
+
+# ENS Namespace Configuration
+# Required. Must be an ENS namespace's Identifier such as mainnet, sepolia, or ens-test-env.
+# (see `@ensnode/datasources` for available options).
+NAMESPACE=mainnet
+
 # ENSApi: RPC Configuration
 # Required. ENSApi requires an HTTP RPC to the connected ENSIndexer's ENS Root Chain, which depends
 # on ENSIndexer's NAMESPACE (ex: mainnet, sepolia, ens-test-env). This ENS Root Chain RPC

apps/ensapi/src/cache/indexing-status.cache.ts

@@ -1,26 +1,21 @@
-import config from "@/config";
-
-import {
-  type CrossChainIndexingStatusSnapshot,
-  ENSNodeClient,
-  IndexingStatusResponseCodes,
-  SWRCache,
-} from "@ensnode/ensnode-sdk";
+import { type CrossChainIndexingStatusSnapshot, SWRCache } from "@ensnode/ensnode-sdk";
 
+import { ensDbClient } from "@/lib/ensdb-client/singleton";
 import { makeLogger } from "@/lib/logger";
 
 const logger = makeLogger("indexing-status.cache");
-const client = new ENSNodeClient({ url: config.ensIndexerUrl });
 
 export const indexingStatusCache = new SWRCache<CrossChainIndexingStatusSnapshot>({
   fn: async (_cachedResult) =>
-    client
-      .indexingStatus() // fetch a new indexing status snapshot
-      .then((response) => {
-        if (response.responseCode !== IndexingStatusResponseCodes.Ok) {
-          // An indexing status response was successfully fetched, but the response code contained within the response was not 'ok'.
+    ensDbClient
+      .getIndexingStatusSnapshot() // get the latest indexing status snapshot
+      .then((snapshot) => {
+        if (snapshot === undefined) {
+          // An indexing status snapshot has not been found in ENSDb yet.
+          // This might happen during application startup, i.e. when ENSDb
+          // has not yet been populated with the first snapshot.
           // Therefore, throw an error to trigger the subsequent `.catch` handler.
-          throw new Error("Received Indexing Status response with responseCode other than 'ok'.");
+          throw new Error("Indexing Status snapshot not found in ENSDb yet.");
         }
 
         logger.info("Fetched Indexing Status to be cached");
@@ -29,10 +24,10 @@ export const indexingStatusCache = new SWRCache<CrossChainIndexingStatusSnapshot
         // Therefore, return it so that this current invocation of `readCache` will:
         // - Replace the currently cached value (if any) with this new value.
         // - Return this non-null value.
-        return response.realtimeProjection.snapshot;
+        return snapshot;
       })
       .catch((error) => {
-        // Either the indexing status snapshot fetch failed, or the indexing status response was not 'ok'.
+        // Either the indexing status snapshot fetch failed, or the indexing status snapshot was not found in ENSDb yet.
         // Therefore, throw an error so that this current invocation of `readCache` will:
         // - Reject the newly fetched response (if any) such that it won't be cached.
         // - Return the most recently cached value from prior invocations, or `null` if no prior invocation successfully cached a value.

apps/ensapi/src/config/config.schema.test.ts

@@ -9,7 +9,7 @@
 } from "@ensnode/ensnode-sdk";
 import type { RpcConfig } from "@ensnode/ensnode-sdk/internal";
 
-import { buildConfigFromEnvironment, buildEnsApiPublicConfig } from "@/config/config.schema";
+import { buildConfigFromEnvironment } from "@/config/config.schema";
 import { ENSApi_DEFAULT_PORT } from "@/config/defaults";
 import type { EnsApiEnvironment } from "@/config/environment";
 import logger from "@/lib/logger";
@@ -64,7 +64,7 @@
       json: () => Promise.resolve(serializeENSIndexerPublicConfig(ENSINDEXER_PUBLIC_CONFIG)),
     });
 
     await expect(buildConfigFromEnvironment(BASE_ENV)).resolves.toStrictEqual({
       port: ENSApi_DEFAULT_PORT,
       databaseUrl: BASE_ENV.DATABASE_URL,
       ensIndexerUrl: new URL(BASE_ENV.ENSINDEXER_URL),
@@ -99,7 +99,7 @@
       CUSTOM_REFERRAL_PROGRAM_EDITIONS: customUrl,
     });
 
     expect(config.customReferralProgramEditionConfigSetUrl).toEqual(new URL(customUrl));
   });
 
   describe("Useful error messages", () => {
@@ -130,7 +130,7 @@
         CUSTOM_REFERRAL_PROGRAM_EDITIONS: "not-a-url",
       });
 
       expect(logger.error).toHaveBeenCalledWith(
         expect.stringContaining("CUSTOM_REFERRAL_PROGRAM_EDITIONS is not a valid URL: not-a-url"),
       );
       expect(process.exit).toHaveBeenCalledWith(1);
@@ -147,7 +147,7 @@
         QUICKNODE_API_KEY: "my-api-key",
       });
 
       expect(logger.error).toHaveBeenCalledWith(
         new Error(
           "Use of the QUICKNODE_API_KEY environment variable requires use of the QUICKNODE_ENDPOINT_NAME environment variable as well.",
         ),
@@ -167,7 +167,7 @@
         QUICKNODE_ENDPOINT_NAME: "my-endpoint-name",
       });
 
       expect(logger.error).toHaveBeenCalledWith(
         new Error(
           "Use of the QUICKNODE_ENDPOINT_NAME environment variable requires use of the QUICKNODE_API_KEY environment variable as well.",
         ),
@@ -177,94 +177,3 @@
     });
   });
 });
-
-describe("buildEnsApiPublicConfig", () => {
-  it("returns a valid ENSApi public config with correct structure", () => {
-    const mockConfig = {
-      port: ENSApi_DEFAULT_PORT,
-      databaseUrl: BASE_ENV.DATABASE_URL,
-      ensIndexerUrl: new URL(BASE_ENV.ENSINDEXER_URL),
-      ensIndexerPublicConfig: ENSINDEXER_PUBLIC_CONFIG,
-      namespace: ENSINDEXER_PUBLIC_CONFIG.namespace,
-      databaseSchemaName: ENSINDEXER_PUBLIC_CONFIG.databaseSchemaName,
-      rpcConfigs: new Map([
-        [
-          1,
-          {
-            httpRPCs: [new URL(VALID_RPC_URL)],
-            websocketRPC: undefined,
-          } satisfies RpcConfig,
-        ],
-      ]),
-      customReferralProgramEditionConfigSetUrl: undefined,
-    };
-
-    const result = buildEnsApiPublicConfig(mockConfig);
-
-    expect(result).toStrictEqual({
-      version: packageJson.version,
-      theGraphFallback: {
-        canFallback: false,
-        reason: "not-subgraph-compatible",
-      },
-      ensIndexerPublicConfig: ENSINDEXER_PUBLIC_CONFIG,
-    });
-  });
-
-  it("preserves the complete ENSIndexer public config structure", () => {
-    const mockConfig = {
-      port: ENSApi_DEFAULT_PORT,
-      databaseUrl: BASE_ENV.DATABASE_URL,
-      ensIndexerUrl: new URL(BASE_ENV.ENSINDEXER_URL),
-      ensIndexerPublicConfig: ENSINDEXER_PUBLIC_CONFIG,
-      namespace: ENSINDEXER_PUBLIC_CONFIG.namespace,
-      databaseSchemaName: ENSINDEXER_PUBLIC_CONFIG.databaseSchemaName,
-      rpcConfigs: new Map(),
-      customReferralProgramEditionConfigSetUrl: undefined,
-    };
-
-    const result = buildEnsApiPublicConfig(mockConfig);
-
-    // Verify that all ENSIndexer public config fields are preserved
-    expect(result.ensIndexerPublicConfig.namespace).toBe(ENSINDEXER_PUBLIC_CONFIG.namespace);
-    expect(result.ensIndexerPublicConfig.plugins).toEqual(ENSINDEXER_PUBLIC_CONFIG.plugins);
-    expect(result.ensIndexerPublicConfig.versionInfo).toEqual(ENSINDEXER_PUBLIC_CONFIG.versionInfo);
-    expect(result.ensIndexerPublicConfig.indexedChainIds).toEqual(
-      ENSINDEXER_PUBLIC_CONFIG.indexedChainIds,
-    );
-    expect(result.ensIndexerPublicConfig.isSubgraphCompatible).toBe(
-      ENSINDEXER_PUBLIC_CONFIG.isSubgraphCompatible,
-    );
-    expect(result.ensIndexerPublicConfig.labelSet).toEqual(ENSINDEXER_PUBLIC_CONFIG.labelSet);
-    expect(result.ensIndexerPublicConfig.databaseSchemaName).toBe(
-      ENSINDEXER_PUBLIC_CONFIG.databaseSchemaName,
-    );
-  });
-
-  it("includes the theGraphFallback and redacts api key", () => {
-    const mockConfig = {
-      port: ENSApi_DEFAULT_PORT,
-      databaseUrl: BASE_ENV.DATABASE_URL,
-      ensIndexerUrl: new URL(BASE_ENV.ENSINDEXER_URL),
-      ensIndexerPublicConfig: {
-        ...ENSINDEXER_PUBLIC_CONFIG,
-        plugins: ["subgraph"],
-        isSubgraphCompatible: true,
-      },
-      namespace: ENSINDEXER_PUBLIC_CONFIG.namespace,
-      databaseSchemaName: ENSINDEXER_PUBLIC_CONFIG.databaseSchemaName,
-      rpcConfigs: new Map(),
-      customReferralProgramEditionConfigSetUrl: undefined,
-      theGraphApiKey: "secret-api-key",
-    };
-
-    const result = buildEnsApiPublicConfig(mockConfig);
-
-    expect(result.theGraphFallback.canFallback).toBe(true);
-    // discriminate the type...
-    if (!result.theGraphFallback.canFallback) throw new Error("never");
-
-    // shouldn't have the secret-api-key in the url
-    expect(result.theGraphFallback.url).not.toMatch(/secret-api-key/gi);
-  });
-});

apps/ensapi/src/config/config.schema.ts

@@ -1,27 +1,23 @@
 import packageJson from "@/../package.json" with { type: "json" };
 
-import pRetry from "p-retry";
 import { parse as parseConnectionString } from "pg-connection-string";
+import { version } from "pino";
 import { prettifyError, ZodError, z } from "zod/v4";
 
-import type { EnsApiPublicConfig } from "@ensnode/ensnode-sdk";
 import {
   buildRpcConfigsFromEnv,
-  canFallbackToTheGraph,
   DatabaseSchemaNameSchema,
   ENSNamespaceSchema,
   EnsIndexerUrlSchema,
   invariant_rpcConfigsSpecifiedForRootChain,
-  makeENSIndexerPublicConfigSchema,
+  makeEnsApiVersionSchema,
   OptionalPortNumberSchema,
   RpcConfigsSchema,
   TheGraphApiKeySchema,
 } from "@ensnode/ensnode-sdk/internal";
 
 import { ENSApi_DEFAULT_PORT } from "@/config/defaults";
 import type { EnsApiEnvironment } from "@/config/environment";
-import { invariant_ensIndexerPublicConfigVersionInfo } from "@/config/validations";
-import { fetchENSIndexerConfig } from "@/lib/fetch-ensindexer-config";
 import logger from "@/lib/logger";
 
 export const DatabaseUrlSchema = z.string().refine(
@@ -60,20 +56,21 @@ const CustomReferralProgramEditionConfigSetUrlSchema = z
   })
   .optional();
 
+const EnsApiVersionSchema = makeEnsApiVersionSchema();
+
 const EnsApiConfigSchema = z
   .object({
+    version: EnsApiVersionSchema,
     port: OptionalPortNumberSchema.default(ENSApi_DEFAULT_PORT),
     databaseUrl: DatabaseUrlSchema,
     databaseSchemaName: DatabaseSchemaNameSchema,
     ensIndexerUrl: EnsIndexerUrlSchema,
     theGraphApiKey: TheGraphApiKeySchema,
     namespace: ENSNamespaceSchema,
     rpcConfigs: RpcConfigsSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema("ensIndexerPublicConfig"),
     customReferralProgramEditionConfigSetUrl: CustomReferralProgramEditionConfigSetUrlSchema,
   })
-  .check(invariant_rpcConfigsSpecifiedForRootChain)
-  .check(invariant_ensIndexerPublicConfigVersionInfo);
+  .check(invariant_rpcConfigsSpecifiedForRootChain);
 
 export type EnsApiConfig = z.infer<typeof EnsApiConfigSchema>;
 
@@ -83,29 +80,19 @@ export type EnsApiConfig = z.infer<typeof EnsApiConfigSchema>;
  * @returns A validated EnsApiConfig object
  * @throws Error with formatted validation messages if environment parsing fails
  */
-export async function buildConfigFromEnvironment(env: EnsApiEnvironment): Promise<EnsApiConfig> {
+export function buildConfigFromEnvironment(env: EnsApiEnvironment): EnsApiConfig {
   try {
-    const ensIndexerUrl = EnsIndexerUrlSchema.parse(env.ENSINDEXER_URL);
-
-    const ensIndexerPublicConfig = await pRetry(() => fetchENSIndexerConfig(ensIndexerUrl), {
-      retries: 3,
-      onFailedAttempt: ({ error, attemptNumber, retriesLeft }) => {
-        logger.info(
-          `ENSIndexer Config fetch attempt ${attemptNumber} failed (${error.message}). ${retriesLeft} retries left.`,
-        );
-      },
-    });
-
-    const rpcConfigs = buildRpcConfigsFromEnv(env, ensIndexerPublicConfig.namespace);
+    const namespace = ENSNamespaceSchema.parse(env.NAMESPACE);
+    const rpcConfigs = buildRpcConfigsFromEnv(env, namespace);
 
     return EnsApiConfigSchema.parse({
+      version: packageJson.version,
       port: env.PORT,
       databaseUrl: env.DATABASE_URL,
+      databaseSchemaName: env.DATABASE_SCHEMA,
       ensIndexerUrl: env.ENSINDEXER_URL,
       theGraphApiKey: env.THEGRAPH_API_KEY,
-      ensIndexerPublicConfig,
-      namespace: ensIndexerPublicConfig.namespace,
-      databaseSchemaName: ensIndexerPublicConfig.databaseSchemaName,
+      namespace: env.NAMESPACE,
       rpcConfigs,
       customReferralProgramEditionConfigSetUrl: env.CUSTOM_REFERRAL_PROGRAM_EDITIONS,
     });
@@ -121,24 +108,3 @@ export async function buildConfigFromEnvironment(env: EnsApiEnvironment): Promis
     process.exit(1);
   }
 }
-
-/**
- * Builds the ENSApi public configuration from an EnsApiConfig object.
- *
- * @param config - The validated EnsApiConfig object
- * @returns A complete ENSApiPublicConfig object
- */
-export function buildEnsApiPublicConfig(config: EnsApiConfig): EnsApiPublicConfig {
-  return {
-    version: packageJson.version,
-    theGraphFallback: canFallbackToTheGraph({
-      namespace: config.namespace,
-      // NOTE: very important here that we replace the actual server-side api key with a placeholder
-      // so that it's not sent to clients as part of the `theGraphFallback.url`. The placeholder must
-      // pass validation, of course, but the only validation necessary is that it is a string.
-      theGraphApiKey: config.theGraphApiKey ? "<API_KEY>" : undefined,
-      isSubgraphCompatible: config.ensIndexerPublicConfig.isSubgraphCompatible,
-    }),
-    ensIndexerPublicConfig: config.ensIndexerPublicConfig,
-  };
-}

apps/ensapi/src/config/environment.ts

@@ -15,8 +15,9 @@ import type {
  * their state in `process.env`. This interface is intended to be the source type which then gets
  * mapped/parsed into a structured configuration object like `EnsApiConfig`.
  */
-export type EnsApiEnvironment = Omit<DatabaseEnvironment, "DATABASE_SCHEMA"> &
-  EnsIndexerUrlEnvironment &
+export type EnsApiEnvironment = DatabaseEnvironment & {
+  NAMESPACE?: string;
+} & EnsIndexerUrlEnvironment &
   RpcEnvironment &
   PortEnvironment &
   LogLevelEnvironment &

apps/ensapi/src/handlers/ensnode-api.ts

@@ -4,12 +4,12 @@ import {
   EnsApiIndexingStatusResponseCodes,
   type EnsApiIndexingStatusResponseError,
   type EnsApiIndexingStatusResponseOk,
-  serializeENSApiPublicConfig,
   serializeEnsApiIndexingStatusResponse,
+  serializeEnsApiPublicConfig,
 } from "@ensnode/ensnode-sdk";
 
-import { buildEnsApiPublicConfig } from "@/config/config.schema";
 import { createApp } from "@/lib/hono-factory";
+import { publicConfigBuilder } from "@/lib/public-config-builder/singleton";
 
 import { getConfigRoute, getIndexingStatusRoute } from "./ensnode-api.routes";
 import ensnodeGraphQLApi from "./ensnode-graphql-api";
@@ -20,8 +20,8 @@ import resolutionApi from "./resolution-api";
 const app = createApp();
 
 app.openapi(getConfigRoute, async (c) => {
-  const ensApiPublicConfig = buildEnsApiPublicConfig(config);
-  return c.json(serializeENSApiPublicConfig(ensApiPublicConfig));
+  const ensApiPublicConfig = await publicConfigBuilder.getPublicConfig();
+  return c.json(serializeEnsApiPublicConfig(ensApiPublicConfig));
 });
 
 app.openapi(getIndexingStatusRoute, async (c) => {

apps/ensapi/src/handlers/name-tokens-api.ts

@@ -17,17 +17,13 @@ import {
 import { createApp } from "@/lib/hono-factory";
 import { findRegisteredNameTokensForDomain } from "@/lib/name-tokens/find-name-tokens-for-domain";
 import { getIndexedSubregistries } from "@/lib/name-tokens/get-indexed-subregistries";
+import { publicConfigBuilder } from "@/lib/public-config-builder/singleton";
 import { nameTokensApiMiddleware } from "@/middleware/name-tokens.middleware";
 
 import { getNameTokensRoute } from "./name-tokens-api.routes";
 
 const app = createApp();
 
-const indexedSubregistries = getIndexedSubregistries(
-  config.namespace,
-  config.ensIndexerPublicConfig.plugins as PluginName[],
-);
-
 // Middleware managing access to Name Tokens API route.
 // It makes the route available if all prerequisites are met,
 // and if not returns the appropriate HTTP 503 (Service Unavailable) error.
@@ -98,6 +94,12 @@ app.openapi(getNameTokensRoute, async (c) => {
     }
 
     const parentNode = namehash(getParentNameFQDN(name));
+    const { ensIndexerPublicConfig } = await publicConfigBuilder.getPublicConfig();
+
+    const indexedSubregistries = getIndexedSubregistries(
+      config.namespace,
+      ensIndexerPublicConfig.plugins as PluginName[],
+    );
     const subregistry = indexedSubregistries.find((subregistry) => subregistry.node === parentNode);
 
     // Return 404 response with error code for Name Tokens Not Indexed when

apps/ensapi/src/lib/ensdb-client/drizzle.ts

@@ -0,0 +1,26 @@
+// This file is based on `packages/ponder-subgraph/src/drizzle.ts` file.
+// We currently duplicate the makeDrizzle function, as we don't have
+// a shared package for backend code yet. When we do, we can move
+// this function to the shared package and import it in both places.
+import { setDatabaseSchema } from "@ponder/client";
+import { drizzle } from "drizzle-orm/node-postgres";
+
+type Schema = { [name: string]: unknown };
+
+/**
+ * Makes a Drizzle DB object.
+ */
+export const makeDrizzle = <SCHEMA extends Schema>({
+  schema,
+  databaseUrl,
+  databaseSchema,
+}: {
+  schema: SCHEMA;
+  databaseUrl: string;
+  databaseSchema: string;
+}) => {
+  // monkeypatch schema onto tables
+  setDatabaseSchema(schema, databaseSchema);
+
+  return drizzle(databaseUrl, { schema, casing: "snake_case" });
+};