add code for fetching single document

src/leaflet-live-loader.ts

···
+import type { LiveLoader } from "astro/loaders";
+import { Agent } from "@atproto/api";
+import { isDid } from "@atproto/did";
+import { isValidHandle } from "@atproto/syntax";
+import {
+	getLeafletDocuments,
+	getSingleLeafletDocument,
+	resolveMiniDoc,
+	uriToRkey,
+} from "./utils.js";
+import type {
+	CollectionFilter,
+	EntryFilter,
+	LeafletRecord,
+	LiveLoaderOptions,
+} from "./types.js";
+
+export class LiveLoaderError extends Error {
+	constructor(
+		message: string,
+		public code?: string,
+	) {
+		super(message);
+		this.name = "LiveLoaderError";
+	}
+}
+
+/**
+ * Flow:
+ * - Check for valid handle or did [done]
+ * - Resolve PDS url from handle or did [done, thanks Phil!]
+ * - Fetch leaflet documents [done]
+ * - Find out how to use leaflet types here
+ */
+
+export function leafletLiveLoader(
+	options: LiveLoaderOptions,
+): LiveLoader<LeafletRecord, EntryFilter, CollectionFilter, LiveLoaderError> {
+	const { repo } = options;
+
+	if (!repo || typeof repo !== "string") {
+		throw new LiveLoaderError(
+			"missing or invalid handle or did",
+			"MISSING_OR_INVALID_HANDLE_OR_DID",
+		);
+	}
+
+	if (!isValidHandle(repo)) {
+		// not a valid handle, let's check if it's a valid did
+		if (!isDid(repo)) {
+			throw new LiveLoaderError(
+				"invalid handle or did",
+				"INVALID_HANDLE_OR_DID",
+			);
+		}
+	}
+
+	return {
+		name: "leaflet-live-loader",
+		loadCollection: async ({ filter }) => {
+			try {
+				const pds_url = await resolveMiniDoc(repo);
+				const agent = new Agent({ service: pds_url });
+
+				const documents = await getLeafletDocuments({
+					repo,
+					agent,
+					cursor: filter?.cursor,
+					limit: filter?.limit,
+					reverse: filter?.reverse,
+				});
+
+				return {
+					entries: documents.map((document) => ({
+						id: uriToRkey(document.uri),
+						data: document,
+					})),
+				};
+			} catch (error) {
+				return {
+					error: new LiveLoaderError(
+						"could not recover from error, please report on github",
+						"UNRECOVERABLE_ERROR",
+					),
+				};
+			}
+		},
+		loadEntry: async ({ filter }) => {
+			try {
+				if (!filter.id) {
+					return {
+						error: new LiveLoaderError(
+							"must provide an id for specific document",
+							"MISSING_DOCUMENT_ID",
+						),
+					};
+				}
+				const pds_url = await resolveMiniDoc(repo);
+				const agent = new Agent({ service: pds_url });
+				const document = await getSingleLeafletDocument({
+					agent,
+					id: filter.id,
+					repo,
+				});
+
+				return {
+					id: uriToRkey(document.data.uri),
+					data: document.data.value,
+				};
+			} catch {
+				return {
+					error: new LiveLoaderError(
+						"could not recover from error, please report on github",
+						"UNRECOVERABLE_ERROR",
+					),
+				};
+			}
+		},
+	};
+}

src/loader.ts

