@bash-app/bash-common 1.0.13 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash-app/bash-common",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "Common data and scripts to use on the frontend and backend",
   "type": "module",
   "main": "src/index.ts",
@@ -21,7 +21,9 @@
     "typescript": "^5.2.2"
   },
   "peerDependencies": {
-    "tsx": "^4.10.3"
+    "tsx": "^4.10.3",
+    "dayjs": "^1.11.10",
+    "react-tailwindcss-datepicker": "^1.6.6"
   },
   "devDependencies": {
     "@prisma/client": "^5.13.0",

package/prisma/schema.prisma

@@ -767,22 +767,48 @@ model AssociatedBash {
 }
 
 model Service {
-  id             String        @id @default(cuid())
-  ownerId        String
-  owner          User          @relation(fields: [ownerId], references: [id], onDelete: Cascade)
-  name           String?
-  coverPhoto     String?
-  media          Media[]
-  serviceType    ServiceType
-  subServiceType String?
-  serviceLinks   ServiceLink[]
-  address        String
-  description    String?
-  canContact     Boolean?
-  genre          GenreType?
-}
-
-enum GenreType {
+  id                 String               @id @default(cuid())
+  ownerId            String
+  owner              User                 @relation(fields: [ownerId], references: [id], onDelete: Cascade)
+  name               String?
+  coverPhoto         String?
+  media              Media[]
+  serviceType        ServiceType[]
+  subServiceType     String?
+  serviceLinks       ServiceLink[]
+  address            String
+  description        String?
+  canContact         Boolean?
+  musicGenre         MusicGenreType?
+  visibility         VisibilityPreference @default(Public)
+  bashesInterestedIn BashEventType[]
+  crowdSizeId        String               @unique
+  crowdSize          ServiceRange         @relation("CrowdSize", fields: [crowdSizeId], references: [id], onDelete: Cascade)
+  serviceRangeId     String               @unique
+  serviceRange       ServiceRange         @relation("ServiceRange", fields: [serviceRangeId], references: [id], onDelete: Cascade)
+  availableDateTimes DateTime?
+}
+
+model ServiceRange {
+  id           String   @id @default(cuid())
+  minimum      Int?
+  maximum      Int?
+  crowdSize    Service? @relation("CrowdSize")
+  serviceRange Service? @relation("ServiceRange")
+}
+
+model Availability {
+    id           String   @id @default(cuid())
+  startDateTime String
+  endDateTime String
+}
+
+enum VisibilityPreference {
+  Public
+  Private
+}
+
+enum MusicGenreType {
   Classical
   Rock
   HipHop
@@ -873,8 +899,8 @@ model VendorLink {
 
 model ServiceLink {
   id         String  @id @default(cuid())
-  service    Service @relation(fields: [servicesId], references: [id], onDelete: Cascade)
-  link       Link    @relation(fields: [linkId], references: [id], onDelete: Cascade)
   servicesId String
+  service    Service @relation(fields: [servicesId], references: [id], onDelete: Cascade)
   linkId     String
+  link       Link    @relation(fields: [linkId], references: [id], onDelete: Cascade)
 }

package/src/definitions.ts

@@ -40,6 +40,11 @@ export const URL_PARAMS_GOOGLE_ACCESS_CODE = 'code' as const;
 export const URL_PARAMS_LINKED_IN_CODE = 'code' as const;
 export const URL_PARAMS_STATE = 'state' as const;
 
+export const URL_PARAMS_TICKET_LIST_DELIM = ',' as const;
+export const URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM = '__' as const
+export const URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM = '~~' as const
+export const URL_PARAMS_TICKETS_DATE_DELIM = ';;' as const
+
 export const URL_INCLUDE_QUERY_PARAM_DELIM = ',' as const;
 export const URL_INCLUDE_PRISMA_DATA_KEYS_DELIM = '.' as const;
 
@@ -56,6 +61,7 @@ export const ASSET_KEY_DELIM = '__' as const;
 export const ASSET_MAX_MD5_BYTE_LENGTH = 1024 * 100; // 100kb
 
 
+
 export type DateTimeArgType = Date | string | undefined | null;
 export type RequiredStripeInfoMissingErrorDataType = { [k in keyof User]?: { type: string, label: string } };
 

package/src/index.ts

@@ -1,2 +1,5 @@
 export * from "./extendedSchemas";
 export * from "./definitions";
+export * from "./utils/ticketListUtils";
+export * from "./utils/dateTimeUtils";
+export * from "./utils/recurrenceUtils";

package/src/utils/dateTimeUtils.ts

@@ -0,0 +1,177 @@
+import {DateType, DateValueType} from "react-tailwindcss-datepicker";
+import dayjs from "dayjs";
+import dayjsUtc from "dayjs/plugin/utc";
+import dayjsTimeZone from "dayjs/plugin/timezone";
+import {DateTimeArgType} from "../definitions";
+
+dayjs.extend(dayjsUtc);
+dayjs.extend(dayjsTimeZone);
+
+
+const PARSE_TIME_REG = /^(\d{1,2}):(\d{2}) ?([APM]{0,2})$/i;
+
+export const DATETIME_FORMAT_STANDARD = "MMM D, YYYY - h:mm A";
+export const DATETIME_FORMAT_ISO_LIKE = "YYYY-MM-DD HH:mm"
+export const DATE_FORMAT_STANDARD = "MM/DD/YYYY";
+export const DATE_FORMAT_ISO = "YYYY-MM-DD";
+export const TIME_FORMAT_AM_PM = "hh:mm A";
+
+export interface ITime {
+  hours: number;
+  minutes: number;
+  ampm: string;
+}
+
+export function ensureIsDateTime(possiblyADate: DateTimeArgType): Date | undefined {
+  if (!possiblyADate) {
+    return undefined;
+  }
+  return typeof possiblyADate === 'string' ? new Date(possiblyADate) : possiblyADate;
+}
+
+export function normalizeDate(validDate: Date | string | undefined | null): Date | undefined {
+  if (validDate) {
+    if (typeof validDate === 'string') {
+      validDate = new Date(validDate);
+    }
+    validDate.setHours(validDate.getHours(), validDate.getMinutes(), 0);
+    return validDate;
+  }
+}
+
+export function normalizeDates(dates: Date[]): Date[] {
+  return dates
+    .map((date): Date | undefined => {
+      return normalizeDate(date);
+    })
+    .filter((dateTime: Date | undefined): boolean => {
+      return !!dateTime
+    }) as Date[];
+}
+
+export function formatDateTimeToISODateTimeString(date: DateTimeArgType): string | undefined {
+  if (!date) {
+    return undefined;
+  }
+  date = new Date(date);
+  return date.toISOString();
+}
+
+export function dateWithinDateRange(date: DateTimeArgType, dateRange: DateValueType | undefined): boolean {
+  const startDate = dayjs(dateRange?.startDate).startOf('day').toDate();
+  const endDate = dayjs(dateRange?.endDate).endOf('day').toDate();
+
+  return compareDateTime(date, startDate) >= 0 &&
+    compareDateTime(date, endDate) < 0;
+}
+
+export function findLatestDateTime(date1Arg: DateTimeArgType, date2Arg: DateTimeArgType): Date | undefined {
+  const date1 = dateTimeTypeToDate(date1Arg);
+  const date2 = dateTimeTypeToDate(date2Arg);
+  return compareDateTime(date1, date2) > 0 ? date1 : date2;
+}
+
+function dateTimeTypeToDate(date: DateTimeArgType): Date | undefined {
+  if (typeof date === 'string') {
+    return new Date(date);
+  }
+  else {
+    return date ?? undefined;
+  }
+}
+
+export function isDateTimeLaterThanNow(date: DateTimeArgType): boolean {
+  return compareDateTime(date, new Date()) > 0;
+}
+
+export function areDateTimesEqual(date1: DateTimeArgType,
+                                  date2: DateTimeArgType): boolean {
+  return compareDateTime(date1, date2) === 0;
+}
+
+/**
+ * Returns a 1 if date1 is later than date2; 0 if both dates are equal; -1 if date2 is later than date1
+ * @param date1
+ * @param date2
+ */
+export function compareDateTime(date1: DateTimeArgType,
+                                date2: DateTimeArgType): number {
+  if (!date1 && !date2) {
+    return 0;
+  }
+  if (!date1) {
+    return -1;
+  }
+  if (!date2) {
+    return 1;
+  }
+  if (typeof date1 === 'string') {
+    date1 = new Date(date1);
+  }
+  if (typeof date2 === 'string') {
+    date2 = new Date(date2);
+  }
+
+  const date1Time = date1.getTime();
+  const date2Time = date2.getTime();
+
+  if (date1Time > date2Time) {
+    return 1;
+  }
+  if (date1Time === date2Time) {
+    return 0;
+  }
+  else {
+    return -1;
+  }
+}
+
+export function setDateButPreserveTime(dateArg: DateType, dateWithTheTimeYouWantToKeep: DateType | undefined): Date {
+  const date = dayjs(dateArg).format(DATE_FORMAT_ISO);
+  const time = dayjs(dateWithTheTimeYouWantToKeep).format(TIME_FORMAT_AM_PM);
+  const combinedDateTime = dayjs(date + " " + time).toDate();
+  return combinedDateTime;
+}
+
+export function setTimeOnDate(date: DateType | Date | undefined, parsedTime: ITime): Date {
+  const dateTime = new Date(date ?? Date.now());
+  const parsedTimeDate = new Date();
+  parsedTimeDate.setHours(parsedTime.hours, parsedTime.minutes, 0); // Will change the date depending on time; corrected later
+  const correctTimeOnDate = setDateButPreserveTime(dateTime, parsedTimeDate);
+  return correctTimeOnDate;
+}
+
+export function ensureDateTimeIsLocalDateTime(dateArg: DateType | undefined): Date {
+  if (dayjs(dateArg).isUTC()) {
+    const dateLocalTimeZone = dayjs(dateArg);
+    const date = dateLocalTimeZone.toDate();
+    return date;
+  }
+  else {
+    return new Date(dateArg ?? Date.now());
+  }
+}
+
+export function formatDateTimeToTimeString(date: Date | string | undefined | null): string {
+  date = new Date(date ?? Date.now());
+  const result = dayjs(date).format("h:mm A");
+  return result;
+}
+
+export function parseTimeString(timeStr: string): ITime | null {
+  const match = timeStr.match(PARSE_TIME_REG);
+
+  if (match) {
+    const hours = parseInt(match[1], 10);
+    const minutes = parseInt(match[2], 10);
+    const ampm = match[3].toUpperCase();
+
+    if ((hours >= 0 && hours <= 12) && (minutes >= 0 && minutes <= 59) && (ampm === 'AM' || ampm === 'PM')) {
+      return {
+        hours: ampm === 'PM' && hours < 12 ? hours + 12 : hours,
+        minutes,
+        ampm };
+    }
+  }
+  return null;
+}

package/src/utils/recurrenceUtils.ts

@@ -0,0 +1,175 @@
+import {DayOfWeek, Recurrence, RecurringFrequency} from "@prisma/client";
+import dayjs, {Dayjs} from "dayjs";
+import dayjsWeekDay from "dayjs/plugin/weekday";
+import {DateTimeArgType} from "../definitions";
+import {compareDateTime, DATETIME_FORMAT_ISO_LIKE} from "./dateTimeUtils";
+
+dayjs.extend(dayjsWeekDay);
+
+
+export function getRecurringBashEventPossibleDateTimes(startDateTime: DateTimeArgType,
+                                                       recurrence: Recurrence | undefined | null): Date[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, true) as Date[];
+}
+
+export function getRecurringBashEventPossibleDayjsTimes(startDateTime: DateTimeArgType,
+                                                        recurrence: Recurrence | undefined | null): Dayjs[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, false) as Dayjs[];
+}
+
+
+function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTimeArgType,
+                                                         recurrence: Recurrence | undefined | null,
+                                                         toDate: boolean): (Dayjs | Date)[] {
+  if (!recurrence || !recurrence.frequency || recurrence.frequency === RecurringFrequency.Never) {
+    return [];
+  }
+
+  let recurrenceDates: Dayjs[] = [];
+  const beginningDate = findEarliestPossibleBashEventDate(startDateTime) as Dayjs; // Don't allow dates before the current date
+
+  switch (recurrence.frequency) {
+    case RecurringFrequency.Weekly:
+      recurrenceDates = getWeeklyRecurringDates(beginningDate, recurrence);
+      break;
+    default:
+      console.error(`Only weekly frequency is currently supported`);
+  }
+  return recurrenceDates.map((date: Dayjs): string => date.format(DATETIME_FORMAT_ISO_LIKE))
+                        .sort()
+                        .map((dateStr: string): Dayjs | Date => {
+                          if (toDate) {
+                            return dayjs(dateStr).toDate();
+                          }
+                          else {
+                            return dayjs(dateStr);
+                          }
+                        });
+}
+
+/**
+ * Get the weekly recurring dates
+ * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.
+ * @param recurrence
+ */
+function getWeeklyRecurringDates(beginningDateTime: Dayjs, recurrence: Recurrence): Dayjs[] {
+  if (recurrence.frequency !== RecurringFrequency.Weekly) {
+    throw new Error(`Cannot do a weekly recurrence if the frequency isn't weekly.`);
+  }
+
+  const interval = recurrence.interval ?? 1;
+  const recurrenceEnds = dayjs(recurrence.ends).endOf('day'); // Get the end of the day to not miss the last day
+  const numberOfDays = recurrenceEnds.diff(beginningDateTime, 'days');
+  const numberOfWeeks = Math.ceil((numberOfDays / 7) / interval); // Get the number of days and then round up so that we include the ending date
+
+  const recurrenceDates: Dayjs[] = [];
+  let theNextWeekOfRecurrences = beginningDateTime;
+
+  // Go week by week getting the next recurrence date
+  for (let i = 0; i < numberOfWeeks; i++) {
+    let weekday: Dayjs | null = null;
+    for (const dayOfWeekEnum of recurrence.repeatOnDays) {
+      const dayOfWeekNum = dayOfWeekEnumToDayNumber(dayOfWeekEnum);
+      weekday = theNextWeekOfRecurrences.weekday(dayOfWeekNum);
+      if (weekday > recurrenceEnds || weekday < beginningDateTime) {
+        continue; // Continue because repeatOnDays isn't sorted by the day of the week
+      }
+      // Set the time on the date so that it matches the time when the event starts
+      weekday = copyTimeToDate(beginningDateTime, weekday);
+      recurrenceDates.push(weekday);
+    }
+    if (weekday) {
+      theNextWeekOfRecurrences = getBeginningOfWeekInterval(weekday, interval);
+    }
+  }
+  return recurrenceDates;
+}
+
+function copyTimeToDate(dateWithTimeToCopy: Dayjs, dateWhoseTimeToChange: Dayjs): Dayjs {
+  if (dateWithTimeToCopy.second() !== 0) {
+    console.warn(`dateWithTimeToCopy has non-zero seconds: ${dateWithTimeToCopy.toString()} \nFixing...`);
+    dateWithTimeToCopy = dateWithTimeToCopy.set('seconds', 0);
+  }
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('hours', dateWithTimeToCopy.hour());
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('minutes', dateWithTimeToCopy.minute());
+  dateWhoseTimeToChange = dateWhoseTimeToChange.set('seconds', 0); // Should be 0
+  return dateWhoseTimeToChange;
+}
+
+function dayOfWeekEnumToDayNumber(dayEnum: DayOfWeek): number {
+  switch (dayEnum) {
+    case DayOfWeek.Sunday:
+      return 0;
+    case DayOfWeek.Monday:
+      return 1;
+    case DayOfWeek.Tuesday:
+      return 2;
+    case DayOfWeek.Wednesday:
+      return 3;
+    case DayOfWeek.Thursday:
+      return 4;
+    case DayOfWeek.Friday:
+      return 5;
+    case DayOfWeek.Saturday:
+      return 6;
+    default:
+      throw new Error(`How did this happen? Invalid DayOfWeek: ${dayEnum}`); // Shouldn't happen
+  }
+}
+
+/**
+ * Get the next week determined by the interval by going to the end of the week interval and adding one day
+ * @param date
+ * @param interval
+ */
+function getBeginningOfWeekInterval(date: Dayjs, interval: number): Dayjs {
+  if (!interval) {
+    interval = 1; // Avoid 0
+  }
+  // An interval of 2 would be (2 - 1) * 7 + 1 = 8 days to add to skip a week and go into the next week
+  const numberOfDaysToAdd = interval > 1 ? (interval - 1) * 7 + 1 : 1;
+  return date.endOf('week').add(numberOfDaysToAdd, 'day');
+}
+
+export function freqToGrammarString(freq: RecurringFrequency, interval: number | undefined, toLowerCase: boolean = false): string {
+  if (!interval) {
+    return freq;
+  }
+  const isPlural = interval > 1;
+  let result: string = freq;
+  switch (freq) {
+    case RecurringFrequency.Daily:
+      result = isPlural ? 'Days' : 'Day';
+      break;
+    case RecurringFrequency.Weekly:
+      result = isPlural ? 'Weeks' : 'Week';
+      break;
+    case RecurringFrequency.Monthly:
+      result = isPlural ? 'Months' : 'Month';
+      break;
+    case RecurringFrequency.Yearly:
+      result = isPlural ? 'Years' : 'Year';
+      break;
+  }
+  return toLowerCase ? result.toLowerCase() : result;
+}
+
+export function findEarliestPossibleBashEventDate(startDateTimeArg: DateTimeArgType): Dayjs | undefined {
+  return findEarliestOrLatestPossibleBashEventDate(startDateTimeArg, true);
+}
+
+function findEarliestOrLatestPossibleBashEventDate(startDateTimeArg: DateTimeArgType, findEarly: boolean): Dayjs | undefined {
+  if (!startDateTimeArg) {
+    return;
+  }
+  // Don't allow dates before the current date
+  const startDateTime = dayjs(startDateTimeArg);
+  const currentDateTime = dayjs();
+  const comparedDateTime = compareDateTime(currentDateTime.toDate(), startDateTimeArg);
+  if (findEarly) {
+    return comparedDateTime > 0 ? currentDateTime : startDateTime;
+  }
+  else {
+    return comparedDateTime < 0 ? currentDateTime : startDateTime;
+  }
+}

