Add missing fields

db/migrations/1689623692588-Data.js

@@ -1,25 +1,58 @@
 module.exports = class Data1689623692588 {
-    name = 'Data1689623692588'
+  name = 'Data1689623692588'
 
-    async up(db) {
-        await db.query(`CREATE TABLE "token_entity" ("id" character varying NOT NULL, "block_number" numeric, "hash" text NOT NULL, "image" text, "media" text, "name" text, "updated_at" TIMESTAMP WITH TIME ZONE NOT NULL, "created_at" TIMESTAMP WITH TIME ZONE NOT NULL, "count" integer NOT NULL, "collection_id" character varying, CONSTRAINT "PK_687443f2a51af49b5472e2c5ddc" PRIMARY KEY ("id"))`)
-        await db.query(`CREATE INDEX "IDX_0eb2ed7929c3e81941fa1b51b3" ON "token_entity" ("collection_id") `)
-        await db.query(`CREATE INDEX "IDX_40d6049fd30532dada71922792" ON "token_entity" ("hash") `)
-        await db.query(`CREATE INDEX "IDX_47b385945a425667b9e690bc02" ON "token_entity" ("name") `)
-        await db.query(`ALTER TABLE "nft_entity" ADD "token_id" character varying`)
-        await db.query(`CREATE INDEX "IDX_060d0f515d293fac1d81ee61a7" ON "nft_entity" ("token_id") `)
-        await db.query(`ALTER TABLE "token_entity" ADD CONSTRAINT "FK_0eb2ed7929c3e81941fa1b51b35" FOREIGN KEY ("collection_id") REFERENCES "collection_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`)
-        await db.query(`ALTER TABLE "nft_entity" ADD CONSTRAINT "FK_060d0f515d293fac1d81ee61a79" FOREIGN KEY ("token_id") REFERENCES "token_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`)
-    }
+  async up(db) {
+    await db.query(
+      `CREATE TABLE "token_entity" ("id" character varying NOT NULL, "block_number" numeric, "hash" text NOT NULL, "image" text, "media" text, "name" text, "updated_at" TIMESTAMP WITH TIME ZONE NOT NULL, "created_at" TIMESTAMP WITH TIME ZONE NOT NULL, "count" integer NOT NULL, "collection_id" character varying, CONSTRAINT "PK_687443f2a51af49b5472e2c5ddc" PRIMARY KEY ("id"))`
+    )
+    await db.query(`ALTER TABLE "token_entity" ADD "total_count" integer NOT NULL`)
+    await db.query(`CREATE INDEX "IDX_0eb2ed7929c3e81941fa1b51b3" ON "token_entity" ("collection_id") `)
+    await db.query(`CREATE INDEX "IDX_40d6049fd30532dada71922792" ON "token_entity" ("hash") `)
+    await db.query(`CREATE INDEX "IDX_47b385945a425667b9e690bc02" ON "token_entity" ("name") `)
+    await db.query(`ALTER TABLE "nft_entity" ADD "token_id" character varying`)
+    await db.query(`CREATE INDEX "IDX_060d0f515d293fac1d81ee61a7" ON "nft_entity" ("token_id") `)
+    await db.query(
+      `ALTER TABLE "token_entity" ADD CONSTRAINT "FK_0eb2ed7929c3e81941fa1b51b35" FOREIGN KEY ("collection_id") REFERENCES "collection_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`
+    )
+    await db.query(
+      `ALTER TABLE "nft_entity" ADD CONSTRAINT "FK_060d0f515d293fac1d81ee61a79" FOREIGN KEY ("token_id") REFERENCES "token_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`
+    )
 
-    async down(db) {
-        await db.query(`DROP TABLE "token_entity"`)
-        await db.query(`DROP INDEX "public"."IDX_0eb2ed7929c3e81941fa1b51b3"`)
-        await db.query(`DROP INDEX "public"."IDX_40d6049fd30532dada71922792"`)
-        await db.query(`DROP INDEX "public"."IDX_47b385945a425667b9e690bc02"`)
-        await db.query(`ALTER TABLE "nft_entity" DROP COLUMN "token_id"`)
-        await db.query(`DROP INDEX "public"."IDX_060d0f515d293fac1d81ee61a7"`)
-        await db.query(`ALTER TABLE "token_entity" DROP CONSTRAINT "FK_0eb2ed7929c3e81941fa1b51b35"`)
-        await db.query(`ALTER TABLE "nft_entity" DROP CONSTRAINT "FK_060d0f515d293fac1d81ee61a79"`)
-    }
+    // Commands from Data1696428349370
+    await db.query(`ALTER TABLE "token_entity" ADD "cheapest_nft_id" character varying`)
+    await db.query(`CREATE INDEX "IDX_6d56119ac99ab53644b1b21a6e" ON "token_entity" ("cheapest_nft_id") `)
+    await db.query(
+      `ALTER TABLE "token_entity" ADD CONSTRAINT "FK_6d56119ac99ab53644b1b21a6ef" FOREIGN KEY ("cheapest_nft_id") REFERENCES "nft_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`
+    )
+
+    // Commands from Data1696576165016
+    await db.query(`ALTER TABLE "token_entity" ADD "metadata" text`)
+    await db.query(`ALTER TABLE "token_entity" ADD "meta_id" character varying`)
+    await db.query(`CREATE INDEX "IDX_ae4ff3b28e3fec72aa14124d1e" ON "token_entity" ("meta_id") `)
+    await db.query(
+      `ALTER TABLE "token_entity" ADD CONSTRAINT "FK_ae4ff3b28e3fec72aa14124d1e1" FOREIGN KEY ("meta_id") REFERENCES "metadata_entity"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`
+    )
+  }
+
+  async down(db) {
+    // Rollback commands from Data1696576165016
+    await db.query(`ALTER TABLE "token_entity" DROP COLUMN "metadata"`)
+    await db.query(`ALTER TABLE "token_entity" DROP COLUMN "meta_id"`)
+    await db.query(`DROP INDEX "public"."IDX_ae4ff3b28e3fec72aa14124d1e"`)
+    await db.query(`ALTER TABLE "token_entity" DROP CONSTRAINT "FK_ae4ff3b28e3fec72aa14124d1e1"`)
+
+    // Rollback commands from Data1696428349370
+    await db.query(`ALTER TABLE "token_entity" DROP COLUMN "cheapest_nft_id"`)
+    await db.query(`DROP INDEX "public"."IDX_6d56119ac99ab53644b1b21a6e"`)
+    await db.query(`ALTER TABLE "token_entity" DROP CONSTRAINT "FK_6d56119ac99ab53644b1b21a6ef"`)
+
+    await db.query(`DROP TABLE "token_entity"`)
+    await db.query(`DROP INDEX "public"."IDX_0eb2ed7929c3e81941fa1b51b3"`)
+    await db.query(`DROP INDEX "public"."IDX_40d6049fd30532dada71922792"`)
+    await db.query(`DROP INDEX "public"."IDX_47b385945a425667b9e690bc02"`)
+    await db.query(`ALTER TABLE "nft_entity" DROP COLUMN "token_id"`)
+    await db.query(`DROP INDEX "public"."IDX_060d0f515d293fac1d81ee61a7"`)
+    await db.query(`ALTER TABLE "token_entity" DROP CONSTRAINT "FK_0eb2ed7929c3e81941fa1b51b35"`)
+    await db.query(`ALTER TABLE "nft_entity" DROP CONSTRAINT "FK_060d0f515d293fac1d81ee61a79"`)
+  }
 }

