@lcas58/esmi-api-types 1.0.6 → 1.0.7

package/dist/src/app.d.ts

@@ -1154,5 +1154,5 @@ declare const routes: readonly [import("@hono/zod-openapi").OpenAPIHono<import("
         };
     };
 }, "/">];
-export { routes };
+export type { routes };
 export default app;

package/dist/src/app.js

@@ -19,5 +19,4 @@ const routes = [
 routes.forEach((route) => {
     app.route("/", route);
 });
-export { routes };
 export default app;

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

@@ -0,0 +1,20 @@
+import type { AppRouteHandler } from "../../lib/types.js";
+import type { CreateRoute, GetCountStatsRoute, ListRoute, PatchRoute } from "./events.routes.js";
+/**
+ * GET /events
+ * - Returns a list of events
+ */
+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>;

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

@@ -0,0 +1,177 @@
+import { and, eq, sql } 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
+ */
+export const list = async (c) => {
+    const { db } = createDb(c.env);
+    const { type, organizationId, status } = c.req.valid("query");
+    // Build where conditions
+    const whereConditions = [];
+    if (type) {
+        whereConditions.push(eq(event.type, type));
+    }
+    if (status) {
+        whereConditions.push(eq(event.status, status));
+    }
+    if (organizationId) {
+        whereConditions.push(eq(event.organizationId, organizationId));
+    }
+    const events = await db.query.event.findMany({
+        where: whereConditions.length > 0 ? and(...whereConditions) : undefined,
+        with: {
+            creator: true,
+            organization: true,
+            location: true,
+        },
+    });
+    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) => {
+    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),
+        with: {
+            creator: true,
+            organization: true,
+            location: 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);
+};