chore: remove classes

Author: GabrielMartinezRodriguez

apps/faucet/src/faucet.route.ts

@@ -1,67 +1,75 @@
 import { isAddress } from "@happy.tech/common"
-import type { Hono } from "hono"
+import type { Context } from "hono"
 import { describeRoute } from "hono-openapi"
 import { resolver } from "hono-openapi/zod"
 import { validator } from "hono-openapi/zod"
+import type { BlankEnv } from "hono/types"
 import { err } from "neverthrow"
+import type { Address } from "viem"
 import { z } from "zod"
 import { env } from "./env"
-import type { CloudflareService } from "./services/cloudflare"
-import type { FaucetService } from "./services/faucet"
+import { cloudflareService } from "./services/cloudflare"
+import { faucetService } from "./services/faucet"
 import { makeResponse } from "./utils"
 
+type Request = {
+    json: {
+        address: Address
+        cfToken: string
+    }
+}
+
 export const inputSchema = z.object({
     address: z.string().refine(isAddress),
     cfToken: z.string(),
 })
 
 export const outputSchema = z.object({
     success: z.boolean(),
-    message: z.string(),
+    message: z.string().optional(),
 })
 
 export type FaucetInput = z.infer<typeof inputSchema>
 export type FaucetOutput = z.infer<typeof outputSchema>
 
