How get type of request with context ?

[CarlosZiegler]

Hello,

First I want to say that is a really great library :)

In my case I like to use middlewares and controllers to hanle my request. Then is is great that I can do something like :

my context:

import { zodiosContext } from '@zodios/express';
import z from 'zod';
import { userSchema } from '../schemas/user.schema';

export const ctx = zodiosContext(
	z.object({
		user: userSchema,
	})
);

my route schema:

import { makeApi } from '@zodios/core';
import { userObjSchema } from '../schemas/user.schema';

export const userApi = makeApi([
	{
		method: 'get',
		path: '/',
		alias: 'iam',
		description: 'Get a current user',
		response: userObjSchema,
	},
]);

my route implementation:

That is fine if I do something like:

import { iamMiddleware } from '../middlewares';
import { userApi } from '../api/userApi';
import { ctx } from '../api/context.api';

const userRouter = ctx.router(userApi);

userRouter.use(iamMiddleware.iam);
userRouter.get('/', (req, res) => {
        // I get correct types here :). Thanks ZODIOS / ZOD
	const { id } = req.params;
	const user = req.user;
	res.json({
		user: user,
	});
});

But I want to extract this logic inside a controller:

my controller:

import { NextFunction, Request, Response } from 'express';
import { UserContext, UserRequest } from '../types';
import { userRepository } from '../repository';
import { User } from '@supabase/supabase-js';

// here is the problem, I dont get the types, need to be explicit, I can create a types but think is good that we
// use type generated of request on context. How can I get the request type of ctx ? 

const current = async (req, res) => {
	return res.status(200).json({ user: req.user });
};

Then will to use like:

import { userController } from '../controllers';
import { iamMiddleware } from '../middlewares';
import { userApi } from '../api/userApi';
import { ctx } from '../api/context.api';

const userRouter = ctx.router(userApi);

userRouter.use(iamMiddleware.iam);
userRouter.get('/', userController.current);

The main problem is if I need use the typed request or response on another piece of code, how can I get it ?

Thanks for some tips :)

[lSelectral]

Hello, I asked similar question before.

Here is how you can get typed middleware and controller type definition.

lSelectral/zodios-express-middleware-test@d25871c

export type Middleware<
	M extends Method,
	Path extends ZodiosPathsByMethod<Api, Method>
> = ZodiosRequestHandler<Api, Context, M, Path>

Sample

export const verifyPermissions = <
	M extends Method,
	Path extends ZodiosPathsByMethod<Api, Method>
>(
	...permissions: PermissionType[]
) => {
	const middleware: Middleware<M, Path> = async (req, res, next) => {}}

Controller Sample

	public static create: Middleware<'post', '/booklets'> = async (
		req,
		res
	) => {
		try {
			const result = await this.getService(req, res).create(req.body)
			return res.status(200).json(result)
		} catch (error) {
			return res.status(500).json(ServerError())
		}
	}

[CarlosZiegler]

Hello @lSelectral , sorry for delay but last week I was really busy and thanks for your example!!
Thanks @ecyrbe to provide this library and add this topic on discussions!

After think about it I created an example how I provided my types :

import { ZodiosRequestHandler } from '@zodios/express';
import { makeApi } from '@zodios/core';

import { zodiosContext } from '@zodios/express';
import { z } from 'zod';

export const userSchema = z.object({
	id: z.string(),
	email: z.string().optional(),
	phone: z.string().optional(),
	role: z.string().optional(),
	created_at: z.string(),
	updated_at: z.string().optional(),
});

export const deleteResponseSchema = z.object({
	message: z.string(),
});

// creating a context schema
export const userContext = z.object({
	user: userSchema,
});

// I think I can use it on my handlers but not possible, see comment abobe in controllers 
export type TUserContext = z.infer<typeof userContext>;

// creating a context
export const ctx = zodiosContext(userContext);

// creating an api
export const userApi = makeApi([
	{
		method: 'get',
		path: '/',
		alias: 'iam',
		description: 'Get a current user',
		response: userContext,
	},
	{
		method: 'put',
		path: '/:id',

		alias: 'update',
		description: 'Update user',
		parameters: [
			{
				name: 'user',
				type: 'Body',
				schema: userSchema.pick({ email: true, phone: true, role: true }).required(),
			},
		],
		response: userContext,
	},
	{
		method: 'delete',
		path: '/:id',
		alias: 'delete',
		description: 'Delete current user',
		response: deleteResponseSchema,
	},
]);

// creating a router
const userRouter = ctx.router(userApi);

// using the router without controller:
userRouter.get('/', (req, res) => {
	const { id } = req.params;
	const user = req.user;
	res.json({
		user: user,
	});
});

// ****************************************************************************************************

// using the router with controller:

// creating a API types
export type Api = typeof userApi;

// creting a context from ZOD schema
export type UserContext = typeof userContext;

// using controller with correct request / response types
const getUser: ZodiosRequestHandler<Api, UserContext, 'get', '/'> = async (req, res) => {
	try {
		const result = req.user;
		return res.status(200).json({ user: result });
	} catch (error: any) {
		return res.status(500).json(error);
	}
};

userRouter.get('/', getUser);

// using controller with correct request / response types
const updateUser: ZodiosRequestHandler<Api, UserContext, 'put', '/:id'> = async (req, res) => {
	try {
		const { id } = req.params;
		const { email, phone, role } = req.body;
		// const currentUser = getUserById(id);
		const currentUser = req.user;
		return res.status(200).json({ user: { ...currentUser, email, phone, role } });
	} catch (error: any) {
		return res.status(500).json(error);
	}
};

userRouter.put('/:id', updateUser);

// using controller with correct request / response types
const deleteUser: ZodiosRequestHandler<Api, UserContext, 'delete', '/:id'> = async (req, res) => {
	try {
		const result = req.user;
		// some logic to delete user
		return res.status(200).json({ message: 'User deleted' });
	} catch (error: any) {
		return res.status(500).json(error);
	}
};

userRouter.delete('/:id', deleteUser);

After creating all schemas I can handle request direct on router or I can use controllers pattern, that extract logic of each endpoint to controllers.

I think is really good if we get this types directly from ZODIOS, if is possible, like prisma did.

[ecyrbe]

I think is really good if we get this types directly from ZODIOS, if is possible, like prisma did.

Can you expand a little on what you mean here ?

[CarlosZiegler]

Maybe is not possible, but I mean that if created a API I wnat get the types, maybe is possible if create a generator to handle types in this case.