feat(ErrorObjectSerializer): make {Error} serializable

Author: michael-ciniawsky

lib/serialization/ErrorObjectSerializer.js

@@ -0,0 +1,21 @@
+"use strict";
+
+class ErrorObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.name);
+		write(obj.message);
+		write(obj.stack);
+	}
+
+	deserialize({ read }) {
+		const err = new Error();
+
+		err.name = read();
+		err.message = read();
+		err.stack = read();
+
+		return err;
+	}
+}
+
+module.exports = ErrorObjectSerializer;

lib/serialization/ObjectMiddleware.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+const ErrorObjectSerializer = require("./ErrorObjectSerializer");
 const MapObjectSerializer = require("./MapObjectSerializer");
 const PlainObjectSerializer = require("./PlainObjectSerializer");
 const RegExpObjectSerializer = require("./RegExpObjectSerializer");
@@ -57,6 +58,7 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 1;
 
+const errorObjectSerializer = new ErrorObjectSerializer();
 const plainObjectSerializer = new PlainObjectSerializer();
 const mapObjectSerializer = new MapObjectSerializer();
 const setObjectSerializer = new SetObjectSerializer();
@@ -74,26 +76,37 @@ serializers.set(Object, {
 	name: null,
 	serializer: plainObjectSerializer
 });
+
 serializers.set(Array, {
 	request: "",
 	name: null,
 	serializer: plainObjectSerializer
 });
+
 serializers.set(Map, {
 	request: "",
 	name: 1,
 	serializer: mapObjectSerializer
 });
+
 serializers.set(Set, {
 	request: "",
 	name: 2,
 	serializer: setObjectSerializer
 });
+
 serializers.set(RegExp, {
 	request: "",
 	name: 3,
 	serializer: regExpObjectSerializer
 });
+
+serializers.set(Error, {
+	request: "",
+	name: 4,
+	serializer: errorObjectSerializer
+});
+
 for (const { request, name, serializer } of serializers.values()) {
 	serializerInversed.set(`${request}/${name}`, serializer);
 }
@@ -108,23 +121,27 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 */
 	static register(Constructor, request, name, serializer) {
 		const key = request + "/" + name;
+
 		if (serializers.has(Constructor)) {
 			throw new Error(
 				`ObjectMiddleware.register: serializer for ${
 					Constructor.name
 				} is already registered`
 			);
 		}
+
 		if (serializerInversed.has(key)) {
 			throw new Error(
 				`ObjectMiddleware.register: serializer for ${key} is already registered`
 			);
 		}
+
 		serializers.set(Constructor, {
 			request,
 			name,
 			serializer
 		});
+
 		serializerInversed.set(key, serializer);
 	}
 
@@ -140,40 +157,49 @@ class ObjectMiddleware extends SerializerMiddleware {
 				} is already registered`
 			);
 		}
+
 		serializers.set(Constructor, NOT_SERIALIZABLE);
 	}
 
 	static getSerializerFor(object) {
 		const c = object.constructor;
 		const config = serializers.get(c);
+
 		if (!config) throw new Error(`No serializer registered for ${c.name}`);
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
+
 		return config;
 	}
 
 	static getDeserializerFor(request, name) {
 		const key = request + "/" + name;
 		const serializer = serializerInversed.get(key);
+
 		if (serializer === undefined) {
 			throw new Error(`No deserializer registered for ${key}`);
 		}
+
 		return serializer;
 	}
 
 	_handleFunctionSerialization(fn, context) {
 		return () => {
 			const r = fn();
+
 			if (r instanceof Promise)
 				return r.then(data => this.serialize([data], context));
+
 			return this.serialize([r], context);
 		};
 	}
 
 	_handleFunctionDeserialization(fn, context) {
 		return () => {
 			const r = fn();
+
 			if (r instanceof Promise)
 				return r.then(data => this.deserialize(data, context)[0]);
+
 			return this.deserialize(r, context)[0];
 		};
 	}
@@ -197,12 +223,16 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const process = item => {
 			// check if we can emit a reference
 			const ref = referenceable.get(item);
+
 			if (ref !== undefined) {
 				result.push(ESCAPE, ref - currentPos);
+
 				return;
 			}
+
 			if (Buffer.isBuffer(item)) {
 				addReferenceable(item);
+
 				result.push(item);
 			} else if (typeof item === "object" && item !== null) {
 				if (cycleStack.has(item)) {
@@ -213,32 +243,40 @@ class ObjectMiddleware extends SerializerMiddleware {
 							.join(" -> ")})`
 					);
 				}
