@pinata/sdk 2.1.0 → 3.0.1

package/src/commands/pinning/pinFileToIPFS.ts

@@ -1,118 +0,0 @@
-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 { handleError } from '../../util/errorResponse';
-import { PinataConfig, PinataMetadata } from '../..';
-
-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?: PinataMetadata;
-    pinataOptions?: PinataOptions | undefined;
-}
-const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
-
-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();
-
-        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'
-            );
-        }
-
-        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')
-            );
-        }
-
-        resolve(uploadToIPFS(config, data, options));
-    });
-}

package/src/commands/pinning/pinFromFS.ts

@@ -1,60 +0,0 @@
-
-import NodeFormData from 'form-data';
-
-import { PinataConfig } from '../..';
-import {
-    PinataPinOptions,
-    PinataPinResponse,
-    uploadToIPFS
-} from './pinFileToIPFS';
-import fs from 'fs';
-
-import path from 'path';
-
-export function normalizePath(p: string) {
-    const splitPath = path.normalize(p).split(path.sep).filter(file => file.length > 0 && file !== '..');
-    let folderFile = splitPath;
-    if (splitPath.length > 1) {
-        folderFile = splitPath.slice(splitPath.length - 2);
-    }
-
-    return path.join.apply(null, folderFile);
-}
-
-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) => {
-
-                const filepath = path.join(sourcePath, file);
-                //for each file stream, we need to include the correct relative file path
-                data.append('file', fs.createReadStream(filepath), {
-                    filepath: normalizePath(filepath)
-                });
-            });
-
-            return uploadToIPFS(config, data, options);
-
-    } catch (err) {
-        console.log(err);
-        throw err;
-    }
-
-}

package/src/commands/pinning/pinJSONToIPFS.ts

