dineway 0.1.9 → 0.1.12

package/dist/utils-C0ONdBul.mjs

@@ -0,0 +1,285 @@
+import { n as slugify } from "./slugify-PDTDtMXp.mjs";
+import mime from "mime/lite";
+
+//#region src/import/utils.ts
+/**
+* Shared import utilities
+*
+* Common constants and functions used across all WordPress import sources.
+*/
+/** Internal WordPress post types that should be excluded from import */
+const INTERNAL_POST_TYPES = [
+	"revision",
+	"nav_menu_item",
+	"custom_css",
+	"customize_changeset",
+	"oembed_cache",
+	"wp_global_styles",
+	"wp_navigation",
+	"wp_template",
+	"wp_template_part",
+	"attachment",
+	"wp_block"
+];
+/** Internal meta key prefixes to filter out */
+const INTERNAL_META_PREFIXES = ["_edit_", "_wp_"];
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const TRAILING_SLASHES = /\/+$/;
+const WP_JSON_SUFFIX = /\/wp-json\/?.*$/;
+/** Specific internal meta keys */
+const INTERNAL_META_KEYS = [
+	"_edit_last",
+	"_edit_lock",
+	"_pingme",
+	"_encloseme"
+];
+/** Base fields required for any WordPress import */
+const BASE_REQUIRED_FIELDS = [
+	{
+		slug: "title",
+		label: "Title",
+		type: "string",
+		required: true,
+		searchable: true
+	},
+	{
+		slug: "content",
+		label: "Content",
+		type: "portableText",
+		required: false,
+		searchable: true
+	},
+	{
+		slug: "excerpt",
+		label: "Excerpt",
+		type: "text",
+		required: false
+	}
+];
+/** Featured image field - only added to post types that have _thumbnail_id */
+const FEATURED_IMAGE_FIELD = {
+	slug: "featured_image",
+	label: "Featured Image",
+	type: "image",
+	required: false
+};
+/**
+* Check if a post type is internal/should be excluded
+*/
+function isInternalPostType(type) {
+	return INTERNAL_POST_TYPES.includes(type);
+}
+/**
+* Check if a meta key is internal/should be filtered out
+*/
+function isInternalMetaKey(key) {
+	if (INTERNAL_META_KEYS.includes(key)) return true;
+	for (const prefix of INTERNAL_META_PREFIXES) if (key.startsWith(prefix)) return true;
+	if (key === "_thumbnail_id") return false;
+	if (key.startsWith("_yoast_")) return false;
+	if (key.startsWith("_rank_math_")) return false;
+	if (key.startsWith("_")) return true;
+	return false;
+}
+/**
+* Map WordPress status to normalized status
+*/
+function mapWpStatus(status) {
+	switch (status) {
+		case "publish": return "publish";
+		case "draft": return "draft";
+		case "pending": return "pending";
+		case "private": return "private";
+		case "future": return "future";
+		default: return "draft";
+	}
+}
+/** Default mappings from WordPress post types to Dineway collections */
+const POST_TYPE_TO_COLLECTION = {
+	post: "posts",
+	page: "pages",
+	attachment: "media",
+	product: "products",
+	portfolio: "portfolio",
+	testimonial: "testimonials",
+	team: "team",
+	event: "events",
+	faq: "faqs"
+};
+/**
+* Map WordPress post type to Dineway collection name
+*/
+function mapPostTypeToCollection(postType) {
+	return POST_TYPE_TO_COLLECTION[postType] || postType;
+}
+/**
+* Map WordPress meta key to Dineway field slug
+*/
+function mapMetaKeyToField(key) {
+	if (key === "_yoast_wpseo_title") return "seo_title";
+	if (key === "_yoast_wpseo_metadesc") return "seo_description";
+	if (key === "_rank_math_title") return "seo_title";
+	if (key === "_rank_math_description") return "seo_description";
+	if (key === "_thumbnail_id") return "featured_image";
+	if (key.startsWith("_")) return key.slice(1);
+	return key;
+}
+/**
+* Infer field type from meta key name and sample value
+*/
+function inferMetaType(key, value) {
+	if (key.endsWith("_id") || key === "_thumbnail_id") return "string";
+	if (key.endsWith("_date") || key.endsWith("_time")) return "date";
+	if (key.endsWith("_count") || key.endsWith("_number")) return "number";
+	if (!value) return "string";
+	if (value.startsWith("a:") || value.startsWith("{") || value.startsWith("[")) return "json";
+	if (NUMERIC_PATTERN.test(value)) return "number";
+	if ([
+		"0",
+		"1",
+		"true",
+		"false"
+	].includes(value)) return "boolean";
+	return "string";
+}
+/**
+* Normalize URL for API requests
+*/
+function normalizeUrl(url) {
+	let normalized = url.trim();
+	if (!normalized.startsWith("http")) normalized = `https://${normalized}`;
+	normalized = normalized.replace(TRAILING_SLASHES, "");
+	normalized = normalized.replace(WP_JSON_SUFFIX, "");
+	return normalized;
+}
+/**
+* Extract filename from URL
+*/
+function getFilenameFromUrl(url) {
+	try {
+		return new URL(url).pathname.split("/").filter(Boolean).pop();
+	} catch {
+		return;
+	}
+}
+/**
+* Guess MIME type from filename
+*/
+function guessMimeType(filename) {
+	return mime.getType(filename) ?? void 0;
+}
+/**
+* Build a map of attachment IDs to URLs for resolving featured images
+*/
+function buildAttachmentMap(attachments) {
+	const map = /* @__PURE__ */ new Map();
+	for (const att of attachments) if (att.id && att.url) map.set(String(att.id), att.url);
+	return map;
+}
+/**
+* Check if two field types are compatible for import
+*/
+function isTypeCompatible(requiredType, existingType) {
+	if (requiredType === existingType) return true;
+	return {
+		string: [
+			"string",
+			"text",
+			"slug"
+		],
+		text: ["string", "text"],
+		portableText: ["portableText", "json"],
+		number: ["number", "integer"],
+		integer: ["number", "integer"]
+	}[requiredType]?.includes(existingType) ?? false;
+}
+const MAX_SLUG_COLLISION_ATTEMPTS = 1e3;
+/**
+* Find or create a unique byline slug, capped at MAX_SLUG_COLLISION_ATTEMPTS.
+*/
+async function ensureUniqueBylineSlug(bylineRepo, baseSlug) {
+	let candidate = baseSlug;
+	let suffix = 2;
+	while (await bylineRepo.findBySlug(candidate)) {
+		if (suffix > MAX_SLUG_COLLISION_ATTEMPTS) throw new Error(`Byline slug collision limit exceeded for base slug "${baseSlug}". Tried ${MAX_SLUG_COLLISION_ATTEMPTS} variants.`);
+		candidate = `${baseSlug}-${suffix}`;
+		suffix++;
+	}
+	return candidate;
+}
+/**
+* Resolve (find-or-create) a byline for an imported WordPress author.
+* Caches results in `cache` keyed by `authorLogin:mappedUserId`.
+*/
+async function resolveImportByline(authorLogin, displayName, mappedUserId, bylineRepo, cache) {
+	if (!authorLogin) return void 0;
+	const cacheKey = `${authorLogin}:${mappedUserId ?? ""}`;
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	if (mappedUserId) {
+		const existingForUser = await bylineRepo.findByUserId(mappedUserId);
+		if (existingForUser) {
+			cache.set(cacheKey, existingForUser.id);
+			return existingForUser.id;
+		}
+	}
+	const name = displayName || authorLogin;
+	const slug = await ensureUniqueBylineSlug(bylineRepo, slugify(authorLogin) || "author");
+	const created = await bylineRepo.create({
+		slug,
+		displayName: name,
+		userId: mappedUserId ?? null,
+		isGuest: !mappedUserId
+	});
+	cache.set(cacheKey, created.id);
+	return created.id;
+}
+/**
+* Check schema compatibility between required fields and existing collection
+*/
+function checkSchemaCompatibility(requiredFields, existingCollection) {
+	if (!existingCollection) {
+		const fieldStatus = {};
+		for (const field of requiredFields) fieldStatus[field.slug] = {
+			status: "missing",
+			requiredType: field.type
+		};
+		return {
+			exists: false,
+			fieldStatus,
+			canImport: true
+		};
+	}
+	const fieldStatus = {};
+	const incompatibleFields = [];
+	for (const field of requiredFields) {
+		const existingField = existingCollection.fields.get(field.slug);
+		if (!existingField) fieldStatus[field.slug] = {
+			status: "missing",
+			requiredType: field.type
+		};
+		else if (isTypeCompatible(field.type, existingField.type)) fieldStatus[field.slug] = {
+			status: "compatible",
+			existingType: existingField.type,
+			requiredType: field.type
+		};
+		else {
+			fieldStatus[field.slug] = {
+				status: "type_mismatch",
+				existingType: existingField.type,
+				requiredType: field.type
+			};
+			incompatibleFields.push(field.slug);
+		}
+	}
+	const canImport = incompatibleFields.length === 0;
+	return {
+		exists: true,
+		fieldStatus,
+		canImport,
+		reason: canImport ? void 0 : `Incompatible field types: ${incompatibleFields.join(", ")}`
+	};
+}
+
+//#endregion
+export { getFilenameFromUrl as a, isInternalMetaKey as c, mapPostTypeToCollection as d, mapWpStatus as f, checkSchemaCompatibility as i, isInternalPostType as l, resolveImportByline as m, FEATURED_IMAGE_FIELD as n, guessMimeType as o, normalizeUrl as p, buildAttachmentMap as r, inferMetaType as s, BASE_REQUIRED_FIELDS as t, mapMetaKeyToField as u };

