@pinata/sdk 1.2.1 → 2.0.0-beta.2

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

@@ -1,9 +1,25 @@
-/**
- * Pin File to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} readStream
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFileToIPFS(config: any, readStream: any, options: any): Promise<unknown>;
+import NodeFormData from "form-data";
+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;
+}
+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,9 +1,3 @@
-/**
- * PinFromFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {string} sourcePath
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFromFS(config: any, sourcePath: string, options: any): Promise<unknown>;
+import { PinataConfig } from "../..";
+import { PinataPinOptions, PinataPinResponse } from "./pinFileToIPFS";
+export default function pinFromFS(config: PinataConfig, sourcePath: string, options?: PinataPinOptions): Promise<PinataPinResponse>;

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

@@ -1,9 +1,3 @@
-/**
- * Pin JSON to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} body
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinJSONToIPFS(config: any, body: any, options: any): Promise<unknown>;
+import { PinataConfig } from '../..';
+import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
+export default function pinJSONToIPFS(config: PinataConfig, body: any, options?: PinataPinOptions): Promise<PinataPinResponse>;

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

@@ -1,8 +1,20 @@
-/**
- * Pin Jobs
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} filters
- * @returns {Promise<unknown>}
- */
-export default function pinJobs(config: any, filters: any): Promise<unknown>;
+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>;

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

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

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

@@ -1,8 +1,2 @@
-/**
- * Unpin
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {string} hashToUnpin
- * @returns {Promise<unknown>}
- */
-export default function unpin(config: any, hashToUnpin: string): Promise<unknown>;
+import { PinataConfig } from '../..';
+export default function unpin(config: PinataConfig, hashToUnpin: string): Promise<unknown>;

package/types/constants.d.ts

@@ -1,2 +1,2 @@
-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";
+export declare const baseUrl = "https://api.pinata.cloud";
+export declare 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/types/index.d.ts

