@vyckr/tachyon 0.3.0 → 1.0.0

package/src/server/tach.ts

@@ -0,0 +1,234 @@
+import { Subprocess, ServerWebSocket, BunFile, BunRequest, Server } from "bun";
+import Router, { _ctx } from "../router.js";
+import { rm } from "fs/promises";
+
+export default class Tach {
+
+    static webSockets = new Map<ServerWebSocket<any>, Subprocess<"pipe", "inherit", "pipe">>()
+
+    static headers = {
+        "Access-Control-Allow-Headers": process.env.ALLOW_HEADERS || "",
+        "Access-Control-Allow-Origin": process.env.ALLLOW_ORGINS || "",
+        "Access-Control-Allow-Credential": process.env.ALLOW_CREDENTIALS || "false",
+        "Access-Control-Expose-Headers": process.env.ALLOW_EXPOSE_HEADERS || "",
+        "Access-Control-Max-Age": process.env.ALLOW_MAX_AGE || "",
+        "Access-Control-Allow-Methods": process.env.ALLOW_METHODS || ""
+    }
+
+    static parseRequest(request: Request) {
+
+        const req: Record<string, any> = {}
+
+        req.headers = Object.fromEntries(request.headers)
+        req.cache = request.cache
+        req.credentials = request.credentials
+        req.destination = request.destination
+        req.integrity = request.integrity
+        req.keepalive = request.keepalive
+        req.method = request.method
+        req.mode = request.mode
+        req.redirect = request.redirect
+        req.referrer = request.referrer
+        req.referrerPolicy = request.referrerPolicy
+        req.url = request.url
+
+        return req
+    }
+
+    private static getParams(request: BunRequest, route: string) {
+    
+        const url = new URL(request.url)
+
+        const params = url.pathname.slice(route.length).split('/')
+
+        return { params: Tach.parseParams(params) }
+    }
+
+    private static parseParams(input: string[]) {
+
+        const params: (string | boolean | number | null | undefined)[] = []
+
+        for(const param of input) {
+
+            const num = Number(param)
+
+            if(!Number.isNaN(num)) params.push(num)
+
+            else if(param === 'true') params.push(true)
+
+            else if(param === 'false') params.push(false)
+
+            else if(param === 'null') params.push(null)
+
+            else if(param === 'undefined') params.push(undefined)
+
+            else params.push(param)
+        }
+
+        return params
+    }
+
+    private static parseKVParams(input: URLSearchParams | FormData) {
+
+        const params: Record<string, any> = {}
+
+        for(const [key, val] of input) {
+
+            if(typeof val === "string") {
+
+                try {
+
+                    params[key] = JSON.parse(val)
+    
+                } catch {
+    
+                    const num = Number(val)
+    
+                    if(!Number.isNaN(num)) params[key] = num
+    
+                    else if(val === 'true') params[key] = true
+    
+                    else if(val === 'false') params[key] = false
+    
+                    else if(typeof val === "string" && val.includes(',')) params[key] = Tach.parseParams(val.split(','))
+    
+                    else if(val === 'null') params[key] = null
+    
+                    if(params[key] === undefined) params[key] = val
+                }
+
+            } else params[key] = val
+        }
+
+        return params
+    }
+
+    static processRequest(request: BunRequest, route: string, ctx: _ctx) {
+
+        const { params } = Tach.getParams(request, route)
+
+        ctx.slugs = request.params
+
+        const searchParams = new URL(request.url).searchParams
+
+        let queryParams: Record<string, any> | undefined;
+
+        if(searchParams.size > 0) queryParams = Tach.parseKVParams(searchParams)
+
+        ctx.params = params
+        ctx.query = queryParams
+
+        return { ctx }
+    }
+
+    private static async processResponse(cmd: string[], input: _ctx) {
+
+        const proc = Bun.spawn({
+            cmd,
+            stdout: 'inherit',
+            stderr: "pipe",
+            stdin: "pipe"
+        })
+
+        proc.stdin.write(JSON.stringify(input))
+        proc.stdin.end()
+
+        let exitCode = await proc.exited
+
+        if(exitCode !== 0 && proc.stderr.length > 0) {
+            exitCode = exitCode < 0 || (exitCode > 0 && exitCode < 100) || exitCode > 599 ? 500 : exitCode
+            return { status: exitCode, body: proc.stderr.toString() }
+        }
+
+        exitCode = exitCode === 0 ? 200 : exitCode
+
+        return { status: exitCode, body: Bun.file(`/tmp/${proc.pid}`) }
+    }
+
+    private static async serveRequest(handler: string, ctx: _ctx) {
+
+        const res = await Tach.processResponse([handler], ctx) as { status: number, body?: BunFile }
+            
+        const size = res.body ? res.body.size : 0
+        
+        const response = new Response(res.body, { status: res.status, headers: Tach.headers })
+
+        return { response, size }
+    }
+
+    static createServerRoutes() {
+
+        for(const [route, methods] of Router.allRoutes) {
+
+            const serverRoute = async (request?: BunRequest, server?: Server) => {
+
+                const start = Date.now()
+        
+                let res: Response
+                let bodySize: number
+                const path = new URL(request!.url).pathname
+                const body = `/tmp/${Bun.randomUUIDv7()}`
+
+                try {
+
+                    const accept = request!.headers.get('accept') || ''
+
+                    if(accept.includes('text/html')) {
+                        return new Response(await Bun.file(`${import.meta.dir}/../client/dev.html`).text(), { status: 200, headers: { 'Content-Type': 'text/html' } })  
+                    }
+
+                    request!.blob().then(async blob => {
+                        if(blob.size > 0) await Bun.write(body, blob)
+                    })
+
+                    const { handler, ctx } = Router.processRequest(request!, route,  { 
+                        request: Router.parseRequest(request!),
+                        ipAddress: server?.requestIP(request!) ? server.requestIP(request!)!.address : '0.0.0.0',
+                        body
+                    })
+
+                    const { response, size } = await Tach.serveRequest(handler, ctx!)
+
+                    res = response
+                    bodySize = size
+
+                } catch(err) {
+
+                    const error = err as Error
+
+                    bodySize = error.message.length
+
+                    res = Response.json({ error: error.message }, { status: error.cause as number, headers: Tach.headers })
+                
+                } finally {
+
+                    Bun.file(body).exists().then(async exists => {
+                        if(exists) await rm(body, { recursive: true })
+                    })
+                }
+
+                const status = res.status
+                const method = request!.method
+                const duration = Date.now() - start
+
+                console.info(`${path} - ${method} - ${status} - ${duration}ms - ${bodySize} byte(s)`)
+
+                return res
+            }
+
+            for(const method of methods) {
+
+                if(method !== 'HTML' && method !== 'SOCKET') {
+
+                    if(!Router.reqRoutes[route]) {
+                        Router.reqRoutes[route] = {}
+                        Router.reqRoutes[`${route}/*`] = {}
+                    }
+
+                    Router.reqRoutes[route][method] = serverRoute
+                    Router.reqRoutes[`${route}/*`][method] = serverRoute
+                }
+            }
+        }
+    }
+}

