| null} [config.allowedUrls]
145 | * @param {Array<{ platform: string, bundleId: string }> | null} [config.allowedApplications] This option restricts tokens with an Application Bundle ID. The feature is in beta and is only available to our selected customers. For more information, please contact sales.
146 | * @return {MapiRequest}
147 | *
148 | * @example
149 | * tokensClient.updateToken({
150 | * tokenId: 'cijucimbe000brbkt48d0dhcx',
151 | * note: 'datasets-token',
152 | * scopes: ['datasets:write', 'datasets:read']
153 | * })
154 | * .send()
155 | * .then(response => {
156 | * const token = response.body;
157 | * });
158 | */
159 | Tokens.updateToken = function(config) {
160 | v.assertShape({
161 | tokenId: v.required(v.string),
162 | note: v.string,
163 | scopes: v.arrayOf(v.string),
164 | resources: v.arrayOf(v.string),
165 | allowedUrls: v.arrayOf(v.string),
166 | allowedApplications: v.arrayOf(
167 | v.shape({
168 | bundleId: v.string,
169 | platform: v.string
170 | })
171 | )
172 | })(config);
173 |
174 | var body = {};
175 | if (config.scopes) {
176 | body.scopes = config.scopes;
177 | }
178 | if (config.note !== undefined) {
179 | body.note = config.note;
180 | }
181 | if (config.resources || config.resources === null) {
182 | body.resources = config.resources;
183 | }
184 | if (config.allowedUrls || config.allowedUrls === null) {
185 | body.allowedUrls = config.allowedUrls;
186 | }
187 |
188 | if (config.allowedApplications || config.allowedApplications === null) {
189 | body.allowedApplications = config.allowedApplications;
190 | }
191 |
192 | return this.client.createRequest({
193 | method: 'PATCH',
194 | path: '/tokens/v2/:ownerId/:tokenId',
195 | params: pick(config, ['ownerId', 'tokenId']),
196 | body: body
197 | });
198 | };
199 |
200 | /**
201 | * Get data about the client's access token.
202 | *
203 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/accounts/#retrieve-a-token).
204 | *
205 | * @return {MapiRequest}
206 | *
207 | * @example
208 | * tokensClient.getToken()
209 | * .send()
210 | * .then(response => {
211 | * const token = response.body;
212 | * });
213 | */
214 | Tokens.getToken = function() {
215 | return this.client.createRequest({
216 | method: 'GET',
217 | path: '/tokens/v2'
218 | });
219 | };
220 |
221 | /**
222 | * Delete an access token.
223 | *
224 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/accounts/#delete-a-token).
225 | *
226 | * @param {Object} config
227 | * @param {string} config.tokenId
228 | * @return {MapiRequest}
229 | *
230 | * @example
231 | * tokensClient.deleteToken({
232 | * tokenId: 'cijucimbe000brbkt48d0dhcx'
233 | * })
234 | * .send()
235 | * .then(response => {
236 | * // Token successfully deleted.
237 | * });
238 | */
239 | Tokens.deleteToken = function(config) {
240 | v.assertShape({
241 | tokenId: v.required(v.string)
242 | })(config);
243 |
244 | return this.client.createRequest({
245 | method: 'DELETE',
246 | path: '/tokens/v2/:ownerId/:tokenId',
247 | params: pick(config, ['ownerId', 'tokenId'])
248 | });
249 | };
250 |
251 | /**
252 | * List your available scopes. Each item is a metadata
253 | * object about the scope, not just the string scope.
254 | *
255 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/accounts/#list-scopes).
256 | *
257 | * @return {MapiRequest}
258 | *
259 | * @example
260 | * tokensClient.listScopes()
261 | * .send()
262 | * .then(response => {
263 | * const scopes = response.body;
264 | * });
265 | */
266 | Tokens.listScopes = function() {
267 | return this.client.createRequest({
268 | method: 'GET',
269 | path: '/scopes/v1/:ownerId'
270 | });
271 | };
272 |
273 | module.exports = createServiceFactory(Tokens);
274 |
--------------------------------------------------------------------------------
/services/uploads.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var v = require('./service-helpers/validator');
4 | var createServiceFactory = require('./service-helpers/create-service-factory');
5 | var pick = require('./service-helpers/pick');
6 |
7 | /**
8 | * Uploads API service.
9 | *
10 | * Learn more about this service and its responses in
11 | * [the HTTP service documentation](https://docs.mapbox.com/api/maps/#uploads).
12 | */
13 | var Uploads = {};
14 |
15 | /**
16 | * List the statuses of all recent uploads.
17 | *
18 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/maps/#retrieve-recent-upload-statuses).
19 | *
20 | * @param {Object} [config]
21 | * @param {boolean} [config.reverse] - List uploads in chronological order, rather than reverse chronological order.
22 | * @return {MapiRequest}
23 | *
24 | * @example
25 | * uploadsClient.listUploads()
26 | * .send()
27 | * .then(response => {
28 | * const uploads = response.body;
29 | * });
30 | */
31 | Uploads.listUploads = function(config) {
32 | v.assertShape({
33 | reverse: v.boolean
34 | })(config);
35 |
36 | return this.client.createRequest({
37 | method: 'GET',
38 | path: '/uploads/v1/:ownerId',
39 | query: config
40 | });
41 | };
42 |
43 | /**
44 | * Create S3 credentials.
45 | *
46 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/maps/#retrieve-s3-credentials).
47 | *
48 | * @return {MapiRequest}
49 | *
50 | * @example
51 | * const AWS = require('aws-sdk');
52 | * const getCredentials = () => {
53 | * return uploadsClient
54 | * .createUploadCredentials()
55 | * .send()
56 | * .then(response => response.body);
57 | * }
58 | * const putFileOnS3 = (credentials) => {
59 | * const s3 = new AWS.S3({
60 | * accessKeyId: credentials.accessKeyId,
61 | * secretAccessKey: credentials.secretAccessKey,
62 | * sessionToken: credentials.sessionToken,
63 | * region: 'us-east-1'
64 | * });
65 | * return s3.putObject({
66 | * Bucket: credentials.bucket,
67 | * Key: credentials.key,
68 | * Body: fs.createReadStream('/path/to/file.mbtiles')
69 | * }).promise();
70 | * };
71 | *
72 | * getCredentials().then(putFileOnS3);
73 | */
74 | Uploads.createUploadCredentials = function() {
75 | return this.client.createRequest({
76 | method: 'POST',
77 | path: '/uploads/v1/:ownerId/credentials'
78 | });
79 | };
80 |
81 | /**
82 | * Create an upload.
83 | *
84 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/maps/#create-an-upload).
85 | *
86 | * @param {Object} config
87 | * @param {string} config.tileset - The tileset ID to create or replace, in the format `username.nameoftileset`.
88 | * Limited to 32 characters (only `-` and `_` special characters allowed; limit does not include username).
89 | * @param {string} config.url - HTTPS URL of the S3 object provided by [`createUploadCredentials`](#createuploadcredentials)
90 | * @param {string} [config.name] - The name of the tileset. Limited to 64 characters.
91 | * @return {MapiRequest}
92 | *
93 | * @example
94 | * // Response from a call to createUploadCredentials
95 | * const credentials = {
96 | * accessKeyId: '{accessKeyId}',
97 | * bucket: '{bucket}',
98 | * key: '{key}',
99 | * secretAccessKey: '{secretAccessKey}',
100 | * sessionToken: '{sessionToken}',
101 | * url: '{s3 url}'
102 | * };
103 | * uploadsClient.createUpload({
104 | * tileset: `${myUsername}.${myTileset}`,
105 | * url: credentials.url,
106 | * name: 'my uploads name',
107 | * })
108 | * .send()
109 | * .then(response => {
110 | * const upload = response.body;
111 | * });
112 | */
113 | Uploads.createUpload = function(config) {
114 | v.assertShape({
115 | url: v.required(v.string),
116 | tileset: v.string,
117 | name: v.string,
118 | mapId: v.string,
119 | tilesetName: v.string
120 | })(config);
121 |
122 | if (!config.tileset && !config.mapId) {
123 | throw new Error('tileset or mapId must be defined');
124 | }
125 |
126 | if (!config.name && !config.tilesetName) {
127 | throw new Error('name or tilesetName must be defined');
128 | }
129 |
130 | // Support old mapId option
131 | if (config.mapId) {
132 | config.tileset = config.mapId;
133 | }
134 |
135 | // Support old tilesetName option
136 | if (config.tilesetName) {
137 | config.name = config.tilesetName;
138 | }
139 |
140 | return this.client.createRequest({
141 | method: 'POST',
142 | path: '/uploads/v1/:ownerId',
143 | body: pick(config, ['tileset', 'url', 'name'])
144 | });
145 | };
146 |
147 | /**
148 | * Get an upload's status.
149 | *
150 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/maps/#retrieve-upload-status).
151 | *
152 | * @param {Object} config
153 | * @param {string} config.uploadId
154 | * @return {MapiRequest}
155 | *
156 | * @example
157 | * uploadsClient.getUpload({
158 | * uploadId: '{upload_id}'
159 | * })
160 | * .send()
161 | * .then(response => {
162 | * const status = response.body;
163 | * });
164 | */
165 | Uploads.getUpload = function(config) {
166 | v.assertShape({
167 | uploadId: v.required(v.string)
168 | })(config);
169 |
170 | return this.client.createRequest({
171 | method: 'GET',
172 | path: '/uploads/v1/:ownerId/:uploadId',
173 | params: config
174 | });
175 | };
176 |
177 | /**
178 | * Delete an upload.
179 | *
180 | * See the [corresponding HTTP service documentation](https://docs.mapbox.com/api/maps/#remove-an-upload-status).
181 | *
182 | * @param {Object} config
183 | * @param {string} config.uploadId
184 | * @return {MapiRequest}
185 | *
186 | * @example
187 | * uploadsClient.deleteUpload({
188 | * uploadId: '{upload_id}'
189 | * })
190 | * .send()
191 | * .then(response => {
192 | * // Upload successfully deleted.
193 | * });
194 | */
195 | Uploads.deleteUpload = function(config) {
196 | v.assertShape({
197 | uploadId: v.required(v.string)
198 | })(config);
199 |
200 | return this.client.createRequest({
201 | method: 'DELETE',
202 | path: '/uploads/v1/:ownerId/:uploadId',
203 | params: config
204 | });
205 | };
206 |
207 | module.exports = createServiceFactory(Uploads);
208 |
--------------------------------------------------------------------------------
/test/browser-interface.test.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @jest-environment jsdom-global
3 | */
4 | 'use strict';
5 | const mockXHR = require('xhr-mock').default;
6 | const browserClient = require('../lib/browser/browser-client');
7 | const constants = require('../lib/constants');
8 | const tu = require('./test-utils');
9 | const testSharedInterface = require('./test-shared-interface');
10 |
11 | describe('shared interface tests', () => {
12 | testSharedInterface(browserClient, true); // second argument sets isBrowserClient to true
13 | });
14 |
15 | test('errors early if access token not provided', () => {
16 | tu.expectError(
17 | () => browserClient(),
18 | error => {
19 | expect(error.message).toMatch(/access token/);
20 | }
21 | );
22 | });
23 |
24 | // Note: there are discrepancies between the node progress events
25 | // and browser progress events. For now we are assuming
26 | // the discrepancies are not worth normalizing across these
27 | // two platforms as no one would be planning to use them
28 | // in unison.
29 | describe('test progress events', () => {
30 | let request;
31 | const { mockToken } = tu;
32 |
33 | afterEach(() => {
34 | mockXHR.teardown();
35 | });
36 |
37 | beforeEach(() => {
38 | mockXHR.setup();
39 | const accessToken = mockToken();
40 | const responseBody = { mockStyle: true };
41 |
42 | // To mock the progress event
43 | // server needs to send the `Content-length` header
44 | // ref: https://github.com/jameslnewell/xhr-mock/tree/master/packages/xhr-mock#upload-progress
45 | mockXHR.get(
46 | `https://api.mapbox.com/styles/v1/mockuser/foo?access_token=${accessToken}`,
47 | {
48 | status: 200,
49 | headers: {
50 | 'Content-Length': JSON.stringify(responseBody).length,
51 | 'Content-Type': 'application/json; charset=utf-8'
52 | },
53 | body: JSON.stringify(responseBody)
54 | }
55 | );
56 | const client = browserClient({ accessToken });
57 |
58 | request = client.createRequest({
59 | method: 'GET',
60 | path: '/styles/v1/:ownerId/:styleId',
61 | params: { styleId: 'foo' }
62 | });
63 | });
64 |
65 | test('request.emitter should not emit uploadProgress events', () => {
66 | let progressUpload = [];
67 | request.emitter.on(constants.EVENT_PROGRESS_UPLOAD, resp => {
68 | progressUpload.push(Object.assign({}, resp));
69 | });
70 |
71 | return request.send().then(() => {
72 | expect(progressUpload).toEqual([]);
73 | });
74 | });
75 |
76 | test('request.emitter should emit downloadProgress events', () => {
77 | let progressDownload = [];
78 | request.emitter.on(constants.EVENT_PROGRESS_DOWNLOAD, resp => {
79 | progressDownload.push(Object.assign({}, resp));
80 | });
81 |
82 | return request.send().then(() => {
83 | expect(progressDownload).toEqual([
84 | { percent: 100, total: 18, transferred: 18 }
85 | ]);
86 | });
87 | });
88 | });
89 |
--------------------------------------------------------------------------------
/test/bundle.test.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const fs = require('fs');
4 | const path = require('path');
5 | const camelcase = require('camelcase');
6 | const mapboxSdk = require('../bundle');
7 |
8 | describe('includes all services', () => {
9 | const services = fs
10 | .readdirSync(path.join(__dirname, '../services'))
11 | .filter(filename => path.extname(filename) === '.js')
12 | .map(filename => camelcase(path.basename(filename, '.js')));
13 |
14 | // Mock token lifted from parse-mapbox-token tests.
15 | const client = mapboxSdk({
16 | accessToken:
17 | 'pk.eyJ1IjoiZmFrZXVzZXIiLCJhIjoicHBvb2xsIn0.sbihZCZJ56-fsFNKHXF8YQ'
18 | });
19 |
20 | services.forEach(service => {
21 | test(`includes ${service}`, () => {
22 | expect(client[service]).toBeTruthy();
23 | });
24 | });
25 | });
26 |
--------------------------------------------------------------------------------
/test/node-interface.test.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const nodeClient = require('../lib/node/node-client');
4 | const constants = require('../lib/constants');
5 | const tu = require('./test-utils');
6 | const testSharedInterface = require('./test-shared-interface');
7 |
8 | describe('shared interface tests', () => {
9 | testSharedInterface(nodeClient);
10 | });
11 |
12 | test('errors early if access token not provided', () => {
13 | tu.expectError(
14 | () => nodeClient(),
15 | error => {
16 | expect(error.message).toMatch(/access token/);
17 | }
18 | );
19 | });
20 |
21 | describe('test node progress events', () => {
22 | let request;
23 | let server;
24 | let createLocalClient;
25 | const { mockToken } = tu;
26 |
27 | beforeAll(() => {
28 | return tu.mockServer().then(s => {
29 | server = s;
30 | createLocalClient = server.localClient(nodeClient);
31 | });
32 | });
33 |
34 | afterAll(done => {
35 | server.close(done);
36 | });
37 |
38 | afterEach(() => {
39 | server.reset();
40 | });
41 |
42 | beforeEach(() => {
43 | server.setResponse((req, res) => {
44 | res.append('Content-Type', 'application/json; charset=utf-8');
45 | res.json({ mockStyle: true });
46 | });
47 |
48 | const accessToken = mockToken();
49 | const client = createLocalClient({ accessToken });
50 | request = client.createRequest({
51 | method: 'GET',
52 | path: '/styles/v1/:ownerId/:styleId',
53 | params: { styleId: 'foo' }
54 | });
55 | });
56 |
57 | test('request.emitter should emit uploadProgress events', () => {
58 | let progressUpload = [];
59 | request.emitter.on(constants.EVENT_PROGRESS_UPLOAD, resp => {
60 | progressUpload.push(Object.assign({}, resp));
61 | });
62 |
63 | return request.send().then(() => {
64 | expect(progressUpload).toEqual([
65 | { percent: 0, total: undefined, transferred: 0 },
66 | { percent: 100, total: 0, transferred: 0 }
67 | ]);
68 | });
69 | });
70 |
71 | test('request.emitter should emit downloadProgress events', () => {
72 | let progressDownload = [];
73 | request.emitter.on(constants.EVENT_PROGRESS_DOWNLOAD, resp => {
74 | progressDownload.push(Object.assign({}, resp));
75 | });
76 |
77 | return request.send().then(() => {
78 | expect(progressDownload).toEqual([
79 | { percent: 0, total: 18, transferred: 0 },
80 | { percent: 100, total: 18, transferred: 18 }
81 | ]);
82 | });
83 | });
84 | });
85 |
86 | describe('test empty request bodies', () => {
87 | let server;
88 | let createLocalClient;
89 | const { mockToken } = tu;
90 |
91 | beforeAll(() => {
92 | return tu.mockServer().then(s => {
93 | server = s;
94 | createLocalClient = server.localClient(nodeClient);
95 | });
96 | });
97 |
98 | afterAll(done => {
99 | server.close(done);
100 | });
101 |
102 | afterEach(() => {
103 | server.reset();
104 | });
105 |
106 | beforeEach(() => {
107 | server.setResponse((req, res) => {
108 | res.append('Content-Type', 'application/json; charset=utf-8');
109 | res.json({ mockStyle: true });
110 | });
111 | });
112 |
113 | test('request for POST, PATCH, PUT, or DELETE without an explicit body should include empty string as body', () => {
114 | // https://github.com/sindresorhus/got/issues/2303
115 | const accessToken = mockToken();
116 | const client = createLocalClient({ accessToken });
117 | const request = client.createRequest({
118 | method: 'DELETE',
119 | path: '/tilesets/v1/:tilesetId',
120 | params: { tilesetId: 'foo.bar' }
121 | });
122 |
123 | return request.send().then(({ statusCode }) => {
124 | expect(statusCode).toBe(200);
125 | });
126 | });
127 | });
128 |
--------------------------------------------------------------------------------
/test/test-utils.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const express = require('express');
4 | const bodyParser = require('body-parser');
5 | const base64url = require('base64-url');
6 | const getPort = require('get-port');
7 | const MapiClient = require('../lib/classes/mapi-client');
8 |
9 | function requestConfig(service) {
10 | return service.client.createRequest.mock.calls[0][0];
11 | }
12 |
13 | function mockClient() {
14 | var client = {
15 | createRequest: jest.fn(),
16 | abortRequest: jest.fn()
17 | };
18 | // Allow for Object.isPrototypeOf checks.
19 | Object.setPrototypeOf(client, MapiClient.prototype);
20 | return client;
21 | }
22 |
23 | function mockServer() {
24 | let handleRequest;
25 | let handleResponse;
26 |
27 | const reset = () => {
28 | handleRequest = () => {};
29 | handleResponse = (req, res) => {
30 | if (req.headers['content-type'] === 'application/octet-stream') {
31 | const json = JSON.stringify({
32 | test: 'test'
33 | });
34 | const buf = Buffer.from(json);
35 | res.writeHead(200, {
36 | 'Content-Type': 'application/octet-stream',
37 | 'Content-disposition': 'attachment; filename=data.json'
38 | });
39 | res.write(buf);
40 | res.end();
41 | }
42 |
43 | res.send();
44 | };
45 | };
46 | reset();
47 |
48 | const setResponse = cb => {
49 | handleResponse = cb;
50 | };
51 |
52 | const captureRequest = sendRequest => {
53 | const promiseRequest = new Promise((resolve, reject) => {
54 | try {
55 | handleRequest = req => resolve(req);
56 | } catch (error) {
57 | reject(error);
58 | }
59 | });
60 | return sendRequest().then(() => promiseRequest);
61 | };
62 |
63 | const app = express();
64 | app.use(bodyParser.json());
65 | app.use((req, res) => {
66 | // The browser tests require Access-Control-Allow-Origin for CORS,
67 | // so we'll just universally set Access-Control-Expose-Headers here.
68 | res.header('Access-Control-Expose-Headers', [
69 | 'Access-Control-Allow-Origin',
70 | 'Link'
71 | ]);
72 |
73 | // allow the three odd headers we are testing for in `test-shared-interface`
74 | res.header('Access-Control-Allow-Headers', [
75 | 'if-unmodified-since',
76 | 'x-horse-name',
77 | 'x-dog-name'
78 | ]);
79 |
80 | res.append('Access-Control-Allow-Origin', '*');
81 | handleRequest(req);
82 | handleResponse(req, res);
83 | });
84 |
85 | return getPort().then(port => {
86 | const origin = `http://localhost:${port}`;
87 | const nodeServer = app.listen(port);
88 |
89 | if (global.jsdom) {
90 | global.jsdom.reconfigure({
91 | url: origin
92 | });
93 | }
94 |
95 | const localClient = createClient => {
96 | return options => {
97 | return createClient(Object.assign({}, options, { origin }));
98 | };
99 | };
100 |
101 | const close = cb => {
102 | nodeServer.close(() => {
103 | cb();
104 | });
105 | };
106 |
107 | return {
108 | captureRequest,
109 | setResponse,
110 | reset,
111 | close,
112 | origin,
113 | port,
114 | localClient
115 | };
116 | });
117 | }
118 |
119 | function mockToken(header = 'pk', payload = {}, signature = 'sss') {
120 | const defaultedPayload = Object.assign(
121 | {
122 | u: 'mockuser',
123 | a: 'mockauth'
124 | },
125 | payload
126 | );
127 | const encodedPayload = base64url.encode(JSON.stringify(defaultedPayload));
128 | return [header, encodedPayload, signature].join('.');
129 | }
130 |
131 | function expectRejection(p, cb) {
132 | return p
133 | .then(() => {
134 | throw new Error('should have rejected');
135 | })
136 | .catch(cb);
137 | }
138 |
139 | function expectError(fn, cb) {
140 | try {
141 | fn();
142 | throw new Error('should have errored');
143 | } catch (e) {
144 | cb(e);
145 | }
146 | }
147 |
148 | module.exports = {
149 | requestConfig,
150 | mockClient,
151 | mockServer,
152 | mockToken,
153 | expectRejection,
154 | expectError
155 | };
156 |
--------------------------------------------------------------------------------
/test/try-browser/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "env": {
3 | "browser": true,
4 | "node": false
5 | }
6 | }
--------------------------------------------------------------------------------
/test/try-browser/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Test the SDK in the browser
4 |
21 |
22 |
23 | Test the SDK in the browser
24 |
25 | Open the console and use the global method tryServiceMethod.
26 | It should log responses and errors to the console.
27 | Here's its signature:
28 |
29 |
30 |
tryServiceMethod(
31 | service: string,
32 | method: string,
33 | config: ?Object,
34 | accessToken: ?string,
35 | callback: ?(response) => void,
36 | )
37 |
38 |
39 | You can paste an access token as the last argument or set it as the global variable MAPBOX_ACCESS_TOKEN.
40 |
41 |
42 | Only use public or very temporary access tokens! This is not a secure place to put a secret token.
43 |
44 |
45 | An example:
46 |
47 | MAPBOX_ACCESS_TOKEN = 'pk....';
48 | tryServiceMethod('styles', 'getStyle', {
49 | styleId: 'cjgzfhs7k00072rnkgjlcuxsu'
50 | });
51 |
52 |
53 |
54 |