@verdant-web/server 3.3.11 → 4.0.1

package/src/storage/sql/SqlBaselines.ts

@@ -1,147 +0,0 @@
-import { Kysely } from 'kysely';
-import { BaselineStorage } from '../Storage.js';
-import { Database, DocumentBaselineRow } from './tables.js';
-import { DocumentBaseline, Ref, applyPatch } from '@verdant-web/common';
-import { HydratedDocumentBaseline, StoredOperation } from '../../types.js';
-
-export class SqlBaselines implements BaselineStorage {
-	constructor(
-		private db: Kysely<Database>,
-		private dialect: 'postgres' | 'sqlite',
-	) {}
-
-	get = async (
-		libraryId: string,
-		oid: string,
-		{ tx }: { tx?: Kysely<Database> } = {},
-	): Promise<HydratedDocumentBaseline | null> => {
-		const db = tx ?? this.db;
-		const raw =
-			(await db
-				.selectFrom('DocumentBaseline')
-				.where('libraryId', '=', libraryId)
-				.where('oid', '=', oid)
-				.selectAll()
-				.executeTakeFirst()) ?? null;
-		if (!raw) return null;
-		this.hydrate(raw);
-		return raw as any;
-	};
-
-	getAll = async (libraryId: string) => {
-		const raw = await this.db
-			.selectFrom('DocumentBaseline')
-			.where('libraryId', '=', libraryId)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
-
-		raw.forEach(this.hydrate);
-
-		return raw as any;
-	};
-
-	set = async (
-		libraryId: string,
-		baseline: DocumentBaseline,
-		{
-			tx,
-		}: {
-			tx?: Kysely<Database>;
-		},
-	) => {
-		const db = tx ?? this.db;
-		if (!baseline.snapshot) {
-			await db
-				.deleteFrom('DocumentBaseline')
-				.where('libraryId', '=', libraryId)
-				.where('oid', '=', baseline.oid)
-				.execute();
-			return;
-		}
-
-		await db
-			.insertInto('DocumentBaseline')
-			.values({
-				libraryId,
-				oid: baseline.oid,
-				snapshot: JSON.stringify(baseline.snapshot),
-				timestamp: baseline.timestamp,
-				authz: baseline.authz,
-			})
-			.onConflict((cb) =>
-				cb.doUpdateSet({
-					snapshot: JSON.stringify(baseline.snapshot),
-					timestamp: baseline.timestamp,
-					authz: baseline.authz,
-				}),
-			)
-			.execute();
-	};
-
-	insertAll = async (libraryId: string, baselines: DocumentBaseline[]) => {
-		await this.db.transaction().execute(async (tx) => {
-			for (const baseline of baselines) {
-				await this.set(libraryId, baseline, { tx });
-			}
-		});
-	};
-
-	private hydrate = (row: DocumentBaselineRow) => {
-		// avoiding extra allocation from .map by type-asserting here
-		row.snapshot = JSON.parse(row.snapshot);
-	};
-
-	applyOperations = async (
-		libraryId: string,
-		oid: string,
-		operations: StoredOperation[],
-		deletedRefs?: Ref[],
-	) => {
-		if (operations.length === 0) return;
-
-		await this.db.transaction().execute(async (tx) => {
-			let baseline = await this.get(libraryId, oid, { tx });
-			if (!baseline) {
-				baseline = {
-					oid,
-					snapshot: {},
-					timestamp: operations[0].timestamp,
-					libraryId,
-					authz: operations[0].authz,
-				};
-			}
-			for (const operation of operations) {
-				baseline.snapshot = applyPatch(
-					baseline.snapshot,
-					operation.data,
-					deletedRefs,
-				);
-				if (operation.data.op === 'initialize') {
-					baseline.authz = operation.authz;
-				}
-			}
-			baseline.timestamp = operations[operations.length - 1].timestamp;
-			await this.set(libraryId, baseline, { tx });
-		});
-	};
-
-	deleteAll = async (libraryId: string) => {
-		await this.db
-			.deleteFrom('DocumentBaseline')
-			.where('libraryId', '=', libraryId)
-			.execute();
-	};
-
-	getCount = async (libraryId: string) => {
-		return (
-			(
-				await this.db
-					.selectFrom('DocumentBaseline')
-					.where('libraryId', '=', libraryId)
-					.select(({ fn }) => fn.countAll<number>().as('count'))
-					.executeTakeFirst()
-			)?.count ?? 0
-		);
-	};
-}

