@lcas58/esmi-api-types 1.0.26 → 1.0.28

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

@@ -0,0 +1,205 @@
+import { and, count, eq, gte, ilike, lte, or, 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, group } from "../../db/schema/index.js";
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 255);
+}
+export const list = async (c) => {
+    const { db } = createDb(c.env);
+    const query = c.req.valid("query");
+    const { sportId, source, search } = query;
+    const limit = query.limit ?? 20;
+    const offset = query.offset ?? 0;
+    const city = query.city?.trim();
+    const state = query.state?.trim();
+    const whereConditions = [eq(group.isActive, true)];
+    if (sportId) {
+        whereConditions.push(eq(group.sportId, sportId));
+    }
+    if (source) {
+        whereConditions.push(eq(group.source, source));
+    }
+    if (city) {
+        whereConditions.push(ilike(group.city, city));
+    }
+    if (state) {
+        whereConditions.push(ilike(group.state, state));
+    }
+    if (search) {
+        whereConditions.push(or(ilike(group.name, `%${search}%`), ilike(group.description, `%${search}%`)));
+    }
+    const groups = await db.query.group.findMany({
+        where: and(...whereConditions),
+        with: {
+            sport: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                },
+            },
+        },
+        limit,
+        offset,
+        orderBy: (group, { asc }) => [asc(group.name)],
+    });
+    // Count events per group
+    const groupIds = groups.map(g => g.id);
+    let eventCounts = {};
+    if (groupIds.length > 0) {
+        const counts = await db
+            .select({
+            groupId: event.groupId,
+            count: count(),
+        })
+            .from(event)
+            .where(and(sql `${event.groupId} IN ${groupIds}`, gte(event.startsAt, new Date())))
+            .groupBy(event.groupId);
+        eventCounts = Object.fromEntries(counts.map(r => [r.groupId, r.count]));
+    }
+    const result = groups.map(g => ({
+        ...g,
+        _count: { events: eventCounts[g.id] ?? 0 },
+    }));
+    return c.json(result, HttpStatusCodes.OK);
+};
+export const getOne = async (c) => {
+    const { db } = createDb(c.env);
+    const { id } = c.req.valid("param");
+    const foundGroup = await db.query.group.findFirst({
+        where: eq(group.id, id),
+        with: {
+            sport: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                },
+            },
+        },
+    });
+    if (!foundGroup) {
+        return c.json({ message: HttpStatusPhrases.NOT_FOUND }, HttpStatusCodes.NOT_FOUND);
+    }
+    return c.json(foundGroup, HttpStatusCodes.OK);
+};
+export const getEvents = async (c) => {
+    const { db } = createDb(c.env);
+    const { id } = c.req.valid("param");
+    const query = c.req.valid("query");
+    const foundGroup = await db.query.group.findFirst({
+        where: eq(group.id, id),
+        columns: { id: true },
+    });
+    if (!foundGroup) {
+        return c.json({ message: HttpStatusPhrases.NOT_FOUND }, HttpStatusCodes.NOT_FOUND);
+    }
+    const limit = query.limit ?? 20;
+    const offset = query.offset ?? 0;
+    const whereConditions = [eq(event.groupId, id)];
+    if (query.from) {
+        whereConditions.push(gte(event.startsAt, query.from));
+    }
+    if (query.to) {
+        const to = new Date(query.to);
+        if (to.getUTCHours() === 0 && to.getUTCMinutes() === 0 && to.getUTCSeconds() === 0) {
+            to.setUTCHours(23, 59, 59, 999);
+        }
+        whereConditions.push(lte(event.startsAt, to));
+    }
+    const events = await db.query.event.findMany({
+        where: and(...whereConditions),
+        with: {
+            sport: true,
+            location: true,
+            externalLink: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                },
+            },
+        },
+        limit,
+        offset,
+        orderBy: (event, { asc }) => [asc(event.startsAt)],
+    });
+    return c.json(events, HttpStatusCodes.OK);
+};
+export const create = async (c) => {
+    const { db } = createDb(c.env);
+    const body = c.req.valid("json");
+    const user = c.get("user");
+    const slug = body.slug || slugify(body.name);
+    const [newGroup] = await db.insert(group).values({
+        name: body.name,
+        slug,
+        description: body.description,
+        source: "internal",
+        sportId: body.sportId,
+        city: body.city,
+        state: body.state,
+        imageUrl: body.imageUrl,
+        createdByUserId: user.id,
+    }).returning();
+    const result = await db.query.group.findFirst({
+        where: eq(group.id, newGroup.id),
+        with: {
+            sport: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                },
+            },
+        },
+    });
+    return c.json(result, HttpStatusCodes.OK);
+};
+export const update = async (c) => {
+    const { db } = createDb(c.env);
+    const { id } = c.req.valid("param");
+    const body = c.req.valid("json");
+    const user = c.get("user");
+    const existing = await db.query.group.findFirst({
+        where: eq(group.id, id),
+    });
+    if (!existing) {
+        return c.json({ message: HttpStatusPhrases.NOT_FOUND }, HttpStatusCodes.NOT_FOUND);
+    }
+    if (existing.source === "external") {
+        return c.json({ message: "Cannot update external groups" }, HttpStatusCodes.UNAUTHORIZED);
+    }
+    if (existing.createdByUserId !== user.id) {
+        return c.json({ message: HttpStatusPhrases.UNAUTHORIZED }, HttpStatusCodes.UNAUTHORIZED);
+    }
+    await db.update(group).set({
+        ...body,
+        updatedAt: new Date(),
+    }).where(eq(group.id, id));
+    const result = await db.query.group.findFirst({
+        where: eq(group.id, id),
+        with: {
+            sport: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                },
+            },
+        },
+    });
+    return c.json(result, HttpStatusCodes.OK);
+};

