[zod-openapi] Question - Generic createRoute generator

[DBain07]

I would like to hear opinions on something like this. I was just trying to think of ways to further simplify creating new routes to reduce duplication.

import type {
  ResponseConfig,
  RouteParameter,
  ZodRequestBody,
} from '@asteasolutions/zod-to-openapi/dist/openapi-registry.js';
import { createRoute, type RouteConfig } from '@hono/zod-openapi';
import type { StatusCode } from 'hono/utils/http-status';
import type { ZodSchema } from 'zod';
import type { Scopes } from '../env/scopes.mjs';
import {
  generateScopeDescription,
  validateCallerScopes,
} from '../middlewares/validate-caller-scopes/validate-caller-scopes.middleware.mjs';
import { getFilteredCommonResponses } from './filter-common-responses.utils.mjs';

const security = [{ 'x-api-key': [] }];

interface RouteOptions {
  method: 'get' | 'post' | 'patch' | 'delete';
  path: string;
  paramsSchema?: RouteParameter;
  bodySchema?: ZodRequestBody;
  scopes: Scopes[];
  tags: string[];
  description: string;
  successSchema: ZodSchema<unknown>;
  requiredResponses: StatusCode[];
  additionalResponses?: Record<number, any>;
  isPublic?: boolean;
}

export function createGenericRoute<
  TRequest extends RouteConfig['request'] | undefined,
  TResponse extends { [key in StatusCode]?: ResponseConfig },
>(options: RouteOptions) {
  const filteredCommonResponses = getFilteredCommonResponses(
    options.requiredResponses,
  );
  return createRoute({
    method: options.method,
    path: options.path,
    request: {
      // add query and whatnot
      ...(options.paramsSchema
        ? { params: options.paramsSchema }
        : { params: undefined }),
      ...(options.bodySchema
        ? {
            body: {
              content: { 'application/json': { schema: options.bodySchema } },
            },
          }
        : { body: undefined }),
    } as TRequest,
    // type?
    middleware: options.isPublic
      ? []
      : [validateCallerScopes<Scopes>({ scopes: options.scopes })],
    responses: {
      200: {
        content: {
          'application/json': {
            schema: options.successSchema,
          },
        },
        description: 'Success',
      },
      ...filteredCommonResponses,
      ...options.additionalResponses,
      // any way to remove as unknown
    } as unknown as TResponse,
    // dynamoic security
    security: options.isPublic ? [] : security,
    tags: options.tags,
    description: [
      options.description,
      generateScopeDescription<Scopes>(options.scopes),
    ].join('\n'),
  });
}

and its usage:

export const updateUserIdRoute = createGenericRoute<
  {
    params: typeof EmailToUserIdParamsSchema;
    body: typeof requestBody;
  },
  typeof res
>({
  method: 'patch',
  path: '/userId/{email}',
  paramsSchema: ParamsSchema,
  bodySchema: getRequestBodySchema(User),
  scopes: ['plane:service:update:user'],
  tags: ['User'],
  description: 'Updates information associated with user.',
  successSchema: User,
  requiredResponses: [400, 401, 403, 409, 500],
});