breaking: rewrite api of APIs

Author: Je

api.ts

@@ -1,34 +1,74 @@
 import { gzipEncode } from 'https://deno.land/x/[email protected]/mod.ts'
 import log from './log.ts'
 import type { ServerRequest } from './std.ts'
-import type { APIRequest, APIRequestURL, APIResponse, RouterURL } from './types.ts'
+import type { APIRequest, APIRequestURL, Response } from './types.ts'
 
-export class AlephAPIRequest implements APIRequest {
+export class Request implements APIRequest {
     #req: ServerRequest
     #url: APIRequestURL
-    #cookies: ReadonlyMap<string, string>
+    #cookies: ReadonlyMap<string, string> = new Map()
+    #resp = {
+        status: 200,
+        headers: new Headers({
+            'Status': '200',
+            'Server': 'Aleph.js',
+        }),
+        done: false
+    }
 
-    constructor(req: ServerRequest, url: RouterURL) {
-        const paramsMap = new Map<string, string>()
-        for (const key in url.params) {
-            paramsMap.set(key, url.params[key])
-        }
+    constructor(req: ServerRequest, url: APIRequestURL) {
         this.#req = req
-        this.#url = {
-            proto: this.#req.proto,
-            protoMinor: this.#req.protoMinor,
-            protoMajor: this.#req.protoMajor,
-            pathname: url.pathname,
-            params: paramsMap,
-            query: url.query,
-        }
-        this.#cookies = new Map() // todo: parse cookies
+        this.#url = url
     }
 
     get method(): string {
         return this.#req.method
     }
 
+    get proto() {
+        return this.#req.proto
+    }
+
+    get protoMinor() {
+        return this.#req.protoMinor
+    }
+
+    get protoMajor() {
+        return this.#req.protoMajor
+    }
+
+    get conn() {
+        return this.#req.conn
+    }
+
+    get r() {
+        return this.#req.r
+    }
+
+    get w() {
+        return this.#req.w
+    }
+
+    get done() {
+        return this.#req.done
+    }
+
+    get contentLength() {
+        return this.#req.contentLength
+    }
+
+    get body() {
+        return this.#req.body
+    }
+
+    async respond(r: Response) {
+        return this.#req.respond(r)
+    }
+
+    async finalize() {
+        return this.#req.finalize()
+    }
+
     get url(): APIRequestURL {
         return this.#url
     }
@@ -40,51 +80,34 @@ export class AlephAPIRequest implements APIRequest {
     get cookies(): ReadonlyMap<string, string> {
         return this.#cookies
     }
-}
-
-export class AlephAPIResponse implements APIResponse {
-    #req: ServerRequest
-    #status: number
-    #headers: Headers
-    #sent: boolean
-
-    constructor(req: ServerRequest) {
-        this.#req = req
-        this.#status = 200
-        this.#headers = new Headers({
-            'Status': '200',
-            'Server': 'Aleph.js',
-        })
-        this.#sent = false
-    }
 
     status(code: number): this {
-        this.#headers.set('status', code.toString())
-        this.#status = code
+        this.#resp.headers.set('status', code.toString())
+        this.#resp.status = code
         return this
     }
 
     addHeader(key: string, value: string): this {
-        this.#headers.append(key, value)
+        this.#resp.headers.append(key, value)
         return this
     }
 
     setHeader(key: string, value: string): this {
-        this.#headers.set(key, value)
+        this.#resp.headers.set(key, value)
         return this
     }
 
     removeHeader(key: string): this {
-        this.#headers.delete(key)
+        this.#resp.headers.delete(key)
         return this
     }
 
