@lcas58/esmi-api-types 1.0.8 → 1.0.10

package/dist/src/routes/events/schemas/event.schemas.js

@@ -1,49 +1,29 @@
-import { z } from "zod";
-import { selectEventSchema } from "../../../db/schema/event.js";
-import { insertLocationSchema, selectLocationSchema } from "../../../db/schema/location.js";
-import { selectOrganizationSchema } from "../../../db/schema/organization.js";
-import { selectUserSchema } from "../../../db/schema/user.js";
-export const createEventSchema = z.object({
-    name: selectEventSchema.shape.name,
-    description: selectEventSchema.shape.description,
-    location: insertLocationSchema,
-    type: selectEventSchema.shape.type,
-    organizationId: selectEventSchema.shape.organizationId,
-    ageGroup: selectEventSchema.shape.ageGroup,
-    gender: selectEventSchema.shape.gender,
-}).refine(data => data.location, {
-    message: "Location details must be provided",
-});
-// Patch event schema (all fields optional)
-export const patchEventSchema = z.object({
-    name: selectEventSchema.shape.name.min(1).optional(),
-    description: selectEventSchema.shape.description,
-    location: insertLocationSchema.optional(),
-    type: selectEventSchema.shape.type.optional(),
-    organizationId: selectEventSchema.shape.organizationId.optional(),
-    mode: selectEventSchema.shape.mode.optional(),
-    ageGroup: selectEventSchema.shape.ageGroup.optional(),
-    gender: selectEventSchema.shape.gender,
-    status: selectEventSchema.shape.status.optional(),
-});
-// Query schema for list endpoint using Drizzle schema shape
-export const listEventsQuerySchema = z.object({
-    status: selectEventSchema.shape.status.optional(),
-    type: selectEventSchema.shape.type.optional(),
-    organizationId: selectEventSchema.shape.organizationId.optional(),
-});
-// Response schemas with relations
+import { z } from "@hono/zod-openapi";
+import { selectEventSchema } from "../../../db/schema/index.js";
 export const eventWithRelationsSchema = selectEventSchema.extend({
-    creator: selectUserSchema.nullable(),
-    organization: selectOrganizationSchema.nullable(),
-    location: selectLocationSchema.nullable(),
+    sport: z.object({
+        id: z.string(),
+        name: z.string(),
+        icon: z.string().nullable(),
+    }).nullable(),
+    location: z.object({
+        id: z.string(),
+        name: z.string(),
+        formattedAddress: z.string(),
+        city: z.string().nullable(),
+        state: z.string().nullable(),
+        latitude: z.number().nullable(),
+        longitude: z.number().nullable(),
+    }).nullable(),
+    externalLink: z.object({
+        id: z.string(),
+        url: z.string(),
+        domain: z.string(),
+    }).nullable(),
 });
-export const eventResponseSchema = eventWithRelationsSchema;
-export const eventsListResponseSchema = z.array(eventWithRelationsSchema);
-export const countStatsResponseSchema = z.object({
-    total: z.number(),
-    thisMonth: z.number(),
-    upcoming: z.number(),
-    inProgress: z.number(),
-    completed: z.number(),
+export const listEventsQuerySchema = z.object({
+    sportId: z.string().optional(),
+    source: z.enum(["external", "community"]).optional(),
+    limit: z.coerce.number().min(1).max(100).default(20).optional(),
+    offset: z.coerce.number().min(0).default(0).optional(),
 });

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

@@ -1 +1 @@
-export { type CreateEventInput, createEventSchema, type EventResponse, eventResponseSchema, type EventsListResponse, eventsListResponseSchema, type ListEventsQuery, listEventsQuerySchema, type PatchEventInput, patchEventSchema, } from "./event.schemas.js";
+export { eventWithRelationsSchema, listEventsQuerySchema, type EventWithRelations, type ListEventsQuery, } from "./event.schemas.js";

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

@@ -1 +1 @@
-export { createEventSchema, eventResponseSchema, eventsListResponseSchema, listEventsQuerySchema, patchEventSchema, } from "./event.schemas.js";
+export { eventWithRelationsSchema, listEventsQuerySchema, } from "./event.schemas.js";

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

@@ -33,13 +33,14 @@ export const list = async (c) => {
         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, location.id, organization.id, user.id, leagues.id);
+        .groupBy(event.id, leagues.id, location.id, organization.id, user.id);
     if (data.length === 0) {
         return c.json({
             message: HttpStatusPhrases.NOT_FOUND,

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

@@ -11,8 +11,8 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
             input: {};
             output: {
                 id: number;
-                email: string;
                 createdAt: string | null;
+                email: string;
             }[];
             outputFormat: "text" | "json";
             status: 200;
@@ -27,18 +27,12 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                 };
             };
             output: {
-                error: {
-                    issues: {
-                        code: string;
-                        path: (string | number)[];
-                        message?: string | undefined;
-                    }[];
-                    name: string;
-                };
-                success: boolean;
+                id: number;
+                createdAt: string | null;
+                email: string;
             };
             outputFormat: "text" | "json";
-            status: 422;
+            status: 200;
         } | {
             input: {
                 json: {
@@ -46,12 +40,18 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                 };
             };
             output: {
-                id: number;
-                email: string;
-                createdAt: string | null;
+                error: {
+                    issues: {
+                        code: string;
+                        path: (string | number)[];
+                        message?: string | undefined | undefined;
+                    }[];
+                    name: string;
+                };
+                success: boolean;
             };
             outputFormat: "text" | "json";
-            status: 200;
+            status: 422;
         };
     };
 }, "/">;

