@pinata/sdk 1.2.0 → 2.0.0-beta.0

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

@@ -1,29 +1,23 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import NodeFormData from 'form-data';
-import {validateApiKeys, validateMetadata, validatePinataOptions} from '../../util/validators';
+import {createConfigForAxiosHeadersWithFormData, validateMetadata, validatePinataOptions} from '../../util/validators';
 import basePathConverter from 'base-path-converter';
 import { handleError } from '../../util/errorResponse';
-const fs = require('fs');
-const recursive = require('recursive-fs');
+import { PinataConfig } from '../..';
+import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
+import * as fs from 'fs';
+import * as recursive from 'recursive-fs';
 
-/**
- * PinFromFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {string} sourcePath
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function pinFromFS(config: PinataConfig, sourcePath: string, options?: PinataPinOptions): Promise<PinataPinResponse> {
 
     return new Promise((resolve, reject) => {
         const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
 
-        fs.stat(sourcePath, (err, stats) => {
+        // eslint-disable-next-line consistent-return
+        fs.stat(sourcePath, (err: any, stats: any) => {
             if (err) {
-                reject(err);
+                return reject(err);
             }
             if (stats.isFile()) {
                 //we need to create a single read stream instead of reading the directory recursively
@@ -45,16 +39,8 @@ export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath,
                 axios.post(
                     endpoint,
                     data,
-                    {
-                        withCredentials: true,
-                        maxContentLength: 'Infinity', //this is needed to prevent axios from erroring out with large directories
-                        maxBodyLength: 'Infinity',
-                        headers: {
-                            'Content-type': `multipart/form-data; boundary= ${data._boundary}`,
-                            'pinata_api_key': pinataApiKey,
-                            'pinata_secret_api_key': pinataSecretApiKey
-                        }
-                    }).then(function (result) {
+                    createConfigForAxiosHeadersWithFormData(config, data.getBoundary()))
+                .then(function (result) {
                     if (result.status !== 200) {
                         reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
                     }
@@ -64,14 +50,14 @@ export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath,
                     reject(formattedError);
                 });
             } else {
-                recursive.readdirr(sourcePath, function (err, dirs, files) {
+                recursive.readdirr(sourcePath, function (err: any, dirs: any, files: any) {
                     if (err) {
                         reject(new Error(err));
                     }
 
-                    let data = new NodeFormData();
+                    const data = new NodeFormData();
 
-                    files.forEach((file) => {
+                    files.forEach((file: any) => {
                         //for each file stream, we need to include the correct relative file path
                         data.append('file', fs.createReadStream(file), {
                             filepath: basePathConverter(sourcePath, file)
@@ -92,16 +78,8 @@ export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath,
                     axios.post(
                         endpoint,
                         data,
-                        {
-                            withCredentials: true,
-                            maxContentLength: 'Infinity',
-                            maxBodyLength: 'Infinity', //this is needed to prevent axios from erroring out with large directories
-                            headers: {
-                                'Content-type': `multipart/form-data; boundary= ${data._boundary}`,
-                                'pinata_api_key': pinataApiKey,
-                                'pinata_secret_api_key': pinataSecretApiKey
-                            }
-                        }).then(function (result) {
+                        createConfigForAxiosHeadersWithFormData(config, data.getBoundary()))
+                    .then(function (result) {
                         if (result.status !== 200) {
                             reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
                         }

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

@@ -1,20 +1,13 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { validateApiKeys, validateMetadata, validatePinataOptions } from '../../util/validators';
+import { baseUrl } from '../../constants';
+import { createConfigForAxiosHeaders, validateMetadata, validatePinataOptions } from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
+import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
 
-/**
- * Pin JSON to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} body
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function pinJSONToIPFS(config: PinataConfig, body: any, options? : PinataPinOptions):Promise<PinataPinResponse> {
 
-    let requestBody = body;
+    let requestBody: any = body;
 
     if (typeof body !== 'object') {
         throw new Error('body must be a valid JSON object');
@@ -40,13 +33,8 @@ export default function pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, op
         axios.post(
             endpoint,
             requestBody,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while pinning JSON to IPFS: ${result}`));
             }

package/src/commands/pinning/pinJobs/pinJobs.ts

@@ -0,0 +1,50 @@
+import axios from 'axios';
+import { baseUrl } from '../../../constants';
+import { createConfigForAxiosHeaders } from '../../../util/validators';
+import queryBuilder from './queryBuilder';
+import { handleError } from '../../../util/errorResponse';
+import { PinataConfig } from '../../..';
+
+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`;
+
+    if (filters) {
+        endpoint = queryBuilder(endpoint, filters);
+    }
+
+    return new Promise((resolve, reject) => {
+        axios.get(
+            endpoint,
+            {...createConfigForAxiosHeaders(config)})
+        .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/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,19 +1,11 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { validateApiKeys } from '../../util/validators';
+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(pinataApiKey, pinataSecretApiKey, hashToUnpin) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function unpin(config: PinataConfig, hashToUnpin: string) {
     if (!hashToUnpin) {
         throw new Error('hashToUnpin value is required for removing a pin from Pinata');
     }
@@ -26,13 +18,8 @@ export default function unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin) {
     return new Promise((resolve, reject) => {
         axios.delete(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while removing pin from IPFS: ${result}`));
             }

package/src/constants.ts

@@ -0,0 +1,4 @@
+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';

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.ts

@@ -0,0 +1,175 @@
+import isIPFS from 'is-ipfs';
+import { PinataConfig } from '..';
+import { ERROR_NO_CREDENTIALS_PROVIDED} from '../constants';
+
+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'
+        );
+    }
+    if (!pinataSecretApiKey || pinataSecretApiKey === '') {
+        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: PinataConfig) {
+    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: PinataConfig, boundaryValue: string) {
+    const requestOptions = {
+        ...createConfigForAxiosHeaders(config),
+        maxContentLength: Infinity, //this is needed to prevent axios from erroring out with large files
+        maxBodyLength: Infinity,
+        headers: {
+            'Content-type': `multipart/form-data; boundary= ${boundaryValue}`
+        }
+    };
+
+    return requestOptions;
+}
+
+export function validateHostNodes(hostNodes: any) {
+    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`
+            );
+        }
+    });
+}
+
+export function validateMetadata(metadata: any) {
+    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: any) {
+            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++;
+        });
+    }
+}
+
+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');
+    }
+
+    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');
+            }
+        });
+    }
+}
+
+export function validatePinataOptions(options: { cidVersion?: number; wrapWithDirectory?: boolean; hostNodes?: any; customPinPolicy?: any; }) {
+    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);
+    }
+}