package/src/storage/sql/SqlFileMetadata.ts

@@ -1,94 +0,0 @@
-import { Kysely } from 'kysely';
-import { FileMetadataStorage } from '../Storage.js';
-import { Database } from './tables.js';
-import { FileMetadata } from '../../types.js';
-import { FileInfo } from '../../files/FileStorage.js';
-
-export class SqlFileMetadata implements FileMetadataStorage {
-	constructor(
-		private db: Kysely<Database>,
-		private deleteExpirationDays: number,
-		private dialect: 'postgres' | 'sqlite',
-	) {}
-
-	get = async (
-		libraryId: string,
-		fileId: string,
-	): Promise<FileMetadata | null> => {
-		return (
-			(await this.db
-				.selectFrom('FileMetadata')
-				.where('libraryId', '=', libraryId)
-				.where('fileId', '=', fileId)
-				.selectAll()
-				.executeTakeFirst()) ?? null
-		);
-	};
-
-	getAll = async (libraryId: string): Promise<FileMetadata[]> => {
-		return this.db
-			.selectFrom('FileMetadata')
-			.where('libraryId', '=', libraryId)
-			.selectAll()
-			.execute();
-	};
-
-	deleteAll = async (libraryId: string): Promise<void> => {
-		await this.db
-			.deleteFrom('FileMetadata')
-			.where('libraryId', '=', libraryId)
-			.execute();
-	};
-
-	put = async (libraryId: string, fileInfo: FileInfo): Promise<void> => {
-		await this.db
-			.insertInto('FileMetadata')
-			.values({
-				libraryId,
-				fileId: fileInfo.id,
-				name: fileInfo.fileName,
-				type: fileInfo.type,
-			})
-			.onConflict((cb) =>
-				cb.columns(['libraryId', 'fileId']).doUpdateSet({
-					name: fileInfo.fileName,
-					type: fileInfo.type,
-					pendingDeleteAt: null,
-				}),
-			)
-			.execute();
-	};
-
-	markPendingDelete = async (
-		libraryId: string,
-		fileId: string,
-	): Promise<void> => {
-		await this.db
-			.updateTable('FileMetadata')
-			.set({ pendingDeleteAt: Date.now() })
-			.where('libraryId', '=', libraryId)
-			.where('fileId', '=', fileId)
-			.execute();
-	};
-
-	delete = async (libraryId: string, fileId: string): Promise<void> => {
-		await this.db
-			.deleteFrom('FileMetadata')
-			.where('libraryId', '=', libraryId)
-			.where('fileId', '=', fileId)
-			.execute();
-	};
-
-	getPendingDelete = async (libraryId: string): Promise<FileMetadata[]> => {
-		return this.db
-			.selectFrom('FileMetadata')
-			.where('libraryId', '=', libraryId)
-			.where(
-				'pendingDeleteAt',
-				'<',
-				Date.now() - 1000 * 60 * 60 * 24 * this.deleteExpirationDays,
-			)
-			.selectAll()
-			.execute();
-	};
-}

package/src/storage/sql/SqlOperations.ts

