@verdant-web/server 3.3.10 → 4.0.0

package/src/storage/sqlShard/SqlFileMetadata.ts

@@ -1,98 +1,77 @@
-import { Kysely } from 'kysely';
-import { FileMetadataStorage } from '../Storage.js';
-import { Database, FileMetadataRow } from './tables.js';
-import { FileMetadata } from '../../types.js';
 import { FileInfo } from '../../files/FileStorage.js';
-import { Databases } from './Databases.js';
+import { FileMetadata } from '../../types.js';
+import { FileMetadataStorage } from '../Storage.js';
+import { SqliteExecutor } from './database.js';
+import { FileMetadataRow } from './tables.js';
 
 export class SqlFileMetadata implements FileMetadataStorage {
 	constructor(
-		private dbs: Databases,
+		private db: SqliteExecutor,
+		private libraryId: string,
 		private deleteExpirationDays: number,
-		private dialect: 'postgres' | 'sqlite',
 	) {}
 
-	private attachLibrary = (libraryId: string, row: FileMetadataRow) => {
+	private attachLibrary = (row: FileMetadataRow) => {
 		if (!row) return row;
-		(row as any).libraryId = libraryId;
+		(row as any).libraryId = this.libraryId;
 		return row as FileMetadata;
 	};
 
-	get = async (
-		libraryId: string,
-		fileId: string,
-	): Promise<FileMetadata | null> => {
-		const db = await this.dbs.get(libraryId);
-		const row =
-			(await db
-				.selectFrom('FileMetadata')
-				.where('fileId', '=', fileId)
-				.selectAll()
-				.executeTakeFirst()) ?? null;
-		if (row) return this.attachLibrary(libraryId, row);
+	get = async (fileId: string): Promise<FileMetadata | null> => {
+		const db = this.db;
+		const row = db.first<FileMetadataRow>(
+			`SELECT * FROM FileMetadata WHERE fileId = ?`,
+			[fileId],
+		);
+		if (row) return this.attachLibrary(row);
 		return row;
 	};
 
-	getAll = async (libraryId: string): Promise<FileMetadata[]> => {
-		const db = await this.dbs.get(libraryId);
-		return (await db.selectFrom('FileMetadata').selectAll().execute()).map(
-			this.attachLibrary.bind(this, libraryId),
-		);
+	getAll = async (): Promise<FileMetadata[]> => {
+		const db = this.db;
+		return db
+			.query<FileMetadataRow>(`SELECT * FROM FileMetadata`)
+			.map(this.attachLibrary);
 	};
 
-	deleteAll = async (libraryId: string): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('FileMetadata').execute();
+	deleteAll = async (): Promise<void> => {
+		const db = this.db;
+		db.exec('DELETE FROM FileMetadata');
 	};
 
-	put = async (libraryId: string, fileInfo: FileInfo): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db
-			.insertInto('FileMetadata')
-			.values({
-				fileId: fileInfo.id,
-				name: fileInfo.fileName,
-				type: fileInfo.type,
-			})
-			.onConflict((cb) =>
-				cb.column('fileId').doUpdateSet({
-					name: fileInfo.fileName,
-					type: fileInfo.type,
-					pendingDeleteAt: null,
-				}),
-			)
-			.execute();
+	put = async (fileInfo: FileInfo): Promise<void> => {
+		const db = this.db;
+		db.exec(
+			`INSERT INTO FileMetadata (fileId, name, type) VALUES (?, ?, ?)
+				ON CONFLICT(fileId) DO UPDATE SET
+					name = excluded.name,
+					type = excluded.type,
+					pendingDeleteAt = NULL
+			`,
+			[fileInfo.id, fileInfo.fileName, fileInfo.type],
+		);
 	};
 
-	markPendingDelete = async (
-		libraryId: string,
-		fileId: string,
-	): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db
-			.updateTable('FileMetadata')
-			.set({ pendingDeleteAt: Date.now() })
-			.where('fileId', '=', fileId)
-			.execute();
+	markPendingDelete = async (fileId: string): Promise<void> => {
+		const db = this.db;
+		db.exec(`UPDATE FileMetadata SET pendingDeleteAt = ? WHERE fileId = ?`, [
+			Date.now(),
+			fileId,
+		]);
 	};
 
-	delete = async (libraryId: string, fileId: string): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('FileMetadata').where('fileId', '=', fileId).execute();
+	delete = async (fileId: string): Promise<void> => {
+		const db = this.db;
+		db.exec(`DELETE FROM FileMetadata WHERE fileId = ?`, [fileId]);
 	};
 
-	getPendingDelete = async (libraryId: string): Promise<FileMetadata[]> => {
-		const db = await this.dbs.get(libraryId);
-		return (
-			await db
-				.selectFrom('FileMetadata')
-				.where(
-					'pendingDeleteAt',
-					'<',
-					Date.now() - 1000 * 60 * 60 * 24 * this.deleteExpirationDays,
-				)
-				.selectAll()
-				.execute()
-		).map(this.attachLibrary.bind(this, libraryId));
+	getPendingDelete = async (): Promise<FileMetadata[]> => {
+		const db = this.db;
+		return db
+			.query<FileMetadataRow>(
+				`SELECT * FROM FileMetadata WHERE pendingDeleteAt < ?`,
+				[Date.now() - this.deleteExpirationDays * 24 * 60 * 60 * 1000],
+			)
+			.map(this.attachLibrary);
 	};
 }

package/src/storage/sqlShard/SqlOperations.ts

@@ -1,73 +1,62 @@
 import { Operation } from '@verdant-web/common';
 import { StoredOperation } from '../../types.js';
 import { OperationStorage } from '../Storage.js';
+import { SqliteExecutor } from './database.js';
 import { OperationHistoryRow } from './tables.js';
-import { Databases } from './Databases.js';
 
 export class SqlOperations implements OperationStorage {
-	constructor(private dbs: Databases, private dialect: 'postgres' | 'sqlite') {}
+	constructor(
+		private db: SqliteExecutor,
+		private libraryId: string,
+	) {}
 
 	private hydrate = (row: OperationHistoryRow) => {
 		// avoiding extra allocation from .map by type-asserting here
 		row.data = JSON.parse(row.data);
 	};
 
-	getAll = async (
-		libraryId: string,
-		oid: string,
-	): Promise<StoredOperation[]> => {
-		const db = await this.dbs.get(libraryId);
-		const raw = await db
-			.selectFrom('OperationHistory')
-			.where('oid', '=', oid)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
+	getAll = async (oid: string): Promise<StoredOperation[]> => {
+		const db = this.db;
+		const raw = db.query<OperationHistoryRow>(
+			`SELECT * FROM OperationHistory WHERE oid = ? ORDER BY timestamp ASC`,
+			[oid],
+		);
 
 		raw.forEach(this.hydrate);
 		return raw as unknown as StoredOperation[];
 	};
 
 	getBeforeServerOrder = async (
-		libraryId: string,
 		beforeServerOrder: number,
 	): Promise<StoredOperation[]> => {
-		const db = await this.dbs.get(libraryId);
-		const raw = await db
-			.selectFrom('OperationHistory')
-			.where('serverOrder', '<', beforeServerOrder)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
+		const db = this.db;
+		const raw = db.query<OperationHistoryRow>(
+			`SELECT * FROM OperationHistory WHERE serverOrder < ? ORDER BY timestamp ASC`,
+			[beforeServerOrder],
+		);
 
 		raw.forEach(this.hydrate);
 		return raw as unknown as StoredOperation[];
 	};
 
 	getAfterServerOrder = async (
-		libraryId: string,
 		afterServerOrder: number,
 	): Promise<StoredOperation[]> => {
-		const db = await this.dbs.get(libraryId);
-		const raw = await db
-			.selectFrom('OperationHistory')
-			.where('serverOrder', '>', afterServerOrder)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
+		const db = this.db;
+		const raw = db.query<OperationHistoryRow>(
+			`SELECT * FROM OperationHistory WHERE serverOrder > ? ORDER BY timestamp ASC`,
+			[afterServerOrder],
+		);
 
 		raw.forEach(this.hydrate);
 		return raw as unknown as StoredOperation[];
 	};
 
-	getLatestServerOrder = async (libraryId: string): Promise<number> => {
-		const db = await this.dbs.get(libraryId);
-		const result = await db
-			.selectFrom('OperationHistory')
-			.orderBy('serverOrder', 'desc')
-			.select('serverOrder')
-			.limit(1)
-			.executeTakeFirst();
+	getLatestServerOrder = async (): Promise<number> => {
+		const db = this.db;
+		const result = db.first<Pick<OperationHistoryRow, 'serverOrder'>>(
+			`SELECT serverOrder FROM OperationHistory ORDER BY serverOrder DESC LIMIT 1`,
+		);
 		if (result) {
 			return result.serverOrder;
 		}
@@ -75,51 +64,42 @@ export class SqlOperations implements OperationStorage {
 		return 0;
 	};
 
-	getCount = async (libraryId: string): Promise<number> => {
-		const db = await this.dbs.get(libraryId);
+	getCount = async (): Promise<number> => {
+		const db = this.db;
 		return (
-			(
-				await db
-					.selectFrom('OperationHistory')
-					.select(({ fn }) => fn.countAll<number>().as('count'))
-					.executeTakeFirst()
+			db.first<{ count: number }>(
+				`SELECT COUNT(*) as count FROM OperationHistory`,
 			)?.count ?? 0
 		);
 	};
 
 	insertAll = async (
-		libraryId: string,
 		replicaId: string,
 		operations: Operation[],
 	): Promise<number> => {
-		const db = await this.dbs.get(libraryId);
+		const db = this.db;
 		// inserts all operations and updates server order
 		// FIXME: this whole thing is kinda sus
-		return await db.transaction().execute(async (tx): Promise<number> => {
-			let orderResult = await tx
-				.selectFrom('OperationHistory')
-				.select('serverOrder')
-				.orderBy('serverOrder', 'desc')
-				.limit(1)
-				.executeTakeFirst();
+		return db.transaction((tx): number => {
+			let orderResult = tx.first<Pick<OperationHistoryRow, 'serverOrder'>>(
+				`SELECT serverOrder FROM OperationHistory ORDER BY serverOrder DESC LIMIT 1`,
+			);
 			let currentServerOrder = orderResult?.serverOrder ?? 0;
 			for (const item of operations) {
 				// utilizing returned serverOrder accommodates for conflicts
-				const result = await tx
-					.insertInto('OperationHistory')
-					.values({
-						oid: item.oid,
-						data: JSON.stringify(item.data),
-						timestamp: item.timestamp,
+				const result = tx.first(
+					`INSERT INTO OperationHistory (oid, data, timestamp, replicaId, serverOrder, authz) VALUES (?, ?, ?, ?, ?, ?)
+						ON CONFLICT (replicaId, oid, timestamp) DO NOTHING
+						RETURNING serverOrder`,
+					[
+						item.oid,
+						JSON.stringify(item.data),
+						item.timestamp,
 						replicaId,
-						serverOrder: currentServerOrder + 1,
-						authz: item.authz,
-					})
-					.onConflict((cb) =>
-						cb.columns(['replicaId', 'oid', 'timestamp']).doNothing(),
-					)
-					.returning('serverOrder')
-					.executeTakeFirst();
+						currentServerOrder + 1,
+						item.authz,
+					],
+				);
 				if (result) {
 					currentServerOrder = result.serverOrder;
 				} else {
@@ -132,22 +112,18 @@ export class SqlOperations implements OperationStorage {
 		});
 	};
 
-	deleteAll = async (libraryId: string): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('OperationHistory').execute();
+	deleteAll = async (): Promise<void> => {
+		const db = this.db;
+		db.exec('DELETE FROM OperationHistory');
 	};
-	delete = async (
-		libraryId: string,
-		operations: Operation[],
-	): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.transaction().execute(async (tx) => {
+	delete = async (operations: Operation[]): Promise<void> => {
+		const db = this.db;
+		return db.transaction((tx) => {
 			for (const item of operations) {
-				await tx
-					.deleteFrom('OperationHistory')
-					.where('oid', '=', item.oid)
-					.where('timestamp', '=', item.timestamp)
-					.execute();
+				tx.exec(
+					`DELETE FROM OperationHistory WHERE oid = ? AND timestamp = ?`,
+					[item.oid, item.timestamp],
+				);
 			}
 		});
 	};

package/src/storage/sqlShard/SqlReplicas.ts

@@ -1,61 +1,50 @@
+import { ReplicaType, VerdantError } from '@verdant-web/common';
 import { StoredReplicaInfo } from '../../types.js';
 import { ReplicaStorage } from '../Storage.js';
-import { sql, type Kysely } from 'kysely';
-import { Database, ReplicaInfoRow } from './tables.js';
-import { ReplicaType, VerdantError } from '@verdant-web/common';
-import { Databases } from './Databases.js';
+import { SqliteExecutor } from './database.js';
+import { ReplicaInfoRow } from './tables.js';
 
 export class SqlReplicas implements ReplicaStorage {
 	constructor(
-		private dbs: Databases,
+		private db: SqliteExecutor,
+		private libraryId: string,
 		private readonly replicaTruancyMinutes: number,
-		private readonly dialect: 'sqlite' | 'postgres',
 	) {}
 
 	get truantCutoff(): number {
 		return Date.now() - this.replicaTruancyMinutes * 60 * 1000;
 	}
 
-	private attachLibraryId = (libraryId: string, row: ReplicaInfoRow) => {
-		(row as any).libraryId = libraryId;
+	private attachLibraryId = (row: ReplicaInfoRow) => {
+		(row as any).libraryId = this.libraryId;
 		return row as StoredReplicaInfo;
 	};
 
-	get = async (
-		libraryId: string,
-		replicaId: string,
-	): Promise<StoredReplicaInfo | null> => {
-		const db = await this.dbs.get(libraryId);
-		const row =
-			(await db
-				.selectFrom('ReplicaInfo')
-				.where('id', '=', replicaId)
-				.selectAll()
-				.executeTakeFirst()) ?? null;
-		if (row) return this.attachLibraryId(libraryId, row);
+	get = async (replicaId: string): Promise<StoredReplicaInfo | null> => {
+		const db = this.db;
+		const row = db.first<ReplicaInfoRow>(
+			`SELECT * FROM ReplicaInfo WHERE id = ?`,
+			[replicaId],
+		);
+		if (row) return this.attachLibraryId(row);
 		return row;
 	};
 	getOrCreate = async (
-		libraryId: string,
 		replicaId: string,
 		info: { userId: string; type: ReplicaType },
 	): Promise<{
 		status: 'new' | 'existing' | 'truant';
 		replicaInfo: StoredReplicaInfo;
 	}> => {
-		const existing = await this.get(libraryId, replicaId);
+		const existing = await this.get(replicaId);
 		if (!existing) {
-			const db = await this.dbs.get(libraryId);
-			const created = await db
-				.insertInto('ReplicaInfo')
-				.values({
-					id: replicaId,
-					clientId: info.userId,
-					type: info.type,
-					ackedServerOrder: 0,
-				})
-				.returningAll()
-				.executeTakeFirst();
+			const db = this.db;
+			const created = db.first<ReplicaInfoRow>(
+				`INSERT INTO ReplicaInfo (id, clientId, type, ackedServerOrder) VALUES (?, ?, ?, ?)
+					ON CONFLICT(id) DO NOTHING
+					RETURNING *`,
+				[replicaId, info.userId, info.type, 0],
+			);
 			if (!created) {
 				throw new VerdantError(
 					VerdantError.Code.Unexpected,
@@ -65,18 +54,17 @@ export class SqlReplicas implements ReplicaStorage {
 			}
 			return {
 				status: 'new',
-				replicaInfo: this.attachLibraryId(libraryId, created),
+				replicaInfo: this.attachLibraryId(created),
 			};
 		}
 
 		if (existing.type !== info.type) {
-			const db = await this.dbs.get(libraryId);
+			const db = this.db;
 			// type should be updated if a new token changes it
-			await db
-				.updateTable('ReplicaInfo')
-				.set({ type: info.type })
-				.where('id', '=', replicaId)
-				.execute();
+			db.exec(`UPDATE ReplicaInfo SET type = ? WHERE id = ?`, [
+				info.type,
+				replicaId,
+			]);
 		}
 
 		if (existing.clientId !== info.userId) {
@@ -99,112 +87,83 @@ export class SqlReplicas implements ReplicaStorage {
 	};
 
 	getAll = async (
-		libraryId: string,
 		options?: { omitTruant: boolean } | undefined,
 	): Promise<StoredReplicaInfo[]> => {
-		const db = await this.dbs.get(libraryId);
-		let builder = db.selectFrom('ReplicaInfo');
-
-		if (options?.omitTruant) {
-			builder = builder.where('lastSeenWallClockTime', '>', this.truantCutoff);
-		}
-
-		return (await builder.selectAll().execute()).map(
-			this.attachLibraryId.bind(this, libraryId),
+		const result = this.db.query<ReplicaInfoRow>(
+			`SELECT * FROM ReplicaInfo${options?.omitTruant ? ' WHERE lastSeenWallClockTime > ?' : ''}`,
+			options?.omitTruant ? [this.truantCutoff] : [],
 		);
+
+		return result.map(this.attachLibraryId);
 	};
 
-	updateLastSeen = async (
-		libraryId: string,
-		replicaId: string,
-	): Promise<void> => {
+	updateLastSeen = async (replicaId: string): Promise<void> => {
 		const clockTime = Date.now();
-		const db = await this.dbs.get(libraryId);
-		await db
-			.updateTable('ReplicaInfo')
-			.set({ lastSeenWallClockTime: clockTime })
-			.where('id', '=', replicaId)
-			.execute();
+		const db = this.db;
+		db.exec(`UPDATE ReplicaInfo SET lastSeenWallClockTime = ? WHERE id = ?`, [
+			clockTime,
+			replicaId,
+		]);
 	};
 
 	updateAckedServerOrder = async (
-		libraryId: string,
 		replicaId: string,
 		serverOrder: number,
 	): Promise<void> => {
-		const max = this.dialect === 'postgres' ? 'GREATEST' : 'MAX';
-		const db = await this.dbs.get(libraryId);
-		await db
-			.updateTable('ReplicaInfo')
-			.set(
-				'ackedServerOrder',
-				({ val }) =>
-					sql<number>`${sql.raw(max)}(ackedServerOrder, ${val(serverOrder)})`,
-			)
-			.where('id', '=', replicaId)
-			.execute();
+		this.db.exec(
+			`UPDATE ReplicaInfo SET ackedServerOrder = MAX(ackedServerOrder, ?) WHERE id = ?`,
+			[serverOrder, replicaId],
+		);
 	};
 
 	updateAcknowledgedLogicalTime = async (
-		libraryId: string,
 		replicaId: string,
 		timestamp: string,
 	): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db
-			.updateTable('ReplicaInfo')
-			.set({ ackedLogicalTime: timestamp })
-			.where('id', '=', replicaId)
-			.execute();
+		this.db.exec(`UPDATE ReplicaInfo SET ackedLogicalTime = ? WHERE id = ?`, [
+			timestamp,
+			replicaId,
+		]);
 	};
 
-	getEarliestAckedServerOrder = async (libraryId: string): Promise<number> => {
-		const db = await this.dbs.get(libraryId);
+	getEarliestAckedServerOrder = async (): Promise<number> => {
 		// gets earliest acked server order of all non-truant replicas.
-		const res = await db
-			.selectFrom('ReplicaInfo')
-			.where('lastSeenWallClockTime', '>', this.truantCutoff)
-			.orderBy('ackedServerOrder', 'asc')
-			.select('ackedServerOrder')
-			.executeTakeFirst();
+		const res = this.db.first<Pick<ReplicaInfoRow, 'ackedServerOrder'>>(
+			`SELECT ackedServerOrder FROM ReplicaInfo WHERE lastSeenWallClockTime > ? ORDER BY ackedServerOrder ASC LIMIT 1`,
+			[this.truantCutoff],
+		);
 		return res?.ackedServerOrder ?? 0;
 	};
 
 	acknowledgeOperation = async (
-		libraryId: string,
 		replicaId: string,
 		timestamp: string,
 	): Promise<void> => {
 		if (!timestamp) return;
-		const db = await this.dbs.get(libraryId);
 		// when acking an operation, we also set the replica's server order
 		// to that operation's server order, if it's greater.
-		const max = this.dialect === 'postgres' ? 'GREATEST' : 'MAX';
-		await db
-			.updateTable('ReplicaInfo')
-			.set({ ackedLogicalTime: timestamp })
-			.set(
-				'ackedServerOrder',
-				({ val }) => sql<number>`${sql.raw(max)}(
-					ackedServerOrder,
-					COALESCE(
-						(
-        			SELECT serverOrder FROM OperationHistory
-        			WHERE timestamp = ${val(timestamp)}
-      			),
-						0
+		this.db.exec(
+			`UPDATE ReplicaInfo SET
+					ackedLogicalTime = ?,
+					ackedServerOrder = MAX(
+						ackedServerOrder,
+						COALESCE(
+							(
+								SELECT serverOrder FROM OperationHistory
+								WHERE timestamp = ?
+							),
+							0
+						)
 					)
-				)`,
-			)
-			.where('id', '=', replicaId)
-			.execute();
+				WHERE id = ?`,
+			[timestamp, timestamp, replicaId],
+		);
 	};
 
 	getGlobalAck = async (
-		libraryId: string,
 		onlineReplicaIds?: string[] | undefined,
 	): Promise<string | null> => {
-		const nonTruant = await this.getAll(libraryId, { omitTruant: true });
+		const nonTruant = await this.getAll({ omitTruant: true });
 		if (nonTruant.length === 0) return null;
 		const globalAckEligible = nonTruant.filter(
 			(replica) => replica.type < 2 || onlineReplicaIds?.includes(replica.id),
@@ -219,19 +178,19 @@ export class SqlReplicas implements ReplicaStorage {
 			null as string | null,
 		);
 	};
-	delete = async (libraryId: string, replicaId: string): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('ReplicaInfo').where('id', '=', replicaId).execute();
+	delete = async (replicaId: string): Promise<void> => {
+		this.db.exec(`DELETE FROM ReplicaInfo WHERE id = ?`, [replicaId]);
 	};
-	deleteAll = async (libraryId: string): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('ReplicaInfo').execute();
+	deleteAll = async (): Promise<void> => {
+		this.db.exec(`DELETE FROM ReplicaInfo`, []);
 	};
-	deleteAllForUser = async (
-		libraryId: string,
-		userId: string,
-	): Promise<void> => {
-		const db = await this.dbs.get(libraryId);
-		await db.deleteFrom('ReplicaInfo').where('clientId', '=', userId).execute();
+	deleteAllForUser = async (userId: string): Promise<void> => {
+		this.db.exec(`DELETE FROM ReplicaInfo WHERE clientId = ?`, [userId]);
+	};
+	forceTruant = async (replicaId: string): Promise<void> => {
+		this.db.exec(
+			`UPDATE ReplicaInfo SET lastSeenWallClockTime = ? WHERE id = ?`,
+			[Date.now() - this.replicaTruancyMinutes * 60 * 1000 - 1, replicaId],
+		);
 	};
 }