@lcas58/esmi-api-types 1.0.8 → 1.0.10

package/dist/src/routes/events/events.handlers.d.ts

@@ -1,20 +1,4 @@
 import type { AppRouteHandler } from "../../lib/types.js";
-import type { CreateRoute, GetCountStatsRoute, ListRoute, PatchRoute } from "./events.routes.js";
-/**
- * GET /events
- * - Returns a list of events
- */
+import type { GetOneRoute, ListRoute } from "./events.routes.js";
 export declare const list: AppRouteHandler<ListRoute>;
-/**
- * POST /events
- * - Idempotently upserts the optional location
- * - Inserts the event in a single transaction
- * - Returns 201 + created entity
- */
-export declare const create: AppRouteHandler<CreateRoute>;
-/**
- * PATCH /events/{id}
- * - Updates the event
- */
-export declare const patch: AppRouteHandler<PatchRoute>;
-export declare const getCountStats: AppRouteHandler<GetCountStatsRoute>;
+export declare const getOne: AppRouteHandler<GetOneRoute>;

package/dist/src/routes/events/events.handlers.js

@@ -1,177 +1,47 @@
-import { and, eq, sql } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import * as HttpStatusCodes from "stoker/http-status-codes";
 import * as HttpStatusPhrases from "stoker/http-status-phrases";
 import { createDb } from "../../db/index.js";