package/dist/src/routes/marketing/marketing.routes.d.ts

@@ -13,12 +13,12 @@ export declare const list: {
                         createdAt: z.ZodNullable<z.ZodDate>;
                     }, z.UnknownKeysParam, z.ZodTypeAny, {
                         id: number;
-                        email: string;
                         createdAt: Date | null;
+                        email: string;
                     }, {
                         id: number;
-                        email: string;
                         createdAt: Date | null;
+                        email: string;
                     }>, "many">;
                 };
             };
@@ -53,8 +53,8 @@ export declare const create: {
                 "application/json": {
                     schema: z.ZodObject<Omit<{
                         id: z.ZodOptional<z.ZodNumber>;
-                        email: z.ZodString;
                         createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+                        email: z.ZodString;
                     }, "id" | "createdAt">, z.UnknownKeysParam, z.ZodTypeAny, {
                         email: string;
                     }, {
@@ -75,12 +75,12 @@ export declare const create: {
                         createdAt: z.ZodNullable<z.ZodDate>;
                     }, z.UnknownKeysParam, z.ZodTypeAny, {
                         id: number;
-                        email: string;
                         createdAt: Date | null;
+                        email: string;
                     }, {
                         id: number;
-                        email: string;
                         createdAt: Date | null;
+                        email: string;
                     }>;
                 };
             };

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

@@ -49,7 +49,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };
@@ -124,7 +124,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };
@@ -206,7 +206,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };
@@ -358,7 +358,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };
@@ -438,7 +438,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };
@@ -481,7 +481,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     issues: {
                         code: string;
                         path: (string | number)[];
-                        message?: string | undefined;
+                        message?: string | undefined | undefined;
                     }[];
                     name: string;
                 };

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

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

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

@@ -0,0 +1,23 @@
+import { 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 { sport } from "../../db/schema/index.js";
+export const list = async (c) => {
+    const { db } = createDb(c.env);
+    const sports = await db.query.sport.findMany({
+        orderBy: (sport, { asc }) => [asc(sport.name)],
+    });
+    return c.json(sports, HttpStatusCodes.OK);
+};
+export const getOne = async (c) => {
+    const { db } = createDb(c.env);
+    const { id } = c.req.valid("param");
+    const foundSport = await db.query.sport.findFirst({
+        where: eq(sport.id, id),
+    });
+    if (!foundSport) {
+        return c.json({ message: HttpStatusPhrases.NOT_FOUND }, HttpStatusCodes.NOT_FOUND);
+    }
+    return c.json(foundSport, HttpStatusCodes.OK);
+};

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

@@ -0,0 +1,45 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/sports": {
+        $get: {
+            input: {};
+            output: {
+                id: string;
+                name: string;
+                createdAt: string;
+                icon: string | null;
+            }[];
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/sports/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                id: string;
+                name: string;
+                createdAt: string;
+                icon: string | null;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;

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

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

package/dist/src/routes/sports/sports.routes.d.ts

@@ -0,0 +1,90 @@
+import { z } from "@hono/zod-openapi";
+export declare const list: {
+    path: "/sports";
+    method: "get";
+    tags: string[];
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        icon: z.ZodNullable<z.ZodString>;
+                        createdAt: z.ZodDate;
+                    }, z.UnknownKeysParam, z.ZodTypeAny, {
+                        id: string;
+                        name: string;
+                        createdAt: Date;
+                        icon: string | null;
+                    }, {
+                        id: string;
+                        name: string;
+                        createdAt: Date;
+                        icon: string | null;
+                    }>, "many">;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/sports";
+};
+export declare const getOne: {
+    path: "/sports/{id}";
+    method: "get";
+    tags: string[];
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        icon: z.ZodNullable<z.ZodString>;
+                        createdAt: z.ZodDate;
+                    }, z.UnknownKeysParam, z.ZodTypeAny, {
+                        id: string;
+                        name: string;
+                        createdAt: Date;
+                        icon: string | null;
+                    }, {
+                        id: string;
+                        name: string;
+                        createdAt: Date;
+                        icon: string | null;
+                    }>;
+                };
+            };
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/sports/:id";
+};
+export type ListRoute = typeof list;
+export type GetOneRoute = typeof getOne;