-    async json(data: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number) {
+    json(data: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number) {
         return this.send(JSON.stringify(data, replacer, space), 'application/json')
     }
 
     async send(data: string | Uint8Array | ArrayBuffer, contentType?: string) {
-        if (this.#sent) {
+        if (this.#resp.done) {
             log.warn('ServerRequest: repeat respond calls')
             return
         }
@@ -99,9 +122,9 @@ export class AlephAPIResponse implements APIResponse {
             return
         }
         if (contentType) {
-            this.#headers.set('Content-Type', contentType)
-        } else if (this.#headers.has('Content-Type')) {
-            contentType = this.#headers.get('Content-Type')!
+            this.#resp.headers.set('Content-Type', contentType)
+        } else if (this.#resp.headers.has('Content-Type')) {
+            contentType = this.#resp.headers.get('Content-Type')!
         }
         let isText = false
         if (contentType) {
@@ -114,29 +137,29 @@ export class AlephAPIResponse implements APIResponse {
             }
         }
         if (isText && body.length > 1024 && this.#req.headers.get('accept-encoding')?.includes('gzip')) {
-            this.#headers.set('Vary', 'Origin')
-            this.#headers.set('Content-Encoding', 'gzip')
+            this.#resp.headers.set('Vary', 'Origin')
+            this.#resp.headers.set('Content-Encoding', 'gzip')
             body = gzipEncode(body)
         }
-        this.#headers.set('Date', (new Date).toUTCString())
-        this.#sent = true
+        this.#resp.headers.set('Date', (new Date).toUTCString())
+        this.#resp.done = true
         return this.#req.respond({
-            status: this.#status,
-            headers: this.#headers,
+            status: this.#resp.status,
+            headers: this.#resp.headers,
             body
         }).catch(err => log.warn('ServerRequest.respond:', err.message))
     }
 
     async end(status: number) {
-        if (this.#sent) {
+        if (this.#resp.done) {
             log.warn('ServerRequest: repeat respond calls')
             return
         }
-        this.#headers.set('Date', (new Date).toUTCString())
-        this.#sent = true
+        this.#resp.headers.set('Date', (new Date).toUTCString())
+        this.#resp.done = true
         return this.#req.respond({
             status,
-            headers: this.#headers,
+            headers: this.#resp.headers,
         }).catch(err => log.warn('ServerRequest.respond:', err.message))
     }
 }

context.ts

@@ -5,7 +5,7 @@ export const RouterContext = createContext<RouterURL>({
     locale: 'en',
     pagePath: '/',
     pathname: '/',
-    params: {},
+    params: new Map(),
     query: new URLSearchParams(),
 })
 RouterContext.displayName = 'RouterContext'

project.ts

@@ -1,14 +1,14 @@
 import marked from 'https://esm.sh/[email protected]'
 import { minify } from 'https://esm.sh/[email protected]'
 import { safeLoadFront } from 'https://esm.sh/[email protected]'
-import { AlephAPIRequest, AlephAPIResponse } from './api.ts'
+import { Request } from './api.ts'
 import { EventEmitter } from './events.ts'
 import { createHtml } from './html.ts'
 import log from './log.ts'
 import { getPagePath, RouteModule, Routing } from './routing.ts'
 import { colors, ensureDir, path, ServerRequest, Sha1, walk } from './std.ts'
 import { compile } from './tsc/compile.ts'
-import type { AlephRuntime, APIHandle, Config, RouterURL } from './types.ts'
+import type { AlephRuntime, APIHandler, Config, RouterURL } from './types.ts'
 import util, { existsDirSync, existsFileSync, hashShort, MB, reHashJs, reHttp, reLocaleID, reMDExt, reModuleExt, reStyleModuleExt } from './util.ts'
 import { cleanCSS, Document, less } from './vendor/mod.ts'
 import { version } from './version.ts'
@@ -175,18 +175,15 @@ export class Project {
         }
     }
 
