body parsing (#50)

Author: Rich-Harris

packages/adapter-node/src/index.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import http from 'http';
 import { parse, URLSearchParams } from 'url';
 import sirv from 'sirv';
-import { render } from '@sveltejs/app-utils';
+import { render, get_body } from '@sveltejs/app-utils';
 
 const manifest = require('./manifest.js');
 const client = require('./client.json');
@@ -39,6 +39,7 @@ const server = http.createServer((req, res) => {
 					method: req.method,
 					headers: req.headers,
 					path: parsed.pathname,
+					body: await get_body(req),
 					query: new URLSearchParams(parsed.query)
 				}, {
 					static_dir: 'static',

packages/app-utils/rollup.config.js

@@ -1,5 +1,5 @@
 import { nodeResolve } from '@rollup/plugin-node-resolve';
-import sucrase from '@rollup/plugin-sucrase';
+import typescript from '@rollup/plugin-typescript';
 import pkg from './package.json';
 
 export default {
@@ -18,9 +18,7 @@ export default {
 	],
 	plugins: [
 		nodeResolve(),
-		sucrase({
-			transforms: ['typescript']
-		})
+		typescript()
 	],
 	external: [
 		...require('module').builtinModules,

packages/app-utils/src/http/get_body/index.ts

@@ -0,0 +1,152 @@
+import { IncomingMessage } from 'http';
+import { read_only_form_data } from './read_only_form_data';
+
+export function get_body(req: IncomingMessage) {
+	const has_body = (
+		req.headers['content-type'] !== undefined &&
+		// https://github.com/jshttp/type-is/blob/c1f4388c71c8a01f79934e68f630ca4a15fffcd6/index.js#L81-L95
+		(req.headers['transfer-encoding'] !== undefined || !isNaN(Number(req.headers['content-length'])))
+	);
+
+	if (!has_body) return Promise.resolve(undefined);
+
+	const [type, ...directives] = req.headers['content-type'].split(/;\s*/);
+
+	switch (type) {
+		case 'application/octet-stream':
+			return get_buffer(req);
+
+		case 'text/plain':
+			return get_text(req);
+
+		case 'application/json':
+			return get_json(req);
+
+		case 'application/x-www-form-urlencoded':
+			return get_urlencoded(req);
+
+		case 'multipart/form-data':
+			const boundary = directives.find(directive => directive.startsWith('boundary='));
+			if (!boundary) throw new Error(`Missing boundary`);
+			return get_multipart(req, boundary.slice('boundary='.length));
+
+		default:
+			throw new Error(`Invalid Content-Type ${type}`);
+	}
+}
+
+async function get_json(req: IncomingMessage) {
+	return JSON.parse(await get_text(req));
+}
+
+async function get_urlencoded(req: IncomingMessage) {
+	const text = await get_text(req);
+
+	const { data, append } = read_only_form_data();
+
+	text.replace(/\+/g, ' ').split('&').forEach(str => {
+		const [key, value] = str.split('=');
+		append(decodeURIComponent(key), decodeURIComponent(value));
+	});
+
+	return data;
+}
+
+async function get_multipart(req: IncomingMessage, boundary: string) {
+	const text = await get_text(req);
+	const parts = text.split(`--${boundary}`);
+
+	const nope = () => {
+		throw new Error('Malformed form data');
+	}
+
+	if (parts[0] !== '' || parts[parts.length - 1].trim() !== '--') {
+		nope();
+	}
+
+	const { data, append } = read_only_form_data();
+
+	parts.slice(1, -1).forEach(part => {
+		const match = /\s*([\s\S]+?)\r\n\r\n([\s\S]*)\s*/.exec(part);
+		const raw_headers = match[1];
+		const body = match[2].trim();
+
+		let key: string;
+
+		const headers = {};
+		raw_headers.split('\r\n').forEach(str => {
+			const [raw_header, ...raw_directives] = str.split('; ');
+			let [name, value] = raw_header.split(': ');
+
+			name = name.toLowerCase();
+			headers[name] = value;
+
+			const directives: Record<string, string> = {};
+			raw_directives.forEach(raw_directive => {
+				const [name, value] = raw_directive.split('=');
+				directives[name] = JSON.parse(value); // TODO is this right?
+			});
+
+			if (name === 'content-disposition') {
+				if (value !== 'form-data') nope();
+
+				if (directives.filename) {
+					// TODO we probably don't want to do this automatically
+					throw new Error('File upload is not yet implemented');
+				}
+
+				if (directives.name) {
+					key = directives.name;
+				}
+			}
+		});
+
+		if (!key) nope();
+
+		append(key, body);
+	});
+
+	return data;
+}
+
+function get_text(req: IncomingMessage): Promise<string> {
+	return new Promise((fulfil, reject) => {
+		let data = '';
+
+		req.on('error', reject);
+
+		req.on('data', chunk => {
+			data += chunk;
+		});
+
+		req.on('end', () => {
+			fulfil(data);
+		});
+	});
+}
+
+function get_buffer(req: IncomingMessage): Promise<ArrayBuffer> {
+	return new Promise((fulfil, reject) => {
+		let data = new Uint8Array(0);
+
+		req.on('error', reject);
+
+		req.on('data', chunk => {
+			const new_data = new Uint8Array(data.length + chunk.length);
+
+			for (let i = 0; i < data.length; i += 1) {
+				new_data[i] = data[i];
+			}
+
+			for (let i = 0; i < chunk.length; i += 1) {
+				new_data[i + data.length] = chunk[i];
+			}
+
+			data = new_data;
+		});
+
+		req.on('end', () => {
+			fulfil(data.buffer);
+		});
+	});
+}

packages/app-utils/src/http/get_body/read_only_form_data.ts

@@ -0,0 +1,69 @@
+type FormDataMap = Map<string, string[]>;
+
+export function read_only_form_data() {
+	const map: FormDataMap = new Map();
+
+	return {
+		append(key: string, value: string) {
+			if (map.has(key)) {
+				map.get(key).push(value);
+			} else {
+				map.set(key, [value]);
+			}
+		},
+
+		data: new ReadOnlyFormData(map)
+	};
+}
+
+class ReadOnlyFormData {
+	#map: FormDataMap;
+
+	constructor(map: FormDataMap) {
+		this.#map = map;
+	}
+
+	get(key: string) {
+		return this.#map.get(key)?.[0];
+	}
+
+	getAll(key: string) {
+		return this.#map.get(key);
+	}
+
+	has(key: string) {
+		return this.#map.has(key);
+	}
+
+	*[Symbol.iterator]() {
+		for (const [key, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield [key, value[i]];
+			}
+		}
+	}
+
+	*entries() {
+		for (const [key, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield [key, value[i]];
+			}
+		}
+	}
+
+	*keys() {
+		for (const [key, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield key;
+			}
+		}
+	}
+
+	*values() {
+		for (const [, value] of this.#map) {
+			for (let i = 0; i < value.length; i += 1) {
+				yield value;
+			}
+		}
+	}
+}

packages/app-utils/src/http/index.ts

@@ -0,0 +1 @@
+export { get_body } from './get_body';

packages/app-utils/src/index.ts

@@ -1,3 +1,4 @@
 export { render } from './render';
 export { prerender } from './prerender';
-export * from './files';
+export * from './files';
+export * from './http';

packages/app-utils/src/prerender/index.ts

@@ -3,7 +3,7 @@ import { dirname, resolve as resolve_path } from 'path';
 import { parse, resolve, URLSearchParams } from 'url';
 import { mkdirp } from '../files';
 import { render } from '../render';
-import { RouteManifest } from '../types';
+import { PageResponse, RouteManifest } from '../types';
 
 function clean_html(html) {
 	return html
@@ -85,6 +85,7 @@ export async function prerender({
 			method: 'GET',
 			headers: {},
 			path,
+			body: null,
 			query: new URLSearchParams()
 		}, {
 			only_prerender: !force,
@@ -130,9 +131,11 @@ export async function prerender({
 				log.error(`${rendered.status} ${path}`);
 			}
 
-			if (rendered.dependencies) {
-				for (const path in rendered.dependencies) {
-					const result = rendered.dependencies[path];
+			const { dependencies } = rendered as PageResponse;
+
+			if (dependencies) {
+				for (const path in dependencies) {
+					const result = dependencies[path];
 					const response_type = Math.floor(result.status / 100);
 
 					const is_html = result.headers['content-type'] === 'text/html';

packages/app-utils/src/render/page.ts

@@ -104,6 +104,7 @@ export default async function render_page(
 					method: opts.method || 'GET',
 					headers: opts.headers || {}, // TODO inject credentials...
 					path: resolved,
+					body: opts.body,
 					query: new URLSearchParams(parsed.query)
 				}, options);
 

packages/app-utils/src/render/route.ts

@@ -27,6 +27,7 @@ export default function render_route(
 					host: request.host,
 					path: request.path,
 					query: request.query,
+					body: request.body,
 					params
 				}, context);
 

packages/app-utils/src/types.ts

@@ -8,7 +8,7 @@ export type IncomingRequest = {
 	host: string; // TODO is this actually necessary?
 	method: Method;
 	headers: Headers;
-	// TODO body
+	body: any; // TODO
 	path: string;
 	query: URLSearchParams;
 };

packages/app-utils/tsconfig.json

@@ -0,0 +1,31 @@
+{
+	"ts-node": {
+		"compilerOptions": {
+			"module": "commonjs"
+		}
+	},
+	"compilerOptions": {
+		// target node v8+ (https://node.green/)
+		// the only missing feature is Array.prototype.values
+		"lib": ["es2020"],
+		"target": "es2019",
+
+		// "declaration": true,
+		// "declarationDir": "types",
+
+		"noEmitOnError": true,
+		"noErrorTruncation": true,
+
+		// rollup takes care of these
+		"module": "esnext",
+		"moduleResolution": "node",
+		"resolveJsonModule": true,
+		"allowSyntheticDefaultImports": true,
+
+		// TODO: error all the things
+		//"strict": true,
+		"noImplicitThis": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true
+	}
+}

packages/kit/dummy/manifest.ts

@@ -0,0 +1,5 @@
+export const ErrorComponent = {};
+
+export const components = [];
+
+export const routes = [];

packages/kit/dummy/root.ts

@@ -0,0 +1,13 @@
+export function preload(_page: any, _session: any) {
+
+}
+
+export default class root {
+	constructor(_opts: any) {
+
+	}
+
+	$set(_data: any) {
+
+	}
+}