@pinata/sdk 1.2.0 → 2.0.0-beta.0

package/src/commands/data/userPinnedDataTotal.js

@@ -1,36 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { validateApiKeys } from '../../util/validators';
-import { handleError } from '../../util/errorResponse';
-
-/**
- * User Pinned Data Total
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {Promise<unknown>}
- */
-export default function userPinnedDataTotal(pinataApiKey, pinataSecretApiKey) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
-    let endpoint = `${baseUrl}/data/userPinnedDataTotal`;
-
-    return new Promise((resolve, reject) => {
-        axios.get(
-            endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while attempting to retrieve pinned data total: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/hashPinPolicy.js

@@ -1,57 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { validateApiKeys, validatePinPolicyStructure } from '../../util/validators';
-import isIPFS from 'is-ipfs';
-import { handleError } from '../../util/errorResponse';
-
-/**
- * Hash Pin Policy
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} ipfsPinHash
- * @param {*} newPinPolicy
- * @returns {Promise<unknown>}
- */
-export default function hashPinPolicy(pinataApiKey, pinataSecretApiKey, ipfsPinHash, newPinPolicy) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-    validatePinPolicyStructure(newPinPolicy);
-
-    if (!ipfsPinHash) {
-        throw new Error('ipfsPinHash value is required for changing the pin policy of a pin');
-    }
-
-    if (!isIPFS.cid(ipfsPinHash)) {
-        throw new Error('ipfsPinHash value is an invalid IPFS CID');
-    }
-
-    if (!newPinPolicy) {
-        throw new Error('newPinPolicy is required for changing the pin policy of a pin');
-    }
-
-    const endpoint = `${baseUrl}/pinning/hashPinPolicy`;
-    const body = {
-        ipfsPinHash: ipfsPinHash,
-        newPinPolicy: newPinPolicy
-    };
-
-    return new Promise((resolve, reject) => {
-        axios.put(
-            endpoint,
-            body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while changing pin policy for hash: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/pinJobs/pinJobs.js

@@ -1,42 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../../constants';
-import { validateApiKeys } from '../../../util/validators';
-import queryBuilder from './queryBuilder';
-import { handleError } from '../../../util/errorResponse';
-
-/**
- * Pin Jobs
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} filters
- * @returns {Promise<unknown>}
- */
-export default function pinJobs(pinataApiKey, pinataSecretApiKey, filters) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
-    let endpoint = `${baseUrl}/pinning/pinJobs`;
-
-    if (filters) {
-        endpoint = queryBuilder(endpoint, filters);
-    }
-
-    return new Promise((resolve, reject) => {
-        axios.get(
-            endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while attempting to retrieve pin jobs: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/userPinPolicy.js

@@ -1,46 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { validateApiKeys, validatePinPolicyStructure } from '../../util/validators';
-import { handleError } from '../../util/errorResponse';
-
-/**
- * User Pin Policy
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} newPinPolicy
- * @returns {Promise<unknown>}
- */
-export default function userPinPolicy(pinataApiKey, pinataSecretApiKey, newPinPolicy) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-    validatePinPolicyStructure(newPinPolicy);
-
-    if (!newPinPolicy) {
-        throw new Error('newPinPolicy is required for changing the pin policy of a pin');
-    }
-
-    const endpoint = `${baseUrl}/pinning/userPinPolicy`;
-    const body = {
-        newPinPolicy: newPinPolicy
-    };
-
-    return new Promise((resolve, reject) => {
-        axios.put(
-            endpoint,
-            body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while changing pin policy for user: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/constants.js

@@ -1 +0,0 @@
-export const baseUrl = 'https://api.pinata.cloud';

package/src/index.js

@@ -1,262 +0,0 @@
-import pinByHash from './commands/pinning/pinByHash';
-import hashMetadata from './commands/pinning/hashMetadata';
-import pinFileToIPFS from './commands/pinning/pinFileToIPFS';
-import pinFromFS from './commands/pinning/pinFromFS';
-import pinJSONToIPFS from './commands/pinning/pinJSONToIPFS';
-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
-
-/**
- * @typedef {Record<string, string | number | null>} PinataMetadata
- */
-
-/**
- * @typedef PinataMetadataFilter
- * @property {string} [name]
- * @property {Record<string, {value: string, op: string}>} keyvalues
- */
-
-/**
- * @typedef {{id: string, desiredReplicationCount: number}} PinataPinPolicyItem
- */
-
-/**
- * @typedef PinataPinByHashOptions
- * @property {string[]} [hostNodes]
- * @property {{regions: PinataPinPolicyItem[]}} [customPinPolicy]
- */
-
-/**
- * @typedef PinataPinByHashPinOptions
- * @property {PinataMetadata} [pinataMetadata]
- * @property {PinataPinByHashOptions} [pinataOptions]
- */
-
-/**
- * @typedef PinataOptions
- * @property {0 | 1} [cidVersion]
- * @property {boolean} [wrapWithDirectory]
- * @property {{regions: PinataPinPolicyItem[]}} [customPinPolicy]
- */
-
-/**
- * @typedef PinataPinOptions
- * @property {PinataMetadata} [pinataMetadata]
- * @property {PinataOptions} [pinataOptions]
- */
-
-/**
- * @typedef PinataPinJobsFilterOptions
- * @property {'ASC' | 'DESC'} sort
- * @property {string} [status]
- * @property {string} [ipfs_pin_hash]
- * @property {number} [limit]
- * @property {number} [offset]
- */
-
-/**
- * @typedef PinataPinListFilterOptions
- * @property {string} [hashContains]
- * @property {string} [pinStart]
- * @property {string} [pinEnd]
- * @property {string} [unpinStart]
- * @property {string} [unpinEnd]
- * @property {number} [pinSizeMin]
- * @property {number} [pinSizeMax]
- * @property {string} [status]
- * @property {number} [pageLimit]
- * @property {number} [pageOffset]
- * @property {PinataMetadataFilter} [metadata]
- */
-
-// RESPONSES
-
-/**
- * @typedef PinataPinByHashResponse
- * @property {number | string} id
- * @property {string} ipfsHash
- * @property {string} status
- * @property {string} name
- */
-
-/**
- * @typedef PinataPinResponse
- * @property {string} IpfsHash
- * @property {number} PinSize
- * @property {string} Timestamp
- */
-
-/**
- * @typedef PinataPinJobsResponseRow
- * @property {number | string} id
- * @property {string} ipfs_pin_hash
- * @property {string} date_queued
- * @property {string | undefined | null} name
- * @property {string} status
- */
-
-/**
- * @typedef PinataPinJobsResponse
- * @property {number} count
- * @property {PinataPinJobsResponseRow[]} rows
- */
-
-/**
- * @typedef PinataPinListResponseRow
- * @property {number | string} id
- * @property {string} ipfs_pin_hash
- * @property {number} size
- * @property {string | number} user_id
- * @property {string} date_pinned
- * @property {string} date_unpinned
- * @property {PinataMetadata} metadata
- */
-
-/**
- * @typedef PinataPinListResponse
- * @property {number} count
- * @property {PinataPinListResponseRow[]} rows
- */
-
-// METHODS
-
-/**
- * Hash meta data
- * @callback hashMetadata
- * @param {string} ipfsPinHash
- * @param {PinataMetadata} metadata
- * @returns {Promise<any>}
- */
-
-/**
- * Pin by hash
- * @callback pinByHash
- * @param {string} hashToPin
- * @param {PinataPinByHashPinOptions} [options]
- * @returns {Promise<PinataPinByHashResponse>}
- */
-
-/**
- * Pin file to IPFS
- * @callback pinFileToIPFS
- * @param {ReadStream} readableStream
- * @param {PinataPinOptions} [options]
- * @returns {Promise<PinataPinResponse>}
- */
-
-/**
- * Pin from FS
- * @callback pinFromFS
- * @param {string} sourcePath
- * @param {PinataPinOptions} [options]
- * @returns {Promise<PinataPinResponse>}
- */
-
-/**
- * Pin Jobs
- * @callback pinJobs
- * @param {PinataPinJobsFilterOptions} [filters]
- * @returns {Promise<PinataPinJobsResponse>}
- */
-
-/**
- * Pin JSON to IPFS
- * @callback pinJSONToIPFS
- * @param {Object} body
- * @param {PinataPinOptions} [options]
- * @returns {Promise<PinataPinResponse>}
- */
-
-/**
- * Unpin
- * @callback unpin
- * @param {string} hashToUnpin
- * @returns {Promise<any>}
- */
-
-/**
- * Test Authentication
- * @callback testAuthentication
- * @returns {Promise<{authenticated: boolean}>}
- */
-
-/**
- * Pin List
- * @callback pinList
- * @param {PinataPinListFilterOptions} [filters]
- * @returns {Promise<PinataPinListResponse>}
- */
-
-/**
- * User Pinned Data Total
- * @callback userPinnedDataTotal
- * @returns {Promise<number>}
- */
-
-/**
- * @typedef PinataClient
- * @property {pinByHash} pinByHash
- * @property {hashMetadata} hashMetadata
- * @property {pinFileToIPFS} pinFileToIPFS
- * @property {pinFromFS} pinFromFS
- * @property {pinJSONToIPFS} pinJSONToIPFS
- * @property {pinJobs} pinJobs
- * @property {unpin} unpin
- * @property {testAuthentication} testAuthentication
- * @property {pinList} pinList
- * @property {userPinnedDataTotal} userPinnedDataTotal
- */
-
-/**
- * Pinata Client
- *
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {PinataClient}
- */
-export default function pinataClient(pinataApiKey, pinataSecretApiKey) {
-    let client = {};
-
-    //  setting up the actual calls you can make using this package
-    client.pinByHash = function (hashToPin, options) {
-        return pinByHash(pinataApiKey, pinataSecretApiKey, hashToPin, options);
-    };
-    client.hashMetadata = function (ipfsPinHash, metadata) {
-        return hashMetadata(pinataApiKey, pinataSecretApiKey, ipfsPinHash, metadata);
-    };
-    client.pinFileToIPFS = function (readableStream, options) {
-        return pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readableStream, options);
-    };
-    client.pinFromFS = function (sourcePath, options) {
-        return pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath, options);
-    };
-    client.pinJSONToIPFS = function (body, options) {
-        return pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, options);
-    };
-    client.pinJobs = function (filters) {
-        return pinJobs(pinataApiKey, pinataSecretApiKey, filters);
-    };
-    client.unpin = function (hashToUnpin) {
-        return unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin);
-    };
-    client.testAuthentication = function () {
-        return testAuthentication(pinataApiKey, pinataSecretApiKey);
-    };
-    client.pinList = function (filters) {
-        return pinList(pinataApiKey, pinataSecretApiKey, filters);
-    };
-
-    client.getFilesByCount = function (filters, maxCount,) {
-        return getFilesByCount(pinataApiKey, pinataSecretApiKey, filters, maxCount);
-    };
-    client.userPinnedDataTotal = function () {
-        return userPinnedDataTotal(pinataApiKey, pinataSecretApiKey);
-    };
-    return client;
-}

package/src/util/validators.js

@@ -1,118 +0,0 @@
-import isIPFS from 'is-ipfs';
-
-/**
- * Validate API Keys
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- */
-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');
-    }
-    if (!pinataSecretApiKey || pinataSecretApiKey === '') {
-        throw new Error('No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script');
-    }
-}
-
-/**
- * Validate host Nodes
- * @param {*} hostNodes
- */
-export function validateHostNodes(hostNodes) {
-    if (!Array.isArray(hostNodes)) {
-        throw new Error('host_nodes value must be an array');
-    }
-    hostNodes.forEach((node) => {
-        if (!isIPFS.peerMultiaddr(node)) {
-            throw new Error(`host_node array entry: ${node} is not a valid peer multiaddr`);
-        }
-    });
-}
-
-/**
- * Validate MetaData
- * @param {*} metadata
- */
-export function validateMetadata(metadata) {
-    if (metadata.name) {
-        if (!(typeof metadata.name === 'string' || metadata.name instanceof String)) {
-            throw new Error('metadata name must be of type string');
-        }
-    }
-
-    if (metadata.keyvalues) {
-        if (!(typeof metadata.keyvalues === 'object')) {
-            throw new Error('metatadata keyvalues must be an object');
-        }
-
-        let i = 0;
-
-        Object.entries(metadata.keyvalues).forEach(function (keyValue) {
-            if (i > 9) {
-                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');
-            }
-            i++;
-        });
-    }
-}
-
-/**
- * Validate Pin Policy Structure
- * @param {*} pinPolicy
- */
-export function validatePinPolicyStructure(pinPolicy) {
-    //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');
-    }
-
-    if (!pinPolicy.regions) {
-        throw new Error('No regions provided in pin policy');
-    }
-    if (pinPolicy.regions.length) {
-        pinPolicy.regions.forEach((region) => {
-            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)) {
-                throw new Error('desiredReplicationCount must be an integer');
-            }
-        });
-    }
-}
-
-/**
- * Validate Pinata Options
- * @param {*} options
- */
-export function validatePinataOptions(options) {
-    if (typeof options !== 'object') {
-        throw new Error('options must be an object');
-    }
-
-    if (options.cidVersion) {
-        // eslint-disable-next-line eqeqeq
-        if (options.cidVersion != 0 && options.cidVersion != 1) {
-            throw new Error('unsupported or invalid cidVersion');
-        }
-    }
-    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.hostNodes) {
-        validateHostNodes(options.hostNodes);
-    }
-
-    if (options.customPinPolicy) {
-        validatePinPolicyStructure(options.customPinPolicy);
-    }
-}

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

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