@pinata/sdk 1.2.1 → 2.0.0-beta.0

package/package.json

@@ -1,74 +1,86 @@
 {
-  "name": "@pinata/sdk",
-  "version": "1.2.1",
-  "description": "Official SDK for the Pinata IPFS platform",
-  "main": "lib/pinata-sdk.js",
-  "types": "types/index.d.ts",
-  "scripts": {
-    "build": "webpack --env dev && webpack --env build && npm run test && tsc",
-    "coverage": "jest --coverage",
-    "dev": "webpack --progress --colors --watch --env dev",
-    "html": "open coverage/index.html",
-    "lint": "eslint src --quiet ",
-    "lint:fix": "eslint src --fix",
-    "test": "./node_modules/.bin/jest --env=node",
-    "repl": "node -i -e \"$(< ./lib/pinata-sdk.js)\""
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/PinataCloud/Pinata-SDK.git"
-  },
-  "keywords": [
-    "webpack",
-    "es6",
-    "starter",
-    "library",
-    "universal",
-    "umd",
-    "commonjs"
-  ],
-  "author": "Matt Ober",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/PinataCloud/Pinata-SDK/issues"
-  },
-  "homepage": "https://github.com/PinataCloud/Pinata-SDK",
-  "devDependencies": {
-    "@babel/cli": "^7.8.4",
-    "@babel/core": "^7.8.4",
-    "@babel/plugin-transform-runtime": "^7.19.1",
-    "@babel/preset-env": "^7.19.4",
-    "@babel/register": "^7.8.3",
-    "@types/node": "^15.6.1",
-    "acorn": "^7.1.0",
-    "babel-eslint": "^10.0.3",
-    "babel-loader": "^8.0.6",
-    "babel-plugin-add-module-exports": "^1.0.2",
-    "babel-polyfill": "^6.26.0",
-    "eslint": "^6.8.0",
-    "eslint-loader": "^3.0.3",
-    "jest": "^25.1.0",
-    "typescript": "^4.2.3",
-    "uglifyjs-webpack-plugin": "^2.2.0",
-    "webpack": "^4.41.6",
-    "webpack-cli": "^3.3.11",
-    "yargs": "^10.0.3"
-  },
-  "dependencies": {
-    "axios": "^0.21.1",
-    "base-path-converter": "^1.0.2",
-    "form-data": "^2.3.3",
-    "is-ipfs": "^0.6.0",
-    "recursive-fs": "^1.1.2"
-  },
-  "jest": {
-    "collectCoverage": true,
-    "coverageReporters": [
-      "text",
-      "html"
+    "name": "@pinata/sdk",
+    "version": "2.0.0-beta.0",
+    "description": "Official SDK for the Pinata IPFS platform",
+    "main": "lib/pinata-sdk.js",
+    "types": "types/index.d.ts",
+    "scripts": {
+        "prepare": "husky install",
+        "build": "npm run build-dev && npm run build-prod && npm run test && tsc",
+        "build-dev": "webpack --env dev",
+        "build-prod": "webpack --env build",
+        "coverage": "jest --coverage",
+        "dev": "webpack --progress --colors --watch --env dev",
+        "html": "open coverage/index.html",
+        "lint": "eslint src --quiet ",
+        "lint:fix": "eslint src test --fix",
+        "test": "./node_modules/.bin/jest --env=node",
+        "repl": "node -i -e \"$(< ./lib/pinata-sdk.js)\""
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/PinataCloud/Pinata-SDK.git"
+    },
+    "keywords": [
+        "webpack",
+        "es6",
+        "starter",
+        "library",
+        "universal",
+        "umd",
+        "commonjs"
     ],
-    "moduleFileExtensions": [
-      "js"
-    ]
-  }
+    "author": "Matt Ober",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/PinataCloud/Pinata-SDK/issues"
+    },
+    "homepage": "https://github.com/PinataCloud/Pinata-SDK",
+    "devDependencies": {
+        "@babel/cli": "^7.8.4",
+        "@babel/core": "^7.8.4",
+        "@babel/plugin-transform-runtime": "^7.19.1",
+        "@babel/preset-env": "^7.19.4",
+        "@babel/preset-typescript": "^7.18.6",
+        "@babel/register": "^7.8.3",
+        "@types/jest": "^29.2.0",
+        "@types/node": "^15.6.1",
+        "@typescript-eslint/eslint-plugin": "^5.41.0",
+        "@typescript-eslint/parser": "^5.41.0",
+        "acorn": "^7.1.0",
+        "babel-eslint": "^10.0.3",
+        "babel-loader": "^8.0.6",
+        "babel-plugin-add-module-exports": "^1.0.2",
+        "babel-polyfill": "^6.26.0",
+        "eslint": "^8.26.0",
+        "eslint-loader": "^3.0.3",
+        "husky": "^8.0.0",
+        "jest": "^25.1.0",
+        "source-map-loader": "^4.0.1",
+        "typescript": "^4.8.4",
+        "uglifyjs-webpack-plugin": "^2.2.0",
+        "webpack": "^4.41.6",
+        "webpack-cli": "^3.3.11"
+    },
+    "dependencies": {
+        "axios": "^0.21.1",
+        "base-path-converter": "^1.0.2",
+        "form-data": "^2.3.3",
+        "is-ipfs": "^0.6.0",
+        "recursive-fs": "^1.1.2"
+    },
+    "jest": {
+        "collectCoverage": true,
+        "coverageReporters": [
+            "text",
+            "html"
+        ],
+        "moduleFileExtensions": [
+            "ts",
+            "tsx",
+            "js",
+            "jsx",
+            "json"
+        ]
+    }
 }

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

