@pinata/sdk 1.2.1 → 2.0.0-beta.0

package/src/commands/pinning/pinJobs/{pinJobs.js → pinJobs.ts}

@@ -1,17 +1,31 @@
 import axios from 'axios';
-import { baseUrl } from './../../../constants';
+import { baseUrl } from '../../../constants';
 import { createConfigForAxiosHeaders } from '../../../util/validators';
 import queryBuilder from './queryBuilder';
 import { handleError } from '../../../util/errorResponse';
+import { PinataConfig } from '../../..';
 
-/**
- * Pin Jobs
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} filters
- * @returns {Promise<unknown>}
- */
-export default function pinJobs(config, filters) {
+export interface PinataPinJobsResponseRow {
+    id: number | string;
+    ipfs_pin_hash: string;
+    date_queued: string;
+    name: string | undefined | null;
+    status: string;
+}
+export interface PinataPinJobsResponse {
+    count: number;
+    rows: PinataPinJobsResponseRow[];
+}
+
+export interface PinataPinJobsFilterOptions {
+    sort: 'ASC' | 'DESC';
+    status?: string | undefined;
+    ipfs_pin_hash?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+
+export default function pinJobs(config: PinataConfig, filters? : PinataPinJobsFilterOptions): Promise<PinataPinJobsResponse> {
 
     let endpoint = `${baseUrl}/pinning/pinJobs`;
 

package/src/commands/pinning/pinJobs/{queryBuilder.js → queryBuilder.ts}

@@ -1,12 +1,6 @@
 import isIPFS from 'is-ipfs';
 
-/**
- * Query Buidler
- * @param {string} baseUrl
- * @param {*} filters
- * @returns {*}
- */
-export default function queryBuilder(baseUrl, filters) {
+export default function queryBuilder(baseUrl: string, filters?: any): string {
     if (!baseUrl) {
         throw new Error('no baseUrl provided');
     }
@@ -19,7 +13,7 @@ export default function queryBuilder(baseUrl, filters) {
 
     let firstFilterApplied = false; // we want to make sure that the "?" character is only applied once
 
-    function addFilter(newFilter) {
+    function addFilter(newFilter: string) {
         if (firstFilterApplied) {
             newUrl = `${newUrl}&${newFilter}`;
         } else {

package/src/commands/pinning/{unpin.js → unpin.ts}

@@ -1,17 +1,11 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import { createConfigForAxiosHeaders } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
 
-/**
- * Unpin
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {string} hashToUnpin
- * @returns {Promise<unknown>}
- */
-export default function unpin(config, hashToUnpin) {
+export default function unpin(config: PinataConfig, hashToUnpin: string) {
     if (!hashToUnpin) {
         throw new Error('hashToUnpin value is required for removing a pin from Pinata');
     }

package/src/index.ts

@@ -0,0 +1,120 @@
+import pinByHash, {
+    PinataPinByHashPinOptions
+} from './commands/pinning/pinByHash';
+import hashMetadata from './commands/pinning/hashMetadata';
+import pinFileToIPFS, {
+    PinataPinOptions
+} from './commands/pinning/pinFileToIPFS';
+import pinFromFS from './commands/pinning/pinFromFS';
+import pinJSONToIPFS from './commands/pinning/pinJSONToIPFS';
+import pinJobs, {
+    PinataPinJobsFilterOptions
+} from './commands/pinning/pinJobs/pinJobs';
+import unpin from './commands/pinning/unpin';
+import testAuthentication from './commands/data/testAuthentication';
+import pinList, {
+    PinataMetadata,
+    PinataPinListFilterOptions
+} from './commands/data/pinList/pinList';
+import getFilesByCount from './commands/data/getFilesByCount/getFilesByCount';
+import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
+
+export interface PinataConfig {
+    pinataApiKey?: string;
+    pinataSecretApiKey?: string;
+    pinataJWTKey?: string;
+}
+
+function refactorConfig(pinataConfigParam: PinataConfig): PinataConfig {
+    const config: PinataConfig = {};
+    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?: string | PinataConfig,
+    pinataSecretApiKey?: string
+): PinataConfig {
+    let config: PinataConfig = {};
+
+    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;
+}
+
+class PinataClient {
+    config: PinataConfig;
+
+    constructor(
+        pinataApiKey?: string | PinataConfig,
+        pinataSecretApiKey?: string
+    ) {
+        this.config = sanitizeConfig(pinataApiKey, pinataSecretApiKey);
+    }
+
+    pinByHash(hashToPin: string, options?: PinataPinByHashPinOptions) {
+        return pinByHash(this.config, hashToPin, options);
+    }
+
+    hashMetadata(ipfsPinHash: string, metadata: PinataMetadata) {
+        return hashMetadata(this.config, ipfsPinHash, metadata);
+    }
+
+    pinFileToIPFS(readableStream: any, options?: PinataPinOptions) {
+        return pinFileToIPFS(this.config, readableStream, options);
+    }
+
+    pinFromFS(sourcePath: string, options?: PinataPinOptions) {
+        return pinFromFS(this.config, sourcePath, options);
+    }
+    pinJSONToIPFS(body: any, options?: PinataPinOptions) {
+        return pinJSONToIPFS(this.config, body, options);
+    }
+    pinJobs(filters?: PinataPinJobsFilterOptions) {
+        return pinJobs(this.config, filters);
+    }
+    unpin(hashToUnpin: string) {
+        return unpin(this.config, hashToUnpin);
+    }
+
+    pinList(filters: PinataPinListFilterOptions) {
+        return pinList(this.config, filters);
+    }
+
+    getFilesByCount(filters: PinataPinListFilterOptions, maxCount?: number) {
+        return getFilesByCount(this.config, filters, maxCount);
+    }
+
+    testAuthentication() {
+        return testAuthentication(this.config);
+    }
+    userPinnedDataTotal() {
+        return userPinnedDataTotal(this.config);
+    }
+}
+
+export * from './commands/data';
+export * from './commands/pinning';
+
+export default PinataClient;

package/src/third-party/base-path-converter.d.ts

@@ -0,0 +1,3 @@
+declare module 'base-path-converter' {
+    export default function(sourcePath: string, filePath: string): string;
+}

package/src/third-party/is-ipfs.d.ts

@@ -0,0 +1,5 @@
+declare module 'is-ipfs' {
+    export function cid (cid: string): boolean
+    export function isPeerMultiaddr(addr: string): boolean;
+    export function peerMultiaddr(addr: string): boolean;
+}

package/src/third-party/recursive-fs.d.ts

@@ -0,0 +1,5 @@
+declare module 'recursive-fs' {
+    export function readdirr(sourcePath: string, callback: (err: any, dirs: any, files: any) => void): void
+
+}
+

package/src/util/{errorResponse.js → errorResponse.ts}

@@ -1,4 +1,4 @@
-export const handleError = (error) => {
+export const handleError = (error : any) => {
   if (error && error.response && error.response && error.response.data && error.response.data.error) {
     return error.response.data.error;
   } else if (error.data && error.data.error) {

package/src/util/{validators.js → validators.ts}

@@ -1,11 +1,8 @@
 import isIPFS from 'is-ipfs';
+import { PinataConfig } from '..';
 import { ERROR_NO_CREDENTIALS_PROVIDED} from '../constants';
-/**
- * Validate API Keys
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- */
-export function validateApiKeys(pinataApiKey, pinataSecretApiKey) {
+
+export function validateApiKeys(pinataApiKey?: string, pinataSecretApiKey?: string) {
     if (!pinataApiKey || pinataApiKey === '') {
         throw new Error(
             'No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script'
@@ -18,7 +15,7 @@ export function validateApiKeys(pinataApiKey, pinataSecretApiKey) {
     }
 }
 
-export function createConfigForAxiosHeaders(config) {
+export function createConfigForAxiosHeaders(config: PinataConfig) {
     if (
         config.pinataApiKey && config.pinataApiKey.length > 0 &&
         config.pinataSecretApiKey && config.pinataSecretApiKey.length > 0
@@ -43,24 +40,20 @@ export function createConfigForAxiosHeaders(config) {
     throw new Error(ERROR_NO_CREDENTIALS_PROVIDED);
 }
 
-export function createConfigForAxiosHeadersWithFormData(config, boundaryValue) {
+export function createConfigForAxiosHeadersWithFormData(config: PinataConfig, boundaryValue: string) {
     const requestOptions = {
         ...createConfigForAxiosHeaders(config),
         maxContentLength: Infinity, //this is needed to prevent axios from erroring out with large files
-        maxBodyLength: Infinity
+        maxBodyLength: Infinity,
+        headers: {
+            'Content-type': `multipart/form-data; boundary= ${boundaryValue}`
+        }
     };
 
-    requestOptions.headers[
-        'Content-type'
-    ] = `multipart/form-data; boundary= ${boundaryValue}`;
     return requestOptions;
 }
 
-/**
- * Validate host Nodes
- * @param {*} hostNodes
- */
-export function validateHostNodes(hostNodes) {
+export function validateHostNodes(hostNodes: any) {
     if (!Array.isArray(hostNodes)) {
         throw new Error('host_nodes value must be an array');
     }
@@ -73,11 +66,7 @@ export function validateHostNodes(hostNodes) {
     });
 }
 
-/**
- * Validate MetaData
- * @param {*} metadata
- */
-export function validateMetadata(metadata) {
+export function validateMetadata(metadata: any) {
     if (metadata.name) {
         if (
             !(
@@ -96,7 +85,7 @@ export function validateMetadata(metadata) {
 
         let i = 0;
 
-        Object.entries(metadata.keyvalues).forEach(function (keyValue) {
+        Object.entries(metadata.keyvalues).forEach(function (keyValue: any) {
             if (i > 9) {
                 throw new Error(
                     'No more than 10 keyvalues can be provided for metadata entries'
@@ -119,11 +108,7 @@ export function validateMetadata(metadata) {
     }
 }
 
-/**
- * Validate Pin Policy Structure
- * @param {*} pinPolicy
- */
-export function validatePinPolicyStructure(pinPolicy) {
+export function validatePinPolicyStructure(pinPolicy: { regions: any[]; }) {
     //this function takes in a pin policy and checks the JSON structure to make sure it's valid
     if (!pinPolicy) {
         throw new Error('No pin policy provided');
@@ -157,11 +142,7 @@ export function validatePinPolicyStructure(pinPolicy) {
     }
 }
 
-/**
- * Validate Pinata Options
- * @param {*} options
- */
-export function validatePinataOptions(options) {
+export function validatePinataOptions(options: { cidVersion?: number; wrapWithDirectory?: boolean; hostNodes?: any; customPinPolicy?: any; }) {
     if (typeof options !== 'object') {
         throw new Error('options must be an object');
     }

package/test/commands/data/getFilesByCount/{getFilesByCount.test.js → getFilesByCount.test.ts}

@@ -1,18 +1,19 @@
-import getFilesByCount from "../../../../src/commands/data/getFilesByCount/getFilesByCount";
-import axios from "axios";
+import getFilesByCount from '../../../../src/commands/data/getFilesByCount/getFilesByCount';
+import axios from 'axios';
 import {
     APIData,
     pinListAxiosMockPages,
-    fakeHeaders,
-} from "../pinlist-sample-api";
+    fakeHeaders
+} from '../pinlist-sample-api';
+import { PinataConfig, PinataPin, PinataPinListFilterOptions } from '../../../../src';
 
-jest.mock("axios");
+jest.mock('axios');
 
 const metadataName = (item) => {
     return item.metadata.name;
 };
-const callIterableObject = async (config, filterToApply, pinsCount) => {
-    const pins = [];
+const callIterableObject = async (config: PinataConfig, filterToApply: PinataPinListFilterOptions, pinsCount?: number) => {
+    const pins: PinataPin[] = [];
     for await (const item of getFilesByCount(
         config,
         filterToApply,
@@ -24,23 +25,23 @@ const callIterableObject = async (config, filterToApply, pinsCount) => {
     return pins;
 };
 
-describe("Get Files By Count", () => {
+describe('Get Files By Count', () => {
     const pinataConfig = {
         pinataApiKey: fakeHeaders.headers.pinata_api_key,
-        pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+        pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
     };
     const filterToApply = {
-        status: "pinned",
+        status: 'pinned'
     };
 
     afterEach(() => {
         jest.resetAllMocks();
     });
 
-    test("Request 17 pins, pins available", async () => {
+    test('Request 17 pins, pins available', async () => {
         const pinsToRequest = 17;
 
-        axios.get
+        (axios.get as jest.Mock)
             .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
             .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
 
@@ -68,10 +69,10 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(2);
     });
 
-    test("Request 6 pins, pins available", async () => {
+    test('Request 6 pins, pins available', async () => {
         const pinsToRequest = 6;
 
-        axios.get.mockResolvedValueOnce(
+        (axios.get as jest.Mock).mockResolvedValueOnce(
             pinListAxiosMockPages.firstPage.response
         );
         const pins = await callIterableObject(
@@ -92,10 +93,10 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(1);
     });
 
-    test("Request 25 pins, pins not available", async () => {
+    test('Request 25 pins, pins not available', async () => {
         const pinsToRequest = 25;
 
-        axios.get
+        (axios.get as jest.Mock)
             .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
             .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
             .mockResolvedValueOnce(
@@ -131,10 +132,10 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(3);
     });
 
-    test("Request 3 pins, pins not available", async () => {
+    test('Request 3 pins, pins not available', async () => {
         const pinsToRequest = 3;
 
-        axios.get.mockResolvedValueOnce(
+        (axios.get as jest.Mock).mockResolvedValueOnce(
             pinListAxiosMockPages.firstPageEmpty.response
         );
         const pins = await callIterableObject(
@@ -155,8 +156,8 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(1);
     });
 
-    test("Request all pins, pins available", async () => {
-        axios.get
+    test('Request all pins, pins available', async () => {
+        (axios.get as jest.Mock)
             .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
             .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
             .mockResolvedValueOnce(
@@ -188,8 +189,8 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(3);
     });
 
-    test("Request all pins, pins not available", async () => {
-        axios.get.mockResolvedValueOnce(
+    test('Request all pins, pins not available', async () => {
+        (axios.get as jest.Mock).mockResolvedValueOnce(
             pinListAxiosMockPages.firstPageEmpty.response
         );
         const pins = await callIterableObject(

package/test/commands/data/pinList/{pinList.test.js → pinList.test.ts}

@@ -1,36 +1,35 @@
-import axios from "axios";
-import pinList from "./../../../../src/commands/data/pinList/pinList";
+import axios from 'axios';
+import pinList from '../../../../src/commands/data/pinList/pinList';
 import {
-    APIData,
     pinListAxiosMockPages,
-    fakeHeaders,
-} from "../pinlist-sample-api";
+    fakeHeaders
+} from '../pinlist-sample-api';
 
-jest.mock("axios");
+jest.mock('axios');
 
-describe("Get Files By Count", () => {
+describe('Pin List by page', () => {
     afterEach(() => {
         jest.resetAllMocks();
     });
 
-    test("Call two pages in a row", async () => {
-        axios.get
+    test('Call two pages in a row', async () => {
+        (axios.get as jest.Mock)
             .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,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
             },
-            { pageLimit: 10, pageOffset: 0 }
+            { pageLimit: 10, pageOffset: 0, status: 'pinned' }
         );
         const resp2 = await pinList(
             {
                 pinataApiKey: fakeHeaders.headers.pinata_api_key,
-                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
             },
-            { pageLimit: 10, pageOffset: 10 }
+            { pageLimit: 10, pageOffset: 10, status: 'pinned' }
         );
         expect(resp).toEqual(pinListAxiosMockPages.firstPage.response.data);
         expect(resp2).toEqual(pinListAxiosMockPages.secondPage.response.data);
@@ -49,17 +48,17 @@ describe("Get Files By Count", () => {
         expect(axios.get).toHaveBeenCalledTimes(2);
     });
 
-    test("Call empty page", async () => {
-        axios.get.mockResolvedValueOnce(
+    test('Call empty page', async () => {
+        (axios.get as jest.Mock).mockResolvedValueOnce(
             pinListAxiosMockPages.firstPageEmpty.response
         );
 
         const resp = await pinList(
             {
                 pinataApiKey: fakeHeaders.headers.pinata_api_key,
-                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key,
+                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
             },
-            { pageLimit: 10, pageOffset: 0 }
+            { pageLimit: 10, pageOffset: 0, status: 'pinned' }
         );
 
         expect(resp).toEqual({ rows: [] });
@@ -72,11 +71,11 @@ describe("Get Files By Count", () => {
 
         expect(axios.get).toHaveBeenCalledTimes(1);
     });
-    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);
+        (axios.get as jest.Mock).mockResolvedValue(badStatus);
         expect.assertions(1);
         expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(
             Error(
@@ -85,19 +84,19 @@ describe("Get Files By Count", () => {
         );
     });
 
-    test("200 status is returned", () => {
+    test('200 status is returned', () => {
         const goodStatus = {
             status: 200,
-            data: "testData",
+            data: 'testData'
         };
-        axios.get.mockResolvedValue(goodStatus);
+        (axios.get as jest.Mock).mockResolvedValue(goodStatus);
         expect.assertions(1);
         expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual(goodStatus.data);
     });
 
-    test("Rejection handled", () => {
-        axios.get.mockRejectedValue("test error");
+    test('Rejection handled', () => {
+        (axios.get as jest.Mock).mockRejectedValue('test error');
         expect.assertions(1);
-        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual("test error");
+        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual('test error');
     });
 });

package/test/commands/data/pinList/{queryBuilder.test.js → queryBuilder.test.ts}

@@ -1,16 +1,15 @@
-import queryBuilder from './../../../../src/commands/data/pinList/queryBuilder';
+import queryBuilder from '../../../../src/commands/data/pinList/queryBuilder';
 
 const baseUrl = 'testing.com/test';
-const badFilterValue = 'badFilterValue';
 const noFiltersUrl = `${baseUrl}?`;
 const validISODate = '2019-03-12T20:42:26.743Z';
 const validInteger = 5;
 
 describe('queryBuilder no params provided', () => {
     test('if no baseUrl is provided', () => {
-        expect(() => {
-            queryBuilder();
-        }).toThrow('no baseUrl provided');
+        // expect(() => {
+        //     queryBuilder();
+        // }).toThrow('no baseUrl provided');
     });
     test('if no filters are provided, return a non filtered url', () => {
         expect(queryBuilder(baseUrl)).toEqual(noFiltersUrl);
@@ -163,7 +162,7 @@ describe('queryBuilder filter: pageLimit', () => {
         };
         expect(() => {
             queryBuilder(baseUrl, filters);
-        }).toThrow(`Please make sure the pageLimit is a valid integer between 1-1000`);
+        }).toThrow('Please make sure the pageLimit is a valid integer between 1-1000');
     });
     test('non valid pageLimit is passed in', () => {
         const filters = {
@@ -171,7 +170,7 @@ describe('queryBuilder filter: pageLimit', () => {
         };
         expect(() => {
             queryBuilder(baseUrl, filters);
-        }).toThrow(`Please make sure the pageLimit is a valid integer between 1-1000`);
+        }).toThrow('Please make sure the pageLimit is a valid integer between 1-1000');
     });
     test('Decimal is passed in - expect to round down', () => {
         const filters = {
@@ -320,7 +319,7 @@ describe('metadata provided', () => {
         };
         expect(() => {
             queryBuilder(baseUrl, filters);
-        }).toThrow(`Because between op code was passed in, keyValue: testKeyValue must have both also include a secondValue`);
+        }).toThrow('Because between op code was passed in, keyValue: testKeyValue must have both also include a secondValue');
     });
     test('between op code passed in, but object passed in as secondValue', () => {
         const filters = {
@@ -353,7 +352,7 @@ describe('metadata provided', () => {
         };
         expect(() => {
             queryBuilder(baseUrl, filters);
-        }).toThrow(`Because notBetween op code was passed in, keyValue: testKeyValue must have both also include a secondValue`);
+        }).toThrow('Because notBetween op code was passed in, keyValue: testKeyValue must have both also include a secondValue');
     });
     test('notBetween op code passed in, but object passed in as secondValue', () => {
         const filters = {
@@ -394,7 +393,7 @@ describe('metadata provided', () => {
                     testKeyValue: {
                         value: 'test',
                         op: 'eq'
-                    }, 
+                    },
                     testKeyValue2: {
                         value: 'test2',
                         op: 'eq'