@verdant-web/store 3.6.3 → 3.7.0

package/src/entities/types.ts

@@ -84,9 +84,14 @@ export interface ObjectEntity<
 	Snapshot = DataFromInit<Init>,
 > extends BaseEntity<Init, Value, Snapshot> {
 	keys(): string[];
+	readonly size: number;
 	entries(): [string, Exclude<Value[keyof Value], undefined>][];
 	values(): Exclude<Value[keyof Value], undefined>[];
-	set<Key extends keyof Init>(key: Key, value: Init[Key]): void;
+	set<Key extends keyof Init>(
+		key: Key,
+		value: Init[Key],
+		options?: { force?: boolean },
+	): void;
 	delete(key: DeletableKeys<Value>): void;
 	update(
 		value: DeepPartial<Init>,
@@ -114,6 +119,16 @@ export interface ObjectEntity<
 			merge?: boolean;
 		},
 	): void;
+	/**
+	 * Deletes the entity from either its parent (if it's a nested value)
+	 * or the database itself. WARNING: this method is tricky. It will
+	 * throw an error on nested fields which are not deletable in the
+	 * schema. Deleting any entity and then attempting to access its
+	 * data will also result in an error.
+	 *
+	 * Prefer using client.<collection>.delete(id) instead.
+	 */
+	deleteSelf(): void;
 	readonly isList: false;
 }
 
