@pinata/sdk 1.2.0 → 1.2.1

package/test/commands/pinning/pinJobs/pinJobs.test.js

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

package/test/commands/pinning/unpin.test.js

@@ -9,13 +9,13 @@ const goodHashToUnpin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
 
 test('No hashToUnpin value is provided should error', () => {
     expect(() => {
-        unpin('test', 'test');
+        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' });
     }).toThrow('hashToUnpin value is required for removing a pin from Pinata');
 });
 
 test('Invalid hashToUnpin value is provided', () => {
     expect(() => {
-        unpin('test', 'test', badHashToUnpin);
+        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToUnpin);
     }).toThrow(`${badHashToUnpin} is an invalid IPFS CID`);
 });
 
@@ -26,7 +26,7 @@ test('200 status is returned', () => {
     };
     axios.delete.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).resolves.toEqual(goodStatus.data);
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).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.delete.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).rejects.toEqual(Error(`unknown server response while removing pin from IPFS: ${badStatus}`));
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual(Error(`unknown server response while removing pin from IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     axios.delete.mockRejectedValue('test error');
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).rejects.toEqual('test error');
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual('test error');
 });
 
 

package/test/commands/pinning/userPinPolicy.test.js

@@ -1,51 +1,80 @@
-import axios from 'axios';
-import userPinPolicy from'../../../src/commands/pinning/userPinPolicy';
+import axios from "axios";
+import userPinPolicy from "../../../src/commands/pinning/userPinPolicy";
 
-jest.mock('axios');
+jest.mock("axios");
 
 //common values
 const newPinPolicy = {
     regions: [
         {
-            id: 'FRA1',
-            desiredReplicationCount: 2
+            id: "FRA1",
+            desiredReplicationCount: 2,
         },
         {
-            id: 'NYC1',
-            desiredReplicationCount: 2
-        }
-    ]
+            id: "NYC1",
+            desiredReplicationCount: 2,
+        },
+    ],
 };
 
-test('No newPinPolicy value provided should error', () => {
+test("No newPinPolicy value provided should error", () => {
     expect(() => {
-        userPinPolicy('test', 'test');
+        userPinPolicy({
+            pinataApiKey: "test",
+            pinataSecretApiKey: "test",
+        });
     }).toThrow();
 });
 
-test('200 status is returned', () => {
+test("200 status is returned", () => {
     const goodStatus = {
         status: 200,
-        data: 'testData'
+        data: "testData",
     };
     axios.put.mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(userPinPolicy('test', 'test', newPinPolicy)).resolves.toEqual(goodStatus.data);
+    expect(
+        userPinPolicy(
+            {
+                pinataApiKey: "test",
+                pinataSecretApiKey: "test",
+            },
+            newPinPolicy
+        )
+    ).resolves.toEqual(goodStatus.data);
 });
 
-test('Result other than 200 status is returned', () => {
+test("Result other than 200 status is returned", () => {
     const badStatus = {
-        status: 700
+        status: 700,
     };
     axios.put.mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(userPinPolicy('test', 'test', newPinPolicy)).rejects.toEqual(Error(`unknown server response while changing pin policy for user: ${badStatus}`));
+    expect(
+        userPinPolicy(
+            {
+                pinataApiKey: "test",
+                pinataSecretApiKey: "test",
+            },
+            newPinPolicy
+        )
+    ).rejects.toEqual(
+        Error(
+            `unknown server response while changing pin policy for user: ${badStatus}`
+        )
+    );
 });
 
-test('Rejection handled', () => {
-    axios.put.mockRejectedValue('test error');
+test("Rejection handled", () => {
+    axios.put.mockRejectedValue("test error");
     expect.assertions(1);
-    expect(userPinPolicy('test', 'test', newPinPolicy)).rejects.toEqual('test error');
+    expect(
+        userPinPolicy(
+            {
+                pinataApiKey: "test",
+                pinataSecretApiKey: "test",
+            },
+            newPinPolicy
+        )
+    ).rejects.toEqual("test error");
 });
-
-

package/test/util/validators.test.js

@@ -1,61 +1,98 @@
-import { validateApiKeys, validateHostNodes, validateMetadata, validatePinPolicyStructure, validatePinataOptions } from "../../src/util/validators";
+import {
+    validateApiKeys,
+    createConfigForAxiosHeaders,
+    validateHostNodes,
+    validateMetadata,
+    validatePinPolicyStructure,
+    validatePinataOptions,
+} from "../../src/util/validators";
+import { ERROR_NO_CREDENTIALS_PROVIDED } from "../../src/constants";
 
-describe('validateApiKeys function testing', () => {
-    test('check to throw if either pinataApiKey or pinataSecretApiKey are not provided', () => {
-        expect(() => {
-            validateApiKeys('', 'test');
-        }).toThrow('No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script');
-        expect(() => {
-            validateApiKeys('test', '');
-        }).toThrow('No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script');
+describe("validateApiKeys function testing", () => {
+    test("check to throw if either pinataApiKey or pinataSecretApiKey are not provided", () => {
+        expect(() => {
+            validateApiKeys("", "test");
+        }).toThrow(
+            "No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script"
+        );
+        expect(() => {
+            validateApiKeys("test", "");
+        }).toThrow(
+            "No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script"
+        );
     });
 });
 
-describe('validateHostNodes function testing', () => {
-    test('host_nodes is not an array', () => {
+describe("createConfigForAxiosHeaders function testing", () => {
+    expect(() => {
+        createConfigForAxiosHeaders({});
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(() => {
+        createConfigForAxiosHeaders({ pinataApiKey: "some api key" });
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(() => {
+        createConfigForAxiosHeaders({ pinataSecretApiKey: "some api secret" });
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(
+        createConfigForAxiosHeaders({
+            pinataApiKey: "some api key",
+            pinataSecretApiKey: "some api secret",
+        })
+    ).toEqual({
+        withCredentials: true,
+        headers: {
+            pinata_api_key: "some api key",
+            pinata_secret_api_key: "some api secret",
+        },
+    });
+});
+describe("validateHostNodes function testing", () => {
+    test("host_nodes is not an array", () => {
         const hostNodes = {
-            test: 'test'
+            test: "test",
         };
         expect(() => {
             validateHostNodes(hostNodes);
-        }).toThrow('host_nodes value must be an array');
+        }).toThrow("host_nodes value must be an array");
     });
 
-    test('invalid host_node entry', () => {
-        const validHost = '/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj';
-        const invalidHost = 'invalid host';
-        const hostNodes = [
-            validHost,
-            invalidHost
-        ];
+    test("invalid host_node entry", () => {
+        const validHost =
+            "/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj";
+        const invalidHost = "invalid host";
+        const hostNodes = [validHost, invalidHost];
         expect(() => {
             validateHostNodes(hostNodes);
-        }).toThrow(`host_node array entry: ${invalidHost} is not a valid peer multiaddr`);
+        }).toThrow(
+            `host_node array entry: ${invalidHost} is not a valid peer multiaddr`
+        );
     });
 });
 
-
-describe('validateMetadata function testing', () => {
-    test('name is not a string', () => {
+describe("validateMetadata function testing", () => {
+    test("name is not a string", () => {
         const badName = {
-            test: 'testing'
+            test: "testing",
         };
         expect(() => {
             validateMetadata({
-                name: badName
+                name: badName,
             });
-        }).toThrow('metadata name must be of type string');
+        }).toThrow("metadata name must be of type string");
     });
-    test('keyvalues is not an object', () => {
-        const badKeyValues = 'testing';
+    test("keyvalues is not an object", () => {
+        const badKeyValues = "testing";
         expect(() => {
             validateMetadata({
-                keyvalues: badKeyValues
+                keyvalues: badKeyValues,
             });
-        }).toThrow('metatadata keyvalues must be an object');
+        }).toThrow("metatadata keyvalues must be an object");
     });
 
-    test('more than 10 keyvalues was provided', () => {
+    test("more than 10 keyvalues was provided", () => {
         const tooManyKeyValues = {
             one: 1,
             two: 2,
@@ -67,19 +104,21 @@ describe('validateMetadata function testing', () => {
             eight: 8,
             nine: 9,
             ten: 10,
-            eleven: 11
+            eleven: 11,
         };
         expect(() => {
             validateMetadata({
-                keyvalues: tooManyKeyValues
+                keyvalues: tooManyKeyValues,
             });
-        }).toThrow('No more than 10 keyvalues can be provided for metadata entries');
+        }).toThrow(
+            "No more than 10 keyvalues can be provided for metadata entries"
+        );
     });
-    test('Throws error on an object being passed in as a value for a keyvalue', () => {
+    test("Throws error on an object being passed in as a value for a keyvalue", () => {
         const invalidValue = {
             one: 1,
             two: {
-                test: 'test'
+                test: "test",
             },
             three: 3,
             four: 4,
@@ -89,15 +128,17 @@ describe('validateMetadata function testing', () => {
             eight: 8,
             nine: 9,
             ten: 10,
-            eleven: 11
+            eleven: 11,
         };
         expect(() => {
             validateMetadata({
-                keyvalues: invalidValue
+                keyvalues: invalidValue,
             });
-        }).toThrow('Metadata keyvalue values must be strings, booleans, or numbers');
+        }).toThrow(
+            "Metadata keyvalue values must be strings, booleans, or numbers"
+        );
     });
-    test('Does not throw an error if metadata is valid', () => {
+    test("Does not throw an error if metadata is valid", () => {
         const invalidValue = {
             one: 1,
             two: 2,
@@ -108,85 +149,86 @@ describe('validateMetadata function testing', () => {
             seven: 7,
             eight: 8,
             nine: 9,
-            ten: 10
+            ten: 10,
         };
         expect(() => {
             validateMetadata({
-                keyvalues: invalidValue
+                keyvalues: invalidValue,
             });
         }).not.toThrow();
     });
 });
 
-describe('validatePinPolicyStructure function testing', () => {
-    test('No Policy Provided', () => {
+describe("validatePinPolicyStructure function testing", () => {
+    test("No Policy Provided", () => {
         expect(() => {
             validatePinPolicyStructure();
         }).toThrow("No pin policy provided");
     });
-    test('No Regions Provided', () => {
+    test("No Regions Provided", () => {
         expect(() => {
             validatePinPolicyStructure({
-                test: 'test'
+                test: "test",
             });
         }).toThrow("No regions provided in pin policy");
     });
-    test('region id is not a string', () => {
+    test("region id is not a string", () => {
         expect(() => {
             validatePinPolicyStructure({
                 regions: [
                     {
-                        id: 'goodRegionId',
-                        desiredReplicationCount: 1
+                        id: "goodRegionId",
+                        desiredReplicationCount: 1,
                     },
                     {
                         id: 0,
-                        desiredReplicationCount: 1
-                    }
-                ]
+                        desiredReplicationCount: 1,
+                    },
+                ],
             });
         }).toThrow("region id must be a string");
     });
-    test('desiredReplicationCount is not an integer', () => {
+    test("desiredReplicationCount is not an integer", () => {
         expect(() => {
             validatePinPolicyStructure({
                 regions: [
                     {
-                        id: 'goodRegionId',
-                        desiredReplicationCount: 1
+                        id: "goodRegionId",
+                        desiredReplicationCount: 1,
                     },
                     {
-                        id: 'goodRegionId2',
-                        desiredReplicationCount: 'string that should fail'
-                    }
-                ]
+                        id: "goodRegionId2",
+                        desiredReplicationCount: "string that should fail",
+                    },
+                ],
             });
         }).toThrow("desiredReplicationCount must be an integer");
     });
 });
 
-
-describe('validatePinataOptions function testing', () => {
-    test('options is not an object', () => {
+describe("validatePinataOptions function testing", () => {
+    test("options is not an object", () => {
         expect(() => {
-            validatePinataOptions('test');
-        }).toThrow('options must be an object');
+            validatePinataOptions("test");
+        }).toThrow("options must be an object");
     });
-    test('cidVersion is not a 0 or 1', () => {
+    test("cidVersion is not a 0 or 1", () => {
         const badVersion = {
-            test: 'testing'
+            test: "testing",
         };
         expect(() => {
             validatePinataOptions({
-                cidVersion: badVersion
+                cidVersion: badVersion,
             });
-        }).toThrow('unsupported or invalid cidVersion');
+        }).toThrow("unsupported or invalid cidVersion");
     });
-    test('wrapWithDirectory is not true or false', () => {
+    test("wrapWithDirectory is not true or false", () => {
         expect(() => {
             validatePinataOptions({
-                wrapWithDirectory: 'test'
+                wrapWithDirectory: "test",
             });
-        }).toThrow('wrapWithDirectory must be a boolean value of true or false');
+        }).toThrow(
+            "wrapWithDirectory must be a boolean value of true or false"
+        );
     });
 });

package/types/commands/data/getFilesByCount/getFilesByCount.d.ts

@@ -1,4 +1,4 @@
-export default function getFilesByCount(pinataApiKey: any, pinataSecretApiKey: any, filters?: {}, maxCount?: number): {
+export default function getFilesByCount(config: any, filters?: {}, maxCount?: number): {
     [Symbol.asyncIterator]: () => {
         next(): Promise<{
             value: any;

package/types/commands/data/pinList/pinList.d.ts

@@ -5,4 +5,4 @@
  * @param {any} filters
  * @returns {Promise<unknown>}
  */
-export default function pinList(pinataApiKey: string, pinataSecretApiKey: string, filters?: any): Promise<unknown>;
+export default function pinList(config: any, filters?: any): Promise<unknown>;

package/types/commands/data/testAuthentication.d.ts

@@ -4,4 +4,4 @@
  * @param {string} pinataSecretApiKey
  * @returns {Promise<unknown>}
  */
-export default function testAuthentication(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;
+export default function testAuthentication(config: any): Promise<unknown>;

package/types/commands/data/userPinnedDataTotal.d.ts

@@ -4,4 +4,4 @@
  * @param {string} pinataSecretApiKey
  * @returns {Promise<unknown>}
  */
-export default function userPinnedDataTotal(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;
+export default function userPinnedDataTotal(config: any): Promise<unknown>;

package/types/commands/pinning/hashMetadata.d.ts

@@ -6,4 +6,4 @@
  * @param {*} metadata
  * @returns {Promise<unknown>}
  */
-export default function hashMetadata(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, metadata: any): Promise<unknown>;
+export default function hashMetadata(config: any, ipfsPinHash: any, metadata: any): Promise<unknown>;

package/types/commands/pinning/hashPinPolicy.d.ts

@@ -6,4 +6,4 @@
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function hashPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, newPinPolicy: any): Promise<unknown>;
+export default function hashPinPolicy(config: any, ipfsPinHash: any, newPinPolicy: any): Promise<unknown>;

package/types/commands/pinning/pinByHash.d.ts

@@ -6,4 +6,4 @@
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinByHash(pinataApiKey: string, pinataSecretApiKey: string, hashToPin: any, options: any): Promise<unknown>;
+export default function pinByHash(config: any, hashToPin: any, options: any): Promise<unknown>;

package/types/commands/pinning/pinFileToIPFS.d.ts

@@ -6,4 +6,4 @@
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinFileToIPFS(pinataApiKey: string, pinataSecretApiKey: string, readStream: any, options: any): Promise<unknown>;
+export default function pinFileToIPFS(config: any, readStream: any, options: any): Promise<unknown>;

package/types/commands/pinning/pinFromFS.d.ts

@@ -6,4 +6,4 @@
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinFromFS(pinataApiKey: string, pinataSecretApiKey: string, sourcePath: string, options: any): Promise<unknown>;
+export default function pinFromFS(config: any, sourcePath: string, options: any): Promise<unknown>;

package/types/commands/pinning/pinJSONToIPFS.d.ts

@@ -6,4 +6,4 @@
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinJSONToIPFS(pinataApiKey: string, pinataSecretApiKey: string, body: any, options: any): Promise<unknown>;
+export default function pinJSONToIPFS(config: any, body: any, options: any): Promise<unknown>;

package/types/commands/pinning/pinJobs/pinJobs.d.ts

@@ -5,4 +5,4 @@
  * @param {*} filters
  * @returns {Promise<unknown>}
  */
-export default function pinJobs(pinataApiKey: string, pinataSecretApiKey: string, filters: any): Promise<unknown>;
+export default function pinJobs(config: any, filters: any): Promise<unknown>;

package/types/commands/pinning/unpin.d.ts

@@ -5,4 +5,4 @@
  * @param {string} hashToUnpin
  * @returns {Promise<unknown>}
  */
-export default function unpin(pinataApiKey: string, pinataSecretApiKey: string, hashToUnpin: string): Promise<unknown>;
+export default function unpin(config: any, hashToUnpin: string): Promise<unknown>;

package/types/commands/pinning/userPinPolicy.d.ts

@@ -5,4 +5,4 @@
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function userPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, newPinPolicy: any): Promise<unknown>;
+export default function userPinPolicy(config: any, newPinPolicy: any): Promise<unknown>;

package/types/constants.d.ts

@@ -1 +1,2 @@
 export const baseUrl: "https://api.pinata.cloud";
+export const ERROR_NO_CREDENTIALS_PROVIDED: "No credentials provided! Please provide your pinata api key and pinata secret api key or your pinata JWT key as an argument when you start this script";