@ensdomains/ensjs 3.0.0-beta.1 → 3.0.0-beta.2

package/src/functions/subgraph/getNameHistory.ts

@@ -1,7 +1,7 @@
 import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { gql } from 'graphql-request'
 import type { ClientWithEns } from '../../contracts/consts.js'
-import { decodeContenthash } from '../../utils/contentHash.js'
+import { decodeContentHash } from '../../utils/contentHash.js'
 import { namehash } from '../../utils/normalise.js'
 import { createSubgraphClient } from './client.js'
 import type {
@@ -300,7 +300,7 @@ const getNameHistory = async (
           }
         }
         case 'ContenthashChanged': {
-          const { decoded: contentHash, protocolType } = decodeContenthash(
+          const { decoded: contentHash, protocolType } = decodeContentHash(
             event.hash,
           ) || { protocolType: null, decoded: null }
           return {

package/src/functions/subgraph/getNamesForAddress.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { gql } from 'graphql-request'
 import type { Address } from 'viem'
 import type { ClientWithEns } from '../../contracts/consts.js'
@@ -6,8 +7,9 @@ import {
   InvalidFilterKeyError,
   InvalidOrderByError,
 } from '../../errors/subgraph.js'
-import { GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
+import { EMPTY_ADDRESS, GRACE_PERIOD_SECONDS } from '../../utils/consts.js'
 import { createSubgraphClient } from './client.js'
+import type { DomainFilter } from './filters.js'
 import {
   domainDetailsFragment,
   registrationDetailsFragment,
@@ -16,6 +18,13 @@ import {
 } from './fragments.js'
 import { makeNameObject, type Name } from './utils.js'
 
+const supportedOwnerFilters = [
+  'owner',
+  'registrant',
+  'wrappedOwner',
+  'resolvedAddress',
+] as const
+
 type GetNamesForAddressOrderBy =
   | 'expiryDate'
   | 'name'
@@ -38,6 +47,8 @@ type GetNamesForAddressFilter = GetNamesForAddressRelation & {
   allowExpired?: boolean
   /** Allows reverse record nodes to be included (default: false) */
   allowReverseRecord?: boolean
+  /** Allows deleted names to be included (default: false) */
+  allowDeleted?: boolean
 }
 
 export type GetNamesForAddressParameters = {
@@ -65,6 +76,70 @@ type SubgraphResult = {
   domains: SubgraphDomain[]
 }
 
+const getOrderByFilter = ({
+  orderBy,
+  orderDirection,
+  previousPage,
+}: Required<
+  Pick<
+    GetNamesForAddressParameters,
+    'orderBy' | 'orderDirection' | 'previousPage'
+  >
+>): DomainFilter => {
+  const lastDomain = previousPage[previousPage.length - 1]
+  const operator = orderDirection === 'asc' ? 'gt' : 'lt'
+
+  switch (orderBy) {
+    case 'expiryDate': {
+      let lastExpiryDate = lastDomain.expiryDate?.value
+        ? lastDomain.expiryDate.value / 1000
+        : 0
+      if (lastDomain.parentName === 'eth') {
+        lastExpiryDate += GRACE_PERIOD_SECONDS
+      }
+
+      if (orderDirection === 'asc' && lastExpiryDate === 0) {
+        return {
+          and: [{ expiryDate: null }, { [`id_${operator}`]: lastDomain.id }],
+        }
+      }
+      if (orderDirection === 'desc' && lastExpiryDate !== 0) {
+        return {
+          [`expiryDate_${operator}`]: `${lastExpiryDate}`,
+        }
+      }
+      return {
+        or: [
+          {
+            [`expiryDate_${operator}`]: `${lastExpiryDate}`,
+          },
+          { expiryDate: null },
+        ],
+      }
+    }
+    case 'name': {
+      return {
+        [`name_${operator}`]: lastDomain.name ?? '',
+      }
+    }
+    case 'labelName': {
+      return {
+        [`labelName_${operator}`]: lastDomain.labelName ?? '',
+      }
+    }
+    case 'createdAt': {
+      return {
+        [`createdAt_${operator}`]: `${lastDomain.createdAt.value / 1000}`,
+      }
+    }
+    default:
+      throw new InvalidOrderByError({
+        orderBy: orderBy || '<no orderBy provided>',
+        supportedOrderBys: ['expiryDate', 'name', 'labelName', 'createdAt'],
+      })
+  }
+}
+
 /**
  * Gets the names for an address from the subgraph.
  * @param client - {@link ClientWithEns}
@@ -92,6 +167,7 @@ const getNamesForAddress = async (
       resolvedAddress: true,
       wrappedOwner: true,
       allowExpired: false,
+      allowDeleted: false,
       allowReverseRecord: false,
     },
     orderBy = 'name',
@@ -102,231 +178,139 @@ const getNamesForAddress = async (
 ): Promise<GetNamesForAddressReturnType> => {
   const subgraphClient = createSubgraphClient({ client })
 
-  let ownerWhereFilter = `
-    or: [
-  `
-  let hasFilterApplied = false
-  const { allowExpired, allowReverseRecord, ...filters } = filter
-  for (const [key, value] of Object.entries(filters)) {
-    if (value) {
-      hasFilterApplied = true
-      switch (key) {
-        case 'owner': {
-          ownerWhereFilter += `
-            { owner: $address }
-          `
-          break
-        }
-        case 'registrant': {
-          ownerWhereFilter += `
-            { registrant: $address }
-          `
-          break
-        }
-        case 'wrappedOwner': {
-          ownerWhereFilter += `
-            { wrappedOwner: $address }
-          `
-          break
-        }
-        case 'resolvedAddress': {
-          ownerWhereFilter += `
-            { resolvedAddress: $address }
-          `
-          break
-        }
-        default:
+  const { allowExpired, allowDeleted, allowReverseRecord, ...filters } = filter
+  const ownerWhereFilters: DomainFilter[] = Object.entries(filters).reduce(
+    (prev, [key, value]) => {
+      if (value) {
+        if (!supportedOwnerFilters.includes(key as any))
           throw new InvalidFilterKeyError({
             filterKey: key,
-            supportedFilterKeys: [
-              'owner',
-              'registrant',
-              'wrappedOwner',
-              'resolvedAddress',
-            ],
+            supportedFilterKeys: supportedOwnerFilters,
           })
+        return [
+          ...prev,
+          {
+            [key]: address.toLowerCase(),
+          },
+        ]
       }
-    }
-  }
+      return prev
+    },
+    [] as DomainFilter[],
+  )
+
+  const hasFilterApplied = ownerWhereFilters.length > 0
 
   if (!hasFilterApplied)
     throw new FilterKeyRequiredError({
-      supportedFilterKeys: [
-        'owner',
-        'registrant',
-        'wrappedOwner',
-        'resolvedAddress',
-      ],
+      supportedFilterKeys: supportedOwnerFilters,
       details: 'At least one ownership filter must be enabled',
     })
 
-  ownerWhereFilter += `
-    ]
-  `
-
-  const whereFilters = [ownerWhereFilter]
-
-  let orderByFilter = ''
-  let orderByStringVar = ''
+  const ownerWhereFilter: DomainFilter =
+    ownerWhereFilters.length > 1
+      ? { or: ownerWhereFilters }
+      : ownerWhereFilters[0]
+  const whereFilters: DomainFilter[] = [ownerWhereFilter]
 
-  if (previousPage && previousPage.length > 0) {
-    const lastDomain = previousPage[previousPage.length - 1]
-    const operator = orderDirection === 'asc' ? 'gt' : 'lt'
-    switch (orderBy) {
-      case 'expiryDate': {
-        let lastExpiryDate = lastDomain.expiryDate?.value
-          ? lastDomain.expiryDate.value / 1000
-          : 0
-        if (lastDomain.parentName === 'eth') {
-          lastExpiryDate += GRACE_PERIOD_SECONDS
-        }
-        if (orderDirection === 'asc' && lastExpiryDate === 0) {
-          orderByFilter = `
-              {
-                and: [
-                  { expiryDate: null }
-                  { id_${operator}: "${lastDomain.id}" }
-                ]
-              }
-            `
-        } else if (orderDirection === 'desc' && lastExpiryDate !== 0) {
-          orderByFilter = `
-            {
-              expiryDate_${operator}: ${lastExpiryDate}
-            }
-          `
-        } else {
-          orderByFilter = `
-            {
-              or: [
-                {
-                  expiryDate_${operator}: ${lastExpiryDate}
-                }
-                { expiryDate: null }
-              ]
-            }
-          `
-        }
-        break
-      }
-      case 'name': {
-        orderByFilter = `
-          {
-            name_${operator}: $orderByStringVar
-          }
-        `
-        orderByStringVar = lastDomain.name ?? ''
-        break
-      }
-      case 'labelName': {
-        orderByFilter = `
-          {
-            labelName_${operator}: $orderByStringVar
-          }
-        `
-        orderByStringVar = lastDomain.labelName ?? ''
-        break
-      }
-      case 'createdAt': {
-        orderByFilter = `
-          {
-            createdAt_${operator}: ${lastDomain.createdAt.value / 1000}
-          }
-        `
-        break
-      }
-      default:
-        throw new InvalidOrderByError({
-          orderBy,
-          supportedOrderBys: ['expiryDate', 'name', 'labelName', 'createdAt'],
-        })
-    }
-    whereFilters.push(orderByFilter)
+  if (previousPage?.length) {
+    whereFilters.push(
+      getOrderByFilter({
+        orderBy,
+        orderDirection,
+        previousPage,
+      }),
+    )
   }
 
   if (!allowReverseRecord) {
     // Exclude domains with parent addr.reverse
     // namehash of addr.reverse = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2
-    whereFilters.push(`
-      {
-        parent_not: "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2"
-      }
-    `)
+    whereFilters.push({
+      parent_not:
+        '0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2',
+    })
   }
 
   if (!allowExpired) {
     // Exclude domains that are expired
     // if expiryDate is null, there is no expiry on the domain (registration or wrapped)
-    whereFilters.push(`
-      {
-        or: [
-          { expiryDate_gt: $expiryDate }
-          { expiryDate: null }
-        ]
-      }
-    `)
+    whereFilters.push({
+      or: [
+        { expiryDate_gt: `${Math.floor(Date.now() / 1000)}` },
+        { expiryDate: null },
+      ],
+    })
   }
 
-  const whereFilter =
-    whereFilters.length > 1
-      ? `
-    and: [
-      {
-        ${whereFilters.shift()}
-      }
-      ${whereFilters.join('\n')}
-    ]
-  `
-      : whereFilters[0]
+  if (!allowDeleted) {
+    // exclude "deleted" domains
+    // when owner/resolver/registrant = null
+    whereFilters.push({
+      or: [
+        {
+          owner_not: EMPTY_ADDRESS,
+        },
+        {
+          resolver_not: null,
+        },
+        {
+          and: [
+            {
+              registrant_not: EMPTY_ADDRESS,
+            },
+            {
+              registrant_not: null,
+            },
+          ],
+        },
+      ],
+    })
+  }
+
+  const whereFilter: DomainFilter =
+    whereFilters.length > 1 ? { and: whereFilters } : whereFilters[0]
 
   const query = gql`
-      query getNamesForAddress(
-        $address: String!
-        $orderBy: Domain_orderBy
-        $orderDirection: OrderDirection
-        $first: Int
-        $expiryDate: Int
-        $orderByStringVar: String
+    query getNamesForAddress(
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+      $first: Int
+      $whereFilter: Domain_filter
+    ) {
+      domains(
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+        first: $first
+        where: $whereFilter
       ) {
-        domains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-          first: $first
-          where: {
-            ${whereFilter}
-          }
-        ) {
-          ...DomainDetails
-          registration {
-            ...RegistrationDetails
-          }
-          wrappedDomain {
-            ...WrappedDomainDetails
-          }
+        ...DomainDetails
+        registration {
+          ...RegistrationDetails
+        }
+        wrappedDomain {
+          ...WrappedDomainDetails
         }
       }
-      ${domainDetailsFragment}
-      ${registrationDetailsFragment}
-      ${wrappedDomainDetailsFragment}
-    `
+    }
+    ${domainDetailsFragment}
+    ${registrationDetailsFragment}
+    ${wrappedDomainDetailsFragment}
+  `
 
   const result = await subgraphClient.request<
     SubgraphResult,
     {
-      address: string
       orderBy: string
       orderDirection: string
       first: number
-      expiryDate: number
-      orderByStringVar: string
+      whereFilter: DomainFilter
     }
   >(query, {
-    address: address.toLowerCase(),
     orderBy,
     orderDirection,
     first: pageSize,
-    expiryDate: Math.floor(Date.now() / 1000),
-    orderByStringVar,
+    whereFilter,
   })
 
   if (!result) return []