@postedin/cms-client 0.1.0

package/src/collections/posts.ts

@@ -0,0 +1,249 @@
+import type { Context } from '../context';
+import { TfIdf } from 'natural/lib/natural/tfidf/index.js';
+import type { Author, Category, Media, Post, Tag } from '../payload-types';
+import type { Locale } from '../locales';
+import type { WiredCategory } from './categories';
+import { createCollectionLoader } from '../loader';
+import type { WiredTag } from './tags';
+
+export interface WiredPost extends Post {
+	coverImage?: Media | null;
+	category?: WiredCategory | null;
+	secondaryCategories?: WiredCategory[];
+	tags?: WiredTag[];
+	searchTokens: string;
+}
+
+export async function wirePost(
+	ctx: Context,
+	post: Post | undefined,
+	locale: Locale,
+	tags: Tag[] = [],
+): Promise<WiredPost | undefined> {
+	if (!post) {
+		return undefined;
+	}
+
+	let coverImage = post.coverImage;
+	if (typeof coverImage === 'string') {
+		// TODO: I think we need to be getting the actual image here instead
+		coverImage = undefined;
+	}
+
+	const postTags = post.tags
+		?.map((tag) =>
+			typeof tag === 'string' ? tags.find((t) => t.id === tag) : tag,
+		)
+		.filter((tag): tag is WiredTag => tag !== undefined);
+
+	const cms = ctx.cms(locale);
+
+	const secondaryCategories = (
+		await Promise.all(
+			(post.secondaryCategories ?? []).map((c) =>
+				cms.categories.wire(c as Category | string),
+			),
+		)
+	).filter((c): c is WiredCategory => c != null);
+
+	const category = await cms.categories.wire(post.category);
+	const categoryTitles = [category, ...secondaryCategories]
+		.filter((c): c is WiredCategory => c != null)
+		.map((c) => c.title);
+
+	return {
+		...post,
+		category,
+		secondaryCategories,
+		coverImage,
+		tags: postTags,
+		searchTokens: `${post.title} ${categoryTitles.join(' ')}`,
+	};
+}
+
+// Only top-level team-member blocks with filter='custom' are indexed.
+// Nested blocks (inside tabs/columns) are intentionally out of scope.
+function collectCustomTeamMemberIds(post: WiredPost): string[] {
+	const ids: string[] = [];
+	for (const block of post.contentBlocks ?? []) {
+		if (block.blockType !== 'team-member') {
+			continue;
+		}
+		if (block.filter !== 'custom') {
+			continue;
+		}
+		for (const m of block.members ?? []) {
+			const id = typeof m === 'string' ? m : m?.id;
+			if (id) {
+				ids.push(id);
+			}
+		}
+	}
+	return ids;
+}
+
+export default function (ctx: Context, locale: Locale) {
+	const tfIdf = new TfIdf();
+	const keyedPosts: Record<string, WiredPost> = {};
+	let teamMemberIndex: Promise<Map<string, WiredPost[]>> | null = null;
+
+	const posts = createCollectionLoader(
+		async () =>
+			ctx.api.fetchCmsCollection<Post>('posts', {
+				status: 'published',
+				sort: '-publishDate',
+				locale,
+			}) || [],
+		{
+			transform: async (posts): Promise<WiredPost[]> => {
+				// Lazy-resolve cms here (not at factory call time) to avoid the
+				// circular init: createCms → buildCms → posts() → createCms → ...
+				const cms = ctx.cms(locale);
+				const tags = await cms.tags.all();
+
+				const wiredPosts = await Promise.all(
+					posts
+						?.filter((post) => post.slug)
+						.map(async (post) => {
+							return wirePost(ctx, post, locale, tags) as Promise<WiredPost>;
+						}) || [],
+				);
+
+				const currentYear = new Date().getFullYear();
+
+				// we don't want every post used for performance reasons so instead use the last 4 years of
+				// posts and if there are less than 200 then keep going until we have 100
+				wiredPosts.forEach((post) => {
+					if (
+						post.publishDate &&
+						(new Date(post.publishDate).getFullYear() > currentYear - 4 ||
+							tfIdf.documents.length < 200)
+					) {
+						tfIdf.addDocument(post.searchTokens, post.id);
+						keyedPosts[post.id] = post;
+					}
+				});
+
+				return wiredPosts;
+			},
+		},
+	);
+
+	return {
+		all: posts,
+		exists: async () => !!(await posts()).length,
+		page: async (...args: Parameters<typeof posts.page>) => {
+			return posts.page(...args);
+		},
+		latest: async () => {
+			return posts.page(1, 6);
+		},
+		featured: async () => {
+			return (await posts()).filter((post) => post.featured).slice(0, 10);
+		},
+		// TF-IDF similarity over title + category titles. When similarity
+		// yields fewer than `limit` posts, pad with the latest posts from the
+		// same category (newest first, secondary categories count too).
+		related: async (post: WiredPost, limit: number = 6) => {
+			const scores: { score: number; postId: string }[] = [];
+			tfIdf.tfidfs(post.searchTokens, (_, score, postId) => {
+				scores.push({
+					postId: postId as string,
+					score,
+				});
+			});
+
+			const similar = scores
+				.filter((entry) => entry.postId !== post.id && entry.score > 0)
+				.sort((a, b) => b.score - a.score)
+				.slice(0, limit)
+				.map((entry) => keyedPosts[entry.postId]);
+
+			if (similar.length >= limit) {
+				return similar;
+			}
+
+			const categoryId = post.category?.id;
+			const seen = new Set(similar.map((p) => p.id));
+			const fromCategory = await posts.filter(
+				(p) =>
+					p.id !== post.id &&
+					!seen.has(p.id) &&
+					(!categoryId ||
+						p.category?.id === categoryId ||
+						(p.secondaryCategories ?? []).some(
+							(c: WiredCategory) => c.id === categoryId,
+						)),
+			);
+			return [...similar, ...fromCategory.slice(0, limit - similar.length)];
+		},
+		findBySlug: async (slug: string) => {
+			return posts.find((post) => post.slug === slug);
+		},
+		findByAuthor: async (author: Author) => {
+			return posts.filter((post) => post.author?.id === author.id);
+		},
+		findByTeamMember: async (memberId: string) => {
+			if (!teamMemberIndex) {
+				teamMemberIndex = (async () => {
+					const all = await posts();
+					const index = new Map<string, WiredPost[]>();
+					for (const post of all) {
+						for (const id of collectCustomTeamMemberIds(post)) {
+							const list = index.get(id);
+							if (list) {
+								list.push(post);
+							} else {
+								index.set(id, [post]);
+							}
+						}
+					}
+					for (const list of index.values()) {
+						list.sort(
+							(a, b) =>
+								new Date(b.publishDate ?? 0).getTime() -
+								new Date(a.publishDate ?? 0).getTime(),
+						);
+					}
+					return index;
+				})();
+			}
+			return (await teamMemberIndex).get(memberId) ?? [];
+		},
+		findByCategory: async (category: Category) => {
+			return posts.filter(
+				(post) =>
+					post.category === category.id ||
+					(post.category as Category)?.id === category.id ||
+					(post.secondaryCategories ?? []).some(
+						(c: WiredCategory) => c.id === category.id,
+					),
+			);
+		},
+		findByTag: async (tag: Tag) => {
+			return posts.filter((post) => {
+				return post.tags?.some((postTag: WiredTag) => postTag.id === tag.id);
+			});
+		},
+		nextInCategory: async (post: WiredPost): Promise<WiredPost | undefined> => {
+			if (!post.category) {
+				return undefined;
+			}
+			const allCategoryIds = new Set([
+				(post.category as Category).id,
+				...(post.secondaryCategories ?? []).map((c) => c.id),
+			]);
+			const categoryPosts = await posts.filter(
+				(p) =>
+					allCategoryIds.has((p.category as Category)?.id ?? '') ||
+					(p.secondaryCategories ?? []).some((c: WiredCategory) =>
+						allCategoryIds.has(c.id),
+					),
+			);
+			const idx = categoryPosts.findIndex((p) => p.id === post.id);
+			return idx >= 0 && idx + 1 < categoryPosts.length
+				? categoryPosts[idx + 1]
+				: undefined;
+		},
+	};
+}

