dineway 0.1.8 → 0.1.11

package/dist/oauth-state-store-hSdzxsEe.mjs

@@ -0,0 +1,48 @@
+//#region src/auth/oauth-state-store.ts
+const OAUTH_STATE_TTL_MS = 600 * 1e3;
+function createOAuthStateStore(db) {
+	return {
+		async set(state, data) {
+			const expiresAt = new Date(Date.now() + OAUTH_STATE_TTL_MS).toISOString();
+			await db.insertInto("auth_challenges").values({
+				challenge: state,
+				type: "oauth",
+				user_id: null,
+				data: JSON.stringify(data),
+				expires_at: expiresAt
+			}).onConflict((oc) => oc.column("challenge").doUpdateSet({
+				type: "oauth",
+				data: JSON.stringify(data),
+				expires_at: expiresAt
+			})).execute();
+		},
+		async get(state) {
+			const row = await db.selectFrom("auth_challenges").selectAll().where("challenge", "=", state).where("type", "=", "oauth").executeTakeFirst();
+			if (!row) return null;
+			if (new Date(row.expires_at).getTime() < Date.now()) {
+				await this.delete(state);
+				return null;
+			}
+			if (!row.data) return null;
+			try {
+				const parsed = JSON.parse(row.data);
+				if (typeof parsed !== "object" || parsed === null || !("provider" in parsed) || typeof parsed.provider !== "string" || !("redirectUri" in parsed) || typeof parsed.redirectUri !== "string") return null;
+				const oauthState = {
+					provider: parsed.provider,
+					redirectUri: parsed.redirectUri
+				};
+				if ("codeVerifier" in parsed && typeof parsed.codeVerifier === "string") oauthState.codeVerifier = parsed.codeVerifier;
+				if ("nonce" in parsed && typeof parsed.nonce === "string") oauthState.nonce = parsed.nonce;
+				return oauthState;
+			} catch {
+				return null;
+			}
+		},
+		async delete(state) {
+			await db.deleteFrom("auth_challenges").where("challenge", "=", state).where("type", "=", "oauth").execute();
+		}
+	};
+}
+
+//#endregion
+export { createOAuthStateStore as t };

package/dist/oauth-user-lookup-B4OcmsLV.mjs

@@ -0,0 +1,25 @@
+import { toRoleLevel } from "@dineway-ai/auth";
+
+//#region src/api/handlers/oauth-user-lookup.ts
+/**
+* Shared user lookup for OAuth token operations.
+*
+* Extracts user role and disabled status from the database. Used by
+* handleTokenRefresh() to revalidate scopes against the user's current
+* role and reject disabled users.
+*/
+/**
+* Look up a user's current role and disabled status.
+* Returns null if the user doesn't exist.
+*/
+async function lookupUserRoleAndStatus(db, userId) {
+	const row = await db.selectFrom("users").select(["role", "disabled"]).where("id", "=", userId).executeTakeFirst();
+	if (!row) return null;
+	return {
+		role: toRoleLevel(row.role),
+		disabled: row.disabled === 1
+	};
+}
+
+//#endregion
+export { lookupUserRoleAndStatus as t };

package/dist/options-z8VVg1Ll.mjs

