Add missing fields

src/server-extension/model/tokenEntity.model.ts

@@ -54,7 +54,7 @@ class Collection {
 }
 
 @ObjectType()
-export class TokenEntityByOwner {
+export class TokenEntityModel {
     @Field(() => String, { nullable: false })
     id!: string;
 
@@ -95,13 +95,13 @@ export class TokenEntityByOwner {
     collection!: Collection;
 
 
-    constructor(props: Partial<TokenEntityByOwner>) {
+    constructor(props: Partial<TokenEntityModel>) {
         Object.assign(this, props);
     }
 }
 
 @ObjectType()
-export class TokenEntityByOwnerQueryResult {
+export class TokenEntityQueryResult {
     @Field(() => String, { nullable: false })
     id!: string;
 
@@ -156,7 +156,7 @@ export class TokenEntityByOwnerQueryResult {
 
 
 
-    constructor(props: Partial<TokenEntityByOwner>) {
+    constructor(props: Partial<TokenEntityModel>) {
         Object.assign(this, props);
     }
 }

src/server-extension/query/tokenEntityByOwner.ts → src/server-extension/query/tokenEntities.ts

@@ -1,4 +1,4 @@
-export const tokenEntityByOwner = `WITH cheapest_nft AS (
+export const tokenEntities = `WITH cheapest_nft AS (
     SELECT 
         ne.token_id,
         ne.id AS nft_id,
@@ -7,17 +7,19 @@ export const tokenEntityByOwner = `WITH cheapest_nft AS (
     FROM 
         nft_entity ne
     WHERE 
-        ne.current_owner = $1
+    ($1::text IS NULL OR ne.current_owner = $1) AND 
+    ($7::text[] IS NULL OR ne.issuer NOT IN (SELECT unnest($7)))
 ),
 nft_count AS (
     SELECT 
         token_id, 
         COUNT(*) as count,
         COUNT(CASE WHEN burned = false THEN 1 END) as supply
     FROM 
-        nft_entity
+        nft_entity ne
     WHERE 
-        current_owner = $1
+    ($1::text IS NULL OR ne.current_owner = $1) AND 
+    ($7::text[] IS NULL OR ne.issuer NOT IN (SELECT unnest($7)))
     GROUP BY 
         token_id
 )
@@ -48,10 +50,7 @@ FROM
         JOIN metadata_entity as me ON t.meta_id = me.id
         JOIN nft_count ON t.id = nft_count.token_id
 WHERE
-    ($5::bigint IS NULL OR c.cheapest >= $5::bigint) AND
-    ($6::bigint IS NULL OR c.cheapest > $6::bigint) AND
-    ($7::bigint IS NULL OR c.cheapest <= $7::bigint)
-
-ORDER BY $4 LIMIT $2 OFFSET $3;
-
+    ($4::bigint IS NULL OR c.cheapest >= $4::bigint) AND
+    ($5::bigint IS NULL OR c.cheapest > $5::bigint) AND
+    ($6::bigint IS NULL OR c.cheapest <= $6::bigint)
 `

src/server-extension/resolvers/index.ts

@@ -3,4 +3,4 @@ export { WalletResolver } from './walletResolver'
 export { EventResolver } from './event'
 export { SeriesResolver } from './series'
 export { SpotlightResolver } from './spotlight'
-export { TokenResolver } from './tokenEntityByOwner'
+export { TokenResolver } from './tokenEntities'

src/server-extension/resolvers/tokenEntities.ts

@@ -0,0 +1,79 @@
+/* eslint-disable camelcase */
+import { Arg, Query, Resolver } from 'type-graphql'
+import { EntityManager } from 'typeorm'
+import { OrderBy, TokenEntityModel, TokenEntityQueryResult } from '../model/tokenEntity.model'
+import { makeQuery } from '../utils'
+import { tokenEntities } from '../query/tokenEntities'
+
+@Resolver()
+export class TokenResolver {
+  constructor(private tx: () => Promise<EntityManager>) {}
+
+  @Query(() => [TokenEntityModel])
+  async tokenEntityList(
+    @Arg('owner', { nullable: true }) owner?: string,
+    @Arg('limit', { nullable: true }) limit?: number,
+    @Arg('offset', { nullable: true, defaultValue: 0 }) offset?: number,
+    @Arg('orderBy', { nullable: true, defaultValue: OrderBy.blockNumber_DESC }) orderBy?: OrderBy,
+    @Arg('price_gte', { nullable: true }) price_gte?: number,
+    @Arg('price_gt', { nullable: true }) price_gt?: number,
+    @Arg('price_lte', { nullable: true }) price_lte?: number,
+    @Arg('denyList', () => [String], { nullable: true }) denyList?: string[]
+    ): Promise<TokenEntityModel[]> {
+    const orderQuery = this.getOrderByQuery(orderBy)
+
+    const fullSQLQuery = `
+${tokenEntities}
+ORDER BY ${orderQuery} LIMIT $2 OFFSET $3;
+`
+
+    const result: TokenEntityQueryResult[] = await makeQuery(this.tx, TokenEntityModel, fullSQLQuery, [
+      owner,
+      limit,
+      offset,
+      price_gte,
+      price_gt,
+      price_lte,
+      denyList,
+    ])
+    return result.map(this.mapRowToTokenEntityByOwner)
+  }
+
+  private mapRowToTokenEntityByOwner(row: TokenEntityQueryResult): TokenEntityModel {
+    return {
+      ...row,
+      blockNumber: row.block_number,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      cheapest: {
+        id: row.cheapest_id,
+        price: row.cheapest_price,
+      },
+      collection: {
+        id: row.collection_id,
+        name: row.collection_name,
+      },
+      meta: {
+        id: row.meta_id,
+        description: row.meta_description,
+        animationUrl: row.meta_animation_url,
+        image: row.meta_image,
+      },
+    }
+  }
+
+  ORDER_BY_MAPPING: Record<OrderBy, string> = {
+    [OrderBy.blockNumber_ASC]: 'block_number ASC',
+    [OrderBy.blockNumber_DESC]: 'block_number DESC',
+    [OrderBy.createdAt_ASC]: 'created_at ASC',
+    [OrderBy.createdAt_DESC]: 'created_at DESC',
+    [OrderBy.updatedAt_ASC]: 'updated_at ASC',
+    [OrderBy.updatedAt_DESC]: 'updated_at DESC',
+    [OrderBy.price_ASC]: 'cheapest_price ASC',
+    [OrderBy.price_DESC]: 'cheapest_price DESC',
+  }
+
+  private getOrderByQuery(orderBy: OrderBy = OrderBy.blockNumber_DESC): string {
+    return this.ORDER_BY_MAPPING[orderBy] || 'block_number DESC' // default to "block_number DESC" if not found
+  }
+}