Custom RouteHandler type

[WildEgo]

Hey guys was wondering, what is the best way to implement a RouteHandler like the one present in @hono/zod-openapi based on my function below createRoute, I am using hono-openapi for .lazy() and a couple other features

import { db } from '@/database';
import type { Table } from 'drizzle-orm';
import { getTableConfig } from 'drizzle-orm/pg-core';
import type { Env, Handler, MiddlewareHandler, TypedResponse } from 'hono';
import { describeRoute, type DescribeRouteOptions } from 'hono-openapi';
import { resolver, validator } from 'hono-openapi/zod';
import { z, type AnyZodObject, type ZodTypeAny } from 'zod';
import type { Require } from './types';

export function resolveParamRecords<T extends Table>(table: T) {
  const config = getTableConfig(table);

  const type = z
    .string()
    .uuid()
    .transform(async (id, ctx) => {
      // @ts-ignore: This and the below ignores are there due to it needing to be a generic.
      const result = await db.query[config.name as keyof typeof schema].findFirst({
        where: {
          id,
        },
      });

      if (!result) {
        ctx.addIssue({
          code: z.ZodIssueCode.custom,
          message: 'Not found',
        });

        return z.NEVER;
      }

      return result as T['$inferSelect'];
    })
    .openapi({
      description: `Identification for table \`${config.name}\``,
    });

  // TODO Replace this with Metadata in Zod V4
  type._def.model = config.name;

  return type;
}

export const RequestMethod = {
  GET: 'get',
  POST: 'post',
  PUT: 'put',
  PATCH: 'patch',
  DELETE: 'delete',
} as const;

type BodyContentHeader = 'application/json' | 'multipart/form-data';

const responses = {
  404: {
    content: {
      'application/json': {
        schema: resolver(
          z.object({
            message: z.string().openapi({ example: 'Not found' }),
          }),
        ),
      },
    },
    description: 'Record not found',
  },
  500: {
    content: {
      'application/json': {
        schema: resolver(
          z.object({
            message: z.string().openapi({ example: 'Internal server error' }),
          }),
        ),
      },
    },
    description: 'Internal server error',
  },
} as const;

type Hook = Parameters<typeof validator>[2];

const defaultHook: Hook = (result, c) => {
  if (!result.success) {
    if (result.error.issues.find((issue) => issue.code === 'custom' && issue.message === 'Not found')) {
      return c.json(
        {
          message: 'Not found',
        },
        404,
      );
    }

    return c.json(
      {
        message: 'Failed validation',
        errors: result.error.flatten().fieldErrors,
      },
      422,
    );
  }
};

export type RouteInput<
  Query extends AnyZodObject,
  Params extends AnyZodObject,
  Headers extends AnyZodObject,
  Json extends AnyZodObject,
  Form extends AnyZodObject,
  Content extends Partial<Record<BodyContentHeader, { schema: AnyZodObject }>> = {
    'application/json'?: { schema: Json };
    'multipart/form-data'?: { schema: Form };
  },
> = Require<DescribeRouteOptions, 'responses'> & {
  path: string;
  method: keyof typeof RequestMethod;
  request?: {
    query?: Query;
    params?: Params;
    body?: {
      content: Content;
    };
    headers?: Headers;
  };
};

export type RouteOutput<
  Query extends AnyZodObject,
  Params extends AnyZodObject,
  Headers extends AnyZodObject,
  Json extends AnyZodObject,
  Form extends AnyZodObject,
  Content extends Partial<Record<BodyContentHeader, { schema: AnyZodObject }>>,
  R extends RouteInput<Query, Params, Headers, Json, Form, Content> = RouteInput<
    Query,
    Params,
    Headers,
    Json,
    Form,
    Content
  >,
> = {
  path: R['path'];
  method: (typeof RequestMethod)[keyof typeof RequestMethod];
  request?: R['request'];
  validators: MiddlewareHandler[];
  description: DescribeRouteOptions;
  route: ReturnType<typeof describeRoute>;
};

export function createRoute<
  Query extends AnyZodObject = AnyZodObject,
  Params extends AnyZodObject = AnyZodObject,
  Headers extends AnyZodObject = AnyZodObject,
  Json extends AnyZodObject = AnyZodObject,
  Form extends AnyZodObject = AnyZodObject,
  Content extends Partial<Record<BodyContentHeader, { schema: AnyZodObject }>> = {
    'application/json'?: { schema: Json };
    'multipart/form-data'?: { schema: Form };
  },
  R extends RouteInput<Query, Params, Headers, Json, Form, Content> = RouteInput<
    Query,
    Params,
    Headers,
    Json,
    Form,
    Content
  >,
>({ path, method, request, ...description }: R): RouteOutput<Query, Params, Headers, Json, Form, Content, R> {
  const validators: MiddlewareHandler[] = [];

  if (request?.query) {
    validators.push(validator('query', request.query, defaultHook));
  }

  if (request?.headers) {
    validators.push(validator('header', request.headers, defaultHook));
  }

  if (request?.params) {
    validators.push(validator('param', request.params, defaultHook));

    // Has model so can 404
    if (Object.values(request.params.shape).findIndex((value) => !!(value as ZodTypeAny)?._def.model) !== -1) {
      description.responses[404] = responses[404];
    }
  }

  const content = request?.body?.content;
  if (content?.['application/json']) {
    validators.push(validator('json', content['application/json'].schema, defaultHook));
  }

  if (content?.['multipart/form-data']) {
    validators.push(validator('json', content['multipart/form-data'].schema, defaultHook));
  }

  description.responses[500] = responses[500];

  return {
    path,
    method: RequestMethod[method],
    request,
    validators,
    description,
    route: describeRoute(description),
  };
}