schema.graphql

@@ -30,14 +30,18 @@ type TokenEntity @entity {
   id: ID!
   blockNumber: BigInt
   collection: CollectionEntity
+  cheapestNFT: NFTEntity
   nfts: [NFTEntity!] @derivedFrom(field: "token")
   hash: String! @index
   image: String
   media: String
+  meta: MetadataEntity
+  metadata: String
   name: String @index
   updatedAt: DateTime!
   createdAt: DateTime!
   count: Int!
+  totalCount: Int!
 }
 
 type NFTEntity @entity {

src/mappings/nfts/burn.ts

@@ -1,10 +1,11 @@
-import { getWith } from '@kodadot1/metasquid/entity'
+import {  getWith } from '@kodadot1/metasquid/entity'
 import { NFTEntity as NE } from '../../model'
 import { unwrap } from '../utils/extract'
 import { debug, pending, success } from '../utils/logger'
 import { Action, Context, createTokenId } from '../utils/types'
 import { createEvent } from '../shared/event'
 import { calculateCollectionOwnerCountAndDistribution } from '../utils/helper'
+import { eventHandlers } from '../shared/handleTokenEntity'
 import { getBurnTokenEvent } from './getters'
 
 const OPERATION = Action.BURN
@@ -31,6 +32,8 @@ export async function handleTokenBurn(context: Context): Promise<void> {
   entity.collection.ownerCount = ownerCount
   entity.collection.distribution = distribution
 
+  await eventHandlers.burnHandler(context, entity)
+
   success(OPERATION, `${id} by ${event.caller}}`)
   await context.store.save(entity)
   const meta = entity.metadata ?? ''

src/mappings/nfts/list.ts

@@ -4,6 +4,7 @@ import { unwrap } from '../utils/extract'
 import { debug, pending, success } from '../utils/logger'
 import { Action, Context, createTokenId } from '../utils/types'
 import { createEvent } from '../shared/event'
+import { eventHandlers } from '../shared/handleTokenEntity'
 import { getPriceTokenEvent } from './getters'
 
 const OPERATION = Action.LIST
@@ -22,6 +23,7 @@ export async function handleTokenList(context: Context): Promise<void> {
   if (entity.price && (entity.collection.floor === 0n || entity.price < entity.collection.floor)) {
     entity.collection.floor = entity.price
   }
+  eventHandlers.listHandler(context, entity)
 
   success(OPERATION, `${id} by ${event.caller}} for ${String(event.price)}`)
   await context.store.save(entity)

src/mappings/nfts/mint.ts

@@ -8,6 +8,7 @@ import { unwrap } from '../utils/extract'
 import { debug, pending, success } from '../utils/logger'
 import { Action, Context, createTokenId } from '../utils/types'
 import { calculateCollectionOwnerCountAndDistribution, versionOf } from '../utils/helper'
+import { eventHandlers } from '../shared/handleTokenEntity'
 import { getCreateTokenEvent } from './getters'
 
 const OPERATION = Action.MINT
@@ -60,6 +61,8 @@ export async function handleTokenCreate(context: Context): Promise<void> {
     final.name = metadata?.name
     final.image = metadata?.image
     final.media = metadata?.animationUrl
+
+    await eventHandlers.mintHandler(context, collection, final)
   }
 
   success(OPERATION, `${final.id}`)

src/mappings/nfts/setMetadata.ts

@@ -1,12 +1,12 @@
-import { get, getOptional } from '@kodadot1/metasquid/entity'
+import { get, getOptional, getWith } from '@kodadot1/metasquid/entity'
 import { isFetchable } from '@kodadot1/minipfs'
 import { unwrap } from '../utils/extract'
 import { Context, isNFT } from '../utils/types'
 import { CollectionEntity, NFTEntity } from '../../model'
 import { handleMetadata } from '../shared/metadata'
 import { debug, warn } from '../utils/logger'
 import { updateItemMetadataByCollection } from '../utils/cache'
-import { handleTokenEntity } from '../shared/handleTokenEntity'
+import { eventHandlers  } from '../shared/handleTokenEntity'
 import { tokenIdOf } from './types'
 import { getMetadataEvent } from './getters'
 
@@ -51,17 +51,15 @@ export async function handleMetadataSet(context: Context): Promise<void> {
         warn(OPERATION, `collection ${event.collectionId} not found`)
         return
       }
-      const nft = final as NFTEntity
-      const token = await handleTokenEntity(context, collection, nft)
-      if (token) {
-        nft.token = token
+      if (final instanceof NFTEntity) {
+        await eventHandlers.setMetadataHandler(context, collection, final)
       }
     }
-  }
 
-  await context.store.save(final)
+    await context.store.save(final)
 
-  if (!event.sn && final.metadata) {
-    await updateItemMetadataByCollection(context.store, event.collectionId)
+    if (!event.sn && final.metadata) {
+      await updateItemMetadataByCollection(context.store, event.collectionId)
+    }
   }
 }

src/mappings/shared/handleTokenEntity.ts

@@ -1,44 +1,166 @@
-import { create, getOptional } from '@kodadot1/metasquid/entity'
+import { create, getOptional, getWith } from '@kodadot1/metasquid/entity'
 import md5 from 'md5'
 import { CollectionEntity as CE, NFTEntity as NE, TokenEntity as TE } from '../../model'
-import { warn } from '../utils/logger'
+import { debug, warn } from '../utils/logger'
 import { Context } from '../utils/types'
 
 const OPERATION = 'TokenEntity' as any
 
-export async function handleTokenEntity(context: Context, collection: CE, nft: NE): Promise<TE | undefined> {
-  const nftMedia = nft.image || nft.media
+function generateTokenId(collectionId: string, nftMedia: string): string {
+  return `${collectionId}-${md5(nftMedia)}`
+}
+
+async function createToken(context: Context, collection: CE, nft: NE): Promise<TE | undefined> {
+  const nftMedia = nft.image ?? nft.media
   if (!nftMedia || nftMedia === '') {
     warn(OPERATION, `MISSING NFT MEDIA ${nft.id}`)
     return
   }
+  const tokenId = generateTokenId(collection.id, nftMedia)
+  debug(OPERATION, { createToken: `Create TOKEN ${tokenId} for NFT ${nft.id}` })
+  const tokenName = typeof nft.name === 'string' ? nft.name?.replace(/([#_]\d+$)/g, '').trim() : ''
 
-  const tokenId = `${collection.id}-${md5(nftMedia)}`
-  let token = await getOptional<TE>(context.store, TE, tokenId)
+  const token = create(TE, tokenId, {
+    createdAt: nft.createdAt,
+    collection,
+    name: tokenName,
+    count: 1,
+    totalCount: 1,
+    hash: md5(tokenId),
+    image: nft.image,
+    media: nft.media,
+    metadata: nft.metadata,
+    meta: nft.meta,
+    blockNumber: nft.blockNumber,
+    updatedAt: nft.updatedAt,
+    id: tokenId,
+  })
 
-  if (!token) {
-    const tokenName = (typeof nft.name === 'string' ? nft.name?.replace(/([#_]\d+$)/g, '').trim() : '')
-
-    token = create(TE, tokenId, {
-      createdAt: nft.createdAt,
-      collection,
-      name: tokenName,
-      count: 1,
-      hash: md5(tokenId),
-      image: nft.image,
-      media: nft.media,
-      blockNumber: nft.blockNumber,
-      updatedAt: nft.updatedAt,
-      id: tokenId,
-    })
-  } else {
-    token.count += 1
-  }
+  nft.token = token
+  await context.store.save(token)
+  await context.store.save(nft)
 
-  token.updatedAt = nft.updatedAt
-  token.blockNumber = nft.blockNumber
+  return token
+}
 
+async function addNftToToken(context: Context, nft: NE, token: TE): Promise<TE> {
+  debug(OPERATION, { updateToken: `Add NFT ${nft.id} to TOKEN ${token.id} for ` })
+  token.count += 1
+  token.totalCount += 1
+  token.updatedAt = nft.updatedAt
+  nft.token = token
   await context.store.save(token)
+  await context.store.save(nft)
 
   return token
 }
+
+async function removeNftFromToken(context: Context, nft: NE, token: TE): Promise<void> {
+  if (!token) {
+    return
+  }
+  debug(OPERATION, { removeNftFromToken: `Unlink NFT ${nft.id} from  TOKEN ${token.id}` })
+
+  await context.store.update(NE, nft.id, { token: null })
+  const updatedTotalCount = token.totalCount - 1
+  await context.store.update(TE, token.id, { count: token.count - 1, totalCount: updatedTotalCount , updatedAt: nft.updatedAt })
+
+  if (updatedTotalCount === 0) {
+    debug(OPERATION, { deleteEmptyToken: `delete empty token ${token.id}` })
+
+    await context.store.delete(TE, token.id)
+  }
+}
+
+async function mintHandler(context: Context, collection: CE, nft: NE): Promise<TE | undefined> {
+  const nftMedia = nft.image ?? nft.media
+  debug(OPERATION, { mintHandler: `Handle mint for NFT ${nft.id}` })
+
+  if (!nftMedia || nftMedia === '') {
+    warn(OPERATION, `MISSING NFT MEDIA ${nft.id}`)
+    return
+  }
+
+  const existingToken = await getOptional<TE>(context.store, TE, generateTokenId(collection.id, nftMedia))
+  return await (existingToken ? addNftToToken(context, nft, existingToken) : createToken(context, collection, nft))
+}
+
+async function handleMetadataSet(context: Context, collection: CE, nft: NE): Promise<TE | undefined> {
+  debug(OPERATION, { handleMetadataSet: `Handle set metadata for NFT ${nft.id}` })
+  const nftMedia = nft.image ?? nft.media
+
+  if (!nftMedia || nftMedia === '') {
+    warn(OPERATION, `MISSING NFT MEDIA ${nft.id}`)
+    return
+  }
+
+  let nftWithToken, existingToken
+  try {
+    [nftWithToken, existingToken] = await Promise.all([
+      getWith(context.store, NE, nft.id, { token: true }),
+      getOptional<TE>(context.store, TE, generateTokenId(collection.id, nftMedia)),
+    ])
+  } catch (error) {
+    warn(OPERATION, `ERROR ${error}`)
+    return
+  }
+  if (nftWithToken.token) {
+    await removeNftFromToken(context, nft, nftWithToken.token)
+  }
+  return await (existingToken ? addNftToToken(context, nft, existingToken) : createToken(context, collection, nft))
+}
+
+async function handleBurn(context: Context, nft: NE): Promise<void> {
+  debug(OPERATION, { handleBurn: `Handle Burn for NFT ${nft.id}` })
+  const nftMedia = nft.image ?? nft.media
+
+  if (!nftMedia || nftMedia === '') {
+    warn(OPERATION, `MISSING NFT MEDIA ${nft.id}`)
+    return
+  }
+
+  const token = await getOptional<TE>(context.store, TE, generateTokenId(nft.collection.id, nftMedia))
+
+  if (!token) {
+    return
+  }
+
+  debug(OPERATION, { BURN: `decrement Token's ${token.id} count` })
+
+  await context.store.update(TE, token.id, { count: token.count - 1, updatedAt: nft.updatedAt })
+}
+
+async function listHandler(context: Context, nft: NE): Promise<TE | undefined> {
+  const nftMedia = nft.image ?? nft.media
+
+  if (!nftMedia || nftMedia === '') {
+    warn(OPERATION, `MISSING NFT MEDIA ${nft.id}`)
+    return
+  }
+
+  try {
+    const nftWithToken = await getWith(context.store, NE, nft.id, { token: true })
+    if (!nftWithToken.token) {
+      warn(OPERATION, `nft ${nft.id} is not linked to a token`)
+      return
+    }
+    const cheapestNFT = nftWithToken.token.cheapestNFT
+    if (!nft.price && !cheapestNFT?.price) {
+      return;
+  }
+
+    if (!cheapestNFT?.price || (nft.price && nft.price < cheapestNFT.price)) {
+      context.store.update(TE, nftWithToken.token.id, { cheapestNFT: nft, updatedAt: nft.updatedAt })
+    }
+  } catch (error) {
+    warn(OPERATION, `ERROR ${error}`)
+  }
+}
+
+
+export const eventHandlers = {
+  setMetadataHandler: handleMetadataSet,
+  mintHandler,
+  burnHandler: handleBurn,
+  listHandler
+}