@@ -1,160 +0,0 @@
-import { Operation } from '@verdant-web/common';
-import { StoredOperation } from '../../types.js';
-import { OperationStorage } from '../Storage.js';
-import { Kysely } from 'kysely';
-import { Database, OperationHistoryRow } from './tables.js';
-
-export class SqlOperations implements OperationStorage {
-	constructor(
-		private db: Kysely<Database>,
-		private dialect: 'postgres' | 'sqlite',
-	) {}
-
-	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 raw = await this.db
-			.selectFrom('OperationHistory')
-			.where('libraryId', '=', libraryId)
-			.where('oid', '=', oid)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
-
-		raw.forEach(this.hydrate);
-		return raw as unknown as StoredOperation[];
-	};
-
-	getBeforeServerOrder = async (
-		libraryId: string,
-		beforeServerOrder: number,
-	): Promise<StoredOperation[]> => {
-		const raw = await this.db
-			.selectFrom('OperationHistory')
-			.where('libraryId', '=', libraryId)
-			.where('serverOrder', '<', beforeServerOrder)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
-
-		raw.forEach(this.hydrate);
-		return raw as unknown as StoredOperation[];
-	};
-
-	getAfterServerOrder = async (
-		libraryId: string,
-		afterServerOrder: number,
-	): Promise<StoredOperation[]> => {
-		const raw = await this.db
-			.selectFrom('OperationHistory')
-			.where('libraryId', '=', libraryId)
-			.where('serverOrder', '>', afterServerOrder)
-			.orderBy('timestamp', 'asc')
-			.selectAll()
-			.execute();
-
-		raw.forEach(this.hydrate);
-		return raw as unknown as StoredOperation[];
-	};
-
-	getLatestServerOrder = async (libraryId: string): Promise<number> => {
-		return (
-			(
-				await this.db
-					.selectFrom('OperationHistory')
-					.where('libraryId', '=', libraryId)
-					.orderBy('serverOrder', 'desc')
-					.select('serverOrder')
-					.limit(1)
-					.executeTakeFirst()
-			)?.serverOrder ?? 0
-		);
-	};
-
-	getCount = async (libraryId: string): Promise<number> => {
-		return (
-			(
-				await this.db
-					.selectFrom('OperationHistory')
-					.where('libraryId', '=', libraryId)
-					.select(({ fn }) => fn.countAll<number>().as('count'))
-					.executeTakeFirst()
-			)?.count ?? 0
-		);
-	};
-
-	insertAll = async (
-		libraryId: string,
-		replicaId: string,
-		operations: Operation[],
-	): Promise<number> => {
-		// inserts all operations and updates server order
-		// FIXME: this whole thing is kinda sus
-		return await this.db.transaction().execute(async (tx): Promise<number> => {
-			let orderResult = await tx
-				.selectFrom('OperationHistory')
-				.select('serverOrder')
-				.where('libraryId', '=', libraryId)
-				.orderBy('serverOrder', 'desc')
-				.limit(1)
-				.executeTakeFirst();
-			let currentServerOrder = orderResult?.serverOrder ?? 0;
-			for (const item of operations) {
-				// utilizing returned serverOrder accommodates for conflicts
-				const result = await tx
-					.insertInto('OperationHistory')
-					.values({
-						libraryId,
-						oid: item.oid,
-						data: JSON.stringify(item.data),
-						timestamp: item.timestamp,
-						replicaId,
-						serverOrder: currentServerOrder + 1,
-						authz: item.authz,
-					})
-					.onConflict((cb) =>
-						cb
-							.columns(['libraryId', 'replicaId', 'oid', 'timestamp'])
-							.doNothing(),
-					)
-					.returning('serverOrder')
-					.executeTakeFirst();
-				if (result) {
-					currentServerOrder = result.serverOrder;
-				} else {
-					// on conflict, nothing is returned.
-					// this would mean an operation was synced twice
-				}
-			}
-			return currentServerOrder;
-		});
-	};
-
-	deleteAll = async (libraryId: string): Promise<void> => {
-		await this.db
-			.deleteFrom('OperationHistory')
-			.where('libraryId', '=', libraryId)
-			.execute();
-	};
-	delete = async (
-		libraryId: string,
-		operations: Operation[],
-	): Promise<void> => {
-		await this.db.transaction().execute(async (tx) => {
-			for (const item of operations) {
-				await tx
-					.deleteFrom('OperationHistory')
-					.where('libraryId', '=', libraryId)
-					.where('oid', '=', item.oid)
-					.where('timestamp', '=', item.timestamp)
-					.execute();
-			}
-		});
-	};
-}

package/src/storage/sql/SqlReplicas.ts

