@pinata/sdk 2.1.0 → 3.0.0

package/src/util/validators.ts

@@ -1,182 +0,0 @@
-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(
-            'No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script'
-        );
-    }
-    if (!pinataSecretApiKey || pinataSecretApiKey === '') {
-        throw new Error(
-            'No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script'
-        );
-    }
-}
-
-export function createConfigForAxiosHeaders(config: PinataConfig) {
-    if (
-        config.pinataApiKey && config.pinataApiKey.length > 0 &&
-        config.pinataSecretApiKey && config.pinataSecretApiKey.length > 0
-    ) {
-        return {
-            withCredentials: true,
-            headers: {
-                pinata_api_key: config.pinataApiKey,
-                pinata_secret_api_key: config.pinataSecretApiKey
-            }
-        };
-    }
-
-    if (config.pinataJWTKey && config.pinataJWTKey.length > 0) {
-        return {
-            headers: {
-                Authorization: `Bearer ${config.pinataJWTKey}`
-            }
-        };
-    }
-
-    throw new Error(ERROR_NO_CREDENTIALS_PROVIDED);
-}
-
-export function createConfigForAxiosHeadersWithFormData(config: PinataConfig, boundaryValue: string) {
-    const requestOptions: axiosHeaders = {
-        ...createConfigForAxiosHeaders(config),
-        maxContentLength: Infinity, //this is needed to prevent axios from erroring out with large files
-        maxBodyLength: Infinity
-    };
-
-    requestOptions.headers['Content-type'] = `multipart/form-data; boundary=${boundaryValue}`;
-    return requestOptions;
-}
-
-export function validateHostNodes(hostNodes: any) {
-    if (!Array.isArray(hostNodes)) {
-        throw new Error('host_nodes value must be an array');
-    }
-    hostNodes.forEach((node) => {
-        if (!isIPFS.peerMultiaddr(node)) {
-            throw new Error(
-                `host_node array entry: ${node} is not a valid peer multiaddr`
-            );
-        }
-    });
-}
-
-export function validateMetadata(metadata: any) {
-    if (metadata.name) {
-        if (
-            !(
-                typeof metadata.name === 'string' ||
-                metadata.name instanceof String
-            )
-        ) {
-            throw new Error('metadata name must be of type string');
-        }
-    }
-
-    if (metadata.keyvalues) {
-        if (!(typeof metadata.keyvalues === 'object')) {
-            throw new Error('metatadata keyvalues must be an object');
-        }
-
-        let i = 0;
-
-        Object.entries(metadata.keyvalues).forEach(function (keyValue: any) {
-            if (i > 9) {
-                throw new Error(
-                    'No more than 10 keyvalues can be provided for metadata entries'
-                );
-            }
-            //  we want to make sure that the input is a string, a boolean, or a number, so we don't get an object passed in by accident
-            if (
-                !(
-                    typeof keyValue[1] === 'string' ||
-                    typeof keyValue[1] === 'boolean' ||
-                    !isNaN(keyValue[1])
-                )
-            ) {
-                throw new Error(
-                    'Metadata keyvalue values must be strings, booleans, or numbers'
-                );
-            }
-            i++;
-        });
-    }
-}
-
-export function validatePinPolicyStructure(pinPolicy: { regions: any[]; }) {
-    //this function takes in a pin policy and checks the JSON structure to make sure it's valid
-    if (!pinPolicy) {
-        throw new Error('No pin policy provided');
-    }
-
-    if (!pinPolicy.regions) {
-        throw new Error('No regions provided in pin policy');
-    }
-    if (pinPolicy.regions.length) {
-        pinPolicy.regions.forEach((region) => {
-            if (
-                !region.id ||
-                !(
-                    Object.prototype.toString.call(region.id) ===
-                    '[object String]'
-                )
-            ) {
-                throw new Error('region id must be a string');
-            }
-
-            if (
-                !(
-                    region.desiredReplicationCount ||
-                    region.desiredReplicationCount === 0
-                ) ||
-                !Number.isInteger(region.desiredReplicationCount)
-            ) {
-                throw new Error('desiredReplicationCount must be an integer');
-            }
-        });
-    }
-}
-
-export function validatePinataOptions(options: { cidVersion?: number; wrapWithDirectory?: boolean; hostNodes?: any; customPinPolicy?: any; }) {
-    if (typeof options !== 'object') {
-        throw new Error('options must be an object');
-    }
-
-    if (options.cidVersion) {
-        // eslint-disable-next-line eqeqeq
-        if (options.cidVersion != 0 && options.cidVersion != 1) {
-            throw new Error('unsupported or invalid cidVersion');
-        }
-    }
-    if (options.wrapWithDirectory) {
-        // eslint-disable-next-line eqeqeq
-        if (
-            options.wrapWithDirectory !== true &&
-            options.wrapWithDirectory !== false
-        ) {
-            throw new Error(
-                'wrapWithDirectory must be a boolean value of true or false'
-            );
-        }
-    }
-
-    if (options.hostNodes) {
-        validateHostNodes(options.hostNodes);
-    }
-
-    if (options.customPinPolicy) {
-        validatePinPolicyStructure(options.customPinPolicy);
-    }
-}

