write the library

Author: v1rtl

README.md

@@ -1,2 +1,27 @@
-# compress
-🗜️ Deno compression middleware
+# compression
+
+Deno HTTP compression middleware.
+
+## Features
+
+- Detects supported encodings with `Accept-Encoding` header
+- Supports chaining algorithms (e.g. `gzip` -> `br`)
+- Creates a `Content-Encoding` header with applied compression
+- Send `409 Not Acceptable` if encoding is not supported
+
+## Example
+
+```ts
+import { serve } from 'https://deno.land/[email protected]/http/server.ts'
+import { compression } from 'https://deno.land/x/compression/mod.ts'
+
+const s = serve({ port: 3000 })
+
+for await (const req of s) {
+  await compression({
+    path: 'README.md',
+    // Apply all algos in a queue
+    compression: ['gzip', 'deflate']
+  })(req)
+}
+```

example.ts

@@ -0,0 +1,11 @@
+import { serve } from 'https://deno.land/[email protected]/http/server.ts'
+import { compression } from './mod.ts'
+
+const s = serve({ port: 3000 })
+
+for await (const req of s) {
+  await compression({
+    path: 'README.md',
+    compression: ['gzip', 'deflate']
+  })(req)
+}

mod.ts

@@ -0,0 +1,117 @@
+// import { compress as brotli } from 'https://deno.land/x/[email protected]/mod.ts'
+import { gzip, deflate } from 'https://deno.land/x/[email protected]/mod.ts'
+import { ServerRequest } from 'https://deno.land/[email protected]/http/server.ts'
+import { Accepts } from 'https://deno.land/x/[email protected]/mod.ts'
+
+const funcs = {
+  // br: brotli,
+  gzip: (body: Uint8Array) => gzip(body, undefined),
+  deflate: (body: Uint8Array) => deflate(body, undefined)
+}
+
+/**
+ * Supported compression algorithms
+ */
+type Compression = 'gzip' | /* 'br' | */ 'deflate'
+
+export type CompressionOptions = {
+  /**
+   * Path to file
+   */
+  path: string
+  /**
+   * Compression algorithms (gzip, brotli, deflate). The first is used if all are accepted by the client
+   */
+  compression: [Compression] | [Compression, Compression] | [Compression, Compression, Compression]
+}
+
+/**
+ * HTTP Compression middleware.
+ * @param {CompressionOptions} opts
+ *
+ * @example
+ * ```ts
+ *import { serve } from 'https://deno.land/[email protected]/http/server.ts'
+ *import { compression } from 'https://deno.land/x/compression/brotli.ts'
+ *
+ *const s = serve({ port: 3000 })
+ *
+ *for await (const req of s) {
+ *  await compression({
+ *    path: 'README.md',
+ *    compression: ['gzip', 'deflate']
+ *  })(req)
+ *}
+ * ```
+ */
+export const compression = (opts: CompressionOptions) => async (req: ServerRequest) => {
+  const acceptHeader = req.headers.get('Accept-Encoding')
+
+  const accepts = new Accepts(req.headers)
+
+  const encodings = accepts.encodings()
+
+  const buf = await Deno.readAll(await Deno.open(opts.path))
+
+  if (
+    !acceptHeader ||
+    encodings === 'identity' ||
+    (Array.isArray(encodings) && encodings.length === 1 && encodings[0] === 'identity')
+  ) {
+    await req.respond({
+      body: buf,
+      status: 200,
+      headers: new Headers({
+        'Content-Encoding': 'identity'
+      })
+    })
+  } else if (acceptHeader === '*') {
+    const preferredAlgo = opts.compression[0]
+
+    const compressed = funcs[preferredAlgo](buf)
+
+    await req.respond({
+      body: compressed,
+      headers: new Headers({
+        'Content-Encoding': preferredAlgo
+      }),
+      status: 200
+    })
+  } else {
+    if (Array.isArray(encodings)) {
+      let compressed: Uint8Array = buf
+      let encs: string[] = []
+      for (const enc of encodings.filter((x) => x !== 'identity')) {
+        if (Object.keys(funcs).includes(enc as string)) {
+          compressed = funcs[enc as Compression](compressed)
+          encs.push(enc)
+        } else {
+          return await req.respond({
+            status: 406,
+            body: 'Not Acceptable'
+          })
+        }
+      }
+      return await req.respond({
+        body: compressed,
+        headers: new Headers({
+          'Content-Encoding': encs.join(', ')
+        })
+      })
+    } else {
+      return await req.respond(
+        Object.keys(funcs).includes(encodings as string)
+          ? {
+              body: funcs[encodings as Compression](buf),
+              headers: new Headers({
+                'Content-Encoding': encodings as string
+              })
+            }
+          : {
+              status: 406,
+              body: 'Not Acceptable'
+            }
+      )
+    }
+  }
+}