@dev-crew-berlin/enter-js-utils 0.23.0 → 0.30.0

package/dist/generated/api-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/api-result.d.ts

@@ -1,4 +1,3 @@
-import { Validator } from 'fefe';
 import { Result } from './result';
 export declare type NetworkError = {
     type: 'network-error';
@@ -15,11 +14,5 @@ export declare type ClientError = {
     type: 'client-error';
     message: string;
 };
-export declare type ValidationError = {
-    type: 'validation-error';
-    message: string;
-};
-export declare type APIError = NetworkError | HTTPError | ClientError | ValidationError;
+export declare type APIError = NetworkError | HTTPError | ClientError;
 export declare type APIResult<Model> = Result<APIError[], Model>;
-export declare type APIValidator<Model> = (value: unknown) => APIResult<Model>;
-export declare function apiValidator<T>(validate: Validator<T>): APIValidator<T>;

package/dist/lib/api-result.js

@@ -1,12 +1 @@
-import { isSuccess, getErrorString } from 'fefe';
-import { success, failure } from './result';
-export function apiValidator(validate) {
-  return value => {
-    const fefeResult = validate(value);
-    if (isSuccess(fefeResult)) return success(fefeResult.right);
-    return failure([{
-      type: 'validation-error',
-      message: getErrorString(fefeResult.left)
-    }]);
-  };
-}
+export {};

package/dist/models/access-token.d.ts

@@ -1,11 +1,2 @@
-import { ValidatorReturnType } from 'fefe';
-declare const accessToken: import("fefe").Validator<import("fefe").ObjectResult<{
-    accessToken: import("fefe").Validator<string, import("fefe").LeafError>;
-    expires: import("fefe").Pipe<unknown, Date>;
-}>, import("fefe").FefeError>;
-export declare type AccessToken = ValidatorReturnType<typeof accessToken>;
-export declare const parseAccessToken: import("../lib").APIValidator<import("fefe").ObjectResult<{
-    accessToken: import("fefe").Validator<string, import("fefe").LeafError>;
-    expires: import("fefe").Pipe<unknown, Date>;
-}>>;
-export {};
+import { components } from '../generated/api-schema';
+export declare type AccessToken = components['schemas']['AuthResponse'];

package/dist/models/access-token.js

@@ -1,11 +1 @@
-import { object, parseDate, pipe, string } from 'fefe';
-import { apiValidator } from '../lib';
-const accessToken = object({
-  accessToken: string(),
-  expires: pipe(string()).pipe(parseDate({
-    iso: true
-  }))
-}, {
-  allowExcessProperties: true
-});
-export const parseAccessToken = apiValidator(accessToken);
+export {};

package/dist/models/attendee.d.ts

@@ -1,37 +1,18 @@
-import { ValidatorReturnType } from 'fefe';
-import { APIResult } from '../lib';
-import { Checkin, Checkins, CheckinsJSON } from './checkins';
+import { components } from '../generated/api-schema';
+import { Checkin } from './checkin';
+import { Checkins } from './checkins';
 import { FieldValue } from './field-value';
-export declare type AttendeeJSON = {
-    id: string;
-    auth: string | null;
-    userdata: Record<string, FieldValue>;
-    tags: string[] | null;
-    language: string | null;
-    time: string;
-    rsvp: Record<string, number | null>;
-    checkin: Record<string, CheckinsJSON>;
-    companions: {
-        isCompanion: false;
-    } | {
-        isCompanion: true;
-        mainGuestId: string;
+export declare type AttendeeJSON = Omit<components['schemas']['PublicAttendee'], 'rsvp' | 'auth'> & {
+    rsvp: {
+        [key: string]: number | null;
     };
-    payment: {
-        paid: boolean;
-        provider: 'credit' | 'paypal';
-        amount: number;
-        testmode: boolean;
-    } | null;
-    deleted: boolean;
 };
 export declare class Attendee {
     id: string;
-    auth: string | null;
     userdata: Record<string, FieldValue>;
-    tags: string[] | null;
-    language: string | null;
-    time: Date;
+    tags: string[];
+    language?: string;
+    time?: Date;
     rsvp: Record<string, number | null>;
     checkin: Record<string, Checkins>;
     companions: {
@@ -40,15 +21,14 @@ export declare class Attendee {
         isCompanion: true;
         mainGuestId: string;
     };
-    payment: {
+    payment?: {
         paid: boolean;
-        provider: 'credit' | 'paypal';
+        provider: components['schemas']['Payment']['provider'];
         amount: number;
         testmode: boolean;
-    } | null;
+    };
     deleted: boolean;
-    constructor(rawAttendee: RawAttendee);
-    static fromJSON(json: AttendeeJSON): Attendee;
+    constructor(args: AttendeeJSON | string);
     toJSON(): AttendeeJSON;
     getRsvpCountForTag(checkinTag: string): number;
     getResponseForTag(checkinTag: string): 'no-response' | 'negative-repsone' | 'positive-response';
@@ -66,30 +46,3 @@ export declare class Attendee {
         checkinTags: string[];
     }): boolean;
 }
-export declare const rawAttendee: import("fefe").Validator<import("fefe").ObjectResult<{
-    id: import("fefe").Validator<string, import("fefe").LeafError>;
-    auth: import("fefe").Validator<string | null, import("fefe").FefeError>;
-    userdata: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<string | number | string[] | null>, import("fefe").FefeError>;
-    tags: import("fefe").Validator<string[] | null, import("fefe").FefeError>;
-    language: import("fefe").Validator<string | null, import("fefe").FefeError>;
-    time: import("fefe").Pipe<unknown, Date>;
-    rsvp: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<number | null>, import("fefe").FefeError>;
-    checkin: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<Checkins>, import("fefe").FefeError>;
-    companions: import("fefe").Validator<import("fefe").ObjectResult<{
-        isCompanion: import("fefe").Validator<false, import("fefe").FefeError>;
-    }> | import("fefe").ObjectResult<{
-        isCompanion: import("fefe").Validator<true, import("fefe").FefeError>;
-        mainGuestId: import("fefe").Validator<string, import("fefe").LeafError>;
-    }>, import("fefe").LeafError>;
-    payment: import("fefe").Validator<import("fefe").ObjectResult<{
-        paid: import("fefe").Validator<boolean, import("fefe").LeafError>;
-        provider: import("fefe").Validator<"credit" | "paypal", import("fefe").LeafError>;
-        amount: import("fefe").Validator<number, import("fefe").LeafError>;
-        testmode: import("fefe").Validator<boolean, import("fefe").LeafError>;
-    }> | null, import("fefe").FefeError>;
-    deleted: import("fefe").Validator<boolean, import("fefe").FefeError>;
-}>, import("fefe").FefeError>;
-declare type RawAttendee = ValidatorReturnType<typeof rawAttendee>;
-export declare const parseAttendee: (value: unknown) => APIResult<Attendee>;
-export declare const parseAttendeeList: (value: unknown) => APIResult<Attendee[]>;
-export {};

package/dist/models/attendee.js

@@ -1,32 +1,31 @@
-import { array, boolean, defaultTo, enumerate, number, object, parseDate, pipe, string, union } from 'fefe';
-import { apiValidator, success } from '../lib';
-import { Checkins, checkins } from './checkins';
-import { rawFieldValue } from './field-value';
-import { maybe, dictionary, constant } from './_helpers';
+import { Checkins } from './checkins';
 export class Attendee {
-  constructor(rawAttendee) {
-    this.id = rawAttendee.id;
-    this.auth = rawAttendee.auth;
-    this.userdata = rawAttendee.userdata;
-    this.tags = rawAttendee.tags;
-    this.language = rawAttendee.language;
-    this.time = rawAttendee.time;
-    this.rsvp = rawAttendee.rsvp;
-    this.checkin = rawAttendee.checkin;
-    this.companions = rawAttendee.companions;
-    this.payment = rawAttendee.payment;
-    this.deleted = rawAttendee.deleted;
-  }
+  userdata = {};
+  tags = [];
+  rsvp = {};
+  checkin = {};
+  companions = {
+    isCompanion: false
+  };
+  deleted = false;
 
-  static fromJSON(json) {
-    const checkin = Object.entries(json.checkin).reduce((obj, [tag, checkins]) => {
-      obj[tag] = Checkins.fromJSON(checkins);
-      return obj;
-    }, {});
-    return new Attendee({ ...json,
-      time: new Date(json.time),
-      checkin
-    });
+  constructor(args) {
+    if (typeof args === 'string') {
+      this.id = args;
+      return;
+    }
+
+    const json = args;
+    this.id = json.id;
+    this.userdata = json.userdata;
+    this.tags = json.tags;
+    this.language = json.language;
+    this.time = json.time ? new Date(json.time) : undefined;
+    this.rsvp = json.rsvp;
+    this.checkin = Object.fromEntries(new Map(Object.entries(json.checkin).map(([checkinTag, checkin]) => [checkinTag, new Checkins(checkin)])));
+    this.companions = json.companions;
+    this.payment = json.payment;
+    this.deleted = json.deleted;
   }
 
   toJSON() {
@@ -34,12 +33,9 @@ export class Attendee {
     // but then typescript complains that there is no toJSON function
     // so we implement it here again by hand
     // convert each checkin to its json representation
-    const checkin = Object.entries(this.checkin).reduce((obj, [tag, checkins]) => {
-      obj[tag] = checkins.toJSON();
-      return obj;
-    }, {});
+    const checkin = Object.fromEntries(new Map(Object.entries(this.checkin).map(([checkinTag, checkin]) => [checkinTag, checkin.toJSON()])));
     return { ...this,
-      time: this.time.toISOString(),
+      time: this.time?.toISOString(),
       checkin
     };
   }
@@ -71,16 +67,14 @@ export class Attendee {
 
   addCheckinForTag(args) {
     const exsitingCheckins = this.getCheckinsForTag(args.checkinTag);
-    const newCheckins = new Checkins({
-      checkins: [args.checkin],
-      deleted: []
-    });
+    const newCheckins = new Checkins();
+    newCheckins.checkins = [args.checkin];
     const mergedCheckins = exsitingCheckins.merge(newCheckins);
-    return new Attendee({ ...this,
-      checkin: { ...this.checkin,
-        [args.checkinTag]: mergedCheckins
-      }
-    });
+    const newAttendee = new Attendee(this.toJSON());
+    newAttendee.checkin = { ...this.checkin,
+      [args.checkinTag]: mergedCheckins
+    };
+    return newAttendee;
   }
 
   deleteCheckinForTag(args) {
@@ -90,55 +84,15 @@ export class Attendee {
       deleted: [args.checkinId]
     });
     const mergedCheckins = exsitingCheckins.merge(deletedCheckins);
-    return new Attendee({ ...this,
-      checkin: { ...this.checkin,
-        [args.checkinTag]: mergedCheckins
-      }
-    });
+    const newAttendee = new Attendee(this.toJSON());
+    newAttendee.checkin = { ...this.checkin,
+      [args.checkinTag]: mergedCheckins
+    };
+    return newAttendee;
   }
 
   hasRsvp(args) {
     return args.checkinTags.some(checkinTag => this.getResponseForTag(checkinTag) !== 'no-response');
   }
 
-}
-export const rawAttendee = object({
-  id: string(),
-  auth: maybe(string()),
-  userdata: dictionary(rawFieldValue),
-  tags: maybe(array(string())),
-  language: maybe(string()),
-  time: pipe(string()).pipe(parseDate({
-    iso: true
-  })),
-  rsvp: dictionary(maybe(number())),
-  checkin: dictionary(checkins),
-  companions: union(object({
-    isCompanion: constant(false)
-  }), object({
-    isCompanion: constant(true),
-    mainGuestId: string()
-  })),
-  payment: defaultTo(maybe(object({
-    paid: boolean(),
-    provider: enumerate('credit', 'paypal'),
-    amount: number({
-      integer: true
-    }),
-    testmode: boolean()
-  })), null),
-  deleted: defaultTo(boolean(), false)
-}, {
-  allowExcessProperties: true
-});
-const rawAttendeeList = array(rawAttendee);
-export const parseAttendee = value => {
-  const result = apiValidator(rawAttendee)(value);
-  if (!result.success) return result;
-  return success(new Attendee(result.data));
-};
-export const parseAttendeeList = value => {
-  const result = apiValidator(rawAttendeeList)(value);
-  if (!result.success) return result;
-  return success(result.data.map(rawAttendee => new Attendee(rawAttendee)));
-};
+}

package/dist/models/checkin-counts.d.ts

@@ -1,10 +1,4 @@
-import { ValidatorReturnType } from 'fefe';
-export declare const checkinCounts: (value: unknown) => import("fefe").Result<import("./_helpers").Dictionary<import("fefe").ObjectResult<{
-    checkins: import("fefe").Validator<number, import("fefe").LeafError>;
-    rsvp: import("fefe").Validator<number, import("fefe").LeafError>;
-}>>, import("fefe").FefeError>;
-export declare type CheckinCounts = ValidatorReturnType<typeof checkinCounts>;
-export declare const parseCheckinCounts: import("../lib").APIValidator<import("./_helpers").Dictionary<import("fefe").ObjectResult<{
-    checkins: import("fefe").Validator<number, import("fefe").LeafError>;
-    rsvp: import("fefe").Validator<number, import("fefe").LeafError>;
-}>>>;
+import { components } from '../generated/api-schema';
+export declare type CheckinCounts = {
+    [checkinTag: string]: components['schemas']['CheckinCount'];
+};

package/dist/models/checkin-counts.js

@@ -1,10 +1 @@
-import { number, object } from 'fefe';
-import { apiValidator } from '../lib';
-import { dictionary } from './_helpers';
-export const checkinCounts = dictionary(object({
-  checkins: number(),
-  rsvp: number()
-}, {
-  allowExcessProperties: true
-}));
-export const parseCheckinCounts = apiValidator(checkinCounts);
+export {};

package/dist/models/checkin.d.ts

@@ -0,0 +1,9 @@
+import { components } from '../generated/api-schema';
+export declare type CheckinJSON = components['schemas']['Checkin'];
+export declare class Checkin {
+    id: string;
+    time: Date;
+    main: boolean;
+    constructor(json: CheckinJSON);
+    toJSON(): CheckinJSON;
+}

package/dist/models/checkin.js

@@ -0,0 +1,16 @@
+export class Checkin {
+  constructor(json) {
+    this.id = json.id;
+    this.time = new Date(json.time);
+    this.main = json.main;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      time: this.time.toISOString(),
+      main: this.main
+    };
+  }
+
+}

package/dist/models/checkins.d.ts

@@ -1,41 +1,13 @@
-import { Result as FefeResult, ValidatorReturnType } from 'fefe';
-export declare type Checkin = {
-    id: string;
-    time: Date;
-    main: boolean;
-};
-export declare type CheckinsJSON = {
-    checkins: {
-        id: string;
-        time: string;
-        main: boolean;
-    }[];
-    deleted: string[];
-};
+import { components } from '../generated/api-schema';
+import { Checkin } from './checkin';
+export declare type CheckinsJSON = components['schemas']['Checkins'];
 export declare class Checkins {
     checkins: Checkin[];
     deleted: string[];
-    constructor(rawCheckins: RawCheckins);
-    static fromJSON(json: CheckinsJSON): Checkins;
+    constructor(json?: CheckinsJSON);
     toJSON(): CheckinsJSON;
     getAllCheckins(): Checkin[];
     getOtherCheckins(): Checkin[];
     getMainCheckin(): Checkin | undefined;
     merge(otherCheckin: Checkins): Checkins;
 }
-export declare const checkin: import("fefe").Validator<import("fefe").ObjectResult<{
-    id: import("fefe").Validator<string, import("fefe").LeafError>;
-    time: import("fefe").Pipe<unknown, Date>;
-    main: import("fefe").Validator<boolean, import("fefe").LeafError>;
-}>, import("fefe").FefeError>;
-declare const rawCheckins: import("fefe").Validator<import("fefe").ObjectResult<{
-    checkins: import("fefe").Validator<import("fefe").ObjectResult<{
-        id: import("fefe").Validator<string, import("fefe").LeafError>;
-        time: import("fefe").Pipe<unknown, Date>;
-        main: import("fefe").Validator<boolean, import("fefe").LeafError>;
-    }>[], import("fefe").FefeError>;
-    deleted: import("fefe").Validator<string[], import("fefe").FefeError>;
-}>, import("fefe").FefeError>;
-declare type RawCheckins = ValidatorReturnType<typeof rawCheckins>;
-export declare const checkins: (value: unknown) => FefeResult<Checkins>;
-export {};

package/dist/models/checkins.js

@@ -1,27 +1,19 @@
-import { array, boolean, isFailure, object, parseDate, pipe, string, success as fefeSuccess } from 'fefe';
 import { notUndefined } from '../lib';
+import { Checkin } from './checkin';
 export class Checkins {
-  constructor(rawCheckins) {
-    this.checkins = rawCheckins.checkins;
-    this.deleted = rawCheckins.deleted;
-  }
+  checkins = [];
+  deleted = [];
 
-  static fromJSON(json) {
-    return new Checkins({
-      checkins: json.checkins.map(checkin => ({ ...checkin,
-        time: new Date(checkin.time)
-      })),
-      deleted: json.deleted
-    });
+  constructor(json) {
+    // if constructor is called without params use default values
+    if (!json) return;
+    this.checkins = json.checkins.map(checkinJSON => new Checkin(checkinJSON));
+    this.deleted = json.deleted;
   }
 
   toJSON() {
     return {
-      checkins: this.checkins.map(checkin => ({
-        id: checkin.id,
-        time: checkin.time.toISOString(),
-        main: checkin.main
-      })),
+      checkins: this.checkins.map(checkin => checkin.toJSON()),
       deleted: this.deleted
     };
   }
@@ -43,30 +35,10 @@ export class Checkins {
   merge(otherCheckin) {
     const checkins = new Map([...this.checkins, ...otherCheckin.checkins].map(checkin => [checkin.id, checkin])).values();
     const deleted = new Set([...this.deleted, ...otherCheckin.deleted]);
-    return new Checkins({
-      checkins: Array.from(checkins),
-      deleted: Array.from(deleted)
-    });
+    const newCheckins = new Checkins();
+    newCheckins.checkins = Array.from(checkins);
+    newCheckins.deleted = Array.from(deleted);
+    return newCheckins;
   }
 
-}
-export const checkin = object({
-  id: string(),
-  time: pipe(string()).pipe(parseDate({
-    iso: true
-  })),
-  main: boolean()
-}, {
-  allowExcessProperties: true
-});
-const rawCheckins = object({
-  checkins: array(checkin),
-  deleted: array(string())
-}, {
-  allowExcessProperties: true
-});
-export const checkins = value => {
-  const result = rawCheckins(value);
-  if (isFailure(result)) return result;
-  return fefeSuccess(new Checkins(result.right));
-};
+}

package/dist/models/event.d.ts

@@ -1,40 +1,2 @@
-import { AttendeeJSON } from './attendee';
-import { Checkin } from './checkins';
-export declare type Event = {
-    id: string;
-    event: 'checkin-created';
-    instanceName: string;
-    attendeeId: string;
-    checkinTag: string;
-    checkin: Checkin;
-} | {
-    id: string;
-    event: 'checkin-deleted';
-    instanceName: string;
-    attendeeId: string;
-    checkinTag: string;
-    checkinId: string;
-} | {
-    id: string;
-    event: 'attendee-created';
-    instanceName: string;
-    attendee: AttendeeJSON;
-} | {
-    id: string;
-    event: 'attendee-updated';
-    instanceName: string;
-    attendeeId: string;
-    updates: Partial<Omit<AttendeeJSON, 'id' | 'checkin'>>;
-} | {
-    id: string;
-    event: 'attendee-responded';
-    instanceName: string;
-    attendeeId: string;
-    rsvp: Record<string, number | null>;
-    isEdit?: boolean;
-} | {
-    id: string;
-    event: 'payment-paid';
-    instanceName: string;
-    attendeeId: string;
-};
+import { components } from '../generated/api-schema';
+export declare type Event = components['schemas']['EventList'][number];