package/test/commands/data/getFilesByCount/getFilesByCount.test.ts

@@ -1,212 +0,0 @@
-import getFilesByCount from '../../../../src/commands/data/getFilesByCount/getFilesByCount';
-import axios from 'axios';
-import {
-    APIData,
-    pinListAxiosMockPages,
-    fakeHeaders
-} from '../pinlist-sample-api';
-import { PinataConfig, PinataPin, PinataPinListFilterOptions } from '../../../../src';
-
-jest.mock('axios');
-
-const metadataName = (item) => {
-    return item.metadata.name;
-};
-const callIterableObject = async (config: PinataConfig, filterToApply: PinataPinListFilterOptions, pinsCount?: number) => {
-    const pins: PinataPin[] = [];
-    for await (const item of getFilesByCount(
-        config,
-        filterToApply,
-        pinsCount
-    )) {
-        pins.push(metadataName(item));
-    }
-
-    return pins;
-};
-
-describe('Get Files By Count', () => {
-    const pinataConfig = {
-        pinataApiKey: fakeHeaders.headers.pinata_api_key,
-        pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
-    };
-    const filterToApply = {
-        status: 'pinned'
-    };
-
-    afterEach(() => {
-        jest.resetAllMocks();
-    });
-
-    test('Request 17 pins, pins available', async () => {
-        const pinsToRequest = 17;
-
-        (axios.get as jest.Mock)
-            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
-            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
-
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply,
-            pinsToRequest
-        );
-
-        expect(pins).toEqual(
-            APIData.rows.slice(0, pinsToRequest).map(metadataName)
-        );
-        expect(pins).toHaveLength(pinsToRequest);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPage.url,
-            pinListAxiosMockPages.firstPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            2,
-            pinListAxiosMockPages.secondPage.url,
-            pinListAxiosMockPages.secondPage.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(2);
-    });
-
-    test('Request 6 pins, pins available', async () => {
-        const pinsToRequest = 6;
-
-        (axios.get as jest.Mock).mockResolvedValueOnce(
-            pinListAxiosMockPages.firstPage.response
-        );
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply,
-            pinsToRequest
-        );
-        expect(pins).toEqual(
-            APIData.rows.slice(0, pinsToRequest).map(metadataName)
-        );
-
-        expect(pins).toHaveLength(pinsToRequest);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPage.url,
-            pinListAxiosMockPages.firstPage.headers
-        );
-        expect(axios.get).toHaveBeenCalledTimes(1);
-    });
-
-    test('Request 25 pins, pins not available', async () => {
-        const pinsToRequest = 25;
-
-        (axios.get as jest.Mock)
-            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
-            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
-            .mockResolvedValueOnce(
-                pinListAxiosMockPages.thirdPageEmpty.response
-            );
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply,
-            pinsToRequest
-        );
-
-        expect(pins).toEqual(
-            APIData.rows.slice(0, pinsToRequest).map(metadataName)
-        );
-
-        expect(pins).toHaveLength(20);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPage.url,
-            pinListAxiosMockPages.firstPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            2,
-            pinListAxiosMockPages.secondPage.url,
-            pinListAxiosMockPages.secondPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            3,
-            pinListAxiosMockPages.thirdPageEmpty.url,
-            pinListAxiosMockPages.thirdPageEmpty.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(3);
-    });
-
-    test('Request 3 pins, pins not available', async () => {
-        const pinsToRequest = 3;
-
-        (axios.get as jest.Mock).mockResolvedValueOnce(
-            pinListAxiosMockPages.firstPageEmpty.response
-        );
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply,
-            pinsToRequest
-        );
-
-        expect(pins).toEqual([]);
-
-        expect(pins).toHaveLength(0);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPageEmpty.url,
-            pinListAxiosMockPages.firstPageEmpty.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(1);
-    });
-
-    test('Request all pins, pins available', async () => {
-        (axios.get as jest.Mock)
-            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
-            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response)
-            .mockResolvedValueOnce(
-                pinListAxiosMockPages.thirdPageEmpty.response
-            );
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply
-        );
-        expect(pins).toEqual(APIData.rows.map(metadataName));
-
-        expect(pins).toHaveLength(APIData.rows.length);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPage.url,
-            pinListAxiosMockPages.firstPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            2,
-            pinListAxiosMockPages.secondPage.url,
-            pinListAxiosMockPages.secondPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            3,
-            pinListAxiosMockPages.thirdPageEmpty.url,
-            pinListAxiosMockPages.thirdPageEmpty.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(3);
-    });
-
-    test('Request all pins, pins not available', async () => {
-        (axios.get as jest.Mock).mockResolvedValueOnce(
-            pinListAxiosMockPages.firstPageEmpty.response
-        );
-        const pins = await callIterableObject(
-            pinataConfig,
-            filterToApply
-        );
-
-        expect(pins).toEqual([]);
-
-        expect(pins).toHaveLength(0);
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPageEmpty.url,
-            pinListAxiosMockPages.firstPageEmpty.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(1);
-    });
-});

