@lcas58/esmi-api-types 1.0.9 → 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/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;
@@ -21,6 +21,19 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
 } & {
     "/marketing/email": {
         $post: {
+            input: {
+                json: {
+                    email: string;
+                };
+            };
+            output: {
+                id: number;
+                createdAt: string | null;
+                email: string;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        } | {
             input: {
                 json: {
                     email: string;
@@ -39,19 +52,6 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
             };
             outputFormat: "text" | "json";
             status: 422;
-        } | {
-            input: {
-                json: {
-                    email: string;
-                };
-            };
-            output: {
-                id: number;
-                email: string;
-                createdAt: string | null;
-            };
-            outputFormat: "text" | "json";
-            status: 200;
         };
     };
 }, "/">;

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/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.routes.d.ts

@@ -3,6 +3,7 @@ export declare const verify: {
     method: "post";
     path: "/webhooks/verify";
     tags: string[];
+    middleware: import("hono").MiddlewareHandler[];
     request: {
         body: {
             content: {

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

@@ -1,3 +1,4 @@
+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";
@@ -5,6 +6,7 @@ export const verify = createRoute({
     method: "post",
     path: "/webhooks/verify",
     tags: ["Webhooks"],
+    middleware: [isAuth()],
     request: {
         body: jsonContent(z.object({
             url: z.string().url(),

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

@@ -1,8 +1,6 @@
 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";
+import type sports from "../routes/sports/sports.index.js";
 import type webhooks from "../routes/webhooks/webhooks.index.js";
-export type AppType = typeof index | typeof organizations | typeof events | typeof leagues | typeof marketing | typeof tags | typeof webhooks;
+export type AppType = typeof index | typeof events | typeof sports | typeof marketing | typeof webhooks;

package/package.json

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