feat: api type improvements

Author: didinele

apps/website/src/data/client.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import type { GetAMAsQuery, GetAuthMeQuery, InferAPIRouteResult } from '@chatsift/api';
+import type { CreateAMABody, GetAMAsQuery, GetAuthMeQuery, InferAPIRouteResult } from '@chatsift/api';
 import type { QueryClient } from '@tanstack/react-query';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import type { GettableRoutes, MakeOptions } from './common';
@@ -25,6 +25,7 @@ function make<Options extends MakeOptions & { path: GettableRoutes }>({ path, qu
 		const fetcher = useClientSideFetcher({ path: finalPath as `/${string}`, method: 'GET' });
 		return useQuery({
 			queryKey,
+			// @ts-expect-error - This won't ever compile
 			queryFn: async () => fetcher() as Promise<InferAPIRouteResult<Options['path'], 'GET'> | null>,
 			throwOnError: clientSideErrorHandler({ throwOverride: false }),
 			refetchOnWindowFocus: false,
@@ -76,12 +77,21 @@ function makeMutation<Options extends MakeOptions, Method extends 'DELETE' | 'PA
 
 export const client = {
 	auth: {
-		useMe: (query?: GetAuthMeQuery) => make(routesInfo.auth.me(query ?? { force_fresh: false }))(),
+		useMe: (query?: GetAuthMeQuery) => make(routesInfo.auth.me(query ?? { force_fresh: 'false' }))(),
 		useLogout: makeMutation(routesInfo.auth.logout, 'POST', async (queryClient) => queryClient.invalidateQueries()),
 	},
 
 	guilds: {
 		ama: {
+			createAMA: (guildId: string) =>
+				makeMutation(routesInfo.guilds(guildId).ama.amas(), 'POST', async (queryClient) => {
+					await queryClient.invalidateQueries({
+						queryKey: [
+							routesInfo.guilds(guildId).ama.amas({ include_ended: 'false' }).queryKey,
+							routesInfo.guilds(guildId).ama.amas({ include_ended: 'true' }).queryKey,
+						],
+					});
+				})(),
 			useAMAs: (guildId: string, query: GetAMAsQuery) => make(routesInfo.guilds(guildId).ama.amas(query))(),
 		},
 	},

apps/website/src/data/common.ts

@@ -47,10 +47,10 @@ export const routesInfo = {
 
 	guilds: (guildId: string) => ({
 		ama: {
-			amas: (query: GetAMAsQuery) => ({
-				queryKey: ['guilds', guildId, 'ama', 'amas', String(query.include_ended)],
+			amas: (query?: GetAMAsQuery) => ({
+				queryKey: ['guilds', guildId, 'ama', 'amas', String(query?.include_ended ?? false)],
 				path: '/v3/guilds/:guildId/ama/amas',
-				query,
+				query: { include_ended: query?.include_ended ?? 'false' },
 				params: { guildId },
 			}),
 		},

services/api/src/index.ts

@@ -17,7 +17,7 @@ export type * from './routes/_types/index.js';
 export async function bin(): Promise<void> {
 	const app = polka({
 		onError(err, req, res) {
-			context.logger.error({ err, trackingId: (req as TRequest<unknown>).trackingId }, 'request error');
+			context.logger.error({ err, trackingId: (req as TRequest<any>).trackingId }, 'request error');
 
 			if (res.writableEnded) {
 				return;

services/api/src/routes/_types/routeTypes.ts

@@ -1,3 +1,4 @@
+export type * from '../ama/createAMA.js';
 export type * from '../ama/getAMAs.js';
 
 export type * from '../auth/discord.js';

services/api/src/routes/ama/createAMA.ts

@@ -44,11 +44,11 @@ const bodySchema = z.intersection(
 	promptSchema,
 );
 
-export type CreateAMABody = z.infer<typeof bodySchema>;
+export type CreateAMABody = z.input<typeof bodySchema>;
 
 export type CreateAMAResult = Selectable<AMASession>;
 
-export default class CreateAMA extends Route<CreateAMAResult, CreateAMABody> {
+export default class CreateAMA extends Route<CreateAMAResult, typeof bodySchema> {
 	public readonly info = {
 		method: RouteMethod.post,
 		path: '/v3/guilds/:guildId/ama/amas',
@@ -60,8 +60,8 @@ export default class CreateAMA extends Route<CreateAMAResult, CreateAMABody> {
 		...isAuthed({ fallthrough: false, isGlobalAdmin: false, isGuildManager: true }),
 	];
 
-	public override async handle(req: TRequest<CreateAMABody>, res: Response, next: NextHandler) {
-		const data = req.body as CreateAMABody;
+	public override async handle(req: TRequest<typeof bodySchema>, res: Response, next: NextHandler) {
+		const data = req.body;
 		const { guildId } = req.params as { guildId: string };
 
 		// TODO(DD): Reconsider?

services/api/src/routes/ama/getAMAs.ts

@@ -1,25 +1,25 @@
 import type { AMASession } from '@chatsift/core';
 import type { Selectable } from 'kysely';
 import type { NextHandler, Response } from 'polka';
-import { z } from 'zod';
+import { z, input } from 'zod';
 import { context } from '../../context.js';
 import { isAuthed } from '../../middleware/isAuthed.js';
 import type { TRequest } from '../route.js';
 import { Route, RouteMethod } from '../route.js';
 
 const querySchema = z
 	.object({
-		include_ended: z.string().pipe(z.coerce.boolean()).default(false),
+		include_ended: z.stringbool().optional().default(false),
 	})
 	.strict();
 
-export type GetAMAsQuery = z.infer<typeof querySchema>;
+export type GetAMAsQuery = z.input<typeof querySchema>;
 
 export interface AMASessionWithCount extends Selectable<AMASession> {
 	questionCount: number;
 }
 
-export default class GetAMAs extends Route<AMASessionWithCount[], GetAMAsQuery> {
+export default class GetAMAs extends Route<AMASessionWithCount[], typeof querySchema> {
 	public readonly info = {
 		method: RouteMethod.get,
 		path: '/v3/guilds/:guildId/ama/amas',
@@ -31,8 +31,8 @@ export default class GetAMAs extends Route<AMASessionWithCount[], GetAMAsQuery>
 		...isAuthed({ fallthrough: false, isGlobalAdmin: false, isGuildManager: true }),
 	];
 
-	public override async handle(req: TRequest<GetAMAsQuery>, res: Response, next: NextHandler) {
-		const { include_ended } = req.query as unknown as GetAMAsQuery;
+	public override async handle(req: TRequest<typeof querySchema>, res: Response, next: NextHandler) {
+		const { include_ended } = req.query;
 		const { guildId } = req.params as { guildId: string };
 
 		let query = context.db.selectFrom('AMASession').selectAll().where('guildId', '=', guildId);

services/api/src/routes/auth/discordCallback.ts

@@ -20,9 +20,8 @@ const querySchema = z
 		state: z.string(),
 	})
 	.strict();
-type Query = z.infer<typeof querySchema>;
 
-export default class GetAuthDiscordCallback extends Route<never, Query> {
+export default class GetAuthDiscordCallback extends Route<never, typeof querySchema> {
 	public readonly info = {
 		method: RouteMethod.get,
 		path: '/v3/auth/discord/callback',
@@ -32,13 +31,13 @@ export default class GetAuthDiscordCallback extends Route<never, Query> {
 
 	public override readonly middleware = [...isAuthed({ fallthrough: true, isGlobalAdmin: false })];
 
-	public override async handle(req: TRequest<never>, res: Response, next: NextHandler) {
+	public override async handle(req: TRequest<typeof querySchema>, res: Response, next: NextHandler) {
 		if (req.tokens) {
 			res.redirect(context.env.FRONTEND_URL);
 			return res.end();
 		}
 
-		const { code, state: stateQuery } = req.query as Query;
+		const { code, state: stateQuery } = req.query;
 
 		const parsedCookies = cookie.parse(req.headers.cookie ?? '');
 		if (stateQuery !== parsedCookies['state']) {

services/api/src/routes/auth/me.ts

@@ -10,12 +10,12 @@ export type { Me, MeGuild } from '../../util/me.js';
 
 const querySchema = z
 	.object({
-		force_fresh: z.string().pipe(z.coerce.boolean()).default(false),
+		force_fresh: z.stringbool().optional().default(false),
 	})
 	.strict();
-export type GetAuthMeQuery = z.infer<typeof querySchema>;
+export type GetAuthMeQuery = z.input<typeof querySchema>;
 
-export default class GetAuthMe extends Route<Me, GetAuthMeQuery> {
+export default class GetAuthMe extends Route<Me, typeof querySchema> {
 	public readonly info = {
 		method: RouteMethod.get,
 		path: '/v3/auth/me',
@@ -27,8 +27,8 @@ export default class GetAuthMe extends Route<Me, GetAuthMeQuery> {
 		...isAuthed({ fallthrough: false, isGlobalAdmin: false, isGuildManager: false }),
 	];
 
-	public override async handle(req: TRequest<never>, res: Response, next: NextHandler) {
-		const { force_fresh } = req.query as unknown as GetAuthMeQuery;
+	public override async handle(req: TRequest<typeof querySchema>, res: Response, next: NextHandler) {
+		const { force_fresh } = req.query;
 
 		const result: Me = await fetchMe(req.tokens!.access.discordAccessToken, force_fresh);
 

services/api/src/routes/route.ts

@@ -2,7 +2,7 @@ import { performance } from 'node:perf_hooks';
 import { setTimeout, clearTimeout } from 'node:timers';
 import { nanoid } from 'nanoid';
 import type { IError, Middleware, NextHandler, Polka, Request, Response } from 'polka';
-import type { ZodType } from 'zod';
+import type { z, ZodType } from 'zod';
 import { context } from '../context.js';
 import { jsonParser } from '../middleware/jsonParser.js';
 import { validate } from '../middleware/validate.js';
@@ -33,13 +33,20 @@ export interface RouteInfo {
 }
 
 // TODO: More generics?
-export type TRequest<TBody> = Omit<Request, 'body'> & { body: TBody; trackingId: string };
+export type TRequest<TBodyOrQueryZodType extends ZodType<any> | never> = Omit<Request, 'body' | 'query'> & {
+	body: TBodyOrQueryZodType extends never ? never : z.infer<TBodyOrQueryZodType>;
+	query: TBodyOrQueryZodType extends never ? never : z.infer<TBodyOrQueryZodType>;
+	trackingId: string;
+};
 
 /**
  * Represents a route on the server
  */
-export abstract class Route<TResult, TBodyOrQuery> {
-	public readonly __internalOnlyHereForTypeInferrenceDoNotUse__!: { bodyOrQuery: TBodyOrQuery; result: TResult };
+export abstract class Route<TResult, TBodyOrQueryZodType extends ZodType<any> | never> {
+	public readonly __internalOnlyHereForTypeInferrenceDoNotUse__!: {
+		bodyOrQuery: z.infer<TBodyOrQueryZodType>;
+		result: TResult;
+	};
 
 	/**
 	 * Base route information
@@ -49,30 +56,30 @@ export abstract class Route<TResult, TBodyOrQuery> {
 	/**
 	 * Middleware to use for this route - needs to be overriden by subclasses
 	 */
-	public readonly middleware: Middleware<TRequest<unknown>>[] = [];
+	public readonly middleware: Middleware<TRequest<any>>[] = [];
 
 	/**
 	 * Schema to use for body validation. Implicitly appends a jsonParser to the middleware
 	 */
-	public readonly bodyValidationSchema: ZodType<TBodyOrQuery> | null = null;
+	public readonly bodyValidationSchema: TBodyOrQueryZodType | null = null;
 
 	/**
 	 * Schema to use for query validation.
 	 */
-	public readonly queryValidationSchema: ZodType<TBodyOrQuery> | null = null;
+	public readonly queryValidationSchema: TBodyOrQueryZodType | null = null;
 
 	/**
 	 * Handles a request to this route
 	 */
-	public abstract handle(req: TRequest<TBodyOrQuery>, res: Response, next: NextHandler): unknown;
+	public abstract handle(req: TRequest<z.infer<TBodyOrQueryZodType>>, res: Response, next: NextHandler): unknown;
 
 	/**
 	 * Registers this route
 	 *
 	 * @param server - The Polka webserver to register this route onto
 	 */
-	public register(server: Polka<TRequest<unknown>>): void {
-		const middleware: Middleware<TRequest<unknown>>[] = [
+	public register(server: Polka<TRequest<any>>): void {
+		const middleware: Middleware<TRequest<any>>[] = [
 			async (req, res, next) => {
 				req.trackingId = nanoid(10);
 
@@ -124,7 +131,7 @@ export abstract class Route<TResult, TBodyOrQuery> {
 					{ trackingId: req.trackingId, method: req.method, path: req.path },
 					'passing to route handler from middleware',
 				);
-				await this.handle(req as TRequest<TBodyOrQuery>, res, next);
+				await this.handle(req as TRequest<z.infer<TBodyOrQueryZodType>>, res, next);
 				context.logger.info(
 					{ trackingId: req.trackingId, method: req.method, path: req.path },
 					'route handler complete',
@@ -148,8 +155,8 @@ export type ParseHTTPParameters<
 export type InferRouteMethod<TRoute extends Route<any, any>> = TRoute['info']['method'];
 export type InferRouteResult<TRoute> = TRoute extends Route<infer TResult, any> ? TResult : never;
 export type InferRouteBodyOrQuery<TRoute extends Route<any, any>> =
-	TRoute['bodyValidationSchema'] extends ZodType<infer Body>
+	TRoute['bodyValidationSchema'] extends ZodType<any, infer Body>
 		? Body
-		: TRoute['queryValidationSchema'] extends ZodType<infer Query>
+		: TRoute['queryValidationSchema'] extends ZodType<any, infer Query>
 			? Query
 			: never;

services/api/src/routes/routes.ts

@@ -1,5 +1,6 @@
 // This file should exclusively re-export the default exports from each route file
 
+export { default as CreateAMA } from './ama/createAMA.js';
 export { default as GetAMAs } from './ama/getAMAs.js';
 
 export { default as GetAuthDiscord } from './auth/discord.js';