package/dist/{validate-IPf8n4Fj.d.mts → validate-BwmQEbu8.d.mts}

@@ -1,6 +1,6 @@
-import { t as Database } from "./types-DOrVigru.mjs";
-import { i as SiteSettings, m as FieldType } from "./types-BuMDPy5C.mjs";
-import { d as Storage } from "./types-CWbdtiux.mjs";
+import { t as Database } from "./types-DZPw8Rru.mjs";
+import { i as SiteSettings, m as FieldType } from "./types-C0mmVRJN.mjs";
+import { d as Storage } from "./types-B7kpsMJ3.mjs";
 import { Kysely } from "kysely";
 
 //#region src/seed/types.d.ts

package/dist/{validate-BZ5wnLLp.mjs → validate-C7TzfamJ.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
-import { t as FIELD_TYPES } from "./types-COeOq9nK.mjs";
+import { t as FIELD_TYPES } from "./types-DL7Y8D_t.mjs";
 
 //#region src/seed/validate.ts
 /**

package/dist/version-D3vDb22n.mjs

@@ -0,0 +1,6 @@
+//#region src/version.ts
+const VERSION = "0.1.12";
+const COMMIT = "beee4572";
+
+//#endregion
+export { VERSION as n, COMMIT as t };

package/dist/widgets-B7DRpZvy.mjs

@@ -0,0 +1,104 @@
+import { r as getDb } from "./loader-PZnPxFLc.mjs";
+import { t as getWidgetComponents$1 } from "./components-BPknylYg.mjs";
+
+//#region src/widgets/index.ts
+/**
+* Get a widget area by name, with all its widgets
+*/
+async function getWidgetArea(name) {
+	const rows = await (await getDb()).selectFrom("_dineway_widget_areas as a").leftJoin("_dineway_widgets as w", "w.area_id", "a.id").select([
+		"a.id as a_id",
+		"a.name as a_name",
+		"a.label as a_label",
+		"a.description as a_description",
+		"w.id as w_id",
+		"w.type as w_type",
+		"w.title as w_title",
+		"w.content as w_content",
+		"w.menu_name as w_menu_name",
+		"w.component_id as w_component_id",
+		"w.component_props as w_component_props",
+		"w.area_id as w_area_id",
+		"w.sort_order as w_sort_order",
+		"w.created_at as w_created_at"
+	]).where("a.name", "=", name).orderBy("w.sort_order", "asc").execute();
+	const first = rows[0];
+	if (!first) return null;
+	const widgets = [];
+	for (const row of rows) {
+		if (!row.w_id || !isWidgetType(row.w_type) || !row.w_area_id || row.w_sort_order === null || !row.w_created_at) continue;
+		const widgetRow = {
+			id: row.w_id,
+			type: row.w_type,
+			title: row.w_title,
+			content: row.w_content,
+			menu_name: row.w_menu_name,
+			component_id: row.w_component_id,
+			component_props: row.w_component_props,
+			area_id: row.w_area_id,
+			sort_order: row.w_sort_order,
+			created_at: row.w_created_at
+		};
+		widgets.push(rowToWidget(widgetRow));
+	}
+	return {
+		id: first.a_id,
+		name: first.a_name,
+		label: first.a_label,
+		description: first.a_description ?? void 0,
+		widgets
+	};
+}
+function isWidgetType(value) {
+	return value === "content" || value === "menu" || value === "component";
+}
+/**
+* Get all widget areas with their widgets
+*/
+async function getWidgetAreas() {
+	const db = await getDb();
+	const areaRows = await db.selectFrom("_dineway_widget_areas").selectAll().execute();
+	const widgetRows = await db.selectFrom("_dineway_widgets").selectAll().$castTo().orderBy("sort_order", "asc").execute();
+	const widgetsByArea = /* @__PURE__ */ new Map();
+	for (const row of widgetRows) {
+		if (!widgetsByArea.has(row.area_id)) widgetsByArea.set(row.area_id, []);
+		widgetsByArea.get(row.area_id).push(rowToWidget(row));
+	}
+	return areaRows.map((areaRow) => ({
+		id: areaRow.id,
+		name: areaRow.name,
+		label: areaRow.label,
+		description: areaRow.description ?? void 0,
+		widgets: widgetsByArea.get(areaRow.id) || []
+	}));
+}
+/**
+* Get available widget components (for admin UI)
+*/
+function getWidgetComponents() {
+	return getWidgetComponents$1();
+}
+/**
+* Convert a widget row to the API type
+*/
+function rowToWidget(row) {
+	const widget = {
+		id: row.id,
+		type: row.type,
+		title: row.title ?? void 0
+	};
+	if (row.type === "content" && row.content) try {
+		widget.content = JSON.parse(row.content);
+	} catch {}
+	if (row.type === "menu" && row.menu_name) widget.menuName = row.menu_name;
+	if (row.type === "component" && row.component_id) {
+		widget.componentId = row.component_id;
+		if (row.component_props) try {
+			widget.componentProps = JSON.parse(row.component_props);
+		} catch {}
+	}
+	return widget;
+}
+
+//#endregion
+export { rowToWidget as i, getWidgetAreas as n, getWidgetComponents as r, getWidgetArea as t };

package/dist/wordpress-slugs-CnporCYH.mjs

@@ -0,0 +1,14 @@
+import { r as RESERVED_COLLECTION_SLUGS } from "./types-DL7Y8D_t.mjs";
+
+//#region src/import/wordpress-slugs.ts
+const INVALID_SLUG_CHARS = /[^a-z0-9_]/g;
+const LEADING_NON_ALPHA = /^[^a-z]+/;
+function sanitizeWordPressImportSlug(slug) {
+	const sanitized = slug.toLowerCase().replace(INVALID_SLUG_CHARS, "_").replace(LEADING_NON_ALPHA, "");
+	if (!sanitized) return "imported";
+	if (RESERVED_COLLECTION_SLUGS.includes(sanitized)) return `wp_${sanitized}`;
+	return sanitized;
+}
+
+//#endregion
+export { sanitizeWordPressImportSlug as t };

package/dist/zod-generator-DBVP8D0P.mjs

@@ -0,0 +1,132 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { n as hashString } from "./hash-CDX7M0ze.mjs";
+import { z } from "zod";
+
+//#region src/schema/zod-generator.ts
+var zod_generator_exports = /* @__PURE__ */ __exportAll({
+	generateSchemaHash: () => generateSchemaHash,
+	generateTypeScript: () => generateTypeScript,
+	generateTypesFile: () => generateTypesFile
+});
+/** Pattern to split on underscores, hyphens, and spaces for PascalCase conversion */
+const PASCAL_CASE_SPLIT_PATTERN = /[_\-\s]+/;
+/**
+* Generate TypeScript interface from field definitions
+* Used by CLI `dineway types` to generate types
+*/
+function generateTypeScript(collection) {
+	const interfaceName = getInterfaceName(collection);
+	const lines = [];
+	lines.push(`export interface ${interfaceName} {`);
+	lines.push(`  id: string;`);
+	lines.push(`  slug: string | null;`);
+	lines.push(`  status: string;`);
+	for (const field of collection.fields) {
+		const tsType = fieldTypeToTypeScript(field);
+		const optional = field.required ? "" : "?";
+		lines.push(`  ${field.slug}${optional}: ${tsType};`);
+	}
+	lines.push(`  createdAt: Date;`);
+	lines.push(`  updatedAt: Date;`);
+	lines.push(`  publishedAt: Date | null;`);
+	lines.push(`  bylines?: ContentBylineCredit[];`);
+	lines.push(`}`);
+	return lines.join("\n");
+}
+/**
+* Generate a complete types file with module augmentation
+* This produces dineway-env.d.ts content that provides typed query functions
+*/
+function generateTypesFile(collections) {
+	const lines = [];
+	lines.push(`// Generated by Dineway on dev server start`);
+	lines.push(`// Do not edit manually`);
+	lines.push(``);
+	lines.push(`/// <reference types="dineway/locals" />`);
+	lines.push(``);
+	const needsPortableText = collections.some((c) => c.fields.some((f) => f.type === "portableText"));
+	const imports = ["ContentBylineCredit"];
+	if (needsPortableText) imports.push("PortableTextBlock");
+	lines.push(`import type { ${imports.join(", ")} } from "dineway";`);
+	lines.push(``);
+	for (const collection of collections) {
+		lines.push(generateTypeScript(collection));
+		lines.push(``);
+	}
+	lines.push(`declare module "dineway" {`);
+	lines.push(`  interface DinewayCollections {`);
+	for (const collection of collections) {
+		const interfaceName = getInterfaceName(collection);
+		lines.push(`    ${collection.slug}: ${interfaceName};`);
+	}
+	lines.push(`  }`);
+	lines.push(`}`);
+	return lines.join("\n");
+}
+/**
+* Generate schema hash for cache invalidation
+*/
+async function generateSchemaHash(collections) {
+	return hashString(JSON.stringify(collections.map((c) => ({
+		slug: c.slug,
+		fields: c.fields.map((f) => ({
+			slug: f.slug,
+			type: f.type,
+			required: f.required,
+			validation: f.validation
+		}))
+	}))));
+}
+/**
+* Map field type to TypeScript type
+*/
+function fieldTypeToTypeScript(field) {
+	switch (field.type) {
+		case "string":
+		case "text":
+		case "url":
+		case "slug":
+		case "datetime": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "select":
+			const options = field.validation?.options;
+			if (options && options.length > 0) return options.map((o) => `"${o}"`).join(" | ");
+			return "string";
+		case "multiSelect":
+			const multiOptions = field.validation?.options;
+			if (multiOptions && multiOptions.length > 0) return `(${multiOptions.map((o) => `"${o}"`).join(" | ")})[]`;
+			return "string[]";
+		case "portableText": return "PortableTextBlock[]";
+		case "image": return "{ id: string; src?: string; alt?: string; width?: number; height?: number }";
+		case "file": return "{ id: string; src?: string; filename?: string; mimeType?: string; size?: number }";
+		case "reference": return "string";
+		case "json": return "unknown";
+		default: return "unknown";
+	}
+}
+/**
+* Convert string to PascalCase (handles slugs, spaces, etc.)
+*/
+function pascalCase(str) {
+	return str.split(PASCAL_CASE_SPLIT_PATTERN).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/**
+* Simple singularization - handles common cases
+*/
+function singularize(str) {
+	if (str.endsWith("ies")) return str.slice(0, -3) + "y";
+	if (str.endsWith("es") && (str.endsWith("sses") || str.endsWith("xes") || str.endsWith("ches") || str.endsWith("shes"))) return str.slice(0, -2);
+	if (str.endsWith("s") && !str.endsWith("ss")) return str.slice(0, -1);
+	return str;
+}
+/**
+* Get the interface name for a collection
+*/
+function getInterfaceName(collection) {
+	return pascalCase(collection.labelSingular || singularize(collection.slug));
+}
+
+//#endregion
+export { zod_generator_exports as n, generateTypeScript as t };

package/locals.d.ts

@@ -7,7 +7,7 @@
 
 import type { User } from "@dineway-ai/auth";
 
-import type { DinewayHandlers, DinewayManifest } from "./dist/types.d.mts";
+import type { DinewayHandlers } from "./dist/types.d.mts";
 
 declare global {
 	namespace App {
@@ -17,11 +17,6 @@ declare global {
 			 */
 			dineway: DinewayHandlers;
 
-			/**
-			 * Dineway manifest - the serialized admin configuration
-			 */
-			dinewayManifest: DinewayManifest;
-
 			/**
 			 * Authenticated user - set by auth middleware when a valid session exists
 			 */