@verdant-web/common 1.16.2 → 2.0.0

package/src/schema/validation.ts

@@ -1,97 +1,182 @@
-import { LEGACY_OID_KEY, OID_KEY } from '../oids.js';
 import { isObject } from '../utils.js';
-import { StorageCollectionSchema, StorageFieldSchema } from './types.js';
+import { hasDefault, isNullable } from './fields.js';
+import { StorageFieldSchema, StorageFieldsSchema } from './types.js';
 
 export function validateEntity(
-	schema: StorageCollectionSchema,
+	schema: StorageFieldsSchema,
 	entity: any,
-): string | void {
+): EntityValidationProblem | void {
 	for (const [key, value] of Object.entries(entity)) {
-		if (!schema.fields[key]) {
-			return `Invalid field "${key}"`;
+		if (!schema[key]) {
+			return {
+				type: 'invalid-key',
+				fieldPath: [key],
+				message: `Invalid field "${key}"`,
+			};
 		}
 		if (value) {
-			const err = validateEntityField(schema.fields[key], value);
+			const err = validateEntityField({
+				field: schema[key],
+				value,
+				fieldPath: [key],
+			});
 			if (err) return err;
 		}
 	}
 	return;
 }
 
-export function validateEntityField(
-	field: StorageFieldSchema,
-	value: any,
-	fieldPath: string[] = [],
-): string | void {
+export type EntityValidationProblem = {
+	type:
+		| 'null'
+		| 'no-default'
+		| 'invalid-type'
+		| 'invalid-value'
+		| 'invalid-key';
+	fieldPath: (string | number)[];
+	message: string;
+};
+
+export function validateEntityField({
+	field,
+	value,
+	fieldPath = [],
+	depth,
+	requireDefaults,
+}: {
+	field: StorageFieldSchema;
+	value: any;
+	fieldPath: (string | number)[];
+	depth?: number;
+	requireDefaults?: boolean;
+}): EntityValidationProblem | undefined {
+	if (depth !== undefined && depth <= 0) return;
+
+	if (isNullable(field) && value === null) return;
+	if (value === null) {
+		if (requireDefaults || !hasDefault(field)) {
+			return {
+				type: 'no-default',
+				fieldPath,
+				message: `Invalid null value for field ${formatField(fieldPath)}`,
+			};
+		}
+	}
+
 	if (field.type === 'object') {
 		if (!isObject(value)) {
-			if (value === null && field.nullable) return;
-			return `Expected object${
-				field.nullable ? ' or null' : ''
-			} for field ${formatField(fieldPath)}}`;
+			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)) {
 			if (value[key]) {
-				validateEntityField(subField, value[key]);
+				validateEntityField({
+					field: subField,
+					value: value[key],
+					fieldPath: [...fieldPath, key],
+					depth: depth !== undefined ? depth - 1 : undefined,
+				});
 			}
 		}
+		// check for unexpected keys
 		for (const key of Object.keys(value)) {
 			if (!field.properties[key]) {
-				return `Invalid field "${key}" on value ${formatField(fieldPath)}`;
+				return {
+					type: 'invalid-key',
+					fieldPath: [...fieldPath, key],
+					message: `Invalid unexpected field "${key}" on value ${formatField(
+						fieldPath,
+					)}`,
+				};
 			}
 		}
 	} else if (field.type === 'array') {
 		if (!Array.isArray(value)) {
 			if (value === null && field.nullable) return;
-			return `Expected array${
-				field.nullable ? ' or null' : ''
-			} for field ${formatField(fieldPath)}}`;
+			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.items, item);
+			validateEntityField({
+				field: field.items,
+				value: item,
+				fieldPath: [...fieldPath, '[]'],
+				depth: depth !== undefined ? depth - 1 : undefined,
+			});
 		}
 	} else if (field.type === 'map') {
 		if (!isObject(value)) {
-			return `Expected map for field ${formatField(fieldPath)}}`;
+			return {
+				type: 'invalid-type',
+				fieldPath,
+				message: `Expected map for field ${formatField(
+					fieldPath,
+				)}, got ${value}`,
+			};
 		}
 		for (const [key, item] of Object.entries(value)) {
-			// santiy check to weed out any id field
-			if (key === OID_KEY || key === LEGACY_OID_KEY) continue;
-			validateEntityField(field.values, item);
+			validateEntityField({
+				field: field.values,
+				value: item,
+				fieldPath: [...fieldPath, key],
+				depth: depth !== undefined ? depth - 1 : undefined,
+			});
 		}
 	} else if (field.type === 'string') {
 		if (typeof value !== 'string') {
-			if (value === null && field.nullable) return;
-			return `Expected string ${
-				field.nullable ? ' or null' : ''
-			} for field ${formatField(fieldPath)}}`;
+			return {
+				type: 'invalid-type',
+				fieldPath,
+				message: `Expected string ${
+					field.nullable ? ' or null' : ''
+				} for field ${formatField(fieldPath)}, got ${value}`,
+			};
 		}
 		if (field.options && !field.options.includes(value)) {
-			return `Expected one of ${field.options.join(
-				', ',
-			)} for field ${formatField(fieldPath)}`;
+			return {
+				type: 'invalid-value',
+				fieldPath,
+				message: `Expected one of ${field.options.join(
+					', ',
+				)} for field ${formatField(fieldPath)}, got ${value}`,
+			};
 		}
 	} else if (field.type === 'boolean') {
 		if (typeof value !== 'boolean') {
-			if (value === null && field.nullable) return;
-			return `Expected boolean ${
-				field.nullable ? ' or null' : ''
-			} for field ${formatField(fieldPath)}}`;
+			return {
+				type: 'invalid-type',
+				fieldPath,
+				message: `Expected boolean ${
+					field.nullable ? ' or null' : ''
+				} for field ${formatField(fieldPath)}, got ${value}`,
+			};
 		}
 	} else if (field.type === 'number') {
 		if (typeof value !== 'number') {
-			if (value === null && field.nullable) return;
-			return `Expected number ${
-				field.nullable ? ' or null' : ''
-			} for field ${formatField(fieldPath)}}`;
+			return {
+				type: 'invalid-type',
+				fieldPath,
+				message: `Expected number ${
+					field.nullable ? ' or null' : ''
+				} for field ${formatField(fieldPath)}, got ${value}`,
+			};
 		}
 	} else if (field.type === 'file') {
-		if (value === null && !field.nullable) {
-			return `Expected file for field ${formatField(fieldPath)}}`;
-		}
+		// TODO: how?
 	}
 }
 
