@dev-crew-berlin/enter-js-utils 0.87.0 → 0.87.1

package/README.md

@@ -8,20 +8,31 @@ npm install @dev-crew-berlin/enter-js-utils
 
 ## packages
 
+### ui
+
+React ui components for enter and dcb apps.
+
+> docs: https://js-utils.enter.events/storybook
+
 ### lib
 
 Some common helper functions and types.  
 This also contains the dcb colors.
 
-### ui
+> docs: https://js-utils.enter.events/docs/modules/lib.html
+
+## models
 
-react ui components for enter and dcb apps.  
-see: https://js-utils-main.dcb-utils.vercel.app
+The models retured from the api-client.
+
+> docs: https://js-utils.enter.events/docs/modules/models.html
 
 ### api-client
 
 typed js client for the enter api.
 
+> docs: https://js-utils.enter.events/docs/modules/api-client.html
+
 ```typescript
 import EnterAPIClient from '@dev-crew-berlin/enter-js-utils/api-client'
 
@@ -58,10 +69,6 @@ async function apiExample() {
 }
 ```
 
-## models
-
-The models retured from the api-client.
-
 ## publish
 
 This package is automatically published to npm for each new tag starting with `v*`.

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

@@ -36,6 +36,9 @@ export default class APIBase {
         onLogout: (reason?: string) => void;
     });
     private static fetchResult;
