Added pino as API logger

.vscode/settings.json

@@ -39,6 +39,7 @@
     "oraclisation",
     "oraclise",
     "outdir",
+    "pino",
     "Polkadot",
     "QGIS",
     "roboto",

apps/api/package.json

@@ -12,6 +12,7 @@
     "test": "vitest"
   },
   "dependencies": {
+    "@hono/zod-validator": "0.2.2",
     "@sni/address-utils": "workspace:*",
     "@sni/clients": "workspace:*",
     "@sni/constants": "workspace:*",
@@ -23,14 +24,14 @@
     "@unique-nft/utils": "0.3.19",
     "hono": "4.4.10",
     "lodash": "4.17.21",
-    "nanoid": "^5.0.7"
+    "nanoid": "5.0.7",
+    "pino": "9.2.0",
+    "zod": "3.23.8"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "4.20240620.0",
-    "@hono/zod-validator": "0.2.2",
     "env-cmd": "10.1.0",
     "vitest": "1.6.0",
-    "wrangler": "3.62.0",
-    "zod": "3.23.8"
+    "wrangler": "3.62.0"
   }
 }

apps/api/src/routes/assets/assets.test.ts

@@ -5,10 +5,10 @@ import app from '.';
 describe('Assets API', () => {
   it('should handle invalid DID', async () => {
     const res = await app.request('http://localhost/invalidDID');
-    expect(res.status).toEqual(404);
+    expect(res.status).toEqual(400);
   });
 
-  it('should handle invalid Asset', async () => {
+  it('should handle missing Asset', async () => {
     const res = await app.request(
       'http://localhost/did:asset:deep:polkadot.asset-hub:13:1000000'
     );

apps/api/src/routes/assets/index.ts

@@ -1,10 +1,12 @@
 import { Hono } from 'hono';
 import { env } from 'hono/adapter';
-import { getAssetByDID } from '@sni/clients/assets-client';
+import { AssetNotFoundError, getAssetByDID } from '@sni/clients/assets-client';
+import { AddressParsingError } from '@sni/address-utils';
+import { logger } from '../../utils/logger';
 
 const app = new Hono();
 
-const getAssetRoute = app.get('/:assetDid', async (c) => {
+app.get('/:assetDid', async (c) => {
   const { OPEN_SEA_API_KEY } = env<{ OPEN_SEA_API_KEY: string }>(c);
   const { ALCHEMY_API_KEY } = env<{ ALCHEMY_API_KEY: string }>(c);
 
@@ -17,11 +19,20 @@ const getAssetRoute = app.get('/:assetDid', async (c) => {
     });
     return c.json(assetData);
   } catch (e) {
-    //console.error(JSON.stringify(e)); //TODO: standardize error logging
-    return c.json({ error: true, message: 'Asset not found' }, 404);
+    logger.error(e);
+
+    if (e instanceof AddressParsingError) {
+      return c.json({ error: true, message: e.message }, 400);
+    }
+
+    if (e instanceof AssetNotFoundError) {
+      return c.json({ error: true, message: e.message }, 404);
+    }
+
+    if (e instanceof Error) {
+      return c.json({ error: true, message: e.message }, 500);
+    }
   }
 });
 
-export type GetAssetRoute = typeof getAssetRoute;
-
 export default app;

apps/api/src/routes/claims/index.ts

@@ -2,6 +2,7 @@ import { zValidator } from '@hono/zod-validator';
 import { Hono } from 'hono';
 import { decode, verify } from 'hono/jwt';
 import { env } from 'hono/adapter';
+import { logger } from '../../utils/logger';
 import { CollectionConfig, collections } from './config';
 import { ClaimBody, CrossmintResponse, JWTToken } from './schemas';
 import { mintOptimismToken } from './providers/crossmint';
@@ -32,6 +33,7 @@ app.post(
     try {
       await verify(token, CLAIMS_SECRET);
     } catch (e) {
+      logger.error(e);
       return c.json({ error: true, message: 'Invalid token' }, 400);
     }
 
@@ -48,7 +50,7 @@ app.post(
         const mintResponse = await MINTING_KV.get(mintId);
 
         if (mintResponse === null) {
-          console.log('First time minting token');
+          logger.info(`Minting ${mintId}`);
 
           const pendingResponse = {
             id: payload.id,
@@ -60,11 +62,24 @@ app.post(
             actionId: payload.id,
           };
 
-          await MINTING_KV.put(mintId, JSON.stringify(pendingResponse));
+          try {
+            CrossmintResponse.parse(pendingResponse);
+          } catch (e) {
+            logger.error(e);
+            return c.json(
+              {
+                error: true,
+                message: `Internal server error`,
+              },
+              500
+            );
+          }
 
-          console.log('Sending to queue');
+          logger.info(`Sending minting ${mintId} to queue`);
+          await MINTING_KV.put(mintId, JSON.stringify(pendingResponse));
           await MINTING_QUEUE.send({ address, payload, collectionConfig });
-          console.log('Message sent to queue');
+
+          logger.debug(`Message queue received ${mintId}`);
 
           return c.json(pendingResponse);
         }
@@ -93,10 +108,10 @@ app.post(
   }
 );
 
-interface Env {
+type Env = {
   WALLET_MNEMONIC: string;
   MINTING_KV: KVNamespace;
-}
+};
 
 export async function claimsQueue(batch: MessageBatch<MintRequest>, env: Env) {
   for (const message of batch.messages) {
@@ -110,7 +125,7 @@ export async function claimsQueue(batch: MessageBatch<MintRequest>, env: Env) {
           const mintId = mintRequest.payload.id;
           try {
             //TODO: Add proper logger
-            console.log('Minting unique token');
+            logger.info(`Minting ${mintId} on ${network} network`);
 
             const successResponse = await mintUniqueToken(
               mintRequest.address,
@@ -123,9 +138,10 @@ export async function claimsQueue(batch: MessageBatch<MintRequest>, env: Env) {
 
             await env.MINTING_KV.put(mintId, JSON.stringify(parsedResponse));
           } catch (e) {
-            console.log('Error minting token');
-            console.error(e);
+            logger.error(`Error minting token on ${network} network`);
+            logger.error(e);
 
+            //Not sure if cleaning is needed on queue retries
             await env.MINTING_KV.delete(mintId);
           }
         }

apps/api/src/utils/logger.ts

@@ -0,0 +1,4 @@
+import pino from 'pino';
+
+export const logger = pino({ name: 'deep-api' });
+// import { APP_ID, LOG_LEVEL } from "./Config";

packages/address-utils/index.ts

@@ -96,6 +96,8 @@ function getChainName(chainNamespace: string, chainId: string): string {
   }
 }
 
+export class AddressParsingError extends Error {}
+
 //Parsing AssetDID to it's components
 export function parseAssetDID(did: string) {
   try {
@@ -105,7 +107,7 @@ export function parseAssetDID(did: string) {
     const tokenId = asset.identifier;
     return { network, contractAddress, tokenId };
   } catch (e) {
-    // console.error(e); //TODO: Proper logging?
-    throw new Error(`Invalid DID address: ${did}`);
+    //TODO: Throw custom address parsing error
+    throw new AddressParsingError(`Invalid DID address: ${did}`);
   }
 }

packages/clients/assets-client/index.ts

@@ -54,9 +54,17 @@ type KeysConfig = {
   alchemyAPIKey?: string;
 };
 
+export class AssetNotFoundError extends Error {
+  constructor() {
+    super('Asset not found');
+    this.name = 'AssetNotFoundError';
+  }
+}
+
 export async function getAssetByDID(did: string, keys?: KeysConfig) {
   const parsedData = parseAssetDID(did);
 
+  //TODO: Add error handling here
   return await getAsset(
     parsedData.network,
     parsedData.contractAddress,

packages/clients/assets-client/targets/polkadot/client.ts

@@ -1,9 +1,9 @@
 import { GraphQLClient } from 'graphql-request';
 import { DeepAsset } from '@sni/types';
+import { AssetNotFoundError } from '../..';
 import { kusamaApiUrl, polkadotApiUrl } from './config';
 import { getNftById } from './queries';
 import { PolkadotResponse } from './types';
-import polkadotFormatter from './formatter';
 
 const polkadotClient = new GraphQLClient(polkadotApiUrl, { fetch });
 const kusamaClient = new GraphQLClient(kusamaApiUrl, { fetch });
@@ -12,20 +12,52 @@ export async function getPolkadotAsset(
   collectionId: string,
   tokenId: number
 ): Promise<DeepAsset> {
-  return polkadotFormatter(
-    await polkadotClient.request<PolkadotResponse>(getNftById, {
-      id: `${collectionId}-${tokenId}`,
-    })
-  );
+  const res = await polkadotClient.request<PolkadotResponse>(getNftById, {
+    id: `${collectionId}-${tokenId}`,
+  });
+
+  const nftEntity = res.nftEntity;
+  if (!nftEntity) {
+    throw new AssetNotFoundError();
+  }
+
+  return {
+    id: nftEntity.id,
+    tokenId: nftEntity.sn,
+    name: nftEntity.meta.name,
+    description: nftEntity.meta.description,
+    image: nftEntity.meta.image,
+    collection: {
+      id: nftEntity.collection.id,
+      name: nftEntity.collection.name,
+    },
+    address: '', //TODO: Add DID address to the response
+  };
 }
 
 export async function getKusamaAsset(
   collectionId: string,
   tokenId: number
 ): Promise<DeepAsset> {
-  return polkadotFormatter(
-    await kusamaClient.request<PolkadotResponse>(getNftById, {
-      id: `${collectionId}-${tokenId}`,
-    })
-  );
+  const res = await kusamaClient.request<PolkadotResponse>(getNftById, {
+    id: `${collectionId}-${tokenId}`,
+  });
+
+  const nftEntity = res.nftEntity;
+  if (!nftEntity) {
+    throw new AssetNotFoundError();
+  }
+
+  return {
+    id: nftEntity.id,
+    tokenId: nftEntity.sn,
+    name: nftEntity.meta.name,
+    description: nftEntity.meta.description,
+    image: nftEntity.meta.image,
+    collection: {
+      id: nftEntity.collection.id,
+      name: nftEntity.collection.name,
+    },
+    address: '', //TODO: Add DID address to the response
+  };
 }