@lcas58/esmi-api-types 1.0.19 → 1.0.20

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

@@ -1,6 +1,7 @@
 import type { AppRouteHandler } from "../../lib/types.js";
-import type { DiscoverExternalRoute, DiscoverRoute, GetOneRoute, ListRoute } from "./events.routes.js";
+import type { DiscoverExternalRoute, DiscoverRoute, GetOneRoute, ListRoute, SaveExternalRoute } from "./events.routes.js";
 export declare const list: AppRouteHandler<ListRoute>;
 export declare const getOne: AppRouteHandler<GetOneRoute>;
 export declare const discover: AppRouteHandler<DiscoverRoute>;
 export declare const discoverExternal: AppRouteHandler<DiscoverExternalRoute>;
+export declare const saveExternal: AppRouteHandler<SaveExternalRoute>;

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

@@ -1,8 +1,8 @@
 import { and, eq, gte, ilike, inArray, isNotNull, lte } from "drizzle-orm";
 import * as HttpStatusCodes from "stoker/http-status-codes";
 import * as HttpStatusPhrases from "stoker/http-status-phrases";
-import { runExternalDiscoveryAgent } from "../../agent/runner.js";
-import { searchLocalEvents } from "../../agent/tools.js";
+import { agentEventsToRaw, runExternalDiscoveryAgent } from "../../agent/runner.js";
+import { saveEvents, searchLocalEvents } from "../../agent/tools.js";
 import { createDb } from "../../db/index.js";
 import { event, location } from "../../db/schema/index.js";
 export const list = async (c) => {
@@ -110,12 +110,47 @@ export const discover = async (c) => {
 export const discoverExternal = async (c) => {
     const body = c.req.valid("json");
     const { db } = createDb(c.env);
-    const events = await runExternalDiscoveryAgent(c.env, db, {
+    const previews = await runExternalDiscoveryAgent(c.env, db, {
         sportId: body.sportId,
         city: body.city,
         state: body.state,
         from: body.from,
         to: body.to,
     });
-    return c.json(events, HttpStatusCodes.OK);
+    return c.json(previews, HttpStatusCodes.OK);
+};
+export const saveExternal = async (c) => {
+    const { events: previews, city, state } = c.req.valid("json");
+    const { db } = createDb(c.env);
+    const rawEvents = agentEventsToRaw(previews, {
+        sportId: "",
+        city,
+        state,
+    });
+    if (rawEvents.length === 0) {
+        return c.json([], HttpStatusCodes.OK);
+    }
+    const saveResult = await saveEvents(db, rawEvents);
+    if (saveResult.savedIds.length === 0) {
+        return c.json([], HttpStatusCodes.OK);
+    }
+    const savedEvents = await db.query.event.findMany({
+        where: inArray(event.id, saveResult.savedIds),
+        with: {
+            sport: true,
+            location: true,
+            externalLink: true,
+            creator: {
+                columns: {
+                    id: true,
+                    name: true,
+                    image: true,
+                    homeCity: true,
+                    homeState: true,
+                },
+            },
+        },
+        orderBy: (event, { asc }) => [asc(event.startsAt)],
+    });
+    return c.json(savedEvents, HttpStatusCodes.OK);
 };

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

@@ -200,6 +200,52 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     to?: string | undefined;
                 };
             };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 401;
+        } | {
+            input: {
+                json: {
+                    sportId: string;
+                    city: string;
+                    state: string;
+                    from?: string | undefined;
+                    to?: string | undefined;
+                };
+            };
+            output: {
+                url: string;
+                title: string;
+                sport: string;
+                startsAt: string;
+                timezone: string;
+                formattedAddress: string;
+                venueName: string;
+            }[];
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+} & {
+    "/events/save-external": {
+        $post: {
+            input: {
+                json: {
+                    events: {
+                        url: string;
+                        title: string;
+                        sport: string;
+                        startsAt: string;
+                        timezone: string;
+                        formattedAddress: string;
+                        venueName: string;
+                    }[];
+                    city: string;
+                    state: string;
+                };
+            };
             output: {
                 metadata: any;
                 id: string;
@@ -244,11 +290,17 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
         } | {
             input: {
                 json: {
-                    sportId: string;
+                    events: {
+                        url: string;
+                        title: string;
+                        sport: string;
+                        startsAt: string;
+                        timezone: string;
+                        formattedAddress: string;
+                        venueName: string;
+                    }[];
                     city: string;
                     state: string;
-                    from?: string | undefined;
-                    to?: string | undefined;
                 };
             };
             output: {

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

@@ -5,5 +5,6 @@ const router = createRouter()
     .openapi(routes.list, handlers.list)
     .openapi(routes.getOne, handlers.getOne)
     .openapi(routes.discover, handlers.discover)
-    .openapi(routes.discoverExternal, handlers.discoverExternal);
+    .openapi(routes.discoverExternal, handlers.discoverExternal)
+    .openapi(routes.saveExternal, handlers.saveExternal);
 export default router;

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

@@ -953,6 +953,125 @@ export declare const discoverExternal: {
             description: string;
         };
     };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodArray<z.ZodObject<{
+                        title: z.ZodString;
+                        sport: z.ZodString;
+                        startsAt: z.ZodString;
+                        timezone: z.ZodString;
+                        url: z.ZodString;
+                        venueName: z.ZodString;
+                        formattedAddress: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        url: string;
+                        title: string;
+                        sport: string;
+                        startsAt: string;
+                        timezone: string;
+                        formattedAddress: string;
+                        venueName: string;
+                    }, {
+                        url: string;
+                        title: string;
+                        sport: string;
+                        startsAt: string;
+                        timezone: string;
+                        formattedAddress: string;
+                        venueName: string;
+                    }>, "many">;
+                };
+            };
+            description: string;
+        };
+        401: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/events/discover/external";
+};
+export declare const saveExternal: {
+    path: "/events/save-external";
+    method: "post";
+    tags: string[];
+    middleware: [import("hono").MiddlewareHandler];
+    request: {
+        body: {
+            required: boolean;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        events: z.ZodArray<z.ZodObject<{
+                            title: z.ZodString;
+                            sport: z.ZodString;
+                            startsAt: z.ZodString;
+                            timezone: z.ZodString;
+                            url: z.ZodString;
+                            venueName: z.ZodString;
+                            formattedAddress: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            url: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            venueName: string;
+                        }, {
+                            url: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            venueName: string;
+                        }>, "many">;
+                        city: z.ZodString;
+                        state: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        events: {
+                            url: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            venueName: string;
+                        }[];
+                        city: string;
+                        state: string;
+                    }, {
+                        events: {
+                            url: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            venueName: string;
+                        }[];
+                        city: string;
+                        state: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
     responses: {
         200: {
             content: {
@@ -1229,9 +1348,10 @@ export declare const discoverExternal: {
         };
     };
 } & {
-    getRoutingPath(): "/events/discover/external";
+    getRoutingPath(): "/events/save-external";
 };
 export type ListRoute = typeof list;
 export type GetOneRoute = typeof getOne;
 export type DiscoverRoute = typeof discover;
 export type DiscoverExternalRoute = typeof discoverExternal;
+export type SaveExternalRoute = typeof saveExternal;

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

@@ -3,7 +3,7 @@ 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, listEventsQuerySchema } from "./schemas/index.js";
+import { eventWithRelationsSchema, externalEventPreviewSchema, listEventsQuerySchema } from "./schemas/index.js";
 export const list = createRoute({
     path: "/events",
     method: "get",
@@ -58,7 +58,24 @@ export const discoverExternal = createRoute({
         body: jsonContentRequired(discoverRequestSchema, "External event discovery criteria"),
     },
     responses: {
-        [HttpStatusCodes.OK]: jsonContent(z.array(eventWithRelationsSchema), "Externally discovered events"),
+        [HttpStatusCodes.OK]: jsonContent(z.array(externalEventPreviewSchema), "External event previews (not yet saved)"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const saveExternal = createRoute({
+    path: "/events/save-external",
+    method: "post",
+    tags: ["Events"],
+    middleware: [isAuth()],
+    request: {
+        body: jsonContentRequired(z.object({
+            events: z.array(externalEventPreviewSchema),
+            city: z.string().min(1),
+            state: z.string().min(1),
+        }), "Selected event previews to save"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(eventWithRelationsSchema), "Saved events with full relations"),
         [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
     },
 });

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

@@ -279,5 +279,31 @@ export declare const listEventsQuerySchema: z.ZodObject<{
     limit?: number | undefined;
     offset?: number | undefined;
 }>;
+export declare const externalEventPreviewSchema: z.ZodObject<{
+    title: z.ZodString;
+    sport: z.ZodString;
+    startsAt: z.ZodString;
+    timezone: z.ZodString;
+    url: z.ZodString;
+    venueName: z.ZodString;
+    formattedAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    title: string;
+    sport: string;
+    startsAt: string;
+    timezone: string;
+    formattedAddress: string;
+    venueName: string;
+}, {
+    url: string;
+    title: string;
+    sport: string;
+    startsAt: string;
+    timezone: string;
+    formattedAddress: string;
+    venueName: string;
+}>;
+export type ExternalEventPreview = z.infer<typeof externalEventPreviewSchema>;
 export type EventWithRelations = z.infer<typeof eventWithRelationsSchema>;
 export type ListEventsQuery = z.infer<typeof listEventsQuerySchema>;

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

@@ -36,3 +36,12 @@ export const listEventsQuerySchema = z.object({
     limit: z.coerce.number().min(1).max(100).optional().default(20),
     offset: z.coerce.number().min(0).optional().default(0),
 });
+export const externalEventPreviewSchema = z.object({
+    title: z.string(),
+    sport: z.string(),
+    startsAt: z.string(),
+    timezone: z.string(),
+    url: z.string(),
+    venueName: z.string(),
+    formattedAddress: z.string(),
+});

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

@@ -1 +1 @@
-export { type EventWithRelations, eventWithRelationsSchema, type ListEventsQuery, listEventsQuerySchema, } from "./event.schemas.js";
+export { type EventWithRelations, eventWithRelationsSchema, type ExternalEventPreview, externalEventPreviewSchema, type ListEventsQuery, listEventsQuerySchema, } from "./event.schemas.js";

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

@@ -1 +1 @@
-export { eventWithRelationsSchema, listEventsQuerySchema, } from "./event.schemas.js";
+export { eventWithRelationsSchema, externalEventPreviewSchema, listEventsQuerySchema, } from "./event.schemas.js";

package/package.json

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