emdash 0.0.0-a → 0.0.1

package/src/storage/types.ts

@@ -0,0 +1,204 @@
+/**
+ * Storage Layer Types
+ *
+ * Defines the interface for S3-compatible storage backends.
+ * Works with R2, AWS S3, Minio, and other S3-compatible services.
+ */
+
+/**
+ * Storage configuration for S3-compatible backends
+ */
+export interface S3StorageConfig {
+	/** S3 endpoint URL (e.g., "https://xxx.r2.cloudflarestorage.com") */
+	endpoint: string;
+	/** Bucket name */
+	bucket: string;
+	/** AWS access key ID */
+	accessKeyId: string;
+	/** AWS secret access key */
+	secretAccessKey: string;
+	/** Optional region (defaults to "auto" for R2) */
+	region?: string;
+	/** Optional public URL prefix for generated URLs (e.g., CDN URL) */
+	publicUrl?: string;
+}
+
+/**
+ * Local filesystem storage for development
+ */
+export interface LocalStorageConfig {
+	/** Directory path for storing files */
+	directory: string;
+	/** Base URL for serving files */
+	baseUrl: string;
+}
+
+/**
+ * Storage adapter descriptor (serializable config)
+ */
+export interface StorageDescriptor {
+	/** Module path exporting createStorage function */
+	entrypoint: string;
+	/** Serializable config passed to createStorage at runtime */
+	config: Record<string, unknown>;
+}
+
+/**
+ * Factory function signature for storage adapters
+ *
+ * Each adapter accesses its own bindings directly:
+ * - R2: imports from cloudflare:workers
+ * - S3: uses credentials from config
+ * - Local: uses filesystem path from config
+ */
+export type CreateStorageFn = (config: Record<string, unknown>) => Storage;
+
+/**
+ * Upload result
+ */
+export interface UploadResult {
+	/** Storage key (path within bucket) */
+	key: string;
+	/** Public URL to access the file */
+	url: string;
+	/** File size in bytes */
+	size: number;
+}
+
+/**
+ * Download result
+ */
+export interface DownloadResult {
+	/** File content as readable stream */
+	body: ReadableStream<Uint8Array>;
+	/** MIME type */
+	contentType: string;
+	/** File size in bytes */
+	size: number;
+}
+
+/**
+ * Signed URL for direct upload
+ */
+export interface SignedUploadUrl {
+	/** Signed URL for PUT request */
+	url: string;
+	/** HTTP method (always PUT) */
+	method: "PUT";
+	/** Headers to include in the upload request */
+	headers: Record<string, string>;
+	/** URL expiration time (ISO string) */
+	expiresAt: string;
+}
+
+/**
+ * Options for generating signed upload URL
+ */
+export interface SignedUploadOptions {
+	/** Storage key (path within bucket) */
+	key: string;
+	/** MIME type of the file */
+	contentType: string;
+	/** File size in bytes (for content-length validation) */
+	size?: number;
+	/** URL expiration in seconds (default: 3600) */
+	expiresIn?: number;
+}
+
+/**
+ * File listing result
+ */
+export interface ListResult {
+	/** List of files */
+	files: FileInfo[];
+	/** Cursor for next page (if more results) */
+	nextCursor?: string;
+}
+
+/**
+ * File info from listing
+ */
+export interface FileInfo {
+	/** Storage key */
+	key: string;
+	/** File size in bytes */
+	size: number;
+	/** Last modified date */
+	lastModified: Date;
+	/** ETag (content hash) */
+	etag?: string;
+}
+
+/**
+ * Options for listing files
+ */
+export interface ListOptions {
+	/** Filter by key prefix */
+	prefix?: string;
+	/** Maximum results per page */
+	limit?: number;
+	/** Cursor from previous list call */
+	cursor?: string;
+}
+
+/**
+ * Storage interface
+ *
+ * All storage backends must implement this interface.
+ */
+export interface Storage {
+	/**
+	 * Upload a file to storage
+	 */
+	upload(options: {
+		key: string;
+		body: Buffer | Uint8Array | ReadableStream<Uint8Array>;
+		contentType: string;
+	}): Promise<UploadResult>;
+
+	/**
+	 * Download a file from storage
+	 */
+	download(key: string): Promise<DownloadResult>;
+
+	/**
+	 * Delete a file from storage
+	 * Idempotent - does not throw if file doesn't exist
+	 */
+	delete(key: string): Promise<void>;
+
+	/**
+	 * Check if a file exists
+	 */
+	exists(key: string): Promise<boolean>;
+
+	/**
+	 * List files in storage
+	 */
+	list(options?: ListOptions): Promise<ListResult>;
+
+	/**
+	 * Generate a signed URL for direct upload
+	 * Client uploads directly to storage, bypassing the server
+	 */
+	getSignedUploadUrl(options: SignedUploadOptions): Promise<SignedUploadUrl>;
+
+	/**
+	 * Get public URL for a file
+	 */
+	getPublicUrl(key: string): string;
+}
+
+/**
+ * Storage error with additional context
+ */
+export class EmDashStorageError extends Error {
+	constructor(
+		message: string,
+		public code: string,
+		public override cause?: unknown,
+	) {
+		super(message);
+		this.name = "EmDashStorageError";
+	}
+}

