@pinata/sdk 1.1.22 → 1.1.25

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@pinata/sdk",
-  "version": "1.1.22",
+  "version": "1.1.25",
   "description": "Official SDK for the Pinata IPFS platform",
   "main": "lib/pinata-sdk.js",
-  "types": "dist/index.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
     "build": "webpack --env dev && webpack --env build && npm run test && tsc",
     "coverage": "jest --coverage",

package/src/commands/pinning/pinFileToIPFS.js

@@ -24,8 +24,8 @@ export default function pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readStre
 
         const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
 
-        if (!(readStream instanceof stream.Readable)) {
-            reject(new Error('readStream is not a readable stream'));
+        if (!(readStream instanceof stream.Readable || readStream instanceof NodeFormData)) {
+            reject(new Error('readStream is not a readable stream or form data'));
         }
 
         if (options) {
@@ -41,7 +41,7 @@ export default function pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readStre
 
         axios.post(
             endpoint,
-            data,
+            readStream instanceof NodeFormData ? readStream : data,
             {
                 withCredentials: true,
                 maxContentLength: 'Infinity', //this is needed to prevent axios from erroring out with large files

package/test/commands/pinning/pinFileToIPFS.test.js

@@ -1,20 +1,23 @@
 import axios from 'axios';
 import pinFileToIPFS from'../../../src/commands/pinning/pinFileToIPFS';
 import fs from 'fs';
+import NodeFormData from 'form-data';
 jest.mock('axios');
 
 //common values
 const nonStream = 'test';
 const validStream = fs.createReadStream('./pinata.png');
+const validFormData = new NodeFormData();
+validFormData.append('file', validStream, {filepath: 'test/filepath'});
 
 
-test('non-readableStream is passed in', () => {
-    expect(pinFileToIPFS('test', 'test', nonStream)).rejects.toEqual(Error('readStream is not a readable stream'));
+test('non-readableStream and non-formData is passed in', () => {
+    expect(pinFileToIPFS('test', 'test', nonStream)).rejects.toEqual(Error('readStream is not a readable stream or form data'));
 
     return undefined;
 });
 
-test('200 status is returned', () => {
+test('200 status is returned with valid stream', () => {
     const goodStatus = {
         status: 200,
         data: 'testData'
@@ -24,6 +27,16 @@ test('200 status is returned', () => {
     expect(pinFileToIPFS('test', 'test', validStream)).resolves.toEqual(goodStatus.data);
 });
 
+test('200 status is returned with valid form data', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    axios.post.mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinFileToIPFS('test', 'test', validFormData)).resolves.toEqual(goodStatus.data);
+});
+
 test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700

package/tsconfig.json

@@ -6,7 +6,7 @@
     "declaration": true,
     "emitDeclarationOnly": true,
     "allowJs": true,
-    "outDir": "dist",
+    "outDir": "types",
     "target": "es5",
     "module": "commonjs",
     "lib": ["es2017", "es7", "es6", "dom"],

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

@@ -0,0 +1,8 @@
+/**
+ * Pin List
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {string} filters
+ * @returns {Promise<unknown>}
+ */
+export default function pinList(pinataApiKey: string, pinataSecretApiKey: string, filters: string): Promise<unknown>;

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

@@ -0,0 +1,7 @@
+/**
+ * Query Builder
+ * @param {string} baseUrl
+ * @param {*} filters
+ * @returns {string}
+ */
+export default function queryBuilder(baseUrl: string, filters: any): string;

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

@@ -0,0 +1,7 @@
+/**
+ * Test Authentication
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @returns {Promise<unknown>}
+ */
+export default function testAuthentication(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;

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

@@ -0,0 +1,7 @@
+/**
+ * User Pinned Data Total
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @returns {Promise<unknown>}
+ */
+export default function userPinnedDataTotal(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;

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

@@ -0,0 +1,9 @@
+/**
+ * Hash Meta Data
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} ipfsPinHash
+ * @param {*} metadata
+ * @returns {Promise<unknown>}
+ */
+export default function hashMetadata(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, metadata: any): Promise<unknown>;

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

@@ -0,0 +1,9 @@
+/**
+ * Hash Pin Policy
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} ipfsPinHash
+ * @param {*} newPinPolicy
+ * @returns {Promise<unknown>}
+ */
+export default function hashPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, newPinPolicy: any): Promise<unknown>;

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

@@ -0,0 +1,9 @@
+/**
+ * Pin By Hash
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} hashToPin
+ * @param {*} options
+ * @returns {Promise<unknown>}
+ */
+export default function pinByHash(pinataApiKey: string, pinataSecretApiKey: string, hashToPin: any, options: any): Promise<unknown>;

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

@@ -0,0 +1,9 @@
+/**
+ * Pin File to IPFS
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} readStream
+ * @param {*} options
+ * @returns {Promise<unknown>}
+ */
+export default function pinFileToIPFS(pinataApiKey: string, pinataSecretApiKey: string, readStream: any, options: any): Promise<unknown>;

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Pin JSON to IPFS
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} body
+ * @param {*} options
+ * @returns {Promise<unknown>}
+ */
+export default function pinJSONToIPFS(pinataApiKey: string, pinataSecretApiKey: string, body: any, options: any): Promise<unknown>;

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

@@ -0,0 +1,8 @@
+/**
+ * Pin Jobs
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} filters
+ * @returns {Promise<unknown>}
+ */
+export default function pinJobs(pinataApiKey: string, pinataSecretApiKey: string, filters: any): Promise<unknown>;

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

@@ -0,0 +1,7 @@
+/**
+ * Query Buidler
+ * @param {string} baseUrl
+ * @param {*} filters
+ * @returns {*}
+ */
+export default function queryBuilder(baseUrl: string, filters: any): any;

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

@@ -0,0 +1,8 @@
+/**
+ * Unpin
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {string} hashToUnpin
+ * @returns {Promise<unknown>}
+ */
+export default function unpin(pinataApiKey: string, pinataSecretApiKey: string, hashToUnpin: string): Promise<unknown>;

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

@@ -0,0 +1,8 @@
+/**
+ * User Pin Policy
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @param {*} newPinPolicy
+ * @returns {Promise<unknown>}
+ */
+export default function userPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, newPinPolicy: any): Promise<unknown>;

package/types/constants.d.ts

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

package/types/index.d.ts

@@ -0,0 +1,362 @@
+/**
+ * @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]
+ */
+/**
+ * @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
+ */
+/**
+ * Hash meta data
+ * @callback hashMetadata
+ * @param {string} ipfsPinHash
+ * @param {PinataMetadata} metadata
+ * @returns {Promise<any>}
+ */
+/**
+ * Hash pin policy
+ * @callback hashPinPolicy
+ * @param {string} ipfsPinHash
+ * @param {{regions: PinataPinPolicyItem[]}} newPinPolicy
+ * @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>}
+ */
+/**
+ * User Pin Policy
+ * @callback userPinPolicy
+ * @param {{regions: PinataPinPolicyItem[]}} newPinPolicy
+ * @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 {hashPinPolicy} hashPinPolicy
+ * @property {pinFileToIPFS} pinFileToIPFS
+ * @property {pinFromFS} pinFromFS
+ * @property {pinJSONToIPFS} pinJSONToIPFS
+ * @property {pinJobs} pinJobs
+ * @property {unpin} unpin
+ * @property {userPinPolicy} userPinPolicy
+ * @property {testAuthentication} testAuthentication
+ * @property {pinList} pinList
+ * @property {userPinnedDataTotal} userPinnedDataTotal
+ */
+/**
+ * Pinata Client
+ *
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ * @returns {PinataClient}
+ */
+export default function pinataClient(pinataApiKey: string, pinataSecretApiKey: string): PinataClient;
+export type PinataMetadata = Record<string, string | number | null>;
+export type PinataMetadataFilter = {
+    name?: string | undefined;
+    keyvalues: Record<string, {
+        value: string;
+        op: string;
+    }>;
+};
+export type PinataPinPolicyItem = {
+    id: string;
+    desiredReplicationCount: number;
+};
+export type PinataPinByHashOptions = {
+    hostNodes?: string[] | undefined;
+    customPinPolicy?: {
+        regions: PinataPinPolicyItem[];
+    } | undefined;
+};
+export type PinataPinByHashPinOptions = {
+    pinataMetadata?: Record<string, string | number | null> | undefined;
+    pinataOptions?: PinataPinByHashOptions | undefined;
+};
+export type PinataOptions = {
+    cidVersion?: 0 | 1 | undefined;
+    wrapWithDirectory?: boolean | undefined;
+    customPinPolicy?: {
+        regions: PinataPinPolicyItem[];
+    } | undefined;
+};
+export type PinataPinOptions = {
+    pinataMetadata?: Record<string, string | number | null> | undefined;
+    pinataOptions?: PinataOptions | undefined;
+};
+export type PinataPinJobsFilterOptions = {
+    sort: 'ASC' | 'DESC';
+    status?: string | undefined;
+    ipfs_pin_hash?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+};
+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 type PinataPinByHashResponse = {
+    id: number | string;
+    ipfsHash: string;
+    status: string;
+    name: string;
+};
+export type PinataPinResponse = {
+    IpfsHash: string;
+    PinSize: number;
+    Timestamp: string;
+};
+export type PinataPinJobsResponseRow = {
+    id: number | string;
+    ipfs_pin_hash: string;
+    date_queued: string;
+    name: string | undefined | null;
+    status: string;
+};
+export type PinataPinJobsResponse = {
+    count: number;
+    rows: PinataPinJobsResponseRow[];
+};
+export type PinataPinListResponseRow = {
+    id: number | string;
+    ipfs_pin_hash: string;
+    size: number;
+    user_id: string | number;
+    date_pinned: string;
+    date_unpinned: string;
+    metadata: PinataMetadata;
+};
+export type PinataPinListResponse = {
+    count: number;
+    rows: PinataPinListResponseRow[];
+};
+/**
+ * Hash meta data
+ */
+export type hashMetadata = (ipfsPinHash: string, metadata: PinataMetadata) => Promise<any>;
+/**
+ * Hash pin policy
+ */
+export type hashPinPolicy = (ipfsPinHash: string, newPinPolicy: {
+    regions: PinataPinPolicyItem[];
+}) => Promise<any>;
+/**
+ * Pin by hash
+ */
+export type pinByHash = (hashToPin: string, options?: PinataPinByHashPinOptions | undefined) => Promise<PinataPinByHashResponse>;
+/**
+ * Pin file to IPFS
+ */
+export type pinFileToIPFS = (readableStream: any, options?: PinataPinOptions | undefined) => Promise<PinataPinResponse>;
+/**
+ * Pin from FS
+ */
+export type pinFromFS = (sourcePath: string, options?: PinataPinOptions | undefined) => Promise<PinataPinResponse>;
+/**
+ * Pin Jobs
+ */
+export type pinJobs = (filters?: PinataPinJobsFilterOptions | undefined) => Promise<PinataPinJobsResponse>;
+/**
+ * Pin JSON to IPFS
+ */
+export type pinJSONToIPFS = (body: Object, options?: PinataPinOptions | undefined) => Promise<PinataPinResponse>;
+/**
+ * Unpin
+ */
+export type unpin = (hashToUnpin: string) => Promise<any>;
+/**
+ * User Pin Policy
+ */
+export type userPinPolicy = (newPinPolicy: {
+    regions: PinataPinPolicyItem[];
+}) => Promise<any>;
+/**
+ * Test Authentication
+ */
+export type testAuthentication = () => Promise<{
+    authenticated: boolean;
+}>;
+/**
+ * Pin List
+ */
+export type pinList = (filters?: PinataPinListFilterOptions | undefined) => Promise<PinataPinListResponse>;
+/**
+ * User Pinned Data Total
+ */
+export type userPinnedDataTotal = () => Promise<number>;
+export type PinataClient = {
+    pinByHash: pinByHash;
+    hashMetadata: hashMetadata;
+    hashPinPolicy: hashPinPolicy;
+    pinFileToIPFS: pinFileToIPFS;
+    pinFromFS: pinFromFS;
+    pinJSONToIPFS: pinJSONToIPFS;
+    pinJobs: pinJobs;
+    unpin: unpin;
+    userPinPolicy: userPinPolicy;
+    testAuthentication: testAuthentication;
+    pinList: pinList;
+    userPinnedDataTotal: userPinnedDataTotal;
+};
+import pinByHash from "./commands/pinning/pinByHash";
+import hashMetadata from "./commands/pinning/hashMetadata";
+import hashPinPolicy from "./commands/pinning/hashPinPolicy";
+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 userPinPolicy from "./commands/pinning/userPinPolicy";
+import testAuthentication from "./commands/data/testAuthentication";
+import pinList from "./commands/data/pinList/pinList";
+import userPinnedDataTotal from "./commands/data/userPinnedDataTotal";

package/types/util/errorResponse.d.ts

@@ -0,0 +1 @@
+export function handleError(error: any): any;

package/types/util/validators.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Validate API Keys
+ * @param {string} pinataApiKey
+ * @param {string} pinataSecretApiKey
+ */
+export function validateApiKeys(pinataApiKey: string, pinataSecretApiKey: string): void;
+/**
+ * Validate host Nodes
+ * @param {*} hostNodes
+ */
+export function validateHostNodes(hostNodes: any): void;
+/**
+ * Validate MetaData
+ * @param {*} metadata
+ */
+export function validateMetadata(metadata: any): void;
+/**
+ * Validate Pin Policy Structure
+ * @param {*} pinPolicy
+ */
+export function validatePinPolicyStructure(pinPolicy: any): void;
+/**
+ * Validate Pinata Options
+ * @param {*} options
+ */
+export function validatePinataOptions(options: any): void;