-function formatField(fieldPath: string[]) {
+function formatField(fieldPath: (string | number)[]) {
+	if (fieldPath.length === 0) return 'root';
 	return fieldPath.join('.');
 }

package/src/timestamp.ts

@@ -84,9 +84,7 @@ export class HybridLogicalClockTimestampProvider implements TimestampProvider {
 			})
 		);
 	};
-	getWallClockTime = (timestamp: string): number => {
-		return deserializeHlcTimestamp(timestamp.slice(VERSION_BLOCK_LENGTH)).time;
-	};
+	getWallClockTime = getWallClockTime;
 }
 
 class ClockDriftError extends Error {
@@ -290,3 +288,7 @@ export function getTimestampSchemaVersion(timestamp: string): number {
 export function compareTimestampSchemaVersions(a: string, b: string) {
 	return getTimestampSchemaVersion(a) - getTimestampSchemaVersion(b);
 }
+
+export function getWallClockTime(timestamp: string): number {
+	return deserializeHlcTimestamp(timestamp.slice(VERSION_BLOCK_LENGTH)).time;
+}

package/src/undo.ts

@@ -8,7 +8,7 @@ export function getUndoOperations(
 	operations: Operation[],
 	getNow: () => string,
 ): Operation[] {
-	if (initial === undefined) {
+	if (initial === undefined || initial === null) {
 		// if the initial state is nothing, then the undo is to delete everything.
 		// there's nothing else to worry about!
 		return [
@@ -199,6 +199,8 @@ function getUndoOperation(
 					},
 				},
 			];
+		case 'touch':
+			return [];
 		default:
 			throw new Error(`Cannot undo operation type: ${(data as any).op}`);
 	}