sdxc

import { redirect } from "@sdxc/http/response";
import { isFailure } from "@sdxc/result";
import { validate } from "@sdxc/validate";
import { createAction } from "remix/router";

export default createAction(routes.board.create, async (ctx) => {
	let form = await validate(ctx.formData, PostingSchema);
	if (isFailure(form)) return renderBoard(ctx, form.error);

	let posting = await Job.publish(ctx.db, form.data);
	await cache.delete(LISTING_KEY);
	await ctx.jobs.enqueue(jobs.confirm, { id: posting.id });

	ctx.log.set({ posting: { id: posting.id } });
	return redirect(routes.board.index.href(), { status: 303 });
});

import type { ToolMiddleware } from "@sdxc/mcp";

import { WorkerKVCache } from "@sdxc/cache/worker-kv";
import { isSuccess } from "@sdxc/result";

export function cacheToolResults(): ToolMiddleware {
	return async (ctx, next) => {
		let key = await keyFor(ctx.tool.name, ctx.input);
		if (key === null) return next();

		let cache = new WorkerKVCache(env.CACHE, { waitUntil });
		let hit = await cache.read<CallToolResult>(key);
		if (isSuccess(hit) && hit.data !== null) return hit.data;

		let result = await next();
		if (!result.isError) {
			await cache.write(key, result, { ttl: "5 minutes" });
		}
		return result;
	};
}

import { createJobHandler } from "@sdxc/jobs";
import { isFailure } from "@sdxc/result";

export default createJobHandler(jobs.confirm, async (ctx) => {
	let posting = await Job.find(ctx.db, ctx.input.id);
	if (!posting) {
		ctx.log.note("posting.missing");
		return;
	}

	let sent = await mailer.send(new PublishedEmail(posting));
	if (isFailure(sent)) {
		ctx.log.fail(sent.error);
		return;
	}

	ctx.log.set({ confirmation: { posting: posting.id } });
});

import { contextOf } from "@sdxc/auth/remix/context";
import { redirect } from "@sdxc/http/response";
import { Location } from "@sdxc/location";
import { isFailure, wrap } from "@sdxc/result";
import { createAction } from "remix/router";

export default createAction(routes.auth.callback, async (ctx) => {
	let party = relyingParty(ctx.url);
	let grant = await wrap(() => party.callback(contextOf(ctx)));
	if (isFailure(grant)) {
		return ctx.render(<LoginView error={grant.error} />);
	}

	let user = await User.fromProfile(ctx.db, grant.data.profile);
	ctx.log.set({ user: { id: user.id } }).note("auth.signed_in");

	let returnTo = Location.safe(grant.data.returnTo, {
		fallback: routes.dashboard.href(),
	});
	return redirect(returnTo, { status: 303 });
});

import { ok, unauthorized } from "@sdxc/http/response/json";
import { isFailure } from "@sdxc/result";
import * as Webhooks from "@sdxc/webhooks";
import * as s from "remix/data-schema";
import { createAction } from "remix/router";

let InvoiceEvent = s.object({
	type: s.string(),
	amount: s.number(),
});

export default createAction(routes.webhook, async (ctx) => {
	let delivery = await Webhooks.verify(ctx.request, {
		secret: env.WEBHOOK_SECRET,
		schema: InvoiceEvent,
	});
	if (isFailure(delivery)) {
		return unauthorized({ error: "invalid_signature" });
	}

	let { payload } = delivery.data;
	await ctx.jobs.enqueue(jobs.recordInvoice, payload);
	return ok({ received: true });
});

import { xml } from "@sdxc/http/response";
import { RSS } from "@sdxc/rss";
import { links } from "@sdxc/websub/publisher";
import { createAction } from "remix/router";

export default createAction(routes.rss, async (ctx) => {
	let self = new URL("/rss.xml", ctx.url).href;
	let rss = new RSS({
		title: "Articles",
		description: "Everything published here.",
		link: new URL("/articles", ctx.url).href,
		atomLink: [
			{ rel: "self", href: self },
			{ rel: "hub", href: HUB },
		],
	});

	for (let article of await Article.published(ctx.db)) {
		rss.addItem({
			guid: article.id,
			title: article.title,
			description: article.excerpt,
			link: article.url,
			pubDate: article.publishedAt.toUTCString(),
		});
	}

	let headers = { link: links({ hubs: [HUB], self }) };
	return xml(rss.toString(), { headers });
});

import type { Adapter } from "@sdxc/rate-limit";

import { currentLog } from "@sdxc/logger";
import { tooManyRequests } from "@sdxc/rate-limit";
import { isFailure } from "@sdxc/result";

export async function spend(adapter: Adapter, key: string) {
	let result = await adapter.consume(key);
	if (isFailure(result)) {
		currentLog()?.warn("rate_limit.unavailable", { key });
		return null;
	}
	if (result.data.allowed) return null;

	return tooManyRequests(result.data, adapter.window, JSON.stringify({ error: "rate_limited" }), {
		headers: { "Content-Type": "application/json" },
	});
}