dineway 0.1.11 → 0.1.13

package/dist/menus-DYW_UHjv.mjs

@@ -0,0 +1,256 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as CommentRepository } from "./comment-DFO-gWDH.mjs";
+import { r as getDb } from "./loader-PZnPxFLc.mjs";
+import { n as requestCached } from "./request-cache-DHMRr2Lf.mjs";
+import { n as sanitizeHref } from "./url-DNjT2abR.mjs";
+import { sql } from "kysely";
+
+//#region src/comments/query.ts
+/**
+* Get approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getComments } from "dineway";
+*
+* const { items, total } = await getComments({
+*   collection: "posts",
+*   contentId: post.id,
+*   threaded: true,
+* });
+* ```
+*/
+async function getComments(options) {
+	return getCommentsWithDb(await getDb(), options);
+}
+/**
+* Get approved comments with an explicit db handle.
+*
+* @internal Use `getComments()` in templates. This variant is for routes
+* that already have a database handle.
+*/
+async function getCommentsWithDb(db, options) {
+	const repo = new CommentRepository(db);
+	const total = await repo.countByContent(options.collection, options.contentId, "approved");
+	const result = await repo.findByContent(options.collection, options.contentId, {
+		status: "approved",
+		limit: 500
+	});
+	if (options.threaded) return {
+		items: CommentRepository.assembleThreads(result.items).map((c) => CommentRepository.toPublicComment(c)),
+		total
+	};
+	return {
+		items: result.items.map((c) => CommentRepository.toPublicComment(c)),
+		total
+	};
+}
+/**
+* Get the count of approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getCommentCount } from "dineway";
+*
+* const count = await getCommentCount("posts", post.id);
+* ```
+*/
+async function getCommentCount(collection, contentId) {
+	return getCommentCountWithDb(await getDb(), collection, contentId);
+}
+/**
+* Get comment count with an explicit db handle.
+*
+* @internal Use `getCommentCount()` in templates.
+*/
+async function getCommentCountWithDb(db, collection, contentId) {
+	return new CommentRepository(db).countByContent(collection, contentId, "approved");
+}
+
+//#endregion
+//#region src/menus/index.ts
+/**
+* Get menu by name with resolved URLs
+*
+* @example
+* ```ts
+* import { getMenu } from "dineway";
+*
+* const menu = await getMenu("primary");
+* if (menu) {
+*   console.log(menu.items); // Array of MenuItem with resolved URLs
+* }
+* ```
+*/
+function getMenu(name) {
+	return requestCached(`menu:${name}`, async () => {
+		return getMenuWithDb(name, await getDb());
+	});
+}
+/**
+* Get menu by name with resolved URLs (with explicit db)
+*
+* @internal Use `getMenu()` in templates. This variant is for admin routes
+* that already have a database handle.
+*/
+async function getMenuWithDb(name, db) {
+	const menuRow = await db.selectFrom("_dineway_menus").selectAll().where("name", "=", name).executeTakeFirst();
+	if (!menuRow) return null;
+	const items = await buildMenuTree(await db.selectFrom("_dineway_menu_items").selectAll().$castTo().where("menu_id", "=", menuRow.id).orderBy("sort_order", "asc").execute(), db);
+	return {
+		id: menuRow.id,
+		name: menuRow.name,
+		label: menuRow.label,
+		items
+	};
+}
+/**
+* Get all menus (without items - for admin list)
+*
+* @example
+* ```ts
+* import { getMenus } from "dineway";
+*
+* const menus = await getMenus();
+* console.log(menus); // [{ id, name, label }]
+* ```
+*/
+async function getMenus() {
+	return getMenusWithDb(await getDb());
+}
+/**
+* Get all menus (with explicit db)
+*
+* @internal Use `getMenus()` in templates. This variant is for admin routes
+* that already have a database handle.
+*/
+async function getMenusWithDb(db) {
+	return await db.selectFrom("_dineway_menus").select([
+		"id",
+		"name",
+		"label"
+	]).orderBy("name", "asc").execute();
+}
+/**
+* Build hierarchical menu tree from flat array of items
+*/
+async function buildMenuTree(items, db) {
+	const collectionSlugs = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		if (item.reference_collection) collectionSlugs.add(item.reference_collection);
+		if (item.type === "page" || item.type === "post") collectionSlugs.add(item.reference_collection || `${item.type}s`);
+	}
+	const urlPatterns = /* @__PURE__ */ new Map();
+	if (collectionSlugs.size > 0) {
+		const rows = await db.selectFrom("_dineway_collections").select(["slug", "url_pattern"]).where("slug", "in", [...collectionSlugs]).execute();
+		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
+	}
+	const validItems = (await Promise.all(items.map((item) => resolveMenuItem(item, db, urlPatterns)))).filter((item) => item !== null);
+	const itemMap = /* @__PURE__ */ new Map();
+	const rootItems = [];
+	for (const item of validItems) itemMap.set(item.id, {
+		...item,
+		children: []
+	});
+	for (const item of items) {
+		const menuItem = itemMap.get(item.id);
+		if (!menuItem) continue;
+		if (item.parent_id) {
+			const parent = itemMap.get(item.parent_id);
+			if (parent) parent.children.push(menuItem);
+			else rootItems.push(menuItem);
+		} else rootItems.push(menuItem);
+	}
+	return rootItems;
+}
+/**
+* Resolve a single menu item's URL
+*
+* Returns null if the referenced content no longer exists (item should be skipped)
+*/
+async function resolveMenuItem(item, db, urlPatterns) {
+	let url;
+	try {
+		switch (item.type) {
+			case "custom":
+				url = item.custom_url || "#";
+				break;
+			case "page":
+			case "post":
+				url = await resolveContentUrl(item.reference_collection || `${item.type}s`, item.reference_id, db, urlPatterns);
+				if (url === null) return null;
+				break;
+			case "taxonomy":
+				url = await resolveTaxonomyUrl(item.reference_id, db);
+				if (url === null) return null;
+				break;
+			case "collection":
+				url = `/${item.reference_collection}/`;
+				break;
+			default: if (item.reference_collection && item.reference_id) {
+				url = await resolveContentUrl(item.reference_collection, item.reference_id, db, urlPatterns);
+				if (url === null) return null;
+			} else url = "#";
+		}
+	} catch (error) {
+		console.error(`Failed to resolve menu item ${item.id}:`, error);
+		return null;
+	}
+	return {
+		id: item.id,
+		label: item.label,
+		url: sanitizeHref(url),
+		target: item.target || void 0,
+		titleAttr: item.title_attr || void 0,
+		cssClasses: item.css_classes || void 0,
+		children: []
+	};
+}
+const SLUG_PLACEHOLDER = /\{slug\}/g;
+const ID_PLACEHOLDER = /\{id\}/g;
+/**
+* Interpolate a URL pattern with entry data
+*
+* Replaces `{slug}` and `{id}` placeholders.
+*/
+function interpolateUrlPattern(pattern, slug, id) {
+	return pattern.replace(SLUG_PLACEHOLDER, slug).replace(ID_PLACEHOLDER, id);
+}
+/**
+* Resolve URL for a content entry (page/post)
+*
+* Uses the collection's url_pattern if set, otherwise falls back to /{collection}/{slug}.
+* Returns null if content not found (item should be skipped).
+*/
+async function resolveContentUrl(collection, entryId, db, urlPatterns) {
+	if (!entryId) return null;
+	try {
+		validateIdentifier(collection, "menu item collection");
+		const row = (await sql`
+			SELECT slug FROM ${sql.ref(`ec_${collection}`)} WHERE id = ${entryId} LIMIT 1
+		`.execute(db)).rows[0];
+		if (row) {
+			const pattern = urlPatterns.get(collection);
+			if (pattern) return interpolateUrlPattern(pattern, row.slug, entryId);
+			return `/${collection}/${row.slug}`;
+		}
+		return null;
+	} catch (error) {
+		console.error(`Failed to resolve content URL for ${collection}/${entryId}:`, error);
+		return null;
+	}
+}
+/**
+* Resolve URL for a taxonomy term
+*
+* Returns null if taxonomy not found (item should be skipped)
+*/
+async function resolveTaxonomyUrl(taxonomyId, db) {
+	if (!taxonomyId) return null;
+	const taxonomy = await db.selectFrom("taxonomies").select(["name", "slug"]).where("id", "=", taxonomyId).executeTakeFirst();
+	if (!taxonomy) return null;
+	return `/${taxonomy.name}/${taxonomy.slug}`;
+}
+
+//#endregion
+export { getComments as i, getMenus as n, getCommentCount as r, getMenu as t };

