@dev-crew-berlin/enter-js-utils 0.24.0 → 0.30.1

package/README.md

@@ -25,7 +25,7 @@ typed js client for the enter api.
 ```typescript
 import EnterAPIClient from '@dev-crew-berlin/enter-js-utils/api-client'
 
-const url = 'https://enter.events/api/v1'
+const url = 'https://api.enter.events'
 
 async function apiExample() {
   // fetch access Token
@@ -36,14 +36,9 @@ async function apiExample() {
     deviceName: 'my-device',
   })
 
-  const credentials = {
-    accessToken: accessToken,
-    url: url,
-  }
-
   // create api instance
   const api = new EnterAPIClient({
-    credentials: credentials,
+    credentials: { accessToken, url },
     onLogout: (reason?: string) => {
       deleteCredetials()
     },

package/dist/api-client/api-base.d.ts

@@ -1,9 +1,23 @@
-import { APIResult, APIValidator } from '../lib';
+import { APIResult } from '../lib';
 import { AccessToken } from '../models/access-token';
+import { paths } from '../generated/api-schema';
 export interface APICredentials {
-    accessToken: string;
+    accessToken: AccessToken;
     url: string;
 }
+declare type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+declare type JSONRes = {
+    content: {
+        'application/json': unknown;
+    };
+};
+declare type ResJSON<Code extends number> = {
+    responses: Record<Code, JSONRes>;
+};
+declare type ResponseType<Path extends keyof paths, Method extends HTTPMethod> = paths[Path] extends Record<Method, ResJSON<200>> ? paths[Path][Method]['responses'][200]['content']['application/json'] : paths[Path] extends Record<Method, ResJSON<204>> ? paths[Path][Method]['responses'][204]['content']['application/json'] : never;
+export declare type RequestBody<Path extends keyof paths, Method extends HTTPMethod> = paths[Path] extends Record<Method, {
+    requestBody: JSONRes;
+}> ? paths[Path][Method]['requestBody']['content']['application/json'] : never;
 export default class APIBase {
     private credentials;
     private isLoggedIn;
@@ -19,12 +33,13 @@ export default class APIBase {
         password: string;
         deviceName: string;
     }): Promise<APIResult<AccessToken>>;
-    static getAuthHeader(username: string, password: string): string;
     private fetchFromEnter;
-    protected get<Model>(endpoint: string, validate: APIValidator<Model>): Promise<APIResult<Model>>;
-    protected post<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown> | null, validate: APIValidator<Model>): Promise<APIResult<Model>>;
-    protected put<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown>, validate: APIValidator<Model>): Promise<APIResult<Model>>;
-    protected patch<Model>(endpoint: string, data: Record<string, unknown> | Array<unknown>, validate: APIValidator<Model>): Promise<APIResult<Model>>;
+    protected get<Path extends keyof paths>(endpoint: Path): Promise<APIResult<ResponseType<Path, 'get'>>>;
+    protected post<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'post'>): Promise<APIResult<ResponseType<Path, 'post'>>>;
+    protected put<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'put'>): Promise<APIResult<ResponseType<Path, 'put'>>>;
+    protected patch<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'patch'>): Promise<APIResult<ResponseType<Path, 'patch'>>>;
+    protected delete<Path extends keyof paths>(endpoint: Path): Promise<APIResult<ResponseType<Path, 'delete'>>>;
     refreshToken(): Promise<APIResult<AccessToken>>;
     logout(): Promise<void>;
 }
+export {};

package/dist/api-client/api-base.js

@@ -1,5 +1,4 @@
 import { failure, success } from '../lib';
-import { parseAccessToken } from '../models/access-token';
 export default class APIBase {
   constructor(args) {
     this.credentials = args.credentials;
@@ -18,17 +17,16 @@ export default class APIBase {
 
   static async fetchAccessToken(args) {
     const body = {
-      apiKey: 'default',
-      user: args.user,
+      username: args.user,
       password: args.password,
-      device: args.deviceName
+      scope: args.deviceName
     };
-    const res = await APIBase.fetchResult(`${args.url}/authenticate`, {
+    const res = await APIBase.fetchResult(`/${args.url}/authenticate`, {
       method: 'POST',
       headers: {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/x-www-form-urlencoded'
       },
-      body: JSON.stringify(body)
+      body: new URLSearchParams(body)
     });
 
     if (!res.success) {
@@ -59,22 +57,16 @@ export default class APIBase {
     }
 
     const payload = await res.data.json();
-    return parseAccessToken(payload);
+    return success(payload);
   }
 
-  static getAuthHeader(username, password) {
-    const buffer = Buffer.from(`${username}:${password}`);
-    return 'Basic ' + buffer.toString('base64');
-  }
-
-  async fetchFromEnter(endpoint, method, data = null) {
+  async fetchFromEnter(endpoint, method, data) {
     const body = data !== null ? JSON.stringify(data) : null;
     const headers = {
-      Authorization: APIBase.getAuthHeader('default', this.credentials.accessToken),
-      'Content-Type': 'application/json',
-      'Enter-Live-Api': 'true'
+      Authorization: `bearer ${this.credentials.accessToken.access_token}`,
+      'Content-Type': 'application/json'
     };
-    const res = await APIBase.fetchResult(`${this.credentials.url}/${endpoint}`, {
+    const res = await APIBase.fetchResult(`${this.credentials.url}${endpoint}`, {
       method,
       headers,
       body
@@ -122,32 +114,38 @@ export default class APIBase {
     return success(json);
   }
 
-  async get(endpoint, validate) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'GET');
+  async get(endpoint) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'get', undefined);
+    if (!rawResponse.success) return rawResponse;
+    return success(rawResponse.data);
+  }
+
+  async post(endpoint, data) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'post', data);
     if (!rawResponse.success) return rawResponse;
-    return validate(rawResponse.data);
+    return success(rawResponse.data);
   }
 
-  async post(endpoint, data, validate) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'POST', data);
+  async put(endpoint, data) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'put', data);
     if (!rawResponse.success) return rawResponse;
-    return validate(rawResponse.data);
+    return success(rawResponse.data);
   }
 
-  async put(endpoint, data, validate) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'PUT', data);
+  async patch(endpoint, data) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'patch', data);
     if (!rawResponse.success) return rawResponse;
-    return validate(rawResponse.data);
+    return success(rawResponse.data);
   }
 
-  async patch(endpoint, data, validate) {
-    const rawResponse = await this.fetchFromEnter(endpoint, 'PATCH', data);
+  async delete(endpoint) {
+    const rawResponse = await this.fetchFromEnter(endpoint, 'delete', undefined);
     if (!rawResponse.success) return rawResponse;
-    return validate(rawResponse.data);
+    return success(rawResponse.data);
   }
 
   async refreshToken() {
-    return this.post('authenticate/refresh', null, parseAccessToken);
+    return this.post('/authenticate/refresh', null);
   }
 
   async logout() {
@@ -156,7 +154,7 @@ export default class APIBase {
 
     try {
       // delete token at api backend so it becomes invalid
-      await this.fetchFromEnter('/authenticate', 'DELETE');
+      await this.fetchFromEnter('/authenticate', 'delete', undefined);
     } catch (e) {
       console.warn('error deleting the token in the backend, so it is still valid', e);
     }

package/dist/api-client/index.d.ts

@@ -1,76 +1,58 @@
-import APIBase from './api-base';
+import APIBase, { RequestBody } from './api-base';
 import { APIResult } from '../lib';
 import { Attendee } from '../models/attendee';
 import { Event } from '../models';
 import { CheckinCounts } from '../models/checkin-counts';
 import { FieldGroups } from '../models/field-group';
 import { Instance } from '../models/instance';
-import { Invite } from '../models/invite';
 import { User } from '../models/user';
 import { Variable } from '../models/variable';
-import { Dictionary } from '../models/_helpers';
 export type { APICredentials } from './api-base';
 export default class API extends APIBase {
+    getInstanceList(): Promise<APIResult<Instance[]>>;
     getInstance(args: {
-        instanceId: string;
+        instanceName: string;
     }): Promise<APIResult<Instance>>;
-    getInstanceList(): Promise<APIResult<Instance[]>>;
     getFields(args: {
-        instanceId: string;
+        instanceName: string;
     }): Promise<APIResult<FieldGroups>>;
     getCheckinCounts(args: {
-        instanceId: string;
+        instanceName: string;
     }): Promise<APIResult<CheckinCounts>>;
     getAttendeeList(args: {
-        instanceId: string;
+        instanceName: string;
         includeDeleted?: boolean;
     }): Promise<APIResult<Attendee[]>>;
-    sendEmail(args: {
-        instanceId: string;
-        collection: 'attendees';
-        attendeeId: string;
-        mailId: string;
-    } | {
-        instanceId: string;
-        collection: 'invites';
-        index: number;
-        mailId: string;
-    }): Promise<APIResult<null>>;
-    getAttendeesByAuthCode(args: {
-        instanceId: string;
-        authCode: string;
-    }): Promise<APIResult<Attendee[]>>;
-    getInviteByAuthCode(args: {
-        instanceId: string;
-        authCode: string;
-    }): Promise<APIResult<Invite>>;
-    getAttendeeById(args: {
-        instanceId: string;
+    getAttendee(args: {
+        instanceName: string;
         attendeeId: string;
     }): Promise<APIResult<Attendee>>;
-    createEvents(args: {
-        events: Event[];
-    }): Promise<APIResult<null>>;
-    getUser(): Promise<APIResult<User>>;
-    patchUser(args: {
-        userdata: Dictionary<unknown>;
-    }): Promise<APIResult<null>>;
-    getAllVariables(args: {
-        instanceId: string;
+    getVariableList(args: {
+        instanceName: string;
     }): Promise<APIResult<Variable[]>>;
-    getVariableByName(args: {
-        instanceId: string;
+    getVariable(args: {
+        instanceName: string;
         variableName: string;
     }): Promise<APIResult<Variable>>;
     createVariable(args: {
-        instanceId: string;
+        instanceName: string;
         variable: Variable;
     }): Promise<APIResult<Variable>>;
     updateVariable(args: {
-        instanceId: string;
+        instanceName: string;
         variableName: string;
-        update: {
-            value: string;
-        };
+        update: RequestBody<'/instances/{instance_name}/variables/{variable_name}', 'put'>;
     }): Promise<APIResult<Variable>>;
+    deleteVariable(args: {
+        instanceName: string;
+        variableName: string;
+    }): Promise<APIResult<null>>;
+    getUser(): Promise<APIResult<User>>;
+    updateUser(args: RequestBody<'/users/me', 'patch'>): Promise<APIResult<User>>;
+    sendEmail(args: {
+        instanceName: string;
+        attendeeId: string;
+        emailName: string;
+    }): Promise<APIResult<null>>;
+    createEvents(args: Event[]): Promise<APIResult<null>>;
 }

package/dist/api-client/index.js

@@ -1,28 +1,32 @@
 import APIBase from './api-base';
 import { success } from '../lib';
-import { parseAttendee, parseAttendeeList } from '../models/attendee';
-import { parseCheckinCounts } from '../models/checkin-counts';
-import { parseFieldGroups } from '../models/field-group';
-import { parseInstance, parseInstanceList } from '../models/instance';
-import { parseInvite } from '../models/invite';
-import { parseUser } from '../models/user';
-import { parseVariable, parseVariableList } from '../models/variable';
-import { parseNoContent } from '../models/_helpers';
+import { Attendee } from '../models/attendee';
+import { FieldGroups } from '../models/field-group';
+import { Instance } from '../models/instance';
 export default class API extends APIBase {
-  async getInstance(args) {
-    return this.get(`instances/${args.instanceId}`, parseInstance);
+  async getInstanceList() {
+    const result = await this.get('/instances');
+    if (!result.success) return result;
+    return success(result.data.map(instanceJSON => new Instance(instanceJSON)));
   }
 
-  async getInstanceList() {
-    return this.get(`instances`, parseInstanceList);
+  async getInstance(args) {
+    const instanceName = args.instanceName;
+    const result = await this.get(`/instances/${instanceName}`);
+    if (!result.success) return result;
+    return success(new Instance(result.data));
   }
 
   async getFields(args) {
-    return this.get(`instances/${args.instanceId}/fields`, parseFieldGroups);
+    const instanceName = args.instanceName;
+    const result = await this.get(`/instances/${instanceName}/fields`);
+    if (!result.success) return result;
+    return success(new FieldGroups(result.data));
   }
 
   async getCheckinCounts(args) {
-    return this.get(`instances/${args.instanceId}/checkins`, parseCheckinCounts);
+    const instanceName = args.instanceName;
+    return this.get(`/instances/${instanceName}/checkin_counts`);
   }
 
   async getAttendeeList(args) {
@@ -32,58 +36,66 @@ export default class API extends APIBase {
       query.append('include_deleted', 'true');
     }
 
-    return this.get(`instances/${args.instanceId}/attendees?${query.toString()}`, parseAttendeeList);
+    const instanceName = args.instanceName;
+    const queryString = `?${query.toString()}`;
+    const result = await this.get(`/instances/${instanceName}/attendees${queryString}`);
+    if (!result.success) return result;
+    return success(result.data.map(attendeeJSON => new Attendee(attendeeJSON)));
   }
 
-  async sendEmail(args) {
-    const guestId = args.collection === 'attendees' ? args.attendeeId : args.index;
-    return this.post(`instances/${args.instanceId}/${args.collection}/${guestId}/emails/${args.mailId}`, null, parseNoContent);
-  }
-
-  async getAttendeesByAuthCode(args) {
-    // it is stupid to get all attendees here
-    // but here we would need a special endpoint that could get attendees by authcode
-    const allAttendees = await this.getAttendeeList({
-      instanceId: args.instanceId
-    });
-    if (!allAttendees.success) return allAttendees;
-    return success(allAttendees.data.filter(attendee => attendee.auth === args.authCode));
+  async getAttendee(args) {
+    const instanceName = args.instanceName;
+    const attendeeId = args.attendeeId;
+    const result = await this.get(`/instances/${instanceName}/attendees/${attendeeId}`);
+    if (!result.success) return result;
+    return success(new Attendee(result.data));
   }
 
-  async getInviteByAuthCode(args) {
-    return await this.get(`instances/${args.instanceId}/invites/${args.authCode}`, parseInvite);
+  async getVariableList(args) {
+    const instanceName = args.instanceName;
+    return this.get(`/instances/${instanceName}/variables`);
   }
 
-  async getAttendeeById(args) {
-    return await this.get(`instances/${args.instanceId}/attendees/${args.attendeeId}`, parseAttendee);
+  async getVariable(args) {
+    const instanceName = args.instanceName;
+    const variableName = args.variableName;
+    return this.get(`/instances/${instanceName}/variables/${variableName}`);
   }
 
-  async createEvents(args) {
-    return this.post(`events`, args.events, parseNoContent);
+  async createVariable(args) {
+    const instanceName = args.instanceName;
+    return this.post(`/instances/${instanceName}/variables`, args.variable);
   }
 
-  async getUser() {
-    return this.get('user', parseUser);
+  async updateVariable(args) {
+    const instanceName = args.instanceName;
+    const variableName = args.variableName;
+    return this.put(`/instances/${instanceName}/variables/${variableName}`, args.update);
   }
 
-  async patchUser(args) {
-    return this.patch('user', args, parseNoContent);
+  async deleteVariable(args) {
+    const instanceName = args.instanceName;
+    const variableName = args.variableName;
+    return this.delete(`/instances/${instanceName}/variables/${variableName}`);
   }
 
-  async getAllVariables(args) {
-    return this.get(`instances/${args.instanceId}/variables`, parseVariableList);
+  async getUser() {
+    return this.get('/users/me');
   }
 
-  async getVariableByName(args) {
-    return this.get(`instances/${args.instanceId}/variables/${args.variableName}`, parseVariable);
+  async updateUser(args) {
+    return this.patch('/users/me', args);
   }
 
-  async createVariable(args) {
-    return this.post(`instances/${args.instanceId}/variables`, args.variable, parseVariable);
+  async sendEmail(args) {
+    const instanceName = args.instanceName;
+    const attendeeId = args.attendeeId;
+    const emailName = args.emailName;
+    return this.post(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/send`, null);
   }
 
-  async updateVariable(args) {
-    return this.put(`instances/${args.instanceId}/variables/${args.variableName}`, args.update, parseVariable);
+  async createEvents(args) {
+    return this.post(`/events`, args);
   }
 
 }