feat: owners endpoint (#238)

* feat: owners endpoint

* feat: created endpoint

* feat: fixed request to match needs

* fix: owner response types

* feat/added tests for query owners

* feat: added test to component

* fix: pr comments

* fix: pr comments

* removed console.log

* removed unused line

* fix: pr comments

* feat: added tokenId to query

* fix: pr comment

Author: flobarreto

src/adapters/handlers/owners.ts

@@ -0,0 +1,34 @@
+import { IHttpServerComponent } from '@well-known-components/interfaces'
+import { AppComponents, Context } from '../../types'
+import { Params } from '../../logic/http/params'
+import { asJSON } from '../../logic/http/response'
+import { OwnersSortBy } from '../../ports/owner/types'
+
+export function createOwnersHandler(
+  components: Pick<AppComponents, 'logs' | 'owners'>
+): IHttpServerComponent.IRequestHandler<Context<'/owners'>> {
+  const { owners } = components
+  return async (context) => {
+    const params = new Params(context.url.searchParams)
+
+    const contractAddress = params.getAddress('contractAddress')
+    const itemId = params.getString('itemId')
+
+    const sortBy = params.getValue<OwnersSortBy>('sortBy', OwnersSortBy)
+    const orderDirection = params.getString('orderDirection')
+
+    const first = params.getNumber('first')
+    const skip = params.getNumber('skip')
+
+    return asJSON(() =>
+      owners.fetchAndCount({
+        contractAddress,
+        itemId,
+        orderDirection,
+        sortBy,
+        first,
+        skip,
+      })
+    )
+  }
+}

src/adapters/routes.ts

@@ -15,6 +15,7 @@ import { createTrendingHandler } from './handlers/trending'
 import { createVolumeHandler } from './handlers/volume'
 import { createPricesHandler } from './handlers/prices'
 import { createStatsHandler } from './handlers/stats'
+import { createOwnersHandler } from './handlers/owners'
 
 export async function setupRoutes(globalContext: GlobalContext) {
   const { components } = globalContext
@@ -45,6 +46,8 @@ export async function setupRoutes(globalContext: GlobalContext) {
     '/contracts/:contractAddress/tokens/:tokenId',
     createNFTHandler(components)
   )
+  router.get('/owners', createOwnersHandler(components))
+
 
   server.use(router.middleware())
 }

src/index.ts

@@ -153,6 +153,7 @@ import {
   getCollectionsAccountFragment,
   getCollectionsAccountOrderBy,
 } from './logic/accounts/collections'
+import { createOwnersComponent } from './ports/owner/component'
 
 async function initComponents(): Promise<AppComponents> {
   // Default config
@@ -423,6 +424,11 @@ async function initComponents(): Promise<AppComponents> {
     maxCount: 1000,
   })
 
+  // owners
+  const owners = createOwnersComponent({
+    subgraph: collectionsSubgraph,
+  })
+
   // mints
   const collectionsMints = createMintsComponent({
     subgraph: collectionsSubgraph,
@@ -660,6 +666,7 @@ async function initComponents(): Promise<AppComponents> {
     collectionsSubgraph,
     marketplaceSubgraph,
     stats,
+    owners,
   }
 }
 

src/ports/owner/component.ts

@@ -0,0 +1,54 @@
+import { ISubgraphComponent } from '@well-known-components/thegraph-component'
+import { HttpError } from '../../logic/http/response'
+import { FetchOptions } from '../merger/types'
+import {
+  IOwnerDataComponent,
+  OwnerFragment,
+  OwnersFilters,
+  OwnersSortBy,
+} from './types'
+import { getOwnersQuery } from './utils'
+
+export function createOwnersComponent(options: {
+  subgraph: ISubgraphComponent
+}): IOwnerDataComponent {
+  const { subgraph } = options
+
+  async function fetchAndCount(
+    filters: FetchOptions<OwnersFilters, OwnersSortBy>
+  ) {
+    if (filters.itemId === undefined || !filters.contractAddress) {
+      throw new HttpError(
+        'itemId and contractAddress are neccesary params.',
+        400
+      )
+    }
+
+    const parsedFilters: FetchOptions<OwnersFilters, OwnersSortBy> = {
+      ...filters,
+      sortBy: filters.sortBy as OwnersSortBy,
+    }
+
+    const data: { nfts: OwnerFragment[] } = await subgraph.query(
+      getOwnersQuery(parsedFilters, false)
+    )
+
+    const countData: { nfts: { id: string }[] } = await subgraph.query(
+      getOwnersQuery(parsedFilters, true)
+    )
+
+    const results = data.nfts.map((owner: OwnerFragment) => ({
+      issuedId: owner.issuedId,
+      ownerId: owner.owner.id,
+      orderStatus: owner.searchOrderStatus,
+      orderExpiresAt: owner.searchOrderExpiresAt,
+      tokenId: owner.tokenId
+    }))
+
+    return { data: results, total: countData.nfts.length }
+  }
+
+  return {
+    fetchAndCount,
+  }
+}

src/ports/owner/types.ts

@@ -0,0 +1,37 @@
+import { FetchOptions } from '../merger/types'
+
+export type Owners = {
+  issuedId: string
+  ownerId: string
+  orderStatus: string | null
+  orderExpiresAt: string | null
+  tokenId: string
+}
+
+export type OwnersFilters = {
+  contractAddress?: string,
+  first?: number, 
+  itemId?: string,
+  skip?: number,
+  orderDirection?: string
+}
+
+export enum OwnersSortBy {
+  ISSUED_ID = 'issuedId', 
+}
+
+export type OwnerFragment = {
+  issuedId: string
+  owner: {
+    id: string
+  }
+  searchOrderStatus: string
+  searchOrderExpiresAt: string
+  tokenId: string
+}
+
+export interface IOwnerDataComponent {
+  fetchAndCount(
+    filters: FetchOptions<OwnersFilters, OwnersSortBy>
+  ): Promise<{data: Owners[], total: number}>
+}

src/ports/owner/utils.spec.ts

@@ -0,0 +1,113 @@
+import { FetchOptions } from '../merger/types'
+import { OwnersFilters, OwnersSortBy } from './types'
+import { getOwnersQuery } from './utils'
+
+describe('#getOwnersQuery', () => {
+  let queryFilters: FetchOptions<OwnersFilters, OwnersSortBy>
+  let isCount: boolean
+
+  beforeEach(() => {
+    queryFilters = {
+      contractAddress: 'contractAddress',
+      itemId: 'itemId',
+      first: 10,
+      skip: 10,
+      sortBy: OwnersSortBy.ISSUED_ID,
+    }
+    isCount = false
+  })
+
+  describe('when isCount is true', () => {
+    beforeEach(() => {
+      isCount = true
+    })
+
+    it('should have first value in 1000', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain('first: 1000')
+    })
+
+    it('should have skip value as undefined', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).not.toContain('skip')
+    })
+
+    it('should contain id', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain('id')
+      expect(query).not.toContain('...ownerFragment')
+      expect(query).not.toContain('fragment ownerFragment on NFT')
+    })
+  })
+
+  describe('when isCount is false', () => {
+    it('should have first value as first prop', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain(`first: ${queryFilters.first}`)
+    })
+
+    it('should have skip value as skip prop', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain(`skip: ${queryFilters.skip}`)
+    })
+
+    it('should contain ownerFragment', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain('...ownerFragment')
+      expect(query).toContain('fragment ownerFragment on NFT')
+    })
+  })
+
+  describe('when the sortby filter is undefined', () => {
+    beforeEach(() => {
+      delete queryFilters.sortBy
+    })
+
+    it('should not contain orderBy', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).not.toContain(`orderBy`)
+    })
+  })
+
+  describe('when sortBy is not undefined', () => {
+    it('should have orderBy value as sortBy prop ', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain(`orderBy: ${queryFilters.sortBy}`)
+    })
+  })
+
+  describe('when orderDirection is undefined', () => {
+    it('should not contain orderDirection', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).not.toContain(`orderDirection`)
+    })
+  })
+
+  describe('when orderDirection is not undefined', () => {
+    beforeEach(() => {
+      queryFilters = { ...queryFilters, orderDirection: 'desc' }
+    })
+
+    it('should have orderDirection value as orderDirection ', () => {
+      const query = getOwnersQuery(queryFilters, isCount)
+
+      expect(query).toContain(`orderDirection: ${queryFilters.orderDirection}`)
+    })
+  })
+
+  it('should have contractAddress and itemId values as the ones passed by params', () => {
+    const query = getOwnersQuery(queryFilters, isCount)
+
+    expect(query).toContain(`${queryFilters.contractAddress}`)
+    expect(query).toContain(`${queryFilters.itemId}`)
+  })
+})

