emdash 0.0.0-b → 0.0.1

package/src/api/schemas/widgets.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Widgets: Input schemas
+// ---------------------------------------------------------------------------
+
+const widgetType = z.enum(["content", "menu", "component"]);
+
+export const createWidgetAreaBody = z
+	.object({
+		name: z.string().min(1),
+		label: z.string().min(1),
+		description: z.string().optional(),
+	})
+	.meta({ id: "CreateWidgetAreaBody" });
+
+export const createWidgetBody = z
+	.object({
+		type: widgetType,
+		title: z.string().optional(),
+		content: z.array(z.record(z.string(), z.unknown())).optional(),
+		menuName: z.string().optional(),
+		componentId: z.string().optional(),
+		componentProps: z.record(z.string(), z.unknown()).optional(),
+	})
+	.meta({ id: "CreateWidgetBody" });
+
+export const updateWidgetBody = z
+	.object({
+		type: widgetType.optional(),
+		title: z.string().optional(),
+		content: z.array(z.record(z.string(), z.unknown())).optional(),
+		menuName: z.string().optional(),
+		componentId: z.string().optional(),
+		componentProps: z.record(z.string(), z.unknown()).optional(),
+	})
+	.meta({ id: "UpdateWidgetBody" });
+
+export const reorderWidgetsBody = z
+	.object({
+		widgetIds: z.array(z.string().min(1)),
+	})
+	.meta({ id: "ReorderWidgetsBody" });
+
+// ---------------------------------------------------------------------------
+// Widgets: Response schemas
+// ---------------------------------------------------------------------------
+
+export const widgetAreaSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		description: z.string().nullable(),
+		created_at: z.string(),
+		updated_at: z.string(),
+	})
+	.meta({ id: "WidgetArea" });
+
+export const widgetSchema = z
+	.object({
+		id: z.string(),
+		area_id: z.string(),
+		type: z.string(),
+		title: z.string().nullable(),
+		content: z.string().nullable(),
+		menu_name: z.string().nullable(),
+		component_id: z.string().nullable(),
+		component_props: z.string().nullable(),
+		sort_order: z.number().int(),
+		created_at: z.string(),
+		updated_at: z.string(),
+	})
+	.meta({ id: "Widget" });
+
+export const widgetAreaWithWidgetsSchema = widgetAreaSchema
+	.extend({
+		widgets: z.array(widgetSchema),
+	})
+	.meta({ id: "WidgetAreaWithWidgets" });

package/src/api/site-url.ts

@@ -0,0 +1,25 @@
+/**
+ * Resolve the canonical site base URL for use in outbound links (emails, etc.).
+ *
+ * Uses the stored `emdash:site_url` (set during setup on the real domain)
+ * so that Host header spoofing in later requests cannot redirect users to
+ * attacker-controlled domains.
+ *
+ * Falls back to the request URL only if no stored value exists (pre-setup).
+ */
+
+import type { Kysely } from "kysely";
+
+import { OptionsRepository } from "../database/repositories/options.js";
+import type { Database } from "../database/types.js";
+
+export async function getSiteBaseUrl(db: Kysely<Database>, request: Request): Promise<string> {
+	const options = new OptionsRepository(db);
+	const storedUrl = await options.get<string>("emdash:site_url");
+	if (storedUrl) {
+		return `${storedUrl}/_emdash`;
+	}
+	// Fallback: derive from request (only reached before setup completes)
+	const url = new URL(request.url);
+	return `${url.protocol}//${url.host}/_emdash`;
+}

package/src/api/types.ts

