@interknot/pom-pom 0.1.0

package/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,149 @@
+<div align="center">
+    <img src="docs/pom-pom.webp" alt="PomPom Logo" width="150" />
+    <h1>PomPom</h1>
+    <p>Express-like wrapper around <code>Bun.serve</code></p>
+    <sub>Our little Express' Conductor</sub>
+</div>
+
+## Disclaimer
+This project will not work in Node.js, it's built specifically for Bun. If you want an Express-like framework for Node.js, consider using Express itself or Fastify.
+
+## Installation
+```sh
+bun install @interknot/pom-pom
+```
+
+## Usage
+Use it exactly as you would use Express.js.
+```ts
+import { PomPom, PomResponse } from "@interknot/pom-pom"
+
+const app = new PomPom()
+
+app.get("/hello", (req, res) => {
+    return res.text("Hello, world!")
+})
+
+app.listen(3000, () => {
+    console.log("Server is running on http://localhost:3000")
+})
+```
+
+## Middlewares
+Supported middlewares: `cors`
+```ts
+import { cors } from "@interknot/pom-pom/middlewares"
+
+app.use(cors({
+    origin: "https://example.com"
+}))
+```
+
+## Router
+PomPom includes a file-system based router that follows Next.js style routing.
+```ts
+import { PomPom, registerRoutes } from "@interknot/pom-pom"
+
+const app = new PomPom()
+
+registerRoutes(app, "./routes")
+```
+### Example directory structure
+```
+/routes
+  /api
+    /users
+      [id].ts         --> /api/users/:id
+      index.ts        --> /api/users
+    index.ts          --> /api
+    /about.ts         --> /about
+    index.ts          --> /
+```
+
+### Example route handler file
+Supported HTTP methods: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `OPTIONS`
+```ts
+// /routes/api/users/[id].ts
+import type { PomRequest, PomResponse } from "@interknot/pom-pom"
+
+export async function get(req: PomRequest, res: PomResponse) {
+    const userId = req.params.id
+    return res.json({ id: userId, name: "User " + userId })
+}
+
+export async function post(req: PomRequest, res: PomResponse) {
+    const userData = await req.json()
+    // Process userData...
+    return res.json({ success: true, data: userData })
+}
+
+export async function put(req: PomRequest, res: PomResponse) {
+    const userData = await req.json()
+    // Update userData...
+    return res.json({ success: true, data: userData })
+}
+
+// Note: 'delete' is a reserved keyword in JavaScript/TypeScript, 
+// so we use '_delete' instead
+export async function _delete(req: PomRequest, res: PomResponse) {
+    const userId = req.params.id
+    // Delete user...
+    return res.json({ success: true, id: userId })
+}
+
+export async function patch(req: PomRequest, res: PomResponse) {
+    const userData = await req.json()
+    // Partially update userData...
+    return res.json({ success: true, data: userData })
+}
+```
+
+## Performance
+PomPom is designed to be lightweight and fast. It adds minimal overhead
+over `Bun.serve`, making it suitable for high-performance applications.
+
+From my testing, the overhead it around 10-25%, depending on the complexity of the routes and middlewares used. Still faster than Express, though!
+
+### Benchmarks
+I've used Bombardier for benchmarking, the command is the same everywhere.
+```sh
+❯ bombardier -n 1000000 -c 1000 "http://localhost:5100/"
+```
+#### PomPom
+```sh
+Statistics        Avg      Stdev        Max
+  Reqs/sec     81866.28    4143.86   98144.69
+  Latency       12.21ms     2.40ms   160.95ms
+  HTTP codes:
+    1xx - 0, 2xx - 1000000, 3xx - 0, 4xx - 0, 5xx - 0
+    others - 0
+  Throughput:    16.16MB/s
+```
+
+#### Bun.serve
+```sh
+Statistics        Avg      Stdev        Max
+  Reqs/sec     94794.96    5274.28  108950.55
+  Latency       10.55ms     3.69ms   249.50ms
+  HTTP codes:
+    1xx - 0, 2xx - 1000000, 3xx - 0, 4xx - 0, 5xx - 0
+    others - 0
+  Throughput:    19.97MB/s
+```
+
+## License
+```
+Copyright 2026 Night Sky Studio (Konstantin Romanets)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@interknot/pom-pom",
+    "version": "0.1.0",
+    "description": "Express-like wrapper for Bun's HTTP server",
+    "author": "Night Sky Studio (Konstantin Romanets)",
+    "license": "Apache-2.0",
+    "homepage": "https://github.com/Night-Sky-Studio/pom-pom",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Night-Sky-Studio/pom-pom.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Night-Sky-Studio/pom-pom/issues"
+    },
+    "keywords": [
+        "bun",
+        "bun-serve",
+        "express",
+        "http",
+        "server",
+        "routing",
+        "middleware"
+    ],
+    "type": "module",
+    "main": "./src/index.ts",
+    "files": [
+        "src"
+    ],
+    "devDependencies": {
+        "@types/bun": "latest"
+    },
+    "peerDependencies": {
+        "typescript": "^5"
+    },
+    "engines": {
+        "bun": ">=1.3.8"
+    }
+}

package/src/Conductor.ts

@@ -0,0 +1,168 @@
+import Bun, { type MaybePromise, type BunRequest } from "bun"
+import { PomRequest, type RouteParams } from "./Request"
+import { PomOptions } from "./Options"
+import { PomResponse } from "./Response"
+
+export type MiddlewareFunction = (req: PomRequest<any>, res: PomResponse) => MaybePromise<Response | void>
+
+/**
+ * Middleware modifies the current request
+ * 
+ * It should either return a Response to short-circuit the request,
+ * or return nothing to continue processing
+ * 
+ * On 2nd option, it can modify the request/response objects directly
+ */
+export type Middleware = MiddlewareFunction | MaybePromise<void>
+
+export type RouteHandler<R extends string> = (req: PomRequest<R>, res: PomResponse) => MaybePromise<PomResponse | void>
+
+interface RouteHandlers<R extends string = string> {
+    GET?: RouteHandler<R>
+    POST?: RouteHandler<R>
+    PUT?: RouteHandler<R>
+    DELETE?: RouteHandler<R>
+    PATCH?: RouteHandler<R>
+    OPTIONS?: RouteHandler<R>
+    [key: string]: RouteHandler<R> | undefined
+}
+
+export class PomPom {
+    private middlewares: Middleware[] = []
+    private routes: Map<string, RouteHandlers<any>> = new Map()
+    public opts: PomOptions
+
+    constructor(opts?: PomOptions) {
+        this.opts = opts ?? new PomOptions()
+    }
+
+    public use(middleware: Middleware) {
+        this.middlewares.push(middleware)
+    }
+
+    public route<R extends string>(path: R, handlers: RouteHandlers<R>) {
+        // remove trailing slash except for root
+        const normalizedPath = path.endsWith('/') && path.length > 1 
+            ? path.slice(0, -1) 
+            : path
+
+        if (this.routes.has(normalizedPath)) {
+            const existingHandlers = this.routes.get(normalizedPath)!
+            this.routes.set(normalizedPath, { ...existingHandlers, ...handlers })
+            return this
+        }
+
+        this.routes.set(normalizedPath, handlers)        
+        return this
+    }
+
+    public get<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { GET: handler })
+    }
+
+    public post<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { POST: handler })
+    }
+
+    public put<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { PUT: handler })
+    }
+
+    /** js syntax workaround */
+    private _delete<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { DELETE: handler })
+    }
+
+    public delete<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { DELETE: handler })
+    }
+
+    public patch<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { PATCH: handler })
+    }
+
+    public options<R extends string>(path: R, handler: RouteHandler<R>) {
+        return this.route<R>(path, { OPTIONS: handler })
+    }
+
+    private async execMiddleware(mw: Middleware, req: PomRequest<any>, res: PomResponse) {
+        return typeof mw === 'function' ? await mw(req, res) : await mw
+    }
+
+    private buildRoutes() {
+        const routes: Bun.Serve.Routes<never, any> = {}
+
+        for (const [path, handlers] of this.routes.entries()) {
+            // Pre-parse path structure to avoid parsing on every request
+            const pathSegments = path.split('/').filter(Boolean)
+            const paramDefs = pathSegments
+                .map((segment, index) => {
+                    if (segment.startsWith(':')) return { index, key: segment.slice(1).replace('?', ''), isWildcard: false }
+                    if (segment.startsWith('*')) return { index, key: segment.slice(1), isWildcard: true }
+                    return null
+                })
+                .filter((def): def is NonNullable<typeof def> => def !== null)
+
+            
+            routes[path] = async (request: BunRequest<any>) => {
+                try {
+                    const pomRequest = new PomRequest(request, request.params)
+
+                    const response = new PomResponse()
+                    
+                    for (const middleware of this.middlewares) {
+                        const mwResponse = await this.execMiddleware(middleware, pomRequest, response)
+                        if (mwResponse) {
+                            return mwResponse
+                        }
+                    }
+
+                    const method = request.method.toUpperCase()
+                    const handler = handlers[method]
+
+                    if (handler) {
+                        await handler(pomRequest, response)
+                        return response.build()
+                    }
+
+                    return PomResponse.init({
+                        status: 405,
+                        body: "Method Not Allowed",
+                    })
+                } catch (error) {
+                    console.error("[SERVER]", error)
+                    return PomResponse.init({
+                        status: 500,
+                        body: `Internal Server Error: ${(error as Error).message}`
+                    })
+                }
+            }
+
+            console.log(`[SERVER] Built ${Object.keys(handlers).join(" ")} ${path}`)
+        }
+
+        return routes
+    }
+
+    public listen(port: number, callback?: () => void) {
+        const routes = this.buildRoutes()
+
+        const server = Bun.serve({
+            port,
+            routes,
+            fetch: () => PomResponse.init({
+                status: 404,
+                body: "Not Found",
+            }),
+            error: (error: Error) => {
+                console.error("[SERVER]", error)
+                return PomResponse.init({
+                    status: 500,
+                    body: `${error.message}`
+                })
+            }
+        })
+        callback?.()
+        return server
+    }
+}

package/src/Options.ts

@@ -0,0 +1,8 @@
+export class PomOptions {
+    defaultHeaders: Map<string, string>
+
+    constructor(options: Partial<PomOptions> = {}) {
+        this.defaultHeaders = options.defaultHeaders || new Map()
+        this.defaultHeaders.set('X-Powered-By', 'Pom-Pom')
+    }
+}

package/src/Request.ts

@@ -0,0 +1,67 @@
+import Bun, { type BunRequest } from "bun"
+
+type ExtractSearchParams<S extends string> = S extends `${infer _}?${infer Q}` ? Q : ""
+type SplitParams<Q extends string> = Q extends `${infer K}&${infer R}` 
+    ? { [key in K | keyof SplitParams<R>]: string } 
+    : Q extends `${infer K}` 
+        ? { [key in K]: string } : {}
+type ParseSearchParams<S extends string> = SplitParams<ExtractSearchParams<S>>
+
+export type RouteParams<R extends string = string> = { 
+    [Key in keyof Bun.Serve.ExtractRouteParams<R>]: Bun.Serve.ExtractRouteParams<R>[Key] 
+} & {}
+
+export type QueryParams<S extends string = string> = {
+    [key in keyof ParseSearchParams<S>]: ParseSearchParams<S>[key]
+} & {}
+
+export class PomRequest<R extends string = string> {
+    raw: BunRequest
+    private _url: URL | undefined = undefined
+    params: RouteParams<R>
+
+    private _query: QueryParams<R> | null = null
+
+    get cookies(): Bun.CookieMap {
+        return this.raw.cookies
+    }
+
+    get query(): QueryParams<R> {
+        if (this._query) return this._query
+        const q: Record<string, string> = {}
+
+        this._url = this._url ?? new URL(this.raw.url)
+
+        const s = this._url.search.slice(1) // remove '?'
+        try {
+            let i = 0
+            while (i < s.length) {
+                // find '=' or '&'
+                let j = s.indexOf('=', i)
+                if (j === -1) break
+                const key = decodeURIComponent(s.slice(i, j))
+                let k = s.indexOf('&', j + 1)
+                if (k === -1) k = s.length
+                const val = decodeURIComponent(s.slice(j + 1, k))
+                q[key] = val
+                i = k + 1
+            }
+        } catch (e) {
+            throw new Error(`[server.PomRequest.query] Failed to parse: ${s}`)
+        }
+        return this._query = q as any
+    }
+
+    json<T>(): Promise<T> {
+        return this.raw.json() as Promise<T>
+    }
+
+    text(): Promise<string> {
+        return this.raw.text()
+    }
+
+    constructor(raw: BunRequest, params: RouteParams<R>) {
+        this.raw = raw
+        this.params = params
+    }
+}

package/src/Response.ts

@@ -0,0 +1,62 @@
+export interface IPomResponseInit {
+    status?: number
+    contentType?: string
+    headers?: Record<string, string>
+    body?: any
+}
+
+export class PomResponse {
+    code: number = 200
+    contentType: string = "text/plain"
+    body: any = null
+    headers: Record<string, string> = {}
+
+    static init({
+        status, 
+        contentType = "text/plain", 
+        headers, 
+        body
+    }: IPomResponseInit = {}): Response {
+        const res = new PomResponse()
+        res.code = status ?? res.code
+        res.contentType = contentType ?? res.contentType
+        res.headers = headers ?? res.headers
+        res.body = body ?? res.body
+        return res.build()
+    }
+
+    json(data: any): PomResponse {
+        this.body = JSON.stringify(data)
+        this.contentType = "application/json"
+        return this
+    }
+
+    text(body: string): PomResponse {
+        this.body = body
+        this.contentType = "text/plain"
+        return this
+    }
+
+    status(code: number): PomResponse {
+        this.code = code
+        return this
+    }
+
+    header(key: string, value: string): PomResponse {
+        this.headers = {
+            ...this.headers,
+            [key]: value
+        }
+        return this
+    }
+
+    build(): Response {
+        return new Response(this.body, {
+            status: this.code,
+            headers: {
+                "Content-Type": this.contentType,
+                ...this.headers
+            }
+        })
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./Conductor"
+export * from "./Request"
+export * from "./Response"

package/src/middlewares/Cors.ts

@@ -0,0 +1,24 @@
+import type { MiddlewareFunction, PomRequest, PomResponse } from ".."
+
+interface CorsOptions {
+    origin?: string
+    methods?: string[]
+    headers?: string[]
+}
+
+export function cors({ 
+    origin = "*", 
+    methods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"], 
+    headers = ["Content-Type", "Authorization"] 
+}: CorsOptions = {}): MiddlewareFunction {
+    return (req: PomRequest<any>, res: PomResponse) => {
+        res.header('Access-Control-Allow-Origin', origin)
+        res.header('Access-Control-Allow-Methods', methods.join(', '))
+        res.header('Access-Control-Allow-Headers', headers.join(', '))
+        res.header("Access-Control-Allow-Credentials", `${res.headers["Access-Control-Allow-Origin"] !== "*"}`)
+
+        if (req.raw.method === "OPTIONS") {
+            return res.status(204).build()
+        }
+    }
+}

package/src/middlewares/index.ts

@@ -0,0 +1 @@
+export * from "./Cors"

package/src/router.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert"
+import { readdir, exists, stat } from "node:fs/promises"
+import path from "node:path"
+import { type RouteHandler, PomPom } from "."
+
+const Methods = ["get", "post", "put", "_delete", "patch"] as const
+
+interface RouteModule<R extends string = string> {
+    get?: RouteHandler<R>
+    post?: RouteHandler<R>
+    put?: RouteHandler<R>
+    delete?: RouteHandler<R>
+    patch?: RouteHandler<R>
+    [key: string]: RouteHandler<R> | undefined
+}
+
+function toRouteSegment(fileName: string): string {
+    if (fileName === "index") return "/"
+    // Replace all [param] with :param
+    return "/" + fileName.replace(
+        /\[\#([a-zA-Z0-9_]+)\]|\[\*([a-zA-Z0-9_]+)\]|\[([a-zA-Z0-9_]+)\]/g,
+        (_match, opt, rest, normal) => {
+            if (opt) {
+                // Optional param [#name]
+                return `:${opt}?`
+            } else if (rest) {
+                // Catch-all [*rest]
+                return `*${rest}`
+            } else if (normal) {
+                // Required param [name]
+                return `:${normal}`
+            }
+            return _match
+        }
+    )
+}
+
+export async function registerRoutes(app: PomPom, routesDir: string = "routes", baseRoute = "") {
+    assert(await exists(routesDir), `Routes directory "${routesDir}" does not exist`)
+
+    const routesPath = path.resolve(routesDir)
+
+    const files = await readdir(routesPath)
+
+    for (const file of files) {
+        try {
+            const fullPath = path.join(routesPath, file)
+            const fileStat = await stat(fullPath)
+            if (fileStat.isDirectory()) {
+                // Apply toRouteSegment to directory name
+                await registerRoutes(app, fullPath, path.posix.join(baseRoute || '/', toRouteSegment(file)))
+            } else if (file.endsWith(".ts") || file.endsWith(".js")) {
+                const routePath = baseRoute + toRouteSegment(file.replace(/\.(ts|js)$/, ""))
+                const module: RouteModule = await import(fullPath)
+
+                for (const method of Methods) {
+                    if (typeof module[method] === "function") {
+                        const handler = module[method] as RouteHandler<any>
+                        app[method](routePath, handler)
+                        console.log(`[ROUTER] Registered ${method.toUpperCase()} ${routePath}`)
+                    }
+                }
+            }
+        } catch (err) {
+            console.error(`[ROUTER] Error registering route ${baseRoute + toRouteSegment(file.replace(/\.(ts|js)$/, ""))}\n`, err)
+        }
+    }
+}