dineway 0.1.8 → 0.1.11

package/dist/redirects-B69T59hK.mjs

@@ -0,0 +1,499 @@
+import { t as OptionsRepository } from "./options-z8VVg1Ll.mjs";
+import { a as validateDestinationParams, i as matchPattern, n as interpolateDestination, o as validatePattern, r as isPattern, t as compilePattern } from "./patterns-K0DLqWir.mjs";
+import { t as RedirectRepository } from "./redirect-CGl64yOX.mjs";
+import { i as invalidateRedirectCache } from "./cache-DEbQ13c9.mjs";
+
+//#region src/redirects/loops.ts
+/**
+* Redirect loop and chain detection utilities.
+*/
+const DUMMY_SEGMENT = "__p__";
+const SPLAT_RE = /\[\.\.\.(\w+)\]/g;
+const PARAM_RE = /\[(\w+)\]/g;
+function compilePatterns(edges) {
+	const result = [];
+	for (const edge of edges) {
+		if (!edge.enabled || !edge.isPattern) continue;
+		result.push({
+			id: edge.id,
+			compiled: compilePattern(edge.source),
+			destination: edge.destination
+		});
+	}
+	return result;
+}
+function extractPatternSuffix(patternSource) {
+	let result = patternSource.replace(SPLAT_RE, DUMMY_SEGMENT);
+	result = result.replace(PARAM_RE, DUMMY_SEGMENT);
+	return result.split("/").filter(Boolean).slice(1).join("/");
+}
+function generateRepresentatives(template, existingEdges) {
+	if (!(template.match(SPLAT_RE) !== null)) return [template.replace(PARAM_RE, DUMMY_SEGMENT)];
+	const splatIndex = template.indexOf("[...");
+	const prefix = template.slice(0, splatIndex);
+	const reps = [
+		template.replace(SPLAT_RE, DUMMY_SEGMENT).replace(PARAM_RE, DUMMY_SEGMENT),
+		template.replace(SPLAT_RE, `${DUMMY_SEGMENT}/${DUMMY_SEGMENT}`).replace(PARAM_RE, DUMMY_SEGMENT),
+		template.replace(SPLAT_RE, `${DUMMY_SEGMENT}/${DUMMY_SEGMENT}/${DUMMY_SEGMENT}`).replace(PARAM_RE, DUMMY_SEGMENT)
+	];
+	if (existingEdges) for (const edge of existingEdges) {
+		if (!edge.enabled || !edge.isPattern || edge.source === template) continue;
+		const suffix = extractPatternSuffix(edge.source);
+		if (suffix) reps.push(`${prefix}${suffix}`);
+	}
+	return reps;
+}
+function buildGraph(edges) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (edge.enabled) graph.set(edge.source, {
+		destination: edge.destination,
+		id: edge.id
+	});
+	return graph;
+}
+function resolveNext(path, graph, patterns, edges) {
+	const exact = graph.get(path);
+	if (exact) return exact;
+	if (!path.includes("[")) {
+		for (const pattern of patterns) {
+			const params = matchPattern(pattern.compiled, path);
+			if (params) return {
+				destination: interpolateDestination(pattern.destination, params),
+				id: pattern.id
+			};
+		}
+		return null;
+	}
+	for (const pattern of patterns) for (const rep of generateRepresentatives(path, edges)) {
+		const params = matchPattern(pattern.compiled, rep);
+		if (params) return {
+			destination: interpolateDestination(pattern.destination, params),
+			id: pattern.id
+		};
+	}
+	return null;
+}
+function detectLoops(edges) {
+	const graph = buildGraph(edges);
+	const patterns = compilePatterns(edges);
+	const visited = /* @__PURE__ */ new Set();
+	const loopRedirectIds = /* @__PURE__ */ new Set();
+	for (const [startSource] of graph) {
+		if (visited.has(startSource)) continue;
+		const path = [];
+		const pathSet = /* @__PURE__ */ new Set();
+		const pathIds = [];
+		let current = startSource;
+		while (current) {
+			if (pathSet.has(current)) {
+				const loopStart = path.indexOf(current);
+				for (const id of pathIds.slice(loopStart)) loopRedirectIds.add(id);
+				break;
+			}
+			if (visited.has(current)) break;
+			const next = resolveNext(current, graph, patterns, edges);
+			if (!next) break;
+			path.push(current);
+			pathSet.add(current);
+			pathIds.push(next.id);
+			current = next.destination;
+		}
+		for (const node of path) visited.add(node);
+	}
+	return [...loopRedirectIds];
+}
+function findMatchingTemplate(resolvedPath, patterns) {
+	for (const pattern of patterns) if (matchPattern(pattern.compiled, resolvedPath) !== null) return pattern.compiled.source;
+	return null;
+}
+function wouldCreateLoop(source, destination, existingEdges, excludeId) {
+	const filtered = excludeId ? existingEdges.filter((edge) => edge.id !== excludeId) : existingEdges;
+	const graph = buildGraph(filtered);
+	const patterns = compilePatterns(filtered);
+	const compiledSource = source.includes("[") ? compilePattern(source) : null;
+	let startingPoints;
+	if (destination.includes("[")) {
+		const reps = generateRepresentatives(destination, filtered);
+		const compiledDestination = compilePattern(destination);
+		for (const [key] of graph) if (!key.includes("[") && matchPattern(compiledDestination, key) !== null) reps.push(key);
+		reps.push(destination);
+		startingPoints = reps;
+	} else startingPoints = [destination];
+	for (const start of startingPoints) {
+		const path = [source, destination];
+		let current = start;
+		const seen = new Set([
+			source,
+			destination,
+			start
+		]);
+		while (current) {
+			const next = resolveNext(current, graph, patterns, filtered);
+			if (!next) break;
+			if (seen.has(next.destination) || compiledSource !== null && matchPattern(compiledSource, next.destination) !== null) {
+				const displayPath = !seen.has(next.destination) && compiledSource !== null ? source : next.destination;
+				path.push(displayPath);
+				return path;
+			}
+			const cleanDestination = next.destination.includes(DUMMY_SEGMENT) ? findMatchingTemplate(next.destination, patterns) ?? next.destination : next.destination;
+			path.push(cleanDestination);
+			seen.add(next.destination);
+			current = next.destination;
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/api/handlers/redirects.ts
+/**
+* List redirects with cursor pagination and optional filters
+*/
+async function handleRedirectList(db, params) {
+	try {
+		const result = await new RedirectRepository(db).findMany(params);
+		const loopRedirectIds = await getLoopRedirectIds(db);
+		return {
+			success: true,
+			data: {
+				...result,
+				...loopRedirectIds.length > 0 ? { loopRedirectIds } : {}
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REDIRECT_LIST_ERROR",
+				message: "Failed to fetch redirects"
+			}
+		};
+	}
+}
+/**
+* Create a redirect rule
+*/
+async function handleRedirectCreate(db, input) {
+	try {
+		const repo = new RedirectRepository(db);
+		if (input.source === input.destination) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Source and destination must be different"
+			}
+		};
+		const sourceIsPattern = isPattern(input.source);
+		if (sourceIsPattern) {
+			const patternError = validatePattern(input.source);
+			if (patternError) return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: `Invalid source pattern: ${patternError}`
+				}
+			};
+			const destError = validateDestinationParams(input.source, input.destination);
+			if (destError) return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: destError
+				}
+			};
+		}
+		if (await repo.findBySource(input.source)) return {
+			success: false,
+			error: {
+				code: "CONFLICT",
+				message: `A redirect from "${input.source}" already exists`
+			}
+		};
+		if (input.enabled !== false) {
+			const loopPath = wouldCreateLoop(input.source, input.destination, toEdges(await repo.findAllEnabled()));
+			if (loopPath) return loopError(loopPath);
+		}
+		const redirect = await repo.create({
+			source: input.source,
+			destination: input.destination,
+			type: input.type ?? 301,
+			isPattern: sourceIsPattern,
+			enabled: input.enabled ?? true,
+			groupName: input.groupName ?? null
+		});
+		await updateLoopCache(db);
+		invalidateRedirectCache();
+		return {
+			success: true,
+			data: redirect
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REDIRECT_CREATE_ERROR",
+				message: "Failed to create redirect"
+			}
+		};
+	}
+}
+/**
+* Get a redirect by ID
+*/
+async function handleRedirectGet(db, id) {
+	try {
+		const redirect = await new RedirectRepository(db).findById(id);
+		if (!redirect) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Redirect "${id}" not found`
+			}
+		};
+		return {
+			success: true,
+			data: redirect
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REDIRECT_GET_ERROR",
+				message: "Failed to fetch redirect"
+			}
+		};
+	}
+}
+/**
+* Update a redirect by ID
+*/
+async function handleRedirectUpdate(db, id, input) {
+	try {
+		const repo = new RedirectRepository(db);
+		const existing = await repo.findById(id);
+		if (!existing) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Redirect "${id}" not found`
+			}
+		};
+		const newSource = input.source ?? existing.source;
+		const newDest = input.destination ?? existing.destination;
+		if (newSource === newDest) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Source and destination must be different"
+			}
+		};
+		if (input.source !== void 0) {
+			if (isPattern(input.source)) {
+				const patternError = validatePattern(input.source);
+				if (patternError) return {
+					success: false,
+					error: {
+						code: "VALIDATION_ERROR",
+						message: `Invalid source pattern: ${patternError}`
+					}
+				};
+			}
+			const dup = await repo.findBySource(input.source);
+			if (dup && dup.id !== id) return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `A redirect from "${input.source}" already exists`
+				}
+			};
+		}
+		if (isPattern(newSource)) {
+			const destError = validateDestinationParams(newSource, newDest);
+			if (destError) return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: destError
+				}
+			};
+		}
+		if ((input.enabled ?? existing.enabled) && (input.source !== void 0 || input.destination !== void 0 || input.enabled === true && !existing.enabled)) {
+			const loopPath = wouldCreateLoop(newSource, newDest, toEdges(await repo.findAllEnabled()), id);
+			if (loopPath) return loopError(loopPath);
+		}
+		const updated = await repo.update(id, {
+			source: input.source,
+			destination: input.destination,
+			type: input.type,
+			enabled: input.enabled,
+			groupName: input.groupName
+		});
+		if (!updated) return {
+			success: false,
+			error: {
+				code: "REDIRECT_UPDATE_ERROR",
+				message: "Failed to update redirect"
+			}
+		};
+		await updateLoopCache(db);
+		invalidateRedirectCache();
+		return {
+			success: true,
+			data: updated
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REDIRECT_UPDATE_ERROR",
+				message: "Failed to update redirect"
+			}
+		};
+	}
+}
+/**
+* Delete a redirect by ID
+*/
+async function handleRedirectDelete(db, id) {
+	try {
+		if (!await new RedirectRepository(db).delete(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Redirect "${id}" not found`
+			}
+		};
+		await updateLoopCache(db);
+		invalidateRedirectCache();
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REDIRECT_DELETE_ERROR",
+				message: "Failed to delete redirect"
+			}
+		};
+	}
+}
+const LOOP_CACHE_KEY = "_redirect_loop_ids";
+function loopError(loopPath) {
+	return {
+		success: false,
+		error: {
+			code: "VALIDATION_ERROR",
+			message: `This redirect would create a loop:\n${loopPath.slice(0, -1).map((path, index) => `${path} -> ${loopPath[index + 1]}`).join("\n")}`
+		}
+	};
+}
+function toEdges(redirects) {
+	return redirects.map((redirect) => ({
+		id: redirect.id,
+		source: redirect.source,
+		destination: redirect.destination,
+		enabled: redirect.enabled,
+		isPattern: redirect.isPattern
+	}));
+}
+async function updateLoopCache(db) {
+	try {
+		const options = new OptionsRepository(db);
+		const redirects = await new RedirectRepository(db).findAllEnabled();
+		await options.set(LOOP_CACHE_KEY, detectLoops(toEdges(redirects)));
+	} catch (error) {
+		console.error("Failed to update redirect loop cache:", error);
+	}
+}
+async function getLoopRedirectIds(db) {
+	try {
+		const options = new OptionsRepository(db);
+		const cached = await options.get(LOOP_CACHE_KEY);
+		if (cached !== null) return cached;
+		await updateLoopCache(db);
+		return await options.get(LOOP_CACHE_KEY) ?? [];
+	} catch {
+		return [];
+	}
+}
+/**
+* List 404 log entries with cursor pagination
+*/
+async function handleNotFoundList(db, params) {
+	try {
+		return {
+			success: true,
+			data: await new RedirectRepository(db).find404s(params)
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND_LIST_ERROR",
+				message: "Failed to fetch 404 log"
+			}
+		};
+	}
+}
+/**
+* Get 404 summary (grouped by path, sorted by count)
+*/
+async function handleNotFoundSummary(db, limit) {
+	try {
+		return {
+			success: true,
+			data: { items: await new RedirectRepository(db).get404Summary(limit) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND_SUMMARY_ERROR",
+				message: "Failed to fetch 404 summary"
+			}
+		};
+	}
+}
+/**
+* Clear all 404 log entries
+*/
+async function handleNotFoundClear(db) {
+	try {
+		return {
+			success: true,
+			data: { deleted: await new RedirectRepository(db).clear404s() }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND_CLEAR_ERROR",
+				message: "Failed to clear 404 log"
+			}
+		};
+	}
+}
+/**
+* Prune 404 log entries older than a given date
+*/
+async function handleNotFoundPrune(db, olderThan) {
+	try {
+		return {
+			success: true,
+			data: { deleted: await new RedirectRepository(db).prune404s(olderThan) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND_PRUNE_ERROR",
+				message: "Failed to prune 404 log"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleRedirectCreate as a, handleRedirectList as c, handleNotFoundSummary as i, handleRedirectUpdate as l, handleNotFoundList as n, handleRedirectDelete as o, handleNotFoundPrune as r, handleRedirectGet as s, handleNotFoundClear as t };