@pinata/sdk 1.2.0 → 2.0.0-beta.0

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(pinataApiKey: string, pinataSecretApiKey: string, 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(pinataApiKey: string, pinataSecretApiKey: string, 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(pinataApiKey: string, pinataSecretApiKey: string, hashToUnpin: string): Promise<unknown>;
+import { PinataConfig } from '../..';
+export default function unpin(config: PinataConfig, hashToUnpin: string): Promise<unknown>;

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

@@ -5,4 +5,4 @@
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function userPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, newPinPolicy: any): Promise<unknown>;
+export default function userPinPolicy(config: any, newPinPolicy: any): Promise<unknown>;

package/types/constants.d.ts

@@ -1 +1,2 @@
-export const baseUrl: "https://api.pinata.cloud";
+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,331 +1,38 @@
-/**
- * @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>}
- */
-/**
- * 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>}
- */
-/**
- * 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 {pinFileToIPFS} pinFileToIPFS
- * @property {pinFromFS} pinFromFS
- * @property {pinJSONToIPFS} pinJSONToIPFS
- * @property {pinJobs} pinJobs
- * @property {unpin} unpin
- * @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>;
-/**
- * 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 PinataClient = {
-    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";
+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;
+    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,26 +1,43 @@
-/**
- * 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;
+import { PinataConfig } from '..';
+export declare function validateApiKeys(pinataApiKey?: string, pinataSecretApiKey?: string): void;
+export declare function createConfigForAxiosHeaders(config: PinataConfig): {
+    withCredentials: boolean;
+    headers: {
+        pinata_api_key: string;
+        pinata_secret_api_key: string;
+        Authorization?: undefined;
+    };
+} | {
+    headers: {
+        Authorization: string;
+        pinata_api_key?: undefined;
+        pinata_secret_api_key?: undefined;
+    };
+    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 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,41 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from './../../../constants';
-import { validateApiKeys } 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(pinataApiKey, pinataSecretApiKey, filters = {}) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
-    filters = {...filters, ...{includeCount: 'false' }};
-
-    const baseEndpoint = `${baseUrl}/data/pinList`;
-    const endpoint = queryBuilder(baseEndpoint, filters);
-
-    return new Promise((resolve, reject) => {
-        axios.get(
-            endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).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);
-        });
-    });
-}