Adding schedule API :) (#246)

Con esta query podemos mostrar el programa para los 3 dias
```GQL
query e {
  event(id: "f4e59c2c-9385-4592-acfc-3e46fd1a167f") {
    id
    name
    description
    schedules {
      id
      title
      startTimestamp
      endTimestamp
      sessions {
        id
        title
        startTimestamp
        endTimestamp
        speakers {
          id
          avatar
          name
        }
      }
    }
  }
}

```

![image](https://github.com/user-attachments/assets/92fcd449-d981-40a5-9bb5-04095001eae9)

Author: fforres

src/schema/events/types.ts

@@ -3,7 +3,9 @@ import { SQL, eq, inArray } from "drizzle-orm";
 import { authHelpers } from "~/authz/helpers";
 import { builder } from "~/builder";
 import {
+  ScheduleStatus,
   selectCommunitySchema,
+  selectScheduleSchema,
   selectSpeakerSchema,
   selectTagsSchema,
   selectTeamsSchema,
@@ -17,6 +19,8 @@ import {
 } from "~/datasources/db/schema";
 import { getImagesBySanityEventId } from "~/datasources/sanity/images";
 import { eventsFetcher } from "~/schema/events/eventsFetcher";
+import { schedulesFetcher } from "~/schema/schedules/schedulesFetcher";
+import { ScheduleLoadable, ScheduleRef } from "~/schema/schedules/types";
 import {
   CommunityRef,
   EventRef,
@@ -300,6 +304,20 @@ export const EventLoadable = builder.loadableObject(EventRef, {
         return tickets.map((t) => selectTicketSchema.parse(t));
       },
     }),
+    schedules: t.field({
+      type: [ScheduleRef],
+      resolve: async (root, args, ctx) => {
+        const schedules = await schedulesFetcher.searchSchedules({
+          DB: ctx.DB,
+          search: {
+            eventIds: [root.id],
+            satus: ScheduleStatus.active,
+          },
+        });
+
+        return schedules.map((s) => selectScheduleSchema.parse(s));
+      },
+    }),
     usersTickets: t.field({
       description: "List of tickets that a user owns for this event.",
       type: [UserTicketRef],

src/schema/index.ts

@@ -29,6 +29,7 @@ import "./purchaseOrder/types";
 import "./salary/mutations";
 import "./salary/queries";
 import "./salary/types";
+import "./schedules/types";
 import "./sessions/types";
 import "./speakers/types";
 import "./status/types";

src/schema/schedules/schedulesFetcher.ts

@@ -0,0 +1,109 @@
+import { SQL, and, asc, desc, eq, ilike, inArray } from "drizzle-orm";
+
+import { ORM_TYPE } from "~/datasources/db";
+import { scheduleSchema, ScheduleStatus } from "~/datasources/db/schedule";
+import {
+  PaginationOptionsType,
+  paginationDBHelper,
+} from "~/datasources/helpers/paginationQuery";
+import { SortableSchemaFields } from "~/datasources/helpers/sorting";
+import { sanitizeForLikeSearch } from "~/schema/shared/helpers";
+
+export type SchedulesSearch = {
+  scheduleIds?: string[];
+  eventIds?: string[];
+  title?: string;
+  description?: string;
+  satus?: ScheduleStatus;
+};
+
+type SortableFields =
+  | "description"
+  | "title"
+  | "startTimestamp"
+  | "endTimestamp";
+type EventFetcherSort = SortableSchemaFields<SortableFields>;
+
+const getSearchSchedulesQuery = (
+  DB: ORM_TYPE,
+  search: SchedulesSearch = {},
+  sort: EventFetcherSort,
+) => {
+  const { scheduleIds, title, description, eventIds, satus } = search;
+
+  const wheres: SQL[] = [];
+  const query = DB.select().from(scheduleSchema);
+
+  if (scheduleIds && scheduleIds.length > 0) {
+    wheres.push(inArray(scheduleSchema.id, scheduleIds));
+  }
+
+  if (eventIds && eventIds.length > 0) {
+    wheres.push(inArray(scheduleSchema.eventId, eventIds));
+  }
+
+  if (title) {
+    wheres.push(ilike(scheduleSchema.title, sanitizeForLikeSearch(title)));
+  }
+
+  if (description) {
+    wheres.push(
+      ilike(scheduleSchema.description, sanitizeForLikeSearch(description)),
+    );
+  }
+
+  if (satus) {
+    wheres.push(eq(scheduleSchema.status, satus));
+  }
+
+  const orderBy: SQL<unknown>[] = [];
+
+  if (sort) {
+    const sorts = sort.map(([field, direction]) => {
+      const sortDirection = direction === "asc" ? asc : desc;
+
+      return sortDirection(scheduleSchema[field]);
+    });
+
+    orderBy.push(...sorts);
+  }
+
+  return query.where(and(...wheres)).orderBy(...orderBy);
+};
+
+const searchSchedules = async ({
+  DB,
+  search = {},
+  sort,
+}: {
+  DB: ORM_TYPE;
+  search: SchedulesSearch;
+  sort?: EventFetcherSort;
+}) => {
+  const schedules = await getSearchSchedulesQuery(DB, search, sort).execute();
+
+  return schedules;
+};
+
+const searchPaginatedSchedules = async ({
+  DB,
+  pagination,
+  search = {},
+  sort,
+}: {
+  DB: ORM_TYPE;
+  search: SchedulesSearch;
+  pagination: PaginationOptionsType;
+  sort?: EventFetcherSort;
+}) => {
+  const query = getSearchSchedulesQuery(DB, search, sort);
+
+  const results = await paginationDBHelper(DB, query, pagination);
+
+  return results;
+};
+
+export const schedulesFetcher = {
+  searchSchedules,
+  searchPaginatedSchedules,
+};

src/schema/schedules/types.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+
+import { builder } from "~/builder";
+import {
+  selectEventsSchema,
+  selectScheduleSchema,
+  selectSessionSchema,
+} from "~/datasources/db/schema";
+import { applicationError, ServiceErrors } from "~/errors";
+import { EventLoadable } from "~/schema/events/types";
+import { schedulesFetcher } from "~/schema/schedules/schedulesFetcher";
+import { sessionsFetcher } from "~/schema/sessions/sessionsFetcher";
+import { SessionRef } from "~/schema/sessions/types";
+import { EventRef } from "~/schema/shared/refs";
+
+type ScheduleraphqlSchema = z.infer<typeof selectScheduleSchema>;
+
+export const ScheduleRef = builder.objectRef<ScheduleraphqlSchema>("Schedule");
+
+export const ScheduleLoadable = builder.loadableObject(ScheduleRef, {
+  description: "Representation of a Schedule",
+  load: (ids: string[], context) =>
+    schedulesFetcher.searchSchedules({
+      DB: context.DB,
+      search: { scheduleIds: ids },
+    }),
+  fields: (t) => ({
+    id: t.exposeID("id", { nullable: false }),
+    title: t.exposeString("title", { nullable: false }),
+    description: t.exposeString("description", { nullable: true }),
+    startTimestamp: t.field({
+      type: "DateTime",
+      resolve: (root) => new Date(root.startTimestamp),
+    }),
+    endTimestamp: t.field({
+      type: "DateTime",
+      resolve: (root) => new Date(root.endTimestamp),
+    }),
+    event: t.field({
+      type: EventRef,
+      resolve: async (root, args, ctx) => {
+        const event = await EventLoadable.getDataloader(ctx).load(root.eventId);
+
+        if (!event) {
+          throw applicationError(
+            "Event not found",
+            ServiceErrors.NOT_FOUND,
+            ctx.logger,
+          );
+        }
+
+        return selectEventsSchema.parse(event);
+      },
+    }),
+    sessions: t.field({
+      type: [SessionRef],
+      resolve: async (root, args, ctx) => {
+        const sessions = await sessionsFetcher.searchSessions({
+          DB: ctx.DB,
+          search: {
+            scheduleIds: [root.id],
+          },
+          sort: [["startTimestamp", "asc"]],
+        });
+
+        return sessions.map((s) => selectSessionSchema.parse(s));
+      },
+    }),
+  }),
+});

src/schema/sessions/sessionsFetcher.ts

@@ -1,4 +1,4 @@
-import { SQL, and, asc, ilike, inArray } from "drizzle-orm";
+import { SQL, and, asc, desc, ilike, inArray } from "drizzle-orm";
 
 import { ORM_TYPE } from "~/datasources/db";
 import { sessionSchema } from "~/datasources/db/sessions";
@@ -7,6 +7,7 @@ import {
   PaginationOptionsType,
   paginationDBHelper,
 } from "~/datasources/helpers/paginationQuery";
+import { SortableSchemaFields } from "~/datasources/helpers/sorting";
 import { sanitizeForLikeSearch } from "~/schema/shared/helpers";
 
 export type SessionSearch = {
@@ -17,12 +18,16 @@ export type SessionSearch = {
   speakerIds?: string[];
 };
 
-type SortableType = null | undefined;
-
+type SortableFields =
+  | "description"
+  | "title"
+  | "startTimestamp"
+  | "endTimestamp";
+type EventFetcherSort = SortableSchemaFields<SortableFields>;
 const getSearchSessionsQuery = (
   DB: ORM_TYPE,
   search: SessionSearch = {},
-  sort: SortableType,
+  sort: EventFetcherSort,
 ) => {
   const { sessionIds, scheduleIds, title, description, speakerIds } = search;
 
@@ -59,8 +64,14 @@ const getSearchSessionsQuery = (
 
   const orderBy: SQL<unknown>[] = [];
 
-  if (sort !== null) {
-    orderBy.push(asc(sessionSchema.startTimestamp));
+  if (sort) {
+    const sorts = sort.map(([field, direction]) => {
+      const sortDirection = direction === "asc" ? asc : desc;
+
+      return sortDirection(sessionSchema[field]);
+    });
+
+    orderBy.push(...sorts);
   }
 
   return query.where(and(...wheres)).orderBy(...orderBy);
@@ -73,7 +84,7 @@ const searchSessions = async ({
 }: {
   DB: ORM_TYPE;
   search: SessionSearch;
-  sort?: SortableType;
+  sort?: EventFetcherSort;
 }) => {
   const sessions = await getSearchSessionsQuery(DB, search, sort).execute();
 
@@ -89,7 +100,7 @@ const searchPaginatedSessions = async ({
   DB: ORM_TYPE;
   search: SessionSearch;
   pagination: PaginationOptionsType;
-  sort?: SortableType;
+  sort?: EventFetcherSort;
 }) => {
   const query = getSearchSessionsQuery(DB, search, sort);
 

src/schema/sessions/types.ts

@@ -11,7 +11,7 @@ import { SpeakerRef } from "~/schema/speakers/types";
 
 type SessionGraphqlSchema = z.infer<typeof selectSessionSchema>;
 
-export const SessionRef = builder.objectRef<SessionGraphqlSchema>("SessionRef");
+export const SessionRef = builder.objectRef<SessionGraphqlSchema>("Session");
 
 export const SessionLoadable = builder.loadableObject(SessionRef, {
   description: "Representation of a Session",
@@ -25,11 +25,11 @@ export const SessionLoadable = builder.loadableObject(SessionRef, {
     title: t.exposeString("title", { nullable: false }),
     description: t.exposeString("description", { nullable: true }),
     startTimestamp: t.field({
-      type: "Date",
+      type: "DateTime",
       resolve: (root) => new Date(root.startTimestamp),
     }),
     endTimestamp: t.field({
-      type: "Date",
+      type: "DateTime",
       resolve: (root) => new Date(root.endTimestamp),
     }),
     speakers: t.field({