@fileverse-dev/formulajs 4.4.38 → 4.4.41-example

package/lib/cjs/index.cjs

@@ -17697,15 +17697,16 @@ const aaveParamsSchema = objectType({
   category:  enumType(['tokens','markets']),
   param1:    stringType().nonempty(),
   param2:    stringType().optional(),
+  columnName: stringType().optional(),
 });
 
 async function AAVE() {
   try {
 
-    const [graphType, category, param1, param2] = argsToArray(arguments);
+    const [graphType, category, param1, param2, columnName] = argsToArray(arguments);
 
 
-    validateParams(aaveParamsSchema, { graphType, category, param1, param2 });
+    validateParams(aaveParamsSchema, { graphType, category, param1, param2, columnName });
 
     const baseUrl = 'https://onchain-proxy.fileverse.io/third-party';
     const url =
@@ -17722,16 +17723,25 @@ async function AAVE() {
     }
 
     const json = await res.json();
+    const filterColumnName = columnName?.split(',').map(s => s.trim());
+
     if (Array.isArray(json)) {
       return json.map(item => {
         const flat = {};
         Object.entries(item).forEach(([k, v]) => {
-          if (v === null || typeof v !== 'object') flat[k] = v;
+          if ((columnName && filterColumnName.includes(k)) && (v === null || typeof v !== 'object')) flat[k] = v;
         });
         return flat
       })
     }
-    return json
+    if(columnName && typeof json === 'object') {
+      const data = {};
+      filterColumnName.forEach(k => {
+        data[k] = json[k];
+      });
+      return data
+    }
+    return json;
   } catch (err) {
     return errorMessageHandler(err, 'AAVE')
   }
@@ -17771,6 +17781,7 @@ const baseSchema = objectType({
   endTime:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
   offset:    numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"offset" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+  columnName: stringType().optional(),
 });
 
 const eoaParamsSchema = preprocessType(
@@ -18000,9 +18011,9 @@ function toTimestamp(dateStr) {
 
 async function EOA() {
   try {
-    const [addresses, category, chains, startTime, endTime, page = 1, offset = 10] =
+    const [addresses, category, chains, startTime, endTime, page = 1, offset = 10, columnName = null] =
       argsToArray(arguments);
-    validateParams(eoaParamsSchema, { addresses, category, chains, startTime, endTime, page, offset });
+    validateParams(eoaParamsSchema, { addresses, category, chains, startTime, endTime, page, offset, columnName });
 
     const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
 
@@ -18072,6 +18083,16 @@ async function EOA() {
         }
       }
     }
+    if(columnName){
+      const filterColumnName = columnName.split(',').map(s => s.trim());
+      return out.map(obj =>
+        Object.fromEntries(
+          filterColumnName
+            .filter(key => key in obj)
+            .map(key => [key, obj[key]])
+        )
+      );
+    }
     return out
   } catch (err) {
     return errorMessageHandler(err, 'EOA')
@@ -18084,6 +18105,7 @@ const gasSchema$1 = objectType({
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
   limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+  columnName: stringType().optional(),
 });
 
 const txnSchema$1 = objectType({
@@ -18093,6 +18115,7 @@ const txnSchema$1 = objectType({
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
   limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+  columnName: stringType().optional(),
 });
 
 const baseParamsSchema = discriminatedUnionType('type', [gasSchema$1, txnSchema$1]);
@@ -18169,11 +18192,11 @@ async function handleScanRequest({
 
 async function BASE() {
   try {
-    const [type, address, startDate, endDate, page, limit] = argsToArray(arguments);
-    validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit });
+    const [type, address, startDate, endDate, page, limit, columnName] = argsToArray(arguments);
+    validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit, columnName });
     const API_KEY = window.localStorage.getItem(SERVICES_API_KEY.Basescan);
 
-    return await handleScanRequest({
+    const out = await handleScanRequest({
       type,
       address,
       startDate,
@@ -18184,7 +18207,18 @@ async function BASE() {
       functionName: 'BASE',
       chainId: CHAIN_ID_MAP.base,
       network: 'base'
-    })
+    });
+    if (columnName) {
+      const filterColumnName = columnName.split(',').map(s => s.trim());
+      return out.map(obj =>
+        Object.fromEntries(
+          filterColumnName
+            .filter(key => key in obj)
+            .map(key => [key, obj[key]])
+        )
+      );
+    }
+    return out
   } catch (error) {
     return errorMessageHandler(error, 'BASE')
   }
@@ -18304,6 +18338,7 @@ const derivativesSchema = objectType({
   category: literalType('derivatives'),
   param1:   stringType().nonempty(),
   param2:   anyType().optional(),
+  columnName: stringType().optional(),
 });
 const coingeckoParamsSchema = discriminatedUnionType('category', [
   priceSchema$1,
@@ -18315,11 +18350,10 @@ const coingeckoParamsSchema = discriminatedUnionType('category', [
 /* global window */
 
 
-
 async function COINGECKO() {
   try {
-    const [category, param1, param2] = argsToArray(arguments);
-    validateParams(coingeckoParamsSchema, { category, param1, param2 });
+    const [category, param1, param2, columnName = null] = argsToArray(arguments);
+    validateParams(coingeckoParamsSchema, { category, param1, param2, columnName });
 
     const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Coingecko);
 
@@ -18354,7 +18388,7 @@ async function COINGECKO() {
         break
       }
     }
-    const {URL: finalUrl, HEADERS} = getUrlAndHeaders({url, serviceName: 'Coingecko', headers});
+    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Coingecko', headers });
 
     const res = await fetch(finalUrl + "?refresh=true", { headers: HEADERS });
     const json = await res.json();
@@ -18380,6 +18414,16 @@ async function COINGECKO() {
           flat[key] = value;
         }
       }
+      if (columnName) {
+        const filterData = {};
+        const filterColumnName = columnName.split(',').map(s => s.trim());
+        filterColumnName.forEach(col => {
+          if (flat[col] !== undefined) {
+            filterData[col] = flat[col];
+          }
+        });
+        return filterData;
+      }
       return flat
     })
   } catch (err) {
@@ -18389,7 +18433,8 @@ async function COINGECKO() {
 
 const categories = ['protocols','yields','dex','fees'];
 const defillamaParamsSchema = objectType({
-  category: enumType(categories)
+  category: enumType(categories),
+  columnName: stringType().optional(),
 });
 
 const CATEGORY_URLS = {
@@ -18401,8 +18446,8 @@ const CATEGORY_URLS = {
 
 async function DEFILLAMA() {
   try {
-    const [category] = argsToArray(arguments);
-    validateParams(defillamaParamsSchema, { category });
+    const [category, columnName = null] = argsToArray(arguments);
+    validateParams(defillamaParamsSchema, { category, columnName });
     const url = CATEGORY_URLS[category];
     if (!url) throw new ValidationError(`Invalid category: ${category}`)
     const res = await fetch(url);
@@ -18422,10 +18467,12 @@ async function DEFILLAMA() {
         break
     }
 
+    const filterColumnName = columnName?.split(',').map(s => s.trim());
+
     return (Array.isArray(json) ? json : [json]).map(item => {
       const out = {};
       for (const [k, v] of Object.entries(item)) {
-        if (v === null || typeof v !== 'object') out[k] = v;
+        if ((columnName && filterColumnName.includes(k)) && (v === null || typeof v !== 'object')) out[k] = v;
       }
       return out
     })
@@ -18440,6 +18487,7 @@ const gasSchema = objectType({
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
   limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+  columnName: stringType().optional(),
 });
 
 const txnSchema = objectType({
@@ -18450,6 +18498,7 @@ const txnSchema = objectType({
     chain:     enumType(['ethereum','base','gnosis']),
   page:      numberType().int().nonnegative().default(1),
   limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+  columnName: stringType().optional(),
 });
 
 const etherscanParamsSchema = discriminatedUnionType('type', [gasSchema, txnSchema]);
@@ -18463,18 +18512,18 @@ const etherscanParamsSchema = discriminatedUnionType('type', [gasSchema, txnSche
 
 async function ETHERSCAN() {
   try {
-    const [type, chain, address, startDate, endDate, page = 1, limit = 10] =
+    const [type, chain, address, startDate, endDate, page = 1, limit = 10, columnName = null] =
       argsToArray(arguments);
 
 
-    validateParams(etherscanParamsSchema, { type, chain, address, startDate, endDate, page, limit });
+    validateParams(etherscanParamsSchema, { type, chain, address, startDate, endDate, page, limit, columnName });
 
     const chainId = CHAIN_ID_MAP[chain];
     if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
 
     const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
 
-    return await handleScanRequest({
+    const out = await handleScanRequest({
       type,
       address,
       startDate,
@@ -18485,7 +18534,18 @@ async function ETHERSCAN() {
       functionName: 'ETHERSCAN',
       chainId,
       network: chain,
-    })
+    });
+    if (columnName) {
+      const filterColumnName = columnName.split(',').map(s => s.trim());
+      return out.map(obj =>
+        Object.fromEntries(
+          filterColumnName
+            .filter(key => key in obj)
+            .map(key => [key, obj[key]])
+        )
+      );
+    }
+    return out
   } catch (err) {
     return errorMessageHandler(err, 'ETHERSCAN')
   }
@@ -18924,13 +18984,14 @@ const uniswapParamsSchema = objectType({
   category:  enumType(['tokens','markets']),
   param1:    stringType().nonempty(),
   param2:    stringType().optional(),
+  colummnName: stringType().optional(),
 });
 
 async function UNISWAP() {
   try {
-    const [graphType, category, param1, param2] = argsToArray(arguments);
+    const [graphType, category, param1, param2, columnName] = argsToArray(arguments);
 
-    validateParams(uniswapParamsSchema, { graphType, category, param1, param2 });
+    validateParams(uniswapParamsSchema, { graphType, category, param1, param2, columnName });
 
     const baseUrl = 'https://onchain-proxy.fileverse.io/third-party';
     const url =
@@ -18948,16 +19009,24 @@ async function UNISWAP() {
     }
 
     const json = await res.json();
+    const filterColumnName = columnName?.split(',').map(s => s.trim());
     if (Array.isArray(json)) {
       // flatten nested
       return json.map(item => {
         const flat = {};
         Object.entries(item).forEach(([k, v]) => {
-          if (v === null || typeof v !== 'object') flat[k] = v;
+          if ((columnName && filterColumnName.includes(k)) && (v === null || typeof v !== 'object')) flat[k] = v;
         });
         return flat
       })
     }
+    if(columnName && typeof json === 'object') {
+      const data = {};
+      filterColumnName.forEach(k => {
+        data[k] = json[k];
+      });
+      return data
+    }
     return json
   } catch (err) {
     return errorMessageHandler(err, 'UNISWAP')
@@ -18967,6 +19036,7 @@ async function UNISWAP() {
 async function SMARTCONTRACT() {
   try {
     const args = argsToArray(arguments);
+    console.log(args, arguments);
 
     return new Promise((resolve) => {
     resolve( {
@@ -29870,14 +29940,15 @@ class CirclesData {
 const circlesParamsSchema = objectType({
   functionName: enumType(['trust', 'profile', 'transactions', 'balances']),
   address: stringType().nonempty(),
-  entries: numberType().int().nonnegative().default(10)
+  entries: numberType().int().nonnegative().default(10),
+  columnName: stringType().optional(),
 });
 
 async function CIRCLES() {
   try {
-    const [functionName, address, entries] = argsToArray(arguments);
+    const [functionName, address, entries, columnName] = argsToArray(arguments);
 
-    validateParams(circlesParamsSchema, { functionName, address, entries });
+    validateParams(circlesParamsSchema, { functionName, address, entries, columnName });
 
     const resolved = await fromEnsNameToAddress$1.validateAndGetAddress(address);
     const dataClient = new CirclesData('https://rpc.aboutcircles.com');
@@ -29895,10 +29966,34 @@ async function CIRCLES() {
 
     switch (functionName) {
       case 'trust':
-        return await runOnePage(dataClient.getTrustRelations(resolved, limit))
+        const dataTrust = await runOnePage(dataClient.getTrustRelations(resolved, limit));
+        if (columnName) {
+          const filterColumnName = columnName.split(',').map(s => s.trim());
+          return dataTrust.map(obj =>
+            Object.fromEntries(
+              filterColumnName
+                .filter(key => key in obj)
+                .map(key => [key, obj[key]])
+            )
+          );
+        } else {
+          return dataTrust;
+        }
 
       case 'transactions':
-        return await runOnePage(dataClient.getTransactionHistory(resolved, limit))
+        const data = await runOnePage(dataClient.getTransactionHistory(resolved, limit));
+        if (columnName) {
+          const filterColumnName = columnName.split(',').map(s => s.trim());
+          return data.map(obj =>
+            Object.fromEntries(
+              filterColumnName
+                .filter(key => key in obj)
+                .map(key => [key, obj[key]])
+            )
+          );
+        } else {
+          return data;
+        }
 
       case 'profile': {
         const res = await dataClient.getAvatarInfo(resolved);