package/tests/index.test.ts

@@ -0,0 +1,110 @@
+import { test, beforeAll, expect, describe } from 'bun:test'
+
+beforeAll(async () => {
+    new Worker('./tests/worker.ts').postMessage(`./src/serve.ts`)
+    await Bun.sleep(1000)
+})
+
+describe('/', () => {
+
+    test('GET', async () => {
+    
+        const res = await fetch('http://localhost:8080')
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+
+    test('POST', async () => {
+    
+        const res = await fetch('http://localhost:8080', {
+            method: 'POST'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+    
+    test('DELETE', async () => {
+    
+        const res = await fetch('http://localhost:8080', {
+            method: 'DELETE'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+})
+
+
+describe('/api', () => {
+
+    test('GET', async () => {
+    
+        const res = await fetch('http://localhost:8080/api')
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+    
+    test('POST', async () => {
+    
+        const res = await fetch('http://localhost:8080/api', {
+            method: 'POST'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+    
+    test('PUT', async () => {
+    
+        const res = await fetch('http://localhost:8080/api', {
+            method: 'PUT'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+})
+
+
+describe('/api/v2', () => {
+
+    test('GET', async () => {
+    
+        const res = await fetch('http://localhost:8080/api/v2')
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+    
+    test('DELETE', async () => {
+    
+        const res = await fetch('http://localhost:8080/api/v2', {
+            method: 'DELETE'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+    
+    test('PATCH', async () => {
+    
+        const res = await fetch('http://localhost:8080/api/v2/users', {
+            method: 'PATCH'
+        })
+    
+        console.log(await res.json())
+    
+        expect(res.status).toEqual(200)
+    })
+})

package/tests/stream.ts

@@ -0,0 +1,24 @@
+new Worker('./tests/worker.ts').postMessage(`./src/serve.ts`)
+
+await Bun.sleep(1000)
+
+const res = await fetch(`http://localhost:8080/`, {
+    headers: {
+        'Accept': 'text/html'
+    }
+})
+
+for await (const chunk of res.body!) {
+    
+    console.log(new TextDecoder().decode(chunk))
+}
+
+// const ws = new WebSocket(`ws://localhost:8080`)
+
+// ws.onopen = (ev) => {
+//     ws.send("Ping")
+// }
+
+// ws.onmessage = (ev) => {
+//     console.log(JSON.parse(ev.data))
+// }

package/tests/worker.ts

@@ -0,0 +1,7 @@
+import { $ } from 'bun'
+
+declare var self: Worker;
+
+self.onmessage = async (event: MessageEvent) => {
+    await $`${event.data}`
+};

package/tsconfig.json

@@ -11,7 +11,7 @@
         "noFallthroughCasesInSwitch": true,
         "noImplicitReturns": true,
         "forceConsistentCasingInFileNames": true,
-        "types": ["bun-types", "node", "@vyckr/byos"],
+        "types": ["@types/bun", "@types/node", "@types/deno"],
         "isolatedModules": true
     }
   }

package/Dockerfile

@@ -1,47 +0,0 @@
-FROM oven/bun:latest AS build
-
-RUN apt-get update && apt-get install -y unzip git
-
-WORKDIR /app
-
-RUN git clone https://github.com/oven-sh/bun.git
-
-WORKDIR /app/bun/packages/bun-lambda
-
-RUN bun install
-
-RUN bun run build-layer
-
-RUN unzip bun-lambda-layer.zip -d /tmp
-
-WORKDIR /tmp
-
-COPY package.json .
-
-RUN bun install
-
-FROM public.ecr.aws/lambda/provided:al2
-
-COPY --from=build /tmp/node_modules ${LAMBDA_TASK_ROOT}/node_modules
-
-COPY --from=build /tmp/package.json ${LAMBDA_TASK_ROOT}/package.json
-
-COPY --from=build /tmp/bootstrap ${LAMBDA_RUNTIME_DIR}
-
-COPY --from=build /tmp/bun /opt
-
-COPY ./src/Tach.ts ${LAMBDA_TASK_ROOT}
-
-COPY ./tsconfig.json ${LAMBDA_TASK_ROOT}
-
-COPY ./src/runtime.ts /opt
-
-RUN chmod 777 /opt/bun
-
-RUN chmod 777 /opt/runtime.ts
-
-RUN chmod 777 ${LAMBDA_TASK_ROOT}/Tach.ts
-
-RUN chmod 777 ${LAMBDA_RUNTIME_DIR}/bootstrap
-
-CMD ["Tach.fetch"]

package/routes/byos/[primary]/doc/index.ts

@@ -1,28 +0,0 @@
-import { VALIDATE } from "../../../utils/validation.js";
-
-export default class Doc {
-
-    @VALIDATE([{ type: "object" }])
-    static async GET({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "object" }, { type: "object" }])
-    static async POST({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "object" }, { type: "object" }])
-    static async PATCH({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "string" }, { type: "object" }])
-    static async DELETE({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-}

package/routes/byos/[primary]/docs/index.ts

@@ -1,28 +0,0 @@
-import { VALIDATE } from "../../../utils/validation.js";
-
-export default class Docs {
-
-    @VALIDATE([{ type: "object" }])
-    static async GET({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "object" }])
-    static async POST({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "object" }])
-    static async PATCH({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    @VALIDATE([{ type: "object" }])
-    static async DELETE({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-}

package/routes/byos/[primary]/join/[secondary]/docs/index.ts

@@ -1,10 +0,0 @@
-import { VALIDATE } from "../../../../../utils/validation.js";
-
-export default class Docs {
-
-    @VALIDATE([{ type: "object" }])
-    static async GET({ slugs }: _HTTPContext) {
-
-        console.info(slugs)
-    }
-}

package/routes/byos/[primary]/schema/index.ts

@@ -1,17 +0,0 @@
-export default class Schema {
-
-    static async POST({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    static async PATCH({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-
-    static DELETE({ request }: _HTTPContext) {
-
-        console.log(request.url)
-    }
-}

package/routes/byos/[primary]/stream/doc/index.ts

@@ -1,28 +0,0 @@
-import { VALIDATE } from "../../../../utils/validation.js";
-
-export default class {
-
-    @VALIDATE([{ type: "object" }])
-    static GET({ request }: _HTTPContext) {
-
-        return {
-
-            async *[Symbol.asyncIterator]() {
-
-                yield request.url
-            }
-        }
-    }
-
-    @VALIDATE([{ type: "object" }])
-    static DELETE({ request }: _HTTPContext) {
-
-        return {
-
-            async *[Symbol.asyncIterator]() {
-
-                yield request.url
-            }
-        }
-    }
-}

package/routes/byos/[primary]/stream/docs/index.ts

@@ -1,28 +0,0 @@
-import { VALIDATE } from "../../../../utils/validation.js";
-
-export default class {
-
-    @VALIDATE([{ type: "object" }])
-    static GET({ request }: _HTTPContext) {
-
-        return {
-
-            async *[Symbol.asyncIterator]() {
-
-                yield request.url
-            }
-        }
-    }
-
-    @VALIDATE([{ type: "object", default: {} }, { type: "object" }])
-    static DELETE({ request }: _HTTPContext) {
-
-        return {
-
-            async *[Symbol.asyncIterator]() {
-
-                yield request.url
-            }
-        }
-    }
-}

package/routes/proxy.ts

@@ -1,8 +0,0 @@
-export default async function middleware(request: Request, next: (request: Request) => Promise<Response>) {
-
-    console.log("Within Proxy")
-
-    const response = await next(request)
-
-    return response
-}

package/routes/utils/validation.ts

@@ -1,36 +0,0 @@
-export const VALIDATE = (input: any[]) => (cls: Object, funcName: string, propDesc: PropertyDescriptor) => {
-
-    const originalFunc: Function = propDesc.value
-            
-    propDesc.value = async function(...args: any[]) {
-
-        const params = [...input]
-
-        if(params.length !== args.length) {
-
-            do {
-
-                const idx = params.findLastIndex(x => x.default !== undefined)
-
-                if(idx === -1) break
-
-                const [ param ] = params.splice(idx, 1)
-
-                args.unshift(param.default)
-
-            } while(true)
-
-            if(input.length !== args.length) throw new Error(`Invalid number of arguments for ${funcName}`)
-        }
-
-        for(let i = 0; i < input.length; i++) {
-
-            if(typeof args[i] !== input[i].type) {
-
-                throw new Error(`Invalid argument type for ${funcName}`)
-            }
-        }
-
-        return originalFunc.apply(this, args)
-    }
-}