feat: Initial clean release of CHM

packages/tools/fuzzer/model/Serializable.ts

@@ -0,0 +1,131 @@
+import { hasOwnProperty } from '@joplin/utils/object';
+import { ItemId } from './types';
+
+type StringTypePrimitive = 'string'|'boolean'|'number'|'unknown'|'id';
+type StringType = StringTypePrimitive|`${StringTypePrimitive}[]`;
+export type BaseSchema =
+	StringType
+	| [BaseSchema, '...']
+	| [BaseSchema, BaseSchema]
+	| { [key: string]: BaseSchema };
+
+type TypeMap = {
+	'string': string;
+	'boolean': boolean;
+	'number': number;
+	'id': ItemId;
+	'unknown': unknown;
+	'string[]': string[];
+	'boolean[]': boolean[];
+	'number[]': number[];
+	'id[]': ItemId[];
+	'unknown[]': unknown[];
+};
+
+export type SchemaToType<Schema extends BaseSchema|StringType> = (
+	Schema extends StringType
+		? TypeMap[Schema]
+		: {
+			[key in keyof Schema]:
+			Schema[key] extends [BaseSchema, '...']
+				? SchemaToType<Schema[key][0]>[]
+				: Schema[key] extends [BaseSchema, BaseSchema]
+					? [ SchemaToType<Schema[key][0]>, SchemaToType<Schema[key][1]> ]
+					: Schema[key] extends BaseSchema
+						? SchemaToType<Schema[key]>
+						: never
+		}
+);
+
+const deserializeFromSchema = <Schema extends BaseSchema|StringType> (schema: Schema, data: unknown): SchemaToType<Schema> => {
+	const errorContext = () => `(deserializing ${JSON.stringify(data)})`;
+
+	let result;
+	if (typeof schema === 'string') {
+		if (schema === 'id') {
+			if (typeof data !== 'string') {
+				throw new Error(`IDs must be strings. ${errorContext()}`);
+			}
+			if (data !== '' && !/^[a-z0-9]{32}$/i.exec(data)) {
+				throw new Error(`IDs must be 32 character alphanumeric strings or empty. ${errorContext()}`);
+			}
+
+			result = data;
+		} else if (schema === 'unknown') {
+			// No check required
+			result = data;
+		} else if (schema.endsWith('[]')) {
+			if (!Array.isArray(data)) {
+				throw new Error(`Invalid type ${typeof data}, expected array. ${errorContext()}`);
+			}
+
+			const subSchema = schema.substring(0, schema.length - 2) as StringType;
+
+			const resultArray = [];
+			for (const item of data) {
+				resultArray.push(deserializeFromSchema(subSchema, item));
+			}
+			result = resultArray;
+		} else if (typeof data !== schema) {
+			throw new Error(`Invalid type: ${typeof data}. Expected ${schema} ${errorContext()}`);
+		} else {
+			result = data;
+		}
+	} else if (Array.isArray(schema)) {
+		if (!Array.isArray(data)) {
+			throw new Error(`Invalid type: ${typeof data}. Expected array. ${errorContext()}`);
+		}
+
+		if (schema.length !== 2) {
+			throw new Error(`Invalid schema: ${JSON.stringify(schema)}. Expected an array of length 2.`);
+		}
+
+		if (schema[1] === '...') {
+			const itemSchema = schema[0];
+
+			const resultArray = [];
+			for (let i = 0; i < data.length; i++) {
+				// Cast to 'unknown' to avoid "type instantiation is excessively deep" errors
+				resultArray.push(deserializeFromSchema(itemSchema as 'unknown', data[i]));
+			}
+			result = resultArray;
+		} else {
+			result = [
+				// Cast to 'unknown' to avoid "type instantiation is excessively deep" errors
+				deserializeFromSchema(schema[0] as 'unknown', data[0]),
+				deserializeFromSchema(schema[1] as 'unknown', data[1]),
+			];
+		}
+	} else {
+		if (typeof data !== 'object') {
+			throw new Error(`Cannot deserialize non-object ${errorContext()}`);
+		}
+
+		result = Object.create(null);
+		for (const [key, subSchema] of Object.entries(schema)) {
+			if (!hasOwnProperty(data, key)) {
+				throw new Error(`Cannot deserialize: Missing property ${JSON.stringify(key)} ${errorContext()}`);
+			}
+
+			result[key] = deserializeFromSchema(subSchema as 'unknown', data[key]);
+		}
+	}
+	return result;
+};
+
+export default abstract class Serializable<Schema extends BaseSchema> {
+	// Note: At present, schema **must** use the js-private variable
+	// syntax to prevent it from being listed as a property on the subclass.
+	#schema: Schema;
+
+	protected constructor(schema: Schema) {
+		this.#schema = schema;
+	}
+
+	public abstract serialize(): Readonly<SchemaToType<Schema>>;
+
+	protected static deserialize = deserializeFromSchema;
+	protected deserialize(data: unknown): SchemaToType<Schema> {
+		return deserializeFromSchema(this.#schema, data);
+	}
+}