@@ -1,47 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import { createConfigForAxiosHeaders, validateMetadata, validatePinataOptions } from '../../util/validators';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
-
-export default function pinJSONToIPFS(config: PinataConfig, body: any, options? : PinataPinOptions):Promise<PinataPinResponse> {
-
-    let requestBody: any = body;
-
-    if (typeof body !== 'object') {
-        throw new Error('body must be a valid JSON object');
-    }
-
-    if (options) {
-        requestBody = {
-            pinataContent: body
-        };
-        if (options.pinataMetadata) {
-            validateMetadata(options.pinataMetadata);
-            requestBody.pinataMetadata = options.pinataMetadata;
-        }
-        if (options.pinataOptions) {
-            validatePinataOptions(options.pinataOptions);
-            requestBody.pinataOptions = options.pinataOptions;
-        }
-    }
-
-    const endpoint = `${baseUrl}/pinning/pinJSONToIPFS`;
-
-    return new Promise((resolve, reject) => {
-        axios.post(
-            endpoint,
-            requestBody,
-            {...createConfigForAxiosHeaders(config)})
-        .then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while pinning JSON to IPFS: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

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

@@ -1,50 +0,0 @@
-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.ts

@@ -1,75 +0,0 @@
-import isIPFS from 'is-ipfs';
-
-export default function queryBuilder(baseUrl: string, filters?: any): string {
-    if (!baseUrl) {
-        throw new Error('no baseUrl provided');
-    }
-
-    if (!filters) {
-        return baseUrl;
-    }
-
-    let newUrl = baseUrl;
-
-    let firstFilterApplied = false; // we want to make sure that the "?" character is only applied once
-
-    function addFilter(newFilter: string) {
-        if (firstFilterApplied) {
-            newUrl = `${newUrl}&${newFilter}`;
-        } else {
-            firstFilterApplied = true;
-            newUrl = `${newUrl}?${newFilter}`;
-        }
-    }
-
-    if (filters) {
-        //  now we need to construct the actual URL based on the given filters provided
-        if (filters.sort) {
-            if (filters.sort === 'ASC' ||
-                filters.sort === 'DESC') {
-                addFilter(`sort=${filters.sort}`);
-            } else {
-                throw new Error(`Unknown sort value: ${filters.sort} provided`);
-            }
-        }
-
-        if (filters.status) {
-            if (filters.status === 'searching' ||
-                filters.status === 'expired' ||
-                filters.status === 'over_free_limit' ||
-                filters.status === 'over_max_size' ||
-                filters.status === 'invalid_object' ||
-                filters.status === 'bad_host_node'
-            ) {
-                addFilter(`status=${filters.status}`);
-            } else {
-                throw new Error(`Unknown status value: ${filters.status} provided`);
-            }
-        }
-
-        if (filters.ipfs_pin_hash) {
-            if (isIPFS.cid(filters.ipfs_pin_hash)) {
-                addFilter(`ipfs_pin_hash=${filters.ipfs_pin_hash}`);
-            } else {
-                throw new Error(`Invalid IPFS hash: ${filters.ipfs_pin_hash}`);
-            }
-        }
-
-        if (filters.limit) {
-            if (Number.isInteger(filters.limit) && (filters.limit > 0) && (filters.limit < 100)) {
-                addFilter(`limit=${filters.limit}`);
-            } else {
-                throw new Error(`Invalid limit: ${filters.limit}. Valid limits are 1-100`);
-            }
-        }
-
-        if (filters.offset) {
-            if (Number.isInteger(filters.offset) && (filters.offset > 0)) {
-                addFilter(`offset=${filters.offset}`);
-            } else {
-                throw new Error(`Invalid offset: ${filters.offset}. Please provide a positive integer for the offset`);
-            }
-        }
-    }
-    return newUrl;
-}

package/src/commands/pinning/unpin.ts

@@ -1,32 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import { createConfigForAxiosHeaders } from '../../util/validators';
-import isIPFS from 'is-ipfs';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-
-export default function unpin(config: PinataConfig, hashToUnpin: string) {
-    if (!hashToUnpin) {
-        throw new Error('hashToUnpin value is required for removing a pin from Pinata');
-    }
-    if (!isIPFS.cid(hashToUnpin)) {
-        throw new Error(`${hashToUnpin} is an invalid IPFS CID`);
-    }
-
-    const endpoint = `${baseUrl}/pinning/unpin/${hashToUnpin}`;
-
-    return new Promise((resolve, reject) => {
-        axios.delete(
-            endpoint,
-            {...createConfigForAxiosHeaders(config)})
-        .then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while removing pin from IPFS: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/constants.ts

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

@@ -1,124 +0,0 @@
-import './require-babel-polyfill';
-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);
-    }
-}
-
-module.exports = PinataClient;
-
-export * from './commands/data';
-export * from './commands/pinning';
-
-export default PinataClient;
-

package/src/require-babel-polyfill.ts

@@ -1,5 +0,0 @@
-export default (() => {
-    if (!global || !global._babelPolyfill) {
-        require('babel-polyfill');
-    }
-})();

package/src/third-party/base-path-converter.d.ts

@@ -1,3 +0,0 @@
-declare module 'base-path-converter' {
-    export default function(sourcePath: string, filePath: string): string;
-}

package/src/third-party/global.d.ts

@@ -1,9 +0,0 @@
-export {};
-
-declare global {
-    namespace NodeJS {
-      interface Global {
-        _babelPolyfill: any;
-      }
-    }
-  }

package/src/third-party/is-ipfs.d.ts

@@ -1,5 +0,0 @@
-declare module 'is-ipfs' {
-    export function cid (cid: string): boolean
-    export function isPeerMultiaddr(addr: string): boolean;
-    export function peerMultiaddr(addr: string): boolean;
-}

package/src/util/errorResponse.ts

@@ -1,10 +0,0 @@
-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) {
-    return error.data.error;
-  } else if (error.response && error.response.error) {
-    return error.response.error;
-  }
-  return error;
-};