feat: radar rules one api

lib/api/index.ts

@@ -1,7 +1,8 @@
 // import { route as rulesRoute, handler as rulesHandler } from '@/api/radar/rules';
 import { route as namespaceAllRoute, handler as namespaceAllHandler } from '@/api/namespace/all';
 import { route as namespaceOneRoute, handler as namespaceOneHandler } from '@/api/namespace/one';
-import { route as radarRulesRoute, handler as radarRulesHandler } from '@/api/radar/rules';
+import { route as radarRulesAllRoute, handler as radarRulesAllHandler } from '@/api/radar/rules/all';
+import { route as radarRulesOneRoute, handler as radarRulesOneHandler } from '@/api/radar/rules/one';
 import { OpenAPIHono } from '@hono/zod-openapi';
 import { swaggerUI } from '@hono/swagger-ui';
 
@@ -9,7 +10,8 @@ const app = new OpenAPIHono();
 
 app.openapi(namespaceAllRoute, namespaceAllHandler);
 app.openapi(namespaceOneRoute, namespaceOneHandler);
-app.openapi(radarRulesRoute, radarRulesHandler);
+app.openapi(radarRulesAllRoute, radarRulesAllHandler);
+app.openapi(radarRulesOneRoute, radarRulesOneHandler);
 
 const docs = app.getOpenAPI31Document({
     openapi: '3.1.0',

lib/api/radar/rules/all.ts

@@ -42,7 +42,7 @@ const route = createRoute({
     tags: ['Radar'],
     responses: {
         200: {
-            description: 'All radar rules',
+            description: 'All Radar rules',
         },
     },
 });

lib/api/radar/rules/one.ts

@@ -0,0 +1,68 @@
+import { namespaces } from '@/registry';
+import { parse } from 'tldts';
+import { Radar } from '@/types';
+import { z, createRoute, RouteHandler } from '@hono/zod-openapi';
+
+const radar: Radar = {};
+
+for (const namespace in namespaces) {
+    for (const path in namespaces[namespace].routes) {
+        const realPath = `/${namespace}${path}`;
+        const data = namespaces[namespace].routes[path];
+        if (data.radar && data.radar.source) {
+            const parsedDomain = parse(new URL('https://' + data.radar.source[0]).hostname);
+            const subdomain = parsedDomain.subdomain || '.';
+            const domain = parsedDomain.domain;
+            if (domain) {
+                if (!radar[domain]) {
+                    radar[domain] = {
+                        _name: namespaces[namespace].name,
+                    };
+                }
+                if (!radar[domain][subdomain]) {
+                    radar[domain][subdomain] = [];
+                }
+                radar[domain][subdomain].push({
+                    title: data.name,
+                    docs: `https://docs.rsshub.app/routes/${data.categories?.[0] || 'other'}`,
+                    source: data.radar.source.map((source) => {
+                        const sourceURL = new URL('https://' + source);
+                        return sourceURL.pathname + sourceURL.search + sourceURL.hash;
+                    }),
+                    target: data.radar.target || realPath,
+                });
+            }
+        }
+    }
+}
+
+const ParamsSchema = z.object({
+    domain: z.string().openapi({
+        param: {
+            name: 'domain',
+            in: 'path',
+        },
+        example: 'github.com',
+    }),
+});
+
+const route = createRoute({
+    method: 'get',
+    path: '/radar/rules/{domain}',
+    tags: ['Radar'],
+    request: {
+        params: ParamsSchema,
+    },
+    responses: {
+        200: {
+            description: 'Radar rules for a domain name (does not support subdomains)',
+        },
+    },
+});
+
+const handler: RouteHandler<typeof route> = (ctx) => {
+    const { domain } = ctx.req.valid('param');
+    return ctx.json(radar[domain]);
+};
+
+export { route, handler };