@lcas58/esmi-api-types 1.0.6 → 1.0.7

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

@@ -0,0 +1,49 @@
+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
+export const eventWithRelationsSchema = selectEventSchema.extend({
+    creator: selectUserSchema.nullable(),
+    organization: selectOrganizationSchema.nullable(),
+    location: selectLocationSchema.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(),
+});

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

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

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

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

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

@@ -0,0 +1,13 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../shared/index.js").AppBindings, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;

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

@@ -0,0 +1,19 @@
+import { createRoute } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent } from "stoker/openapi/helpers";
+import { createMessageObjectSchema } from "stoker/openapi/schemas";
+import { createRouter } from "../lib/create-app.js";
+const router = createRouter()
+    .openapi(createRoute({
+    tags: ["Index"],
+    method: "get",
+    path: "/",
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(createMessageObjectSchema("ESMI API"), "ESMI API Index"),
+    },
+}), (c) => {
+    return c.json({
+        message: "ESMI API",
+    }, HttpStatusCodes.OK);
+});
+export default router;

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,49 @@
+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(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);
+    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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,6 @@
+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;

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

@@ -0,0 +1,137 @@
+import { z } from "@hono/zod-openapi";
+export declare const list: {
+    path: "/leagues/{locationId}";
+    method: "get";
+    tags: string[];
+    request: {
+        params: z.ZodObject<{
+            [x: string]: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            [x: string]: string;
+        }, {
+            [x: string]: string;
+        }>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodNullable<z.ZodString>;
+                        formattedAddress: z.ZodString;
+                        type: z.ZodString;
+                        organization: z.ZodObject<{
+                            name: z.ZodString;
+                            description: z.ZodString;
+                            ownerName: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            description: string;
+                            name: string;
+                            ownerName: string;
+                        }, {
+                            description: string;
+                            name: string;
+                            ownerName: string;
+                        }>;
+                        mode: z.ZodString;
+                        ageGroup: z.ZodString;
+                        gender: z.ZodString;
+                        status: z.ZodString;
+                        numberOfTeams: z.ZodNumber;
+                        scheduleDays: z.ZodNullable<z.ZodString>;
+                        scheduleTimes: z.ZodNullable<z.ZodString>;
+                        startDate: z.ZodDate;
+                        endDate: z.ZodDate;
+                        season: z.ZodNullable<z.ZodString>;
+                        registrationStart: z.ZodNullable<z.ZodDate>;
+                        registrationEnd: z.ZodNullable<z.ZodDate>;
+                        teamFee: z.ZodNullable<z.ZodNumber>;
+                        tags: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            id: string;
+                            name: string;
+                        }, {
+                            id: string;
+                            name: string;
+                        }>, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        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: Date;
+                        endDate: Date;
+                        season: string | null;
+                        registrationStart: Date | null;
+                        registrationEnd: Date | null;
+                        teamFee: number | null;
+                    }, {
+                        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: Date;
+                        endDate: Date;
+                        season: string | null;
+                        registrationStart: Date | null;
+                        registrationEnd: Date | null;
+                        teamFee: number | null;
+                    }>, "many">;
+                };
+            };
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/leagues/:locationId";
+};
+export type ListRoute = typeof list;

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

@@ -0,0 +1,47 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent } from "stoker/openapi/helpers";
+import { selectEventSchema, selectLeaguesSchema, selectLocationSchema, selectOrganizationSchema, selectTagsSchema, selectUserSchema } from "../../db/schema/index.js";
+import { notFoundSchema } from "../../lib/constants.js";
+import { uuidParamsSchema } from "../../lib/openapi-schemas.js";
+const tags = ["Leagues"];
+const leagueSchema = z.object({
+    name: selectEventSchema.shape.name,
+    description: selectEventSchema.shape.description,
+    formattedAddress: selectLocationSchema.shape.formattedAddress,
+    type: selectEventSchema.shape.type,
+    organization: z.object({
+        name: selectOrganizationSchema.shape.name,
+        description: selectOrganizationSchema.shape.description,
+        ownerName: selectUserSchema.shape.name,
+    }),
+    mode: selectEventSchema.shape.mode,
+    ageGroup: selectEventSchema.shape.ageGroup,
+    gender: selectEventSchema.shape.gender,
+    status: selectEventSchema.shape.status,
+    numberOfTeams: selectLeaguesSchema.shape.numberOfTeams,
+    scheduleDays: selectLeaguesSchema.shape.scheduleDays,
+    scheduleTimes: selectLeaguesSchema.shape.scheduleTimes,
+    startDate: selectLeaguesSchema.shape.startDate,
+    endDate: selectLeaguesSchema.shape.endDate,
+    season: selectLeaguesSchema.shape.season,
+    registrationStart: selectLeaguesSchema.shape.registrationStart,
+    registrationEnd: selectLeaguesSchema.shape.registrationEnd,
+    teamFee: selectLeaguesSchema.shape.teamFee,
+    tags: z.array(z.object({
+        id: selectTagsSchema.shape.id,
+        name: selectTagsSchema.shape.name,
+    })),
+});
+export const list = createRoute({
+    path: "/leagues/{locationId}",
+    method: "get",
+    tags,
+    request: {
+        params: uuidParamsSchema("locationId"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(leagueSchema), "The list of leagues for the given location"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "No leagues found for the given location"),
+    },
+});

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

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

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