src/ports/owner/utils.ts

@@ -0,0 +1,43 @@
+import { FetchOptions } from '../merger/types'
+import {
+  OwnersFilters,
+  OwnersSortBy,
+} from './types'
+
+export const MAX_RESULTS = 1000
+
+
+export const getOwnerFragment = () => `
+  fragment ownerFragment on NFT {
+    issuedId
+    owner {
+      id
+    }
+    searchOrderStatus
+    searchOrderExpiresAt
+    tokenId
+  }
+`
+
+export function getOwnersQuery(
+  filters: FetchOptions<OwnersFilters, OwnersSortBy>,
+  isCount: boolean
+) {
+  const first = isCount ? 1000 : filters.first
+  const skip = isCount ? undefined : filters.skip
+
+      return `
+      query OwnersData{
+       nfts(
+          ${first ? `first: ${first}` : ''}
+          ${skip ? `skip: ${skip}` : ''}
+          ${filters.sortBy ? `orderBy: ${filters.sortBy}` : ''}
+          ${filters.orderDirection ? `orderDirection: ${filters.orderDirection}` : ''}
+          where: {contractAddress: "${filters.contractAddress}", itemBlockchainId: "${filters.itemId}" }) {
+            ${isCount ? 'id' : `...ownerFragment`}
+        }
+      }
+      ${isCount ? '' : getOwnerFragment()}
+    `
+  }
+

src/tests/components.ts

@@ -135,6 +135,7 @@ import {
   getCollectionsAccountFragment,
   getCollectionsAccountOrderBy,
 } from '../logic/accounts/collections'
+import { createOwnersComponent } from '../ports/owner/component'
 
 // start TCP port for listeners
 let lastUsedPort = 19000 + parseInt(process.env.JEST_WORKER_ID || '1') * 1000
@@ -564,6 +565,10 @@ export async function initComponents(): Promise<AppComponents> {
 
   const statusChecks = await createStatusCheckComponent({ config, server })
 
+  const owners = createOwnersComponent({
+    subgraph: collectionsSubgraph
+  })
+
   return {
     config,
     logs,
@@ -588,5 +593,6 @@ export async function initComponents(): Promise<AppComponents> {
     rankings,
     prices,
     stats,
+    owners
   }
 }