@hg-ts/serialize 0.5.16 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/serialize",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -18,11 +18,11 @@
     "test:dev": "vitest watch"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.16",
-    "@hg-ts/exception": "0.5.16",
-    "@hg-ts/linter": "0.5.16",
-    "@hg-ts/tests": "0.5.16",
-    "@hg-ts/types": "0.5.16",
+    "@hg-ts-config/typescript": "0.5.18",
+    "@hg-ts/exception": "0.5.18",
+    "@hg-ts/linter": "0.5.18",
+    "@hg-ts/tests": "0.5.18",
+    "@hg-ts/types": "0.5.18",
     "@types/node": "22.19.1",
     "@vitest/coverage-v8": "4.0.14",
     "eslint": "9.18.0",
@@ -34,7 +34,7 @@
     "vitest": "4.0.14"
   },
   "peerDependencies": {
-    "@hg-ts/exception": "0.5.16",
+    "@hg-ts/exception": "0.5.18",
     "reflect-metadata": "*",
     "tslib": "*",
     "vitest": "*"

package/src/additional-classes.ts

@@ -0,0 +1,5 @@
+export const classes = new Map<string, Class>();
+
+export function addAdditionalClass(classToTransform: Class<any, any[]>): void {
+	classes.set(classToTransform.name, classToTransform);
+}

package/src/deserialize.ts

@@ -0,0 +1,72 @@
+import { classes } from './additional-classes.js';
+import {
+	DeserializeException,
+	DeserializeUnknownPrototypeException,
+} from './exceptions/index.js';
+import type {
+	SerializedObject,
+	SerializedValue,
+} from './types.js';
+
+function deserializeObject(
+	{ value, prototypeNameList }: SerializedObject,
+): unknown {
+	let targetClass: Class = Object;
+	const [preferredClassName = null] = prototypeNameList.filter(name => name !== Object.name);
+
+	if (preferredClassName) {
+		const foundCtor = classes.get(preferredClassName);
+
+		if (!foundCtor) {
+			throw new DeserializeUnknownPrototypeException(preferredClassName);
+		}
+
+		targetClass = foundCtor;
+	}
+
+	const result: Record<string, unknown> = Object.create(targetClass.prototype);
+
+	return Object.keys(value)
+		.reduce<Record<string, unknown>>((result, key) => {
+			result[key] = deserializeValue(value[key]!);
+
+			return result;
+		}, result);
+}
+
+function deserializeValue(value: SerializedValue): unknown {
+	switch (value.type) {
+	case 'boolean':
+	case 'string':
+	case 'number':
+		return value.value;
+	case 'buffer':
+		return Buffer.from(value.value, 'hex');
+	case 'bigint':
+		return BigInt(value.value);
+	case 'null':
+		return null;
+	case 'date':
+		return new Date(value.value);
+	case 'array':
+		return value.value.map(item => deserializeValue(item));
+	case 'set':
+		return new Set(value.value.map(item => deserializeValue(item)));
+	case 'map':
+		return new Map(value.value.map(item => [
+			deserializeValue(item.key),
+			deserializeValue(item.value),
+		]));
+	case 'object':
+		return deserializeObject(value);
+
+	default: {
+		const error: never = value;
+		throw new DeserializeException(error);
+	}
+	}
+}
+
+export function deserialize(value: SerializedValue): unknown {
+	return deserializeValue(value);
+}

package/src/exceptions/deserialize-unknown-prototype.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class DeserializeUnknownPrototypeException extends BaseException {
+	public constructor(ctorName: string) {
+		super(`Deserialize error. Constructor with name ${ctorName} not found`);
+	}
+}

package/src/exceptions/deserialize.exception.ts

@@ -0,0 +1,9 @@
+import { BaseException } from '@hg-ts/exception';
+
+import type { SerializedValue } from '../types.js';
+
+export class DeserializeException extends BaseException {
+	public constructor(value: SerializedValue) {
+		super(`Error for deserialize value: ${JSON.stringify(value)}`);
+	}
+}

package/src/exceptions/index.ts

@@ -0,0 +1,3 @@
+export * from './deserialize-unknown-prototype.exception.js';
+export * from './deserialize.exception.js';
+export * from './serialize.exception.js';

package/src/exceptions/serialize.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class SerializeException extends BaseException {
+	public constructor(type: string) {
+		super(`Unsupported type for serialization: ${type}`);
+	}
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+
+export { addAdditionalClass } from './additional-classes.js';
+export * from './serialize.js';
+export * from './deserialize.js';
+
+export * from './exceptions/index.js';

package/src/serialize.ts

@@ -0,0 +1,117 @@
+import { SerializeException } from './exceptions/index.js';
+import type {
+	SerializedArray,
+	SerializedObject,
+	SerializedValue,
+} from './types.js';
+
+export function getPrototypeListNames(value: Record<string | symbol, unknown>): string[] {
+	const result: string[] = [];
+	let nextPrototype = Object.getPrototypeOf(value);
+
+	while (nextPrototype !== null) {
+		result.push(nextPrototype.constructor.name);
+
+		nextPrototype = Object.getPrototypeOf(nextPrototype);
+	}
+
+	return result;
+}
+
+function serializeArray(value: unknown[]): SerializedArray {
+	return {
+		type: 'array',
+		value: value.map(item => serializeValue(item)),
+	};
+}
+
+function serializeRecord(value: Record<string | symbol, unknown>): SerializedObject {
+	const symbolKeys = Object.getOwnPropertySymbols(value);
+
+	if (symbolKeys.length > 0) {
+		throw new SerializeException('symbol key not allowed');
+	}
+
+	const fields = Object.keys(value)
+		.reduce<Record<string, SerializedValue>>((result, key) => {
+			result[key as string] = serializeValue(value[key]);
+			return result;
+		}, {});
+
+	return {
+		type: 'object',
+		prototypeNameList: getPrototypeListNames(value),
+		value: fields,
+	};
+}
+
+function serializeObject(value: object | null): SerializedValue {
+	if (value === null) {
+		return { type: 'null' };
+	}
+	if (value instanceof Date) {
+		return {
+			type: 'date',
+			value: value.getTime(),
+		};
+	}
+	if (value instanceof Buffer) {
+		return {
+			type: 'buffer',
+			value: value.toString('hex'),
+		};
+	}
+	if (value instanceof Map) {
+		return {
+			type: 'map',
+			value: [...value.entries()].map(([key, value]) => ({
+				key: serializeValue(key),
+				value: serializeValue(value),
+			})),
+		};
+	}
+	if (value instanceof Set) {
+		return {
+			type: 'set',
+			value: [...value.values()].map(item => serializeValue(item)),
+		};
+	}
+	if (Array.isArray(value)) {
+		return serializeArray(value);
+	}
+
+	return serializeRecord(value as any);
+}
+
+function serializeValue(value: unknown): SerializedValue {
+	switch (typeof value) {
+	case 'boolean':
+		return {
+			value,
+			type: 'boolean',
+		};
+	case 'bigint':
+		return {
+			type: 'bigint',
+			value: String(value),
+		};
+	case 'string':
+		return {
+			value,
+			type: 'string',
+		};
+	case 'number':
+		return {
+			value,
+			type: 'number',
+		};
+	case 'object':
+		return serializeObject(value as any);
+	default:
+		throw new SerializeException(typeof value);
+	}
+}
+
+export function serialize(value: unknown): SerializedValue {
+	return serializeValue(value);
+}

package/src/tests/example.ts

@@ -0,0 +1,6 @@
+export class Example {
+	public readonly value: string;
+	public constructor(value: string) {
+		this.value = value;
+	}
+}

package/src/tests/serialization.test.ts

@@ -0,0 +1,140 @@
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import { addAdditionalClass } from '../additional-classes.js';
+import { deserialize } from '../deserialize.js';
+import {
+	DeserializeException,
+	DeserializeUnknownPrototypeException,
+	SerializeException,
+} from '../exceptions/index.js';
+import { serialize } from '../serialize.js';
+import { SerializedObject } from '../types.js';
+import { Example } from './example.js';
+
+@Describe()
+export class SerializationTestSuite extends Suite {
+	@Test()
+	public async serializeNull(): Promise<void> {
+		this.test(null);
+	}
+
+	@Test()
+	public async serializeNumber(): Promise<void> {
+		this.test(123);
+		this.test(12.35);
+		this.test(0);
+		this.test(-12.35);
+		this.test(-123);
+	}
+
+	@Test()
+	public async serializeString(): Promise<void> {
+		this.test('random string');
+		this.test('');
+	}
+
+	@Test()
+	public async serializeSet(): Promise<void> {
+		this.test(new Set(['foo', 'bar']));
+		this.test(new Set());
+	}
+
+	@Test()
+	public async serializeMap(): Promise<void> {
+		this.test(new Map<unknown, unknown>([
+			['foo', 'bar'],
+			[1, 'string'],
+			['string', Buffer.from('some string')],
+		]));
+		this.test(new Map());
+	}
+
+	@Test()
+	public async serializeDate(): Promise<void> {
+		this.test(new Date());
+		this.test(new Date('2024-01-01'));
+	}
+
+	@Test()
+	public async serializeBigint(): Promise<void> {
+		this.test(1235n * 1_000_000_000_000_000_000_000_000n);
+		this.test(123n);
+		this.test(0n);
+		this.test(-123n);
+		this.test(-1235n * 1_000_000_000_000_000_000_000_000n);
+	}
+
+	@Test()
+	public async serializeBuffer(): Promise<void> {
+		this.test(Buffer.from('sdfsdgdfgdfg'));
+	}
+
+	@Test()
+	public async serializeInstance(): Promise<void> {
+		addAdditionalClass(Example);
+		const test = new Example(Math.random().toString());
+		this.test(test);
+	}
+
+	@Test()
+	@ExpectException(DeserializeUnknownPrototypeException)
+	public async deserializeInstanceError(): Promise<void> {
+		addAdditionalClass(Example);
+		const test = new Example(Math.random().toString());
+
+		const serialized = serialize(test) as SerializedObject;
+
+		serialized.prototypeNameList.unshift('UnknownClass');
+		deserialize(serialized);
+	}
+
+	@Test()
+	public async deserializeWithoutNameList(): Promise<void> {
+		const test = new Example(Math.random().toString());
+
+		const serialized = serialize(test) as SerializedObject;
+
+		serialized.prototypeNameList = [];
+		expect(deserialize(serialized)).toMatchObject(test);
+	}
+
+	@Test()
+	@ExpectException(DeserializeException)
+	public async deserializeFunction(): Promise<void> {
+		deserialize((() => true) as any);
+	}
+
+	@Test()
+	public async serializeArray(): Promise<void> {
+		this.test([1, 2, 3]);
+	}
+
+	@Test()
+	@ExpectException(SerializeException)
+	public async serializeSymbol(): Promise<void> {
+		this.test(Symbol('name'));
+	}
+
+	@Test()
+	@ExpectException(SerializeException)
+	public async serializeSymbolKey(): Promise<void> {
+		this.test({ [Symbol('name')]: 'value' });
+	}
+
+	@Test()
+	public async serializeBoolean(): Promise<void> {
+		this.test(true);
+		this.test(false);
+	}
+
+	protected test(expected: unknown): void {
+		const value = deserialize(serialize(expected));
+
+		expect(value).toEqual(expected);
+	}
+}

package/src/types.ts

@@ -0,0 +1,70 @@
+export type SerializedNumber = {
+	type: 'number';
+	value: number;
+};
+
+export type SerializedString = {
+	type: 'string';
+	value: string;
+};
+
+export type SerializedBoolean = {
+	type: 'boolean';
+	value: boolean;
+};
+
+export type SerializedBigint = {
+	type: 'bigint';
+	value: string;
+};
+
+export type SerializedDate = {
+	type: 'date';
+	value: number;
+};
+
+export type SerializedArray = {
+	type: 'array';
+	value: SerializedValue[];
+};
+
+export type SerializedBuffer = {
+	type: 'buffer';
+	value: string;
+};
+
+export type SerializedObject = {
+	type: 'object';
+	prototypeNameList: string[];
+	value: Record<string, SerializedValue>;
+};
+
+export type SerializedMap = {
+	type: 'map';
+	value: {
+		key: SerializedValue;
+		value: SerializedValue;
+	}[];
+};
+
+export type SerializedSet = {
+	type: 'set';
+	value: SerializedValue[];
+};
+
+export type SerializedNull = {
+	type: 'null';
+};
+
+export type SerializedValue =
+	| SerializedArray
+	| SerializedBigint
+	| SerializedBoolean
+	| SerializedDate
+	| SerializedMap
+	| SerializedNull
+	| SerializedBuffer
+	| SerializedNumber
+	| SerializedObject
+	| SerializedSet
+	| SerializedString;