@pinata/sdk 1.2.0 → 1.2.1

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

@@ -1,22 +1,20 @@
 import getFilesByCount from "../../../../src/commands/data/getFilesByCount/getFilesByCount";
 import axios from "axios";
-import { APIData, pinListAxiosMockPages, fakeHeaders } from "../pinlist-sample-api";
+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 callIterableObject = async (config, filterToApply, pinsCount) => {
     const pins = [];
     for await (const item of getFilesByCount(
-        pinataKey,
-        pinataSecret,
+        config,
         filterToApply,
         pinsCount
     )) {
@@ -27,6 +25,10 @@ const callIterableObject = async (
 };
 
 describe("Get Files By Count", () => {
+    const pinataConfig = {
+        pinataApiKey: fakeHeaders.headers.pinata_api_key,
+        pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+    };
     const filterToApply = {
         status: "pinned",
     };
@@ -43,8 +45,7 @@ describe("Get Files By Count", () => {
             .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
 
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply,
             pinsToRequest
         );
@@ -74,8 +75,7 @@ describe("Get Files By Count", () => {
             pinListAxiosMockPages.firstPage.response
         );
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply,
             pinsToRequest
         );
@@ -102,8 +102,7 @@ describe("Get Files By Count", () => {
                 pinListAxiosMockPages.thirdPageEmpty.response
             );
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply,
             pinsToRequest
         );
@@ -139,8 +138,7 @@ describe("Get Files By Count", () => {
             pinListAxiosMockPages.firstPageEmpty.response
         );
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply,
             pinsToRequest
         );
@@ -165,8 +163,7 @@ describe("Get Files By Count", () => {
                 pinListAxiosMockPages.thirdPageEmpty.response
             );
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply
         );
         expect(pins).toEqual(APIData.rows.map(metadataName));
@@ -196,8 +193,7 @@ describe("Get Files By Count", () => {
             pinListAxiosMockPages.firstPageEmpty.response
         );
         const pins = await callIterableObject(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            pinataConfig,
             filterToApply
         );
 

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

@@ -19,13 +19,17 @@ describe("Get Files By Count", () => {
             .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
 
         const resp = await pinList(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: 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,
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+            },
             { pageLimit: 10, pageOffset: 10 }
         );
         expect(resp).toEqual(pinListAxiosMockPages.firstPage.response.data);
@@ -46,25 +50,26 @@ describe("Get Files By Count", () => {
     });
 
     test("Call empty page", async () => {
-        axios.get
-            .mockResolvedValueOnce(pinListAxiosMockPages.firstPageEmpty.response)
-
+        axios.get.mockResolvedValueOnce(
+            pinListAxiosMockPages.firstPageEmpty.response
+        );
 
         const resp = await pinList(
-            fakeHeaders.headers.pinata_api_key,
-            fakeHeaders.headers.pinata_secret_api_key,
+            {
+                pinataApiKey: fakeHeaders.headers.pinata_api_key,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+            },
             { pageLimit: 10, pageOffset: 0 }
         );
-        
-        expect(resp).toEqual({rows: []});
 
+        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", () => {
@@ -73,7 +78,7 @@ describe("Get Files By Count", () => {
         };
         axios.get.mockResolvedValue(badStatus);
         expect.assertions(1);
-        expect(pinList("test", "test")).rejects.toEqual(
+        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(
             Error(
                 `unknown server response while attempting to retrieve user pin list: ${badStatus}`
             )
@@ -87,12 +92,12 @@ describe("Get Files By Count", () => {
         };
         axios.get.mockResolvedValue(goodStatus);
         expect.assertions(1);
-        expect(pinList("test", "test")).resolves.toEqual(goodStatus.data);
+        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");
+        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual("test error");
     });
 });

package/test/commands/data/testAuthentication.test.js

@@ -1,30 +1,34 @@
-import axios from 'axios';
-import testAuthentication from'../../../src/commands/data/testAuthentication';
+import axios from "axios";
+import testAuthentication from "../../../src/commands/data/testAuthentication";
 
-jest.mock('axios');
+jest.mock("axios");
 
-test('Result other than 200 status is returned', () => {
+test("Result other than 200 status is returned", () => {
     const badStatus = {
-        status: 700
+        status: 700,
     };
     axios.get.mockResolvedValue(badStatus);
     expect.assertions(1);
-    return expect(testAuthentication('test', 'test')).rejects.toEqual(Error(`unknown server response while authenticating: ${badStatus}`));
+    return expect(testAuthentication({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(
+        Error(`unknown server response while authenticating: ${badStatus}`)
+    );
 });
 
-test('200 status is returned', () => {
+test("200 status is returned", () => {
     const goodStatus = {
-        status: 200
+        status: 200,
     };
     axios.get.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    return expect(testAuthentication('test', 'test')).resolves.toEqual({
-        authenticated: true
+    return expect(testAuthentication({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual({
+        authenticated: true,
     });
 });
 
-test('Rejection handled', () => {
-    axios.get.mockRejectedValue('test error');
+test("Rejection handled", () => {
+    axios.get.mockRejectedValue("test error");
     expect.assertions(1);
-    return expect(testAuthentication('test', 'test')).rejects.toEqual('test error');
+    return expect(testAuthentication({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(
+        "test error"
+    );
 });

package/test/commands/data/userPinnedDataTotal.test.js

@@ -9,7 +9,7 @@ test('Result other than 200 status is returned', () => {
     };
     axios.get.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(userPinnedDataTotal('test', 'test')).rejects.toEqual(Error(`unknown server response while attempting to retrieve pinned data total: ${badStatus}`));
+    expect(userPinnedDataTotal({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(Error(`unknown server response while attempting to retrieve pinned data total: ${badStatus}`));
 });
 
 test('200 status is returned', () => {
@@ -19,11 +19,11 @@ test('200 status is returned', () => {
     };
     axios.get.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(userPinnedDataTotal('test', 'test')).resolves.toEqual(goodStatus.data);
+    expect(userPinnedDataTotal({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual(goodStatus.data);
 });
 
 test('Rejection handled', () => {
     axios.get.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(userPinnedDataTotal('test', 'test')).rejects.toEqual('test error');
+    expect(userPinnedDataTotal({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual('test error');
 });

package/test/commands/pinning/hashMetadata.test.js

@@ -23,19 +23,19 @@ const metadataTwo = {
 
 test('No ipfsPinHash value provided should error', () => {
     expect(() => {
-        hashMetadata('test', 'test', null, metadata);
+        hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, null, metadata);
     }).toThrow();
 });
 
 test('Invalid ipfsPinHash value is provided', () => {
     expect(() => {
-        hashMetadata('test', 'test', badHash, metadata);
+        hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHash, metadata);
     }).toThrow();
 });
 
 test('No metadata object provided should error', () => {
     expect(() => {
-        hashMetadata('test', 'test', goodHash);
+        hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash);
     }).toThrow();
 });
 
@@ -46,7 +46,7 @@ test('One keyvalue pair is added', () => {
     };
     axios.put.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(hashMetadata('test', 'test', goodHash, metadata)).resolves.toEqual(goodStatus.data);
+    expect(hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, metadata)).resolves.toEqual(goodStatus.data);
 });
 
 test('Two keyvalue pairs is added', () => {
@@ -56,7 +56,7 @@ test('Two keyvalue pairs is added', () => {
     };
     axios.put.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(hashMetadata('test', 'test', goodHash, metadataTwo)).resolves.toEqual(goodStatus.data);
+    expect(hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, metadataTwo)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -65,13 +65,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.put.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(hashMetadata('test', 'test', goodHash, metadata)).rejects.toEqual(Error(`unknown server response while changing pin policy for hash: ${badStatus}`));
+    expect(hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, metadata)).rejects.toEqual(Error(`unknown server response while changing pin policy for hash: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.put.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(hashMetadata('test', 'test', goodHash, metadata)).rejects.toEqual('test error');
+    expect(hashMetadata({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, metadata)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/hashPinPolicy.test.js

@@ -21,19 +21,19 @@ const newPinPolicy = {
 
 test('No ipfsPinHash value provided should error', () => {
     expect(() => {
-        hashPinPolicy('test', 'test', null, newPinPolicy);
+        hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, null, newPinPolicy);
     }).toThrow();
 });
 
 test('Invalid ipfsPinHash value is provided', () => {
     expect(() => {
-        hashPinPolicy('test', 'test', badHash, newPinPolicy);
+        hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHash, newPinPolicy);
     }).toThrow();
 });
 
 test('No newPinPolicy value provided should error', () => {
     expect(() => {
-        hashPinPolicy('test', 'test', goodHash);
+        hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash);
     }).toThrow();
 });
 
@@ -44,7 +44,7 @@ test('200 status is returned', () => {
     };
     axios.put.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(hashPinPolicy('test', 'test', goodHash, newPinPolicy)).resolves.toEqual(goodStatus.data);
+    expect(hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, newPinPolicy)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -53,13 +53,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.put.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(hashPinPolicy('test', 'test', goodHash, newPinPolicy)).rejects.toEqual(Error(`unknown server response while changing pin policy for hash: ${badStatus}`));
+    expect(hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, newPinPolicy)).rejects.toEqual(Error(`unknown server response while changing pin policy for hash: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.put.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(hashPinPolicy('test', 'test', goodHash, newPinPolicy)).rejects.toEqual('test error');
+    expect(hashPinPolicy({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHash, newPinPolicy)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/pinByHash.test.js

@@ -15,7 +15,7 @@ test('No hashToPin value is provided should error', () => {
 
 test('Invalid HashToPin value is provided', () => {
     expect(() => {
-        pinByHash('test', 'test', badHashToPin);
+        pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToPin);
     }).toThrow();
 });
 
@@ -26,7 +26,7 @@ test('200 status is returned', () => {
     };
     axios.post.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinByHash('test', 'test', goodHashToPin)).resolves.toEqual(goodStatus.data);
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -35,13 +35,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.post.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(pinByHash('test', 'test', goodHashToPin)).rejects.toEqual(Error(`unknown server response while adding to pin queue: ${badStatus}`));
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual(Error(`unknown server response while adding to pin queue: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.post.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinByHash('test', 'test', goodHashToPin)).rejects.toEqual('test error');
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/pinFileToIPFS.test.js

@@ -12,7 +12,7 @@ validFormData.append('file', validStream, {filepath: 'test/filepath'});
 
 
 test('non-readableStream and non-formData is passed in', () => {
-    expect(pinFileToIPFS('test', 'test', nonStream)).rejects.toEqual(Error('readStream is not a readable stream or form data'));
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, nonStream)).rejects.toEqual(Error('readStream is not a readable stream or form data'));
 
     return undefined;
 });
@@ -24,7 +24,7 @@ test('200 status is returned with valid stream', () => {
     };
     axios.post.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS('test', 'test', validStream)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).resolves.toEqual(goodStatus.data);
 });
 
 test('200 status is returned with valid form data', () => {
@@ -34,7 +34,7 @@ test('200 status is returned with valid form data', () => {
     };
     axios.post.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS('test', 'test', validFormData)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -43,13 +43,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.post.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS('test', 'test', validStream)).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.post.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinFileToIPFS('test', 'test', validStream)).rejects.toEqual('test error');
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/pinFromFS.js

@@ -12,7 +12,7 @@ test('200 status is returned', () => {
     };
     axios.post.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFromFS('test', 'test', testSource)).resolves.toEqual(goodStatus.data);
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -21,13 +21,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.post.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(pinFromFS('test', 'test', testSource)).rejects.toEqual(Error(`unknown server response while pinning to IPFS: ${badStatus}`));
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual(Error(`unknown server response while pinning to IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.post.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinFromFS('test', 'test', testSource)).rejects.toEqual('test error');
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/pinJSONToIPFS.test.js

@@ -11,7 +11,7 @@ const goodJSON = {
 
 test('non-object is passed in', () => {
     expect(() => {
-        pinJSONToIPFS('test', 'test', badJSON);
+        pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badJSON);
     }).toThrow('body must be a valid JSON object');
 });
 
@@ -22,7 +22,7 @@ test('200 status is returned', () => {
     };
     axios.post.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinJSONToIPFS('test', 'test', goodJSON)).resolves.toEqual(goodStatus.data);
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -31,13 +31,13 @@ test('Result other than 200 status is returned', () => {
     };
     axios.post.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(pinJSONToIPFS('test', 'test', goodJSON)).rejects.toEqual(Error(`unknown server response while pinning JSON to IPFS: ${badStatus}`));
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual(Error(`unknown server response while pinning JSON to IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.post.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinJSONToIPFS('test', 'test', goodJSON)).rejects.toEqual('test error');
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual('test error');
 });