package/src/collections/project.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../context';
+import { createGlobalLoader } from '../loader';
+import type { Project } from '../payload-types';
+
+// The project document is fetched once, at config time, and handed to
+// `createClient`. It is the same for every locale.
+export default function (ctx: Context) {
+	return createGlobalLoader(async () => {
+		if (!ctx.options.project) {
+			throw new Error(
+				'cms.project() needs the `project` option of createClient: the Project document fetched at config time.',
+			);
+		}
+		return ctx.options.project as Project;
+	});
+}

package/src/collections/questions.ts

@@ -0,0 +1,35 @@
+import type { Context } from '../context';
+import type { Question, QuestionTag } from '../payload-types';
+import type { Locale } from '../locales';
+import { createCollectionLoader } from '../loader';
+
+export interface WiredQuestion extends Omit<Question, 'tags'> {
+	tags: QuestionTag[];
+}
+
+export default function (ctx: Context, locale: Locale) {
+	const questions = createCollectionLoader(
+		async () =>
+			ctx.api.fetchCmsCollection<Question>('questions', {
+				locale,
+				sort: '_questions_questions_order',
+			}),
+		{
+			transform: (questions) => {
+				const validQuestions = questions.filter((question) => question.tags);
+				return validQuestions as WiredQuestion[];
+			},
+		},
+	);
+
+	return {
+		all: questions,
+		filterByTag: async (searchTag: QuestionTag) => {
+			return questions.filter((question: WiredQuestion) =>
+				question.tags.some((tag) => {
+					return tag.id === searchTag.id;
+				}),
+			);
+		},
+	};
+}

