@ensdomains/ensjs 3.0.0-alpha.62 → 3.0.0-alpha.64

package/src/functions/getSubnames.ts

@@ -1,4 +1,9 @@
 import { ENSArgs } from '..'
+import {
+  ENSJSError,
+  getClientErrors,
+  debugSubgraphLatency,
+} from '../utils/errors'
 import { truncateFormat } from '../utils/format'
 import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
@@ -31,6 +36,11 @@ type WrappedSubname = BaseSubname & {
 
 type Subname = WrappedSubname | UnwrappedSubname
 
+type ReturnData = {
+  subnames: Subname[]
+  subnameCount: number
+}
+
 type Params = {
   name: string
   page?: number
@@ -127,8 +137,20 @@ const largeQuery = async (
     orderDirection,
     search: search?.toLowerCase(),
   }
-  const response = await client.request(finalQuery, queryVars)
-  const domain = response?.domain
+  const response = await client
+    .request(finalQuery, queryVars)
+    .catch((e) => {
+      throw new ENSJSError({
+        data: {
+          subnames: [],
+          subnameCount: 0,
+        },
+        errors: getClientErrors(e),
+      })
+    })
+    .finally(debugSubgraphLatency)
+
+  const domain = response?.domain || { subdomains: [], subdomainCount: 0 }
   const subdomains = domain.subdomains.map(
     ({ wrappedDomain, ...subname }: Domain) => {
       const decrypted = decryptName(subname.name!)
@@ -174,7 +196,7 @@ const largeQuery = async (
 const getSubnames = (
   injected: ENSArgs<'gqlInstance'>,
   functionArgs: Params,
-): Promise<{ subnames: Subname[]; subnameCount: number }> => {
+): Promise<ReturnData> => {
   return largeQuery(injected, functionArgs)
 }
 

package/src/functions/supportsTLD.ts

@@ -17,7 +17,7 @@ export default async function (
 
     if (tld === 'eth') return true
 
-    const tldOwner = await getOwner(tld, 'registry')
+    const tldOwner = await getOwner(tld, { contract: 'registry' })
     if (!tldOwner?.owner) return false
 
     const dnsRegistrar = DNSRegistrar__factory.connect(

package/src/utils/errors.ts

@@ -0,0 +1,68 @@
+import { ClientError } from 'graphql-request'
+import { GraphQLError } from 'graphql'
+
+export type ENSJSErrorName = 'ENSJSSubgraphError'
+
+export class ENSJSError<T> extends Error {
+  name = 'ENSJSSubgraphError'
+
+  errors?: GraphQLError[]
+
+  data?: T
+
+  constructor({ data, errors }: { data?: T; errors?: GraphQLError[] }) {
+    super()
+    this.data = data
+    this.errors = errors
+  }
+}
+
+export const getClientErrors = (e: unknown) => {
+  const error = e instanceof ClientError ? (e as ClientError) : undefined
+  return error?.response?.errors || [new GraphQLError('unknown_error')]
+}
+
+const isDebugEnvironmentActive = () => {
+  return (
+    process.env.NODE_ENV === 'development' ||
+    process.env.NEXT_PUBLIC_ENSJS_DEBUG === 'on'
+  )
+}
+
+export const debugSubgraphError = (request: any) => {
+  if (
+    isDebugEnvironmentActive() &&
+    typeof localStorage !== 'undefined' &&
+    localStorage.getItem('ensjs-debug') === 'ENSJSSubgraphError'
+  ) {
+    // If we are testing indexing errors, we will allow _meta queries
+    // to pass through.
+    if (
+      localStorage.getItem('subgraph-debug') === 'ENSJSSubgraphIndexingError' &&
+      /_meta {/.test(request.body)
+    )
+      return
+    throw new ClientError(
+      {
+        data: undefined,
+        errors: [new GraphQLError('ensjs-debug')],
+        status: 200,
+      },
+      request,
+    )
+  }
+}
+
+export const debugSubgraphLatency = (): Promise<void> | undefined => {
+  if (
+    isDebugEnvironmentActive() &&
+    typeof localStorage !== 'undefined' &&
+    localStorage.getItem('ensjs-debug') === 'ENSJSSubgraphLatency'
+  ) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve()
+      }, 10000)
+    })
+  }
+}