@ewanc26/atproto 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ewanc26/atproto",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "AT Protocol service layer extracted from ewancroft.uk",
   "author": "Ewan Croft",
   "license": "AGPL-3.0-only",
@@ -35,16 +35,16 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "dev": "tsc --project tsconfig.json --watch",
+    "check": "tsc --noEmit"
+  },
   "peerDependencies": {
     "@atproto/api": ">=0.13.0"
   },
   "devDependencies": {
     "@atproto/api": "^0.19.3",
     "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "build": "tsc --project tsconfig.json",
-    "dev": "tsc --project tsconfig.json --watch",
-    "check": "tsc --noEmit"
   }
-}
+}

package/src/fetch.ts

@@ -12,7 +12,19 @@ import type {
 	TangledReposData,
 	PopfeedReview,
 	PopfeedCreativeWorkType,
-	PopfeedMainCreditRole
+	PopfeedMainCreditRole,
+	SifaProfileData,
+	SifaSkill,
+	SifaProject,
+	SifaLanguage,
+	SifaCertification,
+	SifaExternalAccount,
+	SifaPosition,
+	SifaEducation,
+	SifaVolunteering,
+	SifaHonor,
+	SifaCourse,
+	SifaPublication
 } from './types.js';
 
 export async function fetchProfile(did: string, fetchFn?: typeof fetch): Promise<ProfileData> {
@@ -363,6 +375,295 @@ export async function fetchRecentPopfeedReviews(
 	}
 }
 