package/src/collections/seo.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../context';
+import type { Seo } from '../payload-types';
+import type { Locale } from '../locales';
+import { createGlobalLoader } from '../loader';
+
+export default function (ctx: Context, locale: Locale) {
+	return createGlobalLoader(async () =>
+		ctx.api.fetchCmsGlobalCollection<Seo>('seo', { locale }),
+	);
+}

package/src/collections/tags.ts

@@ -0,0 +1,25 @@
+import type { Context } from '../context';
+import type { Tag } from '../payload-types';
+import type { Locale } from '../locales';
+import { createCollectionLoader } from '../loader';
+
+export interface WiredTag extends Tag {}
+
+export default function (ctx: Context, locale: Locale) {
+	const tags = createCollectionLoader(
+		async () => ctx.api.fetchCmsCollection<Tag>('tags', { locale }),
+		{
+			transform: (tags) => {
+				const validTags = tags.filter((tag) => tag.slug);
+				return validTags as WiredTag[];
+			},
+		},
+	);
+
+	return {
+		all: tags,
+		findBySlug: async (slug: string) => {
+			return tags.find((tag) => tag.slug === slug);
+		},
+	};
+}

package/src/collections/team-members.ts

@@ -0,0 +1,79 @@
+import type { Context } from '../context';
+import type { MemberType, TeamMember } from '../payload-types';
+import type { Locale } from '../locales';
+import type { WiredArea } from './areas';
+import { createCollectionLoader } from '../loader';
+
+export interface WiredTeamMember extends Omit<TeamMember, 'slug' | 'areas'> {
+	slug: string;
+	// Built from `memberAreas` at wire time. Kept under `areas` for backward
+	// compatibility with consumers that read `member.areas.docs` (the shape
+	// Payload's `join` field used to produce before the schema flipped to a
+	// member-side `memberAreas` array).
+	areas?: {
+		docs?: (string | WiredArea)[];
+		hasNextPage?: boolean;
+		totalDocs?: number;
+	};
+}
+
+export default function (ctx: Context, locale: Locale) {
+	const members = createCollectionLoader(
+		async () =>
+			ctx.api.fetchCmsCollection<TeamMember>('team-members', {
+				sort: '_order',
+				locale,
+			}),
+		{
+			transform: async (members): Promise<WiredTeamMember[]> => {
+				const allAreas = await ctx.cms(locale).areas.all();
+				const areaById = new Map(allAreas.map((a) => [a.id, a]));
+
+				return members
+					.filter((m) => m.slug)
+					.map((m): WiredTeamMember => {
+						const docs: (string | WiredArea)[] = [];
+						for (const row of m.memberAreas ?? []) {
+							const ref = row.area;
+							const id = typeof ref === 'string' ? ref : ref.id;
+							const hit = areaById.get(id);
+							if (hit) {
+								docs.push(hit);
+							} else if (typeof ref === 'string') {
+								docs.push(ref);
+							} else {
+								docs.push({
+									...ref,
+									page: typeof ref.page === 'object' ? ref.page : null,
+								} as WiredArea);
+							}
+						}
+
+						return {
+							...m,
+							areas: {
+								docs,
+								hasNextPage: false,
+								totalDocs: docs.length,
+							},
+						} as WiredTeamMember;
+					});
+			},
+		},
+	);
+
+	const memberTypes = createCollectionLoader(() =>
+		ctx.api.fetchCmsCollection<MemberType>('member-types', {
+			sort: '_order',
+			locale,
+		}),
+	);
+
+	return {
+		all: members,
+		types: memberTypes,
+		findBySlug: async (slug: string) => {
+			return members.find((m) => m.slug === slug);
+		},
+	};
+}

