@pinata/sdk 2.0.0 → 3.0.0

package/test/commands/pinning/pinByHash.test.ts

@@ -1,46 +0,0 @@
-import axios from 'axios';
-import pinByHash from '../../../src/commands/pinning/pinByHash';
-
-jest.mock('axios');
-
-//common values
-const badHashToPin = 'test';
-const goodHashToPin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
-
-test('No hashToPin value is provided should error', () => {
-    expect(() => {
-        pinByHash('test', 'test');
-    }).toThrow();
-});
-
-test('Invalid HashToPin value is provided', () => {
-    expect(() => {
-        pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToPin);
-    }).toThrow();
-});
-
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).resolves.toEqual(goodStatus.data);
-});
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.post as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual(Error(`unknown server response while adding to pin queue: ${badStatus}`));
-});
-
-test('Rejection handled', () => {
-    (axios.post as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual('test error');
-});
-

package/test/commands/pinning/pinFileToIPFS.test.ts

@@ -1,53 +0,0 @@
-import axios from 'axios';
-import pinFileToIPFS from '../../../src/commands/pinning/pinFileToIPFS';
-import fs from 'fs';
-import NodeFormData from 'form-data';
-jest.mock('axios');
-
-//common values
-const nonStream = 'test';
-const validStream = fs.createReadStream('./pinata.png');
-const validFormData = new NodeFormData();
-validFormData.append('file', validStream, {filepath: 'test/filepath'});
-
-test('non-readableStream and non-formData is passed in', () => {
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, nonStream)).rejects.toEqual(Error('readStream is not a readable stream or form data'));
-
-    return undefined;
-});
-
-test('200 status is returned with valid stream', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
-});
-
-test('200 status is returned with valid form data', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
-});
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.post as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
-});
-
-test('Rejection handled', () => {
-    (axios.post as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual('test error');
-});
-

package/test/commands/pinning/pinFromFS.ts

@@ -1,32 +0,0 @@
-import axios from 'axios';
-import pinFromFS from '../../../src/commands/pinning/pinFromFS';
-jest.mock('axios');
-
-//common values
-const testSource = './testing/testing';
-
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).resolves.toEqual(goodStatus.data);
-});
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.post as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual(Error(`unknown server response while pinning to IPFS: ${badStatus}`));
-});
-
-test('Rejection handled', () => {
-    (axios.post as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual('test error');
-});
-

package/test/commands/pinning/pinJSONToIPFS.test.ts

@@ -1,42 +0,0 @@
-import axios from 'axios';
-import pinJSONToIPFS from '../../../src/commands/pinning/pinJSONToIPFS';
-
-jest.mock('axios');
-
-//common values
-const badJSON = 'test';
-const goodJSON = {
-    test: 'test'
-};
-
-test('non-object is passed in', () => {
-    expect(() => {
-        pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badJSON);
-    }).toThrow('body must be a valid JSON object');
-});
-
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).resolves.toEqual(goodStatus.data);
-});
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.post as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual(Error(`unknown server response while pinning JSON to IPFS: ${badStatus}`));
-});
-
-test('Rejection handled', () => {
-    (axios.post as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual('test error');
-});
-

package/test/commands/pinning/pinJobs/pinJobs.test.ts

@@ -1,29 +0,0 @@
-import axios from 'axios';
-import pinJobs from '../../../../src/commands/pinning/pinJobs/pinJobs';
-
-jest.mock('axios');
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.get as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(Error(`unknown server response while attempting to retrieve pin jobs: ${badStatus}`));
-});
-
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.get as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual(goodStatus.data);
-});
-
-test('Rejection handled', () => {
-    (axios.get as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual('test error');
-});

package/test/commands/pinning/pinJobs/queryBuilder.test.ts

@@ -1,120 +0,0 @@
-import queryBuilder from '../../../../src/commands/pinning/pinJobs/queryBuilder';
-
-const baseUrl = 'testing.com/test';
-const badFilterValue = 'badFilterValue';
-const goodHashToPin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
-
-describe('queryBuilder no params provided', () => {
-    test('if no baseUrl is provided', () => {
-        // expect(() => {
-        //     queryBuilder();
-        // }).toThrow('no baseUrl provided');
-    });
-    test('if no filters are provided, return a non filtered url', () => {
-        expect(queryBuilder(baseUrl)).toEqual(baseUrl);
-    });
-});
-
-describe('queryBuilder multiple filters', () => {
-    test('one bad filter and one good are provided', () => {
-        const filter = {
-            limit: 5,
-            offset: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Invalid offset: ${badFilterValue}. Please provide a positive integer for the offset`);
-    });
-    test('two good filters are provided', () => {
-        const filter = {
-            status: 'searching',
-            offset: 5
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?status=searching&offset=5`);
-    });
-});
-
-describe('queryBuilder filter: sort', () => {
-    test('unknown sort is provided', () => {
-        const filter = {
-          sort: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Unknown sort value: ${badFilterValue} provided`);
-    });
-    test('good sort value is provided', () => {
-        const filter = {
-            sort: 'ASC'
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?sort=ASC`);
-    });
-});
-
-describe('queryBuilder filter: status', () => {
-    test('unknown status is provided', () => {
-        const filter = {
-            status: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Unknown status value: ${badFilterValue} provided`);
-    });
-    test('good status value is provided', () => {
-        const filter = {
-            status: 'searching'
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?status=searching`);
-    });
-});
-
-describe('queryBuilder filter: ipfs_pin_hash', () => {
-    test('bad hash is provided', () => {
-        const filter = {
-            ipfs_pin_hash: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Invalid IPFS hash: ${badFilterValue}`);
-    });
-    test('good hash is provided', () => {
-        const filter = {
-            ipfs_pin_hash: goodHashToPin
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?ipfs_pin_hash=${goodHashToPin}`);
-    });
-});
-
-describe('queryBuilder filter: limit', () => {
-    test('bad hash is provided', () => {
-        const filter = {
-            limit: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Invalid limit: ${badFilterValue}. Valid limits are 1-100`);
-    });
-    test('good limit is provided', () => {
-        const filter = {
-            limit: 5
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?limit=5`);
-    });
-});
-
-describe('queryBuilder filter: offset', () => {
-    test('bad hash is provided', () => {
-        const filter = {
-            offset: badFilterValue
-        };
-        expect(() => {
-            queryBuilder(baseUrl, filter);
-        }).toThrow(`Invalid offset: ${badFilterValue}. Please provide a positive integer for the offset`);
-    });
-    test('good offset is provided', () => {
-        const filter = {
-            offset: 5
-        };
-        expect(queryBuilder(baseUrl, filter)).toEqual(`${baseUrl}?offset=5`);
-    });
-});

package/test/commands/pinning/unpin.test.ts

@@ -1,46 +0,0 @@
-import axios from 'axios';
-import unpin from '../../../src/commands/pinning/unpin';
-
-jest.mock('axios');
-
-//common values
-const badHashToUnpin = 'test';
-const goodHashToUnpin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
-
-test('No hashToUnpin value is provided should error', () => {
-    expect(() => {
-        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' });
-    }).toThrow('hashToUnpin value is required for removing a pin from Pinata');
-});
-
-test('Invalid hashToUnpin value is provided', () => {
-    expect(() => {
-        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToUnpin);
-    }).toThrow(`${badHashToUnpin} is an invalid IPFS CID`);
-});
-
-test('200 status is returned', () => {
-    const goodStatus = {
-        status: 200,
-        data: 'testData'
-    };
-    (axios.delete as jest.Mock).mockResolvedValue(goodStatus);
-    expect.assertions(1);
-    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).resolves.toEqual(goodStatus.data);
-});
-
-test('Result other than 200 status is returned', () => {
-    const badStatus = {
-        status: 700
-    };
-    (axios.delete as jest.Mock).mockResolvedValue(badStatus);
-    expect.assertions(1);
-    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual(Error(`unknown server response while removing pin from IPFS: ${badStatus}`));
-});
-
-test('Rejection handled', () => {
-    (axios.delete as jest.Mock).mockRejectedValue('test error');
-    expect.assertions(1);
-    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual('test error');
-});
-