@@ -0,0 +1,82 @@
+/**
+ * API types for EmDash REST endpoints
+ */
+
+import type { ContentItem } from "../database/repositories/types.js";
+
+/**
+ * List response with cursor pagination
+ */
+export interface ListResponse<T> {
+	items: T[];
+	nextCursor?: string;
+}
+
+/**
+ * Content API responses
+ */
+export interface ContentListResponse extends ListResponse<ContentItem> {}
+
+export interface ContentResponse {
+	item: ContentItem;
+	/** Opaque revision token for optimistic concurrency */
+	_rev?: string;
+}
+
+/**
+ * Manifest API response
+ */
+export interface ManifestResponse {
+	version: string;
+	hash: string;
+	collections: Record<
+		string,
+		{
+			label: string;
+			labelSingular: string;
+			supports: string[];
+			fields: Record<string, FieldDescriptor>;
+		}
+	>;
+	plugins: Record<
+		string,
+		{
+			adminPages?: Array<{ path: string; component: string }>;
+			widgets?: string[];
+		}
+	>;
+}
+
+export interface FieldDescriptor {
+	kind: string;
+	label?: string;
+	required?: boolean;
+	options?: Array<{ value: string; label: string }>;
+}
+
+/**
+ * Discriminated union for handler results.
+ *
+ * Handlers return `ApiResult<T>` -- either `{ success: true, data: T }` or
+ * `{ success: false, error: { code, message } }`. The `success` literal
+ * enables TypeScript narrowing on `.data`.
+ *
+ * The generic `E` parameter defaults to `ErrorCode` but can be narrowed to
+ * `OAuthErrorCode` for OAuth token-endpoint handlers.
+ *
+ * Use `unwrapResult()` from `error.ts` to convert to an HTTP Response.
+ */
+export type ApiResult<T, E extends string = string> =
+	| { success: true; data: T }
+	| {
+			success: false;
+			error: { code: E; message: string; details?: Record<string, unknown> };
+	  };
+
+/**
+ * API request context
+ */
+export interface ApiContext {
+	userId?: string;
+	userRole?: string;
+}

package/src/astro/index.ts

@@ -0,0 +1,27 @@
+/**
+ * emdash/astro
+ *
+ * Astro integration for EmDash CMS (build-time only)
+ *
+ * For runtime APIs (loader, query functions, dialects), import from "emdash" directly.
+ * For Cloudflare-specific adapters (d1, r2, access), import from "@emdash-cms/cloudflare".
+ */
+
+// Locals types (for typing Astro.locals in API routes)
+export type {
+	EmDashHandlers,
+	EmDashManifest,
+	MediaItem,
+	ContentItem,
+	ManifestCollection,
+} from "./types.js";
+
+// Storage adapters (for integration config)
+// Note: For R2 bindings, use `r2()` from `@emdash-cms/cloudflare`
+export { local, s3 } from "./storage/index.js";
+export type { StorageDescriptor, LocalStorageConfig, S3StorageConfig } from "./storage/index.js";
+
+// Integration (build-time only - the emdash() function uses Node.js APIs)
+export { default } from "./integration/index.js";
+export { getStoredConfig } from "./integration/runtime.js";
+export type { EmDashConfig, ResolvedPlugin } from "./integration/runtime.js";

package/src/astro/integration/index.ts

