@pinata/sdk 2.1.0 → 3.0.1

package/src/commands/data/getFilesByCount/getFilesByCount.ts

@@ -1,66 +0,0 @@
-import { PinataConfig } from '../../..';
-import pinList, { PinataPin, PinataPinListFilterOptions } from '../pinList/pinList';
-
-export default function getFilesByCount(
-    config: PinataConfig,
-
-    filters: PinataPinListFilterOptions = {},
-    maxCount = -1
-) {
-    if (maxCount === 0) {
-        throw Error("Max count can't be 0");
-    }
-
-    const asyncIterable = {
-        [Symbol.asyncIterator]: () => {
-            let i = 0;
-            const pageLimit = 10;
-            let pageOffset = 0;
-            let cache: PinataPin[] = [];
-            let keepLooping = false;
-
-            return {
-                next() {
-                    return new Promise((resolve, reject) => {
-                        if (i === 0 || (i % pageLimit === 0 && keepLooping)) {
-                            resolve(
-                                pinList(config, {
-                                    ...filters,
-                                    ...{ pageOffset, pageLimit }
-                                }).then((resp) => {
-                                    cache = resp.rows;
-                                    pageOffset = pageOffset + cache.length;
-
-                                    // If the user requested all pins we have to keep looping if the limit page was not fulfill
-                                    keepLooping =
-                                        cache.length !== 0 &&
-                                        (maxCount === -1 ? cache.length === pageLimit : i < maxCount);
-                                })
-                            );
-                        }
-                        resolve(0);
-                    }).then(() => {
-                        const valueToReturn = cache[i % pageLimit];
-
-                        const done = !(
-                            (maxCount === -1 ? i < pageOffset : i < maxCount) &&
-                            keepLooping
-                        );
-
-                        i++;
-                        return Promise.resolve({
-                            value: valueToReturn,
-                            done
-                        });
-                    });
-                },
-                return() {
-                    // This will be reached if the consumer called 'break' or 'return' early in the loop.
-                    return Promise.resolve({ value: i, done: true });
-                }
-            };
-        }
-    };
-
-    return asyncIterable;
-}

package/src/commands/data/index.ts

@@ -1,4 +0,0 @@
-export * from '../data/pinList/pinList';
-export * from '../data/pinList/queryBuilder';
-export * from './testAuthentication';
-export * from './userPinnedDataTotal';

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

