refactor: Update middleware module imports and remove unused files

Author: aXenDeveloper

packages/vitnode/src/api/modules/middleware/middleware.module.ts

@@ -1,5 +1,5 @@
 import { createModuleApi } from '@/api/lib/module';
-import { test } from '@/test/module';
+import { test } from '@/test/test';
 import { OpenAPIHono } from '@hono/zod-openapi';
 
 import { middlewareRoute } from './route';

packages/vitnode/src/lib/fetcher-new.ts

@@ -0,0 +1,21 @@
+import { Route } from './route';
+import { Test } from './test';
+
+type FetcherParams<
+  T extends { plugin: string; routes: Route },
+  R extends T['routes'][number],
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+> = R extends any
+  ? Pick<R['route'], 'method' | 'path'> & { plugin: T['plugin'] }
+  : never;
+
+function fetcher<T extends { plugin: string; routes: Route }>(
+  params: FetcherParams<T, T['routes'][number]>,
+) {
+  const { path, method, plugin } = params;
+}
+
+export const testFetcher = () => {
+  fetcher<Test>({ path: '/test34', method: 'get', plugin: 'test_plugin' });
+  fetcher<Test>({ path: '/test2', method: 'post', plugin: 'test_plugin' });
+};

packages/vitnode/src/lib/test.ts

@@ -1,23 +1,6 @@
-import {
-  createRoute,
-  OpenAPIHono,
-  RouteConfig,
-  RouteHandler,
-  z,
-} from '@hono/zod-openapi';
+import { OpenAPIHono } from '@hono/zod-openapi';
 
-export const withHandler = <R extends RouteConfig, H extends RouteHandler<R>>({
-  route,
-  handler,
-}: {
-  handler: H;
-  route: R;
-}) => ({ route, handler });
-
-type Route<
-  R extends RouteConfig = RouteConfig,
-  H extends RouteHandler<R> = RouteHandler<R>,
-> = readonly { handler: H; route: R }[];
+import { Route } from './route';
 
 export interface BuildModuleType<T extends Route, Plugin extends string> {
   plugin: Plugin;
@@ -36,70 +19,3 @@ export function buildModule<
 
   return { routes, plugin, hono };
 }
-
-export const test = buildModule({
-  plugin: 'test_plugin',
-  routes: [
-    withHandler({
-      route: createRoute({
-        path: '/test34',
-        method: 'get',
-        responses: {
-          200: {
-            description: 'Success',
-            content: {
-              'application/json': {
-                schema: z.object({ message: z.string() }),
-              },
-            },
-          },
-        },
-      }),
-      handler: c => c.json({ message: 'Success' }),
-    }),
-    withHandler({
-      route: createRoute({
-        path: '/test2',
-        method: 'post',
-        responses: {
-          200: {
-            description: 'Success 2',
-            content: {
-              'application/json': {
-                schema: z.object({
-                  message: z.string(),
-                }),
-              },
-            },
-          },
-        },
-      }),
-      handler: c => {
-        return c.json({
-          message: `Hello from ${c.req.path}`,
-        });
-      },
-    }),
-  ],
-});
-
-type Test = typeof test;
-
-type FetcherParams<
-  T extends { plugin: string; routes: Route },
-  R extends T['routes'][number],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-> = R extends any
-  ? Pick<R['route'], 'method' | 'path'> & { plugin: T['plugin'] }
-  : never;
-
-function fetcher<T extends { plugin: string; routes: Route }>(
-  params: FetcherParams<T, T['routes'][number]>,
-) {
-  const { path, method, plugin } = params;
-}
-
-export const testFetcher = () => {
-  fetcher<Test>({ path: '/test34', method: 'get', plugin: 'test_plugin' });
-  fetcher<Test>({ path: '/test2', method: 'post', plugin: 'test_plugin' });
-};

packages/vitnode/src/lib/test.type.ts

@@ -0,0 +1,39 @@
+import { RouteConfig, RouteHandler } from '@hono/zod-openapi';
+
+type RoutingPath<P extends string> =
+  P extends `${infer Head}/{${infer Param}}${infer Tail}`
+    ? `${Head}/:${Param}${RoutingPath<Tail>}`
+    : P;
+
+type ValidHandler<R extends RouteConfig> = (
+  c: Parameters<RouteHandler<R>>[0],
+) => ReturnType<RouteHandler<R>>;
+
+export const buildRoute = <
+  P extends string,
+  R extends Omit<RouteConfig, 'path'> & {
+    path: P;
+  },
+  H extends ValidHandler<R & { path: P }>,
+>({
+  route,
+  handler,
+}: {
+  handler: H;
+  route: R;
+}): {
+  handler: H;
+  route: R & {
+    getRoutingPath: () => RoutingPath<R['path']>;
+  };
+} => ({
+  route: route as R & {
+    getRoutingPath: () => RoutingPath<R['path']>;
+  },
+  handler,
+});
+
+export type Route<
+  R extends RouteConfig = RouteConfig,
+  H extends RouteHandler<R> = RouteHandler<R>,
+> = readonly { handler: H; route: R }[];

packages/vitnode/src/test/fetcher.ts

@@ -0,0 +1,78 @@
+import { z } from '@hono/zod-openapi';
+
+import { buildModule } from './module';
+import { buildRoute } from './route';
+
+export const test = buildModule({
+  plugin: 'test_plugin',
+  routes: [
+    buildRoute({
+      route: {
+        path: '/test34',
+        method: 'get',
+        responses: {
+          200: {
+            description: 'Success',
+            content: {
+              'application/json': {
+                schema: z.object({ message: z.string() }),
+              },
+            },
+          },
+        },
+      },
+      handler: c => {
+        return c.json({
+          message: `Hello from ${c.req.path}`,
+        });
+      },
+    }),
+    buildRoute({
+      route: {
+        path: '/test2',
+        method: 'post',
+        request: {
+          body: {
+            required: true,
+            content: {
+              'application/json': {
+                schema: z.object({
+                  email: z.string().email().toLowerCase().openapi({
+                    example: 'test@test.com',
+                  }),
+                  password: z.string().openapi({
+                    example: 'Test123!',
+                  }),
+                  isAdmin: z.boolean().optional().openapi({
+                    example: false,
+                  }),
+                }),
+              },
+            },
+          },
+        },
+        responses: {
+          200: {
+            description: 'Success 2',
+            content: {
+              'application/json': {
+                schema: z.object({
+                  message: z.string(),
+                }),
+              },
+            },
+          },
+        },
+      },
+      handler: c => {
+        const { isAdmin, email } = c.req.valid('json');
+
+        return c.json({
+          message: `Got request from ${email} with admin status: ${isAdmin ?? false}`,
+        });
+      },
+    }),
+  ],
+});
+
+export type Test = typeof test;