package/src/utils/ticketListUtils.ts

@@ -0,0 +1,69 @@
+import dayjs from "dayjs";
+import {
+  NumberOfTicketsForDate,
+  URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKET_LIST_DELIM,
+  URL_PARAMS_TICKETS_DATE_DELIM
+} from "../definitions";
+import { DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
+
+
+/**
+ * Returns A string structured like: [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~,...
+ * @param ticketList A map where the key is the ticketTierId
+ */
+export function ticketListToString(ticketList: Map<string, NumberOfTicketsForDate[]>): string {
+  const ticketListArr: string[] = [];
+
+  for (const [ticketTierId, ticketListArgs] of ticketList.entries()) {
+    const ticketArgs: string[] = [`${ticketTierId}${URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM}`];
+    for (const ticketNumAndDates of ticketListArgs) {
+      if (ticketNumAndDates.numberOfTickets > 0) {
+        ticketArgs.push(
+          `${ticketNumAndDates.numberOfTickets}${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.ticketDateTime}`);
+      }
+    }
+    ticketListArr.push(ticketArgs.join(URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM));
+  }
+  return ticketListArr.join(URL_PARAMS_TICKET_LIST_DELIM);
+}
+
+/**
+ * Returns map where the key is the ticketTierId
+ * @param ticketListStr A string structured like: [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...,...
+ */
+export function ticketListStrToTicketList(ticketListStr: string): Map<string, NumberOfTicketsForDate[]> {
+  const ticketList: Map<string, NumberOfTicketsForDate[]> = new Map();
+
+  // [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...,...
+  const ticketListArgs = ticketListStr.split(URL_PARAMS_TICKET_LIST_DELIM);
+
+  ticketListArgs.forEach((tierIdAndTicketNumbersAndDates: string): void => {
+    const ticketNumAndDatesArr: NumberOfTicketsForDate[] = [];
+    // [ticketTierId]__[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...
+    const [ticketTierId, ticketNumAndDatesStr] = tierIdAndTicketNumbersAndDates.split(URL_PARAMS_TICKET_ID_NUMBER_OF_TICKETS_DATE_DELIM);
+    // [numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...
+    const ticketNumAndDates = ticketNumAndDatesStr.split(URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM)
+                                                  .filter((ticketNumAndDateStr): boolean => !!ticketNumAndDateStr);
+
+    for (const ticketNumAndDateStr of ticketNumAndDates) {
+      // [numberOfTickets];;[date]
+      const [numberOfTickets, ticketDateTimeStr] = ticketNumAndDateStr.split(URL_PARAMS_TICKETS_DATE_DELIM);
+      let ticketDateTime: string | undefined;
+      if (!ticketDateTimeStr) {
+        ticketDateTime = undefined;
+      }
+      else {
+        ticketDateTime = dayjs(ticketDateTimeStr).format(DATETIME_FORMAT_ISO_LIKE);
+      }
+
+      ticketNumAndDatesArr.push({
+        numberOfTickets: parseInt(numberOfTickets),
+        ticketDateTime: ticketDateTime,
+      });
+    }
+    ticketList.set(ticketTierId, ticketNumAndDatesArr);
+  });
+  return ticketList;
+}