package/src/config-time.ts

@@ -0,0 +1,98 @@
+import type { Api } from './api';
+import type {
+	Appearance,
+	Media,
+	Options,
+	Project,
+	Redirect,
+} from './payload-types';
+import type { Routes } from './routes';
+
+function createRedirect(
+	routes: Routes,
+	from: string,
+	to: Redirect['to'],
+): Record<string, string> | undefined {
+	if (!to) {
+		return;
+	}
+
+	// These things should never be null but checking anyway for ts
+	if (to.type === 'custom') {
+		if (!to.url) {
+			return;
+		}
+
+		return { [from]: to.url };
+	} else if (!to.reference) {
+		return;
+	} else if (typeof to.reference.value === 'string') {
+		return;
+	}
+
+	switch (to.reference.relationTo) {
+		// NOTE: astro doesn't support external redirects so if this is that then it won't work
+		case 'pages':
+			return to.reference.value.slug
+				? { [from]: routes.page(to.reference.value.slug) }
+				: undefined;
+		case 'categories':
+			return to.reference.value.slug
+				? { [from]: routes.blog('category', to.reference.value.slug as string) }
+				: undefined;
+		default:
+			return;
+	}
+}
+
+export function createConfigTime(api: Api, defaultRoutes: Routes) {
+	return {
+		/** The three documents the Astro config and `createClient` need. */
+		async fetchProjectSettings(): Promise<{
+			project: Project;
+			appearance: Appearance;
+			options: Options;
+		}> {
+			const [project, appearance, options] = await Promise.all([
+				api.fetchCmsProject(),
+				api.fetchCmsGlobalCollection<Appearance>('appearance', { depth: 2 }),
+				api.fetchCmsGlobalCollection<Options>('options', { depth: 2 }),
+			]);
+
+			return { project, appearance, options };
+		},
+
+		// Redirects are emitted once at build time for the whole site. Use the
+		// default locale — prefixed paths are handled by page routing, not the
+		// redirect table.
+		async redirects(): Promise<Record<string, string>> {
+			const docs = await api.fetchCmsCollection<Redirect>('redirects', {
+				depth: 2,
+				limit: 1000,
+			});
+
+			return Object.assign(
+				{},
+				...(docs
+					?.map(({ from, to }) => createRedirect(defaultRoutes, from, to))
+					.filter(Boolean) ?? []),
+			);
+		},
+
+		/** The favicon source file, or `false` when there is none to read. */
+		async fetchIconBuffer(icon: Media) {
+			if (icon.url) {
+				const response = await fetch(
+					icon.url.startsWith('/') ? api.apiUrl(icon.url, {}, false) : icon.url,
+					{ headers: api.buildHeaders() },
+				);
+
+				if (response.ok) {
+					return Buffer.from(await response.arrayBuffer());
+				}
+			}
+
+			return false as const;
+		},
+	};
+}

package/src/context.ts