@@ -1,9 +1,10 @@
-import pinList from '../pinList/pinList';
+import { PinataConfig } from '../../..';
+import pinList, { PinataPin, PinataPinListFilterOptions } from '../pinList/pinList';
 
 export default function getFilesByCount(
-    config,
+    config: PinataConfig,
 
-    filters = {},
+    filters: PinataPinListFilterOptions = {},
     maxCount = -1
 ) {
     if (maxCount === 0) {
@@ -15,7 +16,7 @@ export default function getFilesByCount(
             let i = 0;
             const pageLimit = 10;
             let pageOffset = 0;
-            let cache = [];
+            let cache: PinataPin[] = [];
             let keepLooping = false;
 
             return {
@@ -24,7 +25,7 @@ export default function getFilesByCount(
                         if (i === 0 || (i % pageLimit === 0 && keepLooping)) {
                             resolve(
                                 pinList(config, {
-                                    filters,
+                                    ...filters,
                                     ...{ pageOffset, pageLimit }
                                 }).then((resp) => {
                                     cache = resp.rows;
@@ -33,13 +34,11 @@ export default function getFilesByCount(
                                     // If the user requested all pins we have to keep looping if the limit page was not fulfill
                                     keepLooping =
                                         cache.length !== 0 &&
-                                        (maxCount === -1 ?
-                                            cache.length === pageLimit :
-                                            i < maxCount);
+                                        (maxCount === -1 ? cache.length === pageLimit : i < maxCount);
                                 })
                             );
                         }
-                        resolve();
+                        resolve(0);
                     }).then(() => {
                         const valueToReturn = cache[i % pageLimit];
 

package/src/commands/data/index.ts

@@ -0,0 +1,4 @@
+export * from '../data/pinList/pinList';
+export * from '../data/pinList/queryBuilder';
+export * from './testAuthentication';
+export * from './userPinnedDataTotal';

package/src/commands/data/pinList/pinList.ts

@@ -0,0 +1,77 @@
+import axios from 'axios';
+import { baseUrl } from '../../../constants';
+import { createConfigForAxiosHeaders } from '../../../util/validators';
+import { handleError } from '../../../util/errorResponse';
+import queryBuilder from './queryBuilder';
+import { PinataConfig } from '../../..';
+export interface PinataPinRegion {
+    regionId: string;
+    currentReplicationCount: number;
+    desiredReplicationCount: number;
+}
+
+export interface PinataMetadata { [key: string]: string | number | null }
+export interface PinataMetadataFilter {
+    name?: string | undefined;
+    keyvalues: { [key: string]: {
+        value: string;
+        op: string;
+    } }
+}
+export interface PinataPin {
+    id: string | number;
+    ipfs_pin_hash: string;
+    size: number;
+    user_id: string | number;
+    date_pinned: string;
+    date_unpinned: string | null;
+    metadata: PinataMetadata,
+    regions: PinataPinRegion[];
+}
+
+export type PinataPinListFilterOptions = {
+    hashContains?: string | undefined;
+    pinStart?: string | undefined;
+    pinEnd?: string | undefined;
+    unpinStart?: string | undefined;
+    unpinEnd?: string | undefined;
+    pinSizeMin?: number | undefined;
+    pinSizeMax?: number | undefined;
+    status?: string | undefined;
+    pageLimit?: number | undefined;
+    pageOffset?: number | undefined;
+    metadata?: PinataMetadataFilter | undefined;
+};
+
+export interface PinataPinListResponse {
+    rows: PinataPin[];
+}
+
+export default function pinList(
+    config: PinataConfig,
+    filters:PinataPinListFilterOptions = {}
+): Promise<PinataPinListResponse> {
+    filters = { ...filters, ...{ includeCount: 'false' } };
+
+    const baseEndpoint = `${baseUrl}/data/pinList`;
+    const endpoint = queryBuilder(baseEndpoint, 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 user pin list: ${result}`
+                        )
+                    );
+                }
+                resolve(result.data);
+            })
+            .catch(function (error) {
+                const formattedError = handleError(error);
+                reject(formattedError);
+            });
+    });
+}

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

@@ -1,10 +1,6 @@
-/**
- * Validate and return data
- * @param {*} dateToValidate
- * @returns {*}
- */
-function validateAndReturnDate(dateToValidate) {
-    let dateParsed = new Date(Date.parse(dateToValidate));
+
+function validateAndReturnDate(dateToValidate: any): any {
+    const dateParsed = new Date(Date.parse(dateToValidate));
 
     try {
         if (dateParsed.toISOString() === dateToValidate) {
@@ -17,13 +13,7 @@ function validateAndReturnDate(dateToValidate) {
     }
 }
 
-/**
- * Query Builder
- * @param {string} baseUrl
- * @param {*} filters
- * @returns {string}
- */
-export default function queryBuilder(baseUrl, filters) {
+export default function queryBuilder(baseUrl: string, filters?: any): string {
     if (!baseUrl) {
         throw new Error('no baseUrl provided');
     }
@@ -106,11 +96,11 @@ export default function queryBuilder(baseUrl, filters) {
                     throw new Error('metadata keyvalues must be an object');
                 }
 
-                const prunedKeyValues = {}; // we want to make sure we're only grabbing the values we want for the query, and nothing extra
+                const prunedKeyValues: any = {}; // we want to make sure we're only grabbing the values we want for the query, and nothing extra
 
                 Object.entries(filters.metadata.keyvalues).forEach((keyValue) => {
                     const key = keyValue[0];
-                    const value = keyValue[1];
+                    const value: any = keyValue[1];
 
                     if (typeof value !== 'object') {
                         throw new Error(`keyValue: ${key} is not an object`);

package/src/commands/data/{testAuthentication.js → testAuthentication.ts}

@@ -1,15 +1,14 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import {createConfigForAxiosHeaders} from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
 
-/**
- * Test Authentication
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {Promise<unknown>}
- */
-export default function testAuthentication(config) {
+export interface PinataTestAuthenticationResponse {
+    authenticated: boolean;
+}
+
+export default function testAuthentication(config: PinataConfig): Promise<PinataTestAuthenticationResponse> {
     //  test authentication to make sure that the user's provided keys are legit
     const endpoint = `${baseUrl}/data/testAuthentication`;
 
@@ -29,4 +28,4 @@ export default function testAuthentication(config) {
             reject(formattedError);
         });
     });
-};
+}

package/src/commands/data/{userPinnedDataTotal.js → userPinnedDataTotal.ts}

@@ -1,16 +1,11 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import { createConfigForAxiosHeaders } from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
 
-/**
- * User Pinned Data Total
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {Promise<unknown>}
- */
-export default function userPinnedDataTotal(config) {
-    let endpoint = `${baseUrl}/data/userPinnedDataTotal`;
+export default function userPinnedDataTotal(config: PinataConfig): Promise<number> {
+    const endpoint = `${baseUrl}/data/userPinnedDataTotal`;
 
     return new Promise((resolve, reject) => {
         axios.get(

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

@@ -1,18 +1,12 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
+import { PinataMetadata } from '../data/pinList/pinList';
 
-/**
- * Hash Meta Data
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} ipfsPinHash
- * @param {*} metadata
- * @returns {Promise<unknown>}
- */
-export default function hashMetadata(config, ipfsPinHash, metadata) {
+export default function hashMetadata(config: PinataConfig, ipfsPinHash: string, metadata:PinataMetadata): Promise<any> {
     if (!ipfsPinHash) {
         throw new Error('ipfsPinHash value is required for changing the pin policy of a pin');
     }
@@ -28,7 +22,11 @@ export default function hashMetadata(config, ipfsPinHash, metadata) {
     validateMetadata(metadata);
 
     const endpoint = `${baseUrl}/pinning/hashMetadata`;
-    const body = {
+    const body: {
+        ipfsPinHash: string,
+        name?: any,
+        keyvalues?: any
+    } = {
         ipfsPinHash: ipfsPinHash
     };
 

package/src/commands/pinning/index.ts

@@ -0,0 +1,8 @@
+export * from './pinJobs/pinJobs';
+export * from './pinJobs/queryBuilder';
+export * from './hashMetadata';
+export * from './pinByHash';
+export * from './pinFileToIPFS';
+export * from './pinFromFS';
+export * from './pinJSONToIPFS';
+export * from './unpin';

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

@@ -1,18 +1,25 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
+import { PinataOptions } from './pinFileToIPFS';
+import { PinataMetadata } from '../data/pinList/pinList';
 
-/**
- * Pin By Hash
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} hashToPin
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinByHash(config, hashToPin, options) {
+export interface PinataPinByHashPinOptions {
+    pinataMetadata?: PinataMetadata;
+    pinataOptions?: PinataOptions ;
+}
+
+export interface PinataPinByHashResponse {
+    id: number | string;
+    ipfsHash: string;
+    status: string;
+    name: string;
+}
+
+export default function pinByHash(config: PinataConfig, hashToPin: string, options: any): Promise<any> {
     if (!hashToPin) {
         throw new Error('hashToPin value is required for pinning by hash');
     }
@@ -21,7 +28,11 @@ export default function pinByHash(config, hashToPin, options) {
     }
 
     const endpoint = `${baseUrl}/pinning/pinByHash`;
-    const body = {
+    const body : {
+        hashToPin: any,
+        pinataOptions: any,
+        pinataMetadata?: any,
+    } = {
         hashToPin: hashToPin,
         pinataOptions: {}
     };

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

@@ -1,19 +1,35 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import NodeFormData from 'form-data';
 import stream from 'stream';
 import {createConfigForAxiosHeadersWithFormData, validateMetadata, validatePinataOptions} from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
+import { PinataConfig } from '../..';
 
-/**
- * Pin File to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} readStream
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFileToIPFS(config, readStream, options) {
+export interface PinataPinPolicyItem {
+    id: string;
+    desiredReplicationCount: number;
+}
+export interface PinataOptions {
+    hostNodes?: string[] | undefined;
+    cidVersion?: 0 | 1 ;
+    wrapWithDirectory?: boolean;
+    customPinPolicy?: {
+        regions: PinataPinPolicyItem[];
+    };
+}
+
+export interface PinataPinResponse {
+    IpfsHash: string;
+    PinSize: number;
+    Timestamp: string;
+}
+export interface PinataPinOptions {
+    pinataMetadata?: { [key: string]: string | number | null },
+    pinataOptions?: PinataOptions | undefined;
+}
+
+export default function pinFileToIPFS(config: PinataConfig, readStream: any, options?: PinataPinOptions):Promise<PinataPinResponse> {
     return new Promise((resolve, reject) => {
 
         const data = new NodeFormData();
@@ -39,7 +55,7 @@ export default function pinFileToIPFS(config, readStream, options) {
            axios.post(
             endpoint,
             readStream instanceof NodeFormData ? readStream : data,
-            createConfigForAxiosHeadersWithFormData(config, data._boundary)
+            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/{pinFromFS.js → pinFromFS.ts}

@@ -1,28 +1,23 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+import { baseUrl } from '../../constants';
 import NodeFormData from 'form-data';
 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(config, sourcePath, options) {
+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
@@ -44,7 +39,7 @@ export default function pinFromFS(config, sourcePath, options) {
                 axios.post(
                     endpoint,
                     data,
-                    createConfigForAxiosHeadersWithFormData(config, data._boundary))
+                    createConfigForAxiosHeadersWithFormData(config, data.getBoundary()))
                 .then(function (result) {
                     if (result.status !== 200) {
                         reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
@@ -55,14 +50,14 @@ export default function pinFromFS(config, sourcePath, options) {
                     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)
@@ -83,7 +78,7 @@ export default function pinFromFS(config, sourcePath, options) {
                     axios.post(
                         endpoint,
                         data,
-                        createConfigForAxiosHeadersWithFormData(config, data._boundary))
+                        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,19 +1,13 @@
 import axios from 'axios';
-import { baseUrl } from './../../constants';
+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(config, body, options) {
+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');