@pinata/sdk 1.1.26 → 1.2.1

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
@@ -198,8 +199,16 @@ import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
  * @returns {Promise<number>}
  */
 
+/**
+ * @typedef {Object} PinataConfig
+ * @property {string} [pinataApiKey]
+ * @property {string} [pinataSecretApiKey]
+ * @property {string} [pinataJWTKey]
+ */
+
 /**
  * @typedef PinataClient
+ * @property {PinataConfig} config
  * @property {pinByHash} pinByHash
  * @property {hashMetadata} hashMetadata
  * @property {pinFileToIPFS} pinFileToIPFS
@@ -212,46 +221,87 @@ import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
  * @property {userPinnedDataTotal} userPinnedDataTotal
  */
 
+function refactorConfig(pinataConfigParam) {
+    const config = {};
+    if (pinataConfigParam.pinataApiKey) {
+        config.pinataApiKey = pinataConfigParam.pinataApiKey;
+    }
+
+    if (pinataConfigParam.pinataSecretApiKey) {
+        config.pinataSecretApiKey = pinataConfigParam.pinataSecretApiKey;
+    }
+
+    if (pinataConfigParam.pinataJWTKey) {
+        config.pinataJWTKey = pinataConfigParam.pinataJWTKey;
+    }
+
+    return config;
+}
+function sanitizeConfig(pinataApiKey, pinataSecretApiKey) {
+    let config = {};
+
+    if (
+        typeof pinataApiKey === 'string' &&
+        typeof pinataSecretApiKey === 'string'
+    ) {
+        config.pinataApiKey = pinataApiKey;
+        config.pinataSecretApiKey = pinataSecretApiKey;
+    }
+
+    const isPinataConfigParam = typeof pinataApiKey === 'object';
+    if (isPinataConfigParam) {
+        config = refactorConfig(pinataApiKey);
+    }
+
+    return config;
+}
+
 /**
  * Pinata Client
  *
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
+ * @param {string | PinataConfig} [pinataApiKey]
+ * @param {string} [pinataSecretApiKey]
  * @returns {PinataClient}
  */
 export default function pinataClient(pinataApiKey, pinataSecretApiKey) {
-    let client = {};
+    const client = {
+        config: sanitizeConfig(pinataApiKey, pinataSecretApiKey)
+    };
 
     //  setting up the actual calls you can make using this package
     client.pinByHash = function (hashToPin, options) {
-        return pinByHash(pinataApiKey, pinataSecretApiKey, hashToPin, options);
+        return pinByHash(client.config, hashToPin, options);
     };
     client.hashMetadata = function (ipfsPinHash, metadata) {
-        return hashMetadata(pinataApiKey, pinataSecretApiKey, ipfsPinHash, metadata);
+        return hashMetadata(client.config, ipfsPinHash, metadata);
     };
     client.pinFileToIPFS = function (readableStream, options) {
-        return pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readableStream, options);
+        return pinFileToIPFS(client.config, readableStream, options);
     };
     client.pinFromFS = function (sourcePath, options) {
-        return pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath, options);
+        return pinFromFS(client.config, sourcePath, options);
     };
     client.pinJSONToIPFS = function (body, options) {
-        return pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, options);
+        return pinJSONToIPFS(client.config, body, options);
     };
     client.pinJobs = function (filters) {
-        return pinJobs(pinataApiKey, pinataSecretApiKey, filters);
+        return pinJobs(client.config, filters);
     };
     client.unpin = function (hashToUnpin) {
-        return unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin);
+        return unpin(client.config, hashToUnpin);
     };
     client.testAuthentication = function () {
-        return testAuthentication(pinataApiKey, pinataSecretApiKey);
+        return testAuthentication(client.config);
     };
     client.pinList = function (filters) {
-        return pinList(pinataApiKey, pinataSecretApiKey, filters);
+        return pinList(client.config, filters);
+    };
+
+    client.getFilesByCount = function (filters, maxCount) {
+        return getFilesByCount(client.config, filters, maxCount);
     };
     client.userPinnedDataTotal = function () {
-        return userPinnedDataTotal(pinataApiKey, pinataSecretApiKey);
+        return userPinnedDataTotal(client.config);
     };
     return client;
 }

package/src/util/validators.js

@@ -1,5 +1,5 @@
 import isIPFS from 'is-ipfs';