-import event from "../../db/schema/event.js";
-import location from "../../db/schema/location.js";
-import { ZOD_ERROR_CODES, ZOD_ERROR_MESSAGES } from "../../lib/constants.js";
-/**
- * GET /events
- * - Returns a list of events
- */
+import { event } from "../../db/schema/index.js";
 export const list = async (c) => {
     const { db } = createDb(c.env);
-    const { type, organizationId, status } = c.req.valid("query");
-    // Build where conditions
+    const query = c.req.valid("query");
+    const { sportId, source } = query;
+    const limit = query.limit ?? 20;
+    const offset = query.offset ?? 0;
     const whereConditions = [];
-    if (type) {
-        whereConditions.push(eq(event.type, type));
+    if (sportId) {
+        whereConditions.push(eq(event.sportId, sportId));
     }
-    if (status) {
-        whereConditions.push(eq(event.status, status));
-    }
-    if (organizationId) {
-        whereConditions.push(eq(event.organizationId, organizationId));
+    if (source) {
+        whereConditions.push(eq(event.source, source));
     }
     const events = await db.query.event.findMany({
         where: whereConditions.length > 0 ? and(...whereConditions) : undefined,
         with: {
-            creator: true,
-            organization: true,
+            sport: true,
             location: true,
+            externalLink: true,
         },
+        limit,
+        offset,
+        orderBy: (event, { desc }) => [desc(event.startsAt)],
     });
-    if (events.length === 0) {
-        return c.json({
-            message: HttpStatusPhrases.NOT_FOUND,
-        }, HttpStatusCodes.NOT_FOUND);
-    }
     return c.json(events, HttpStatusCodes.OK);
 };
-/**
- * POST /events
- * - Idempotently upserts the optional location
- * - Inserts the event in a single transaction
- * - Returns 201 + created entity
- */
-export const create = async (c) => {
-    const { db } = createDb(c.env);
-    const data = c.req.valid("json");
-    const user = c.get("user");
-    if (!user) {
-        return c.json({ message: HttpStatusPhrases.UNAUTHORIZED }, HttpStatusCodes.UNAUTHORIZED);
-    }
-    try {
-        // Insert location first (if provided)
-        if (data.location) {
-            const loc = data.location;
-            await db
-                .insert(location)
-                .values({
-                id: loc.id,
-                provider: loc.provider,
-                name: loc.name,
-                formattedAddress: loc.formattedAddress,
-                city: loc.city,
-                state: loc.state,
-                country: loc.country,
-                postalCode: loc.postalCode,
-                latitude: loc.latitude ? Number.parseFloat(loc.latitude) : null,
-                longitude: loc.longitude ? Number.parseFloat(loc.longitude) : null,
-            })
-                .onConflictDoNothing({ target: location.id });
-        }
-        // Insert event
-        const [createdEvent] = await db
-            .insert(event)
-            .values({
-            name: data.name.trim(),
-            description: data.description ?? null,
-            locationId: data.location?.id ?? null,
-            type: data.type,
-            organizationId: data.organizationId,
-            creatorId: user.id,
-            mode: "ADULT",
-            ageGroup: data.ageGroup,
-            gender: data.gender,
-            status: "WIP",
-        })
-            .returning();
-        const eventWithRelations = await db.query.event.findFirst({
-            where: eq(event.id, createdEvent.id),
-            with: {
-                creator: true,
-                organization: true,
-                location: true,
-            },
-        });
-        return c.json(eventWithRelations, HttpStatusCodes.CREATED);
-    }
-    catch (err) {
-        console.error("Error creating event:", err);
-        return c.json({
-            success: false,
-            error: {
-                issues: [
-                    {
-                        code: "CREATE_EVENT_FAILED",
-                        path: [],
-                        message: err instanceof Error ? err.message : "Failed to create event.",
-                    },
-                ],
-                name: "ValidationError",
-            },
-        }, HttpStatusCodes.UNPROCESSABLE_ENTITY);
-    }
-};
-/**
- * PATCH /events/{id}
- * - Updates the event
- */
-export const patch = async (c) => {
+export const getOne = async (c) => {
     const { db } = createDb(c.env);
     const { id } = c.req.valid("param");
-    const updates = c.req.valid("json");
-    if (Object.keys(updates).length === 0) {
-        return c.json({
-            success: false,
-            error: {
-                issues: [
-                    {
-                        code: ZOD_ERROR_CODES.INVALID_UPDATES,
-                        path: [],
-                        message: ZOD_ERROR_MESSAGES.NO_UPDATES,
-                    },
-                ],
-                name: "ZodError",
-            },
-        }, HttpStatusCodes.UNPROCESSABLE_ENTITY);
-    }
-    const [updatedEvent] = await db.update(event)
-        .set(updates)
-        .where(eq(event.id, id))
-        .returning();
-    if (!updatedEvent) {
-        return c.json({
-            message: HttpStatusPhrases.NOT_FOUND,
-        }, HttpStatusCodes.NOT_FOUND);
-    }
-    // Fetch the updated event with relations
-    const eventWithRelations = await db.query.event.findFirst({
-        where: eq(event.id, updatedEvent.id),
+    const foundEvent = await db.query.event.findFirst({
+        where: eq(event.id, id),
         with: {
-            creator: true,
-            organization: true,
+            sport: true,
             location: true,
+            externalLink: true,
         },
     });
-    return c.json(eventWithRelations, HttpStatusCodes.OK);
-};
-export const getCountStats = async (c) => {
-    const { db } = createDb(c.env);
-    const { organizationId } = c.req.valid("query");
-    // Single optimized query to get all counts at once
-    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-    const oneYearAgo = new Date(Date.now() - 360 * 24 * 60 * 60 * 1000);
-    const [stats] = await db
-        .select({
-        total: sql `count(case when ${event.status} in ('IN_PROGRESS', 'PUBLISHED', 'COMPLETED') then 1 end)`,
-        thisMonth: sql `count(case when ${event.createdAt} >= ${thirtyDaysAgo} and ${event.status} in ('IN_PROGRESS', 'PUBLISHED', 'COMPLETED') then 1 end)`,
-        inProgress: sql `count(case when ${event.status} = 'IN_PROGRESS' then 1 end)`,
-        completed: sql `count(case when ${event.status} = 'COMPLETED' and ${event.createdAt} >= ${oneYearAgo} then 1 end)`,
-        upcoming: sql `count(case when ${event.status} = 'PUBLISHED' and ${event.createdAt} >= ${thirtyDaysAgo} then 1 end)`,
-    })
-        .from(event)
-        .where(eq(event.organizationId, organizationId));
-    return c.json(stats, HttpStatusCodes.OK);
+    if (!foundEvent) {
+        return c.json({ message: HttpStatusPhrases.NOT_FOUND }, HttpStatusCodes.NOT_FOUND);
+    }
+    return c.json(foundEvent, HttpStatusCodes.OK);
 };