@lcas58/esmi-api-types 1.0.12 → 1.0.14

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

@@ -1,14 +1,22 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, gte, inArray, lte } 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 } from "../../db/schema/index.js";
+import { event, location } from "../../db/schema/index.js";
 export const list = async (c) => {
     const { db } = createDb(c.env);
     const query = c.req.valid("query");
     const { sportId, source } = query;
     const limit = query.limit ?? 20;
     const offset = query.offset ?? 0;
+    const city = query.city?.trim();
+    const state = query.state?.trim();
+    // Time window (default: now → +7 days)
+    const now = new Date();
+    const from = query.from ? new Date(query.from) : now;
+    const to = query.to
+        ? new Date(query.to)
+        : new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
     const whereConditions = [];
     if (sportId) {
         whereConditions.push(eq(event.sportId, sportId));
@@ -16,6 +24,22 @@ export const list = async (c) => {
     if (source) {
         whereConditions.push(eq(event.source, source));
     }
+    // Time filtering (recommended for feed relevance)
+    whereConditions.push(gte(event.startsAt, from));
+    whereConditions.push(lte(event.startsAt, to));
+    // City/state → locationIds → events
+    if (city && state) {
+        const locations = await db.query.location.findMany({
+            where: and(eq(location.city, city), eq(location.state, state)),
+            columns: { id: true },
+            limit: 1000,
+        });
+        if (locations.length === 0) {
+            return c.json([], HttpStatusCodes.OK);
+        }
+        const locationIds = locations.map((l) => l.id);
+        whereConditions.push(inArray(event.locationId, locationIds));
+    }
     const events = await db.query.event.findMany({
         where: whereConditions.length > 0 ? and(...whereConditions) : undefined,
         with: {
@@ -27,12 +51,14 @@ export const list = async (c) => {
                     id: true,
                     name: true,
                     image: true,
+                    homeCity: true,
+                    homeState: true,
                 },
             },
         },
         limit,
         offset,
-        orderBy: (event, { desc }) => [desc(event.startsAt)],
+        orderBy: (event, { asc }) => [asc(event.startsAt)],
     });
     return c.json(events, HttpStatusCodes.OK);
 };

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

@@ -4,7 +4,11 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
             input: {
                 query: {
                     sportId?: string | string[] | undefined;
+                    city?: string | string[] | undefined;
+                    state?: string | string[] | undefined;
                     source?: string | string[] | undefined;
+                    from?: string | string[] | undefined;
+                    to?: string | string[] | undefined;
                     limit?: string | string[] | undefined;
                     offset?: string | string[] | undefined;
                 };

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

@@ -7,16 +7,28 @@ export declare const list: {
         query: z.ZodObject<{
             sportId: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<["external", "community"]>>;
+            city: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodDate>;
+            to: z.ZodOptional<z.ZodDate>;
             limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
             offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         }, "strip", z.ZodTypeAny, {
             sportId?: string | undefined;
+            city?: string | undefined;
+            state?: string | undefined;
             source?: "external" | "community" | undefined;
+            from?: Date | undefined;
+            to?: Date | undefined;
             limit?: number | undefined;
             offset?: number | undefined;
         }, {
             sportId?: string | undefined;
+            city?: string | undefined;
+            state?: string | undefined;
             source?: "external" | "community" | undefined;
+            from?: Date | undefined;
+            to?: Date | undefined;
             limit?: number | undefined;
             offset?: number | undefined;
         }>;

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

@@ -254,16 +254,28 @@ export declare const eventWithRelationsSchema: z.ZodObject<z.objectUtil.extendSh
 export declare const listEventsQuerySchema: z.ZodObject<{
     sportId: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEnum<["external", "community"]>>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodDate>;
+    to: z.ZodOptional<z.ZodDate>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     sportId?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
     source?: "external" | "community" | undefined;
+    from?: Date | undefined;
+    to?: Date | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }, {
     sportId?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
     source?: "external" | "community" | undefined;
+    from?: Date | undefined;
+    to?: Date | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }>;

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

@@ -29,6 +29,10 @@ export const eventWithRelationsSchema = selectEventSchema.extend({
 export const listEventsQuerySchema = z.object({
     sportId: z.string().optional(),
     source: z.enum(["external", "community"]).optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+    from: z.coerce.date().optional(),
+    to: z.coerce.date().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/users/users.handlers.d.ts

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

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

@@ -0,0 +1,33 @@
+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 { user } from "../../db/schema/index.js";
+export const me = async (c) => {
+    const sessionUser = c.get("user");
+    if (!sessionUser) {
+        return c.json({ message: HttpStatusPhrases.UNAUTHORIZED }, HttpStatusCodes.UNAUTHORIZED);
+    }
+    const { db } = createDb(c.env);
+    const foundUser = await db.query.user.findFirst({
+        where: eq(user.id, sessionUser.id),
+        columns: {
+            id: true,
+            name: true,
+            email: true,
+            emailVerified: true,
+            image: true,
+            onboardingStatus: true,
+            onboardingVersion: true,
+            onboardingCompletedAt: true,
+            homeCity: true,
+            homeState: true,
+            homeCountry: true,
+            sports: true,
+        },
+    });
+    if (!foundUser) {
+        return c.json({ message: HttpStatusPhrases.UNAUTHORIZED }, HttpStatusCodes.UNAUTHORIZED);
+    }
+    return c.json(foundUser, HttpStatusCodes.OK);
+};

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

@@ -0,0 +1,31 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/me": {
+        $get: {
+            input: {};
+            output: {
+                image: string | null;
+                id: string;
+                name: string;
+                email: string;
+                emailVerified: boolean;
+                onboardingStatus: "not_started" | "in_progress" | "completed";
+                onboardingVersion: number;
+                onboardingCompletedAt: string | null;
+                homeCity: string | null;
+                homeState: string | null;
+                homeCountry: string | null;
+                sports: string[] | null;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 401;
+        };
+    };
+}, "/">;
+export default router;

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

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

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

@@ -0,0 +1,72 @@
+import { z } from "@hono/zod-openapi";
+export declare const me: {
+    path: "/me";
+    method: "get";
+    tags: string[];
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        email: z.ZodString;
+                        emailVerified: z.ZodBoolean;
+                        image: z.ZodNullable<z.ZodString>;
+                        onboardingStatus: z.ZodEnum<["not_started", "in_progress", "completed"]>;
+                        onboardingVersion: z.ZodNumber;
+                        onboardingCompletedAt: z.ZodNullable<z.ZodDate>;
+                        homeCity: z.ZodNullable<z.ZodString>;
+                        homeState: z.ZodNullable<z.ZodString>;
+                        homeCountry: z.ZodNullable<z.ZodString>;
+                        sports: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+                    }, "strip", z.ZodTypeAny, {
+                        image: string | null;
+                        id: string;
+                        name: string;
+                        email: string;
+                        emailVerified: boolean;
+                        onboardingStatus: "not_started" | "in_progress" | "completed";
+                        onboardingVersion: number;
+                        onboardingCompletedAt: Date | null;
+                        homeCity: string | null;
+                        homeState: string | null;
+                        homeCountry: string | null;
+                        sports: string[] | null;
+                    }, {
+                        image: string | null;
+                        id: string;
+                        name: string;
+                        email: string;
+                        emailVerified: boolean;
+                        onboardingStatus: "not_started" | "in_progress" | "completed";
+                        onboardingVersion: number;
+                        onboardingCompletedAt: Date | null;
+                        homeCity: string | null;
+                        homeState: string | null;
+                        homeCountry: string | null;
+                        sports: string[] | null;
+                    }>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/me";
+};
+export type MeRoute = typeof me;

package/dist/src/routes/users/users.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 { unauthorizedSchema } from "../../lib/constants.js";
+const userProfileSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+    emailVerified: z.boolean(),
+    image: z.string().nullable(),
+    onboardingStatus: z.enum(["not_started", "in_progress", "completed"]),
+    onboardingVersion: z.number(),
+    onboardingCompletedAt: z.date().nullable(),
+    homeCity: z.string().nullable(),
+    homeState: z.string().nullable(),
+    homeCountry: z.string().nullable(),
+    sports: z.array(z.string()).nullable(),
+});
+export const me = createRoute({
+    path: "/me",
+    method: "get",
+    tags: ["Users"],
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(userProfileSchema, "Current user profile"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Not authenticated"),
+    },
+});

package/package.json

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