package/dist/src/routes/groups/groups.index.d.ts

@@ -0,0 +1,337 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/groups": {
+        $get: {
+            input: {
+                query: {
+                    search?: string | string[] | undefined;
+                    city?: string | string[] | undefined;
+                    state?: string | string[] | undefined;
+                    sportId?: string | string[] | undefined;
+                    source?: string | string[] | undefined;
+                    limit?: string | string[] | undefined;
+                    offset?: string | string[] | undefined;
+                };
+            };
+            output: {
+                id: string;
+                description: string | null;
+                name: string;
+                city: string | null;
+                state: string | null;
+                sportId: string;
+                createdAt: string;
+                sport: {
+                    id: string;
+                    name: string;
+                    icon: string | null;
+                } | null;
+                country: string;
+                source: "external" | "internal";
+                slug: string;
+                isActive: boolean;
+                sourceOrgId: string | null;
+                externalUrl: string | null;
+                updatedAt: string;
+                createdByUserId: string | null;
+                imageUrl: string | null;
+                creator: {
+                    image: string | null;
+                    id: string;
+                    name: string;
+                } | null;
+                _count?: {
+                    events: number;
+                } | undefined;
+            }[];
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/groups/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                id: string;
+                description: string | null;
+                name: string;
+                city: string | null;
+                state: string | null;
+                sportId: string;
+                createdAt: string;
+                sport: {
+                    id: string;
+                    name: string;
+                    icon: string | null;
+                } | null;
+                country: string;
+                source: "external" | "internal";
+                slug: string;
+                isActive: boolean;
+                sourceOrgId: string | null;
+                externalUrl: string | null;
+                updatedAt: string;
+                createdByUserId: string | null;
+                imageUrl: string | null;
+                creator: {
+                    image: string | null;
+                    id: string;
+                    name: string;
+                } | null;
+                _count?: {
+                    events: number;
+                } | undefined;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/groups/:id/events": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                query: {
+                    from?: string | string[] | undefined;
+                    to?: string | string[] | undefined;
+                    limit?: string | string[] | undefined;
+                    offset?: string | string[] | undefined;
+                };
+            };
+            output: {
+                metadata: any;
+                id: string;
+                title: string;
+                sportId: string;
+                createdAt: string;
+                sport: {
+                    id: string;
+                    name: string;
+                    icon: string | null;
+                } | null;
+                startsAt: string;
+                endsAt: string | null;
+                timezone: string;
+                location: {
+                    id: string;
+                    name: string;
+                    city: string | null;
+                    state: string | null;
+                    formattedAddress: string;
+                    latitude: number | null;
+                    longitude: number | null;
+                } | null;
+                locationId: string | null;
+                externalLinkId: string | null;
+                source: "external" | "community";
+                thumbnailUrl: string | null;
+                createdByUserId: string | null;
+                groupId: string | null;
+                creator: {
+                    image: string | null;
+                    id: string;
+                    name: string;
+                } | null;
+                externalLink: {
+                    url: string;
+                    id: string;
+                    domain: string;
+                } | null;
+            }[];
+            outputFormat: "text" | "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                query: {
+                    from?: string | string[] | undefined;
+                    to?: string | string[] | undefined;
+                    limit?: string | string[] | undefined;
+                    offset?: string | string[] | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 404;
+        };
+    };
+} & {
+    "/groups": {
+        $post: {
+            input: {
+                json: {
+                    name: string;
+                    sportId: string;
+                    description?: string | undefined;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    slug?: string | undefined;
+                    imageUrl?: string | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 401;
+        } | {
+            input: {
+                json: {
+                    name: string;
+                    sportId: string;
+                    description?: string | undefined;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    slug?: string | undefined;
+                    imageUrl?: string | undefined;
+                };
+            };
+            output: {
+                id: string;
+                description: string | null;
+                name: string;
+                city: string | null;
+                state: string | null;
+                sportId: string;
+                createdAt: string;
+                sport: {
+                    id: string;
+                    name: string;
+                    icon: string | null;
+                } | null;
+                country: string;
+                source: "external" | "internal";
+                slug: string;
+                isActive: boolean;
+                sourceOrgId: string | null;
+                externalUrl: string | null;
+                updatedAt: string;
+                createdByUserId: string | null;
+                imageUrl: string | null;
+                creator: {
+                    image: string | null;
+                    id: string;
+                    name: string;
+                } | null;
+                _count?: {
+                    events: number;
+                } | undefined;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/groups/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    description?: string | undefined;
+                    name?: string | undefined;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    imageUrl?: string | null | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    description?: string | undefined;
+                    name?: string | undefined;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    imageUrl?: string | null | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    description?: string | undefined;
+                    name?: string | undefined;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    imageUrl?: string | null | undefined;
+                };
+            };
+            output: {
+                id: string;
+                description: string | null;
+                name: string;
+                city: string | null;
+                state: string | null;
+                sportId: string;
+                createdAt: string;
+                sport: {
+                    id: string;
+                    name: string;
+                    icon: string | null;
+                } | null;
+                country: string;
+                source: "external" | "internal";
+                slug: string;
+                isActive: boolean;
+                sourceOrgId: string | null;
+                externalUrl: string | null;
+                updatedAt: string;
+                createdByUserId: string | null;
+                imageUrl: string | null;
+                creator: {
+                    image: string | null;
+                    id: string;
+                    name: string;
+                } | null;
+                _count?: {
+                    events: number;
+                } | undefined;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;

package/dist/src/routes/groups/groups.index.js

@@ -0,0 +1,10 @@
+import { createRouter } from "../../lib/create-app.js";
+import * as handlers from "./groups.handlers.js";
+import * as routes from "./groups.routes.js";
+const router = createRouter()
+    .openapi(routes.list, handlers.list)
+    .openapi(routes.getOne, handlers.getOne)
+    .openapi(routes.getEvents, handlers.getEvents)
+    .openapi(routes.create, handlers.create)
+    .openapi(routes.update, handlers.update);
+export default router;