dineway 0.1.3

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

@@ -0,0 +1,112 @@
+import { n as PLUGIN_CAPABILITIES, t as HOOK_NAMES } from "../manifest-schema-CTSEyIJ3.mjs";
+
+//#region src/plugins/adapt-sandbox-entry.ts
+/**
+* Default hook configuration values
+*/
+const DEFAULT_PRIORITY = 100;
+const DEFAULT_TIMEOUT = 5e3;
+const DEFAULT_ERROR_POLICY = "abort";
+/**
+* Check if a standard hook entry is a config object (has a `handler` property)
+*/
+function isHookConfig(entry) {
+	return typeof entry === "object" && entry !== null && "handler" in entry;
+}
+/**
+* Resolve a single standard hook entry to a ResolvedHook.
+*
+* Standard-format hooks use the sandbox entry convention:
+*   handler(event, ctx) -- two args
+*
+* The HookPipeline dispatch methods also call handlers with (event, ctx),
+* so the handler is compatible as-is. We just need to wrap it for type safety.
+*/
+function resolveStandardHook(entry, pluginId) {
+	if (isHookConfig(entry)) return {
+		priority: entry.priority ?? DEFAULT_PRIORITY,
+		timeout: entry.timeout ?? DEFAULT_TIMEOUT,
+		dependencies: entry.dependencies ?? [],
+		errorPolicy: entry.errorPolicy ?? DEFAULT_ERROR_POLICY,
+		exclusive: entry.exclusive ?? false,
+		handler: entry.handler,
+		pluginId
+	};
+	return {
+		priority: DEFAULT_PRIORITY,
+		timeout: DEFAULT_TIMEOUT,
+		dependencies: [],
+		errorPolicy: DEFAULT_ERROR_POLICY,
+		exclusive: false,
+		handler: entry,
+		pluginId
+	};
+}
+const VALID_CAPABILITIES_SET = new Set(PLUGIN_CAPABILITIES);
+const VALID_HOOK_NAMES_SET = new Set(HOOK_NAMES);
+/**
+* Adapt a standard-format plugin definition into a ResolvedPlugin.
+*
+* This is the core of the unified plugin format. It takes the `{ hooks, routes }`
+* export from a standard plugin and produces a ResolvedPlugin that can enter the
+* HookPipeline alongside native plugins.
+*
+* @param definition - The standard plugin definition (from definePlugin() or raw export)
+* @param descriptor - The plugin descriptor with id, version, capabilities, etc.
+* @returns A ResolvedPlugin compatible with HookPipeline
+*/
+function adaptSandboxEntry(definition, descriptor) {
+	const pluginId = descriptor.id;
+	const version = descriptor.version;
+	const resolvedHooks = {};
+	if (definition.hooks) for (const [hookName, entry] of Object.entries(definition.hooks)) {
+		if (!VALID_HOOK_NAMES_SET.has(hookName)) throw new Error(`Plugin "${pluginId}" declares unknown hook "${hookName}". Valid hooks: ${[...VALID_HOOK_NAMES_SET].join(", ")}`);
+		resolvedHooks[hookName] = resolveStandardHook(entry, pluginId);
+	}
+	const resolvedRoutes = {};
+	if (definition.routes) for (const [routeName, routeEntry] of Object.entries(definition.routes)) {
+		const standardHandler = routeEntry.handler;
+		resolvedRoutes[routeName] = {
+			input: routeEntry.input,
+			public: routeEntry.public,
+			handler: async (ctx) => {
+				const routeCtx = {
+					input: ctx.input,
+					request: ctx.request,
+					requestMeta: ctx.requestMeta
+				};
+				const { input: _, request: __, requestMeta: ___, ...pluginCtx } = ctx;
+				return standardHandler(routeCtx, pluginCtx);
+			}
+		};
+	}
+	const rawCapabilities = descriptor.capabilities ?? [];
+	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");
+	const rawStorage = descriptor.storage ?? {};
+	const storage = {};
+	for (const [name, config] of Object.entries(rawStorage)) storage[name] = {
+		indexes: config.indexes ?? [],
+		uniqueIndexes: config.uniqueIndexes
+	};
+	const admin = {};
+	if (descriptor.adminPages) admin.pages = descriptor.adminPages;
+	if (descriptor.adminWidgets) admin.widgets = descriptor.adminWidgets;
+	return {
+		id: pluginId,
+		version,
+		capabilities,
+		allowedHosts,
+		storage,
+		hooks: resolvedHooks,
+		routes: resolvedRoutes,
+		admin
+	};
+}
+
+//#endregion
+export { adaptSandboxEntry };

