feat: use `com.atproto.repo.applyWrites`

README.md

···
 
 ⚠️ **Now with Auto-Publishing!** - Log in to automatically fetch your WhiteWind entries and publish directly to Leaflet.
 
+## ⚠️ IMPORTANT: Untested Implementation
+
+**The auto-publishing feature now uses `com.atproto.repo.applyWrites` for batch operations, which is currently UNTESTED.**
+
+- The implementation has been refactored to use batch writes (up to 10 records per API call)
+- This should dramatically reduce publishing time for large blogs
+- **However, this has not been tested in production**
+- Please test with a small number of posts first (1-5 entries)
+- Consider using Manual Mode and pdsls.dev for critical migrations
+- Report any issues on the GitHub repository
+
+If you need the stable version using individual `createRecord` calls, check out the previous commit.
+
 ---
 
 ## ✨ Features
···
 
 This ensures compliance with Leaflet's required `aspectRatio` field.
 
-### AT Protocol Authentication
+### AT Protocol Authentication & Publishing
 
 Uses `@atproto/api` for secure authentication:
 
···
 - Supports app passwords (2FA-compatible)
 - Session management with localStorage
 - Automatic PDS URL resolution
+
+**Publishing:**
+- Uses `com.atproto.repo.applyWrites` for efficient batch operations
+- Processes up to 10 records per API call (maximum allowed)
+- Dramatically reduces API calls compared to individual `createRecord` operations
+- **Note:** This batch publishing implementation is currently untested
 
 ---
 

src/lib/auth.ts

···
 }
 
 /**
- * Creates a new Leaflet publication
- */
-export async function createPublication(publication: any, rkey: string): Promise<string> {
-	if (!agent || !agent.session) {
-		throw new Error('Not logged in. Cannot create publication.');
-	}
-
-	try {
-		await agent.com.atproto.repo.createRecord({
-			repo: agent.session.did,
-			collection: 'pub.leaflet.publication',
-			rkey: rkey,
-			record: publication
-		});
-
-		return `at://${agent.session.did}/pub.leaflet.publication/${rkey}`;
-	} catch (e) {
-		console.error('Failed to create publication:', e);
-		throw new Error(
-			`Failed to create publication: ${e instanceof Error ? e.message : 'Unknown error'}`
-		);
-	}
-}
-
-/**
- * Creates a new Leaflet document
+ * Maximum operations allowed per applyWrites call
+ * See: https://github.com/bluesky-social/atproto/pull/1571
  */
-export async function createDocument(document: any, rkey: string): Promise<string> {
-	if (!agent || !agent.session) {
-		throw new Error('Not logged in. Cannot create document.');
-	}
-
-	try {
-		await agent.com.atproto.repo.createRecord({
-			repo: agent.session.did,
-			collection: 'pub.leaflet.document',
-			rkey: rkey,
-			record: document
-		});
-
-		return `at://${agent.session.did}/pub.leaflet.document/${rkey}`;
-	} catch (e) {
-		console.error('Failed to create document:', e);
-		throw new Error(
-			`Failed to create document: ${e instanceof Error ? e.message : 'Unknown error'}`
-		);
-	}
-}
+const MAX_APPLY_WRITES_OPS = 10;
 
 /**
- * Publishes all converted documents to AT Protocol
+ * Publishes all converted documents to AT Protocol using applyWrites for efficient batching
  */
 export async function publishToAtProto(
 	publicationRecord: any | null,
···
 	}
 
 	try {
-		// Create publication if provided
+		const repo = agent.session.did;
+		const allWrites: any[] = [];
+
+		// Add publication creation if provided
 		if (publicationRecord) {
-			onProgress?.(0, documents.length + 1, 'Creating publication...');
-			await createPublication(publicationRecord, publicationRecord.rkey);
+			allWrites.push({
+				$type: 'com.atproto.repo.applyWrites#create',
+				collection: 'pub.leaflet.publication',
+				rkey: publicationRecord.rkey,
+				value: publicationRecord
+			});
 		}
 
-		// Create each document
-		for (let i = 0; i < documents.length; i++) {
-			const doc = documents[i];
+		// Add all document creations
+		for (const doc of documents) {
+			const { rkey, ...documentWithoutRkey } = doc;
+			allWrites.push({
+				$type: 'com.atproto.repo.applyWrites#create',
+				collection: 'pub.leaflet.document',
+				rkey: rkey,
+				value: documentWithoutRkey
+			});
+		}
+
+		// Process in batches of MAX_APPLY_WRITES_OPS
+		const totalBatches = Math.ceil(allWrites.length / MAX_APPLY_WRITES_OPS);
+		let processedCount = 0;
+
+		for (let i = 0; i < allWrites.length; i += MAX_APPLY_WRITES_OPS) {
+			const batchWrites = allWrites.slice(i, i + MAX_APPLY_WRITES_OPS);
+			const currentBatch = Math.floor(i / MAX_APPLY_WRITES_OPS) + 1;
+
 			onProgress?.(
-				i + (publicationRecord ? 1 : 0),
-				documents.length + (publicationRecord ? 1 : 0),
-				`Publishing document ${i + 1}/${documents.length}...`
+				processedCount,
+				allWrites.length,
+				`Publishing batch ${currentBatch}/${totalBatches} (${batchWrites.length} records)...`
 			);
 
-			// Remove rkey from document before publishing (it's in the URI)
-			const { rkey, ...documentWithoutRkey } = doc;
-			await createDocument(documentWithoutRkey, rkey);
+			try {
+				await agent.com.atproto.repo.applyWrites({
+					repo,
+					writes: batchWrites
+				});
+
+				processedCount += batchWrites.length;
+				onProgress?.(
+					processedCount,
+					allWrites.length,
+					`Batch ${currentBatch}/${totalBatches} complete`
+				);
+			} catch (batchError) {
+				console.error(`Failed to publish batch ${currentBatch}:`, batchError);
+				throw new Error(
+					`Failed to publish batch ${currentBatch}/${totalBatches}: ${batchError instanceof Error ? batchError.message : 'Unknown error'}`
+				);
+			}
 		}
 
-		onProgress?.(
-			documents.length + (publicationRecord ? 1 : 0),
-			documents.length + (publicationRecord ? 1 : 0),
-			'Publishing complete!'
-		);
+		onProgress?.(allWrites.length, allWrites.length, 'Publishing complete!');
 	} catch (e) {
 		console.error('Failed to publish:', e);
 		throw e;