dineway 0.1.3

package/dist/redirect-JPqLAbxa.mjs

@@ -0,0 +1,328 @@
+import { r as currentTimestampValue } from "./dialect-helpers-B9uSp2GJ.mjs";
+import { n as decodeCursor, r as encodeCursor } from "./types-BawVha09.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/redirects/patterns.ts
+/**
+* URL pattern matching for redirects.
+*
+* Uses Astro's route syntax: [param] for named segments, [...rest] for catch-all.
+* Compiles patterns to safe regexes -- no user-supplied regex, no ReDoS risk.
+*
+* @example
+* ```ts
+* const compiled = compilePattern("/old-blog/[...path]");
+* const match = matchPattern(compiled, "/old-blog/2024/01/post");
+* // match = { path: "2024/01/post" }
+*
+* interpolateDestination("/blog/[...path]", match);
+* // "/blog/2024/01/post"
+* ```
+*/
+/** Matches [paramName] placeholders */
+const PARAM_PATTERN = /\[(\w+)\]/g;
+/** Matches [...splatName] placeholders */
+const SPLAT_PATTERN = /\[\.\.\.(\w+)\]/g;
+/** Combined pattern for validation: matches both [param] and [...splat] */
+const ANY_PLACEHOLDER = /\[(?:\.\.\.)?(\w+)\]/g;
+/** Split on capture groups in compiled regex string */
+const CAPTURE_GROUP_SPLIT = /(\([^)]+\))/;
+/** Escape regex-special characters in literal parts */
+const REGEX_SPECIAL_CHARS = /[.*+?^${}|\\]/g;
+/**
+* Returns true if a source string contains [param] or [...splat] placeholders.
+*/
+function isPattern(source) {
+	return source.match(ANY_PLACEHOLDER) !== null;
+}
+/**
+* Compile a URL pattern into a regex for matching.
+*
+* - `[param]` matches a single path segment (`[^/]+`)
+* - `[...rest]` matches one or more remaining segments (`.+`)
+*/
+function compilePattern(source) {
+	const paramNames = [];
+	let regexStr = source.replace(SPLAT_PATTERN, (_match, name) => {
+		paramNames.push(name);
+		return "(.+)";
+	});
+	regexStr = regexStr.replace(PARAM_PATTERN, (_match, name) => {
+		paramNames.push(name);
+		return "([^/]+)";
+	});
+	const escaped = regexStr.split(CAPTURE_GROUP_SPLIT).map((part, i) => {
+		if (i % 2 === 1) return part;
+		return part.replace(REGEX_SPECIAL_CHARS, "\\$&");
+	}).join("");
+	return {
+		regex: new RegExp(`^${escaped}$`),
+		paramNames,
+		source
+	};
+}
+/**
+* Match a path against a compiled pattern.
+* Returns captured params or null if no match.
+*/
+function matchPattern(compiled, path) {
+	const match = path.match(compiled.regex);
+	if (!match) return null;
+	const params = {};
+	for (let i = 0; i < compiled.paramNames.length; i++) {
+		const value = match[i + 1];
+		if (value !== void 0) params[compiled.paramNames[i]] = value;
+	}
+	return params;
+}
+/**
+* Interpolate captured params into a destination pattern.
+*
+* @example
+* interpolateDestination("/blog/[...path]", { path: "2024/01/post" })
+* // "/blog/2024/01/post"
+*/
+function interpolateDestination(destination, params) {
+	let result = destination.replace(SPLAT_PATTERN, (_match, name) => {
+		return params[name] ?? "";
+	});
+	result = result.replace(PARAM_PATTERN, (_match, name) => {
+		return params[name] ?? "";
+	});
+	return result;
+}
+
+//#endregion
+//#region src/database/repositories/redirect.ts
+function rowToRedirect(row) {
+	return {
+		id: row.id,
+		source: row.source,
+		destination: row.destination,
+		type: row.type,
+		isPattern: row.is_pattern === 1,
+		enabled: row.enabled === 1,
+		hits: row.hits,
+		lastHitAt: row.last_hit_at,
+		groupName: row.group_name,
+		auto: row.auto === 1,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+var RedirectRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_redirects").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToRedirect(row) : null;
+	}
+	async findBySource(source) {
+		const row = await this.db.selectFrom("_dineway_redirects").selectAll().where("source", "=", source).executeTakeFirst();
+		return row ? rowToRedirect(row) : null;
+	}
+	async findMany(opts) {
+		const limit = Math.min(Math.max(opts.limit ?? 50, 1), 100);
+		let query = this.db.selectFrom("_dineway_redirects").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (opts.search) {
+			const term = `%${opts.search}%`;
+			query = query.where((eb) => eb.or([eb("source", "like", term), eb("destination", "like", term)]));
+		}
+		if (opts.group !== void 0) query = query.where("group_name", "=", opts.group);
+		if (opts.enabled !== void 0) query = query.where("enabled", "=", opts.enabled ? 1 : 0);
+		if (opts.auto !== void 0) query = query.where("auto", "=", opts.auto ? 1 : 0);
+		if (opts.cursor) {
+			const decoded = decodeCursor(opts.cursor);
+			if (decoded) query = query.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		const rows = await query.execute();
+		const items = rows.slice(0, limit).map(rowToRedirect);
+		const result = { items };
+		if (rows.length > limit) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const patternFlag = input.isPattern ?? isPattern(input.source);
+		await this.db.insertInto("_dineway_redirects").values({
+			id,
+			source: input.source,
+			destination: input.destination,
+			type: input.type ?? 301,
+			is_pattern: patternFlag ? 1 : 0,
+			enabled: input.enabled !== false ? 1 : 0,
+			hits: 0,
+			last_hit_at: null,
+			group_name: input.groupName ?? null,
+			auto: input.auto ? 1 : 0,
+			created_at: now,
+			updated_at: now
+		}).execute();
+		return await this.findById(id);
+	}
+	async update(id, input) {
+		if (!await this.findById(id)) return null;
+		const values = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+		if (input.source !== void 0) {
+			values.source = input.source;
+			values.is_pattern = input.isPattern !== void 0 ? input.isPattern ? 1 : 0 : isPattern(input.source) ? 1 : 0;
+		} else if (input.isPattern !== void 0) values.is_pattern = input.isPattern ? 1 : 0;
+		if (input.destination !== void 0) values.destination = input.destination;
+		if (input.type !== void 0) values.type = input.type;
+		if (input.enabled !== void 0) values.enabled = input.enabled ? 1 : 0;
+		if (input.groupName !== void 0) values.group_name = input.groupName;
+		await this.db.updateTable("_dineway_redirects").set(values).where("id", "=", id).execute();
+		return await this.findById(id);
+	}
+	async delete(id) {
+		const result = await this.db.deleteFrom("_dineway_redirects").where("id", "=", id).executeTakeFirst();
+		return BigInt(result.numDeletedRows) > 0n;
+	}
+	async findExactMatch(path) {
+		const row = await this.db.selectFrom("_dineway_redirects").selectAll().where("source", "=", path).where("enabled", "=", 1).where("is_pattern", "=", 0).executeTakeFirst();
+		return row ? rowToRedirect(row) : null;
+	}
+	async findEnabledPatternRules() {
+		return (await this.db.selectFrom("_dineway_redirects").selectAll().where("enabled", "=", 1).where("is_pattern", "=", 1).execute()).map(rowToRedirect);
+	}
+	/**
+	* Match a request path against all enabled redirect rules.
+	* Checks exact matches first (indexed), then pattern rules.
+	* Returns the matched redirect and the resolved destination URL.
+	*/
+	async matchPath(path) {
+		const exact = await this.findExactMatch(path);
+		if (exact) return {
+			redirect: exact,
+			resolvedDestination: exact.destination
+		};
+		const patterns = await this.findEnabledPatternRules();
+		for (const redirect of patterns) {
+			const params = matchPattern(compilePattern(redirect.source), path);
+			if (params) return {
+				redirect,
+				resolvedDestination: interpolateDestination(redirect.destination, params)
+			};
+		}
+		return null;
+	}
+	async recordHit(id) {
+		await sql`
+			UPDATE _dineway_redirects
+			SET hits = hits + 1, last_hit_at = ${currentTimestampValue(this.db)}, updated_at = ${currentTimestampValue(this.db)}
+			WHERE id = ${id}
+		`.execute(this.db);
+	}
+	/**
+	* Create an auto-redirect when a content slug changes.
+	* Uses the collection's URL pattern to compute old/new URLs.
+	* Collapses existing redirect chains pointing to the old URL.
+	*/
+	async createAutoRedirect(collection, oldSlug, newSlug, contentId, urlPattern) {
+		const oldUrl = urlPattern ? urlPattern.replace("{slug}", oldSlug).replace("{id}", contentId) : `/${collection}/${oldSlug}`;
+		const newUrl = urlPattern ? urlPattern.replace("{slug}", newSlug).replace("{id}", contentId) : `/${collection}/${newSlug}`;
+		await this.collapseChains(oldUrl, newUrl);
+		const existing = await this.findBySource(oldUrl);
+		if (existing) return await this.update(existing.id, { destination: newUrl });
+		return this.create({
+			source: oldUrl,
+			destination: newUrl,
+			type: 301,
+			isPattern: false,
+			auto: true,
+			groupName: "Auto: slug change"
+		});
+	}
+	/**
+	* Update all redirects whose destination matches oldDestination
+	* to point to newDestination instead. Prevents redirect chains.
+	* Returns the number of updated rows.
+	*/
+	async collapseChains(oldDestination, newDestination) {
+		const result = await this.db.updateTable("_dineway_redirects").set({
+			destination: newDestination,
+			updated_at: (/* @__PURE__ */ new Date()).toISOString()
+		}).where("destination", "=", oldDestination).executeTakeFirst();
+		return Number(result.numUpdatedRows);
+	}
+	async log404(entry) {
+		await this.db.insertInto("_dineway_404_log").values({
+			id: ulid(),
+			path: entry.path,
+			referrer: entry.referrer ?? null,
+			user_agent: entry.userAgent ?? null,
+			ip: entry.ip ?? null,
+			created_at: (/* @__PURE__ */ new Date()).toISOString()
+		}).execute();
+	}
+	async find404s(opts) {
+		const limit = Math.min(Math.max(opts.limit ?? 50, 1), 100);
+		let query = this.db.selectFrom("_dineway_404_log").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (opts.search) query = query.where("path", "like", `%${opts.search}%`);
+		if (opts.cursor) {
+			const decoded = decodeCursor(opts.cursor);
+			if (decoded) query = query.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		const rows = await query.execute();
+		const items = rows.slice(0, limit).map((row) => ({
+			id: row.id,
+			path: row.path,
+			referrer: row.referrer,
+			userAgent: row.user_agent,
+			ip: row.ip,
+			createdAt: row.created_at
+		}));
+		const result = { items };
+		if (rows.length > limit) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async get404Summary(limit = 50) {
+		return (await sql`
+			SELECT
+				path,
+				COUNT(*) as count,
+				MAX(created_at) as last_seen,
+				(
+					SELECT referrer FROM _dineway_404_log AS inner_log
+					WHERE inner_log.path = _dineway_404_log.path
+						AND referrer IS NOT NULL AND referrer != ''
+					GROUP BY referrer
+					ORDER BY COUNT(*) DESC
+					LIMIT 1
+				) as top_referrer
+			FROM _dineway_404_log
+			GROUP BY path
+			ORDER BY count DESC
+			LIMIT ${limit}
+		`.execute(this.db)).rows.map((row) => ({
+			path: row.path,
+			count: Number(row.count),
+			lastSeen: row.last_seen,
+			topReferrer: row.top_referrer
+		}));
+	}
+	async delete404(id) {
+		const result = await this.db.deleteFrom("_dineway_404_log").where("id", "=", id).executeTakeFirst();
+		return BigInt(result.numDeletedRows) > 0n;
+	}
+	async clear404s() {
+		const result = await this.db.deleteFrom("_dineway_404_log").executeTakeFirst();
+		return Number(result.numDeletedRows);
+	}
+	async prune404s(olderThan) {
+		const result = await this.db.deleteFrom("_dineway_404_log").where("created_at", "<", olderThan).executeTakeFirst();
+		return Number(result.numDeletedRows);
+	}
+};
+
+//#endregion
+export { RedirectRepository as t };