@lovrozagar/flare 0.1.0

package/src/revalidation/index.ts

@@ -0,0 +1,84 @@
+import { getRevalidationContext } from "@lovrozagar/flare/server-context";
+import type { FlareStore } from "../store/index.ts";
+
+export type RevalidateFn = (options: RevalidateOptions) => Promise<void>;
+
+export type RevalidationTier = "cdn" | "ssr";
+
+export interface RevalidateOptions {
+	callerData?: unknown;
+	keys?: string[];
+	tags?: string[];
+	tiers: RevalidationTier[];
+}
+
+export interface CdnPurgeAdapter {
+	purgeByKeys?(keys: string[], callerData?: unknown): Promise<void>;
+	purgeByTags(tags: string[], callerData?: unknown): Promise<void>;
+}
+
+export interface CreateRevalidateFnConfig {
+	cdnPurgeAdapter?: CdnPurgeAdapter;
+	store?: FlareStore;
+}
+
+export function createRevalidateFn(config: CreateRevalidateFnConfig): RevalidateFn {
+	return async (options: RevalidateOptions) => {
+		const { callerData, keys, tags, tiers } = options;
+		const promises: Promise<void>[] = [];
+
+		for (const tier of tiers) {
+			if (tier === "ssr") {
+				if (!config.store) {
+					throw new Error(
+						"Revalidation tier 'ssr' not configured. Provide a FlareStore via createRevalidateFn({ store: ... }).",
+					);
+				}
+				if (tags && tags.length > 0) {
+					promises.push(config.store.deleteByTags(tags, callerData));
+				}
+				if (keys && keys.length > 0) {
+					if (config.store.deleteByKeys) {
+						promises.push(config.store.deleteByKeys(keys, callerData));
+					} else {
+						for (const key of keys) {
+							promises.push(config.store.delete(key));
+						}
+					}
+				}
+			} else if (tier === "cdn") {
+				if (!config.cdnPurgeAdapter) {
+					throw new Error(
+						"Revalidation tier 'cdn' not configured. Provide a CdnPurgeAdapter via createRevalidateFn({ cdnPurgeAdapter: ... }).",
+					);
+				}
+				if (tags && tags.length > 0) {
+					promises.push(config.cdnPurgeAdapter.purgeByTags(tags, callerData));
+				}
+				if (keys && keys.length > 0) {
+					if (config.cdnPurgeAdapter.purgeByKeys) {
+						promises.push(config.cdnPurgeAdapter.purgeByKeys(keys, callerData));
+					}
+				}
+			}
+		}
+
+		const results = await Promise.allSettled(promises);
+		const errors = results
+			.filter((r): r is PromiseRejectedResult => r.status === "rejected")
+			.map((r) => r.reason as Error);
+		if (errors.length > 0) {
+			const msg = errors.map((e) => e.message).join("; ");
+			throw new AggregateError(errors, `Revalidation failed: ${msg}`);
+		}
+	};
+}
+
+/**
+ * Importable revalidate() — reads adapters from ALS, works anywhere in request scope.
+ */
+export function revalidate(options: RevalidateOptions): Promise<void> {
+	const ctx = getRevalidationContext();
+	const fn = createRevalidateFn(ctx);
+	return fn(options);
+}

package/src/rewrite/index.ts

@@ -0,0 +1,83 @@
+export type RewriteFn = (ctx: { url: URL }) => URL | string | undefined;
+
+export interface LocationRewrite {
+	input?: RewriteFn;
+	output?: RewriteFn;
+}
+
+export function executeRewriteInput(rewrite: LocationRewrite | undefined, url: URL): URL {
+	try {
+		const result = rewrite?.input?.({ url });
+		if (result === undefined) return url;
+		if (typeof result === "string") return new URL(result, url);
+		return result;
+	} catch {
+		return url;
+	}
+}
+
+export function executeRewriteOutput(rewrite: LocationRewrite | undefined, url: URL): URL {
+	try {
+		const result = rewrite?.output?.({ url });
+		if (result === undefined) return url;
+		if (typeof result === "string") return new URL(result, url);
+		return result;
+	} catch {
+		return url;
+	}
+}
+
+export function composeRewrites(rewrites: LocationRewrite[]): LocationRewrite {
+	if (rewrites.length === 0) {
+		return {};
+	}
+
+	if (rewrites.length === 1) {
+		return rewrites[0] ?? {};
+	}
+
+	return {
+		input: ({ url }) => {
+			let current = url;
+			for (const rewrite of rewrites) {
+				current = executeRewriteInput(rewrite, current);
+			}
+			return current;
+		},
+		output: ({ url }) => {
+			let current = url;
+			for (let i = rewrites.length - 1; i >= 0; i--) {
+				current = executeRewriteOutput(rewrites[i], current);
+			}
+			return current;
+		},
+	};
+}
+
+export function rewriteBasePath(opts: { basePath: string; caseSensitive?: boolean }): LocationRewrite {
+	/* normalize: strip trailing slash */
+	const bp = opts.basePath.endsWith("/") ? opts.basePath.slice(0, -1) : opts.basePath;
+
+	return {
+		input: ({ url }) => {
+			const pathname = url.pathname;
+			const prefix =
+				opts.caseSensitive === false ? pathname.toLowerCase().startsWith(bp.toLowerCase()) : pathname.startsWith(bp);
+
+			if (!prefix) return undefined;
+
+			/* ensure match is at segment boundary: /app/x matches, /application does not */
+			const rest = pathname.slice(bp.length);
+			if (rest !== "" && !rest.startsWith("/")) return undefined;
+
+			const next = new URL(url);
+			next.pathname = rest || "/";
+			return next;
+		},
+		output: ({ url }) => {
+			const next = new URL(url);
+			next.pathname = url.pathname === "/" ? bp : `${bp}${url.pathname}`;
+			return next;
+		},
+	};
+}