+
 				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
 					item
 				);
-
 				const key = `${request}/${name}`;
 				const lastIndex = objectTypeLookup.get(key);
+
 				if (lastIndex === undefined) {
 					objectTypeLookup.set(key, currentPosTypeLookup++);
+
 					result.push(ESCAPE, request, name);
 				} else {
 					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
 				}
+
 				cycleStack.add(item);
+
 				serializer.serialize(item, {
 					write(value) {
 						process(value);
 					}
 				});
+
 				cycleStack.delete(item);
+
 				result.push(ESCAPE, ESCAPE_END_OBJECT);
+
 				addReferenceable(item);
 			} else if (typeof item === "string") {
 				if (item !== "") {
 					// empty strings are shorter when not emitting a reference (this saves 1 byte per empty string)
 					addReferenceable(item);
 				}
+
 				result.push(item);
 			} else if (item === ESCAPE) {
 				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
@@ -250,14 +288,17 @@ class ObjectMiddleware extends SerializerMiddleware {
 				result.push(item);
 			}
 		};
+
 		try {
 			for (const item of data) {
 				process(item);
 			}
 		} catch (e) {
 			if (e === NOT_SERIALIZABLE) return null;
+
 			throw e;
 		}
+
 		return result;
 	}
 
@@ -271,10 +312,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const read = () => {
 			if (currentDataPos >= data.length)
 				throw new Error("Unexpected end of stream");
+
 			return data[currentDataPos++];
 		};
+
 		if (read() !== CURRENT_VERSION)
 			throw new Error("Version missmatch, serializer changed");
+
 		let currentPos = 0;
 		const referenceable = new Map();
 		const addReferenceable = item => {
@@ -285,8 +329,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const result = [];
 		const decodeValue = () => {
 			const item = read();
+
 			if (item === ESCAPE) {
 				const nextItem = read();
+
 				if (nextItem === ESCAPE_ESCAPE_VALUE) {
 					return ESCAPE;
 				} else if (nextItem === ESCAPE_UNDEFINED) {
@@ -301,51 +347,66 @@ class ObjectMiddleware extends SerializerMiddleware {
 				} else {
 					const request = nextItem;
 					let serializer;
+
 					if (typeof request === "number") {
 						serializer = objectTypeLookup.get(currentPosTypeLookup - request);
 					} else {
 						const name = read();
+
 						if (request && !loadedRequests.has(request)) {
 							require(request);
+
 							loadedRequests.add(request);
 						}
+
 						serializer = ObjectMiddleware.getDeserializerFor(request, name);
+
 						objectTypeLookup.set(currentPosTypeLookup++, serializer);
 					}
 					const item = serializer.deserialize({
 						read() {
 							const item = decodeValue();
+
 							return item;
 						}
 					});
 					const end1 = read();
+
 					if (end1 !== ESCAPE) {
 						throw new Error("Expected end of object");
 					}
+
 					const end2 = read();
+
 					if (end2 !== ESCAPE_END_OBJECT) {
 						throw new Error("Expected end of object");
 					}
+
 					addReferenceable(item);
+
 					return item;
 				}
 			} else if (typeof item === "string") {
 				if (item !== "") {
 					addReferenceable(item);
 				}
+
 				return item;
 			} else if (Buffer.isBuffer(item)) {
 				addReferenceable(item);
+
 				return item;
 			} else if (typeof item === "function") {
 				return this._handleFunctionDeserialization(item, context);
 			} else {
 				return item;
 			}
 		};
+
 		while (currentDataPos < data.length) {
 			result.push(decodeValue());
 		}
+
 		return result;
 	}
 }