package/dist/query-BiaPl_g2.mjs

@@ -0,0 +1,459 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { n as getI18nConfig, r as isI18nEnabled, t as getFallbackChain } from "./config-Cq8H0SfX.mjs";
+import { getRequestContext } from "./request-context.mjs";
+
+//#region src/visual-editing/editable.ts
+/**
+* Create an editable proxy for an entry.
+*
+* Usage:
+* - `{...entry.edit}` - entry-level annotation (includes status/hasDraft)
+* - `{...entry.edit.title}` - field-level annotation
+* - `{...entry.edit['nested.field']}` - nested field (bracket notation)
+*/
+function createEditable(collection, id, options) {
+	const base = {
+		collection,
+		id,
+		...options?.status && { status: options.status },
+		...options?.hasDraft && { hasDraft: true }
+	};
+	return new Proxy({}, {
+		get(_, prop) {
+			if (prop === "toJSON") return () => ({ "data-dineway-ref": JSON.stringify(base) });
+			if (typeof prop === "symbol") return void 0;
+			if (prop === "data-dineway-ref") return JSON.stringify(base);
+			return { "data-dineway-ref": JSON.stringify({
+				...base,
+				field: String(prop)
+			}) };
+		},
+		ownKeys() {
+			return ["data-dineway-ref"];
+		},
+		getOwnPropertyDescriptor(_, prop) {
+			if (prop === "data-dineway-ref") return {
+				configurable: true,
+				enumerable: true,
+				value: JSON.stringify(base)
+			};
+		}
+	});
+}
+/**
+* Create a noop proxy for production mode.
+* Spreading this produces no attributes.
+*/
+function createNoop() {
+	return new Proxy({}, {
+		get(_, prop) {
+			if (typeof prop === "symbol") return void 0;
+		},
+		ownKeys() {
+			return [];
+		},
+		getOwnPropertyDescriptor() {}
+	});
+}
+
+//#endregion
+//#region src/query.ts
+/**
+* Query functions for Dineway content
+*
+* These wrap Astro's getLiveCollection/getLiveEntry with type filtering.
+* Use these instead of calling Astro's functions directly.
+*
+* Error handling follows Astro's pattern - returns { entries/entry, error }
+* so callers can gracefully handle errors (including 404s).
+*
+* Preview mode is handled implicitly via ALS request context —
+* no parameters needed. The middleware verifies the preview token
+* and sets the context; query functions read it automatically.
+*/
+var query_exports = /* @__PURE__ */ __exportAll({
+	getDinewayCollection: () => getDinewayCollection,
+	getDinewayEntry: () => getDinewayEntry,
+	getEditMeta: () => getEditMeta,
+	getTranslations: () => getTranslations,
+	resolveDinewayPath: () => resolveDinewayPath
+});
+const COLLECTION_NAME = "_dineway";
+/** Symbol key for edit metadata on PT arrays — avoids collision with user data */
+const DINEWAY_EDIT = Symbol.for("__dineway");
+/** Type guard for EditFieldMeta */
+function isEditFieldMeta(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("collection" in value) || !("id" in value) || !("field" in value)) return false;
+	const { collection, id, field } = value;
+	return typeof collection === "string" && typeof id === "string" && typeof field === "string";
+}
+/**
+* Read edit metadata from a value (returns undefined if not tagged).
+* Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
+* without an unsafe type assertion.
+*/
+function getEditMeta(value) {
+	if (value && typeof value === "object") {
+		const meta = Object.getOwnPropertyDescriptor(value, DINEWAY_EDIT)?.value;
+		if (isEditFieldMeta(meta)) return meta;
+	}
+}
+/**
+* Tag PT-like arrays in entry data with edit metadata (non-enumerable).
+* A PT array is identified by: is an array, first element has _type property.
+*/
+function tagEditableFields(data, collection, id) {
+	for (const [field, value] of Object.entries(data)) if (Array.isArray(value) && value.length > 0 && value[0] && typeof value[0] === "object" && "_type" in value[0]) Object.defineProperty(value, DINEWAY_EDIT, {
+		value: {
+			collection,
+			id,
+			field
+		},
+		enumerable: false,
+		configurable: true
+	});
+}
+/** Safely read a string field from a Record, with optional fallback */
+function dataStr(data, key, fallback = "") {
+	const val = data[key];
+	return typeof val === "string" ? val : fallback;
+}
+/** Type guard for Record<string, unknown> */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Extract data as Record from an Astro entry (which is any-typed) */
+function entryData(entry) {
+	return isRecord(entry.data) ? entry.data : {};
+}
+/** Extract the database ID from entry data (data.id is the ULID, entry.id is the slug) */
+function entryDatabaseId(entry) {
+	return dataStr(entryData(entry), "id") || entry.id;
+}
+/** Extract edit options from entry data for the proxy */
+function entryEditOptions(entry) {
+	const data = entryData(entry);
+	const status = dataStr(data, "status", "draft");
+	const draftRevisionId = dataStr(data, "draftRevisionId") || void 0;
+	const liveRevisionId = dataStr(data, "liveRevisionId") || void 0;
+	return {
+		status,
+		hasDraft: !!draftRevisionId && draftRevisionId !== liveRevisionId
+	};
+}
+/**
+* Get all entries of a content type
+*
+* Returns { entries, error } for graceful error handling.
+*
+* When dineway-env.d.ts is generated, the collection name will be
+* type-checked and the return type will be inferred automatically.
+*
+* @example
+* ```ts
+* import { getDinewayCollection } from "dineway";
+*
+* const { entries: posts, error } = await getDinewayCollection("posts");
+* if (error) {
+*   console.error("Failed to load posts:", error);
+*   return;
+* }
+* // posts[0].data.title is typed (if dineway-env.d.ts exists)
+*
+* // With filters
+* const { entries: drafts } = await getDinewayCollection("posts", { status: "draft" });
+* ```
+*/
+async function getDinewayCollection(type, filter) {
+	const { getLiveCollection } = await import("astro:content");
+	const ctx = getRequestContext();
+	const i18nConfig = getI18nConfig();
+	const resolvedLocale = filter?.locale ?? ctx?.locale ?? (isI18nEnabled() ? i18nConfig.defaultLocale : void 0);
+	const result = await getLiveCollection(COLLECTION_NAME, {
+		type,
+		status: filter?.status,
+		limit: filter?.limit,
+		cursor: filter?.cursor,
+		where: filter?.where,
+		orderBy: filter?.orderBy,
+		locale: resolvedLocale
+	});
+	const { entries, error, cacheHint } = result;
+	const rawCursor = Object.getOwnPropertyDescriptor(result, "nextCursor")?.value;
+	const nextCursor = typeof rawCursor === "string" ? rawCursor : void 0;
+	if (error) return {
+		entries: [],
+		error,
+		cacheHint: {}
+	};
+	const isEditMode = ctx?.editMode ?? false;
+	const entriesWithEdit = entries.map((entry) => {
+		const dbId = entryDatabaseId(entry);
+		if (isEditMode) tagEditableFields(entryData(entry), type, dbId);
+		return {
+			...entry,
+			edit: isEditMode ? createEditable(type, dbId, entryEditOptions(entry)) : createNoop()
+		};
+	});
+	await hydrateEntryBylines(type, entriesWithEdit);
+	return {
+		entries: entriesWithEdit,
+		nextCursor,
+		cacheHint: cacheHint ?? {}
+	};
+}
+/**
+* Get a single entry by type and ID/slug
+*
+* Returns { entry, error, isPreview } for graceful error handling.
+* - entry is null if not found (not an error)
+* - error is set only for actual errors (db issues, etc.)
+*
+* Preview mode is detected automatically from request context (ALS).
+* When the URL has a valid `_preview` token, the middleware sets preview
+* context and this function serves draft revision data if available.
+*
+* @example
+* ```ts
+* import { getDinewayEntry } from "dineway";
+*
+* // Simple usage — preview just works via middleware
+* const { entry: post, isPreview, error } = await getDinewayEntry("posts", "my-slug");
+* if (!post) return Astro.redirect("/404");
+* ```
+*/
+async function getDinewayEntry(type, id, options) {
+	const { getLiveEntry } = await import("astro:content");
+	const ctx = getRequestContext();
+	const preview = ctx?.preview;
+	const isEditMode = ctx?.editMode ?? false;
+	const serveDrafts = !!preview && preview.collection === type || isEditMode;
+	const requestedLocale = options?.locale ?? ctx?.locale;
+	/** Wrap a raw Astro entry with edit proxy, tagging editable fields if needed */
+	function wrapEntry(raw) {
+		const dbId = entryDatabaseId(raw);
+		if (isEditMode) tagEditableFields(entryData(raw), type, dbId);
+		return {
+			...raw,
+			edit: isEditMode ? createEditable(type, dbId, entryEditOptions(raw)) : createNoop()
+		};
+	}
+	/** Check if an entry is publicly visible (published or scheduled past its time) */
+	function isVisible(entry) {
+		const data = entryData(entry);
+		const status = dataStr(data, "status");
+		const scheduledAt = dataStr(data, "scheduledAt") || void 0;
+		return status === "published" || !!(status === "scheduled" && scheduledAt && new Date(scheduledAt) <= /* @__PURE__ */ new Date());
+	}
+	const localeChain = requestedLocale && isI18nEnabled() ? getFallbackChain(requestedLocale) : [requestedLocale];
+	/** Return a successful EntryResult with bylines hydrated */
+	async function successResult(wrapped, opts) {
+		await hydrateEntryBylines(type, [wrapped]);
+		return {
+			entry: wrapped,
+			isPreview: opts.isPreview,
+			fallbackLocale: opts.fallbackLocale,
+			cacheHint: opts.cacheHint
+		};
+	}
+	if (serveDrafts) {
+		for (let i = 0; i < localeChain.length; i++) {
+			const locale = localeChain[i];
+			const fallbackLocale = i > 0 ? locale : void 0;
+			const { entry: baseEntry, error: baseError, cacheHint } = await getLiveEntry(COLLECTION_NAME, {
+				type,
+				id,
+				locale
+			});
+			if (baseError) return {
+				entry: null,
+				error: baseError,
+				isPreview: serveDrafts,
+				cacheHint: {}
+			};
+			if (!baseEntry) continue;
+			const draftRevisionId = dataStr(entryData(baseEntry), "draftRevisionId") || void 0;
+			if (draftRevisionId) {
+				const { entry: draftEntry, error: draftError } = await getLiveEntry(COLLECTION_NAME, {
+					type,
+					id,
+					revisionId: draftRevisionId,
+					locale
+				});
+				if (!draftError && draftEntry) return successResult(wrapEntry(draftEntry), {
+					isPreview: serveDrafts,
+					fallbackLocale,
+					cacheHint: cacheHint ?? {}
+				});
+			}
+			return successResult(wrapEntry(baseEntry), {
+				isPreview: serveDrafts,
+				fallbackLocale,
+				cacheHint: cacheHint ?? {}
+			});
+		}
+		return {
+			entry: null,
+			isPreview: serveDrafts,
+			cacheHint: {}
+		};
+	}
+	for (let i = 0; i < localeChain.length; i++) {
+		const locale = localeChain[i];
+		const fallbackLocale = i > 0 ? locale : void 0;
+		const { entry, error, cacheHint } = await getLiveEntry(COLLECTION_NAME, {
+			type,
+			id,
+			locale
+		});
+		if (error) return {
+			entry: null,
+			error,
+			isPreview: false,
+			cacheHint: {}
+		};
+		if (entry && isVisible(entry)) return successResult(wrapEntry(entry), {
+			isPreview: false,
+			fallbackLocale,
+			cacheHint: cacheHint ?? {}
+		});
+	}
+	return {
+		entry: null,
+		isPreview: false,
+		cacheHint: {}
+	};
+}
+/**
+* Eagerly hydrate byline data onto entry.data for one or more entries.
+*
+* Attaches `bylines` (array of ContentBylineCredit) and `byline`
+* (primary BylineSummary or null) to each entry's data object.
+* Uses batch queries to avoid N+1.
+*
+* Fails silently if the byline tables don't exist yet (pre-migration).
+*/
+async function hydrateEntryBylines(type, entries) {
+	if (entries.length === 0) return;
+	try {
+		const { getBylinesForEntries } = await import("./bylines-DyqBV9EQ.mjs").then((n) => n.t);
+		const ids = entries.map((e) => dataStr(entryData(e), "id")).filter(Boolean);
+		if (ids.length === 0) return;
+		const bylinesMap = await getBylinesForEntries(type, ids);
+		for (const entry of entries) {
+			const data = entryData(entry);
+			const dbId = dataStr(data, "id");
+			if (!dbId) continue;
+			const credits = bylinesMap.get(dbId) ?? [];
+			data.bylines = credits;
+			data.byline = credits[0]?.byline ?? null;
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : "";
+		if (!msg.includes("no such table")) console.warn("[dineway] Failed to hydrate bylines:", msg);
+	}
+}
+/**
+* Get all translations of a content item.
+*
+* Given a content entry, returns all locale variants that share the same
+* translation group. This is useful for building language switcher UI.
+*
+* @example
+* ```ts
+* import { getDinewayEntry, getTranslations } from "dineway";
+*
+* const { entry: post } = await getDinewayEntry("posts", "hello-world", { locale: "en" });
+* const { translations } = await getTranslations("posts", post.data.id);
+* // translations = [{ id: "...", locale: "en", slug: "hello-world", status: "published" }, ...]
+* ```
+*/
+async function getTranslations(type, id) {
+	try {
+		const db = (await import("./loader-qKmo0wAY.mjs").then((n) => n.r)).getDb;
+		const dbInstance = await db();
+		const { ContentRepository } = await import("./content-zSgdNmnt.mjs").then((n) => n.n);
+		const repo = new ContentRepository(dbInstance);
+		const item = await repo.findByIdOrSlug(type, id);
+		if (!item) return {
+			translationGroup: "",
+			translations: [],
+			error: /* @__PURE__ */ new Error(`Content item not found: ${id}`)
+		};
+		const group = item.translationGroup || item.id;
+		return {
+			translationGroup: group,
+			translations: (await repo.findTranslations(type, group)).map((t) => ({
+				id: t.id,
+				locale: t.locale || "en",
+				slug: t.slug,
+				status: t.status
+			}))
+		};
+	} catch (error) {
+		return {
+			translationGroup: "",
+			translations: [],
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+	}
+}
+/** Matches `{paramName}` placeholders in URL patterns */
+const URL_PARAM_PATTERN = /\{(\w+)\}/g;
+/** Convert a URL pattern like "/blog/{slug}" to a regex and param name list */
+function patternToRegex(pattern) {
+	const paramNames = [];
+	const regexStr = pattern.replace(URL_PARAM_PATTERN, (_match, name) => {
+		paramNames.push(name);
+		return "([^/]+)";
+	});
+	return {
+		regex: new RegExp(`^${regexStr}$`),
+		paramNames
+	};
+}
+/**
+* Resolve a URL path to a content entry by matching against collection URL patterns.
+*
+* Loads all collections with a `urlPattern` set, converts each pattern to a regex,
+* and tests the given path. On match, extracts the slug and fetches the entry.
+*
+* @example
+* ```ts
+* import { resolveDinewayPath } from "dineway";
+*
+* // Given pages with urlPattern "/{slug}" and posts with "/blog/{slug}":
+* const result = await resolveDinewayPath("/blog/hello-world");
+* if (result) {
+*   console.log(result.collection); // "posts"
+*   console.log(result.params.slug); // "hello-world"
+*   console.log(result.entry.data); // post data
+* }
+* ```
+*/
+async function resolveDinewayPath(path) {
+	const { getDb } = await import("./loader-qKmo0wAY.mjs").then((n) => n.r);
+	const { SchemaRegistry } = await import("./registry-DSd1GWB8.mjs").then((n) => n.r);
+	const collections = await new SchemaRegistry(await getDb()).listCollections();
+	for (const collection of collections) {
+		if (!collection.urlPattern) continue;
+		const { regex, paramNames } = patternToRegex(collection.urlPattern);
+		const match = path.match(regex);
+		if (!match) continue;
+		const params = {};
+		for (let i = 0; i < paramNames.length; i++) params[paramNames[i]] = match[i + 1];
+		const slug = params.slug;
+		if (!slug) continue;
+		const { entry } = await getDinewayEntry(collection.slug, slug);
+		if (entry) return {
+			entry,
+			collection: collection.slug,
+			params
+		};
+	}
+	return null;
+}
+
+//#endregion
+export { query_exports as a, createNoop as c, getTranslations as i, getDinewayEntry as n, resolveDinewayPath as o, getEditMeta as r, createEditable as s, getDinewayCollection as t };