@verdant-web/common 2.8.0 → 2.9.1

package/src/schema/validation.ts

@@ -1,7 +1,8 @@
-import { isFile, isFileData } from '../files.js';
+import { isFile, isFileData, isFileRef } from '../files.js';
 import { OID_KEY } from '../oidsLegacy.js';
+import { isObjectRef } from '../operation.js';
 import { isObject } from '../utils.js';
-import { getFieldDefault, hasDefault, isNullable } from './fields.js';
+import { hasDefault, isNullable } from './fields.js';
 import { StorageFieldSchema, StorageFieldsSchema } from './types.js';
 
 export function validateEntity(
@@ -47,17 +48,29 @@ export function validateEntityField({
 	fieldPath = [],
 	depth,
 	requireDefaults,
+	expectRefs,
+	hasPassedFirstLevel,
 }: {
 	field: StorageFieldSchema;
 	value: any;
 	fieldPath: (string | number)[];
 	depth?: number;
 	requireDefaults?: boolean;
+	/**
+	 * Run validation expecting refs, not nested objects. For validating
+	 * views (as opposed to inits/snapshots). Recommended to use depth 2
+	 * or no depth specified.
+	 */
+	expectRefs?: boolean;
+	hasPassedFirstLevel?: boolean;
 }): EntityValidationProblem | undefined {
+	// we only _actually_ start expecting refs after the first validation level.
+	// TODO: something more... elegant?
+	const actuallyExpectRefs = expectRefs && hasPassedFirstLevel;
 	if (depth !== undefined && depth <= 0) return;
 
-	if (isNullable(field) && value === null) return;
-	if (value === null) {
+	if (isNullable(field) && (value === null || value === undefined)) return;
+	if (value === null || value === undefined) {
 		if (requireDefaults || !hasDefault(field)) {
 			return {
 				type: 'no-default',
@@ -68,77 +81,126 @@ export function validateEntityField({
 	}
 
 	if (field.type === 'object') {
-		if (!isObject(value)) {
-			return {
-				type: 'invalid-type',
-				fieldPath,
-				message: `Expected object ${
-					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
-			};
-		}
-		for (const [key, subField] of Object.entries(
-			field.properties as StorageFieldsSchema,
-		)) {
-			// legacy -- old objects sometimes accidentally include this key
-			if (key === OID_KEY) continue;
-			if (value[key]) {
-				validateEntityField({
+		if (actuallyExpectRefs) {
+			if (!isObjectRef(value)) {
+				return {
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected ref for field ${formatField(
+						fieldPath,
+					)}, got ${safeStringify(value)}`,
+				};
+			}
+		} else {
+			if (!isObject(value)) {
+				return {
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected object ${
+						field.nullable ? 'or null ' : ''
+					}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
+				};
+			}
+			for (const [key, subField] of Object.entries(
+				field.properties as StorageFieldsSchema,
+			)) {
+				// legacy -- old objects sometimes accidentally include this key
+				if (key === OID_KEY) continue;
+				const error = validateEntityField({
 					field: subField,
 					value: value[key],
 					fieldPath: [...fieldPath, key],
 					depth: depth !== undefined ? depth - 1 : undefined,
+					expectRefs,
+					hasPassedFirstLevel: true,
 				});
+				if (error) {
+					return error;
+				}
+			}
+			// check for unexpected keys
+			for (const key of Object.keys(value)) {
+				if (!field.properties[key]) {
+					return {
+						type: 'invalid-key',
+						fieldPath: [...fieldPath, key],
+						message: `Invalid unexpected field "${key}" on value ${formatField(
+							fieldPath,
+						)}`,
+					};
+				}
 			}
 		}
-		// check for unexpected keys
-		for (const key of Object.keys(value)) {
-			if (!field.properties[key]) {
+	} else if (field.type === 'array') {
+		if (actuallyExpectRefs) {
+			if (!isObjectRef(value)) {
 				return {
-					type: 'invalid-key',
-					fieldPath: [...fieldPath, key],
-					message: `Invalid unexpected field "${key}" on value ${formatField(
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected ref for field ${formatField(
 						fieldPath,
-					)}`,
+					)}, got ${safeStringify(value)}`,
 				};
 			}
-		}
-	} else if (field.type === 'array') {
-		if (!Array.isArray(value)) {
-			if (value === null && field.nullable) return;
-			return {
-				type: 'invalid-value',
-				fieldPath,
-				message: `Expected array ${
-					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
-			};
-		}
-		for (const item of value) {
-			validateEntityField({
-				field: field.items,
-				value: item,
-				fieldPath: [...fieldPath, '[]'],
-				depth: depth !== undefined ? depth - 1 : undefined,
-			});
+		} else {
+			if (!Array.isArray(value)) {
+				if (value === null && field.nullable) return;
+				return {
+					type: 'invalid-value',
+					fieldPath,
+					message: `Expected array ${
+						field.nullable ? 'or null ' : ''
+					}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
+				};
+			}
+			for (const item of value) {
+				const error = validateEntityField({
+					field: field.items,
+					value: item,
+					fieldPath: [...fieldPath, '[]'],
+					depth: depth !== undefined ? depth - 1 : undefined,
+					expectRefs,
+					hasPassedFirstLevel: true,
+				});
+				if (error) {
+					return error;
+				}
+			}
 		}
 	} else if (field.type === 'map') {
-		if (!isObject(value)) {
-			return {
-				type: 'invalid-type',
-				fieldPath,
-				message: `Expected map for field ${formatField(
+		if (actuallyExpectRefs) {
+			if (!isObjectRef(value)) {
+				return {
+					type: 'invalid-type',
 					fieldPath,
-				)}, got ${value}`,
-			};
-		}
-		for (const [key, item] of Object.entries(value)) {
-			validateEntityField({
-				field: field.values,
-				value: item,
-				fieldPath: [...fieldPath, key],
-				depth: depth !== undefined ? depth - 1 : undefined,
-			});
+					message: `Expected ref for field ${formatField(
+						fieldPath,
+					)}, got ${safeStringify(value)}`,
+				};
+			}
+		} else {
+			if (!isObject(value)) {
+				return {
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected map for field ${formatField(
+						fieldPath,
+					)}, got ${safeStringify(value)}`,
+				};
+			}
+			for (const [key, item] of Object.entries(value)) {
+				const error = validateEntityField({
+					field: field.values,
+					value: item,
+					fieldPath: [...fieldPath, key],
+					depth: depth !== undefined ? depth - 1 : undefined,
+					expectRefs,
+					hasPassedFirstLevel: true,
+				});
+				if (error) {
+					return error;
+				}
+			}
 		}
 	} else if (field.type === 'string') {
 		if (typeof value !== 'string') {
@@ -147,7 +209,7 @@ export function validateEntityField({
 				fieldPath,
 				message: `Expected string ${
 					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
+				}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
 			};
 		}
 		if (field.options && !field.options.includes(value)) {
@@ -156,7 +218,7 @@ export function validateEntityField({
 				fieldPath,
 				message: `Expected one of ${field.options.join(
 					', ',
-				)} for field ${formatField(fieldPath)}, got ${value}`,
+				)} for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
 			};
 		}
 	} else if (field.type === 'boolean') {
@@ -166,7 +228,7 @@ export function validateEntityField({
 				fieldPath,
 				message: `Expected boolean ${
 					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
+				}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
 			};
 		}
 	} else if (field.type === 'number') {
@@ -176,22 +238,43 @@ export function validateEntityField({
 				fieldPath,
 				message: `Expected number ${
 					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
+				}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
 			};
 		}
 	} else if (field.type === 'file') {
-		if (!isFile(value) && !isFileData(value)) {
-			return {
-				type: 'invalid-type',
-				fieldPath,
-				message: `Expected file ${
-					field.nullable ? 'or null ' : ''
-				}for field ${formatField(fieldPath)}, got ${value}`,
-			};
+		if (actuallyExpectRefs) {
+			if (!isFileRef(value)) {
+				return {
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected file ref for field ${formatField(
+						fieldPath,
+					)}, got ${safeStringify(value)}`,
+				};
+			}
+		} else {
+			if (!isFile(value) && !isFileData(value)) {
+				return {
+					type: 'invalid-type',
+					fieldPath,
+					message: `Expected file ${
+						field.nullable ? 'or null ' : ''
+					}for field ${formatField(fieldPath)}, got ${safeStringify(value)}`,
+				};
+			}
 		}
 	}
 }
 
+function safeStringify(value: any) {
+	try {
+		return JSON.stringify(value);
+	} catch (err) {
+		// for example, recursive objects can't be stringified
+		return String(value);
+	}
+}
+
 function formatField(fieldPath: (string | number)[]) {
 	if (fieldPath.length === 0) return 'root';
 	return fieldPath.join('.');

package/src/timestamp.ts

@@ -42,6 +42,20 @@ export class NaiveTimestampProvider implements TimestampProvider {
 	}
 }
 
+// good for tests that require determinism.
+export class FixedTimestampProvider implements TimestampProvider {
+	time = new Date(2025, 2, 19).getTime().toString();
+	counter = 0;
+	now = (version: number | string) => {
+		return encodeVersion(version) + this.time + '-' + this.counter++;
+	};
+	update = () => {};
+	zero = (version: number | string) => {
+		return encodeVersion(version) + '0' + '-' + this.counter++;
+	};
+	getWallClockTime = () => 0;
+}
+
 export class HybridLogicalClockTimestampProvider implements TimestampProvider {
 	private latest: HLCTimestamp = {
 		time: Date.now(),

package/src/undo.test.ts

@@ -1,21 +1,100 @@
 import { describe, expect, it } from 'vitest';
-import { createOid } from './oids.js';
+import { assignOid, createOid, createRef } from './oids.js';
 import { PatchCreator } from './patch.js';
 import { getUndoOperations } from './undo.js';
 
+function createClock(start: number = 0) {
+	let time = start;
+	function clock() {
+		return `${time++}`;
+	}
+	clock.reset = () => {
+		time = start;
+	};
+	return clock;
+}
+
 describe('undo', () => {
 	it('correctly removes added list items', () => {
-		let time = 0;
-		const clock = () => `time-${time++}`;
-		let subId = 0;
-		const patchCreator = new PatchCreator(clock, () => `${subId++}`);
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
 		const initial = [1, 2];
 		const oid = createOid('test', 'foo');
 		const operations = patchCreator.createListSet(oid, 2, 3);
-		time = 0;
+		clock.reset();
 		const undos = getUndoOperations(oid, initial, operations, clock);
-
-		time = 0;
+		clock.reset();
 		expect(undos).toEqual(patchCreator.createListDelete(oid, 2, 1));
 	});
+	it('correctly restores removed items by ref', () => {
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
+		const initial = assignOid(
+			[createRef('test/a:1'), createRef('test/a:2'), createRef('test/a:3')],
+			'test/a',
+		);
+		const operations = patchCreator.createListRemove(
+			'test/a',
+			initial[1],
+			'last',
+		);
+		clock.reset();
+		const undos = getUndoOperations('test/a', initial, operations, clock);
+		clock.reset();
+		expect(undos).toEqual(
+			patchCreator.createListInsert('test/a', 1, initial[1]),
+		);
+	});
+	it('undoes list insert with 1 item', () => {
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
+		const initial = [1, 2];
+		const oid = createOid('test', 'foo');
+		const operations = patchCreator.createListInsert(oid, 1, 3);
+		clock.reset();
+		const undos = getUndoOperations(oid, initial, operations, clock);
+		clock.reset();
+		expect(undos).toEqual(patchCreator.createListDelete(oid, 1, 1));
+	});
+	it('undoes list insert with multiple items', () => {
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
+		const initial = [1, 2];
+		const oid = createOid('test', 'foo');
+		const operations = patchCreator.createListInsertMany(oid, 1, [3, 4]);
+		clock.reset();
+		const undos = getUndoOperations(oid, initial, operations, clock);
+		clock.reset();
+		expect(undos).toEqual(patchCreator.createListDelete(oid, 1, 2));
+	});
+	it('undoes initialize with delete', () => {
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
+		const initial = { foo: 'bar' };
+		const oid = createOid('test', 'foo');
+		const operations = patchCreator.createInitialize(initial, oid);
+		clock.reset();
+		const undos = getUndoOperations(oid, initial, operations, clock);
+		clock.reset();
+		expect(undos).toEqual(patchCreator.createDelete(oid));
+	});
+	it('undoes an object move by ref', () => {
+		const clock = createClock();
+		const patchCreator = new PatchCreator(clock, createClock());
+		const initial = assignOid(
+			[createRef('test/a:1'), createRef('test/a:2'), createRef('test/a:3')],
+			'test/a',
+		);
+		const operations = patchCreator.createListMoveByRef(
+			'test/a',
+			initial[1],
+			0,
+		);
+		clock.reset();
+		const undos = getUndoOperations('test/a', initial, operations, clock);
+		clock.reset();
+		expect(undos).toEqual(
+			patchCreator.createListMoveByRef('test/a', initial[1], 1),
+		);
+	});
 });