+    /**
+     * @category Auth
+     */
     static fetchAccessToken(args: {
         oidc: {
             url: string;
@@ -56,6 +59,9 @@ export default class APIBase {
     protected put<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'put'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'put'>>>;
     protected patch<Path extends keyof paths>(endpoint: Path, data: RequestBody<Path, 'patch'>, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'patch'>>>;
     protected delete<Path extends keyof paths>(endpoint: Path, options: FetchOptions): Promise<APIResult<ResponseType<Path, 'delete'>>>;
+    /**
+     * @category Auth
+     */
     logout(): Promise<void>;
 }
 export {};

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

@@ -16,6 +16,10 @@ export default class APIBase {
       return failure(e);
     }
   }
+
+  /**
+   * @category Auth
+   */
   static async fetchAccessToken(args) {
     // see https://zitadel.com/docs/guides/integrate/private-key-jwt to learn about this flow
     const {
@@ -147,6 +151,10 @@ export default class APIBase {
     if (!rawResponse.success) return rawResponse;
     return success(rawResponse.data);
   }
+
+  /**
+   * @category Auth
+   */
   async logout() {
     this.isLoggedIn = false;
     this.onLogout();

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

@@ -10,73 +10,155 @@ import { Variable } from '../models/variable';
 import { components } from '../generated/api-schema';
 import { Email } from '../models/email';
 export type { APICredentials } from './api-base';
-export default class API extends APIBase {
+/**
+ * api client for the enter backend
+ */
+declare class API extends APIBase {
+    /**
+     * @category Instances
+     */
     getInstanceList(options?: FetchOptions): Promise<APIResult<Instance[]>>;
+    /**
+     * @category Instances
+     */
     getInstance(args: {
         instanceName: string;
     }, options?: FetchOptions): Promise<APIResult<Instance>>;
+    /**
+     * @category Fields
+     */
     getFields(args: {
         instanceName: string;
     }, options?: FetchOptions): Promise<APIResult<FieldGroups>>;
+    /**
+     * @category Counts
+     */
     getCheckinCounts(args: {
         instanceName: string;
     }, options?: FetchOptions): Promise<APIResult<CheckinCounts>>;
+    /**
+     * Get the number of guests for multiple custom filters. e.g. all guests that don't eat meat.
+     * This way you don't have to fetch the whole guestlist to calculate those counts.
+     * @category Counts
+     * @example
+     * api.calculateCustomCounts({
+     *   instanceName: 'my-instance',
+     *   counter: [
+     *     {
+     *       name: 'vegetarians',
+     *       filter: '&(user.has_food_restriction checked, user.is_vegetatian checked)'
+     *     },
+     *     {
+     *       name: 'other-restrictions',
+     *       filter: '&(user.has_food_restriction checked, user.is_vegetatian unchecked)'
+     *     }
+     *   ]
+     * })
+     *
+     * @param args.instanceName
+     * @param args.counter A list of `CustomCounter`s. You have to give each of your counts a name `name` and a `filter`
+     * @param options
+     * @returns
+     */
     calculateCustomCounts(args: {
         instanceName: string;
         counter: components['schemas']['CustomCounter'][];
     }, options?: FetchOptions): Promise<APIResult<{
         [key: string]: number;
     }>>;
+    /**
+     * @category Attendees
+     */
     getAttendeeList(args: {
         instanceName: string;
         filter?: string;
         includeDeleted?: boolean;
     }, options?: FetchOptions): Promise<APIResult<Attendee[]>>;
+    /**
+     * @category Attendees
+     */
     getAttendee(args: {
         instanceName: string;
         attendeeId: string;
         includeDeleted?: boolean;
     }, options?: FetchOptions): Promise<APIResult<Attendee>>;
+    /**
+     * @category Attendees
+     */
     getCompanions(args: {
         instanceName: string;
         attendeeId: string;
         includeDeleted?: boolean;
     }, options?: FetchOptions): Promise<APIResult<Attendee[]>>;
+    /**
+     * @category Tokens
+     */
     generateRegistrationToken(args: {
         instanceName: string;
         check: components['schemas']['SecurityQuestion'] | components['schemas']['AuthCode'] | components['schemas']['AttendeeId'];
     }, options?: FetchOptions): Promise<APIResult<string>>;
+    /**
+     * @category Variables
+     */
     getVariableList(args: {
         instanceName: string;
     }, options?: FetchOptions): Promise<APIResult<Variable[]>>;
+    /**
+     * @category Variables
+     */
     getVariable(args: {
         instanceName: string;
         variableName: string;
     }, options?: FetchOptions): Promise<APIResult<Variable>>;
+    /**
+     * @category Variables
+     */
     createVariable(args: {
         instanceName: string;
         variable: Variable;
     }, options?: FetchOptions): Promise<APIResult<Variable>>;
+    /**
+     * @category Variables
+     */
     updateVariable(args: {
         instanceName: string;
         variableName: string;
         update: RequestBody<'/instances/{instance_name}/variables/{variable_name}', 'put'>;
     }, options?: FetchOptions): Promise<APIResult<Variable>>;
+    /**
+     * @category Variables
+     */
     deleteVariable(args: {
         instanceName: string;
         variableName: string;
     }, options?: FetchOptions): Promise<APIResult<null>>;
+    /**
+     * @category User
+     */
     getUser(options?: FetchOptions): Promise<APIResult<User>>;
+    /**
+     * @category User
+     */
     updateUser(args: RequestBody<'/users/me', 'patch'>, options?: FetchOptions): Promise<APIResult<User>>;
+    /**
+     * @category Emails
+     */
     sendEmail(args: {
         instanceName: string;
         attendeeId: string;
         emailName: string;
     }, options?: FetchOptions): Promise<APIResult<null>>;
+    /**
+     * @category Emails
+     */
     getRenderedEmail(args: {
         instanceName: string;
         attendeeId: string;
         emailName: string;
     }, options?: FetchOptions): Promise<APIResult<Email>>;
+    /**
+     * @category Events
+     */
     createEvents(args: Event[], options?: FetchOptions): Promise<APIResult<null>>;
 }
+export default API;

package/dist/api-client/index.js

@@ -3,34 +3,81 @@ import { success } from '../lib';
 import { Attendee } from '../models/attendee';
 import { FieldGroups } from '../models/field-group';
 import { Instance } from '../models/instance';
-export default class API extends APIBase {
+/**
+ * api client for the enter backend
+ */
+class API extends APIBase {
+  /**
+   * @category Instances
+   */
   async getInstanceList(options = {}) {
     const result = await this.get('/instances', options);
     if (!result.success) return result;
     return success(result.data.map(instanceJSON => new Instance(instanceJSON)));
   }
+
+  /**
+   * @category Instances
+   */
   async getInstance(args, options = {}) {
     const instanceName = args.instanceName;
     const result = await this.get(`/instances/${instanceName}`, options);
     if (!result.success) return result;
     return success(new Instance(result.data));
   }
+
+  /**
+   * @category Fields
+   */
   async getFields(args, options = {}) {
     const instanceName = args.instanceName;
     const result = await this.get(`/instances/${instanceName}/fields`, options);
     if (!result.success) return result;
     return success(new FieldGroups(result.data));
   }
+
+  /**
+   * @category Counts
+   */
   async getCheckinCounts(args, options = {}) {
     const instanceName = args.instanceName;
     return this.get(`/instances/${instanceName}/checkin_counts`, options);
   }
+
+  /**
+   * Get the number of guests for multiple custom filters. e.g. all guests that don't eat meat.
+   * This way you don't have to fetch the whole guestlist to calculate those counts.
+   * @category Counts
+   * @example
+   * api.calculateCustomCounts({
+   *   instanceName: 'my-instance',
+   *   counter: [
+   *     {
+   *       name: 'vegetarians',
+   *       filter: '&(user.has_food_restriction checked, user.is_vegetatian checked)'
+   *     },
+   *     {
+   *       name: 'other-restrictions',
+   *       filter: '&(user.has_food_restriction checked, user.is_vegetatian unchecked)'
+   *     }
+   *   ]
+   * })
+   *
+   * @param args.instanceName
+   * @param args.counter A list of `CustomCounter`s. You have to give each of your counts a name `name` and a `filter`
+   * @param options
+   * @returns
+   */
   async calculateCustomCounts(args, options = {}) {
     const instanceName = args.instanceName;
     return this.post(`/instances/${instanceName}/custom_counts`, {
       counters: args.counter
     }, options);
   }
+
+  /**
+   * @category Attendees
+   */
   async getAttendeeList(args, options = {}) {
     const query = new URLSearchParams();
     if (args.filter) {
@@ -45,6 +92,10 @@ export default class API extends APIBase {
     if (!result.success) return result;
     return success(result.data.map(attendeeJSON => new Attendee(attendeeJSON)));
   }
+
+  /**
+   * @category Attendees
+   */
   async getAttendee(args, options = {}) {
     const query = new URLSearchParams();
     if (args.includeDeleted) {
@@ -57,6 +108,10 @@ export default class API extends APIBase {
     if (!result.success) return result;
     return success(new Attendee(result.data));
   }
+
+  /**
+   * @category Attendees
+   */
   async getCompanions(args, options = {}) {
     const query = new URLSearchParams();
     if (args.includeDeleted) {
@@ -69,52 +124,97 @@ export default class API extends APIBase {
     if (!result.success) return result;
     return success(result.data.map(attendeeJSON => new Attendee(attendeeJSON)));
   }
+
+  /**
+   * @category Tokens
+   */
   async generateRegistrationToken(args, options = {}) {
     const instanceName = args.instanceName;
     return this.post(`/instances/${instanceName}/registration/registration_token`, args.check, options);
   }
+
+  /**
+   * @category Variables
+   */
   async getVariableList(args, options = {}) {
     const instanceName = args.instanceName;
     return this.get(`/instances/${instanceName}/variables`, options);
   }
+
+  /**
+   * @category Variables
+   */
   async getVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
     return this.get(`/instances/${instanceName}/variables/${variableName}`, options);
   }
+
+  /**
+   * @category Variables
+   */
   async createVariable(args, options = {}) {
     const instanceName = args.instanceName;
     return this.post(`/instances/${instanceName}/variables`, args.variable, options);
   }
+
+  /**
+   * @category Variables
+   */
   async updateVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
     return this.put(`/instances/${instanceName}/variables/${variableName}`, args.update, options);
   }
+
+  /**
+   * @category Variables
+   */
   async deleteVariable(args, options = {}) {
     const instanceName = args.instanceName;
     const variableName = args.variableName;
     return this.delete(`/instances/${instanceName}/variables/${variableName}`, options);
   }
+
+  /**
+   * @category User
+   */
   async getUser(options = {}) {
     return this.get('/users/me', options);
   }
+
+  /**
+   * @category User
+   */
   async updateUser(args, options = {}) {
     return this.patch('/users/me', args, options);
   }
+
+  /**
+   * @category Emails
+   */
   async sendEmail(args, options = {}) {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const emailName = args.emailName;
     return this.post(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/send`, null, options);
   }
+
+  /**
+   * @category Emails
+   */
   async getRenderedEmail(args, options = {}) {
     const instanceName = args.instanceName;
     const attendeeId = args.attendeeId;
     const emailName = args.emailName;
     return this.get(`/instances/${instanceName}/attendees/${attendeeId}/emails/${emailName}/render`, options);
   }
+
+  /**
+   * @category Events
+   */
   async createEvents(args, options = {}) {
     return this.post(`/events`, args, options);
   }
-}
+}
+export default API;