@pinata/sdk 2.0.0-beta.0 → 2.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pinata/sdk",
-    "version": "2.0.0-beta.0",
+    "version": "2.0.0-beta.2",
     "description": "Official SDK for the Pinata IPFS platform",
     "main": "lib/pinata-sdk.js",
     "types": "types/index.d.ts",
@@ -67,7 +67,7 @@
         "base-path-converter": "^1.0.2",
         "form-data": "^2.3.3",
         "is-ipfs": "^0.6.0",
-        "recursive-fs": "^1.1.2"
+        "path": "^0.12.7"
     },
     "jest": {
         "collectCoverage": true,

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

@@ -14,7 +14,7 @@ export interface PinataMetadata { [key: string]: string | number | null }
 export interface PinataMetadataFilter {
     name?: string | undefined;
     keyvalues: { [key: string]: {
-        value: string;
+        value: string | number | null;
         op: string;
     } }
 }

package/src/commands/pinning/pinFileToIPFS.ts

@@ -2,9 +2,13 @@ import axios from 'axios';
 import { baseUrl } from '../../constants';
 import NodeFormData from 'form-data';
 import stream from 'stream';
-import {createConfigForAxiosHeadersWithFormData, validateMetadata, validatePinataOptions} from '../../util/validators';
+import {
+    createConfigForAxiosHeadersWithFormData,
+    validateMetadata,
+    validatePinataOptions
+} from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
+import { PinataConfig, PinataMetadata } from '../..';
 
 export interface PinataPinPolicyItem {
     id: string;
@@ -12,7 +16,7 @@ export interface PinataPinPolicyItem {
 }
 export interface PinataOptions {
     hostNodes?: string[] | undefined;
-    cidVersion?: 0 | 1 ;
+    cidVersion?: 0 | 1;
     wrapWithDirectory?: boolean;
     customPinPolicy?: {
         regions: PinataPinPolicyItem[];
@@ -25,45 +29,90 @@ export interface PinataPinResponse {
     Timestamp: string;
 }
 export interface PinataPinOptions {
-    pinataMetadata?: { [key: string]: string | number | null },
+    pinataMetadata?: PinataMetadata;
     pinataOptions?: PinataOptions | undefined;
 }
+const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
 
-export default function pinFileToIPFS(config: PinataConfig, readStream: any, options?: PinataPinOptions):Promise<PinataPinResponse> {
+export function uploadToIPFS(
+    config: PinataConfig,
+    data: NodeFormData,
+    options?: PinataPinOptions
+): Promise<PinataPinResponse> {
     return new Promise((resolve, reject) => {
+        if (options && options.pinataMetadata) {
+            validateMetadata(options.pinataMetadata);
+            data.append(
+                'pinataMetadata',
+                JSON.stringify(options.pinataMetadata)
+            );
+        }
+        if (options && options.pinataOptions) {
+            validatePinataOptions(options.pinataOptions);
+            data.append('pinataOptions', JSON.stringify(options.pinataOptions));
+        }
+
+        axios
+            .post(
+                endpoint,
+                data,
+                createConfigForAxiosHeadersWithFormData(
+                    config,
+                    data.getBoundary()
+                )
+            )
+            .then(function (result) {
+                if (result.status !== 200) {
+                    reject(
+                        new Error(
+                            `unknown server response while pinning File to IPFS: ${result}`
+                        )
+                    );
+                }
+                resolve(result.data);
+            })
+            .catch(function (error) {
+                const formattedError = handleError(error);
+                reject(formattedError);
+            });
+    });
+}
 
+export default function pinFileToIPFS(
+    config: PinataConfig,
+    readStream: any,
+    options?: PinataPinOptions
+): Promise<PinataPinResponse> {
+    return new Promise((resolve, reject) => {
         const data = new NodeFormData();
 
-        data.append('file', readStream);
+        if (
+            !(
+                options?.pinataMetadata?.name &&
+                typeof options.pinataMetadata.name === 'string' &&
+                options.pinataMetadata.name.length > 0
+            )
+        ) {
+            throw Error(
+                'filename was not provide, make sure to provide options.pinataMetadata.name'
+            );
+        }
 
-        const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
+        data.append('file', readStream, {
+            filename: options.pinataMetadata.name
+        });
 
-        if (!(readStream instanceof stream.Readable || readStream instanceof NodeFormData)) {
-            reject(new Error('readStream is not a readable stream or form data'));
+        if (
+            !(
+                readStream instanceof stream.Readable ||
+                readStream instanceof NodeFormData
+            )
+        ) {
+            reject(
+                new Error('readStream is not a readable stream or form data')
+            );
         }
 
-        if (options) {
-            if (options.pinataMetadata) {
-                validateMetadata(options.pinataMetadata);
-                data.append('pinataMetadata', JSON.stringify(options.pinataMetadata));
-            }
-            if (options.pinataOptions) {
-                validatePinataOptions(options.pinataOptions);
-                data.append('pinataOptions', JSON.stringify(options.pinataOptions));
-            }
-        }
-           axios.post(
-            endpoint,
-            readStream instanceof NodeFormData ? readStream : data,
-            createConfigForAxiosHeadersWithFormData(config, data.getBoundary())
-        ).then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
+        resolve(uploadToIPFS(config, data, options));
     });
 }

package/src/commands/pinning/pinFromFS.ts

@@ -1,95 +1,50 @@
-import axios from 'axios';
-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';
 import { PinataConfig } from '../..';
-import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
-import * as fs from 'fs';
-import * as recursive from 'recursive-fs';
-
-export default function pinFromFS(config: PinataConfig, sourcePath: string, options?: PinataPinOptions): Promise<PinataPinResponse> {
-
-    return new Promise((resolve, reject) => {
-        const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
-
-        // eslint-disable-next-line consistent-return
-        fs.stat(sourcePath, (err: any, stats: any) => {
-            if (err) {
-                return reject(err);
-            }
-            if (stats.isFile()) {
-                //we need to create a single read stream instead of reading the directory recursively
-                const data = new NodeFormData();
-
-                data.append('file', fs.createReadStream(sourcePath));
-
-                if (options) {
-                    if (options.pinataMetadata) {
-                        validateMetadata(options.pinataMetadata);
-                        data.append('pinataMetadata', JSON.stringify(options.pinataMetadata));
-                    }
-                    if (options.pinataOptions) {
-                        validatePinataOptions(options.pinataOptions);
-                        data.append('pinataOptions', JSON.stringify(options.pinataOptions));
-                    }
-                }
-
-                axios.post(
-                    endpoint,
-                    data,
-                    createConfigForAxiosHeadersWithFormData(config, data.getBoundary()))
-                .then(function (result) {
-                    if (result.status !== 200) {
-                        reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
-                    }
-                    resolve(result.data);
-                }).catch(function (error) {
-                    const formattedError = handleError(error);
-                    reject(formattedError);
+import {
+    PinataPinOptions,
+    PinataPinResponse,
+    uploadToIPFS
+} from './pinFileToIPFS';
+import fs from 'fs';
+
+import path from 'path';
+
+export default async function pinFromFS(
+    config: PinataConfig,
+    sourcePath: string,
+    options?: PinataPinOptions
+): Promise<PinataPinResponse> {
+    try {
+        const stats = await fs.promises.stat(sourcePath);
+        if (stats.isFile()) {
+
+            const stream = fs.createReadStream(sourcePath);
+            const data = new NodeFormData();
+
+            data.append('file', stream, {
+                filename: path.basename(sourcePath)
+            });
+
+            return uploadToIPFS(config, data, options);
+        }
+            const files = await fs.promises.readdir(sourcePath);
+            const data = new NodeFormData();
+
+            files.forEach((file: string) => {
+                //for each file stream, we need to include the correct relative file path
+                data.append('file', fs.createReadStream(file), {
+                    filepath: basePathConverter(sourcePath, file)
                 });
-            } else {
-                recursive.readdirr(sourcePath, function (err: any, dirs: any, files: any) {
-                    if (err) {
-                        reject(new Error(err));
-                    }
+            });
 
-                    const data = new NodeFormData();
+            return uploadToIPFS(config, data, options);
 
-                    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)
-                        });
-                    });
+    } catch (err) {
+        console.log(err);
+        throw err;
+    }
 
-                    if (options) {
-                        if (options.pinataMetadata) {
-                            validateMetadata(options.pinataMetadata);
-                            data.append('pinataMetadata', JSON.stringify(options.pinataMetadata));
-                        }
-                        if (options.pinataOptions) {
-                            validatePinataOptions(options.pinataOptions);
-                            data.append('pinataOptions', JSON.stringify(options.pinataOptions));
-                        }
-                    }
-
-                    axios.post(
-                        endpoint,
-                        data,
-                        createConfigForAxiosHeadersWithFormData(config, data.getBoundary()))
-                    .then(function (result) {
-                        if (result.status !== 200) {
-                            reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
-                        }
-                        resolve(result.data);
-                    }).catch(function (error) {
-                        const formattedError = handleError(error);
-                        reject(formattedError);
-                    });
-                });
-            }
-        });
-    });
 }

package/src/util/validators.ts

@@ -2,6 +2,15 @@ import isIPFS from 'is-ipfs';
 import { PinataConfig } from '..';
 import { ERROR_NO_CREDENTIALS_PROVIDED} from '../constants';
 
+export interface axiosHeaders
+    { maxContentLength: number;
+        maxBodyLength: number;
+        headers: {
+            [key: string]: any
+        };
+        withCredentials?: boolean;
+    }
+
 export function validateApiKeys(pinataApiKey?: string, pinataSecretApiKey?: string) {
     if (!pinataApiKey || pinataApiKey === '') {
         throw new Error(
@@ -41,15 +50,13 @@ export function createConfigForAxiosHeaders(config: PinataConfig) {
 }
 
 export function createConfigForAxiosHeadersWithFormData(config: PinataConfig, boundaryValue: string) {
-    const requestOptions = {
+    const requestOptions: axiosHeaders = {
         ...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}`
-        }
+        maxBodyLength: Infinity
     };
 
+    requestOptions.headers['Content-type'] = `multipart/form-data; boundary=${boundaryValue}`;
     return requestOptions;
 }
 

package/test/commands/pinning/pinFileToIPFS.test.ts

@@ -23,7 +23,7 @@ test('200 status is returned with valid stream', () => {
     };
     (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
 });
 
 test('200 status is returned with valid form data', () => {
@@ -33,7 +33,7 @@ test('200 status is returned with valid form data', () => {
     };
     (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
@@ -42,12 +42,12 @@ test('Result other than 200 status is returned', () => {
     };
     (axios.post as jest.Mock).mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
     (axios.post as jest.Mock).mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual('test error');
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual('test error');
 });
 

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

@@ -11,7 +11,7 @@ export interface PinataMetadataFilter {
     name?: string | undefined;
     keyvalues: {
         [key: string]: {
-            value: string;
+            value: string | number | null;
             op: string;
         };
     };

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

@@ -1,4 +1,5 @@
-import { PinataConfig } from '../..';
+import NodeFormData from "form-data";
+import { PinataConfig, PinataMetadata } from "../..";
 export interface PinataPinPolicyItem {
     id: string;
     desiredReplicationCount: number;
@@ -17,17 +18,8 @@ export interface PinataPinResponse {
     Timestamp: string;
 }
 export interface PinataPinOptions {
-    pinataMetadata?: {
-        [key: string]: string | number | null;
-    };
+    pinataMetadata?: PinataMetadata;
     pinataOptions?: PinataOptions | undefined;
 }
-/**
- * Pin File to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} readStream
- * @param {*} options
- * @returns {Promise<unknown>}
- */
+export declare function uploadToIPFS(config: PinataConfig, data: NodeFormData, options?: PinataPinOptions): Promise<PinataPinResponse>;
 export default function pinFileToIPFS(config: PinataConfig, readStream: any, options?: PinataPinOptions): Promise<PinataPinResponse>;

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

@@ -1,3 +1,3 @@
-import { PinataConfig } from '../..';
-import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
+import { PinataConfig } from "../..";
+import { PinataPinOptions, PinataPinResponse } from "./pinFileToIPFS";
 export default function pinFromFS(config: PinataConfig, sourcePath: string, options?: PinataPinOptions): Promise<PinataPinResponse>;

package/types/util/validators.d.ts

@@ -1,4 +1,12 @@
 import { PinataConfig } from '..';
+export interface axiosHeaders {
+    maxContentLength: number;
+    maxBodyLength: number;
+    headers: {
+        [key: string]: any;
+    };
+    withCredentials?: boolean;
+}
 export declare function validateApiKeys(pinataApiKey?: string, pinataSecretApiKey?: string): void;
 export declare function createConfigForAxiosHeaders(config: PinataConfig): {
     withCredentials: boolean;
@@ -15,21 +23,7 @@ export declare function createConfigForAxiosHeaders(config: PinataConfig): {
     };
     withCredentials?: undefined;
 };
-export declare function createConfigForAxiosHeadersWithFormData(config: PinataConfig, boundaryValue: string): {
-    maxContentLength: number;
-    maxBodyLength: number;
-    headers: {
-        'Content-type': string;
-    };
-    withCredentials: boolean;
-} | {
-    maxContentLength: number;
-    maxBodyLength: number;
-    headers: {
-        'Content-type': string;
-    };
-    withCredentials?: undefined;
-};
+export declare function createConfigForAxiosHeadersWithFormData(config: PinataConfig, boundaryValue: string): axiosHeaders;
 export declare function validateHostNodes(hostNodes: any): void;
 export declare function validateMetadata(metadata: any): void;
 export declare function validatePinPolicyStructure(pinPolicy: {

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

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