package/test/util/validators.test.ts

@@ -1,234 +0,0 @@
-import {
-    validateApiKeys,
-    createConfigForAxiosHeaders,
-    validateHostNodes,
-    validateMetadata,
-    validatePinPolicyStructure,
-    validatePinataOptions
-} from '../../src/util/validators';
-import { ERROR_NO_CREDENTIALS_PROVIDED } from '../../src/constants';
-
-describe('validateApiKeys function testing', () => {
-    test('check to throw if either pinataApiKey or pinataSecretApiKey are not provided', () => {
-        expect(() => {
-            validateApiKeys('', 'test');
-        }).toThrow(
-            'No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script'
-        );
-        expect(() => {
-            validateApiKeys('test', '');
-        }).toThrow(
-            'No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script'
-        );
-    });
-});
-
-describe('createConfigForAxiosHeaders function testing', () => {
-    expect(() => {
-        createConfigForAxiosHeaders({});
-    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
-
-    expect(() => {
-        createConfigForAxiosHeaders({ pinataApiKey: 'some api key' });
-    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
-
-    expect(() => {
-        createConfigForAxiosHeaders({ pinataSecretApiKey: 'some api secret' });
-    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
-
-    expect(
-        createConfigForAxiosHeaders({
-            pinataApiKey: 'some api key',
-            pinataSecretApiKey: 'some api secret'
-        })
-    ).toEqual({
-        withCredentials: true,
-        headers: {
-            pinata_api_key: 'some api key',
-            pinata_secret_api_key: 'some api secret'
-        }
-    });
-});
-describe('validateHostNodes function testing', () => {
-    test('host_nodes is not an array', () => {
-        const hostNodes = {
-            test: 'test'
-        };
-        expect(() => {
-            validateHostNodes(hostNodes);
-        }).toThrow('host_nodes value must be an array');
-    });
-
-    test('invalid host_node entry', () => {
-        const validHost =
-            '/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj';
-        const invalidHost = 'invalid host';
-        const hostNodes = [validHost, invalidHost];
-        expect(() => {
-            validateHostNodes(hostNodes);
-        }).toThrow(
-            `host_node array entry: ${invalidHost} is not a valid peer multiaddr`
-        );
-    });
-});
-
-describe('validateMetadata function testing', () => {
-    test('name is not a string', () => {
-        const badName = {
-            test: 'testing'
-        };
-        expect(() => {
-            validateMetadata({
-                name: badName
-            });
-        }).toThrow('metadata name must be of type string');
-    });
-    test('keyvalues is not an object', () => {
-        const badKeyValues = 'testing';
-        expect(() => {
-            validateMetadata({
-                keyvalues: badKeyValues
-            });
-        }).toThrow('metatadata keyvalues must be an object');
-    });
-
-    test('more than 10 keyvalues was provided', () => {
-        const tooManyKeyValues = {
-            one: 1,
-            two: 2,
-            three: 3,
-            four: 4,
-            five: 5,
-            six: 6,
-            seven: 7,
-            eight: 8,
-            nine: 9,
-            ten: 10,
-            eleven: 11
-        };
-        expect(() => {
-            validateMetadata({
-                keyvalues: tooManyKeyValues
-            });
-        }).toThrow(
-            'No more than 10 keyvalues can be provided for metadata entries'
-        );
-    });
-    test('Throws error on an object being passed in as a value for a keyvalue', () => {
-        const invalidValue = {
-            one: 1,
-            two: {
-                test: 'test'
-            },
-            three: 3,
-            four: 4,
-            five: 5,
-            six: 6,
-            seven: 7,
-            eight: 8,
-            nine: 9,
-            ten: 10,
-            eleven: 11
-        };
-        expect(() => {
-            validateMetadata({
-                keyvalues: invalidValue
-            });
-        }).toThrow(
-            'Metadata keyvalue values must be strings, booleans, or numbers'
-        );
-    });
-    test('Does not throw an error if metadata is valid', () => {
-        const invalidValue = {
-            one: 1,
-            two: 2,
-            three: 3,
-            four: 4,
-            five: 5,
-            six: 6,
-            seven: 7,
-            eight: 8,
-            nine: 9,
-            ten: 10
-        };
-        expect(() => {
-            validateMetadata({
-                keyvalues: invalidValue
-            });
-        }).not.toThrow();
-    });
-});
-
-describe('validatePinPolicyStructure function testing', () => {
-    test('No Policy Provided', () => {
-        expect(() => {
-            validatePinPolicyStructure();
-        }).toThrow('No pin policy provided');
-    });
-    test('No Regions Provided', () => {
-        expect(() => {
-            validatePinPolicyStructure({
-                test: 'test'
-            });
-        }).toThrow('No regions provided in pin policy');
-    });
-    test('region id is not a string', () => {
-        expect(() => {
-            validatePinPolicyStructure({
-                regions: [
-                    {
-                        id: 'goodRegionId',
-                        desiredReplicationCount: 1
-                    },
-                    {
-                        id: 0,
-                        desiredReplicationCount: 1
-                    }
-                ]
-            });
-        }).toThrow('region id must be a string');
-    });
-    test('desiredReplicationCount is not an integer', () => {
-        expect(() => {
-            validatePinPolicyStructure({
-                regions: [
-                    {
-                        id: 'goodRegionId',
-                        desiredReplicationCount: 1
-                    },
-                    {
-                        id: 'goodRegionId2',
-                        desiredReplicationCount: 'string that should fail'
-                    }
-                ]
-            });
-        }).toThrow('desiredReplicationCount must be an integer');
-    });
-});
-
-describe('validatePinataOptions function testing', () => {
-    test('options is not an object', () => {
-        expect(() => {
-            validatePinataOptions('test');
-        }).toThrow('options must be an object');
-    });
-    test('cidVersion is not a 0 or 1', () => {
-        const badVersion = {
-            test: 'testing'
-        };
-        expect(() => {
-            validatePinataOptions({
-                cidVersion: badVersion
-            });
-        }).toThrow('unsupported or invalid cidVersion');
-    });
-    test('wrapWithDirectory is not true or false', () => {
-        expect(() => {
-            validatePinataOptions({
-                wrapWithDirectory: 'test'
-            });
-        }).toThrow(
-            'wrapWithDirectory must be a boolean value of true or false'
-        );
-    });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts",   "src/**/*.js"],
-  "compilerOptions": {
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "sourceMap": true,
-    "allowJs": true,
-    "outDir": "types",
-    "target": "es5",
-    "module": "commonjs",
-    "lib": ["es2017", "es7", "es6", "dom"],
-    "strict": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true
-  },
-  "exclude": [
-    "node_modules",
-    "lib",
-    "test",
-    "coverage"
-  ]
-}

package/types/commands/data/getFilesByCount/getFilesByCount.d.ts

@@ -1,14 +0,0 @@
-import { PinataConfig } from '../../..';
-import { PinataPin, PinataPinListFilterOptions } from '../pinList/pinList';
-export default function getFilesByCount(config: PinataConfig, filters?: PinataPinListFilterOptions, maxCount?: number): {
-    [Symbol.asyncIterator]: () => {
-        next(): Promise<{
-            value: PinataPin;
-            done: boolean;
-        }>;
-        return(): Promise<{
-            value: number;
-            done: boolean;
-        }>;
-    };
-};

package/types/commands/data/index.d.ts

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