+export async function fetchSifaPositions(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaPosition[]> {
+	const cacheKey = `sifa:positions:${did}`;
+	const cached = cache.get<SifaPosition[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.position',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaPosition[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				company: value.company,
+				companyDid: value.companyDid,
+				title: value.title,
+				description: value.description,
+				employmentType: value.employmentType,
+				workplaceType: value.workplaceType,
+				location: value.location,
+				startedAt: value.startedAt,
+				endedAt: value.endedAt,
+				skills: value.skills,
+				isPrimary: value.isPrimary,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			if (!a.startedAt) return 1;
+			if (!b.startedAt) return -1;
+			return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaEducation(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaEducation[]> {
+	const cacheKey = `sifa:education:${did}`;
+	const cached = cache.get<SifaEducation[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.education',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaEducation[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				institution: value.institution,
+				institutionDid: value.institutionDid,
+				degree: value.degree,
+				fieldOfStudy: value.fieldOfStudy,
+				grade: value.grade,
+				activities: value.activities,
+				description: value.description,
+				location: value.location,
+				startedAt: value.startedAt,
+				endedAt: value.endedAt,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			const aEnd = a.endedAt ? new Date(a.endedAt).getTime() : Date.now();
+			const bEnd = b.endedAt ? new Date(b.endedAt).getTime() : Date.now();
+			return bEnd - aEnd;
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaVolunteering(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaVolunteering[]> {
+	const cacheKey = `sifa:volunteering:${did}`;
+	const cached = cache.get<SifaVolunteering[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.volunteering',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaVolunteering[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				organization: value.organization,
+				organizationDid: value.organizationDid,
+				role: value.role,
+				cause: value.cause,
+				description: value.description,
+				startedAt: value.startedAt,
+				endedAt: value.endedAt,
+				uri: record.uri
+			};
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaHonors(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaHonor[]> {
+	const cacheKey = `sifa:honors:${did}`;
+	const cached = cache.get<SifaHonor[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.honor',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaHonor[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				title: value.title,
+				issuer: value.issuer,
+				issuerDid: value.issuerDid,
+				description: value.description,
+				awardedAt: value.awardedAt,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			if (!a.awardedAt) return 1;
+			if (!b.awardedAt) return -1;
+			return new Date(b.awardedAt).getTime() - new Date(a.awardedAt).getTime();
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaCourses(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaCourse[]> {
+	const cacheKey = `sifa:courses:${did}`;
+	const cached = cache.get<SifaCourse[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.course',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaCourse[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				name: value.name,
+				number: value.number,
+				institution: value.institution,
+				education: value.education,
+				uri: record.uri
+			};
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaPublications(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaPublication[]> {
+	const cacheKey = `sifa:publications:${did}`;
+	const cached = cache.get<SifaPublication[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.publication',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaPublication[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				title: value.title,
+				publisher: value.publisher,
+				url: value.url,
+				description: value.description,
+				authors: value.authors,
+				publishedAt: value.publishedAt,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			if (!a.publishedAt) return 1;
+			if (!b.publishedAt) return -1;
+			return new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime();
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
 export async function fetchTangledRepos(
 	did: string,
 	fetchFn?: typeof fetch
@@ -410,3 +711,260 @@ export async function fetchTangledRepos(
 		return null;
 	}
 }
+
+// Sifa Professional Profile fetch functions
+
+export async function fetchSifaProfile(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaProfileData | null> {
+	const cacheKey = `sifa:profile:${did}`;
+	const cached = cache.get<SifaProfileData>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const result = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.getRecord({
+					repo: did,
+					collection: 'id.sifa.profile.self',
+					rkey: 'self'
+				});
+				return response.data;
+			},
+			true,
+			fetchFn
+		);
+
+		if (!result?.value) return null;
+		const value = result.value as any;
+		const data: SifaProfileData = {
+			headline: value.headline,
+			about: value.about,
+			industry: value.industry,
+			location: value.location,
+			openTo: value.openTo || [],
+			preferredWorkplace: value.preferredWorkplace || [],
+			langs: value.langs || [],
+			createdAt: value.createdAt
+		};
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return null;
+	}
+}
+
+export async function fetchSifaSkills(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaSkill[]> {
+	const cacheKey = `sifa:skills:${did}`;
+	const cached = cache.get<SifaSkill[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.skill',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaSkill[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				name: value.name,
+				category: value.category,
+				uri: record.uri
+			};
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaProjects(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaProject[]> {
+	const cacheKey = `sifa:projects:${did}`;
+	const cached = cache.get<SifaProject[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.project',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaProject[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				name: value.name,
+				description: value.description,
+				url: value.url,
+				startedAt: value.startedAt,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			if (!a.startedAt) return 1;
+			if (!b.startedAt) return -1;
+			return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaLanguages(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaLanguage[]> {
+	const cacheKey = `sifa:languages:${did}`;
+	const cached = cache.get<SifaLanguage[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.language',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaLanguage[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				name: value.name,
+				proficiency: value.proficiency,
+				uri: record.uri
+			};
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaCertifications(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaCertification[]> {
+	const cacheKey = `sifa:certifications:${did}`;
+	const cached = cache.get<SifaCertification[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.certification',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaCertification[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				name: value.name,
+				authority: value.authority,
+				issuedAt: value.issuedAt,
+				uri: record.uri
+			};
+		});
+
+		data.sort((a, b) => {
+			if (!a.issuedAt) return 1;
+			if (!b.issuedAt) return -1;
+			return new Date(b.issuedAt).getTime() - new Date(a.issuedAt).getTime();
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}
+
+export async function fetchSifaExternalAccounts(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<SifaExternalAccount[]> {
+	const cacheKey = `sifa:externalAccounts:${did}`;
+	const cached = cache.get<SifaExternalAccount[]>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const records = await withFallback(
+			did,
+			async (agent) => {
+				const response = await agent.com.atproto.repo.listRecords({
+					repo: did,
+					collection: 'id.sifa.profile.externalAccount',
+					limit: 100
+				});
+				return response.data.records;
+			},
+			true,
+			fetchFn
+		);
+
+		const data: SifaExternalAccount[] = records.map((record) => {
+			const value = record.value as any;
+			return {
+				platform: value.platform,
+				url: value.url,
+				label: value.label,
+				feedUrl: value.feedUrl,
+				isPrimary: value.isPrimary,
+				uri: record.uri
+			};
+		});
+
+		cache.set(cacheKey, data);
+		return data;
+	} catch {
+		return [];
+	}
+}

package/src/index.ts

@@ -37,7 +37,21 @@ export type {
 	StandardSiteDocument,
 	StandardSiteDocumentsData,
 	StandardSiteBasicTheme,
-	StandardSiteThemeColor
+	StandardSiteThemeColor,
+	SifaProfileData,
+	SifaSkill,
+	SifaProject,
+	SifaLanguage,
+	SifaCertification,
+	SifaExternalAccount,
+	SifaLocation,
+	SifaPosition,
+	SifaEducation,
+	SifaVolunteering,
+	SifaHonor,
+	SifaCourse,
+	SifaPublication,
+	SifaPublicationAuthor
 } from './types.js';
 
 export {
@@ -47,7 +61,19 @@ export {
 	fetchMusicStatus,
 	fetchKibunStatus,
 	fetchTangledRepos,
-	fetchRecentPopfeedReviews
+	fetchRecentPopfeedReviews,
+	fetchSifaProfile,
+	fetchSifaSkills,
+	fetchSifaProjects,
+	fetchSifaLanguages,
+	fetchSifaCertifications,
+	fetchSifaExternalAccounts,
+	fetchSifaPositions,
+	fetchSifaEducation,
+	fetchSifaVolunteering,
+	fetchSifaHonors,
+	fetchSifaCourses,
+	fetchSifaPublications
 } from './fetch.js';
 
 export {