@lcas58/esmi-api-types 1.0.26 → 1.0.28

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

@@ -0,0 +1,77 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent, jsonContentRequired } from "stoker/openapi/helpers";
+import { notFoundSchema, unauthorizedSchema } from "../../lib/constants.js";
+import { isAuth } from "../../middlewares/is-auth.js";
+import { eventWithRelationsSchema } from "../events/schemas/index.js";
+import { createGroupBodySchema, groupEventsQuerySchema, groupWithRelationsSchema, listGroupsQuerySchema, updateGroupBodySchema, } from "./schemas/index.js";
+export const list = createRoute({
+    path: "/groups",
+    method: "get",
+    tags: ["Groups"],
+    request: {
+        query: listGroupsQuerySchema,
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(groupWithRelationsSchema), "List of groups"),
+    },
+});
+export const getOne = createRoute({
+    path: "/groups/{id}",
+    method: "get",
+    tags: ["Groups"],
+    request: {
+        params: z.object({
+            id: z.string(),
+        }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(groupWithRelationsSchema, "Group details"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Group not found"),
+    },
+});
+export const getEvents = createRoute({
+    path: "/groups/{id}/events",
+    method: "get",
+    tags: ["Groups"],
+    request: {
+        params: z.object({
+            id: z.string(),
+        }),
+        query: groupEventsQuerySchema,
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(eventWithRelationsSchema), "Events for this group"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Group not found"),
+    },
+});
+export const create = createRoute({
+    path: "/groups",
+    method: "post",
+    tags: ["Groups"],
+    middleware: [isAuth()],
+    request: {
+        body: jsonContentRequired(createGroupBodySchema, "Group to create"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(groupWithRelationsSchema, "Created group"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const update = createRoute({
+    path: "/groups/{id}",
+    method: "patch",
+    tags: ["Groups"],
+    middleware: [isAuth()],
+    request: {
+        params: z.object({
+            id: z.string(),
+        }),
+        body: jsonContentRequired(updateGroupBodySchema, "Fields to update"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(groupWithRelationsSchema, "Updated group"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Group not found"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});

package/dist/src/routes/groups/schemas/group.schemas.d.ts

@@ -0,0 +1,214 @@
+import { z } from "@hono/zod-openapi";
+export declare const groupWithRelationsSchema: z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<["internal", "external"]>;
+    city: z.ZodNullable<z.ZodString>;
+    state: z.ZodNullable<z.ZodString>;
+    country: z.ZodString;
+    sportId: z.ZodString;
+    sourceOrgId: z.ZodNullable<z.ZodString>;
+    externalUrl: z.ZodNullable<z.ZodString>;
+    createdByUserId: z.ZodNullable<z.ZodString>;
+    imageUrl: z.ZodNullable<z.ZodString>;
+    isActive: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, {
+    sport: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        icon: string | null;
+    }, {
+        id: string;
+        name: string;
+        icon: string | null;
+    }>>;
+    creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        image: string | null;
+        id: string;
+        name: string;
+    }, {
+        image: string | null;
+        id: string;
+        name: string;
+    }>>;
+    _count: z.ZodOptional<z.ZodObject<{
+        events: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        events: number;
+    }, {
+        events: number;
+    }>>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    id: string;
+    description: string | null;
+    name: string;
+    city: string | null;
+    state: string | null;
+    sportId: string;
+    createdAt: Date;
+    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: Date;
+    createdByUserId: string | null;
+    imageUrl: string | null;
+    creator: {
+        image: string | null;
+        id: string;
+        name: string;
+    } | null;
+    _count?: {
+        events: number;
+    } | undefined;
+}, {
+    id: string;
+    description: string | null;
+    name: string;
+    city: string | null;
+    state: string | null;
+    sportId: string;
+    createdAt: Date;
+    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: Date;
+    createdByUserId: string | null;
+    imageUrl: string | null;
+    creator: {
+        image: string | null;
+        id: string;
+        name: string;
+    } | null;
+    _count?: {
+        events: number;
+    } | undefined;
+}>;
+export declare const listGroupsQuerySchema: z.ZodObject<{
+    sportId: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<["internal", "external"]>>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    search?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    sportId?: string | undefined;
+    source?: "external" | "internal" | undefined;
+}, {
+    search?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    sportId?: string | undefined;
+    source?: "external" | "internal" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const createGroupBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    sportId: z.ZodString;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    sportId: string;
+    description?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    slug?: string | undefined;
+    imageUrl?: string | undefined;
+}, {
+    name: string;
+    sportId: string;
+    description?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    slug?: string | undefined;
+    imageUrl?: string | undefined;
+}>;
+export declare const updateGroupBodySchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
+    name?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    imageUrl?: string | null | undefined;
+}, {
+    description?: string | undefined;
+    name?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    imageUrl?: string | null | undefined;
+}>, {
+    description?: string | undefined;
+    name?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    imageUrl?: string | null | undefined;
+}, {
+    description?: string | undefined;
+    name?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    imageUrl?: string | null | undefined;
+}>;
+export declare const groupEventsQuerySchema: z.ZodObject<{
+    from: z.ZodOptional<z.ZodDate>;
+    to: z.ZodOptional<z.ZodDate>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    from?: Date | undefined;
+    to?: Date | undefined;
+}, {
+    from?: Date | undefined;
+    to?: Date | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type GroupWithRelations = z.infer<typeof groupWithRelationsSchema>;
+export type ListGroupsQuery = z.infer<typeof listGroupsQuerySchema>;
+export type CreateGroupBody = z.infer<typeof createGroupBodySchema>;
+export type UpdateGroupBody = z.infer<typeof updateGroupBodySchema>;

package/dist/src/routes/groups/schemas/group.schemas.js

@@ -0,0 +1,48 @@
+import { z } from "@hono/zod-openapi";
+import { selectGroupSchema } from "../../../db/schema/index.js";
+export const groupWithRelationsSchema = selectGroupSchema.extend({
+    sport: z.object({
+        id: z.string(),
+        name: z.string(),
+        icon: z.string().nullable(),
+    }).nullable(),
+    creator: z.object({
+        id: z.string(),
+        name: z.string(),
+        image: z.string().nullable(),
+    }).nullable(),
+    _count: z.object({
+        events: z.number(),
+    }).optional(),
+});
+export const listGroupsQuerySchema = z.object({
+    sportId: z.string().optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+    source: z.enum(["internal", "external"]).optional(),
+    search: z.string().optional(),
+    limit: z.coerce.number().min(1).max(100).optional().default(20),
+    offset: z.coerce.number().min(0).optional().default(0),
+});
+export const createGroupBodySchema = z.object({
+    name: z.string().min(1).max(255),
+    slug: z.string().min(1).max(255).optional(),
+    description: z.string().optional(),
+    sportId: z.string().min(1),
+    city: z.string().max(100).optional(),
+    state: z.string().max(50).optional(),
+    imageUrl: z.string().url().optional(),
+});
+export const updateGroupBodySchema = z.object({
+    name: z.string().min(1).max(255).optional(),
+    description: z.string().optional(),
+    city: z.string().max(100).optional(),
+    state: z.string().max(50).optional(),
+    imageUrl: z.string().url().nullable().optional(),
+}).refine(data => Object.values(data).some(v => v !== undefined), { message: "At least one field must be provided" });
+export const groupEventsQuerySchema = z.object({
+    from: z.coerce.date().optional(),
+    to: z.coerce.date().optional(),
+    limit: z.coerce.number().min(1).max(100).optional().default(20),
+    offset: z.coerce.number().min(0).optional().default(0),
+});

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

@@ -0,0 +1 @@
+export { type CreateGroupBody, createGroupBodySchema, groupEventsQuerySchema, type GroupWithRelations, groupWithRelationsSchema, type ListGroupsQuery, listGroupsQuerySchema, type UpdateGroupBody, updateGroupBodySchema, } from "./group.schemas.js";

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

@@ -0,0 +1 @@
+export { createGroupBodySchema, groupEventsQuerySchema, groupWithRelationsSchema, listGroupsQuerySchema, updateGroupBodySchema, } from "./group.schemas.js";

package/dist/src/shared/client-types.d.ts

@@ -1,7 +1,8 @@
 import type events from "../routes/events/events.index.js";
+import type groups from "../routes/groups/groups.index.js";
 import type index from "../routes/index.route.js";
 import type marketing from "../routes/marketing/marketing.index.js";
 import type sports from "../routes/sports/sports.index.js";
 import type users from "../routes/users/users.index.js";
 import type webhooks from "../routes/webhooks/webhooks.index.js";
-export type AppType = typeof index | typeof events | typeof sports | typeof users | typeof marketing | typeof webhooks;
+export type AppType = typeof index | typeof events | typeof groups | typeof sports | typeof users | typeof marketing | typeof webhooks;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcas58/esmi-api-types",
   "type": "module",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "license": "MIT",
   "exports": {
     ".": {

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

@@ -1,3 +0,0 @@
-import type { AppRouteHandler } from "../../lib/types.js";
-import type { DiscoverRoute } from "./discover.routes.js";
-export declare const discover: AppRouteHandler<DiscoverRoute>;

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

@@ -1,15 +0,0 @@
-import * as HttpStatusCodes from "stoker/http-status-codes";
-import { runDiscoveryAgent } from "../../agent/runner.js";
-import { createDb } from "../../db/index.js";
-export const discover = async (c) => {
-    const body = c.req.valid("json");
-    const { db } = createDb(c.env);
-    const events = await runDiscoveryAgent(c.env, db, {
-        sportId: body.sportId,
-        city: body.city,
-        state: body.state,
-        from: body.from,
-        to: body.to,
-    });
-    return c.json(events, HttpStatusCodes.OK);
-};

package/dist/src/routes/events/discover.index.d.ts

@@ -1,72 +0,0 @@
-declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
-    "/events/discover": {
-        $post: {
-            input: {
-                json: {
-                    sportId: string;
-                    city: string;
-                    state: string;
-                    from?: string | undefined;
-                    to?: string | undefined;
-                };
-            };
-            output: {
-                metadata: any;
-                id: string;
-                title: string;
-                createdAt: string;
-                sport: {
-                    id: string;
-                    name: string;
-                    icon: string | null;
-                } | null;
-                sportId: string;
-                startsAt: string;
-                endsAt: string | null;
-                timezone: string;
-                location: {
-                    id: string;
-                    name: string;
-                    formattedAddress: string;
-                    city: string | null;
-                    state: string | null;
-                    latitude: number | null;
-                    longitude: number | null;
-                } | null;
-                locationId: string | null;
-                externalLinkId: string | null;
-                source: "external" | "community";
-                thumbnailUrl: string | null;
-                createdByUserId: 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: {
-                json: {
-                    sportId: string;
-                    city: string;
-                    state: string;
-                    from?: string | undefined;
-                    to?: string | undefined;
-                };
-            };
-            output: {
-                message: string;
-            };
-            outputFormat: "text" | "json";
-            status: 401;
-        };
-    };
-}, "/">;
-export default router;

package/dist/src/routes/events/discover.index.js

@@ -1,6 +0,0 @@
-import { createRouter } from "../../lib/create-app.js";
-import * as handlers from "./discover.handlers.js";
-import * as routes from "./discover.routes.js";
-const router = createRouter()
-    .openapi(routes.discover, handlers.discover);
-export default router;

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

@@ -1,26 +0,0 @@
-import { createRoute, z } from "@hono/zod-openapi";
-import * as HttpStatusCodes from "stoker/http-status-codes";
-import { jsonContent, jsonContentRequired } from "stoker/openapi/helpers";
-import { unauthorizedSchema } from "../../lib/constants.js";
-import { isAuth } from "../../middlewares/is-auth.js";
-import { eventWithRelationsSchema } from "./schemas/index.js";
-export const discoverRequestSchema = z.object({
-    sportId: z.string().min(1),
-    city: z.string().min(1),
-    state: z.string().min(1),
-    from: z.string().optional(),
-    to: z.string().optional(),
-});
-export const discover = createRoute({
-    path: "/events/discover",
-    method: "post",
-    tags: ["Events"],
-    middleware: [isAuth()],
-    request: {
-        body: jsonContentRequired(discoverRequestSchema, "Event discovery criteria"),
-    },
-    responses: {
-        [HttpStatusCodes.OK]: jsonContent(z.array(eventWithRelationsSchema), "Discovered events"),
-        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
-    },
-});

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

@@ -1,3 +0,0 @@
-import type { AppRouteHandler } from "../../lib/types.js";
-import type { ListRoute } from "./leagues.routes.js";
-export declare const list: AppRouteHandler<ListRoute>;

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

@@ -1,50 +0,0 @@
-import { 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, eventTags, leagues, location, organization, tags, user } from "../../db/schema/index.js";
-export const list = async (c) => {
-    const { db } = createDb(c.env);
-    const { locationId } = c.req.valid("param");
-    const data = await db
-        .select({
-        name: event.name,
-        description: event.description,
-        formattedAddress: location.formattedAddress,
-        type: event.type,
-        organization: {
-            name: organization.name,
-            description: organization.description,
-            ownerName: user.name,
-        },
-        mode: event.mode,
-        ageGroup: event.ageGroup,
-        gender: event.gender,
-        status: event.status,
-        numberOfTeams: leagues.numberOfTeams,
-        scheduleDays: leagues.scheduleDays,
-        scheduleTimes: leagues.scheduleTimes,
-        startDate: leagues.startDate,
-        endDate: leagues.endDate,
-        season: leagues.season,
-        registrationStart: leagues.registrationStart,
-        registrationEnd: leagues.registrationEnd,
-        teamFee: leagues.teamFee,
-        tags: sql `array_agg(json_build_object('id', ${tags.id}, 'name', ${tags.name}))`.as("tags"),
-    })
-        .from(event)
-        .innerJoin(leagues, eq(leagues.eventId, event.id))
-        .innerJoin(location, eq(event.locationId, location.id))
-        .innerJoin(organization, eq(event.organizationId, organization.id))
-        .innerJoin(user, eq(organization.ownerId, user.id))
-        .innerJoin(eventTags, eq(event.id, eventTags.eventId))
-        .innerJoin(tags, eq(eventTags.tagId, tags.id))
-        .where(eq(event.locationId, locationId))
-        .groupBy(event.id, leagues.id, location.id, organization.id, user.id);
-    if (data.length === 0) {
-        return c.json({
-            message: HttpStatusPhrases.NOT_FOUND,
-        }, HttpStatusCodes.NOT_FOUND);
-    }
-    return c.json(data, HttpStatusCodes.OK);
-};

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

@@ -1,53 +0,0 @@
-declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
-    "/leagues/:locationId": {
-        $get: {
-            input: {
-                param: {
-                    [x: string]: string;
-                };
-            };
-            output: {
-                message: string;
-            };
-            outputFormat: "text" | "json";
-            status: 404;
-        } | {
-            input: {
-                param: {
-                    [x: string]: string;
-                };
-            };
-            output: {
-                status: string;
-                type: string;
-                description: string | null;
-                name: string;
-                formattedAddress: string;
-                organization: {
-                    description: string;
-                    name: string;
-                    ownerName: string;
-                };
-                mode: string;
-                ageGroup: string;
-                gender: string;
-                tags: {
-                    id: string;
-                    name: string;
-                }[];
-                numberOfTeams: number;
-                scheduleDays: string | null;
-                scheduleTimes: string | null;
-                startDate: string;
-                endDate: string;
-                season: string | null;
-                registrationStart: string | null;
-                registrationEnd: string | null;
-                teamFee: number | null;
-            }[];
-            outputFormat: "text" | "json";
-            status: 200;
-        };
-    };
-}, "/">;
-export default router;

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

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