@verdant-web/store 4.3.0 → 4.4.1

package/src/entities/EntityCache.ts

@@ -1,24 +1,25 @@
-import { Entity, EntityInit } from './Entity.js';
-import { EntityFile } from '../files/EntityFile.js';
 import { ObjectIdentifier } from '@verdant-web/common';
+import { Context } from '../internal.js';
+import { Entity, EntityInit } from './Entity.js';
 
 export class EntityCache {
-	private cache = new Map<string, Entity | EntityFile>();
+	private ctx: Context;
+	private cache = new Map<string, WeakRef<Entity>>();
 
-	constructor({ initial }: { initial?: Entity[] } = {}) {
+	constructor({ initial, ctx }: { initial?: Entity[]; ctx: Context }) {
+		this.ctx = ctx;
 		if (initial) {
 			for (const entity of initial) {
-				this.cache.set(entity.oid, entity);
+				this.cache.set(entity.oid, ctx.weakRef(entity));
 			}
 		}
 	}
 
 	get = (init: EntityInit): Entity => {
-		if (this.cache.has(init.oid)) {
-			return this.cache.get(init.oid)! as Entity;
-		}
+		const cached = this.getCached(init.oid);
+		if (cached) return cached;
 		const entity = new Entity(init);
-		this.cache.set(init.oid, entity);
+		this.cache.set(init.oid, this.ctx.weakRef(entity));
 		return entity;
 	};
 
@@ -27,6 +28,15 @@ export class EntityCache {
 	};
 
 	getCached = (oid: string) => {
-		return this.cache.get(oid);
+		if (this.cache.has(oid)) {
+			const ref = this.cache.get(oid);
+			const derefed = ref?.deref();
+			if (derefed) {
+				return derefed as Entity;
+			} else {
+				this.cache.delete(oid);
+			}
+		}
+		return null;
 	};
 }

package/src/entities/EntityMetadata.ts

@@ -29,6 +29,14 @@ export class EntityMetadata {
 	private baseline: DocumentBaseline | null = null;
 	// these must be kept in timestamp order.
 	private confirmedOperations: Operation[] = [];
+	// operations applied locally, but not sent to persistence
+	// until 'committed' by pending operations. this powers the
+	// self-healing pruning system, which injects these ephemeral
+	// operations to materialize pruned 'fixed' data in place of
+	// 'real' invalid data so the user can keep using the app. as
+	// soon as the user makes modifications to the entity, this
+	// ephemeral pruned data is applied underneath it.
+	private ephemeralOperations?: Operation[] = [];
 	private pendingOperations: Operation[] = [];
 	readonly oid;
 
@@ -90,15 +98,26 @@ export class EntityMetadata {
 			authz = confirmedResult.authz;
 		}
 
+		const ephemeralResult =
+			!this.ephemeralOperations || omitPending
+				? confirmedResult
+				: this.applyOperations(
+						confirmedResult.view,
+						confirmedResult.deleted,
+						this.ephemeralOperations,
+						confirmedResult.latestTimestamp,
+						null,
+					);
+
 		const pendingResult = omitPending
 			? confirmedResult
 			: this.applyOperations(
-					confirmedResult.view,
-					confirmedResult.deleted,
+					ephemeralResult.view,
+					ephemeralResult.deleted,
 					// now we're applying pending operations
 					this.pendingOperations,
 					// keep our latest timestamp up to date
-					confirmedResult.latestTimestamp,
+					ephemeralResult.latestTimestamp,
 					// we don't use after for pending ops, they're all
 					// logically in the future
 					null,
@@ -200,11 +219,22 @@ export class EntityMetadata {
 	};
 
 	addPendingOperation = (operation: Operation) => {
-		// check to see if new operation supersedes the previous one
-		// we can assume pending ops are always newer
 		this.pendingOperations.push(operation);
 	};
 
+	addEphemeralOperation = (operation: Operation) => {
+		if (!this.ephemeralOperations) {
+			this.ephemeralOperations = [];
+		}
+		this.ephemeralOperations.push(operation);
+	};
+
+	clearEphemeralOperations = () => {
+		const old = this.ephemeralOperations;
+		this.ephemeralOperations = [];
+		return old;
+	};
+
 	discardPendingOperation = (operation: Operation) => {
 		this.pendingOperations = this.pendingOperations.filter(
 			(op) => op.timestamp !== operation.timestamp,
@@ -346,6 +376,10 @@ export class EntityFamilyMetadata {
 	 * local changes are usually handled, as a list.
 	 */
 	addPendingData = (operations: Operation[]) => {
+		// when pending data is applied, we go ahead and
+		// write all ephemeral changes first.
+		this.flushAllEphemeral();
+
 		const changes: Record<ObjectIdentifier, EntityChange> = {};
 		for (const op of operations) {
 			this.get(op.oid).addPendingOperation(op);
@@ -355,6 +389,31 @@ export class EntityFamilyMetadata {
 		return Object.values(changes);
 	};
 
+	private ephemeralMemo = new Array<Operation>();
+	private flushAllEphemeral = () => {
+		for (const ent of this.entities.values()) {
+			const ops = ent.clearEphemeralOperations();
+			if (ops) {
+				this.ephemeralMemo.push(...ops);
+			}
+		}
+		if (this.ephemeralMemo.length) {
+			const ephemeralCopy = this.ephemeralMemo.slice();
+			// must clear this first to avoid infinite recursion
+			this.ephemeralMemo.length = 0;
+			this.addPendingData(ephemeralCopy);
+		}
+	};
+
+	addEphemeralData = (operations: Operation[]) => {
+		const changes: Record<ObjectIdentifier, EntityChange> = {};
+		for (const op of operations) {
+			this.get(op.oid).addEphemeralOperation(op);
+			changes[op.oid] ??= { oid: op.oid, isLocal: true };
+		}
+		return Object.values(changes);
+	};
+
 	replaceAllData = ({
 		operations = {},
 		baselines = [],

package/src/entities/EntityStore.ts

@@ -1,6 +1,7 @@
 import {
 	AuthorizationKey,
 	DocumentBaseline,
+	FileData,
 	ObjectIdentifier,
 	Operation,
 	StorageObjectFieldSchema,
@@ -335,7 +336,8 @@ export class EntityStore extends Disposable {
 		// remove any OID associations from the initial data
 		removeOidsFromAllSubObjects(initial);
 		// grab files and replace them with refs
-		const processed = processValueFiles(initial, this.files.add);
+		const fileRefs: FileData[] = [];
+		const processed = processValueFiles(initial, fileRefs.push.bind(fileRefs));
 
 		assignOid(processed, oid);
 
@@ -346,6 +348,8 @@ export class EntityStore extends Disposable {
 				`Could not put new document: no schema exists for collection ${collection}`,
 			);
 		}
+		// add files with entity as parent
+		fileRefs.forEach((file) => this.files.add(file, entity));
 
 		const operations = this.ctx.patchCreator.createInitialize(
 			processed,

package/src/files/EntityFile.ts

@@ -1,5 +1,6 @@
 import { EventSubscriber, FileData } from '@verdant-web/common';
 import { Context } from '../context/context.js';
+import { Entity } from '../entities/Entity.js';
 
 export type EntityFileEvents = {
 	change: () => void;
@@ -8,6 +9,9 @@ export type EntityFileEvents = {
 export const UPDATE = Symbol('entity-file-update');
 export const MARK_FAILED = Symbol('entity-file-mark-failed');
 
+// this one goes on Entity
+export const CHILD_FILE_CHANGED = Symbol('child-file-changed');
+
 export type EntityFileSnapshot = {
 	id: string;
 	url?: string | null;
@@ -27,19 +31,23 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 	private _uploaded = false;
 	private ctx: Context;
 	private unsubscribes: (() => void)[] = [];
+	private parent: Entity;
 
 	constructor(
 		public readonly id: string,
 		{
 			downloadRemote = false,
 			ctx,
+			parent,
 		}: {
 			downloadRemote?: boolean;
 			ctx: Context;
+			parent: Entity;
 		},
 	) {
 		super();
 		this.ctx = ctx;
+		this.parent = parent;
 		this._downloadRemote = downloadRemote;
 
 		this.unsubscribes.push(
@@ -57,6 +65,11 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 		return this._uploaded || this._fileData?.remote || false;
 	}
 
+	private emitChange() {
+		this.parent[CHILD_FILE_CHANGED](this);
+		this.emit('change');
+	}
+
 	[UPDATE] = (fileData: FileData) => {
 		this.ctx.log('debug', 'EntityFile updated', this.id, fileData);
 		this._loading = false;
@@ -69,13 +82,13 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 			this.ctx.log('debug', 'Creating object URL for file', this.id);
 			this._objectUrl = URL.createObjectURL(fileData.file);
 		}
-		this.emit('change');
+		this.emitChange();
 	};
 
 	[MARK_FAILED] = () => {
 		this._failed = true;
 		this._loading = false;
-		this.emit('change');
+		this.emitChange();
 	};
 
 	private onUploaded = (data: FileData) => {
@@ -83,7 +96,7 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 		this._fileData ??= data;
 		this._uploaded = true;
 		this.ctx.log('debug', 'File marked uploaded', this.id, this._fileData);
-		this.emit('change');
+		this.emitChange();
 	};
 
 	get url(): string | null {

package/src/files/FileManager.ts

@@ -1,5 +1,6 @@
 import { FileData } from '@verdant-web/common';
 import { Context } from '../context/context.js';
+import { Entity } from '../entities/Entity.js';
 import { Disposable } from '../internal.js';
 import { Sync } from '../sync/Sync.js';
 import { EntityFile, MARK_FAILED, UPDATE } from './EntityFile.js';
@@ -22,11 +23,11 @@ export class FileManager extends Disposable {
 		);
 	}
 
-	add = async (file: FileData) => {
+	add = async (file: FileData, parent: Entity) => {
 		// immediately cache the file
 		let entityFile = this.cache.get(file.id);
 		if (!entityFile) {
-			entityFile = new EntityFile(file.id, { ctx: this.context });
+			entityFile = new EntityFile(file.id, { ctx: this.context, parent });
 			this.cache.set(file.id, entityFile);
 		}
 
@@ -44,7 +45,10 @@ export class FileManager extends Disposable {
 	 * Immediately returns an EntityFile to use, then either loads
 	 * the file from cache, local database, or the server.
 	 */
-	get = (id: string, options: { downloadRemote?: boolean; ctx: Context }) => {
+	get = (
+		id: string,
+		options: { downloadRemote?: boolean; ctx: Context; parent: Entity },
+	) => {
 		if (this.cache.has(id)) {
 			return this.cache.get(id)!;
 		}

package/src/utils/versions.ts

@@ -17,7 +17,7 @@ export function getLatestVersion(data: {
 			return tsVersion;
 		}
 		return v;
-	}, 0);
+	}, 1);
 
 	return latestVersion;
 }