@iebh/tera-fy 2.0.1 → 2.0.2

package/lib/syncro.js

@@ -1,6 +1,8 @@
 import {
 	isEmpty,
 	cloneDeep,
+	random,
+	sample,
 	throttle,
 } from 'lodash-es';
 import {
@@ -11,6 +13,7 @@ import {
 	updateDoc as FirestoreUpdateDoc,
 } from 'firebase/firestore';
 import marshal from '@momsfriendlydevco/marshal';
+import {nanoid} from 'nanoid';
 
 
 /**
@@ -114,7 +117,7 @@ export default class Syncro {
 		Object.assign(this, options);
 
 		if (!Syncro.session) // Assign a random session ID if we don't already have one
-			Syncro.session = `syncro_${crypto.randomUUID()}`;
+			Syncro.session = `syncro_${nanoid()}`;
 	}
 
 
@@ -221,6 +224,7 @@ export default class Syncro {
 	*/
 	static toFirestore(snapshot = {}) {
 		return marshal.serialize(snapshot, {
+			circular: false,
 			clone: true, // Clone away from the original Vue Reactive so we dont mangle it while traversing
 			modules: [
 				marshalFlattenArrays,
@@ -242,6 +246,7 @@ export default class Syncro {
 	*/
 	static fromFirestore(snapshot = {}) {
 		return marshal.deserialize(snapshot, {
+			circular: false,
 			clone: true, // Clone away from original so we don't trigger a loop within Firebase
 			modules: [
 				marshalFlattenArrays,
@@ -419,9 +424,8 @@ export default class Syncro {
 					.then(()=> syncEntities[entity] || Promise.reject(`Unknown Sync entity "${entity}"`))
 					.then(()=> syncEntities[entity].initState({
 						supabase: Syncro.supabase,
-						entity,
-						id,
-						relation,
+						fsCollection, fsId,
+						entity, id, relation,
 					}))
 					.then(state => FirestoreSetDoc(
 						this.docRef,
@@ -437,7 +441,9 @@ export default class Syncro {
 					);
 				}, this.throttle));
 			})
-			.then(()=> this.setHeartbeat(true))
+			.then(()=> this.setHeartbeat(true, {
+				immediate: true,
+			}))
 			.then(()=> this)
 	}
 
@@ -447,27 +453,82 @@ export default class Syncro {
 	* This populates the `sync` presence meta-information
 	*
 	* @param {Boolean} [enable=true] Whether to enable heartbeating
+	*
+	* @param {Object} [options] Additional options to mutate behaviour
+	* @param {Boolean} [options.immediate=false] Fire a heartbeat as soon as this function is called, this is only really useful on mount
 	*/
-	setHeartbeat(enable = true) {
+	setHeartbeat(enable = true, options) {
+		let settings = {
+			immediate: true,
+			...options,
+		};
+
+		// Clear existing heartbeat timer, if there is one
 		clearTimeout(this._heartbeatTimer);
 
-		this._heartbeatTimer = enable && setTimeout(async ()=> {
-			this.debug('heartbeat!');
-			let timestamp = (new Date()).toISOString();
-			await FirestoreSetDoc(
-				FirestoreDocRef(Syncro.firestore, 'presence', this.path),
-				{
-					latest: timestamp,
-					sessions: {
-						[this.session]: timestamp,
-					},
+		if (enable) {
+			this._heartbeatTimer = setTimeout(async ()=> {
+				// Perform the heartbeat
+				await this.heartbeat();
+
+				// If we're enabled - schedule the next heartbeat timer
+				enable && this.setHeartbeat(true);
+			}, this.heartbeatInterval);
+
+			if (settings.immediate) this.heartbeat();
+		}
+	}
+
+
+	/**
+	* Perform one heartbeat pulse to the server to indicate presense within this Syncro
+	* This function is automatically called by a timer if `setHeartbeat(true)` (the default behaviour)
+	*
+	* @returns {Promise} A promise which resolves when the operation has completed
+	*/
+	async heartbeat() {
+		this.debug('heartbeat!');
+		let timestamp = (new Date()).toISOString();
+
+		let docRef = FirestoreDocRef(Syncro.firestore, 'presence', this.path);
+		let doc = await FirestoreGetDoc(docRef);
+
+		await FirestoreSetDoc(
+			docRef,
+			{
+				latest: timestamp,
+				...(!doc.exists() && { // New doc - populate some base fields
+					created: timestamp,
+					lastFlush: null,
+				}),
+				sessions: {
+					[Syncro.session]: timestamp,
 				},
-				{merge: true},
-			);
+			},
+			{merge: true},
+		);
+	}
+
 
-			// If we're enabled - set the next heartbeat timer
-			this.setHeartbeat(true);
-		}, this.heartbeatInterval);
+	/**
+	* Force the server to flush state
+	* This is only really useful for debugging as this happens automatically anyway
+	*
+	* @param {Object} [options] Additional options to mutate behaviour
+	* @param {Boolean} [options.destroy=false] Instruct the server to also dispose of the Syncro state
+	*
+	* @returns {Promise} A promise which resolves when the operation has completed
+	*/
+	flush(options) {
+		let settings = {
+			destroy: false,
+			...options,
+		};
+
+		return fetch(`https://tera-tools.com/api/sync/${this.path}/flush` + (settings.destroy ? '?destroy=1' : ''), {
+			method: 'post',
+		})
+			.then(response => response.ok ? null : Promise.reject(response.statusText || 'An error occured'))
 	}
 
 
@@ -480,6 +541,39 @@ export default class Syncro {
 }
 
 
+/**
+* Build a chaotic random tree structure based on dice rolls
+* This funciton is mainly used for sync testing
+*
+* @param {Number} [depth=0] The current depth we are starting at, changes the nature of branches based on probability
+*
+* @returns {*} The current branch conotents
+*/
+export function randomBranch(depth = 0) {
+	let dice = // Roll a dice to pick the content
+		depth == 0 ? 10 // first roll is always '10'
+		: random(0, 11 - depth, false); // Subsequent rolls bias downwards based on depth (to avoid recursion)
+
+	return (
+		dice == 0 ? false
+		: dice == 1 ? true
+		: dice == 2 ? random(1, 10_000)
+		: dice == 3 ? (new Date(random(1_000_000_000_000, 1_777_777_777_777))).toISOString()
+		: dice == 5 ? Array.from({length: random(1, 10)}, ()=> random(1, 10))
+		: dice == 6 ? null
+		: dice < 8 ? Array.from({length: random(1, 10)}, ()=> randomBranch(depth+1))
+		: Object.fromEntries(
+			Array.from({length: random(1, 5)})
+				.map((v, k) => [
+					sample(['foo', 'bar', 'baz', 'quz', 'flarp', 'corge', 'grault', 'garply', 'waldo', 'fred', 'plugh', 'thud'])
+					+ `_${k}`,
+					randomBranch(depth+1),
+				])
+		)
+	)
+}
+
+
 /**
 * Entities we support syncro paths on, each needs to correspond with a Firebase/Firestore collection name
 *
@@ -519,12 +613,25 @@ export const syncEntities = {
 				.eq('project', id)
 				.eq('name', relation)
 			)
-				.then(rows => rows.length == 1 ? rows[0] : Promise.reject(`Syncro project ("${id}") namespace ("${relation}") not found`))
+				.then(rows => rows.length == 1
+					? rows[0]
+					: Syncro.wrapSupabase(supabase.from('project_namespaces') // Doesn't exist - create it
+						.insert({
+							project: id,
+							name: relation,
+							data: {},
+						})
+						.select('data')
+					)
+				)
 				.then(item => item.data);
 		},
 		flushState({supabase, state, id, relation}) {
 			return Syncro.wrapSupabase(supabase.from('project_namespaces')
-				.update(state)
+				.update({
+					edited_at: new Date(),
+					data: state,
+				})
 				.eq('project', id)
 				.eq('name', relation)
 			)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iebh/tera-fy",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "TERA website worker",
   "scripts": {
     "dev": "esbuild --platform=browser --format=esm --bundle lib/terafy.client.js --outfile=dist/terafy.js --minify --serve --servedir=.",
@@ -80,7 +80,7 @@
     "just-diff": "^6.0.2",
     "lodash-es": "^4.17.21",
     "mitt": "^3.0.1",
-    "nanoid": "^5.0.7",
+    "nanoid": "^5.1.0",
     "release-it": "^17.6.0"
   },
   "devDependencies": {