Very Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399import { join } from 'https://deno.land/std@0.106.0/path/mod.ts'import { readerFromStreamReader } from "https://deno.land/std@0.106.0/io/streams.ts"import { readAll } from "https://deno.land/std@0.106.0/io/util.ts"import { builtinModuleExts, trimBuiltinModuleExts } from '../framework/core/module.ts'import { resolveURL } from '../framework/core/routing.ts'import { existsFile } from '../shared/fs.ts'import log from '../shared/log.ts'import util from '../shared/util.ts'import { APIContext } from '../types.d.ts'import { Aleph } from './aleph.ts'import compress from './compress.ts'import { getContentType } from './mime.ts'import { APIResponse } from './response.ts'
/** The Aleph server class. */export class Server { #aleph: Aleph #ready: boolean
constructor(aleph: Aleph) { this.#aleph = aleph this.#ready = false }
async handle(e: Deno.RequestEvent): Promise<void> { if (!this.#ready) { await this.#aleph.ready this.#ready = true }
const { request: req, respondWith } = e const aleph = this.#aleph const { basePath, server: { headers, rewrites, middlewares } } = aleph.config const url = resolveURL(req.url, basePath, rewrites) const pathname = decodeURI(url.pathname)
try { // serve hmr ws if (pathname === '/_hmr') { const { socket, response } = Deno.upgradeWebSocket(req) const watcher = aleph.createFSWatcher() const send = (message: object) => { try { socket.send(JSON.stringify(message)) } catch (err) { log.warn('socket.send:', err.message) } } socket.addEventListener('open', () => { watcher.on('add', (mod: any) => socket.send(JSON.stringify({ ...mod, type: 'add' }))) watcher.on('remove', (specifier: string) => { watcher.removeAllListeners('modify-' + specifier) send({ type: 'remove', specifier }) }) log.debug('hmr connected') }) socket.addEventListener('close', () => { aleph.removeFSWatcher(watcher) log.debug('hmr closed') }) socket.addEventListener('message', (e) => { if (util.isFilledString(e.data)) { try { const data = JSON.parse(e.data) if (data.type === 'hotAccept' && util.isFilledString(data.specifier)) { const mod = aleph.getModule(data.specifier) if (mod) { watcher.on(`modify-${mod.specifier}`, (data) => { send({ ...data, type: 'update', specifier: mod.specifier, updateUrl: util.cleanPath(`${basePath}/_aleph/${trimBuiltinModuleExts(mod.specifier)}.js`), }) }) } } } catch (e) { } } }) try { await respondWith(response) } catch (err) { log.warn('http:', err.message) } return }
const resp = new APIResponse() const end = async (status?: number): Promise<void> => { const acceptEncoding = req.headers.get('accept-encoding') let { body, headers } = resp
let contentType: string | null = null if (headers.has('Content-Type')) { contentType = headers.get('Content-Type')! } else if (typeof body === 'string') { contentType = 'text/plain; charset=utf-8' headers.set('Content-Type', contentType) }
if (compress.enable && acceptEncoding && body && contentType) { let data = new Uint8Array() if (typeof body === 'string') { data = new TextEncoder().encode(body) } else if (body instanceof Uint8Array) { data = body } else if (body instanceof ArrayBuffer) { data = new Uint8Array(body) } else if (typeof body.getReader === 'function') { data = await readAll(readerFromStreamReader(body.getReader())) } const contentEncoding = compress.accept(acceptEncoding, contentType, data.length) if (contentEncoding) { body = await compress.compress(data, contentEncoding) headers.set('Vary', 'Origin') headers.set('Content-Encoding', contentEncoding) } }
try { await respondWith(new Response(body, { headers, status: status || resp.status })) } catch (err) { log.warn('http:', err.message) } }
// set server header resp.setHeader('Server', 'Aleph.js')
// set custom headers if (headers) { for (const key in headers) { resp.setHeader(key, headers[key]) } }
// we use `Last-Modified` and `ETag` header to control cache resp.setHeader('Cache-Control', 'max-age=0')
// serve dist files if (pathname.startsWith('/_aleph/')) { if (pathname.startsWith('/_aleph/data/') && pathname.endsWith('.json')) { const [path, search] = util.splitBy(util.atobUrl(util.trimSuffix(util.trimPrefix(pathname, '/_aleph/data/'), '.json')), '?') const data = await aleph.getSSRData({ pathname: path, search: search ? '?' + search : undefined }) if (data === null) { resp.json(null) end() } else { resp.json(data) end() } return }
const relPath = util.trimPrefix(pathname, '/_aleph') if (relPath == '/main.js') { resp.body = await aleph.createMainJS(false) resp.setHeader('Content-Type', 'application/javascript; charset=utf-8') end() return }
// serve modules if (relPath.endsWith('.js')) { let module = aleph.findModule(({ jsFile }) => jsFile === relPath) if (!module && aleph.isDev) { for (const ext of [...builtinModuleExts.map(ext => `.${ext}`), '']) { const sepcifier = util.trimSuffix(relPath, '.js') + ext if (await existsFile(join(aleph.workingDir, sepcifier))) { module = await aleph.compile(sepcifier) break } } } if (module) { const content = await aleph.getModuleJS(module, aleph.isDev) if (content) { const hash = aleph.gteModuleHash(module) if (hash === req.headers.get('If-None-Match')) { end(304) return }
resp.setHeader('ETag', hash) resp.setHeader('Content-Type', 'application/javascript; charset=utf-8') resp.body = content end() return } } }
// serve other build files const filePath = join(aleph.buildDir, relPath) if (await existsFile(filePath)) { const info = Deno.lstatSync(filePath) const lastModified = info.mtime?.toUTCString() ?? (new Date).toUTCString() if (lastModified === req.headers.get('If-Modified-Since')) { end(304) return }
resp.body = await Deno.readFile(filePath) resp.setHeader('Last-Modified', lastModified) resp.setHeader('Content-Type', getContentType(filePath)) end() return }
resp.body = 'file not found' end(404) return }
// serve public files const filePath = join(aleph.workingDir, 'public', pathname) if (await existsFile(filePath)) { const info = Deno.lstatSync(filePath) const lastModified = info.mtime?.toUTCString() ?? (new Date).toUTCString() if (lastModified === req.headers.get('If-Modified-Since')) { end(304) return }
resp.body = await Deno.readFile(filePath) resp.setHeader('Last-Modified', lastModified) resp.setHeader('Content-Type', getContentType(filePath)) end() return }
// serve APIs if (pathname.startsWith('/api/')) { const route = await aleph.getAPIRoute({ pathname, search: Array.from(url.searchParams.keys()).length > 0 ? '?' + url.searchParams.toString() : '' }) if (route !== null) { try { const [router, module] = route const data = new Map() const steps = [...middlewares, async (context: APIContext) => { const { default: _handler, handler } = await aleph.importModule(module) const h = _handler || handler if (util.isFunction(h)) { await h(context) } else { resp.json({ status: 500, message: 'bad api handler' }) end(500) } }] let pointer = 0 let responded = false const next = async () => { if (pointer < steps.length && !responded) { let nextPromise: any = null const result = steps[pointer]({ request: req, response: resp, respondWith: async (r: Response | Promise<Response>) => { responded = true try { await respondWith(r) } catch (err) { log.warn('http:', err.message) } }, router, data }, () => { pointer++ nextPromise = next() }) if (nextPromise) { await nextPromise nextPromise = null } if (result instanceof Promise) { await result } if (nextPromise) { await nextPromise } } } await next() if (!responded) { end() } } catch (err) { resp.json({ status: 500, message: err.message }) end(500) log.error('invoke API:', err) } } else { resp.json({ status: 404, message: 'not found' }) end(404) } return }
// ssr const [status, html] = await aleph.renderPage({ pathname, search: Array.from(url.searchParams.keys()).length > 0 ? '?' + url.searchParams.toString() : '' }) resp.setHeader('Content-Type', 'text/html; charset=utf-8') resp.body = html end(status) } catch (err) { try { // todo: custom error page e.respondWith(new Response( [ `<!DOCTYPE html>`, `<title>Server Error</title>`, `<h1>Error: ${err.message}</h1>`, `<p><pre>${err.stack}</pre></p>` ].join('\n'), { status: 500, headers: new Headers({ 'Content-Type': 'text/html; charset=utf-8' }) } )) } catch (err) { log.warn('send:', err.message) } } }}
/** Options for creating a native server. */export type ServeOptions = { /** The Aleph to serve. */ aleph: Aleph /** The port to listen on. */ port: number /** A literal IP address or host name that can be resolved to an IP address. Defaults to `0.0.0.0`. */ hostname?: string /** The certificate file for TLS connection. */ certFile?: string /** The public key file for TLS connection. */ keyFile?: string /* The signal to close the server. */ signal?: AbortSignal}
/** Create a standard Aleph server. */export async function serve({ aleph, port, hostname, certFile, keyFile, signal }: ServeOptions) { const server = new Server(aleph) await aleph.ready
while (true) { try { let listener: Deno.Listener if (certFile && keyFile) listener = Deno.listenTls({ port, hostname, certFile, keyFile }) else { listener = Deno.listen({ port, hostname }) } signal?.addEventListener('abort', () => { listener.close() }) if (!aleph.isDev && aleph.config.server.compress) { compress.enable = true } log.info(`Server ready on http://${hostname || 'localhost'}:${port}${aleph.config.basePath}`)
for await (const conn of listener) { // In order to not be blocking, we need to handle each connection individually // in its own async function. (async () => { try { const httpConn = Deno.serveHttp(conn) // Each request sent over the HTTP connection will be yielded as an async // iterator from the HTTP connection. for await (const e of httpConn) { await server.handle(e) } } catch (err) { log.warn(err.message) } })() } } catch (err) { if (err instanceof Deno.errors.AddrInUse) { if (!aleph.isDev) { log.fatal(`port ${port} already in use!`) } log.warn(`port ${port} already in use, try ${port + 1}...`) port++ } else { log.fatal(err.message) } } }}