Implement validation constraints

package.json

@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "firebase": "^5.8.0",
-    "lodash": "^4.17.11"
+    "lodash": "^4.17.11",
+    "validate.js": "^0.12.0"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.120",

src/artworks/artwork.constraints.ts

@@ -0,0 +1,16 @@
+export const ARTWORK_CONSTRAINTS = {
+    title: {
+        presence: true
+    },
+    imageUrl: {
+        presence: true,
+        url: true
+    },
+    artistId: {
+        presence: true,
+        personExists: true
+    },
+    eventbriteId: {
+        presence: true
+    }
+};

src/artworks/artworks.repository.ts

@@ -3,6 +3,7 @@ import { Artwork } from './artwork';
 import { FirebaseArtwork } from './artwork.firebase';
 import { PeopleRepository } from '../people/people.repository';
 import { withId, QueryFilter, buildQuery } from '../utils';
+import { validators } from 'validate.js';
 import firebase from 'firebase';
 import _ from 'lodash';
 
@@ -25,6 +26,15 @@ export class ArtworksRepository {
         this.firebaseRepository = firebaseService;
         this.peopleRepository = peopleRepository;
         this.artworks = this.firebaseRepository.firestore.collection('artworks');
+
+        validators.artworkExists = (artworkId: string) => new Promise(async (resolve) => {
+            const doc = await this.artworks.doc(artworkId).get();
+            if (doc.exists) {
+                resolve();
+            } else {
+                resolve(`Artwork with ID ${artworkId} does not exist in Firebase`);
+            }
+        });
     }
 
     async getArtworks(

src/events/event.constraints.ts

@@ -0,0 +1,150 @@
+import { EVENT_STATUSES, PROFICIENCIES } from './event';
+
+export const PREREQUISITE_CONSTRAINTS = {
+    label: {
+        presence: true,
+    },
+    proficiency: {
+        presence: true,
+        inclusion: PROFICIENCIES
+    },
+    referenceUrl: {
+        presence: true,
+        url: true
+    }
+};
+
+export const DEPENDENCY_CONSTRAINTS = {
+    label: {
+        presence: true,
+    },
+    specification: {
+        presence: true,
+    },
+    referenceUrl: {
+        presence: true,
+        url: true
+    }
+};
+
+export const SPEAKER_CONSTRAINTS = {
+    personId: {
+        presence: true,
+        personExists: true
+    },
+    organisationId: {
+        presence: true,
+        organisationExists: true
+    },
+    position: {
+        presence: true
+    }
+};
+
+export const PUBLICATION_CONSTRAINTS = {
+    status: {
+        presence: true,
+        inclusion: EVENT_STATUSES
+    },
+    url: {
+        url: true
+    }
+};
+
+export const EVENT_CONSTRAINTS = {
+    tgif: {
+        presence: true,
+        numericality: {
+            onlyInteger: true,
+        },
+        tgifUnique: true
+    },
+    title: {
+        presence: true,
+        length: { maximum: 64 } // Facebook: 64, Eventbrite: 75
+    },
+    speakers: {
+        presence: true,
+        length: {
+            minimum: 1,
+            tooShort: 'needs to have at least 1 speaker',
+        },
+        array: {
+            constraints: SPEAKER_CONSTRAINTS
+        }
+    },
+    tagline: {
+        presence: true
+    },
+    bannerId: {
+        presence: true,
+        artworkExists: true
+    },
+    description: {
+        presence: true
+    },
+    prerequisites: {
+        presence: true,
+        array: {
+            constraints: PREREQUISITE_CONSTRAINTS
+        }
+    },
+    dependencies: {
+        presence: true,
+        array: {
+            constraints: DEPENDENCY_CONSTRAINTS
+        }
+    },
+    promotion: {
+        presence: true
+    },
+    venueId: {
+        presence: true,
+        locationExists: true
+    },
+    startTime: {
+        presence: true,
+        beforeTime: {
+            timeAttribute: 'endTime'
+        }
+    },
+    endTime: {
+        presence: true,
+        afterTime: {
+            timeAttribute: 'startTime'
+        }
+    },
+    githubUrl: {
+        presence: true,
+        url: true
+    },
+    status: {
+        presence: true,
+        inclusion: EVENT_STATUSES
+    },
+    isPublic: {
+        presence: true
+    },
+    isExternal: {
+        presence: true
+    },
+    hasFood: {
+        presence: true
+    },
+    hasDrinks: {
+        presence: true
+    },
+    remarks: {
+        presence: true
+    },
+    eventbrite: {
+        object: {
+            constraints: PUBLICATION_CONSTRAINTS
+        }
+    },
+    facebook: {
+        object: {
+            constraints: PUBLICATION_CONSTRAINTS
+        }
+    }
+};

src/events/event.ts

@@ -53,4 +53,6 @@ export class Publication {
 }
 
 export type Proficiency = 'basic' | 'intermediate' | 'advanced';
+export const PROFICIENCIES: Proficiency[] = ['basic', 'intermediate', 'advanced'];
 export type EventStatus = 'draft' | 'live' | 'completed';
+export const EVENT_STATUSES: EventStatus[] = ['draft', 'live', 'completed'];

src/events/events.repository.ts

@@ -6,6 +6,7 @@ import { FirebaseEvent, FirebaseEventSpeaker } from './event.firebase';
 import { OrganisationsRepository } from '../organisations/organisations.repository';
 import { ArtworksRepository } from '../artworks/artworks.repository';
 import { withId, QueryFilter, buildQuery } from '../utils';
+import { validators } from 'validate.js';
 import firebase from 'firebase';
 import _ from 'lodash';
 
@@ -38,6 +39,15 @@ export class EventsRepository {
         this.artworksRepository = artworksRepository;
 
         this.events = this.firebaseRepository.firestore.collection('events');
+
+        validators.tgifUnique = (tgif: number) => new Promise(async (resolve) => {
+            const doc = await this.events.where('tgif', '==', tgif).get();
+            if (doc.docs.length === 0) {
+                resolve();
+            } else {
+                resolve(`Event with TGIFHacks # ${tgif} already exists in Firebase`);
+            }
+        });
     }
 
     async getEvents(

src/hackoss.ts

@@ -1,18 +1,21 @@
-
-
 export * from './events/event';
+export * from './events/event.constraints';
 export * from './events/events.repository';
 
 export * from './locations/location';
+export * from './locations/location.constraints';
 export * from './locations/locations.repository';
 
 export * from './people/person';
+export * from './people/person.constraints';
 export * from './people/people.repository';
 
 export * from './organisations/organisation';
+export * from './organisations/organisation.constraints';
 export * from './organisations/organisations.repository';
 
 export * from './artworks/artwork';
+export * from './artworks/artwork.constraints';
 export * from './artworks/artworks.repository';
 
 export * from './firebase/firebase.config';

src/locations/location.constraints.ts

@@ -0,0 +1,25 @@
+export const LOCATION_CONSTRAINTS = {
+    name: {
+        presence: true
+    },
+    seatingCapacity: {
+        presence: true,
+        numericality: {
+            onlyInteger: true,
+            greaterThan: 0
+        }
+    },
+    addressLine1: {
+        presence: true
+    },
+    addressLine2: {
+        presence: true
+    },
+    imageUrl: {
+        presence: true,
+        url: true
+    },
+    eventbriteId: {
+        presence: true
+    },
+};

src/locations/locations.repository.ts

@@ -2,6 +2,7 @@ import { Location } from './location';
 import { FirebaseRepository } from '../firebase/firebase.repository';
 import { FirebaseLocation } from './location.firebase';
 import { withId, QueryFilter, buildQuery } from '../utils';
+import { validators } from 'validate.js';
 import firebase from 'firebase';
 import _ from 'lodash';
 
@@ -19,6 +20,15 @@ export class LocationsRepository {
     constructor(firebaseRepository: FirebaseRepository) {
         this.firebaseRepository = firebaseRepository;
         this.locations = this.firebaseRepository.firestore.collection('locations');
+
+        validators.locationExists = (locationId: string) => new Promise(async (resolve) => {
+            const doc = await this.locations.doc(locationId).get();
+            if (doc.exists) {
+                resolve();
+            } else {
+                resolve(`Location with ID ${locationId} does not exist in Firebase`);
+            }
+        });
     }
 
     async getLocations(

src/organisations/organisation.constraints.ts

@@ -0,0 +1,20 @@
+export const ORGANISATION_CONSTRAINTS = {
+    name: {
+        presence: true
+    },
+    about: {
+        presence: true
+    },
+    websiteUrl: {
+        presence: true,
+        url: true
+    },
+    avatarUrl: {
+        presence: true,
+        url: true
+    },
+    githubUrl: {
+        presence: true,
+        url: true
+    }
+};

src/organisations/organisations.repository.ts

@@ -2,6 +2,7 @@ import { FirebaseRepository } from '../firebase/firebase.repository';
 import { Organisation } from './organisation';
 import { FirebaseOrganisation } from './organisation.firebase';
 import { withId, QueryFilter, buildQuery } from '../utils';
+import { validators } from 'validate.js';
 import firebase from 'firebase';
 import _ from 'lodash';
 
@@ -19,6 +20,15 @@ export class OrganisationsRepository {
     constructor(firebaseService: FirebaseRepository) {
         this.firebaseRepository = firebaseService;
         this.organisations = this.firebaseRepository.firestore.collection('organisations');
+
+        validators.organisationExists = (organisationId: string) => new Promise(async (resolve) => {
+            const doc = await this.organisations.doc(organisationId).get();
+            if (doc.exists) {
+                resolve();
+            } else {
+                resolve(`Organisation with ID ${organisationId} does not exist in Firebase`);
+            }
+        });
     }
 
     async getOrganisations(

src/people/people.repository.ts

@@ -2,6 +2,7 @@ import { Person } from './person';
 import { FirebaseRepository } from '../firebase/firebase.repository';
 import { FirebasePerson } from './person.firebase';
 import { withId, QueryFilter, buildQuery } from '../utils';
+import { validators } from 'validate.js';
 import firebase from 'firebase';
 import _ from 'lodash';
 
@@ -19,6 +20,15 @@ export class PeopleRepository {
     constructor(firebaseService: FirebaseRepository) {
         this.firebaseRepository = firebaseService;
         this.people = this.firebaseRepository.firestore.collection('people');
+
+        validators.personExists = (personId: string) => new Promise(async (resolve) => {
+            const doc = await this.people.doc(personId).get();
+            if (doc.exists) {
+                resolve();
+            } else {
+                resolve(`Person with ID ${personId} does not exist in Firebase`);
+            }
+        });
     }
 
     async getPeople(