@@ -1,166 +1,38 @@
-/**
- * Pinata Client
- *
- * @param {string | PinataConfig} [pinataApiKey]
- * @param {string} [pinataSecretApiKey]
- * @returns {PinataClient}
- */
-export default function pinataClient(pinataApiKey?: string | PinataConfig | undefined, pinataSecretApiKey?: string | undefined): 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>;
-/**
- * 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>;
-/**
- * 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 PinataConfig = {
-    pinataApiKey?: string | undefined;
-    pinataSecretApiKey?: string | undefined;
-    pinataJWTKey?: string | undefined;
-};
-export type PinataClient = {
+import { PinataPinByHashPinOptions } from './commands/pinning/pinByHash';
+import { PinataPinOptions } from './commands/pinning/pinFileToIPFS';
+import { PinataPinJobsFilterOptions } from './commands/pinning/pinJobs/pinJobs';
+import { PinataMetadata, PinataPinListFilterOptions } from './commands/data/pinList/pinList';
+export interface PinataConfig {
+    pinataApiKey?: string;
+    pinataSecretApiKey?: string;
+    pinataJWTKey?: string;
+}
+declare class PinataClient {
     config: PinataConfig;
-    pinByHash: pinByHash;
-    hashMetadata: hashMetadata;
-    pinFileToIPFS: pinFileToIPFS;
-    pinFromFS: pinFromFS;
-    pinJSONToIPFS: pinJSONToIPFS;
-    pinJobs: pinJobs;
-    unpin: unpin;
-    testAuthentication: testAuthentication;
-    pinList: pinList;
-    userPinnedDataTotal: userPinnedDataTotal;
-};
-import pinByHash from "./commands/pinning/pinByHash";
-import hashMetadata from "./commands/pinning/hashMetadata";
-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 testAuthentication from "./commands/data/testAuthentication";
-import pinList from "./commands/data/pinList/pinList";
-import userPinnedDataTotal from "./commands/data/userPinnedDataTotal";
+    constructor(pinataApiKey?: string | PinataConfig, pinataSecretApiKey?: string);
+    pinByHash(hashToPin: string, options?: PinataPinByHashPinOptions): Promise<any>;
+    hashMetadata(ipfsPinHash: string, metadata: PinataMetadata): Promise<any>;
+    pinFileToIPFS(readableStream: any, options?: PinataPinOptions): Promise<import("./commands/pinning").PinataPinResponse>;
+    pinFromFS(sourcePath: string, options?: PinataPinOptions): Promise<import("./commands/pinning").PinataPinResponse>;
+    pinJSONToIPFS(body: any, options?: PinataPinOptions): Promise<import("./commands/pinning").PinataPinResponse>;
+    pinJobs(filters?: PinataPinJobsFilterOptions): Promise<import("./commands/pinning").PinataPinJobsResponse>;
+    unpin(hashToUnpin: string): Promise<unknown>;
+    pinList(filters: PinataPinListFilterOptions): Promise<import("./commands/data").PinataPinListResponse>;
+    getFilesByCount(filters: PinataPinListFilterOptions, maxCount?: number): {
+        [Symbol.asyncIterator]: () => {
+            next(): Promise<{
+                value: import("./commands/data").PinataPin;
+                done: boolean;
+            }>;
+            return(): Promise<{
+                value: number;
+                done: boolean;
+            }>;
+        };
+    };
+    testAuthentication(): Promise<import("./commands/data").PinataTestAuthenticationResponse>;
+    userPinnedDataTotal(): Promise<number>;
+}
+export * from './commands/data';
+export * from './commands/pinning';
+export default PinataClient;

package/types/util/errorResponse.d.ts

@@ -1 +1 @@
-export function handleError(error: any): any;
+export declare const handleError: (error: any) => any;

package/types/util/validators.d.ts

@@ -1,36 +1,21 @@
-/**
- * Validate API Keys
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- */
-export function validateApiKeys(pinataApiKey: string, pinataSecretApiKey: string): void;
-export function createConfigForAxiosHeaders(config: any): {
-    withCredentials: boolean;
-    headers: {
-        pinata_api_key: any;
-        pinata_secret_api_key: any;
-        Authorization?: undefined;
-    };
-} | {
-    headers: {
-        Authorization: string;
-        pinata_api_key?: undefined;
-        pinata_secret_api_key?: undefined;
-    };
-    withCredentials?: undefined;
-};
-export function createConfigForAxiosHeadersWithFormData(config: any, boundaryValue: any): {
+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;
     headers: {
-        pinata_api_key: any;
-        pinata_secret_api_key: any;
+        pinata_api_key: string;
+        pinata_secret_api_key: string;
         Authorization?: undefined;
     };
 } | {
-    maxContentLength: number;
-    maxBodyLength: number;
     headers: {
         Authorization: string;
         pinata_api_key?: undefined;
@@ -38,23 +23,15 @@ export function createConfigForAxiosHeadersWithFormData(config: any, boundaryVal
     };
     withCredentials?: undefined;
 };
-/**
- * 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;
+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: {
+    regions: any[];
+}): void;
+export declare function validatePinataOptions(options: {
+    cidVersion?: number;
+    wrapWithDirectory?: boolean;
+    hostNodes?: any;
+    customPinPolicy?: any;
+}): void;

package/webpack.config.js

@@ -1,61 +1,58 @@
-/* global __dirname, require, module*/
-
 const webpack = require('webpack');
 const path = require('path');
-const env = require('yargs').argv.env; // use --env with webpack 2
-const pkg = require('./package.json');
 
-let libraryName = 'pinata-sdk';
+const libraryName = 'pinata-sdk';
 
-let outputFile, mode;
+module.exports = (env) => {
+    let outputFile, mode;
 
-if (env === 'build') {
-    mode = 'production';
-    outputFile = libraryName + '.min.js';
-} else {
-    mode = 'development';
-    outputFile = libraryName + '.js';
-}
+    if (env === 'build') {
+        mode = 'production';
 
-const config = {
-    mode: mode,
-    entry: ['babel-polyfill', __dirname + '/src/index.js'],
-    devtool: 'inline-source-map',
-    output: {
-        path: __dirname + '/lib',
-        filename: outputFile,
-        library: libraryName,
-        libraryTarget: 'umd',
-        umdNamedDefine: true,
-        globalObject: 'typeof self !== \'undefined\' ? self : this'
-    },
-    module: {
-        rules: [
-            {
-                test: /(\.jsx|\.js)$/,
-                loader: 'babel-loader',
-                exclude: /(node_modules|bower_components)/
-            },
-            {
-                test: /(\.jsx|\.js)$/,
-                loader: 'eslint-loader',
-                exclude: /node_modules/
-            }
-        ]
-    },
-    target: 'node',
-    node: {
-      process: false
-    },
-    plugins: [
-        new webpack.DefinePlugin({
-            'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV)
-        })
-    ],
-    resolve: {
-        modules: [path.resolve('./node_modules'), path.resolve('./src')],
-        extensions: ['.json', '.js']
+        outputFile = libraryName + '.min.js';
+    } else {
+        mode = 'development';
+        outputFile = libraryName + '.js';
     }
+    return {
+        mode: mode,
+        entry: ['babel-polyfill', __dirname + '/src/index.ts'],
+        devtool: 'inline-source-map',
+        output: {
+            path: __dirname + '/lib',
+            filename: outputFile,
+            library: libraryName,
+            libraryTarget: 'umd',
+            umdNamedDefine: true,
+            globalObject: "typeof self !== 'undefined' ? self : this"
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.ts?$/,
+                    loader: 'babel-loader',
+                    exclude: /(node_modules|bower_components)/
+             },
+                // {
+                //     test: /\.ts?$/,
+                //     loader: 'eslint-loader',
+                //     exclude: /node_modules/,
+                      
+                // }
+            ]
+        },
+        target: 'node',
+        node: {
+            process: false
+        },
+        plugins: [
+            new webpack.DefinePlugin({
+                'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV)
+            })
+        ],
+        resolve: {
+            modules: [path.resolve('./node_modules'), path.resolve('./src')],
+            extensions: ['.json', '.js', '.ts']
+        }
+    };
 };
-
-module.exports = config;

package/src/commands/data/pinList/pinList.js

@@ -1,34 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../../constants';
-import { createConfigForAxiosHeaders } from '../../../util/validators';
-import { handleError } from '../../../util/errorResponse';
-import queryBuilder from './queryBuilder';
-
-/**
- * Pin List
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {any} filters
- * @returns {Promise<unknown>}
- */
-export default function pinList(config, filters = {}) {
-    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/pinning/hashPinPolicy.js

@@ -1,51 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../constants';
-import { createConfigForAxiosHeaders, validatePinPolicyStructure } from '../../util/validators';
-import isIPFS from 'is-ipfs';
-import { handleError } from '../../util/errorResponse';
-
-/**
- * Hash Pin Policy
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} ipfsPinHash
- * @param {*} newPinPolicy
- * @returns {Promise<unknown>}
- */
-export default function hashPinPolicy(config, ipfsPinHash, newPinPolicy) {
-    validatePinPolicyStructure(newPinPolicy);
-
-    if (!ipfsPinHash) {
-        throw new Error('ipfsPinHash value is required for changing the pin policy of a pin');
-    }
-
-    if (!isIPFS.cid(ipfsPinHash)) {
-        throw new Error('ipfsPinHash value is an invalid IPFS CID');
-    }
-
-    if (!newPinPolicy) {
-        throw new Error('newPinPolicy is required for changing the pin policy of a pin');
-    }
-
-    const endpoint = `${baseUrl}/pinning/hashPinPolicy`;
-    const body = {
-        ipfsPinHash: ipfsPinHash,
-        newPinPolicy: newPinPolicy
-    };
-
-    return new Promise((resolve, reject) => {
-        axios.put(
-            endpoint,
-            body,
-            {...createConfigForAxiosHeaders(config)})
-            .then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while changing pin policy for hash: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/pinFileToIPFS.js

@@ -1,53 +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';
-
-/**
- * Pin File to IPFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} readStream
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFileToIPFS(config, readStream, options) {
-    return new Promise((resolve, reject) => {
-
-        const data = new NodeFormData();
-
-        data.append('file', readStream);
-
-        const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
-
-        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._boundary)
-        ).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);
-        });
-    });
-}