-
+import { ERROR_NO_CREDENTIALS_PROVIDED} from '../constants';
 /**
  * Validate API Keys
  * @param {string} pinataApiKey
@@ -7,11 +7,53 @@ import isIPFS from 'is-ipfs';
  */
 export function validateApiKeys(pinataApiKey, pinataSecretApiKey) {
     if (!pinataApiKey || pinataApiKey === '') {
-        throw new Error('No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script');
+        throw new Error(
+            'No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script'
+        );
     }
     if (!pinataSecretApiKey || pinataSecretApiKey === '') {
-        throw new Error('No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script');
+        throw new Error(
+            'No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script'
+        );
+    }
+}
+
+export function createConfigForAxiosHeaders(config) {
+    if (
+        config.pinataApiKey && config.pinataApiKey.length > 0 &&
+        config.pinataSecretApiKey && config.pinataSecretApiKey.length > 0
+    ) {
+        return {
+            withCredentials: true,
+            headers: {
+                pinata_api_key: config.pinataApiKey,
+                pinata_secret_api_key: config.pinataSecretApiKey
+            }
+        };
+    }
+
+    if (config.pinataJWTKey && config.pinataJWTKey.length > 0) {
+        return {
+            headers: {
+                Authorization: `Bearer ${config.pinataJWTKey}`
+            }
+        };
     }
+
+    throw new Error(ERROR_NO_CREDENTIALS_PROVIDED);
+}
+
+export function createConfigForAxiosHeadersWithFormData(config, boundaryValue) {
+    const requestOptions = {
+        ...createConfigForAxiosHeaders(config),
+        maxContentLength: Infinity, //this is needed to prevent axios from erroring out with large files
+        maxBodyLength: Infinity
+    };
+
+    requestOptions.headers[
+        'Content-type'
+    ] = `multipart/form-data; boundary= ${boundaryValue}`;
+    return requestOptions;
 }
 
 /**
@@ -24,7 +66,9 @@ export function validateHostNodes(hostNodes) {
     }
     hostNodes.forEach((node) => {
         if (!isIPFS.peerMultiaddr(node)) {
-            throw new Error(`host_node array entry: ${node} is not a valid peer multiaddr`);
+            throw new Error(
+                `host_node array entry: ${node} is not a valid peer multiaddr`
+            );
         }
     });
 }
@@ -35,7 +79,12 @@ export function validateHostNodes(hostNodes) {
  */
 export function validateMetadata(metadata) {
     if (metadata.name) {
-        if (!(typeof metadata.name === 'string' || metadata.name instanceof String)) {
+        if (
+            !(
+                typeof metadata.name === 'string' ||
+                metadata.name instanceof String
+            )
+        ) {
             throw new Error('metadata name must be of type string');
         }
     }
@@ -49,11 +98,21 @@ export function validateMetadata(metadata) {
 
         Object.entries(metadata.keyvalues).forEach(function (keyValue) {
             if (i > 9) {
-                throw new Error('No more than 10 keyvalues can be provided for metadata entries');
+                throw new Error(
+                    'No more than 10 keyvalues can be provided for metadata entries'
+                );
             }
             //  we want to make sure that the input is a string, a boolean, or a number, so we don't get an object passed in by accident
-            if (!(typeof keyValue[1] === 'string' || typeof keyValue[1] === 'boolean' || !isNaN(keyValue[1]))) {
-                throw new Error('Metadata keyvalue values must be strings, booleans, or numbers');
+            if (
+                !(
+                    typeof keyValue[1] === 'string' ||
+                    typeof keyValue[1] === 'boolean' ||
+                    !isNaN(keyValue[1])
+                )
+            ) {
+                throw new Error(
+                    'Metadata keyvalue values must be strings, booleans, or numbers'
+                );
             }
             i++;
         });
@@ -75,11 +134,23 @@ export function validatePinPolicyStructure(pinPolicy) {
     }
     if (pinPolicy.regions.length) {
         pinPolicy.regions.forEach((region) => {
-            if (!region.id || !(Object.prototype.toString.call(region.id) === '[object String]')) {
+            if (
+                !region.id ||
+                !(
+                    Object.prototype.toString.call(region.id) ===
+                    '[object String]'
+                )
+            ) {
                 throw new Error('region id must be a string');
             }
 
-            if (!(region.desiredReplicationCount || region.desiredReplicationCount === 0) || !Number.isInteger(region.desiredReplicationCount)) {
+            if (
+                !(
+                    region.desiredReplicationCount ||
+                    region.desiredReplicationCount === 0
+                ) ||
+                !Number.isInteger(region.desiredReplicationCount)
+            ) {
                 throw new Error('desiredReplicationCount must be an integer');
             }
         });
@@ -103,8 +174,13 @@ export function validatePinataOptions(options) {
     }
     if (options.wrapWithDirectory) {
         // eslint-disable-next-line eqeqeq
-        if (options.wrapWithDirectory !== true && options.wrapWithDirectory !== false) {
-            throw new Error('wrapWithDirectory must be a boolean value of true or false');
+        if (
+            options.wrapWithDirectory !== true &&
+            options.wrapWithDirectory !== false
+        ) {
+            throw new Error(
+                'wrapWithDirectory must be a boolean value of true or false'
+            );
         }
     }
 

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

@@ -0,0 +1,211 @@
+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 (config, filterToApply, pinsCount) => {
+    const pins = [];
+    for await (const item of getFilesByCount(
+        config,
+        filterToApply,
+        pinsCount
+    )) {
+        pins.push(metadataName(item));
+    }
+
+    return pins;
+};
+
+describe("Get Files By Count", () => {
+    const pinataConfig = {
+        pinataApiKey: fakeHeaders.headers.pinata_api_key,
+        pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+    };
+    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(
+            pinataConfig,
+            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(
+            pinataConfig,
+            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(
+            pinataConfig,
+            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(
+            pinataConfig,
+            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(
+            pinataConfig,
+            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(
+            pinataConfig,
+            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,103 @@
-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(
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+            },
+            { pageLimit: 10, pageOffset: 0 }
+        );
+        const resp2 = await pinList(
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: 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(
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: 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({ pinataApiKey: 'test', pinataSecretApiKey: '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({ pinataApiKey: 'test', pinataSecretApiKey: '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({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual("test error");
+    });
 });