@@ -1,77 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../../constants';
-import { createConfigForAxiosHeaders } from '../../../util/validators';
-import { handleError } from '../../../util/errorResponse';
-import queryBuilder from './queryBuilder';
-import { PinataConfig } from '../../..';
-export interface PinataPinRegion {
-    regionId: string;
-    currentReplicationCount: number;
-    desiredReplicationCount: number;
-}
-
-export interface PinataMetadata { [key: string]: string | number | null }
-export interface PinataMetadataFilter {
-    name?: string | undefined;
-    keyvalues: { [key: string]: {
-        value: string | number | null;
-        op: string;
-    } }
-}
-export interface PinataPin {
-    id: string | number;
-    ipfs_pin_hash: string;
-    size: number;
-    user_id: string | number;
-    date_pinned: string;
-    date_unpinned: string | null;
-    metadata: PinataMetadata,
-    regions: PinataPinRegion[];
-}
-
-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 interface PinataPinListResponse {
-    rows: PinataPin[];
-}
-
-export default function pinList(
-    config: PinataConfig,
-    filters:PinataPinListFilterOptions = {}
-): Promise<PinataPinListResponse> {
-    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/data/pinList/queryBuilder.ts

@@ -1,239 +0,0 @@
-
-function validateAndReturnDate(dateToValidate: any): any {
-    const dateParsed = new Date(Date.parse(dateToValidate));
-
-    try {
-        if (dateParsed.toISOString() === dateToValidate) {
-            return dateToValidate;
-        }
-        throw new Error('dates must be in valid ISO_8601 format');
-
-    } catch (e) {
-        throw new Error('dates must be in valid ISO_8601 format');
-    }
-}
-
-export default function queryBuilder(baseUrl: string, filters?: any): string {
-    if (!baseUrl) {
-        throw new Error('no baseUrl provided');
-    }
-
-    //  preset filter values
-    let filterQuery = '?';
-
-    let metadataQuery = '';
-
-    if (filters) {
-        //  now we need to construct the actual URL based on the given filters provided
-        if (filters.includeCount) {
-            filterQuery = filterQuery + `includeCount=${filters.includeCount}&`;
-        }
-
-        if (filters.hashContains) {
-            if (typeof filters.hashContains !== 'string') {
-                throw new Error('hashContains value is not a string');
-            }
-            filterQuery = filterQuery + `hashContains=${filters.hashContains}&`;
-        }
-        if (filters.pinStart) {
-            filterQuery = filterQuery + `pinStart=${validateAndReturnDate(filters.pinStart)}&`;
-        }
-        if (filters.pinEnd) {
-            filterQuery = filterQuery + `pinEnd=${validateAndReturnDate(filters.pinEnd)}&`;
-        }
-        if (filters.unpinStart) {
-            filterQuery = filterQuery + `unpinStart=${validateAndReturnDate(filters.unpinStart)}&`;
-        }
-        if (filters.unpinEnd) {
-            filterQuery = filterQuery + `unpinEnd=${validateAndReturnDate(filters.unpinEnd)}&`;
-        }
-        if (filters.pinSizeMin) {
-            if (isNaN(filters.pinSizeMin) || filters.pinSizeMin < 0) {
-                throw new Error('Please make sure the pinSizeMin is a valid positive integer');
-            }
-            filterQuery = filterQuery + `pinSizeMin=${filters.pinSizeMin}&`;
-        }
-        if (filters.pinSizeMax) {
-            if (isNaN(filters.pinSizeMax) || filters.pinSizeMax < 0) {
-                throw new Error('Please make sure the pinSizeMax is a valid positive integer');
-            }
-            filterQuery = filterQuery + `pinSizeMax=${filters.pinSizeMax}&`;
-        }
-        if (filters.status) {
-            if (filters.status !== 'all' && filters.status !== 'pinned' && filters.status !== 'unpinned') {
-                throw new Error('status value must be either: all, pinned, or unpinned');
-            }
-            filterQuery = filterQuery + `status=${filters.status}&`;
-        }
-        if (filters.pageLimit) {
-            if (isNaN(filters.pageLimit) || filters.pageLimit <= 0 || filters.pageLimit > 1000) {
-                throw new Error('Please make sure the pageLimit is a valid integer between 1-1000');
-            }
-            filterQuery = filterQuery + `pageLimit=${parseInt(filters.pageLimit)}&`; // we want to make sure that decimals get rounded to integers
-        }
-
-        if (filters.pageOffset) {
-            if (isNaN(filters.pageOffset) || filters.pageOffset <= 0) {
-                throw new Error('Please make sure the pageOffset is a positive integer');
-            }
-            filterQuery = filterQuery + `pageOffset=${parseInt(filters.pageOffset)}&`; // we want to make sure that decimals get rounded to integers
-        }
-
-        if (filters.metadata) {
-
-            if (typeof filters.metadata !== 'object') {
-                throw new Error('metadata value must be an object');
-            }
-
-            if (filters.metadata.name) {
-                metadataQuery = `metadata[name]=${filters.metadata.name}&`;
-            }
-
-            if (filters.metadata.keyvalues) {
-                metadataQuery = metadataQuery + 'metadata[keyvalues]=';
-
-                if (typeof filters.metadata.keyvalues !== 'object') {
-                    throw new Error('metadata keyvalues must be an object');
-                }
-
-                const prunedKeyValues: any = {}; // we want to make sure we're only grabbing the values we want for the query, and nothing extra
-
-                Object.entries(filters.metadata.keyvalues).forEach((keyValue) => {
-                    const key = keyValue[0];
-                    const value: any = keyValue[1];
-
-                    if (typeof value !== 'object') {
-                        throw new Error(`keyValue: ${key} is not an object`);
-                    }
-                    if (!value || !value.value || !value.op) {
-                        throw new Error(`keyValue: ${key} must have both value and op attributes`);
-                    }
-                    if ((typeof value.value !== 'string') && (typeof value.value !== 'boolean') && (typeof value.value !== 'number')) {
-                        throw new Error('Metadata keyvalue values must be strings, booleans, or numbers');
-                    }
-
-                    // Run checks to make sure all of the keyvalues are valid
-                    switch (value.op) {
-                        case 'gt':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        //greater than or equal
-                        case 'gte':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // less than
-                        case 'lt':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // less than or equal
-                        case 'lte':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // not equal to
-                        case 'ne':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // equal to
-                        case 'eq':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // between
-                        case 'between':
-                            if (!value.secondValue) {
-                                throw new Error(`Because between op code was passed in, keyValue: ${keyValue[0]} must have both also include a secondValue`);
-                            }
-                            if ((typeof value.secondValue !== 'string') && (typeof value.secondValue !== 'boolean') && (typeof value.secondValue !== 'number')) {
-                                throw new Error('Metadata keyvalue secondValue must be a string, boolean, or number');
-                            }
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op,
-                                secondValue: value.secondValue
-                            };
-                            break;
-                        // not between
-                        case 'notBetween':
-                            if (!value.secondValue) {
-                                throw new Error(`Because notBetween op code was passed in, keyValue: ${keyValue[0]} must have both also include a secondValue`);
-                            }
-                            if ((typeof value.secondValue !== 'string') && (typeof value.secondValue !== 'boolean') && (typeof value.secondValue !== 'number')) {
-                                throw new Error('Metadata keyvalue secondValue must be a string, boolean, or number');
-                            }
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op,
-                                secondValue: value.secondValue
-                            };
-                            break;
-                        // like
-                        case 'like':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // not like
-                        case 'notLike':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // case insensitive like
-                        case 'iLike':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // case insensitive not like
-                        case 'notILike':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // regex
-                        case 'regexp':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        // case insensitive regex
-                        case 'iRegexp':
-                            prunedKeyValues[key] = {
-                                value: value.value,
-                                op: value.op
-                            };
-                            break;
-                        default:
-                            throw new Error(`keyValue op: ${value.op} is not a valid op code`);
-                    }
-                });
-
-                metadataQuery = metadataQuery + `${JSON.stringify(prunedKeyValues)}`;
-            }
-        }
-    }
-    return `${baseUrl}${filterQuery}${metadataQuery}`;
-}
-