@@ -1,234 +0,0 @@
-import { StoredReplicaInfo } from '../../types.js';
-import { ReplicaStorage } from '../Storage.js';
-import { sql, type Kysely } from 'kysely';
-import { Database } from './tables.js';
-import { ReplicaType, VerdantError } from '@verdant-web/common';
-
-export class SqlReplicas implements ReplicaStorage {
-	constructor(
-		private db: Kysely<Database>,
-		private readonly replicaTruancyMinutes: number,
-		private readonly dialect: 'sqlite' | 'postgres',
-	) {}
-
-	get truantCutoff(): number {
-		return Date.now() - this.replicaTruancyMinutes * 60 * 1000;
-	}
-
-	get = async (
-		libraryId: string,
-		replicaId: string,
-	): Promise<StoredReplicaInfo | null> => {
-		return (
-			(await this.db
-				.selectFrom('ReplicaInfo')
-				.where('libraryId', '=', libraryId)
-				.where('id', '=', replicaId)
-				.selectAll()
-				.executeTakeFirst()) ?? null
-		);
-	};
-	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);
-		if (!existing) {
-			const created = await this.db
-				.insertInto('ReplicaInfo')
-				.values({
-					id: replicaId,
-					clientId: info.userId,
-					libraryId,
-					type: info.type,
-					ackedServerOrder: 0,
-				})
-				.returningAll()
-				.executeTakeFirst();
-			if (!created) {
-				throw new VerdantError(
-					VerdantError.Code.Unexpected,
-					undefined,
-					'Failed to create replica',
-				);
-			}
-			return { status: 'new', replicaInfo: created };
-		}
-
-		if (existing.type !== info.type) {
-			// type should be updated if a new token changes it
-			await this.db
-				.updateTable('ReplicaInfo')
-				.set({ type: info.type })
-				.where('libraryId', '=', libraryId)
-				.where('id', '=', replicaId)
-				.execute();
-		}
-
-		if (existing.clientId !== info.userId) {
-			// replicas cannot change hands - this is a security issue
-			throw new VerdantError(
-				VerdantError.Code.Forbidden,
-				undefined,
-				'Another user is already using this replica ID',
-			);
-		}
-
-		if (
-			existing.lastSeenWallClockTime !== null &&
-			existing.lastSeenWallClockTime < this.truantCutoff
-		) {
-			return { status: 'truant', replicaInfo: existing };
-		}
-
-		return { status: 'existing', replicaInfo: existing };
-	};
-
-	getAll = async (
-		libraryId: string,
-		options?: { omitTruant: boolean } | undefined,
-	): Promise<StoredReplicaInfo[]> => {
-		let builder = this.db
-			.selectFrom('ReplicaInfo')
-			.where('libraryId', '=', libraryId);
-
-		if (options?.omitTruant) {
-			builder = builder.where('lastSeenWallClockTime', '>', this.truantCutoff);
-		}
-
-		return builder.selectAll().execute();
-	};
-
-	updateLastSeen = async (
-		libraryId: string,
-		replicaId: string,
-	): Promise<void> => {
-		const clockTime = Date.now();
-		await this.db
-			.updateTable('ReplicaInfo')
-			.set({ lastSeenWallClockTime: clockTime })
-			.where('libraryId', '=', libraryId)
-			.where('id', '=', replicaId)
-			.execute();
-	};
-
-	updateAckedServerOrder = async (
-		libraryId: string,
-		replicaId: string,
-		serverOrder: number,
-	): Promise<void> => {
-		const max = this.dialect === 'postgres' ? 'GREATEST' : 'MAX';
-		await this.db
-			.updateTable('ReplicaInfo')
-			.set(
-				'ackedServerOrder',
-				({ val }) =>
-					sql<number>`${sql.raw(max)}(ackedServerOrder, ${val(serverOrder)})`,
-			)
-			.where('libraryId', '=', libraryId)
-			.where('id', '=', replicaId)
-			.execute();
-	};
-
-	updateAcknowledgedLogicalTime = async (
-		libraryId: string,
-		replicaId: string,
-		timestamp: string,
-	): Promise<void> => {
-		await this.db
-			.updateTable('ReplicaInfo')
-			.set({ ackedLogicalTime: timestamp })
-			.where('libraryId', '=', libraryId)
-			.where('id', '=', replicaId)
-			.execute();
-	};
-
-	getEarliestAckedServerOrder = async (libraryId: string): Promise<number> => {
-		// gets earliest acked server order of all non-truant replicas.
-		const res = await this.db
-			.selectFrom('ReplicaInfo')
-			.where('libraryId', '=', libraryId)
-			.where('lastSeenWallClockTime', '>', this.truantCutoff)
-			.orderBy('ackedServerOrder', 'asc')
-			.select('ackedServerOrder')
-			.executeTakeFirst();
-		return res?.ackedServerOrder ?? 0;
-	};
-
-	acknowledgeOperation = async (
-		libraryId: string,
-		replicaId: string,
-		timestamp: string,
-	): Promise<void> => {
-		if (!timestamp) return;
-		// 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 this.db
-			.updateTable('ReplicaInfo')
-			.set({ ackedLogicalTime: timestamp })
-			.set(
-				'ackedServerOrder',
-				({ val }) => sql<number>`${sql.raw(max)}(
-					ackedServerOrder,
-					COALESCE(
-						(
-        			SELECT serverOrder FROM OperationHistory
-        			WHERE libraryId = ${val(libraryId)} AND timestamp = ${val(timestamp)}
-      			),
-						0
-					)
-				)`,
-			)
-			.where('libraryId', '=', libraryId)
-			.where('id', '=', replicaId)
-			.execute();
-	};
-
-	getGlobalAck = async (
-		libraryId: string,
-		onlineReplicaIds?: string[] | undefined,
-	): Promise<string | null> => {
-		const nonTruant = await this.getAll(libraryId, { omitTruant: true });
-		if (nonTruant.length === 0) return null;
-		const globalAckEligible = nonTruant.filter(
-			(replica) => replica.type < 2 || onlineReplicaIds?.includes(replica.id),
-		);
-
-		return globalAckEligible.reduce(
-			(acc, replica) => {
-				if (!replica.ackedLogicalTime) return acc;
-				if (acc === null) return replica.ackedLogicalTime;
-				return acc < replica.ackedLogicalTime ? acc : replica.ackedLogicalTime;
-			},
-			null as string | null,
-		);
-	};
-	delete = async (libraryId: string, replicaId: string): Promise<void> => {
-		await this.db
-			.deleteFrom('ReplicaInfo')
-			.where('libraryId', '=', libraryId)
-			.where('id', '=', replicaId)
-			.execute();
-	};
-	deleteAll = async (libraryId: string): Promise<void> => {
-		await this.db
-			.deleteFrom('ReplicaInfo')
-			.where('libraryId', '=', libraryId)
-			.execute();
-	};
-	deleteAllForUser = async (
-		libraryId: string,
-		userId: string,
-	): Promise<void> => {
-		await this.db
-			.deleteFrom('ReplicaInfo')
-			.where('libraryId', '=', libraryId)
-			.where('clientId', '=', userId)
-			.execute();
-	};
-}

package/src/storage/sql/database.ts

@@ -1,32 +0,0 @@
-import { Kysely, SqliteDialect } from 'kysely';
-import { Database as DatabaseTypes } from './tables.js';
-import Database from 'better-sqlite3';
-import { migrateToLatest } from '@a-type/kysely';
-import migrations from './migrations.js';
-
-export function openDatabase(
-	file: string,
-	options: {
-		skipMigrations?: boolean;
-		disableWal?: boolean;
-	} = {},
-) {
-	const internalDb = new Database(file);
-	if (!options.disableWal) {
-		internalDb.pragma('journal_mode = WAL');
-	}
-	const db = new Kysely<DatabaseTypes>({
-		dialect: new SqliteDialect({
-			database: internalDb,
-		}),
-	});
-	let ready = Promise.resolve<void>(undefined);
-	if (!options.skipMigrations) {
-		ready = migrateToLatest(db, migrations);
-	}
-
-	return {
-		db,
-		ready,
-	};
-}