package/dist/src/routes/sports/sports.routes.js

@@ -0,0 +1,27 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent } from "stoker/openapi/helpers";
+import { selectSportSchema } from "../../db/schema/index.js";
+import { notFoundSchema } from "../../lib/constants.js";
+export const list = createRoute({
+    path: "/sports",
+    method: "get",
+    tags: ["Sports"],
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(selectSportSchema), "List of sports"),
+    },
+});
+export const getOne = createRoute({
+    path: "/sports/{id}",
+    method: "get",
+    tags: ["Sports"],
+    request: {
+        params: z.object({
+            id: z.string(),
+        }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(selectSportSchema, "Sport details"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Sport not found"),
+    },
+});

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

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

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

@@ -0,0 +1,14 @@
+export const verify = async (c) => {
+    const { url, eventType } = c.req.valid("json");
+    // TODO: Implement actual URL verification logic
+    // This could include:
+    // - Sending a challenge request to the URL
+    // - Verifying the URL responds correctly
+    // - Checking for proper SSL/TLS
+    // - Validating response format
+    return c.json({
+        verified: true,
+        url,
+        message: "URL verification pending implementation",
+    });
+};

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

@@ -0,0 +1,32 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/webhooks/verify": {
+        $post: {
+            input: {
+                json: {
+                    url: string;
+                    eventType?: string | undefined;
+                };
+            };
+            output: {
+                message: string;
+                url: string;
+                verified: boolean;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        } | {
+            input: {
+                json: {
+                    url: string;
+                    eventType?: string | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 400;
+        };
+    };
+}, "/">;
+export default router;

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

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

package/dist/src/routes/webhooks/webhooks.routes.d.ts

@@ -0,0 +1,65 @@
+import { z } from "@hono/zod-openapi";
+export declare const verify: {
+    method: "post";
+    path: "/webhooks/verify";
+    tags: string[];
+    middleware: import("hono").MiddlewareHandler[];
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        url: z.ZodString;
+                        eventType: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        url: string;
+                        eventType?: string | undefined;
+                    }, {
+                        url: string;
+                        eventType?: string | undefined;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        verified: z.ZodBoolean;
+                        url: z.ZodString;
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                        url: string;
+                        verified: boolean;
+                    }, {
+                        message: string;
+                        url: string;
+                        verified: boolean;
+                    }>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/webhooks/verify";
+};
+export type VerifyRoute = typeof verify;

package/dist/src/routes/webhooks/webhooks.routes.js

@@ -0,0 +1,26 @@
+import { isAuth } from "../../middlewares/is-auth.js";
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent } from "stoker/openapi/helpers";
+export const verify = createRoute({
+    method: "post",
+    path: "/webhooks/verify",
+    tags: ["Webhooks"],
+    middleware: [isAuth()],
+    request: {
+        body: jsonContent(z.object({
+            url: z.string().url(),
+            eventType: z.string().optional(),
+        }), "URL verification request"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.object({
+            verified: z.boolean(),
+            url: z.string(),
+            message: z.string(),
+        }), "URL verification result"),
+        [HttpStatusCodes.BAD_REQUEST]: jsonContent(z.object({
+            message: z.string(),
+        }), "Invalid request"),
+    },
+});

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

@@ -1,19 +1,6 @@
-/**
- * Type exports for Hono RPC client usage
- *
- * Usage in frontend:
- * ```typescript
- * import { hc } from 'hono/client';
- * import type { AppType } from '@lcas58/esmi-api-types/client-types';
- *
- * const client = hc<AppType>('https://api.example.com');
- * const res = await client.events.$get();
- * ```
- */
 import type events from "../routes/events/events.index.js";
 import type index from "../routes/index.route.js";
-import type leagues from "../routes/leagues/leagues.index.js";
 import type marketing from "../routes/marketing/marketing.index.js";
-import type organizations from "../routes/organizations/organizations.index.js";
-import type tags from "../routes/tags/tags.index.js";
-export type AppType = typeof index | typeof organizations | typeof events | typeof leagues | typeof marketing | typeof tags;
+import type sports from "../routes/sports/sports.index.js";
+import type webhooks from "../routes/webhooks/webhooks.index.js";
+export type AppType = typeof index | typeof events | typeof sports | typeof marketing | typeof webhooks;

package/dist/src/shared/client-types.js

@@ -1,13 +1 @@
-/**
- * Type exports for Hono RPC client usage
- *
- * Usage in frontend:
- * ```typescript
- * import { hc } from 'hono/client';
- * import type { AppType } from '@lcas58/esmi-api-types/client-types';
- *
- * const client = hc<AppType>('https://api.example.com');
- * const res = await client.events.$get();
- * ```
- */
 export {};