package/src/commands/data/testAuthentication.ts

@@ -1,31 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import {createConfigForAxiosHeaders} from '../../util/validators';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-
-export interface PinataTestAuthenticationResponse {
-    authenticated: boolean;
-}
-
-export default function testAuthentication(config: PinataConfig): Promise<PinataTestAuthenticationResponse> {
-    //  test authentication to make sure that the user's provided keys are legit
-    const endpoint = `${baseUrl}/data/testAuthentication`;
-
-    return new Promise((resolve, reject) => {
-        axios.get(
-            endpoint,
-            {...createConfigForAxiosHeaders(config)})
-        .then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while authenticating: ${result}`));
-            }
-            resolve({
-                authenticated: true
-            });
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/data/userPinnedDataTotal.ts

@@ -1,24 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import { createConfigForAxiosHeaders } from '../../util/validators';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-
-export default function userPinnedDataTotal(config: PinataConfig): Promise<number> {
-    const endpoint = `${baseUrl}/data/userPinnedDataTotal`;
-
-    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 pinned data total: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/hashMetadata.ts

@@ -1,56 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
-import isIPFS from 'is-ipfs';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-import { PinataMetadata } from '../data/pinList/pinList';
-
-export default function hashMetadata(config: PinataConfig, ipfsPinHash: string, metadata:PinataMetadata): Promise<any> {
-    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 (!metadata) {
-        throw new Error('no metadata object provided');
-    }
-
-    validateMetadata(metadata);
-
-    const endpoint = `${baseUrl}/pinning/hashMetadata`;
-    const body: {
-        ipfsPinHash: string,
-        name?: any,
-        keyvalues?: any
-    } = {
-        ipfsPinHash: ipfsPinHash
-    };
-
-    if (metadata.name) {
-        body.name = metadata.name;
-    }
-
-    if (metadata.keyvalues) {
-        body.keyvalues = metadata.keyvalues;
-    }
-
-    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 metadata for hash: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}

package/src/commands/pinning/index.ts

@@ -1,8 +0,0 @@
-export * from './pinJobs/pinJobs';
-export * from './pinJobs/queryBuilder';
-export * from './hashMetadata';
-export * from './pinByHash';
-export * from './pinFileToIPFS';
-export * from './pinFromFS';
-export * from './pinJSONToIPFS';
-export * from './unpin';

package/src/commands/pinning/pinByHash.ts

@@ -1,65 +0,0 @@
-import axios from 'axios';
-import { baseUrl } from '../../constants';
-import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
-import isIPFS from 'is-ipfs';
-import { handleError } from '../../util/errorResponse';
-import { PinataConfig } from '../..';
-import { PinataOptions } from './pinFileToIPFS';
-import { PinataMetadata } from '../data/pinList/pinList';
-
-export interface PinataPinByHashPinOptions {
-    pinataMetadata?: PinataMetadata;
-    pinataOptions?: PinataOptions ;
-}
-
-export interface PinataPinByHashResponse {
-    id: number | string;
-    ipfsHash: string;
-    status: string;
-    name: string;
-}
-
-export default function pinByHash(config: PinataConfig, hashToPin: string, options: any): Promise<any> {
-    if (!hashToPin) {
-        throw new Error('hashToPin value is required for pinning by hash');
-    }
-    if (!isIPFS.cid(hashToPin)) {
-        throw new Error('hashToPin value is an invalid IPFS CID');
-    }
-
-    const endpoint = `${baseUrl}/pinning/pinByHash`;
-    const body : {
-        hashToPin: any,
-        pinataOptions: any,
-        pinataMetadata?: any,
-    } = {
-        hashToPin: hashToPin,
-        pinataOptions: {}
-    };
-
-    if (options) {
-        if (options.pinataOptions) {
-            body.pinataOptions = options.pinataOptions;
-        }
-        if (options.pinataMetadata) {
-            validateMetadata(options.pinataMetadata);
-            body.pinataMetadata = options.pinataMetadata;
-        }
-    }
-
-    return new Promise((resolve, reject) => {
-        axios.post(
-            endpoint,
-            body,
-            {...createConfigForAxiosHeaders(config)})
-        .then(function (result) {
-            if (result.status !== 200) {
-                reject(new Error(`unknown server response while adding to pin queue: ${result}`));
-            }
-            resolve(result.data);
-        }).catch(function (error) {
-            const formattedError = handleError(error);
-            reject(formattedError);
-        });
-    });
-}