@harperfast/harper 5.3.0-beta.3 → 5.3.0-beta.4

package/resources/auditStore.ts

@@ -303,6 +303,8 @@ export function openAuditStore(rootStore) {
 									await removeAuditEntry(auditStore, auditRecord);
 								} catch (error) {
 									harperLogger.warn('Error removing audit entry', error);
+									// not continue: the marker and backoff must cover a contiguous removed prefix (DESIGN.md)
+									break;
 								}
 								lastKey = auditRecord.key;
 								await new Promise(setImmediate);
@@ -451,21 +453,27 @@ export function removeAuditEntry(auditStore: any, auditRecord: AuditRecord): Pro
 		// at the same time so the audit table the primary table are in sync, assuming the entry is still
 		// the record state this audit record wrote
 		const tableId = auditRecord.tableId;
-		const primaryStore = auditStore.tableStores[auditRecord.tableId];
-		const tombstone = primaryStore?.getEntry(auditRecord.recordId);
-		if (isAuditEntryWrite(tombstone, auditRecord))
-			// a failed tombstone removal doesn't mean the audit entry removal failed — only
-			// auditStore.remove() below decides this function's outcome
-			tombstoneRemoval = new Promise<void>((resolve) => {
-				resolve(auditStore.deleteCallbacks?.[tableId]?.(auditRecord.recordId, tombstone.version));
-			}).catch((error) => {
-				harperLogger.warn('Error removing deleted record while removing its audit entry', error);
-			});
+		// a failed tombstone lookup or removal doesn't mean the audit entry removal failed — only
+		// auditStore.remove() below decides this function's outcome. The lookup throws for an
+		// undecodable recordId, and that entry would otherwise fail on every cleanup pass.
+		try {
+			const tombstone = auditStore.tableStores[tableId]?.getEntry(auditRecord.recordId);
+			if (isAuditEntryWrite(tombstone, auditRecord))
+				tombstoneRemoval = Promise.resolve(
+					auditStore.deleteCallbacks?.[tableId]?.(auditRecord.recordId, tombstone.version)
+				).catch(warnTombstoneRemovalFailure);
+		} catch (error) {
+			warnTombstoneRemovalFailure(error);
+		}
 	}
 	const auditRemoval = auditStore.remove(auditRecord.key);
 	return tombstoneRemoval ? Promise.all([tombstoneRemoval, auditRemoval]).then(() => undefined) : auditRemoval;
 }
 