package/src/taxonomies/index.ts

@@ -0,0 +1,309 @@
+/**
+ * Runtime API for taxonomies
+ *
+ * Provides functions to query taxonomy definitions and terms.
+ */
+
+import { getDb } from "../loader.js";
+import type { TaxonomyDef, TaxonomyTerm, TaxonomyTermRow } from "./types.js";
+
+/**
+ * Get all taxonomy definitions
+ */
+export async function getTaxonomyDefs(): Promise<TaxonomyDef[]> {
+	const db = await getDb();
+
+	const rows = await db.selectFrom("_emdash_taxonomy_defs").selectAll().execute();
+
+	return rows.map((row) => ({
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		labelSingular: row.label_singular ?? undefined,
+		hierarchical: row.hierarchical === 1,
+		collections: row.collections ? JSON.parse(row.collections) : [],
+	}));
+}
+
+/**
+ * Get a single taxonomy definition by name
+ */
+export async function getTaxonomyDef(name: string): Promise<TaxonomyDef | null> {
+	const db = await getDb();
+
+	const row = await db
+		.selectFrom("_emdash_taxonomy_defs")
+		.selectAll()
+		.where("name", "=", name)
+		.executeTakeFirst();
+
+	if (!row) return null;
+
+	return {
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		labelSingular: row.label_singular ?? undefined,
+		hierarchical: row.hierarchical === 1,
+		collections: row.collections ? JSON.parse(row.collections) : [],
+	};
+}
+
+/**
+ * Get all terms for a taxonomy (as tree for hierarchical, flat for tags)
+ */
+export async function getTaxonomyTerms(taxonomyName: string): Promise<TaxonomyTerm[]> {
+	const db = await getDb();
+
+	// Get taxonomy definition to check if hierarchical
+	const def = await getTaxonomyDef(taxonomyName);
+	if (!def) return [];
+
+	// Get all terms for this taxonomy
+	const rows = await db
+		.selectFrom("taxonomies")
+		.selectAll()
+		.where("name", "=", taxonomyName)
+		.orderBy("label", "asc")
+		.execute();
+
+	// Count entries for each term
+	const countsResult = await db
+		.selectFrom("content_taxonomies")
+		.select(["taxonomy_id"])
+		.select((eb) => eb.fn.count<number>("entry_id").as("count"))
+		.groupBy("taxonomy_id")
+		.execute();
+
+	const counts = new Map<string, number>();
+	for (const row of countsResult) {
+		counts.set(row.taxonomy_id, row.count);
+	}
+
+	const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
+		id: row.id,
+		name: row.name,
+		slug: row.slug,
+		label: row.label,
+		parent_id: row.parent_id,
+		data: row.data,
+	}));
+
+	// If hierarchical, build tree. Otherwise return flat
+	if (def.hierarchical) {
+		return buildTree(flatTerms, counts);
+	}
+
+	return flatTerms.map((term) => ({
+		id: term.id,
+		name: term.name,
+		slug: term.slug,
+		label: term.label,
+		children: [],
+		count: counts.get(term.id) ?? 0,
+	}));
+}
+
+/**
+ * Get a single term by taxonomy and slug
+ */
+export async function getTerm(taxonomyName: string, slug: string): Promise<TaxonomyTerm | null> {
+	const db = await getDb();
+
+	const row = await db
+		.selectFrom("taxonomies")
+		.selectAll()
+		.where("name", "=", taxonomyName)
+		.where("slug", "=", slug)
+		.executeTakeFirst();
+
+	if (!row) return null;
+
+	// Get entry count
+	const countResult = await db
+		.selectFrom("content_taxonomies")
+		.select((eb) => eb.fn.count<number>("entry_id").as("count"))
+		.where("taxonomy_id", "=", row.id)
+		.executeTakeFirst();
+
+	const count = countResult?.count ?? 0;
+
+	// Get children if hierarchical
+	const childRows = await db
+		.selectFrom("taxonomies")
+		.selectAll()
+		.where("parent_id", "=", row.id)
+		.orderBy("label", "asc")
+		.execute();
+
+	const children = childRows.map((child) => ({
+		id: child.id,
+		name: child.name,
+		slug: child.slug,
+		label: child.label,
+		parentId: child.parent_id ?? undefined,
+		children: [],
+	}));
+
+	return {
+		id: row.id,
+		name: row.name,
+		slug: row.slug,
+		label: row.label,
+		parentId: row.parent_id ?? undefined,
+		description: row.data ? JSON.parse(row.data).description : undefined,
+		children,
+		count,
+	};
+}
+
+/**
+ * Get terms assigned to an entry
+ */
+export async function getEntryTerms(
+	collection: string,
+	entryId: string,
+	taxonomyName?: string,
+): Promise<TaxonomyTerm[]> {
+	const db = await getDb();
+
+	let query = db
+		.selectFrom("content_taxonomies")
+		.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+		.selectAll("taxonomies")
+		.where("content_taxonomies.collection", "=", collection)
+		.where("content_taxonomies.entry_id", "=", entryId);
+
+	if (taxonomyName) {
+		query = query.where("taxonomies.name", "=", taxonomyName);
+	}
+
+	const rows = await query.execute();
+
+	return rows.map((row) => ({
+		id: row.id,
+		name: row.name,
+		slug: row.slug,
+		label: row.label,
+		parentId: row.parent_id ?? undefined,
+		children: [],
+	}));
+}
+
+/**
+ * Get terms for multiple entries in a single query (batched API)
+ *
+ * This is more efficient than calling getEntryTerms for each entry
+ * when you need terms for a list of entries.
+ *
+ * @param collection - The collection type (e.g., "posts")
+ * @param entryIds - Array of entry IDs
+ * @param taxonomyName - The taxonomy name (e.g., "categories")
+ * @returns Map from entry ID to array of terms
+ */
+export async function getTermsForEntries(
+	collection: string,
+	entryIds: string[],
+	taxonomyName: string,
+): Promise<Map<string, TaxonomyTerm[]>> {
+	const result = new Map<string, TaxonomyTerm[]>();
+
+	// Initialize all entry IDs with empty arrays
+	for (const id of entryIds) {
+		result.set(id, []);
+	}
+
+	if (entryIds.length === 0) {
+		return result;
+	}
+
+	const db = await getDb();
+
+	const rows = await db
+		.selectFrom("content_taxonomies")
+		.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+		.select([
+			"content_taxonomies.entry_id",
+			"taxonomies.id",
+			"taxonomies.name",
+			"taxonomies.slug",
+			"taxonomies.label",
+			"taxonomies.parent_id",
+		])
+		.where("content_taxonomies.collection", "=", collection)
+		.where("content_taxonomies.entry_id", "in", entryIds)
+		.where("taxonomies.name", "=", taxonomyName)
+		.execute();
+
+	for (const row of rows) {
+		const entryId = row.entry_id;
+		const term: TaxonomyTerm = {
+			id: row.id,
+			name: row.name,
+			slug: row.slug,
+			label: row.label,
+			parentId: row.parent_id ?? undefined,
+			children: [],
+		};
+
+		const terms = result.get(entryId);
+		if (terms) {
+			terms.push(term);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Get entries by term (wraps getEmDashCollection)
+ */
+export async function getEntriesByTerm(
+	collection: string,
+	taxonomyName: string,
+	termSlug: string,
+): Promise<Array<{ id: string; data: Record<string, unknown> }>> {
+	const { getEmDashCollection } = await import("../query.js");
+
+	// Build options as the expected type — getEmDashCollection accepts
+	// a generic options object with `where` for filtering by taxonomy
+	const options: Record<string, unknown> = {
+		where: { [taxonomyName]: termSlug },
+	};
+	const { entries } = await getEmDashCollection(collection, options);
+
+	return entries;
+}
+
+/**
+ * Build tree structure from flat terms
+ */
+function buildTree(flatTerms: TaxonomyTermRow[], counts: Map<string, number>): TaxonomyTerm[] {
+	const map = new Map<string, TaxonomyTerm>();
+	const roots: TaxonomyTerm[] = [];
+
+	// First pass: create nodes
+	for (const term of flatTerms) {
+		map.set(term.id, {
+			id: term.id,
+			name: term.name,
+			slug: term.slug,
+			label: term.label,
+			parentId: term.parent_id ?? undefined,
+			description: term.data ? JSON.parse(term.data).description : undefined,
+			children: [],
+			count: counts.get(term.id) ?? 0,
+		});
+	}
+
+	// Second pass: build tree
+	for (const term of map.values()) {
+		if (term.parentId && map.has(term.parentId)) {
+			map.get(term.parentId)!.children.push(term);
+		} else {
+			roots.push(term);
+		}
+	}
+
+	return roots;
+}

package/src/taxonomies/types.ts

@@ -0,0 +1,61 @@
+/**
+ * Taxonomy types for EmDash CMS
+ */
+
+/**
+ * Taxonomy definition - describes a taxonomy like "category" or "tag"
+ */
+export interface TaxonomyDef {
+	id: string;
+	name: string; // 'category', 'tag', 'genre'
+	label: string; // 'Categories', 'Tags'
+	labelSingular?: string; // 'Category', 'Tag'
+	hierarchical: boolean;
+	collections: string[]; // ['posts', 'pages']
+}
+
+/**
+ * Taxonomy term - a specific term within a taxonomy (e.g., "News" in "category")
+ */
+export interface TaxonomyTerm {
+	id: string;
+	name: string; // Taxonomy name ('category')
+	slug: string; // Term slug ('news')
+	label: string; // Display label ('News')
+	parentId?: string;
+	description?: string;
+	children: TaxonomyTerm[]; // For tree structure
+	count?: number; // Entry count
+}
+
+/**
+ * Flat version for DB row
+ */
+export interface TaxonomyTermRow {
+	id: string;
+	name: string;
+	slug: string;
+	label: string;
+	parent_id: string | null;
+	data: string | null; // JSON
+}
+
+/**
+ * Input for creating a term
+ */
+export interface CreateTermInput {
+	slug: string;
+	label: string;
+	parentId?: string;
+	description?: string;
+}
+
+/**
+ * Input for updating a term
+ */
+export interface UpdateTermInput {
+	slug?: string;
+	label?: string;
+	parentId?: string | null;
+	description?: string;
+}

package/src/ui.ts

@@ -0,0 +1,75 @@
+/**
+ * EmDash UI Components
+ *
+ * Image component for rendering optimized images:
+ *
+ * ```astro
+ * ---
+ * import { Image } from "emdash/ui";
+ * ---
+ * <Image image={post.data.featured_image} />
+ * ```
+ *
+ * Portable Text component for rich content:
+ *
+ * ```astro
+ * ---
+ * import { PortableText } from "emdash/ui";
+ * ---
+ * <PortableText value={post.data.content} />
+ * ```
+ *
+ * Override specific Portable Text components:
+ *
+ * ```astro
+ * <PortableText value={content} components={{ type: { image: MyImage } }} />
+ * ```
+ */
+
+// Re-export types and utilities from astro-portabletext
+export {
+	type PortableTextProps,
+	type TypedObject,
+	type SomePortableTextComponents,
+	type Block,
+	type ArbitraryTypedObject,
+	type PortableTextBlock,
+	type PortableTextMarkDefinition,
+	type PortableTextSpan,
+	type PortableTextListItemBlock,
+	usePortableText,
+	mergeComponents,
+} from "astro-portabletext";
+
+// EmDash PortableText wrapper and components
+export {
+	// Main Image component for EmDash media
+	EmDashImage as Image,
+	// Main component (wrapper with EmDash defaults)
+	PortableText,
+	// Comment components
+	Comments,
+	CommentForm,
+	// Widget components
+	WidgetArea,
+	// Components object for manual use
+	emdashComponents,
+	// Portable Text block types (prefixed to avoid collision with Image)
+	Image as PTImage,
+	Code,
+	Embed,
+	Gallery,
+	Columns,
+	Break,
+	HtmlBlock,
+	// Marks
+	Superscript,
+	Subscript,
+	Underline,
+	StrikeThrough,
+	Link,
+	// Public page contribution components
+	EmDashHead,
+	EmDashBodyStart,
+	EmDashBodyEnd,
+} from "./components/index.js";

package/src/utils/base64.ts

@@ -0,0 +1,73 @@
+/**
+ * Base64 encoding/decoding utilities.
+ *
+ * Uses native Uint8Array.prototype.toBase64 / Uint8Array.fromBase64 when
+ * available (workerd, Node 26+, modern browsers), falls back to btoa/atob.
+ *
+ * All base64url encoding uses the { alphabet: "base64url" } option natively
+ * or manual character replacement as fallback.
+ *
+ * Delete the fallback paths when the minimum Node version supports these
+ * methods natively.
+ */
+
+const hasNative =
+	typeof Uint8Array.prototype.toBase64 === "function" &&
+	typeof Uint8Array.fromBase64 === "function";
+
+// Regex patterns for base64url character replacement
+const BASE64_PLUS_PATTERN = /\+/g;
+const BASE64_SLASH_PATTERN = /\//g;
+const BASE64_PADDING_PATTERN = /=+$/;
+const BASE64URL_DASH_PATTERN = /-/g;
+const BASE64URL_UNDERSCORE_PATTERN = /_/g;
+
+// ---------------------------------------------------------------------------
+// Standard base64 (for opaque tokens, cursors, Basic Auth, etc.)
+// ---------------------------------------------------------------------------
+
+/** Encode a UTF-8 string as standard base64. */
+export function encodeBase64(str: string): string {
+	const bytes = new TextEncoder().encode(str);
+	if (hasNative) return bytes.toBase64();
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary);
+}
+
+/** Decode a standard base64 string to a UTF-8 string. */
+export function decodeBase64(base64: string): string {
+	if (hasNative) return new TextDecoder().decode(Uint8Array.fromBase64(base64));
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+
+// ---------------------------------------------------------------------------
+// Base64url (for tokens, HMAC signatures, PKCE, etc.)
+// ---------------------------------------------------------------------------
+
+/** Encode bytes as base64url without padding. */
+export function encodeBase64url(bytes: Uint8Array): string {
+	if (hasNative) return bytes.toBase64({ alphabet: "base64url", omitPadding: true });
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary)
+		.replace(BASE64_PLUS_PATTERN, "-")
+		.replace(BASE64_SLASH_PATTERN, "_")
+		.replace(BASE64_PADDING_PATTERN, "");
+}
+
+/** Decode a base64url string (with or without padding) to bytes. */
+export function decodeBase64url(encoded: string): Uint8Array {
+	if (hasNative) return Uint8Array.fromBase64(encoded, { alphabet: "base64url" });
+	const base64 = encoded
+		.replace(BASE64URL_DASH_PATTERN, "+")
+		.replace(BASE64URL_UNDERSCORE_PATTERN, "/");
+	const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}