@pinata/sdk 1.1.26 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinata/sdk",
-  "version": "1.1.26",
+  "version": "1.2.0",
   "description": "Official SDK for the Pinata IPFS platform",
   "main": "lib/pinata-sdk.js",
   "types": "types/index.d.ts",
@@ -36,7 +36,8 @@
   "devDependencies": {
     "@babel/cli": "^7.8.4",
     "@babel/core": "^7.8.4",
-    "@babel/preset-env": "^7.9.0",
+    "@babel/plugin-transform-runtime": "^7.19.1",
+    "@babel/preset-env": "^7.19.4",
     "@babel/register": "^7.8.3",
     "@types/node": "^15.6.1",
     "acorn": "^7.1.0",

package/src/commands/data/getFilesByCount/getFilesByCount.js

@@ -0,0 +1,70 @@
+import { validateApiKeys } from '../../../util/validators';
+import pinList from '../pinList/pinList';
+
+export default function getFilesByCount(
+    pinataApiKey,
+    pinataSecretApiKey,
+
+    filters = {},
+    maxCount = -1
+) {
+    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+    if (maxCount === 0) {
+        throw Error("Max count can't be 0");
+    }
+
+    const asyncIterable = {
+        [Symbol.asyncIterator]: () => {
+            let i = 0;
+            const pageLimit = 10;
+            let pageOffset = 0;
+            let cache = [];
+            let keepLooping = false;
+
+            return {
+                next() {
+                    return new Promise((resolve, reject) => {
+                        if (i === 0 || (i % pageLimit === 0 && keepLooping)) {
+                            resolve(
+                                pinList(pinataApiKey, pinataSecretApiKey, {
+                                    filters,
+                                    ...{ pageOffset, pageLimit }
+                                }).then((resp) => {
+                                    cache = resp.rows;
+                                    pageOffset = pageOffset + cache.length;
+
+                                    // If the user requested all pins we have to keep looping if the limit page was not fulfill
+                                    keepLooping =
+                                        cache.length !== 0 &&
+                                        (maxCount === -1 ?
+                                            cache.length === pageLimit :
+                                            i < maxCount);
+                                })
+                            );
+                        }
+                        resolve();
+                    }).then(() => {
+                        const valueToReturn = cache[i % pageLimit];
+
+                        const done = !(
+                            (maxCount === -1 ? i < pageOffset : i < maxCount) &&
+                            keepLooping
+                        );
+
+                        i++;
+                        return Promise.resolve({
+                            value: valueToReturn,
+                            done
+                        });
+                    });
+                },
+                return() {
+                    // This will be reached if the consumer called 'break' or 'return' early in the loop.
+                    return Promise.resolve({ value: i, done: true });
+                }
+            };
+        }
+    };
+
+    return asyncIterable;
+}

package/src/commands/data/pinList/pinList.js

@@ -8,12 +8,14 @@ import queryBuilder from './queryBuilder';
  * Pin List
  * @param {string} pinataApiKey
  * @param {string} pinataSecretApiKey
- * @param {string} filters
+ * @param {any} filters
  * @returns {Promise<unknown>}
  */
-export default function pinList(pinataApiKey, pinataSecretApiKey, filters) {
+export default function pinList(pinataApiKey, pinataSecretApiKey, filters = {}) {
     validateApiKeys(pinataApiKey, pinataSecretApiKey);
 
+    filters = {...filters, ...{includeCount: 'false' }};
+
     const baseEndpoint = `${baseUrl}/data/pinList`;
     const endpoint = queryBuilder(baseEndpoint, filters);
 

package/src/commands/data/pinList/queryBuilder.js

@@ -35,6 +35,10 @@ export default function queryBuilder(baseUrl, filters) {
 
     if (filters) {
         //  now we need to construct the actual URL based on the given filters provided
+        if (filters.includeCount) {
+            filterQuery = filterQuery + `includeCount=${filters.includeCount}&`;
+        }
+
         if (filters.hashContains) {
             if (typeof filters.hashContains !== 'string') {
                 throw new Error('hashContains value is not a string');

package/src/index.js

@@ -7,6 +7,7 @@ import pinJobs from './commands/pinning/pinJobs/pinJobs';
 import unpin from './commands/pinning/unpin';
 import testAuthentication from './commands/data/testAuthentication';
 import pinList from './commands/data/pinList/pinList';
+import getFilesByCount from './commands/data/getFilesByCount/getFilesByCount';
 import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
 
 // OPTIONS
@@ -250,6 +251,10 @@ export default function pinataClient(pinataApiKey, pinataSecretApiKey) {
     client.pinList = function (filters) {
         return pinList(pinataApiKey, pinataSecretApiKey, filters);
     };
+
+    client.getFilesByCount = function (filters, maxCount,) {
+        return getFilesByCount(pinataApiKey, pinataSecretApiKey, filters, maxCount);
+    };
     client.userPinnedDataTotal = function () {
         return userPinnedDataTotal(pinataApiKey, pinataSecretApiKey);
     };

package/test/commands/data/getFilesByCount/getFilesByCount.test.js

@@ -0,0 +1,215 @@
+import getFilesByCount from "../../../../src/commands/data/getFilesByCount/getFilesByCount";
+import axios from "axios";
+import { APIData, pinListAxiosMockPages, fakeHeaders } from "../pinlist-sample-api";
+
+jest.mock("axios");
+
+const metadataName = (item) => {
+    return item.metadata.name;
+};
+const callIterableObject = async (
+    pinataKey,
+    pinataSecret,
+    filterToApply,
+    pinsCount
+) => {
+    const pins = [];
+    for await (const item of getFilesByCount(
+        pinataKey,
+        pinataSecret,
+        filterToApply,
+        pinsCount
+    )) {
+        pins.push(metadataName(item));
+    }
+
+    return pins;
+};
+
+describe("Get Files By Count", () => {
+    const filterToApply = {
+        status: "pinned",
+    };
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test("Request 17 pins, pins available", async () => {
+        const pinsToRequest = 17;
+
+        axios.get
+            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
+            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
+
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply,
+            pinsToRequest
+        );
+
+        expect(pins).toEqual(
+            APIData.rows.slice(0, pinsToRequest).map(metadataName)
+        );
+        expect(pins).toHaveLength(pinsToRequest);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPage.url,
+            pinListAxiosMockPages.firstPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            2,
+            pinListAxiosMockPages.secondPage.url,
+            pinListAxiosMockPages.secondPage.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(2);
+    });
+
+    test("Request 6 pins, pins available", async () => {
+        const pinsToRequest = 6;
+
+        axios.get.mockResolvedValueOnce(
+            pinListAxiosMockPages.firstPage.response
+        );
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply,
+            pinsToRequest
+        );
+        expect(pins).toEqual(
+            APIData.rows.slice(0, pinsToRequest).map(metadataName)
+        );
+
+        expect(pins).toHaveLength(pinsToRequest);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPage.url,
+            pinListAxiosMockPages.firstPage.headers
+        );
+        expect(axios.get).toHaveBeenCalledTimes(1);
+    });
+
+    test("Request 25 pins, pins not available", async () => {
+        const pinsToRequest = 25;
+
+        axios.get
+            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
+            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
+            .mockResolvedValueOnce(
+                pinListAxiosMockPages.thirdPageEmpty.response
+            );
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply,
+            pinsToRequest
+        );
+
+        expect(pins).toEqual(
+            APIData.rows.slice(0, pinsToRequest).map(metadataName)
+        );
+
+        expect(pins).toHaveLength(20);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPage.url,
+            pinListAxiosMockPages.firstPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            2,
+            pinListAxiosMockPages.secondPage.url,
+            pinListAxiosMockPages.secondPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            3,
+            pinListAxiosMockPages.thirdPageEmpty.url,
+            pinListAxiosMockPages.thirdPageEmpty.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(3);
+    });
+
+    test("Request 3 pins, pins not available", async () => {
+        const pinsToRequest = 3;
+
+        axios.get.mockResolvedValueOnce(
+            pinListAxiosMockPages.firstPageEmpty.response
+        );
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply,
+            pinsToRequest
+        );
+
+        expect(pins).toEqual([]);
+
+        expect(pins).toHaveLength(0);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPageEmpty.url,
+            pinListAxiosMockPages.firstPageEmpty.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(1);
+    });
+
+    test("Request all pins, pins available", async () => {
+        axios.get
+            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
+            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
+            .mockResolvedValueOnce(
+                pinListAxiosMockPages.thirdPageEmpty.response
+            );
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply
+        );
+        expect(pins).toEqual(APIData.rows.map(metadataName));
+
+        expect(pins).toHaveLength(APIData.rows.length);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPage.url,
+            pinListAxiosMockPages.firstPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            2,
+            pinListAxiosMockPages.secondPage.url,
+            pinListAxiosMockPages.secondPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            3,
+            pinListAxiosMockPages.thirdPageEmpty.url,
+            pinListAxiosMockPages.thirdPageEmpty.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(3);
+    });
+
+    test("Request all pins, pins not available", async () => {
+        axios.get.mockResolvedValueOnce(
+            pinListAxiosMockPages.firstPageEmpty.response
+        );
+        const pins = await callIterableObject(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            filterToApply
+        );
+
+        expect(pins).toEqual([]);
+
+        expect(pins).toHaveLength(0);
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPageEmpty.url,
+            pinListAxiosMockPages.firstPageEmpty.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(1);
+    });
+});

package/test/commands/data/pinList/pinList.test.js

@@ -1,29 +1,98 @@
-import axios from 'axios';
-import pinList from './../../../../src/commands/data/pinList/pinList';
-
-jest.mock('axios');
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    axios.get.mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinList('test', 'test')).rejects.toEqual(Error(`unknown server response while attempting to retrieve user pin list: ${badStatus}`));
-});
+import axios from "axios";
+import pinList from "./../../../../src/commands/data/pinList/pinList";
+import {
+    APIData,
+    pinListAxiosMockPages,
+    fakeHeaders,
+} from "../pinlist-sample-api";
 
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    axios.get.mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinList('test', 'test')).resolves.toEqual(goodStatus.data);
-});
+jest.mock("axios");
+
+describe("Get Files By Count", () => {
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test("Call two pages in a row", async () => {
+        axios.get
+            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
+            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
+
+        const resp = await pinList(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            { pageLimit: 10, pageOffset: 0 }
+        );
+        const resp2 = await pinList(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            { pageLimit: 10, pageOffset: 10 }
+        );
+        expect(resp).toEqual(pinListAxiosMockPages.firstPage.response.data);
+        expect(resp2).toEqual(pinListAxiosMockPages.secondPage.response.data);
+
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPage.url,
+            pinListAxiosMockPages.firstPage.headers
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            2,
+            pinListAxiosMockPages.secondPage.url,
+            pinListAxiosMockPages.secondPage.headers
+        );
+
+        expect(axios.get).toHaveBeenCalledTimes(2);
+    });
+
+    test("Call empty page", async () => {
+        axios.get
+            .mockResolvedValueOnce(pinListAxiosMockPages.firstPageEmpty.response)
+
+
+        const resp = await pinList(
+            fakeHeaders.headers.pinata_api_key,
+            fakeHeaders.headers.pinata_secret_api_key,
+            { pageLimit: 10, pageOffset: 0 }
+        );
+        
+        expect(resp).toEqual({rows: []});
+
+
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            pinListAxiosMockPages.firstPageEmpty.url,
+            pinListAxiosMockPages.firstPageEmpty.headers
+        );
+        
+        expect(axios.get).toHaveBeenCalledTimes(1);
+    });
+    test("Result other than 200 status is returned", () => {
+        const badStatus = {
+            status: 700,
+        };
+        axios.get.mockResolvedValue(badStatus);
+        expect.assertions(1);
+        expect(pinList("test", "test")).rejects.toEqual(
+            Error(
+                `unknown server response while attempting to retrieve user pin list: ${badStatus}`
+            )
+        );
+    });
+
+    test("200 status is returned", () => {
+        const goodStatus = {
+            status: 200,
+            data: "testData",
+        };
+        axios.get.mockResolvedValue(goodStatus);
+        expect.assertions(1);
+        expect(pinList("test", "test")).resolves.toEqual(goodStatus.data);
+    });
 
-test('Rejection handled', () => {
-    axios.get.mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinList('test', 'test')).rejects.toEqual('test error');
+    test("Rejection handled", () => {
+        axios.get.mockRejectedValue("test error");
+        expect.assertions(1);
+        expect(pinList("test", "test")).rejects.toEqual("test error");
+    });
 });