@@ -0,0 +1,114 @@
+import { sql } from "kysely";
+
+//#region src/database/repositories/options.ts
+function escapeLike(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+/**
+* Options repository for key-value settings storage
+*
+* Used for site settings, plugin configuration, and other arbitrary key-value data.
+* Values are stored as JSON for flexibility.
+*/
+var OptionsRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Get an option value
+	*/
+	async get(name) {
+		const row = await this.db.selectFrom("options").select("value").where("name", "=", name).executeTakeFirst();
+		if (!row) return null;
+		return JSON.parse(row.value);
+	}
+	/**
+	* Get an option value with a default
+	*/
+	async getOrDefault(name, defaultValue) {
+		return await this.get(name) ?? defaultValue;
+	}
+	/**
+	* Set an option value (creates or updates)
+	*/
+	async set(name, value) {
+		const row = {
+			name,
+			value: JSON.stringify(value)
+		};
+		await this.db.insertInto("options").values(row).onConflict((oc) => oc.column("name").doUpdateSet({ value: row.value })).execute();
+	}
+	/**
+	* Set an option value only if no row with that name exists.
+	*
+	* Returns true when the row was inserted, false when a row already existed,
+	* regardless of its value.
+	*/
+	async setIfAbsent(name, value) {
+		const row = {
+			name,
+			value: JSON.stringify(value)
+		};
+		return ((await this.db.insertInto("options").values(row).onConflict((oc) => oc.column("name").doNothing()).executeTakeFirst()).numInsertedOrUpdatedRows ?? 0n) > 0n;
+	}
+	/**
+	* Delete an option
+	*/
+	async delete(name) {
+		return ((await this.db.deleteFrom("options").where("name", "=", name).executeTakeFirst()).numDeletedRows ?? 0) > 0;
+	}
+	/**
+	* Check if an option exists
+	*/
+	async exists(name) {
+		return !!await this.db.selectFrom("options").select("name").where("name", "=", name).executeTakeFirst();
+	}
+	/**
+	* Get multiple options at once
+	*/
+	async getMany(names) {
+		if (names.length === 0) return /* @__PURE__ */ new Map();
+		const rows = await this.db.selectFrom("options").select(["name", "value"]).where("name", "in", names).execute();
+		const result = /* @__PURE__ */ new Map();
+		for (const row of rows) result.set(row.name, JSON.parse(row.value));
+		return result;
+	}
+	/**
+	* Set multiple options at once
+	*/
+	async setMany(options) {
+		const entries = Object.entries(options);
+		if (entries.length === 0) return;
+		for (const [name, value] of entries) await this.set(name, value);
+	}
+	/**
+	* Get all options (use sparingly)
+	*/
+	async getAll() {
+		const rows = await this.db.selectFrom("options").select(["name", "value"]).execute();
+		const result = /* @__PURE__ */ new Map();
+		for (const row of rows) result.set(row.name, JSON.parse(row.value));
+		return result;
+	}
+	/**
+	* Get all options matching a prefix
+	*/
+	async getByPrefix(prefix) {
+		const pattern = `${escapeLike(prefix)}%`;
+		const rows = await this.db.selectFrom("options").select(["name", "value"]).where(sql`name LIKE ${pattern} ESCAPE '\\'`).execute();
+		const result = /* @__PURE__ */ new Map();
+		for (const row of rows) result.set(row.name, JSON.parse(row.value));
+		return result;
+	}
+	/**
+	* Delete all options matching a prefix
+	*/
+	async deleteByPrefix(prefix) {
+		const pattern = `${escapeLike(prefix)}%`;
+		const result = await this.db.deleteFrom("options").where(sql`name LIKE ${pattern} ESCAPE '\\'`).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+};
+
+//#endregion
+export { OptionsRepository as t };

package/dist/page/index.d.mts

@@ -1,5 +1,5 @@
-import { A as PageMetadataContribution, D as PageFragmentContribution, N as PageMetadataLinkRel, P as PagePlacement, q as PublicPageContext, t as BreadcrumbItem } from "../types-Cj0KMIZV.mjs";
-import { n as SeoSettings } from "../types-BuMDPy5C.mjs";
+import { A as PageMetadataContribution, D as PageFragmentContribution, N as PageMetadataLinkRel, P as PagePlacement, q as PublicPageContext, t as BreadcrumbItem } from "../types-DgfUZqcd.mjs";
+import { n as SeoSettings } from "../types-IPACEM14.mjs";
 
 //#region src/page/context.d.ts
 /** Fields shared by both input forms */

package/dist/parse-BeQXIt1U.mjs

@@ -0,0 +1,88 @@
+import { t as apiError } from "./error-DEGjx2Xw.mjs";
+import { z } from "zod";
+
+//#region src/api/parse.ts
+/** Maximum allowed JSON request body size (10 MB). */
+const MAX_BODY_SIZE = 10 * 1024 * 1024;
+/**
+* Parse and validate a JSON request body against a Zod schema.
+*
+* Returns the validated data on success, or a 400 Response on failure.
+* Replaces all `(await request.json()) as T` casts.
+*/
+async function parseBody(request, schema) {
+	const contentLength = request.headers.get("Content-Length");
+	if (contentLength && parseInt(contentLength, 10) > MAX_BODY_SIZE) return apiError("PAYLOAD_TOO_LARGE", "Request body too large", 413);
+	let raw;
+	try {
+		raw = await request.json();
+	} catch {
+		return apiError("INVALID_JSON", "Request body must be valid JSON", 400);
+	}
+	return validate(schema, raw);
+}
+/**
+* Parse and validate an optional JSON request body.
+*
+* Returns `defaultValue` if the body is empty, or the validated data if present.
+* For endpoints where the body is optional (e.g., preview-url, confirm).
+*/
+async function parseOptionalBody(request, schema, defaultValue) {
+	const contentLength = request.headers.get("Content-Length");
+	if (contentLength && parseInt(contentLength, 10) > MAX_BODY_SIZE) return apiError("PAYLOAD_TOO_LARGE", "Request body too large", 413);
+	let text;
+	try {
+		text = await request.text();
+	} catch {
+		return defaultValue;
+	}
+	if (!text.trim()) return defaultValue;
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch {
+		return apiError("INVALID_JSON", "Request body must be valid JSON", 400);
+	}
+	return validate(schema, raw);
+}
+/**
+* Parse and validate URL search params against a Zod schema.
+*
+* Converts searchParams to a plain object before validation.
+* Zod coercion handles string -> number/boolean conversion.
+* Replaces manual `url.searchParams.get()` + `parseInt()` patterns.
+*/
+function parseQuery(url, schema) {
+	const raw = {};
+	for (const [key, value] of url.searchParams) raw[key] = value;
+	return validate(schema, raw);
+}
+/**
+* Validate raw data against a schema. Returns data or error Response.
+*/
+function validate(schema, data) {
+	const result = schema.safeParse(data);
+	if (result.success) return result.data;
+	const issues = result.error.issues.map((issue) => ({
+		path: issue.path.join("."),
+		message: issue.message
+	}));
+	return Response.json({ error: {
+		code: "VALIDATION_ERROR",
+		message: "Invalid request data",
+		details: { issues }
+	} }, {
+		status: 400,
+		headers: { "Cache-Control": "private, no-store" }
+	});
+}
+/**
+* Type guard to check if a ParseResult is an error Response.
+* Usage: `if (isParseError(result)) return result;`
+*/
+function isParseError(result) {
+	return result instanceof Response;
+}
+
+//#endregion
+export { parseQuery as i, parseBody as n, parseOptionalBody as r, isParseError as t };

package/dist/passkey-config-Daqs5fjq.mjs

@@ -0,0 +1,42 @@
+//#region src/auth/passkey-config.ts
+/**
+* Get passkey configuration from request URL
+*
+* @param url The request URL (typically `new URL(Astro.request.url)` or `new URL(request.url)`)
+* @param siteName Optional site name for rpName (defaults to hostname from `url` or public origin)
+* @param siteUrl Optional browser-facing origin (see `DinewayConfig.siteUrl`).
+*        When set, **origin** and **rpId** are taken from this URL so they match WebAuthn `clientData.origin`.
+* @throws If `siteUrl` is non-empty but not parseable by `new URL()`.
+*/
+function getPasskeyConfig(url, siteName, siteUrl, allowedOrigins) {
+	let rpName;
+	let rpId;
+	let canonicalOrigin;
+	if (siteUrl) {
+		let publicUrl;
+		try {
+			publicUrl = new URL(siteUrl);
+		} catch (e) {
+			throw new Error(`Invalid siteUrl: "${siteUrl}"`, { cause: e });
+		}
+		rpName = siteName || publicUrl.hostname;
+		rpId = publicUrl.hostname;
+		canonicalOrigin = publicUrl.origin;
+	} else {
+		rpName = siteName || url.hostname;
+		rpId = url.hostname;
+		canonicalOrigin = url.origin;
+	}
+	const origins = [canonicalOrigin];
+	if (allowedOrigins) {
+		for (const origin of allowedOrigins) if (origin && !origins.includes(origin)) origins.push(origin);
+	}
+	return {
+		rpName,
+		rpId,
+		origins
+	};
+}
+
+//#endregion
+export { getPasskeyConfig as t };

package/dist/{patterns-CrCYkMBb.mjs → patterns-K0DLqWir.mjs}

@@ -21,6 +21,14 @@ const PARAM_PATTERN = /\[(\w+)\]/g;
 const SPLAT_PATTERN = /\[\.\.\.(\w+)\]/g;
 /** Combined pattern for validation: matches both [param] and [...splat] */
 const ANY_PLACEHOLDER = /\[(?:\.\.\.)?(\w+)\]/g;
+/** Nested brackets check: [foo[ */
+const NESTED_BRACKETS = /\[[^\]]*\[/;
+/** Empty brackets: [] */
+const EMPTY_BRACKETS = /\[\]/;
+/** Count open brackets */
+const OPEN_BRACKET = /\[/g;
+/** Count close brackets */
+const CLOSE_BRACKET = /\]/g;
 /** Split on capture groups in compiled regex string */
 const CAPTURE_GROUP_SPLIT = /(\([^)]+\))/;
 /** Escape regex-special characters in literal parts */
@@ -32,6 +40,50 @@ function isPattern(source) {
 	return source.match(ANY_PLACEHOLDER) !== null;
 }
 /**
+* Validate that a pattern string is well-formed.
+* Returns null if valid, or an error message if invalid.
+*/
+function validatePattern(source) {
+	if (!source.startsWith("/")) return "Pattern must start with /";
+	if (NESTED_BRACKETS.test(source)) return "Nested brackets are not allowed";
+	if (EMPTY_BRACKETS.test(source)) return "Empty brackets are not allowed";
+	if ((source.match(OPEN_BRACKET) ?? []).length !== (source.match(CLOSE_BRACKET) ?? []).length) return "Unmatched brackets";
+	const segments = source.split("/").filter(Boolean);
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (SPLAT_PATTERN.test(segment) && i !== segments.length - 1) {
+			SPLAT_PATTERN.lastIndex = 0;
+			return "Catch-all [...param] must be in the last segment";
+		}
+		SPLAT_PATTERN.lastIndex = 0;
+	}
+	for (const segment of segments) {
+		const placeholders = segment.match(ANY_PLACEHOLDER);
+		if (placeholders && placeholders.length > 1) return "Each segment can contain at most one placeholder";
+		if (placeholders && placeholders[0] !== segment) return "A placeholder must be the entire segment, not mixed with literal text";
+	}
+	const names = [];
+	for (const m of source.matchAll(ANY_PLACEHOLDER)) {
+		const name = m[1];
+		if (names.includes(name)) return `Duplicate parameter name: ${name}`;
+		names.push(name);
+	}
+	return null;
+}
+/**
+* Validate that all placeholders in a destination exist in the source.
+* Returns null if valid, or an error message if invalid.
+*/
+function validateDestinationParams(source, destination) {
+	const sourceNames = /* @__PURE__ */ new Set();
+	for (const m of source.matchAll(ANY_PLACEHOLDER)) sourceNames.add(m[1]);
+	for (const m of destination.matchAll(ANY_PLACEHOLDER)) {
+		const name = m[1];
+		if (!sourceNames.has(name)) return `Destination references [${name}] which is not captured in the source pattern`;
+	}
+	return null;
+}
+/**
 * Compile a URL pattern into a regex for matching.
 *
 * - `[param]` matches a single path segment (`[^/]+`)
@@ -89,4 +141,4 @@ function interpolateDestination(destination, params) {
 }
 
 //#endregion
-export { matchPattern as i, interpolateDestination as n, isPattern as r, compilePattern as t };
+export { validateDestinationParams as a, matchPattern as i, interpolateDestination as n, validatePattern as o, isPattern as r, compilePattern as t };

package/dist/{placeholder-Cp8g5Emj.mjs → placeholder-C2P5fKa4.mjs}

@@ -1,131 +1,6 @@
 import { encode } from "blurhash";
 import { imageSize } from "image-size";
 
-//#region src/media/normalize.ts
-const INTERNAL_MEDIA_PREFIX = "/_dineway/api/media/file/";
-const URL_PATTERN = /^https?:\/\//;
-/**
-* Normalize a media field value into a consistent MediaValue shape.
-*
-* - `null`/`undefined` → `null`
-* - Bare URL string → `{ provider: "external", id: "", src: url }`
-* - Bare internal media URL → resolved via local provider's `get()`
-* - Object with `provider` + `id` → enriched with missing fields from provider
-*/
-async function normalizeMediaValue(value, getProvider) {
-	if (value == null) return null;
-	if (typeof value === "string") return normalizeStringUrl(value, getProvider);
-	if (!isRecord(value)) return null;
-	if (!("id" in value) && !("src" in value)) return null;
-	const provider = (typeof value.provider === "string" ? value.provider : void 0) || "local";
-	const id = typeof value.id === "string" ? value.id : "";
-	if (provider === "external") return recordToMediaValue(value);
-	const result = {
-		...recordToMediaValue(value),
-		provider
-	};
-	if (provider === "local") delete result.src;
-	const needsDimensions = result.width == null || result.height == null;
-	const needsStorageKey = provider === "local" && !result.meta?.storageKey;
-	const needsFileInfo = !result.mimeType || !result.filename;
-	if (!(needsDimensions || needsStorageKey || needsFileInfo) || !id) return result;
-	const mediaProvider = getProvider(provider);
-	if (!mediaProvider?.get) return result;
-	let providerItem;
-	try {
-		providerItem = await mediaProvider.get(id);
-	} catch {
-		return result;
-	}
-	if (!providerItem) return result;
-	return mergeProviderData(result, providerItem);
-}
-function normalizeStringUrl(url, getProvider) {
-	if (url.startsWith(INTERNAL_MEDIA_PREFIX)) return resolveInternalUrl(url, getProvider);
-	if (URL_PATTERN.test(url)) return Promise.resolve({
-		provider: "external",
-		id: "",
-		src: url
-	});
-	return Promise.resolve({
-		provider: "external",
-		id: "",
-		src: url
-	});
-}
-async function resolveInternalUrl(url, getProvider) {
-	const storageKey = url.slice(25);
-	const localProvider = getProvider("local");
-	if (!localProvider?.get) return {
-		provider: "external",
-		id: "",
-		src: url
-	};
-	let item;
-	try {
-		item = await localProvider.get(storageKey);
-	} catch {
-		return {
-			provider: "external",
-			id: "",
-			src: url
-		};
-	}
-	if (!item) return {
-		provider: "external",
-		id: "",
-		src: url
-	};
-	return {
-		provider: "local",
-		id: item.id,
-		filename: item.filename,
-		mimeType: item.mimeType,
-		width: item.width,
-		height: item.height,
-		alt: item.alt,
-		meta: item.meta
-	};
-}
-/**
-* Merge provider data into an existing MediaValue, preserving caller-supplied fields.
-* Caller `alt` takes priority over provider `alt` (per-usage, not per-image).
-*/
-function mergeProviderData(existing, item) {
-	const result = { ...existing };
-	if (result.width == null && item.width != null) result.width = item.width;
-	if (result.height == null && item.height != null) result.height = item.height;
-	if (!result.filename && item.filename) result.filename = item.filename;
-	if (!result.mimeType && item.mimeType) result.mimeType = item.mimeType;
-	if (!result.alt && item.alt) result.alt = item.alt;
-	if (item.meta) result.meta = {
-		...item.meta,
-		...result.meta
-	};
-	return result;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Extract known MediaValue fields from a runtime-checked record.
-* Avoids unsafe `as MediaValue` cast by reading each property explicitly.
-*/
-function recordToMediaValue(obj) {
-	const result = { id: typeof obj.id === "string" ? obj.id : "" };
-	if (typeof obj.provider === "string") result.provider = obj.provider;
-	if (typeof obj.src === "string") result.src = obj.src;
-	if (typeof obj.previewUrl === "string") result.previewUrl = obj.previewUrl;
-	if (typeof obj.filename === "string") result.filename = obj.filename;
-	if (typeof obj.mimeType === "string") result.mimeType = obj.mimeType;
-	if (typeof obj.width === "number") result.width = obj.width;
-	if (typeof obj.height === "number") result.height = obj.height;
-	if (typeof obj.alt === "string") result.alt = obj.alt;
-	if (isRecord(obj.meta)) result.meta = obj.meta;
-	return result;
-}
-
-//#endregion
 //#region src/media/placeholder.ts
 /**
 * Image Placeholder Generation
@@ -264,4 +139,4 @@ function downsample(src, srcW, srcH, dstW, dstH) {
 }
 
 //#endregion
-export { normalizeMediaValue as n, generatePlaceholder as t };
+export { generatePlaceholder as t };

package/dist/plugins/adapt-sandbox-entry.d.mts

@@ -1,8 +1,12 @@
-import "../types-DOrVigru.mjs";
-import { wn as PluginDescriptor } from "../index-yvc6E_17.mjs";
-import "../runner-CFI6B6J2.mjs";
-import { X as ResolvedPlugin, tt as StandardPluginDefinition } from "../types-Cj0KMIZV.mjs";
-import "../validate-IPf8n4Fj.mjs";
+import { n as PluginDescriptor } from "../runtime-C4-7y7xK.mjs";
+import "../types-Du8jreyC.mjs";
+import { X as ResolvedPlugin, tt as StandardPluginDefinition } from "../types-DgfUZqcd.mjs";
+import "../types-D4XVOt01.mjs";
+import "../runner-9eIQXuc2.mjs";
+import "../index-CkljPf5F.mjs";
+import "../bylines-HfUKum_j.mjs";
+import "../types-C982qI5I.mjs";
+import "../validate-JCZihRIa.mjs";
 
 //#region src/plugins/adapt-sandbox-entry.d.ts
 /**

package/dist/plugins/adapt-sandbox-entry.mjs

@@ -1,4 +1,4 @@
-import { n as PLUGIN_CAPABILITIES, t as HOOK_NAMES } from "../manifest-schema-D1MSVnoI.mjs";
+import { n as PLUGIN_CAPABILITIES, t as HOOK_NAMES } from "../manifest-schema-DYoCQ5np.mjs";
 
 //#region src/plugins/adapt-sandbox-entry.ts
 /**
@@ -84,9 +84,9 @@ function adaptSandboxEntry(definition, descriptor) {
 	for (const cap of rawCapabilities) if (!VALID_CAPABILITIES_SET.has(cap)) throw new Error(`Invalid capability "${cap}" in plugin "${pluginId}". Valid capabilities: ${[...VALID_CAPABILITIES_SET].join(", ")}`);
 	const capabilities = [...rawCapabilities];
 	const allowedHosts = descriptor.allowedHosts ?? [];
-	if (capabilities.includes("write:content") && !capabilities.includes("read:content")) capabilities.push("read:content");
-	if (capabilities.includes("write:media") && !capabilities.includes("read:media")) capabilities.push("read:media");
-	if (capabilities.includes("network:fetch:any") && !capabilities.includes("network:fetch")) capabilities.push("network:fetch");
+	if (capabilities.includes("content:write") && !capabilities.includes("content:read")) capabilities.push("content:read");
+	if (capabilities.includes("media:write") && !capabilities.includes("media:read")) capabilities.push("media:read");
+	if (capabilities.includes("network:request:unrestricted") && !capabilities.includes("network:request")) capabilities.push("network:request");
 	const rawStorage = descriptor.storage ?? {};
 	const storage = {};
 	for (const [name, config] of Object.entries(rawStorage)) storage[name] = {