-export const setupFaucetRoutes = (app: Hono, faucetService: FaucetService, cloudflareService: CloudflareService) => {
-    const validation = validator("json", inputSchema)
-    const description = describeRoute({
-        description: "Faucet endpoint with Cloudflare Turnstile validation",
-        responses: {
-            200: {
-                description: "Tokens sent",
-                content: { "application/json": { schema: resolver(outputSchema) } },
-            },
-            403: {
-                description: "Turnstile verification failed",
-                content: { "application/json": { schema: resolver(outputSchema) } },
-            },
-            429: {
-                description: "Rate limit exceeded",
-                content: { "application/json": { schema: resolver(outputSchema) } },
-            },
-        },
-        validateResponse: env.NODE_ENV !== "production",
-    })
-
-    app.post("/faucet", validation, description, async (c) => {
-        try {
-            const { address, cfToken } = c.req.valid("json")
+export const validation = validator("json", inputSchema)
 
-            const captchaResult = await cloudflareService.verifyTurnstile(cfToken)
+export const description = describeRoute({
+    description: "Faucet endpoint with Cloudflare Turnstile validation",
+    responses: {
+        200: {
+            description: "Tokens sent",
+            content: { "application/json": { schema: resolver(outputSchema) } },
+        },
+        403: {
+            description: "Turnstile verification failed",
+            content: { "application/json": { schema: resolver(outputSchema) } },
+        },
+        429: {
+            description: "Rate limit exceeded",
+            content: { "application/json": { schema: resolver(outputSchema) } },
+        },
+    },
+    validateResponse: env.NODE_ENV !== "production",
+})
 
-            if (captchaResult.isErr()) {
-                const response = makeResponse(captchaResult)
-                return c.json(response[0], response[1])
-            }
+export const faucetHandler = async (c: Context<BlankEnv, "/faucet", { in: Request; out: Request }>) => {
+    try {
+        const { address, cfToken } = c.req.valid("json")
 
-            const result = await faucetService.sendTokens(address)
+        const captchaResult = await cloudflareService.verifyTurnstile(cfToken)
 
-            const response = makeResponse(result)
-            return c.json(response[0], response[1])
-        } catch (error) {
-            const response = makeResponse(err(error))
+        if (captchaResult.isErr()) {
+            const response = makeResponse(captchaResult)
             return c.json(response[0], response[1])
         }
-    })
+
+        const result = await faucetService.sendTokens(address)
+
+        const response = makeResponse(result)
+        return c.json(response[0], response[1])
+    } catch (error) {
+        const response = makeResponse(err(error))
+        return c.json(response[0], response[1])
+    }
 }

apps/faucet/src/index.ts

@@ -1,4 +1,75 @@
-import { Server } from "./server"
+import { serve } from "@hono/node-server"
+import { apiReference } from "@scalar/hono-api-reference"
+import { Hono } from "hono"
+import { openAPISpecs } from "hono-openapi"
+import { cors } from "hono/cors"
+import { logger as loggerMiddleware } from "hono/logger"
+import { prettyJSON as prettyJSONMiddleware } from "hono/pretty-json"
+import { requestId as requestIdMiddleware } from "hono/request-id"
+import { timeout as timeoutMiddleware } from "hono/timeout"
+import { timing as timingMiddleware } from "hono/timing"
+import pkg from "../package.json" assert { type: "json" }
+import { env } from "./env"
+import { description, faucetHandler, validation } from "./faucet.route"
+import { faucetService } from "./services/faucet"
 
-const server = new Server()
-server.start()
+const app = new Hono()
+
+// Middleware setup
+app.use(
+    "*",
+    cors({
+        origin: "*",
+    }),
+)
+app.use("*", timingMiddleware())
+app.use("*", loggerMiddleware())
+app.use("*", prettyJSONMiddleware())
+app.use("*", timeoutMiddleware(30_000))
+app.use("*", requestIdMiddleware())
+
+// Routes setup
+app.get("/", (c) => c.text("Welcome to the Faucet Service!"))
+
+// Faucet route
+app.post("/faucet", validation, description, faucetHandler)
+
+// OpenAPI documentation
+app.get(
+    "/docs/openapi.json",
+    openAPISpecs(app, {
+        documentation: {
+            info: { title: "Faucet", version: pkg.version, description: "Faucet API" },
+            servers: [
+                ...(env.NODE_ENV === "development"
+                    ? [
+                          {
+                              url: `http://localhost:${env.APP_PORT}`,
+                              description: "Local",
+                          },
+                      ]
+                    : []),
+                { url: "https://faucet.testnet.happy.tech", description: "Testnet" },
+            ],
+        },
+    }),
+)
+
+// API Reference UI
+app.get(
+    "/docs",
+    apiReference({
+        pageTitle: "Faucet API Reference - HappyChain",
+        theme: "kepler",
+        spec: { url: "/docs/openapi.json" },
+        showSidebar: true,
+        hideSearch: false,
+    }),
+)
+
+export async function startServer() {
+    await faucetService.start()
+    serve({ fetch: app.fetch, port: env.APP_PORT })
+}
+
+startServer()

apps/faucet/src/server.ts

@@ -1,17 +1,18 @@
 import { type Result, ResultAsync, err, ok } from "neverthrow"
 import { z } from "zod"
+import { env } from "../env"
 import { FaucetCaptchaError, type FaucetFetchError } from "../errors"
 import { mapFetchError } from "../utils"
 
 export const siteVerifyResponseSchema = z.object({
-    success: z.boolean(),
+    success: z.literal(true),
 })
 
 export class CloudflareService {
     private readonly secret: string
 
-    constructor(secret: string) {
-        this.secret = secret
+    constructor() {
+        this.secret = env.TURNSTILE_SECRET
     }
 
     async verifyTurnstile(token: string): Promise<Result<undefined, FaucetCaptchaError | FaucetFetchError>> {
@@ -38,3 +39,5 @@ export class CloudflareService {
         return ok(undefined)
     }
 }
+
+export const cloudflareService = new CloudflareService()

apps/faucet/src/services/cloudflare.ts

@@ -4,20 +4,20 @@ import type { Address } from "viem"
 import { env } from "../env"
 import { FaucetRateLimitError } from "../errors"
 import { FaucetUsage } from "../faucet-usage.entity"
-import type { FaucetUsageRepository } from "../faucet-usage.repository"
+import { FaucetUsageRepository } from "../faucet-usage.repository"
 
 export class FaucetService {
     private txm: TransactionManager
     private faucetUsageRepository: FaucetUsageRepository
 
-    constructor(faucetUsageRepository: FaucetUsageRepository) {
+    constructor() {
         this.txm = new TransactionManager({
             rpc: { url: env.RPC_URL },
             chainId: env.CHAIN_ID,
             blockTime: env.BLOCK_TIME,
             privateKey: env.PRIVATE_KEY,
         })
-        this.faucetUsageRepository = faucetUsageRepository
+        this.faucetUsageRepository = new FaucetUsageRepository()
     }
 
     async start() {
@@ -47,3 +47,5 @@ export class FaucetService {
         return ok(undefined)
     }
 }
+
+export const faucetService = new FaucetService()