···
-import type { LiveLoader } from "astro/loaders";
-import { Agent } from "@atproto/api";
-import { isDid } from "@atproto/did";
-import { isValidHandle } from "@atproto/syntax";
-import { getLeafletDocuments, resolveMiniDoc, uriToRkey } from "./utils.js";
-import type { LeafletRecord, LiveLoaderOptions } from "./types.js";
-
-export class LiveLoaderError extends Error {
-	constructor(message: string, reason: string) {
-		super(message);
-		this.name = "LiveLoaderError";
-	}
-}
-
-/**
- * Flow:
- * - Check for valid handle or did [done]
- * - Resolve PDS url from handle or did [done, thanks Phil!]
- * - Fetch leaflet documents [done]
- */
-
-export function leafletLiveLoader(
-	options: LiveLoaderOptions,
-): LiveLoader<LeafletRecord> {
-	const { repo } = options;
-
-	return {
-		name: "leaflet-live-loader",
-		loadCollection: async ({ filter }) => {
-			if (!repo || typeof repo !== "string") {
-				throw new LiveLoaderError(
-					"missing or invalid handle or did",
-					"MISSING_OR_INVALID_IDENTIFIER",
-				);
-			}
-
-			if (!isValidHandle(repo) || !isDid(repo)) {
-				throw new LiveLoaderError(
-					"invalid handle or did",
-					"INVALID_IDENTIFIER",
-				);
-			}
-
-			// we know for sure the handle or did is valid now
-
-			try {
-				const pds_url = await resolveMiniDoc(repo);
-				const agent = new Agent({ service: pds_url });
-
-				const response = await getLeafletDocuments(repo, agent);
-
-				return {
-					entries: response.data.records.map((document) => ({
-						id: uriToRkey(document.uri),
-						data: document,
-					})),
-				};
-			} catch (error) {
-				return {
-					error: new LiveLoaderError(
-						"Could not recover from error, please report on github",
-						"UNRECOVERABLE_ERROR",
-					),
-				};
-			}
-		},
-		loadEntry: async () => {},
-	};
-}

src/types.ts

···
+import type { Agent } from "@atproto/api";
+
 export interface LiveLoaderOptions {
 	/**
 	 * @description Your repo is either your handle (@you.some.url) or your DID (did:plc... or did:web...). You can find this information using: https://pdsls.dev
···
 	pds: string;
 	signing_key: string;
 }
+
+export interface CollectionFilter {
+	limit?: number;
+	reverse?: boolean;
+	cursor?: string;
+}
+
+export interface EntryFilter {
+	id?: string;
+}
+
+export interface GetLeafletDocumentsParams {
+	repo: string;
+	agent: Agent;
+	cursor?: string;
+	limit?: number;
+	reverse?: boolean;
+}
+
+export interface GetSingleLeafletDocumentParams {
+	repo: string;
+	agent: Agent;
+	id: string;
+}

src/utils.ts

···
 import type { Agent } from "@atproto/api";
-import type { MiniDoc } from "./types.js";
-import { LiveLoaderError } from "./loader.js";
+import type {
+	GetLeafletDocumentsParams,
+	GetSingleLeafletDocumentParams,
+	MiniDoc,
+} from "./types.js";
+import { LiveLoaderError } from "./leaflet-live-loader.js";
 
 export function uriToRkey(uri: string) {
 	const rkey = uri.split("/").pop();
···
 	}
 }
 
-export async function getLeafletDocuments(repo: string, agent: Agent) {
+export async function getLeafletDocuments({
+	repo,
+	reverse,
+	cursor,
+	agent,
+	limit,
+}: GetLeafletDocumentsParams) {
 	const response = await agent.com.atproto.repo.listRecords({
 		repo,
 		collection: "pub.leaflet.document",
+		cursor,
+		reverse,
+		limit,
 	});
 
 	if (response.success === false) {
 		throw new LiveLoaderError(
 			"Could not fetch leaflet documents",
 			"FETCH_FAILED",
+		);
+	}
+
+	return response?.data?.records;
+}
+
+export async function getSingleLeafletDocument({
+	agent,
+	repo,
+	id,
+}: GetSingleLeafletDocumentParams) {
+	const response = await agent.com.atproto.repo.getRecord({
+		repo,
+		collection: "pub.leaflet.document",
+		rkey: id,
+	});
+
+	if (response.success === false) {
+		throw new LiveLoaderError(
+			"error fetching document",
+			"DOCUMENT_FETCH_ERROR",
 		);
 	}