+function warnTombstoneRemovalFailure(error: unknown) {
+	warnContained('Error removing deleted record while removing its audit entry', error);
+}
+
 function updateLastRemoved(auditStore, lastKey) {
 	FLOAT_TARGET[0] = lastKey;
 	return auditStore.put(Symbol.for('last-removed'), FLOAT_BUFFER);

package/resources/blob.ts

@@ -2641,25 +2641,30 @@ export function getBlobPathsForDatabaseName(databaseName: string): string[] {
 }
 export async function deleteRootBlobPathsForDB(store: RootDatabase): Promise<void> {
 	const paths = getRootBlobPathsForDB(store);
-	if (paths) {
-		await Promise.all(paths.map((path) => rimrafSteadily(path)));
-	}
+	if (paths) await deleteBlobPaths(paths);
+}
+
+export async function deleteBlobPaths(paths: Iterable<string>): Promise<void> {
+	const failures = (await Promise.all([...new Set(paths)].map((path) => rimrafSteadily(path)))).flat();
+	if (failures.length > 0) throw new AggregateError(failures, 'Could not delete blob storage');
 }
 
 /**
  * recursively delete a directory and all of its contents, but do it one at a time, so that we don't run out of memory and hog resources
  * @param path
  */
-async function rimrafSteadily(path: string) {
-	if (!existsSync(path)) return;
+async function rimrafSteadily(path: string): Promise<unknown[]> {
+	if (!existsSync(path)) return [];
+	const failures: unknown[] = [];
 	for (const entry of await readdir(path, { withFileTypes: true })) {
 		if (entry.isDirectory()) {
-			await rimrafSteadily(join(path, entry.name));
+			failures.push(...(await rimrafSteadily(join(path, entry.name))));
 		} else {
 			try {
 				await unlinkPromised(join(path, entry.name));
 			} catch (error) {
 				logger.warn?.('Error deleting file', error);
+				failures.push(error);
 			}
 		}
 	}
@@ -2667,7 +2672,9 @@ async function rimrafSteadily(path: string) {
 		await rmdir(path);
 	} catch (error) {
 		logger.warn?.('Error deleting directory', error);
+		failures.push(error);
 	}
+	return failures;
 }
 function getFilePath({ storageIndex, fileId, store }: StorageInfo): string {
 	const blobStoragePaths = getRootBlobPathsForDB(store);

package/resources/branchDatabase.ts

@@ -504,7 +504,7 @@ async function openOrCreate(baseName: string, appName: string, branchPath: strin
 					// The branch is closed first — it holds the path and store identity a retry needs — and
 					// a close failure must not leave the claim wedged in CREATING for the whole deadline.
 					try {
-						branch?.close();
+						await branch?.close();
 					} catch (closeError) {
 						logger.warn(`Error closing branch at ${branchPath} after a failed open`, closeError);
 					}
@@ -575,7 +575,7 @@ export async function closeBranchAt(branchPath: string): Promise<void> {
 	const pending = branchesByPath.get(branchPath);
 	branchesByPath.delete(branchPath);
 	const opened = await pending?.catch(() => null);
-	opened?.branch.close();
+	await opened?.branch.close();
 }
 
 /**
@@ -737,7 +737,7 @@ async function removeBranchAt(branchPath: string): Promise<void> {
 	const pending = branchesByPath.get(branchPath);
 	branchesByPath.delete(branchPath);
 	const opened = (await pending?.catch(() => null)) ?? null;
-	opened?.branch.close();
+	await opened?.branch.close();
 	await destroyBranchStorage(branchPath, opened);
 }
 

package/resources/databaseDropPreparation.ts

@@ -0,0 +1,120 @@
+import { threadId, workerData } from 'node:worker_threads';
+import { dirname, resolve } from 'node:path';
+
+type DatabaseDropPreparation = {
+	id: string;
+	ownerThreadId: number;
+	databaseName: string;
+	ownerExited?: boolean;
+	preparationTask?: Promise<void>;
+};
+
+const inheritedDatabaseDropPreparations = (workerData?.databaseDropPreparations ?? []).filter(
+	// Main reaches a child through parentPort rather than addThreadIds; worker owners must be in the initial peer topology.
+	([, preparation]: [string, DatabaseDropPreparation]) =>
+		preparation.ownerThreadId === 0 || workerData?.addThreadIds?.includes(preparation.ownerThreadId)
+);
+const databaseDropPreparations = new Map<string, DatabaseDropPreparation>(inheritedDatabaseDropPreparations);
+
+class DatabaseDroppingError extends Error {
+	statusCode = 409;
+	code = 'DATABASE_DROP_IN_PROGRESS';
+	retryable = true;
+	constructor(databaseName: string) {
+		super(`Database '${databaseName}' is already being dropped`);
+		this.name = 'DatabaseDroppingError';
+	}
+}
+
+export function claimDatabaseDropPreparation(
+	rootPath: string,
+	preparationId: string,
+	ownerThreadId = threadId,
+	databaseName = rootPath
+): boolean {
+	const current = databaseDropPreparations.get(rootPath);
+	if (current?.id === preparationId) return false;
+	if (current) {
+		throw new DatabaseDroppingError(current.databaseName);
+	}
+	databaseDropPreparations.set(rootPath, { id: preparationId, ownerThreadId, databaseName });
+	return true;
+}
+
+export function releaseDatabaseDropPreparation(rootPath: string, preparationId: string): void {
+	if (databaseDropPreparations.get(rootPath)?.id === preparationId) databaseDropPreparations.delete(rootPath);
+}
+
+export function claimDatabaseDropPreparations(
+	rootPaths: Iterable<string>,
+	preparationId: string,
+	ownerThreadId = threadId,
+	databaseName?: string
+): void {
+	const claimed: string[] = [];
+	try {
+		for (const rootPath of new Set(rootPaths)) {
+			if (claimDatabaseDropPreparation(rootPath, preparationId, ownerThreadId, databaseName)) claimed.push(rootPath);
+		}
+	} catch (error) {
+		for (const rootPath of claimed) releaseDatabaseDropPreparation(rootPath, preparationId);
+		throw error;
+	}
+}
+
+export function releaseDatabaseDropPreparations(rootPaths: Iterable<string>, preparationId: string): void {
+	for (const rootPath of new Set(rootPaths)) releaseDatabaseDropPreparation(rootPath, preparationId);
+}
+
+export function trackDatabaseDropPreparationTask(
+	rootPath: string,
+	preparationId: string,
+	preparationTask: Promise<void>
+): void {
+	const preparation = databaseDropPreparations.get(rootPath);
+	if (preparation?.id !== preparationId) return;
+	preparation.preparationTask = preparationTask;
+	if (preparation.ownerExited) {
+		const release = () => releaseDatabaseDropPreparation(rootPath, preparationId);
+		preparationTask.then(release, release);
+	}
+}
+
+export function handleDatabaseDropPreparationOwnerExit(ownerThreadId: number): void {
+	for (const [rootPath, preparation] of databaseDropPreparations) {
+		if (preparation.ownerThreadId !== ownerThreadId) continue;
+		preparation.ownerExited = true;
+		if (preparation.preparationTask) {
+			const release = () => releaseDatabaseDropPreparation(rootPath, preparation.id);
+			preparation.preparationTask.then(release, release);
+		} else databaseDropPreparations.delete(rootPath);
+	}
+}
+
+export function databaseDropPrepared(rootPath: string): boolean {
+	return databaseDropPreparations.size > 0 && databaseDropPreparations.has(rootPath);
+}
+
+export function databaseDropPreparedWithin(directoryPath: string): boolean {
+	if (databaseDropPreparations.size === 0) return false;
+	const normalizedDirectoryPath = resolve(directoryPath);
+	for (const rootPath of databaseDropPreparations.keys()) {
+		if (resolve(dirname(rootPath)) === normalizedDirectoryPath) return true;
+	}
+	return false;
+}
+
+export function databaseDropPreparationSnapshot(): [
+	string,
+	Pick<DatabaseDropPreparation, 'id' | 'ownerThreadId' | 'databaseName'>,
+][] {
+	const snapshot: [string, Pick<DatabaseDropPreparation, 'id' | 'ownerThreadId' | 'databaseName'>][] = [];
+	for (const [rootPath, preparation] of databaseDropPreparations) {
+		if (!preparation.ownerExited)
+			snapshot.push([
+				rootPath,
+				{ id: preparation.id, ownerThreadId: preparation.ownerThreadId, databaseName: preparation.databaseName },
+			]);
+	}
+	return snapshot;
+}