feat(users): Add users collection to SDK

README.md

@@ -24,7 +24,7 @@ The official JavaScript SDK for the [Eventbrite v3 API](https://www.eventbrite.c
 
 > NOTE: This library is still in **beta** as we flesh out the API of the SDK.
 
-## ToC
+## Table of Contents
 
 *   [Installation](#installation)
 *   [Quick Usage](#quick-usage)

docs/README.md

@@ -2,11 +2,12 @@
 
 This SDK interface closely mirors the [Eventbrite v3 REST API](https://www.eventbrite.com/developer/v3/) endpoints that it wraps. The SDK provides many conveniences for making requests and processing responses to make it easier to use in the JavaScript environment.
 
-## ToC
+## Table of Contents
 
 -   [Including the package](#including-the-package)
 -   [Configuring a SDK object](#configuring-a-sdk-object)
 -   [`request()`](./request.md)
+-   [Users](./users.md)
 
 ## Including the package
 

docs/users.md

@@ -0,0 +1,93 @@
+# Users
+
+This is a collection of method that are intended to be helpful wrappers around the [Users API endpoints](user-api-docs).
+
+View the [User response object](user-object-reference) for details on the properties you'll get back with each response.
+
+## Table on Contents
+
+- [`sdk.users.me()`](#me)
+- [`sdk.users.get(id)`](#getById)
+- [`sdk.users.emailLookup(email)`](#lookByEmail)
+
+<a id="me"></a>
+
+## `sdk.users.me()`
+Gets details about the current logged in user.
+
+**Read [`/users/me` documentation](user-get-me) for more details.**
+
+### API
+```js
+sdk.users.me(): Promise<User>
+```
+
+### Example
+
+```js
+const eventbrite = require('eventbrite');
+
+// Create configured Eventbrite SDK
+const sdk = eventbrite({token: 'OATH_TOKEN_HERE'});
+
+sdk.users.me().then((user) => {
+    console.log(`Hi ${user.name}!`);
+});
+```
+
+<a id="getById"></a>
+
+## `sdk.users.get(id)`
+Gets the details for a specific user by their user id. 
+
+**Read [`/users/:id` documentation](user-get-me) for more details.**
+
+### API
+```js
+sdk.users.get(id: string): Promise<User>
+```
+
+### Example
+
+```js
+const eventbrite = require('eventbrite');
+
+// Create configured Eventbrite SDK
+const sdk = eventbrite({token: 'OATH_TOKEN_HERE'});
+
+sdk.users.get('1234567890').then((user) => {
+    console.log(`Hi ${user.name}!`);
+});
+```
+
+<a id="lookByEmail"></a>
+
+## `sdk.users.emailLookup(email)`
+Gets the details for a specific user using their emaill address.
+
+**_Currently, no public documentation page._**
+
+### API
+```js
+sdk.users.emailLookup(string>): Promise<User>
+```
+
+### Example
+
+```js
+const eventbrite = require('eventbrite');
+
+// Create configured Eventbrite SDK
+const sdk = eventbrite({token: 'OATH_TOKEN_HERE'});
+
+sdk.users.emailLookup('[email protected]').then((user) => {
+    console.log(`Hi ${user.name}!`);
+});
+```
+
+
+<!-- link reference section -->
+[user-api-docs]: https://www.eventbrite.com/platform/api#/reference/user
+[user-object-reference]: https://www.eventbrite.com/platform/api#/reference/user/retrieve-a-user
+[user-by-id]: https://www.eventbrite.com/platform/api#/reference/user/retrieve-a-user
+[user-get-me]: https://www.eventbrite.com/platform/api#/reference/user/retrieve/retrieve-your-user

src/__tests__/__fixtures__/index.ts

@@ -14,6 +14,22 @@ export const MOCK_USERS_ME_RESPONSE_DATA = {
     image_id: null as string,
 };
 
+export const MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA = {
+    emails: [
+        {
+            email: '[email protected]',
+            verified: true,
+            primary: true,
+        },
+    ],
+    id: '142429416488',
+    name: 'Eventbrite Engineer',
+    firstName: 'Eventbrite',
+    lastName: 'Engineer',
+    isPublic: false,
+    imageId: null as string,
+};
+
 export const MOCK_INTERNAL_ERROR_RESPONSE_DATA = {
     status_code: 500,
     error: 'INTERNAL_ERROR',

src/__tests__/index.spec.ts

@@ -5,7 +5,10 @@ import {
     restoreMockFetch,
     getMockResponse,
 } from './utils';
-import {MOCK_USERS_ME_RESPONSE_DATA} from './__fixtures__';
+import {
+    MOCK_USERS_ME_RESPONSE_DATA,
+    MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA,
+} from './__fixtures__';
 
 describe('configurations', () => {
     it('does not error when creating sdk object w/o configuration', () => {
@@ -90,4 +93,65 @@ describe('request', () => {
             })
         );
     });
+
+    describe('users collection', () => {
+        it('should return an object of functions', () => {
+            const {users} = eventbrite({
+                token: MOCK_TOKEN,
+                baseUrl: MOCK_BASE_URL,
+            });
+
+            expect(users).toBeDefined();
+            Object.keys(users).forEach((key) => {
+                const value = (users as any)[key];
+
+                expect(value).toBeInstanceOf(Function);
+            });
+        });
+
+        it('makes request to API base url override w/ specified token', async() => {
+            const {users} = eventbrite({
+                token: MOCK_TOKEN,
+                baseUrl: MOCK_BASE_URL,
+            });
+
+            await expect(users.me()).resolves.toEqual(
+                MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA
+            );
+
+            expect(getMockFetch()).toHaveBeenCalledTimes(1);
+            expect(getMockFetch()).toHaveBeenCalledWith(
+                `${MOCK_BASE_URL}/users/me/`,
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        Authorization: `Bearer ${MOCK_TOKEN}`,
+                    }),
+                })
+            );
+        });
+
+        it('combines request options properly', async() => {
+            const {users} = eventbrite({
+                token: MOCK_TOKEN,
+                baseUrl: MOCK_BASE_URL,
+            });
+            const email = '[email protected]';
+
+            await expect(users.emailLookup(email)).resolves.toEqual(
+                MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA
+            );
+
+            expect(getMockFetch()).toHaveBeenCalledTimes(1);
+            expect(getMockFetch()).toHaveBeenCalledWith(
+                `${MOCK_BASE_URL}/users/lookup/`,
+                expect.objectContaining({
+                    method: 'POST',
+                    body: JSON.stringify({email}),
+                    headers: expect.objectContaining({
+                        Authorization: `Bearer ${MOCK_TOKEN}`,
+                    }),
+                })
+            );
+        });
+    });
 });

src/__tests__/users.spec.ts

@@ -0,0 +1,144 @@
+import {
+    mockFetch,
+    getMockFetch,
+    getMockResponse,
+    restoreMockFetch,
+} from './utils';
+import {
+    MOCK_USERS_ME_RESPONSE_DATA,
+    MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA,
+} from './__fixtures__';
+
+import request from '../request';
+import {UserApi} from '../users';
+
+describe('users.me()', () => {
+    let users: UserApi;
+
+    beforeEach(() => {
+        users = new UserApi(request);
+    });
+
+    it('calls fetch and calls fetch with appropriate defaults', async() => {
+        mockFetch(getMockResponse(MOCK_USERS_ME_RESPONSE_DATA));
+
+        await expect(users.me()).resolves.toEqual(
+            MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA
+        );
+
+        expect(getMockFetch()).toHaveBeenCalledTimes(1);
+        expect(getMockFetch()).toHaveBeenCalledWith(
+            '/users/me/',
+            expect.objectContaining({})
+        );
+
+        restoreMockFetch();
+    });
+
+    it('handle token missing requests', async() => {
+        mockFetch(
+            getMockResponse(
+                {
+                    status_code: 401,
+                    error_description:
+                        'An OAuth token is required for all requests',
+                    error: 'NO_AUTH',
+                },
+                {status: 401}
+            )
+        );
+
+        await expect(users.me()).rejects.toMatchObject({
+            response: expect.objectContaining({
+                status: 401,
+                statusText: 'Unauthorized',
+                ok: false,
+            }),
+            parsedError: {
+                description: 'An OAuth token is required for all requests',
+                error: 'NO_AUTH',
+            },
+        });
+
+        restoreMockFetch();
+    });
+});
+
+describe('users.get(id)', () => {
+    let users: UserApi;
+
+    beforeEach(() => {
+        users = new UserApi(request);
+    });
+
+    it('calls fetch and calls fetch with appropriate defaults', async() => {
+        mockFetch(getMockResponse(MOCK_USERS_ME_RESPONSE_DATA));
+
+        await expect(users.get('142429416488')).resolves.toEqual(
+            MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA
+        );
+
+        expect(getMockFetch()).toHaveBeenCalledTimes(1);
+        expect(getMockFetch()).toHaveBeenCalledWith(
+            '/users/142429416488/',
+            expect.objectContaining({})
+        );
+
+        restoreMockFetch();
+    });
+
+    it('should handle not found users', async() => {
+        mockFetch(
+            getMockResponse(
+                {
+                    status_code: 404,
+                    error_description: 'The user you requested does not exist.',
+                    error: 'NOT_FOUND',
+                },
+                {status: 404}
+            )
+        );
+
+        await expect(users.get('123')).rejects.toMatchObject({
+            response: expect.objectContaining({
+                status: 404,
+                statusText: 'Not Found',
+                ok: false,
+            }),
+            parsedError: {
+                description: 'The user you requested does not exist.',
+                error: 'NOT_FOUND',
+            },
+        });
+
+        restoreMockFetch();
+    });
+});
+
+describe('users.emailLookup(email)', () => {
+    let users: UserApi;
+
+    beforeEach(() => {
+        users = new UserApi(request);
+    });
+
+    it('calls fetch and calls fetch with appropriate defaults', async() => {
+        mockFetch(getMockResponse(MOCK_USERS_ME_RESPONSE_DATA));
+        const email = '[email protected]';
+
+        await expect(users.emailLookup(email)).resolves.toEqual(
+            MOCK_TRANSFORMED_USERS_ME_RESPONSE_DATA
+        );
+
+        expect(getMockFetch()).toHaveBeenCalledTimes(1);
+        expect(getMockFetch()).toHaveBeenCalledWith(
+            '/users/lookup/',
+            expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify({email}),
+            })
+        );
+
+        restoreMockFetch();
+    });
+});