package/test/commands/data/pinList/pinList.test.ts

@@ -1,102 +0,0 @@
-import axios from 'axios';
-import pinList from '../../../../src/commands/data/pinList/pinList';
-import {
-    pinListAxiosMockPages,
-    fakeHeaders
-} from '../pinlist-sample-api';
-
-jest.mock('axios');
-
-describe('Pin List by page', () => {
-    afterEach(() => {
-        jest.resetAllMocks();
-    });
-
-    test('Call two pages in a row', async () => {
-        (axios.get as jest.Mock)
-            .mockResolvedValueOnce(pinListAxiosMockPages.firstPage.response)
-            .mockResolvedValueOnce(pinListAxiosMockPages.secondPage.response);
-
-        const resp = await pinList(
-            {
-                pinataApiKey: fakeHeaders.headers.pinata_api_key,
-                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
-            },
-            { pageLimit: 10, pageOffset: 0, status: 'pinned' }
-        );
-        const resp2 = await pinList(
-            {
-                pinataApiKey: fakeHeaders.headers.pinata_api_key,
-                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
-            },
-            { pageLimit: 10, pageOffset: 10, status: 'pinned' }
-        );
-        expect(resp).toEqual(pinListAxiosMockPages.firstPage.response.data);
-        expect(resp2).toEqual(pinListAxiosMockPages.secondPage.response.data);
-
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPage.url,
-            pinListAxiosMockPages.firstPage.headers
-        );
-        expect(axios.get).toHaveBeenNthCalledWith(
-            2,
-            pinListAxiosMockPages.secondPage.url,
-            pinListAxiosMockPages.secondPage.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(2);
-    });
-
-    test('Call empty page', async () => {
-        (axios.get as jest.Mock).mockResolvedValueOnce(
-            pinListAxiosMockPages.firstPageEmpty.response
-        );
-
-        const resp = await pinList(
-            {
-                pinataApiKey: fakeHeaders.headers.pinata_api_key,
-                pinataSecretApiKey: fakeHeaders.headers.pinata_secret_api_key
-            },
-            { pageLimit: 10, pageOffset: 0, status: 'pinned' }
-        );
-
-        expect(resp).toEqual({ rows: [] });
-
-        expect(axios.get).toHaveBeenNthCalledWith(
-            1,
-            pinListAxiosMockPages.firstPageEmpty.url,
-            pinListAxiosMockPages.firstPageEmpty.headers
-        );
-
-        expect(axios.get).toHaveBeenCalledTimes(1);
-    });
-    test('Result other than 200 status is returned', () => {
-        const badStatus = {
-            status: 700
-        };
-        (axios.get as jest.Mock).mockResolvedValue(badStatus);
-        expect.assertions(1);
-        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(
-            Error(
-                `unknown server response while attempting to retrieve user pin list: ${badStatus}`
-            )
-        );
-    });
-
-    test('200 status is returned', () => {
-        const goodStatus = {
-            status: 200,
-            data: 'testData'
-        };
-        (axios.get as jest.Mock).mockResolvedValue(goodStatus);
-        expect.assertions(1);
-        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual(goodStatus.data);
-    });
-
-    test('Rejection handled', () => {
-        (axios.get as jest.Mock).mockRejectedValue('test error');
-        expect.assertions(1);
-        expect(pinList({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual('test error');
-    });
-});