@solana/rpc-graphql 2.0.0-experimental.b153bb7 → 2.0.0-experimental.b419cd0

package/dist/index.node.cjs

@@ -1,8 +1,15 @@
 'use strict';
 
 var graphql = require('graphql');
+var DataLoader = require('dataloader');
+var fastStableStringify = require('fast-stable-stringify');
 var schema = require('@graphql-tools/schema');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
+var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableStringify);
+
 // src/rpc.ts
 
 // src/cache.ts
@@ -36,8 +43,8 @@ function createGraphQLCache() {
   };
 }
 
-// src/loaders/account.ts
-function onlyAddressRequested(info) {
+// src/loaders/common/resolve-info.ts
+function onlyPresentFieldRequested(fieldName, info) {
   if (info && info.fieldNodes[0].selectionSet) {
     const selectionSet = info.fieldNodes[0].selectionSet;
     const requestedFields = selectionSet.selections.map((field) => {
@@ -46,12 +53,24 @@ function onlyAddressRequested(info) {
       }
       return null;
     });
-    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === "address") {
+    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === fieldName) {
       return true;
     }
   }
   return false;
 }
+
+// src/loaders/account.ts
+function normalizeArgs(args) {
+  const { address, commitment, dataSlice, encoding, minContextSlot } = args;
+  return {
+    address,
+    commitment: commitment ?? "confirmed",
+    dataSlice,
+    encoding: encoding ?? "jsonParsed",
+    minContextSlot
+  };
+}
 function refineJsonParsedAccountData(jsonParsedAccountData) {
   const meta = {
     program: jsonParsedAccountData.program,
@@ -77,86 +96,44 @@ function processQueryResponse({ address, account, encoding }) {
     data: refinedData
   };
 }
-async function loadAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc, info) {
-  if (onlyAddressRequested(info)) {
-    return { address };
-  }
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(address, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  const account = await rpc.getAccountInfo(address, requestConfig).send().then((res) => res.value).catch((e) => {
+async function loadAccount(rpc, { address, ...config }) {
+  const { encoding } = config;
+  const account = await rpc.getAccountInfo(address, config).send().then((res) => res.value).catch((e) => {
     throw e;
   });
   if (account === null) {
     return { address };
   }
-  const queryResponse = processQueryResponse({ account, address, encoding });
-  cache.insert(address, requestConfig, queryResponse);
-  return queryResponse;
+  return processQueryResponse({ account, address, encoding });
 }
-
-// src/loaders/block.ts
-async function loadBlock({ slot, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  const requestConfig = {
-    encoding,
-    ...config,
-    // Always use 0 to avoid silly errors
-    maxSupportedTransactionVersion: 0
+function createAccountBatchLoadFn(rpc) {
+  const resolveAccountUsingRpc = loadAccount.bind(null, rpc);
+  return async (accountQueryArgs) => {
+    return await Promise.all(accountQueryArgs.map(async (args) => await resolveAccountUsingRpc(args)));
   };
-  const cached = cache.get(slot, config);
-  if (cached !== null) {
-    return cached;
-  }
-  const block = await rpc.getBlock(slot, requestConfig).send();
-  if (block === null) {
-    return null;
-  }
-  cache.insert(slot, config, block);
-  return block;
-}
-
-// src/loaders/program-accounts.ts
-function processQueryResponse2({ encoding, programAccounts }) {
-  return programAccounts.map((programAccount) => {
-    const [refinedData, responseEncoding] = Array.isArray(programAccount.account.data) ? encoding === "jsonParsed" ? [programAccount.account.data[0], "base64"] : [programAccount.account.data[0], encoding] : [refineJsonParsedAccountData(programAccount.account.data), "jsonParsed"];
-    const pubkey = programAccount.pubkey;
-    const responseBase = {
-      ...programAccount.account,
-      address: pubkey,
-      encoding: responseEncoding
-    };
-    return typeof refinedData === "object" && "meta" in refinedData ? {
-      ...responseBase,
-      data: refinedData.data,
-      meta: refinedData.meta
-    } : {
-      ...responseBase,
-      data: refinedData
-    };
-  });
 }
-async function loadProgramAccounts({ programAddress, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(programAddress, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  const programAccounts = await rpc.getProgramAccounts(programAddress, requestConfig).send().then((res) => {
-    if ("value" in res) {
-      return res.value;
+function createAccountLoader(rpc) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("address", info)) {
+        return { address: args.address };
+      }
+      return loader.load(normalizeArgs(args));
     }
-    return res;
-  }).catch((e) => {
-    throw e;
-  });
-  const queryResponse = processQueryResponse2({ encoding, programAccounts });
-  cache.insert(programAddress, requestConfig, queryResponse);
-  return queryResponse;
+  };
 }
 
 // src/loaders/transaction.ts
+function normalizeArgs2(args) {
+  const { commitment, encoding } = args;
+  return {
+    commitment: commitment ?? "confirmed",
+    encoding: encoding ?? "jsonParsed",
+    // Always use 0 to avoid silly errors
+    maxSupportedTransactionVersion: 0
+  };
+}
 function refineJsonParsedInstructionData(jsonParsedInstructionData) {
   if ("parsed" in jsonParsedInstructionData) {
     const meta = {
@@ -194,36 +171,36 @@ function refineJsonParsedTransactionMeta(jsonParsedTransactionMeta) {
     innerInstructions: refinedInnerInstructions
   };
 }
-function processQueryResponse3({ encoding, transaction }) {
-  const [transactionData, transactionMeta, responseEncoding] = Array.isArray(transaction.transaction) ? [transaction.transaction[0], transaction.meta, encoding] : [
-    refineJsonParsedTransactionData(transaction.transaction),
-    refineJsonParsedTransactionMeta(transaction.meta),
-    encoding
-  ];
+function refineJsonParsedTransaction({ encoding, transaction }) {
+  const [transactionData, transactionMeta] = Array.isArray(transaction.transaction) ? [transaction.transaction[0], transaction.meta] : [refineJsonParsedTransactionData(transaction.transaction), refineJsonParsedTransactionMeta(transaction.meta)];
   return {
-    ...transaction,
     data: transactionData,
-    encoding: responseEncoding,
-    meta: transactionMeta
-  };
-}
-async function loadTransaction({ signature, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  const requestConfig = {
     encoding,
-    ...config,
-    // Always use 0 to avoid silly errors
-    maxSupportedTransactionVersion: 0
+    meta: transactionMeta,
+    slot: transaction.slot,
+    version: transaction.version
   };
+}
+function processQueryResponse2({ encoding, transaction }) {
+  return refineJsonParsedTransaction({ encoding, transaction });
+}
+async function loadTransaction({ signature, ...config }, cache, rpc, _info) {
+  const requestConfig = normalizeArgs2(config);
+  const { encoding } = requestConfig;
   const cached = cache.get(signature, requestConfig);
   if (cached !== null) {
     return cached;
   }
-  let transaction = await rpc.getTransaction(signature, requestConfig).send();
+  let transaction = await rpc.getTransaction(signature, requestConfig).send().catch((e) => {
+    throw e;
+  });
   if (transaction === null) {
     return null;
   }
   if (encoding !== "jsonParsed") {
-    const transactionJsonParsed = await rpc.getTransaction(signature, requestConfig).send();
+    const transactionJsonParsed = await rpc.getTransaction(signature, requestConfig).send().catch((e) => {
+      throw e;
+    });
     if (transactionJsonParsed === null) {
       return null;
     }
@@ -233,22 +210,140 @@ async function loadTransaction({ signature, encoding = "jsonParsed", ...config }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
   }
-  const queryResponse = processQueryResponse3({ encoding, transaction });
+  const queryResponse = processQueryResponse2({ encoding, transaction });
   cache.insert(signature, requestConfig, queryResponse);
   return queryResponse;
 }
 
+// src/loaders/block.ts
+function normalizeArgs3(args) {
+  const { commitment, encoding, slot, transactionDetails } = args;
+  return {
+    commitment: commitment ?? "confirmed",
+    encoding: encoding ?? "jsonParsed",
+    // Always use 0 to avoid silly errors
+    maxSupportedTransactionVersion: 0,
+    slot,
+    transactionDetails: transactionDetails ?? "full"
+  };
+}
+function refineJsonParsedTransactionForAccounts({ transaction }) {
+  return {
+    data: transaction.transaction,
+    meta: transaction.meta,
+    version: transaction.version
+  };
+}
+function processQueryResponse3({
+  encoding,
+  block,
+  transactionDetails
+}) {
+  if (typeof block === "object" && "transactions" in block) {
+    const refinedBlock = {
+      ...block,
+      transactions: block.transactions.map((transaction) => {
+        if (transactionDetails === "accounts") {
+          return refineJsonParsedTransactionForAccounts({ transaction });
+        } else {
+          return refineJsonParsedTransaction({ encoding, transaction });
+        }
+      })
+    };
+    block = refinedBlock;
+  }
+  return {
+    ...block,
+    encoding,
+    transactionDetails
+  };
+}
+async function loadBlock(rpc, { slot, ...config }) {
+  const { encoding, transactionDetails } = config;
+  const block = await rpc.getBlock(slot, config).send().catch((e) => {
+    throw e;
+  });
+  if (block === null) {
+    return { slot };
+  }
+  const queryResponse = processQueryResponse3({ block, encoding, transactionDetails });
+  return queryResponse;
+}
+function createBlockBatchLoadFn(rpc) {
+  const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
+  return async (blockQueryArgs) => {
+    return await Promise.all(blockQueryArgs.map(async (args) => await resolveBlockUsingRpc(args)));
+  };
+}
+function createBlockLoader(rpc) {
+  const loader = new DataLoader__default.default(createBlockBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("slot", info)) {
+        return { slot: args.slot };
+      }
+      return loader.load(normalizeArgs3(args));
+    }
+  };
+}
+
+// src/loaders/program-accounts.ts
+function normalizeArgs4(args) {
+  const { commitment, dataSlice, encoding, filters, minContextSlot } = args;
+  return {
+    commitment: commitment ?? "confirmed",
+    dataSlice,
+    encoding: encoding ?? "jsonParsed",
+    filters,
+    minContextSlot
+  };
+}
+function processQueryResponse4({ encoding, programAccounts }) {
+  return programAccounts.map((programAccount) => {
+    const [refinedData, responseEncoding] = Array.isArray(programAccount.account.data) ? encoding === "jsonParsed" ? [programAccount.account.data[0], "base64"] : [programAccount.account.data[0], encoding] : [refineJsonParsedAccountData(programAccount.account.data), "jsonParsed"];
+    const pubkey = programAccount.pubkey;
+    const responseBase = {
+      ...programAccount.account,
+      address: pubkey,
+      encoding: responseEncoding
+    };
+    return typeof refinedData === "object" && "meta" in refinedData ? {
+      ...responseBase,
+      data: refinedData.data,
+      meta: refinedData.meta
+    } : {
+      ...responseBase,
+      data: refinedData
+    };
+  });
+}
+async function loadProgramAccounts({ programAddress, ...config }, cache, rpc, _info) {
+  const requestConfig = normalizeArgs4(config);
+  const { encoding } = requestConfig;
+  const cached = cache.get(programAddress, requestConfig);
+  if (cached !== null) {
+    return cached;
+  }
+  const programAccounts = await rpc.getProgramAccounts(programAddress, requestConfig).send().then((res) => {
+    if ("value" in res) {
+      return res.value;
+    }
+    return res;
+  }).catch((e) => {
+    throw e;
+  });
+  const queryResponse = processQueryResponse4({ encoding, programAccounts });
+  cache.insert(programAddress, requestConfig, queryResponse);
+  return queryResponse;
+}
+
 // src/context.ts
 function createSolanaGraphQLContext(rpc) {
   const cache = createGraphQLCache();
   return {
+    accountLoader: createAccountLoader(rpc),
+    blockLoader: createBlockLoader(rpc),
     cache,
-    loadAccount(args, info) {
-      return loadAccount(args, this.cache, this.rpc, info);
-    },
-    loadBlock(args, info) {
-      return loadBlock(args, this.cache, this.rpc);
-    },
     loadProgramAccounts(args, info) {
       return loadProgramAccounts(args, this.cache, this.rpc);
     },
@@ -261,7 +356,7 @@ function createSolanaGraphQLContext(rpc) {
 
 // src/resolvers/account.ts
 var resolveAccount = (fieldName) => {
-  return (parent, args, context, info) => parent[fieldName] === null ? null : context.loadAccount({ ...args, address: parent[fieldName] }, info);
+  return (parent, args, context, info) => parent[fieldName] === null ? null : context.accountLoader.load({ ...args, address: parent[fieldName] }, info);
 };
 
 // src/schema/account.ts
@@ -602,59 +697,79 @@ var blockTypeDefs = (
 
     # Block interface
     interface Block {
-        blockHeight: BigInt
-        blockTime: BigInt
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
+        transactionDetails: String
     }
 
     # A block with account transaction details
-    type BlockWithAccounts {
-        blockHeight: BigInt
-        blockTime: BigInt
+    type BlockWithAccounts implements Block {
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
         transactions: [BlockTransactionAccounts]
+        transactionDetails: String
     }
 
     # A block with full transaction details
-    type BlockFull {
-        blockHeight: BigInt
-        blockTime: BigInt
+    type BlockWithFull implements Block {
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
         transactions: [Transaction]
+        transactionDetails: String
     }
 
     # A block with none transaction details
-    type BlockWithNone {
-        blockHeight: BigInt
-        blockTime: BigInt
+    type BlockWithNone implements Block {
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
+        transactionDetails: String
     }
 
     # A block with signature transaction details
-    type BlockWithSignatures {
-        blockHeight: BigInt
-        blockTime: BigInt
+    type BlockWithSignatures implements Block {
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
         signatures: [String]
+        transactionDetails: String
     }
 `
 );
-var blockResolvers = {};
+var blockResolvers = {
+  Block: {
+    __resolveType(block) {
+      switch (block.transactionDetails) {
+        case "accounts":
+          return "BlockWithAccounts";
+        case "none":
+          return "BlockWithNone";
+        case "signatures":
+          return "BlockWithSignatures";
+        default:
+          return "BlockWithFull";
+      }
+    }
+  }
+};
 
 // src/schema/common/inputs.ts
 var inputTypeDefs = (
@@ -2875,10 +2990,10 @@ var schemaTypeDefs = (
 var schemaResolvers = {
   Query: {
     account(_, args, context, info) {
-      return context.loadAccount(args, info);
+      return context.accountLoader.load(args, info);
     },
     block(_, args, context, info) {
-      return context.loadBlock(args, info);
+      return context.blockLoader.load(args, info);
     },
     programAccounts(_, args, context, info) {
       return context.loadProgramAccounts(args, info);