@@ -0,0 +1,303 @@
+/**
+ * EmDash Astro Integration
+ *
+ * This integration:
+ * - Injects the admin shell route at /_emdash/admin/[...path].astro
+ * - Sets up REST API endpoints under /_emdash/api/*
+ * - Configures middleware to provide database and manifest
+ *
+ * NOTE: This file is for build-time only. Runtime utilities are in runtime.ts
+ * to avoid bundling Node.js-only code into the production build.
+ */
+
+import type { AstroIntegration, AstroIntegrationLogger } from "astro";
+
+import type { ResolvedPlugin } from "../../plugins/types.js";
+import { local } from "../storage/adapters.js";
+import { injectCoreRoutes, injectBuiltinAuthRoutes, injectMcpRoute } from "./routes.js";
+import type { EmDashConfig, PluginDescriptor } from "./runtime.js";
+import { createViteConfig } from "./vite-config.js";
+
+// Re-export runtime types and functions
+export type {
+	EmDashConfig,
+	PluginDescriptor,
+	SandboxedPluginDescriptor,
+	ResolvedPlugin,
+} from "./runtime.js";
+export { getStoredConfig } from "./runtime.js";
+
+/** Default storage: Local filesystem in .emdash directory */
+const DEFAULT_STORAGE = local({
+	directory: "./.emdash/uploads",
+	baseUrl: "/_emdash/api/media/file",
+});
+
+// Terminal formatting
+const dim = (s: string) => `\x1b[2m${s}\x1b[22m`;
+const bold = (s: string) => `\x1b[1m${s}\x1b[22m`;
+const cyan = (s: string) => `\x1b[36m${s}\x1b[39m`;
+
+/** Print the EmDash startup banner */
+function printBanner(_logger: AstroIntegrationLogger): void {
+	const banner = `
+
+  ${bold(cyan("E C L I P T I C"))}
+   `;
+	console.log(banner);
+}
+
+/** Print route injection summary */
+function printRoutesSummary(_logger: AstroIntegrationLogger): void {
+	console.log(`\n  ${dim("›")} Admin UI    ${cyan("/_emdash/admin")}`);
+	console.log(`  ${dim("›")} API         ${cyan("/_emdash/api/*")}`);
+	console.log("");
+}
+
+/**
+ * Create the EmDash Astro integration
+ */
+export function emdash(config: EmDashConfig = {}): AstroIntegration {
+	// Apply defaults
+	const resolvedConfig: EmDashConfig = {
+		...config,
+		storage: config.storage ?? DEFAULT_STORAGE,
+	};
+
+	// Validate marketplace URL
+	if (resolvedConfig.marketplace) {
+		const url = resolvedConfig.marketplace;
+		try {
+			const parsed = new URL(url);
+			const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+			if (parsed.protocol !== "https:" && !isLocalhost) {
+				throw new Error(
+					`Marketplace URL must use HTTPS (got ${parsed.protocol}). ` +
+						`Only localhost URLs are allowed over HTTP.`,
+				);
+			}
+		} catch (e) {
+			if (e instanceof TypeError) {
+				throw new Error(`Invalid marketplace URL: "${url}"`, { cause: e });
+			}
+			throw e;
+		}
+		if (!resolvedConfig.sandboxRunner) {
+			throw new Error(
+				"Marketplace requires `sandboxRunner` to be configured. " +
+					"Marketplace plugins run in sandboxed V8 isolates.",
+			);
+		}
+	}
+
+	// Plugin descriptors from config
+	const pluginDescriptors = resolvedConfig.plugins ?? [];
+	const sandboxedDescriptors = resolvedConfig.sandboxed ?? [];
+
+	// Validate all plugin descriptors
+	for (const descriptor of [...pluginDescriptors, ...sandboxedDescriptors]) {
+		// Standard-format plugins can't use features that require trusted mode
+		if (descriptor.format === "standard") {
+			if (descriptor.adminEntry) {
+				throw new Error(
+					`Plugin "${descriptor.id}" is standard format but declares adminEntry. ` +
+						`Standard plugins use Block Kit for admin UI, not React components. ` +
+						`Remove adminEntry or change format to "native".`,
+				);
+			}
+			if (descriptor.componentsEntry) {
+				throw new Error(
+					`Plugin "${descriptor.id}" is standard format but declares componentsEntry. ` +
+						`Portable Text block components require native format. ` +
+						`Remove componentsEntry or change format to "native".`,
+				);
+			}
+		}
+	}
+
+	// Validate: non-standard plugins cannot be placed in sandboxed: []
+	for (const descriptor of sandboxedDescriptors) {
+		if (descriptor.format !== "standard") {
+			throw new Error(
+				`Plugin "${descriptor.id}" uses the native format and cannot be placed in ` +
+					`\`sandboxed: []\`. Native plugins can only run in \`plugins: []\`. ` +
+					`To sandbox this plugin, convert it to the standard format.`,
+			);
+		}
+	}
+
+	// Resolved plugins (populated at build time by importing entrypoints)
+	let _resolvedPlugins: ResolvedPlugin[] = [];
+
+	// Serialize config for virtual module (database/storage/auth - plugins handled separately)
+	// i18n is populated in astro:config:setup from astroConfig.i18n
+	const serializableConfig: Record<string, unknown> = {
+		database: resolvedConfig.database,
+		storage: resolvedConfig.storage,
+		auth: resolvedConfig.auth,
+		marketplace: resolvedConfig.marketplace,
+	};
+
+	// Determine auth mode for route injection
+	// Check if auth is an AuthDescriptor (has entrypoint) indicating external auth
+	const useExternalAuth = !!(resolvedConfig.auth && "entrypoint" in resolvedConfig.auth);
+
+	return {
+		name: "emdash",
+		hooks: {
+			"astro:config:setup": ({
+				injectRoute,
+				addMiddleware,
+				logger,
+				updateConfig,
+				config: astroConfig,
+				command,
+			}) => {
+				printBanner(logger);
+				// Extract i18n config from Astro config
+				// Astro locales can be strings OR { path, codes } objects — normalize to paths
+				if (astroConfig.i18n) {
+					const routing = astroConfig.i18n.routing;
+					serializableConfig.i18n = {
+						defaultLocale: astroConfig.i18n.defaultLocale,
+						locales: astroConfig.i18n.locales.map((l) => (typeof l === "string" ? l : l.path)),
+						fallback: astroConfig.i18n.fallback,
+						prefixDefaultLocale:
+							typeof routing === "object" ? (routing.prefixDefaultLocale ?? false) : false,
+					};
+				}
+
+				// Update Vite config with virtual modules and other settings
+				updateConfig({
+					vite: createViteConfig(
+						{
+							serializableConfig,
+							resolvedConfig,
+							pluginDescriptors,
+							astroConfig,
+						},
+						command,
+					),
+				});
+
+				// Inject all core routes
+				injectCoreRoutes(injectRoute);
+
+				// Only inject passkey/oauth/magic-link routes when NOT using external auth
+				if (!useExternalAuth) {
+					injectBuiltinAuthRoutes(injectRoute);
+				}
+
+				// Inject MCP endpoint when enabled
+				if (resolvedConfig.mcp) {
+					injectMcpRoute(injectRoute);
+					logger.info("MCP server enabled at /_emdash/api/mcp");
+				}
+
+				// In playground mode, inject the playground middleware FIRST.
+				// It sets up a per-session DO database in ALS before anything
+				// else runs, so the runtime init middleware sees a real DB.
+				if (resolvedConfig.playground) {
+					addMiddleware({
+						entrypoint: resolvedConfig.playground.middlewareEntrypoint,
+						order: "pre",
+					});
+				}
+
+				// Add middleware to provide database and manifest
+				addMiddleware({
+					entrypoint: "emdash/middleware",
+					order: "pre",
+				});
+
+				// Add redirect middleware (runs after runtime init, before setup/auth)
+				addMiddleware({
+					entrypoint: "emdash/middleware/redirect",
+					order: "pre",
+				});
+
+				// Skip setup and auth in playground mode -- the playground middleware
+				// handles session creation and injects an anonymous admin user.
+				if (!resolvedConfig.playground) {
+					addMiddleware({
+						entrypoint: "emdash/middleware/setup",
+						order: "pre",
+					});
+
+					addMiddleware({
+						entrypoint: "emdash/middleware/auth",
+						order: "pre",
+					});
+				}
+
+				// Add request context middleware (runs after auth, on ALL routes)
+				// Sets up ALS-based context for query functions (edit mode, preview)
+				addMiddleware({
+					entrypoint: "emdash/middleware/request-context",
+					order: "pre",
+				});
+
+				printRoutesSummary(logger);
+			},
+			"astro:server:setup": ({ server, logger }) => {
+				// Generate types once the server is listening.
+				// The endpoint returns the types content; we write the file here
+				// (in Node) because workerd has no real filesystem access.
+				server.httpServer?.once("listening", async () => {
+					const { writeFile, readFile } = await import("node:fs/promises");
+					const { resolve } = await import("node:path");
+
+					const address = server.httpServer?.address();
+					if (!address || typeof address === "string") return;
+
+					const port = address.port;
+					const typegenUrl = `http://localhost:${port}/_emdash/api/typegen`;
+					const outputPath = resolve(process.cwd(), "emdash-env.d.ts");
+
+					try {
+						const response = await fetch(typegenUrl, {
+							method: "POST",
+							headers: { "Content-Type": "application/json" },
+						});
+
+						if (!response.ok) {
+							const body = await response.text().catch(() => "");
+							logger.warn(`Typegen failed: ${response.status} ${body.slice(0, 200)}`);
+							return;
+						}
+
+						const { data: result } = (await response.json()) as {
+							data: {
+								types: string;
+								hash: string;
+								collections: number;
+							};
+						};
+
+						// Only write if content changed
+						let needsWrite = true;
+						try {
+							const existing = await readFile(outputPath, "utf-8");
+							if (existing === result.types) needsWrite = false;
+						} catch {
+							// File doesn't exist yet
+						}
+
+						if (needsWrite) {
+							await writeFile(outputPath, result.types, "utf-8");
+							logger.info(`Generated emdash-env.d.ts (${result.collections} collections)`);
+						}
+					} catch (error) {
+						const msg = error instanceof Error ? error.message : String(error);
+						logger.warn(`Typegen failed: ${msg}`);
+					}
+				});
+			},
+			"astro:build:done": ({ logger }) => {
+				logger.info("Build complete");
+			},
+		},
+	};
+}
+
+export default emdash;