@@ -125,6 +140,11 @@ export interface ListEntity<
 		BaseEntity<Init, Value, Snapshot> {
 	readonly isList: true;
 	readonly length: number;
+	set(
+		index: number,
+		value: ListItemInit<Init>,
+		options?: { force?: boolean },
+	): void;
 	push(value: ListItemInit<Init>): void;
 	insert(index: number, value: ListItemInit<Init>): void;
 	move(from: number, to: number): void;
@@ -138,6 +158,14 @@ export interface ListEntity<
 	removeFirst(item: ListItemValue<Value>): void;
 	removeLast(item: ListItemValue<Value>): void;
 	map<U>(callback: (value: ListItemValue<Value>, index: number) => U): U[];
+	reduce<U>(
+		callback: (
+			accumulator: U,
+			currentValue: ListItemValue<Value>,
+			index: number,
+		) => U,
+		initialValue: U,
+	): U;
 	filter(
 		callback: (value: ListItemValue<Value>, index: number) => boolean,
 	): ListItemValue<Value>[];

package/src/metadata/Metadata.ts

@@ -60,12 +60,16 @@ export class Metadata extends EventSubscriber<{
 
 	private context: Omit<Context, 'documentDb' | 'getNow'>;
 
+	private onOperation?: (operation: Operation) => void;
+
 	constructor({
 		disableRebasing,
 		context,
+		onOperation,
 	}: {
 		disableRebasing?: boolean;
 		context: Omit<Context, 'documentDb' | 'getNow'>;
+		onOperation?: (operation: Operation) => void;
 	}) {
 		super();
 		this.context = context;
@@ -76,6 +80,7 @@ export class Metadata extends EventSubscriber<{
 		this.ackInfo = new AckInfoStore(this.db);
 		this.messageCreator = new MessageCreator(this);
 		this.patchCreator = new PatchCreator(() => this.now);
+		this.onOperation = onOperation;
 		if (disableRebasing) this.disableRebasing = disableRebasing;
 	}
 
@@ -312,6 +317,10 @@ export class Metadata extends EventSubscriber<{
 
 		// we can now enqueue and check for rebase opportunities
 		this.tryAutonomousRebase();
+
+		if (this.onOperation) {
+			operations.forEach((o) => this.onOperation!(o));
+		}
 	};
 
 	/**
@@ -340,6 +349,10 @@ export class Metadata extends EventSubscriber<{
 
 		this.ack(operations[operations.length - 1].timestamp);
 
+		if (this.onOperation) {
+			operations.forEach((o) => this.onOperation!(o));
+		}
+
 		return affectedDocumentOids;
 	};
 

package/src/queries/BaseQuery.ts

@@ -42,6 +42,7 @@ export abstract class BaseQuery<T> extends Disposable {
 
 	readonly collection;
 	readonly key;
+	readonly isListQuery;
 
 	constructor({
 		initial,
@@ -53,6 +54,7 @@ export abstract class BaseQuery<T> extends Disposable {
 		super();
 		this._rawValue = initial;
 		this._value = initial;
+		this.isListQuery = Array.isArray(initial);
 		this._events = new EventSubscriber<BaseQueryEvents>(
 			(event: keyof BaseQueryEvents) => {
 				if (event === 'change') this._allUnsubscribedHandler?.(this);
@@ -98,6 +100,19 @@ export abstract class BaseQuery<T> extends Disposable {
 		return this._status;
 	}
 
+	private set status(v: QueryStatus) {
+		if (this._status === v) return;
+		this._status = v;
+		this._events.emit('statusChange', this._status);
+	}
+
+	get hasDeleted() {
+		if (this.isListQuery) {
+			return (this._rawValue as any[]).length !== (this._value as any[]).length;
+		}
+		return !!this._rawValue && !this._value;
+	}
+
 	/**
 	 * Subscribe to changes in the query value.
 	 *
@@ -138,16 +153,38 @@ export abstract class BaseQuery<T> extends Disposable {
 	protected setValue = (value: T) => {
 		this._rawValue = value;
 		this.subscribeToDeleteAndRestore(this._rawValue);
-		this._value = filterResultSet(value);
-		// validate the value
-		if (
-			Array.isArray(this._value) &&
-			this._value.some((v) => v.getSnapshot() === null)
-		) {
-			debugger;
+		const filtered = filterResultSet(value);
+
+		// prevent excess change notifications by diffing
+		// value by identity for single-value queries,
+		// and by item identity for multi-value
+		let changed = true;
+		// always fire change when going from initial to ready
+		if (this.status === 'initializing' || this.status === 'initial') {
+			changed = true;
+		} else {
+			// compare values by identity, after filtering.
+			if (this.isListQuery) {
+				if (
+					(this._value as any[]).length === (filtered as any[]).length &&
+					(this._value as any[]).every((v, i) => v === (filtered as any[])[i])
+				) {
+					changed = false;
+				}
+			} else {
+				if (this._value === filtered) {
+					changed = false;
+				}
+			}
+		}
+
+		this._value = filtered;
+
+		if (changed) {
+			this.context.log('debug', 'Query value changed', this.key);
+			this._events.emit('change', this._value);
 		}
-		this._status = 'ready';
-		this._events.emit('change', this._value);
+		this.status = 'ready';
 	};
 
 	// re-applies filtering if results have changed
@@ -186,10 +223,10 @@ export abstract class BaseQuery<T> extends Disposable {
 	execute = () => {
 		this.context.log('debug', 'Executing query', this.key);
 
-		if (this._status === 'initial') {
-			this._status = 'initializing';
-		} else if (this._status === 'ready') {
-			this._status = 'revalidating';
+		if (this.status === 'initial') {
+			this.status = 'initializing';
+		} else if (this.status === 'ready') {
+			this.status = 'revalidating';
 		}
 		// no status change needed if already in a 'running' status.
 

package/src/sync/Sync.ts

@@ -173,6 +173,11 @@ export interface ServerSyncOptions<Profile = any, Presence = any>
 	 * but is not yet thoroughly vetted.
 	 */
 	useBroadcastChannel?: boolean;
+	/**
+	 * Listen for outgoing messages from the client to the server.
+	 * Not sure why you want to do this, but be careful.
+	 */
+	onOutgoingMessage?: (message: ClientMessage) => void;
 }
 
 export class ServerSync<Presence = any, Profile = any>
@@ -196,6 +201,8 @@ export class ServerSync<Presence = any, Profile = any>
 
 	readonly presence: PresenceManager<Profile, Presence>;
 
+	private onOutgoingMessage?: (message: ClientMessage) => void;
+
 	private log;
 
 	constructor(
@@ -211,6 +218,7 @@ export class ServerSync<Presence = any, Profile = any>
 			presenceUpdateBatchTimeout,
 			defaultProfile,
 			useBroadcastChannel,
+			onOutgoingMessage,
 		}: ServerSyncOptions<Profile, Presence>,
 		{
 			meta,
@@ -230,6 +238,7 @@ export class ServerSync<Presence = any, Profile = any>
 		this.meta = meta;
 		this.onData = onData;
 		this.log = ctx.log;
+		this.onOutgoingMessage = onOutgoingMessage;
 		this.presence = new PresenceManager({
 			initialPresence,
 			defaultProfile,
@@ -444,9 +453,10 @@ export class ServerSync<Presence = any, Profile = any>
 		return this.pushPullSync.interval;
 	}
 
-	send = (message: ClientMessage) => {
+	send = async (message: ClientMessage) => {
 		if (this.activeSync.status === 'active') {
-			return this.activeSync.send(message);
+			await this.activeSync.send(message);
+			this.onOutgoingMessage?.(message);
 		}
 	};