package/dist/{oauth-authorization-C1qiw4hd.mjs → oauth-authorization-DxGjiWKL.mjs}

@@ -1,8 +1,8 @@
 import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
-import { a as filterExperimentalSiteContextWorkflowScopes, i as experimentalSiteContextWorkflowsEnabled, o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-DldxJlqV.mjs";
-import { a as hashApiToken, n as TOKEN_PREFIXES, r as generatePrefixedToken, t as ALL_VALID_SCOPES } from "./api-tokens-DzloJxuh.mjs";
-import { c as validateRedirectUri, o as lookupOAuthClient, s as validateClientRedirectUri } from "./oauth-clients-CvWatf5p.mjs";
-import { t as lookupUserRoleAndStatus } from "./oauth-user-lookup-B4OcmsLV.mjs";
+import { a as filterExperimentalSiteContextWorkflowScopes, i as experimentalSiteContextWorkflowsEnabled, o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-C9X7yblQ.mjs";
+import { a as hashApiToken, n as TOKEN_PREFIXES, r as generatePrefixedToken, t as ALL_VALID_SCOPES } from "./api-tokens-CPjC3zf8.mjs";
+import { c as validateRedirectUri, o as lookupOAuthClient, s as validateClientRedirectUri } from "./oauth-clients-DxO_NO7k.mjs";
+import { t as lookupUserRoleAndStatus } from "./oauth-user-lookup-Bi0ek9eM.mjs";
 import { clampScopes, computeS256Challenge, secureCompare } from "@dineway-ai/auth";
 import { generateCodeVerifier } from "arctic";
 

package/dist/{oauth-clients-CvWatf5p.mjs → oauth-clients-DxO_NO7k.mjs}

@@ -1,5 +1,5 @@
-import { o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-DldxJlqV.mjs";
-import { o as validateScopes } from "./api-tokens-DzloJxuh.mjs";
+import { o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-C9X7yblQ.mjs";
+import { o as validateScopes } from "./api-tokens-CPjC3zf8.mjs";
 
 //#region src/api/oauth/redirect-uri.ts
 /**

package/dist/page/index.d.mts

@@ -1,143 +1,6 @@
-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";
+import { A as PageMetadataContribution, D as PageFragmentContribution, q as PublicPageContext } from "../types-Q616b2Hn.mjs";
+import { a as generateSiteSeoContributions, c as ResolvedPageMetadata, d as resolvePageMetadata, f as safeJsonLdSerialize, i as generateBaseSeoContributions, l as escapeHtmlAttr, m as createPublicPageContext, n as buildWebSiteJsonLd, o as renderFragments, p as CreatePublicPageContextInput, r as cleanJsonLd, s as resolveFragments, t as buildBlogPostingJsonLd, u as renderPageMetadata } from "../jsonld-D2gUY4kA.mjs";
 
-//#region src/page/context.d.ts
-/** Fields shared by both input forms */
-interface PageContextFields {
-  kind: "content" | "custom";
-  pageType?: string;
-  title?: string | null;
-  pageTitle?: string | null;
-  description?: string | null;
-  canonical?: string | null;
-  image?: string | null;
-  content?: {
-    collection: string;
-    id: string;
-    slug?: string | null;
-  };
-  /** SEO overrides for OG/Twitter meta generation */
-  seo?: {
-    ogTitle?: string | null;
-    ogDescription?: string | null;
-    ogImage?: string | null;
-    robots?: string | null;
-  };
-  /** Article metadata for Open Graph article: tags */
-  articleMeta?: {
-    publishedTime?: string | null;
-    modifiedTime?: string | null;
-    author?: string | null;
-  };
-  /** Site name for structured data and og:site_name */
-  siteName?: string;
-  /**
-   * Breadcrumb trail for this page, root first. Pass an empty array
-   * to explicitly opt out of breadcrumbs (e.g. homepage), or omit the
-   * field to let consumers fall back to their own derivation.
-   */
-  breadcrumbs?: BreadcrumbItem[];
-  /** Public-facing site URL (origin) for structured data */
-  siteUrl?: string;
-}
-/** Input with Astro global -- used in .astro files */
-interface AstroInput extends PageContextFields {
-  Astro: {
-    url: URL;
-    currentLocale?: string;
-  };
-}
-/** Input with explicit URL -- used outside .astro files */
-interface UrlInput extends PageContextFields {
-  url: URL | string;
-  locale?: string;
-}
-type CreatePublicPageContextInput = AstroInput | UrlInput;
-/**
- * Build a PublicPageContext from template input.
- */
-declare function createPublicPageContext(input: CreatePublicPageContextInput): PublicPageContext;
-//#endregion
-//#region src/page/metadata.d.ts
-interface ResolvedPageMetadata {
-  meta: Array<{
-    name: string;
-    content: string;
-  }>;
-  properties: Array<{
-    property: string;
-    content: string;
-  }>;
-  links: Array<{
-    rel: PageMetadataLinkRel;
-    href: string;
-    hreflang?: string;
-  }>;
-  jsonld: Array<{
-    id?: string;
-    json: string;
-  }>;
-}
-/** Escape a string for safe use in an HTML attribute value */
-declare function escapeHtmlAttr(value: string): string;
-/**
- * Safely serialize a value for embedding in a <script type="application/ld+json"> tag.
- *
- * Plain JSON.stringify is not sufficient because:
- * - "</script>" in a nested string breaks out of the script tag
- * - "<!--" can open an HTML comment
- * - U+2028/U+2029 are line terminators in some JS engines
- */
-declare function safeJsonLdSerialize(value: unknown): string;
-/**
- * Resolve a flat list of contributions into deduplicated metadata.
- * First contribution wins for any given dedupe key.
- */
-declare function resolvePageMetadata(contributions: PageMetadataContribution[]): ResolvedPageMetadata;
-/** Render resolved metadata to an HTML string for embedding in <head> */
-declare function renderPageMetadata(metadata: ResolvedPageMetadata): string;
-//#endregion
-//#region src/page/fragments.d.ts
-/**
- * Filter contributions to a specific placement and deduplicate.
- * - Contributions with the same `key + placement` are deduped (first wins).
- * - External scripts with the same `src + placement` are deduped.
- */
-declare function resolveFragments(contributions: PageFragmentContribution[], placement: PagePlacement): PageFragmentContribution[];
-/** Render a list of fragment contributions to an HTML string */
-declare function renderFragments(contributions: PageFragmentContribution[], placement: PagePlacement): string;
-//#endregion
-//#region src/page/seo-contributions.d.ts
-/**
- * Generate base metadata contributions from a page context's SEO data.
- * Returns an empty array if no SEO-relevant data is present.
- */
-declare function generateBaseSeoContributions(page: PublicPageContext): PageMetadataContribution[];
-/**
- * Generate site-level SEO metadata contributions from SiteSettings.seo.
- *
- * These tags apply to every page, so they're sourced from global site settings
- * rather than page-specific context.
- */
-declare function generateSiteSeoContributions(seoSettings: SeoSettings | undefined): PageMetadataContribution[];
-//#endregion
-//#region src/page/jsonld.d.ts
-/**
- * Remove null/undefined values from a JSON-LD object recursively.
- * JSON-LD validators prefer absent keys over null values.
- */
-declare function cleanJsonLd(obj: Record<string, unknown>): Record<string, unknown>;
-/**
- * Build a BlogPosting JSON-LD graph from page context.
- * Used for article-type content pages.
- */
-declare function buildBlogPostingJsonLd(page: PublicPageContext): Record<string, unknown> | null;
-/**
- * Build a WebSite JSON-LD graph from page context.
- * Used for non-article pages (homepage, listing pages, etc.)
- */
-declare function buildWebSiteJsonLd(page: PublicPageContext): Record<string, unknown> | null;
-//#endregion
 //#region src/page/index.d.ts
 /**
  * Shape of the Dineway runtime methods used by the render components.