API调用时仅发送1块元数据

Question

我的API有一个问题，当从我的网站智能合约调用时发送元数据。它的NFT令牌，我的数据库是postgres，API是node.js问题是当我mint 1 NFT元数据完美工作时，但如果我mint 2或更多，它将只发送1块数据？因此，只有1个NFT可以正确地铸造，其余的没有数据？

是否需要设置循环函数或延迟？有没有人有这方面的经验？

任何帮助都将不胜感激。

下面是标签为"nft.js“的”控制器“文件夹中的代码。

const models = require("../../models/index");
const path = require("path");
const fs = require("fs");

module.exports = {
  create_nft: async (req, res, next) => {
    try {
      const dir = path.resolve(__dirname + `../../../data/traitsfinal.json`);
      const readCards = fs.readFileSync(dir, "utf8");

      const parsed = JSON.parse(readCards);
      console.log("ya data ha final ??", parsed);
      parsed.forEach(async (item) => {
        // return res.json(item)
        let newNft = await models.NFT.create({
          name: item.Name,
          description: item.Description,
          background: item.Background,
          body: item.Body,
          mouth: item.Mouth,
          eyes: item.Eyes,
          head_gear: item.Head_Gear,
          tokenId: item.tokenId,
          image: item.imagesIPFS,
        });
      });

      return res.json({
        data: "nft created",
        error: null,
        success: true,
      });
    } catch (error) {
      console.log("server error", error.message);
      next(error);
    }
  },

  get_nft: async (req, res, next) => {
    try {
      const { id } = req.params;
      // console.log("id ?????????",id)
      // console.log("type of  ",typeof(id))
      // const n=Number(id)
      // console.log("type of  ",typeof(id))
      const nft = await models.NFT.findByPk(id);

      if (!nft) {
        throw new Error("Token ID invalid");
      }

      if (!nft.isMinted) {
        throw new Error("Token not minted");
      }
      console.log(nft);
      // }
      const resObj = {
        name: nft.name,
        description: nft.description,
        image: `https://gateway.pinata.cloud/ipfs/${nft.image}`,
        attributes: [
          { trait_type: "background", value: `${nft.background}` },
          { trait_type: "body", value: `${nft.body}` },
          { trait_type: "mouth", value: `${nft.mouth}` },
          { trait_type: "eyes", value: `${nft.eyes}` },
          { trait_type: "tokenId", value: `${nft.tokenId}` },
          {
            display_type: "number",
            trait_type: "Serial No.",
            value: id,
            max_value: 1000,
          },
        ],
      };

      return res.json(resObj);
    } catch (error) {
      console.log("server error", error.message);
      next(error);
    }
  },
  get_nft_all: async (req, res, next) => {
    try {
      // console.log("id ?????????",id)
      // console.log("type of  ",typeof(id))
      // const n=Number(id)
      // console.log("type of  ",typeof(id))
      const nft = await models.NFT.findAndCountAll({
        limit: 10
      });
      // console.log(nft);
      if (!nft) {
        throw new Error("Token ID invalid");
      }

      // if (nft.isMinted) {
      //   throw new Error("Token not minted");
      // }
      // console.log(nft);
      // }
        var resObjarr = [];
        for (var i = 0; i < nft.rows.length; i++) {
           resObj = {
            name: nft.rows[i].name,
            description: nft.rows[i].description,
            image: `https://gateway.pinata.cloud/ipfs/${nft.rows[i].image}`,
            attributes: [
              { trait_type: "background", value: `${nft.rows[i].background}` },
              { trait_type: "body", value: `${nft.rows[i].body}` },
              { trait_type: "mouth", value: `${nft.rows[i].mouth}` },
              { trait_type: "eyes", value: `${nft.rows[i].eyes}` },
              { trait_type: "tokenId", value: `${nft.rows[i].tokenId}` },
              {
                display_type: "number",
                trait_type: "Serial No.",
                value: nft.rows[i].id,
                max_value: 1000,
              },
            ],
          };
          resObjarr.push(resObj);
      }
      console.log(JSON.stringify(resObjarr))
      return res.json(resObjarr);
    } catch (error) {
      console.log("server error", error.message);
      next(error);
    }
  },
  mint: async (req, res, next) => {
    try {
      const { id } = req.params;
      const updated = await models.NFT.findByPk(id);

      if (!updated) {
        throw new Error("NFT ID invalid");
      }
      if (updated.isMinted) {
        throw new Error("NFT Already minted");
      }
      updated.isMinted = true;
      updated.save();

      return res.json({
        data: "Token minted successfully",
        error: null,
        success: true,
      });
    } catch (error) {
      console.log("server error", error.message);
      next(error);
    }
  },
};

下面是routes文件夹中的内容。

const router = require("express").Router();
const auth=require("../middleware/auth")


const {
    create_nft,
    get_nft,
    get_nft_all,
    mint

} = require("../controller/nft");
router.post(
  "/create",
  create_nft
);


router.get(
    "/metadata/:id",
    get_nft
);

router.get(
    "/metadata",
    get_nft_all
);

router.put(
  "/mint/:id",
  mint
);


module.exports = router;

Answer 1

查看您的代码，您可能会在这部分中遇到一些不同步的问题：

      parsed.forEach(async (item) => {
        // return res.json(item)
        let newNft = await models.NFT.create({
          name: item.Name,
          description: item.Description,
          background: item.Background,
          body: item.Body,
          mouth: item.Mouth,
          eyes: item.Eyes,
          head_gear: item.Head_Gear,
          tokenId: item.tokenId,
          image: item.imagesIPFS,
        });
      });

因为.forEach是一个在同步上下文中使用的函数，而NFT.create返回一个promise (即异步)。所以事情发生得乱七八糟。

因此，一种方法是首先处理数据，然后使用Promise.all执行批处理操作。

    const data = parsed.map(item => {
       return models.NFT.create({
          name: item.Name,
          description: item.Description,
          background: item.Background,
          body: item.Body,
          mouth: item.Mouth,
          eyes: item.Eyes,
          head_gear: item.Head_Gear,
          tokenId: item.tokenId,
          image: item.imagesIPFS,
        })
    })

    const results = await Promise.all(data)

这里的主要区别是Promise.all resolves The N promises NFT.create in async context in paralell。但是，如果您注意到data可能太大而无法并行处理并发元数据的数量，那么您可以使用bluebird's Promise.map库提供的异步迭代。

    const Promise = require('bluebird')

    const data = await Promise.map(parsed, item => {
       return models.NFT.create({
          name: item.Name,
          description: item.Description,
          background: item.Background,
          body: item.Body,
          mouth: item.Mouth,
          eyes: item.Eyes,
          head_gear: item.Head_Gear,
          tokenId: item.tokenId,
          image: item.imagesIPFS,
        })
    })

    return data