@sdxc/micropub

import { created, error, parseOperation } from "@sdxc/micropub";
import { isFailure } from "@sdxc/result";

export async function handlePost(request: Request) {
	let parsed = await parseOperation(request);
	if (isFailure(parsed)) return error("invalid_request", parsed.error.message);

	let operation = parsed.data.body;
	if (operation.action !== "create") return error("invalid_request", "Only creates for now");

	let url = await savePost(operation.type, operation.properties);
	return created(url); // 201, Location: <url>
}

import { error, parseOperation, requiredScopes } from "@sdxc/micropub";
import { isFailure } from "@sdxc/result";

let parsed = await parseOperation(request);
if (isFailure(parsed)) return error("invalid_request", parsed.error.message);

let { body: operation, accessToken } = parsed.data;
if (accessToken === null) return error("unauthorized");

let granted = await verifyToken(accessToken); // your token endpoint or store
if (granted === null) return error("forbidden", "Unknown token");

let scopes = requiredScopes(operation);
if (!scopes.some((scope) => granted.includes(scope))) {
	return error("insufficient_scope", "The token cannot do this", { scope: scopes });
}

import { config, error, parseQuery, source, syndicateTo } from "@sdxc/micropub";
import { isFailure } from "@sdxc/result";

export async function handleGet(request: Request) {
	let parsed = parseQuery(request);
	if (isFailure(parsed)) return error("invalid_request", parsed.error.message);

	let query = parsed.data.body;
	switch (query.q) {
		case "config":
			return config({ mediaEndpoint: "https://example.com/micropub/media", q: ["source"] });
		case "syndicate-to":
			return syndicateTo([]);
		case "source": {
			let item = await loadPost(query.url);
			return item ? source(item, query.properties) : error("invalid_request", "No such post");
		}
		default:
			return error("invalid_request", "Unsupported query");
	}
}

import { error } from "@sdxc/micropub";
import { parseUpload, uploaded } from "@sdxc/micropub/media";
import { isFailure } from "@sdxc/result";

export async function handleUpload(request: Request) {
	let upload = parseUpload(request, { formData: await request.formData(), accept: ["image/*"] });
	if (isFailure(upload)) return error("invalid_request", upload.error.message);

	let url = await storeFile(upload.data.body);
	return uploaded(url); // 201, Location: <url>
}

import type { Micropub } from "@sdxc/micropub";

import { accepted, created, deleted, updated } from "@sdxc/micropub";

export async function applyOperation(operation: Micropub.Operation, queue: boolean) {
	switch (operation.action) {
		case "create": {
			let url = urlFor(operation.commands.slug ?? Date.now().toString(36));
			if (queue) {
				await enqueueCreate(url, operation);
				return accepted(url); // 202
			}
			await savePost(url, operation);
			return created(url); // 201
		}
		case "update": {
			let movedTo = await updatePost(operation);
			return updated(movedTo ?? undefined); // 204, or 201 when the URL changed
		}
		case "delete":
		case "undelete":
			await setDeleted(operation.url, operation.action === "delete");
			return deleted(); // 204
	}
}

import type { MF2 } from "@sdxc/microformats";
import type { Micropub } from "@sdxc/micropub";

export function applyUpdate(item: MF2.Item, update: Micropub.Update): MF2.Item {
	let properties = { ...item.properties, ...update.replace };
	for (let [name, values] of Object.entries(update.add)) {
		properties[name] = [...(properties[name] ?? []), ...values];
	}
	for (let name of update.deleteProperties) delete properties[name];
	for (let [name, values] of Object.entries(update.deleteValues)) {
		let removed = new Set(values.map((value) => JSON.stringify(value)));
		let kept = (properties[name] ?? []).filter((value) => !removed.has(JSON.stringify(value)));
		if (kept.length > 0) properties[name] = kept;
		else delete properties[name];
	}
	return { ...item, properties };
}

import type { Micropub } from "@sdxc/micropub";

export async function prepareCreate(operation: Micropub.Create) {
	let uploaded = await Promise.all((operation.files.photo ?? []).map((file) => storeFile(file)));
	let photos = [...(operation.properties.photo ?? []), ...uploaded];

	return {
		properties: { ...operation.properties, photo: photos },
		slug: operation.commands.slug,
		draft: operation.commands.status === "draft",
		syndicateTo: operation.commands.syndicateTo, // uids from q=syndicate-to
	};
}

import { error, parseOperation } from "@sdxc/micropub";
import { isFailure } from "@sdxc/result";

export async function handle(request: Request, formData: FormData | undefined) {
	let parsed = await parseOperation(request, { formData, maxJsonBytes: 256 * 1024 });
	if (isFailure(parsed)) return error("invalid_request", parsed.error.message);
	return applyOperation(parsed.data.body, false);
}

import type { Micropub } from "@sdxc/micropub";

import { categories, config, error, syndicateTo } from "@sdxc/micropub";

let TARGETS: Micropub.SyndicationTarget[] = [
	{
		uid: "mastodon",
		name: "Mastodon",
		service: { name: "Mastodon", url: "https://joinmastodon.org" },
	},
];

export async function answerQuery(query: Micropub.Query) {
	switch (query.q) {
		case "config":
			return config({
				mediaEndpoint: "https://example.com/micropub/media",
				syndicateTo: TARGETS,
				q: ["source", "syndicate-to", "category"],
				postTypes: [
					{ type: "note", name: "Note" },
					{ type: "photo", name: "Photo" },
				],
			});
		case "syndicate-to":
			return syndicateTo(TARGETS);
		case "category": {
			let prefix = query.filter ?? "";
			let tags = await listTags();
			return categories(tags.filter((tag) => tag.startsWith(prefix)));
		}
		case "extension":
			return error("invalid_request", `Unsupported query ${query.name}`);
		default:
			return error("invalid_request", "Unsupported query");
	}
}

import type { MF2 } from "@sdxc/microformats";
import type { Micropub } from "@sdxc/micropub";

import { error, source } from "@sdxc/micropub";

export async function answerSource(query: Micropub.SourceQuery) {
	let post = await loadStoredPost(query.url);
	if (post === null) return error("invalid_request", "No such post");

	let item: MF2.Item = {
		type: ["h-entry"],
		properties: {
			content: [{ html: post.html, value: post.text }],
			photo: post.photos.map((photo) => ({ value: photo.url, alt: photo.alt })),
		},
	};
	return source(item, query.properties); // whole item, or { properties } with the requested names
}