@@ -0,0 +1,12 @@
+import type { Api } from './api';
+import type { Cms } from './cms';
+import type { ClientOptions } from './client';
+import type { Locale, Locales } from './locales';
+
+/** What every collection service is built from. Internal to the package. */
+export interface Context {
+	api: Api;
+	locales: Locales;
+	options: ClientOptions<any>;
+	cms: (locale: Locale) => Cms;
+}

package/src/decode-html.ts

@@ -0,0 +1,8 @@
+export function decodeHtml(str: string): string {
+	return str
+		.replace(/&/g, '&')
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'");
+}

package/src/form-proxy/cms-client.ts

@@ -0,0 +1,95 @@
+import type { Api } from '../api';
+import type { Locale } from '../locales';
+import type { Form } from '../payload-types';
+import { refusedFieldNames } from './cms-errors';
+import type { SubmissionsCmsClient } from './submissions';
+import type { CmsResult } from './types';
+import type { UploadsCmsClient } from './uploads';
+
+// Writes made on behalf of anonymous visitors. Every request pins depth=0 so
+// the CMS never populates the project relationship (which carries deploy
+// hooks and tokens) into a response we hold in memory, and callers only ever
+// get back the status, the new document id, and the names of any fields a
+// refusal named.
+//
+// depth=0 is belt and braces on a create since postedin/cms#279: the CMS
+// depopulates a submission's create response itself, so `form` and `project`
+// come back as bare ids whatever depth is asked for. Nothing here ever read
+// them — only `doc.id` — and nothing should start.
+async function stripToStatusAndId(res: Response): Promise<CmsResult> {
+	let body: unknown;
+	try {
+		body = await res.json();
+	} catch {
+		return { status: res.status };
+	}
+
+	if (!res.ok) {
+		return { status: res.status, fields: refusedFieldNames(body) };
+	}
+
+	const doc = body as { doc?: { id?: unknown }; id?: unknown } | null;
+	const id = doc?.doc?.id ?? doc?.id;
+	return { status: res.status, id: typeof id === 'string' ? id : undefined };
+}
+
+export type FormProxyCmsClient = SubmissionsCmsClient & UploadsCmsClient;
+
+export function createFormProxyCmsClient(
+	api: Pick<Api, 'buildHeaders' | 'fetchCmsCollection'>,
+	apiUrl: string,
+): FormProxyCmsClient {
+	function writeUrl(path: string, locale?: Locale) {
+		const url = new URL(path, apiUrl);
+		url.searchParams.set('depth', '0');
+		if (locale) {
+			url.searchParams.set('locale', locale);
+		}
+		return url;
+	}
+
+	// Only forms of this project are visible: fetchCmsCollection scopes every
+	// query to the client's project, so a foreign form id simply comes back empty.
+	async function formBelongsToProject(formId: string): Promise<boolean> {
+		if (!/^[a-zA-Z0-9_-]+$/.test(formId)) {
+			return false;
+		}
+		const docs = await api.fetchCmsCollection<Pick<Form, 'id'>>('forms', {
+			depth: 0,
+			limit: 1,
+			query: { where: { id: { equals: formId } } },
+		});
+		return docs.some((doc) => doc.id === formId);
+	}
+
+	return {
+		formBelongsToProject,
+
+		async createSubmission(payload, locale?: Locale) {
+			// `project` is still sent: the CMS derives the tenant from the form and
+			// ignores what the body says, but an older deployment of it does not.
+			const res = await fetch(writeUrl('/api/form-submissions', locale), {
+				method: 'POST',
+				headers: { ...api.buildHeaders(), 'Content-Type': 'application/json' },
+				body: JSON.stringify(payload),
+			});
+			return stripToStatusAndId(res);
+		},
+
+		// `form` in the payload is dropped by the CMS — the field is server-written
+		// there, and an upload carries no form until the submission claiming it
+		// arrives. It is sent anyway so an older CMS still records it, and nothing
+		// on this side reads it back.
+		async createUpload(file, payload) {
+			const body = new FormData();
+			body.append('file', file, file.name);
+			body.append('_payload', JSON.stringify(payload));
+			const res = await fetch(writeUrl('/api/form-uploads'), {
+				method: 'POST',
+				headers: api.buildHeaders(),
+				body,
+			});
+			return stripToStatusAndId(res);
+		},
+	};
+}