@iebh/tera-fy 2.3.8 → 2.3.10

package/lib/syncro/entities.ts

@@ -1,21 +1,29 @@
-/* eslint-disable no-unused-vars */
+/* eslint-disable jsdoc/reject-function-type, no-unused-vars */
 // @ts-expect-error TODO: Remove when reflib gets declaration file
 import Reflib from '@iebh/reflib';
 import {v4 as uuid4} from 'uuid';
 import {nanoid} from 'nanoid';
-import { BoundSupabaseyFunction } from '@iebh/supabasey';
+import {BoundSupabaseyFunction} from '@iebh/supabasey';
+
+
+// Minimal interface for a postgres-npm Sql instance (HYPERDRIVE is injected by the Cloudflare Worker runtime)
+export interface PostgresSql {
+	(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>;
+	json(value: any): any;
+}
+
 
 // DATABASE TABLE TYPE DEFINITIONS {{{
 interface ProjectRow {
-  data: {
-		temp?: { [key: string]: any };
+	data: {
+		id: string;
 		// TODO: add other properties in project data
 	};
 	// TODO: Define other columns in project table
 }
 
 interface InstituteRow {
-  data: any;
+	data: any;
 }
 
 interface UserRow {
@@ -36,71 +44,81 @@ interface NamespaceRow {
 		[key: string]: any;
 		// TODO: add other properties in namespace data
 	};
-	// TODO: Define other namespace in user table
+	// TODO: Define other columns in namespace table
 }
 // }}}
 
-// Interface for each syncroconfic
+
+// Interface for each syncro entity config
 interface SyncroEntityConfig {
 	singular: string;
 	initState: (args: {
-			supabasey: BoundSupabaseyFunction;
-			id: string; // Primary ID for the entity
-			relation?: string; // Optional relation identifier (for namespaces, libraries)
+		HYPERDRIVE: PostgresSql;
+		supabasey: BoundSupabaseyFunction;
+		id: string; // Primary ID for the entity
+		relation?: string; // Optional relation identifier (for namespaces, libraries)
 	}) => Promise<any>;
-
 	flushState: (args: {
-			supabasey: BoundSupabaseyFunction;
-			state: any; // The state object to flush
-			id?: string; // Primary ID (used in some lookups like namespaces)
-			fsId?: string; // ID often passed to Supabase RPCs (might be same as 'id')
-			relation?: string; // Optional relation identifier
+		HYPERDRIVE: PostgresSql;
+		supabasey?: BoundSupabaseyFunction;
+		state: any; // The state object to flush
+		id?: string; // Primary ID (used in some lookups like namespaces)
+		fsId?: string; // ID often passed to Supabase RPCs (might be same as 'id')
+		relation?: string; // Optional relation identifier
 	}) => Promise<any>; // Return type signifies completion/result of flush
 }
 
+
 type SyncroConfig = Record<string, SyncroEntityConfig>;
 
+
 /**
 * Entities we support Syncro paths for, each should correspond directly with a Firebase/Firestore collection name
 *
 * @type {Object} An object lookup of entities
 *
 * @property {String} singular The singular noun for the item
-* @property {Function} initState Function called to initialize state when Firestore has no existing document. Called as `({supabase:BoundSupabaseyFunction, db:BoundHyperdriveInstance, entity:String, id:String, relation?:string})` and expected to return the initial data object state
-* @property {Function} flushState Function called to flush state from Firebase to Supabase. Called the same as `initState` + `{state:Object}`
+* @property {Function} initState Function called to initialize state when Firestore has no existing document. Called as `({HYPERDRIVE:PostgresSql, supabasey:BoundSupabaseyFunction, id:String, relation?:string})` and expected to return the initial data object state
+* @property {Function} flushState Function called to flush state from Firebase to Postgres. Called the same as `initState` + `{state:Object}`
 */
 const syncroConfig: SyncroConfig = {
 	institutes: { // {{{
 		singular: 'institute',
-		async initState({supabasey, id}: {supabasey: BoundSupabaseyFunction, id: string}) {
-			const institute = await supabasey((supabase) => supabase
-				.from('institutes')
-				.select('data')
-				.eq('id', id)
-				.maybeSingle<InstituteRow>()
-			);
-			if (institute) return institute.data; // institute is valid and already exists
+		async initState({HYPERDRIVE, id}: {HYPERDRIVE: PostgresSql, id: string}) {
+			let rows = await HYPERDRIVE`
+				SELECT data
+				FROM institutes
+				WHERE id = ${id}
+				LIMIT 1
+			`;
+			if (rows.length > 0) {
+				return rows[0].data; // institute is valid and already exists
+			} else {
+				throw new Error(`Syncro institute "${id}" not found`);
+			}
 		},
-		flushState({supabasey, state, id}) {
-			// @ts-expect-error Typescript struggles to resolve supabasey import correctly
-			return supabasey.rpc('syncro_merge_data', {
-				table_name: 'institutes',
-				entity_id: id,
-				new_data: state,
-			});
+		flushState({HYPERDRIVE, state, id}) {
+			return HYPERDRIVE`
+				SELECT syncro_merge_data(
+					table_name => 'institutes',
+					entity_id => ${id}::UUID,
+					new_data => ${HYPERDRIVE.json(state)}::JSONB
+				)
+			`;
 		},
 	}, // }}}
 	projects: { // {{{
 		singular: 'project',
-		async initState({supabasey, id}) {
-			const projectData = await supabasey((supabase) => supabase
-				.from('projects')
-				.select('data')
-				.eq('id', id)
-				.maybeSingle<ProjectRow>()
-			);
-			if (!projectData) throw new Error(`Syncro project "${id}" not found`);
-			const data = projectData.data;
+		async initState({HYPERDRIVE, supabasey, id}: {HYPERDRIVE: PostgresSql, supabasey: BoundSupabaseyFunction, id: string}) {
+			let rows = await HYPERDRIVE`
+				SELECT data
+				FROM projects
+				WHERE id = ${id}
+				LIMIT 1
+			`;
+			if (rows.length == 0) throw new Error(`Syncro project "${id}" not found`);
+
+			const data = rows[0].data;
 
 			// MIGRATION - Move data.temp{} into Supabase files + add pointer to filename {{{
 			if (
@@ -113,7 +131,7 @@ const syncroConfig: SyncroConfig = {
 				await Promise.all(
 					Object.entries(data.temp)
 						.filter(([, branch]) => typeof branch == 'object')
-						.map(([toolKey, ]) => {
+						.map(([toolKey]) => {
 							console.log(`[MIGRATION] Converting data.temp[${toolKey}]...`);
 
 							const toolName = toolKey.split('-')[0];
@@ -160,18 +178,19 @@ const syncroConfig: SyncroConfig = {
 
 			return data;
 		},
-		flushState({supabasey, state, fsId}) {
-			// Import Supabasey because 'supabasey' lowercase is just a function
-			return supabasey(supabase => supabase.rpc('syncro_merge_data', {
-				table_name: 'projects',
-				entity_id: fsId,
-				new_data: state,
-			}));
+		flushState({HYPERDRIVE, state, fsId}) {
+			return HYPERDRIVE`
+				SELECT syncro_merge_data(
+					table_name => 'projects',
+					entity_id => ${fsId}::UUID,
+					new_data => ${HYPERDRIVE.json(state)}::JSONB
+				)
+			`;
 		},
 	}, // }}}
 	project_libraries: { // {{{
 		singular: 'project library',
-		async initState({supabasey, id, relation}) {
+		async initState({id, relation, supabasey}: {HYPERDRIVE: PostgresSql, id: string, relation?: string, supabasey: BoundSupabaseyFunction}) {
 			if (!relation || !/_\*$/.test(relation)) throw new Error('Project library relation missing, path should resemble "project_library::${PROJECT}::${LIBRARY_FILE_ID}_*"');
 
 			const fileId = relation.replace(/_\*$/, '');
@@ -209,103 +228,79 @@ const syncroConfig: SyncroConfig = {
 			throw new Error('Flushing project_libraries::* namespace is not yet supported');
 		},
 	}, // }}}
-	project_namespaces: { // {{{
+	project_namespaces: { // NOT YET SUPPORTED {{{
 		singular: 'project namespace',
-		async initState({supabasey, id, relation}) {
-			if (!relation) throw new Error('Project namespace relation missing, path should resemble "project_namespaces::${PROJECT}::${RELATION}"');
-			const rows = await supabasey((supabase) => supabase
-				.from('project_namespaces')
-				.select('data')
-				.eq('project', id)
-				.eq('name', relation)
-				.limit(1)
-			);
-
-			if (rows && rows.length == 1) {
-				return rows[0].data;
-			} else {
-				const newItem = await supabasey((supabase) => supabase
-					.from('project_namespaces') // Doesn't exist - create it
-					.insert<NamespaceRow>({
-						project: id,
-						name: relation,
-						data: {},
-					})
-					.select('data')
-					.single<NamespaceRow>() // Assuming insert returns the single inserted row
-				);
-
-				if (!newItem) throw new Error('Failed to create project namespace');
-				return newItem.data;
-			}
+		async initState() {
+			throw new Error('Updating project_namespaces is not yet supported');
 		},
-		flushState({supabasey, state, id, relation}) {
-			return supabasey((supabase) => supabase
-				.from('project_namespaces')
-				.update({
-					edited_at: new Date().toISOString(),
-					data: state,
-				})
-				.eq('project', id)
-				.eq('name', relation)
-			);
+		async flushState() {
+			throw new Error('Updating project_namespaces is not yet supported');
 		},
 	}, // }}}
 	test: { // {{{
 		singular: 'test',
-		async initState({supabasey, id}: {supabasey: BoundSupabaseyFunction, id: string}) {
-			const rows = await supabasey((supabase) => supabase
-				.from('test')
-				.select('data')
-				.eq('id', id)
-				.limit(1)
-			);
-
-			if (!rows || rows.length !== 1) return Promise.reject(`Syncro test item "${id}" not found`);
-			return rows[0].data;
+		async initState({HYPERDRIVE, id}: {HYPERDRIVE: PostgresSql, id: string}) {
+			let rows = await HYPERDRIVE`
+				SELECT data
+				FROM test
+				WHERE id = ${id}
+				LIMIT 1
+			`;
+			if (rows.length > 0) {
+				return rows[0].data; // User is valid and already exists
+			} else {
+				throw new Error(`Syncro test "${id}" not found`);
+			}
 		},
-		flushState({supabasey, state, fsId}) {
-			return supabasey(supabase => supabase.rpc('syncro_merge_data', {
-				table_name: 'test',
-				entity_id: fsId,
-				new_data: state,
-			}));
+		flushState({HYPERDRIVE, state, fsId}) {
+			return HYPERDRIVE`
+				SELECT syncro_merge_data(
+					table_name => 'test',
+					entity_id => ${fsId}::UUID,
+					new_data => ${HYPERDRIVE.json(state)}::JSONB
+				)
+			`;
 		},
 	}, // }}}
 	users: { // {{{
 		singular: 'user',
-		async initState({supabasey, id}: {supabasey: BoundSupabaseyFunction, id: string}) {
-			const user = await supabasey((supabase) => supabase
-				.from('users')
-				.select('data')
-				.eq('id', id)
-				.maybeSingle<UserRow>()
-			);
-			if (user) return user.data; // User is valid and already exists
+		async initState({HYPERDRIVE, id}: {HYPERDRIVE: PostgresSql, id: string}) {
+			let rows = await HYPERDRIVE`
+				SELECT data
+				FROM users
+				WHERE id = ${id}
+				LIMIT 1
+			`;
+			if (rows.length > 0) return rows[0].data; // User is valid and already exists
 
-			// User row doesn't already exist - need to create stub
-			const newUser = await supabasey((supabase) => supabase
-				.from('users')
-				.insert<UserRow>({
+			// User row doesn't already exist - this shouldn't happen if the user has correctly gone through the onboarding process
+			// but... *shrugs*, who knows
+			let newUser = await HYPERDRIVE`
+				INSERT INTO users
+				(
 					id,
-					data: {
+					data
+				)
+				VALUES (
+					${id},
+					${HYPERDRIVE.json({
 						id,
 						credits: 1000,
-					},
-				})
-				.select('data')
-				.single<UserRow>() // Assuming insert returns the single inserted row
-			);
-			if (!newUser) throw new Error('Failed to create user');
-			return newUser.data; // Return back the data that eventually got created - allowing for database triggers, default field values etc.
+					})}::JSONB
+				)
+			`;
+			if (!newUser?.length) throw new Error(`Failed to create new user "${id}"`);
+			return newUser[0].data; // Return back the data that eventually got created - allowing for database triggers, default field values etc.
 
 		},
-		flushState({supabasey, state, fsId}) {
-			return supabasey(supabase => supabase.rpc('syncro_merge_data', {
-				table_name: 'users',
-				entity_id: fsId,
-				new_data: state,
-			}));
+		flushState({HYPERDRIVE, state, fsId}) {
+			return HYPERDRIVE`
+				SELECT syncro_merge_data(
+					table_name => 'users',
+					entity_id => ${fsId}::UUID,
+					new_data => ${HYPERDRIVE.json(state)}::JSONB
+				)
+			`;
 		},
 	}, // }}}
 };

package/lib/syncro/keyed.ts

@@ -137,6 +137,7 @@ export default class SyncroKeyed extends Syncro {
 
 				// Go fetch the initial state object
 				const state = await SyncroEntities[entityKey].initState({
+					HYPERDRIVE: Syncro.db,
 					supabasey: Syncro.supabasey,
 					id, relation,
 				});

package/lib/syncro/syncro.ts

@@ -25,6 +25,7 @@ import PromiseThrottle from 'p-throttle';
 import PromiseRetry from 'p-retry';
 import {FirebaseApp, FirebaseError} from 'firebase/app';
 import { BoundSupabaseyFunction } from '@iebh/supabasey';
+import type { PostgresSql } from './entities.js';
 
 interface ThrottleOptions<T = any> {
 	limit: number,
@@ -81,6 +82,14 @@ export default class Syncro {
 	static supabasey: BoundSupabaseyFunction;
 
 
+	/**
+	* Postgres SQL instance in use (injected by the Cloudflare Worker runtime via Hyperdrive)
+	*
+	* @type {PostgresSql}
+	*/
+	static db: PostgresSql;
+
+
 	/**
 	* The current user session, should be unique for the user + browser tab
 	* Used by the heartbeat system

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iebh/tera-fy",
-  "version": "2.3.8",
+  "version": "2.3.10",
   "description": "TERA website worker",
   "scripts": {
     "dev": "esbuild --platform=browser --format=esm --bundle lib/terafy.client.ts --outfile=dist/terafy.js --minify --serve --servedir=.",