@@ -0,0 +1,20 @@
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import * as HttpStatusPhrases from "stoker/http-status-phrases";
+import { createDb } from "../../db/index.js";
+import { emailCampaign } from "../../db/schema/index.js";
+export const list = async (c) => {
+    const { db } = createDb(c.env);
+    const emailCampaigns = await db.query.emailCampaign.findMany();
+    if (emailCampaigns.length === 0) {
+        return c.json({
+            message: HttpStatusPhrases.NOT_FOUND,
+        }, HttpStatusCodes.NOT_FOUND);
+    }
+    return c.json(emailCampaigns, HttpStatusCodes.OK);
+};
+export const create = async (c) => {
+    const { db } = createDb(c.env);
+    const data = c.req.valid("json");
+    const [inserted] = await db.insert(emailCampaign).values(data).returning();
+    return c.json(inserted, HttpStatusCodes.OK);
+};

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

@@ -0,0 +1,58 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/marketing/email": {
+        $get: {
+            input: {};
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 404;
+        } | {
+            input: {};
+            output: {
+                id: number;
+                email: string;
+                createdAt: string | null;
+            }[];
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/marketing/email": {
+        $post: {
+            input: {
+                json: {
+                    email: string;
+                };
+            };
+            output: {
+                error: {
+                    issues: {
+                        code: string;
+                        path: (string | number)[];
+                        message?: string | undefined;
+                    }[];
+                    name: string;
+                };
+                success: boolean;
+            };
+            outputFormat: "text" | "json";
+            status: 422;
+        } | {
+            input: {
+                json: {
+                    email: string;
+                };
+            };
+            output: {
+                id: number;
+                email: string;
+                createdAt: string | null;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;

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

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

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

@@ -0,0 +1,154 @@
+import { z } from "@hono/zod-openapi";
+export declare const list: {
+    path: "/marketing/email";
+    method: "get";
+    tags: string[];
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodArray<z.ZodObject<{
+                        id: z.ZodNumber;
+                        email: z.ZodString;
+                        createdAt: z.ZodNullable<z.ZodDate>;
+                    }, z.UnknownKeysParam, z.ZodTypeAny, {
+                        id: number;
+                        email: string;
+                        createdAt: Date | null;
+                    }, {
+                        id: number;
+                        email: string;
+                        createdAt: Date | null;
+                    }>, "many">;
+                };
+            };
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/marketing/email";
+};
+export declare const create: {
+    path: "/marketing/email";
+    method: "post";
+    tags: string[];
+    request: {
+        body: {
+            required: boolean;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<Omit<{
+                        id: z.ZodOptional<z.ZodNumber>;
+                        email: z.ZodString;
+                        createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+                    }, "id" | "createdAt">, z.UnknownKeysParam, z.ZodTypeAny, {
+                        email: string;
+                    }, {
+                        email: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        email: z.ZodString;
+                        createdAt: z.ZodNullable<z.ZodDate>;
+                    }, z.UnknownKeysParam, z.ZodTypeAny, {
+                        id: number;
+                        email: string;
+                        createdAt: Date | null;
+                    }, {
+                        id: number;
+                        email: string;
+                        createdAt: Date | null;
+                    }>;
+                };
+            };
+            description: string;
+        };
+        422: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        success: z.ZodBoolean;
+                        error: z.ZodObject<{
+                            issues: z.ZodArray<z.ZodObject<{
+                                code: z.ZodString;
+                                path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                                message: z.ZodOptional<z.ZodString>;
+                            }, "strip", z.ZodTypeAny, {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }, {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }>, "many">;
+                            name: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            issues: {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }[];
+                            name: string;
+                        }, {
+                            issues: {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }[];
+                            name: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        error: {
+                            issues: {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }[];
+                            name: string;
+                        };
+                        success: boolean;
+                    }, {
+                        error: {
+                            issues: {
+                                code: string;
+                                path: (string | number)[];
+                                message?: string | undefined;
+                            }[];
+                            name: string;
+                        };
+                        success: boolean;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/marketing/email";
+};
+export type ListRoute = typeof list;
+export type CreateRoute = typeof create;

package/dist/src/routes/marketing/marketing.routes.js

@@ -0,0 +1,27 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent, jsonContentRequired } from "stoker/openapi/helpers";
+import { createErrorSchema } from "stoker/openapi/schemas";
+import { insertEmailCampaignSchema, selectEmailCampaignSchema } from "../../db/schema/index.js";
+import { notFoundSchema } from "../../lib/constants.js";
+export const list = createRoute({
+    path: "/marketing/email",
+    method: "get",
+    tags: ["marketing"],
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(selectEmailCampaignSchema), "The list of email campaigns"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "No email campaigns found"),
+    },
+});
+export const create = createRoute({
+    path: "/marketing/email",
+    method: "post",
+    tags: ["marketing"],
+    request: {
+        body: jsonContentRequired(insertEmailCampaignSchema, "The email campaign to create"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(selectEmailCampaignSchema, "The email campaign to create"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(insertEmailCampaignSchema), "The validation error(s)"),
+    },
+});