-    async callAPI(req: ServerRequest, loc: { pathname: string, search?: string }): Promise<APIHandle | null> {
+    async callAPI(req: ServerRequest, loc: { pathname: string, search?: string }): Promise<APIHandler | null> {
         const [url] = this.#apiRouting.createRouter(loc)
         if (url.pagePath != '') {
             const moduleID = url.pagePath + '.js'
             if (this.#modules.has(moduleID)) {
                 try {
                     const { default: handle } = await import('file://' + this.#modules.get(moduleID)!.jsFile)
                     if (util.isFunction(handle)) {
-                        await handle(
-                            new AlephAPIRequest(req, url),
-                            new AlephAPIResponse(req)
-                        )
+                        await handle(new Request(req, url))
                     } else {
                         req.respond({
                             status: 500,
@@ -1275,7 +1272,7 @@ export class Project {
         return ret
     }
 
-    private async _render404Page(url: RouterURL = { locale: this.config.defaultLocale, pagePath: '', pathname: '/', params: {}, query: new URLSearchParams() }) {
+    private async _render404Page(url: RouterURL = { locale: this.config.defaultLocale, pagePath: '', pathname: '/', params: new Map(), query: new URLSearchParams() }) {
         const ret: RenderResult = { url, status: 404, head: [], body: '<main></main>', data: null }
         try {
             const e404Module = this.#modules.get('/404.js')

routing.ts

@@ -117,7 +117,7 @@ export class Routing {
         let locale = this._defaultLocale
         let pathname = util.cleanPath(util.trimPrefix(loc.pathname, this._baseUrl))
         let pagePath = ''
-        let params: Record<string, string> = {}
+        let params: Map<string, string> = new Map
         let tree: RouteModule[] = []
 
         if (pathname !== '/' && this._locales.length > 0) {
@@ -139,7 +139,9 @@ export class Routing {
                     tree.push(c.module)
                 }
                 pagePath = path
-                params = p
+                for (const key in p) {
+                    params.set(key, p[key])
+                }
                 return false
             }
         }, true)

server.ts

@@ -1,4 +1,4 @@
-import { AlephAPIResponse } from './api.ts'
+import { Request } from './api.ts'
 import { createHtml } from './html.ts'
 import log from './log.ts'
 import { getContentType } from './mime.ts'
@@ -17,7 +17,7 @@ export async function start(appDir: string, port: number, isDev = false, reload
             for await (const req of s) {
                 const url = new URL('http://localhost/' + req.url)
                 const pathname = util.cleanPath(url.pathname)
-                const resp = new AlephAPIResponse(req)
+                const resp = new Request(req, { pathname, params: new Map(), query: new URLSearchParams() })
 
                 try {
                     // serve hmr ws

types.ts

@@ -29,38 +29,52 @@ export interface Config {
 }
 
 export interface APIRequestURL {
-    readonly proto: string
-    readonly protoMinor: number
-    readonly protoMajor: number
     readonly pathname: string
     readonly params: ReadonlyMap<string, string>
     readonly query: URLSearchParams
 }
 
+export interface Response {
+    status?: number
+    headers?: Headers
+    trailers?: () => Promise<Headers> | Headers
+    body?: Uint8Array | Deno.Reader | string
+}
+
 export interface APIRequest {
     readonly method: string
-    readonly url: APIRequestURL
+    readonly proto: string
+    readonly protoMinor: number
+    readonly protoMajor: number
     readonly headers: Headers
+    readonly conn: Deno.Conn
+    readonly r: Deno.Reader
+    readonly w: Deno.Writer
+    readonly done: Promise<Error | undefined>
+    readonly contentLength: number | null
+    readonly body: Deno.Reader
+    respond(r: Response): Promise<void>
+    finalize(): Promise<void>
+    // plus
+    readonly url: APIRequestURL
     readonly cookies: ReadonlyMap<string, string>
-}
-
-export interface APIResponse {
     status(code: number): this
     addHeader(key: string, value: string): this
     setHeader(key: string, value: string): this
     removeHeader(key: string): this
     send(data: string | Uint8Array | ArrayBuffer): Promise<void>
     json(data: any): Promise<void>
+    end(code: number): Promise<void>
 }
 
-export interface APIHandle {
-    (req: APIRequest, res: APIResponse): void
+export interface APIHandler {
+    (req: APIRequest): void
 }
 
 export interface RouterURL {
     readonly locale: string
     readonly pathname: string
     readonly pagePath: string
-    readonly params: Record<string, string>
+    readonly params: ReadonlyMap<string, string>
     readonly query: URLSearchParams
 }