emdash 0.36.0 → 0.37.0

package/src/astro/routes/api/widget-areas/[name].ts

@@ -9,6 +9,7 @@ import type { APIRoute } from "astro";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { rowToWidget } from "#widgets/index.js";
 import type { WidgetRow } from "#widgets/types.js";
 
@@ -56,7 +57,7 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	}
 };
 
-export const DELETE: APIRoute = async ({ params, locals }) => {
+export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 	const { emdash, user } = locals;
 	const db = emdash.db;
 	const { name } = params;
@@ -83,6 +84,7 @@ export const DELETE: APIRoute = async ({ params, locals }) => {
 		// Delete area (widgets cascade)
 		await db.deleteFrom("_emdash_widget_areas").where("id", "=", area.id).execute();
 
+		if (cache?.enabled) await cache.invalidate({ tags: [widgetAreaTag(name)] });
 		return apiSuccess({ deleted: true });
 	} catch (error) {
 		return handleError(error, "Failed to delete widget area", "WIDGET_AREA_DELETE_ERROR");

package/src/astro/routes/api/widget-areas/index.ts

@@ -12,6 +12,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { createWidgetAreaBody } from "#api/schemas.js";
+import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { rowToWidget } from "#widgets/index.js";
 import type { WidgetRow } from "#widgets/types.js";
 
@@ -56,7 +57,7 @@ export const GET: APIRoute = async ({ locals }) => {
 	}
 };
 
-export const POST: APIRoute = async ({ request, locals }) => {
+export const POST: APIRoute = async ({ request, locals, cache }) => {
 	const { emdash, user } = locals;
 	const db = emdash.db;
 
@@ -95,6 +96,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			.where("id", "=", id)
 			.executeTakeFirstOrThrow();
 
+		if (cache?.enabled) await cache.invalidate({ tags: [widgetAreaTag(area.name)] });
 		return apiSuccess(area, 201);
 	} catch (error) {
 		return handleError(error, "Failed to create widget area", "WIDGET_AREA_CREATE_ERROR");

package/src/astro/types.ts

@@ -329,14 +329,17 @@ export interface EmDashHandlers {
 	// Trash handlers
 	handleContentListTrashed: (
 		collection: string,
-		params?: { cursor?: string; limit?: number },
+		params?: { cursor?: string; limit?: number; locale?: string },
 	) => Promise<HandlerResponse>;
 
 	handleContentRestore: (collection: string, id: string) => Promise<HandlerResponse>;
 
 	handleContentPermanentDelete: (collection: string, id: string) => Promise<HandlerResponse>;
 
-	handleContentCountTrashed: (collection: string) => Promise<HandlerResponse>;
+	handleContentCountTrashed: (
+		collection: string,
+		params?: { locale?: string },
+	) => Promise<HandlerResponse>;
 
 	handleContentGetIncludingTrashed: (collection: string, id: string) => Promise<HandlerResponse>;
 
@@ -350,10 +353,14 @@ export interface EmDashHandlers {
 	handleContentPublish: (
 		collection: string,
 		id: string,
-		options?: { publishedAt?: string; requireScheduledDue?: boolean },
+		options?: { publishedAt?: string; requireScheduledDue?: boolean; _rev?: string },
 	) => Promise<HandlerResponse>;
 
-	handleContentUnpublish: (collection: string, id: string) => Promise<HandlerResponse>;
+	handleContentUnpublish: (
+		collection: string,
+		id: string,
+		options?: { _rev?: string },
+	) => Promise<HandlerResponse>;
 
 	handleContentSchedule: (
 		collection: string,
@@ -365,7 +372,11 @@ export interface EmDashHandlers {
 
 	handleContentCountScheduled: (collection: string) => Promise<HandlerResponse>;
 
-	handleContentDiscardDraft: (collection: string, id: string) => Promise<HandlerResponse>;
+	handleContentDiscardDraft: (
+		collection: string,
+		id: string,
+		options?: { _rev?: string },
+	) => Promise<HandlerResponse>;
 
 	handleContentCompare: (collection: string, id: string) => Promise<HandlerResponse>;
 
@@ -393,6 +404,7 @@ export interface EmDashHandlers {
 		blurhash?: string;
 		dominantColor?: string;
 		authorId?: string;
+		folderId?: string | null;
 	}) => Promise<HandlerResponse>;
 
 	handleMediaUpdate: (
@@ -408,6 +420,12 @@ export interface EmDashHandlers {
 		},
 	) => Promise<HandlerResponse>;
 
+	handleMediaReplaceMetadata?: (
+		id: string,
+		expectedStorageKey: string,
+		input: { size: number; width: number; height: number; contentHash: string },
+	) => Promise<HandlerResponse>;
+
 	handleMediaDelete: (id: string) => Promise<HandlerResponse>;
 
 	// Revision handlers

package/src/auth/challenge-store.ts

@@ -20,13 +20,14 @@ export function createChallengeStore(db: Kysely<Database>): ChallengeStore {
 					challenge,
 					type: data.type,
 					user_id: data.userId ?? null,
-					data: null, // Could store additional context if needed
+					data: data.context ?? null,
 					expires_at: expiresAt,
 				})
 				.onConflict((oc) =>
 					oc.column("challenge").doUpdateSet({
 						type: data.type,
 						user_id: data.userId ?? null,
+						data: data.context ?? null,
 						expires_at: expiresAt,
 					}),
 				)
@@ -55,6 +56,7 @@ export function createChallengeStore(db: Kysely<Database>): ChallengeStore {
 				type: row.type === "registration" ? "registration" : "authentication",
 				userId: row.user_id ?? undefined,
 				expiresAt,
+				...(row.data === null ? {} : { context: row.data }),
 			};
 		},
 

package/src/aws-sdk.d.ts

@@ -64,6 +64,7 @@ declare module "@aws-sdk/client-s3" {
 			Body?: unknown;
 			ContentType?: string;
 			ContentLength?: number;
+			CacheControl?: string;
 		});
 	}
 

package/src/cache/chrome-tags.ts

@@ -0,0 +1,24 @@
+/**
+ * Stable cache tags for EmDash chrome (settings, menus, taxonomies, widget areas).
+ *
+ * These tags are used by both the public read helpers (cacheHint) and the
+ * admin write routes (cache.invalidate), closing the Workers edge cache loop.
+ */
+
+const PREFIX = "emdash";
+
+export function siteSettingsTag(): string {
+	return `${PREFIX}:settings`;
+}
+
+export function menuTag(name: string): string {
+	return `${PREFIX}:menu:${name}`;
+}
+
+export function taxonomyTag(name: string): string {
+	return `${PREFIX}:taxonomy:${name}`;
+}
+
+export function widgetAreaTag(name: string): string {
+	return `${PREFIX}:widget-area:${name}`;
+}

package/src/components/EmDashImage.astro

@@ -25,6 +25,7 @@ import type { HTMLAttributes } from "astro/types";
 import { Image as AstroImage, getImage } from "astro:assets";
 import type { ImageEmbed } from "../media/types.js";
 import { getMediaProvider } from "../media/provider-loader.js";
+import { normalizeLegacyExternalMediaValue } from "../media/normalize.js";
 import { buildRenderMediaUrl } from "../media/url.js";
 import {
 	buildResponsiveImage,
@@ -78,7 +79,7 @@ function normalizeImage(
 	if (typeof img === "string") {
 		return { id: "", src: img };
 	}
-	return img;
+	return normalizeLegacyExternalMediaValue(img);
 }
 
 /**

package/src/components/EmDashMedia.astro

@@ -20,6 +20,7 @@ import type { MediaValue } from "../fields/types.js";
 import type { EmbedResult, EmbedOptions } from "../media/types.js";
 import type { HTMLAttributes } from "astro/types";
 import { getMediaProvider } from "../media/provider-loader.js";
+import { normalizeLegacyExternalMediaValue } from "../media/normalize.js";
 
 interface Props extends Omit<HTMLAttributes<"img" | "video" | "audio">, "src" | "width" | "height"> {
 	/** Media value from content field */
@@ -42,7 +43,7 @@ function normalizeValue(val: MediaValue | string | undefined | null): MediaValue
 	if (typeof val === "string") {
 		return { id: "", src: val, provider: "local" };
 	}
-	return val;
+	return normalizeLegacyExternalMediaValue(val);
 }
 
 const media = normalizeValue(value);

package/src/components/InlinePortableTextEditor.tsx

@@ -155,6 +155,10 @@ function attrNum(attrs: Record<string, unknown> | undefined, key: string): numbe
 	return typeof v === "number" ? v : undefined;
 }
 
+function canonicalMediaProviderId(provider: string | undefined): string | undefined {
+	return provider === "external-url" ? "external" : provider;
+}
+
 function pmToPortableText(doc: PMNode): PTBlock[] {
 	if (!doc || doc.type !== "doc" || !doc.content) return [];
 	const blocks: PTBlock[] = [];
@@ -586,7 +590,7 @@ function convertPTBlock(block: PTBlock): PMNode | null {
 				title: ib.caption || "",
 				caption: ib.caption || "",
 				mediaId: asset?._ref,
-				provider: asset?.provider,
+				provider: canonicalMediaProviderId(asset?.provider),
 				width: ib.width,
 				height: ib.height,
 				blurhash,
@@ -2225,6 +2229,7 @@ export function InlinePortableTextEditor({
 					src,
 					alt: item.alt || item.filename || "",
 					mediaId: item.id,
+					provider: canonicalMediaProviderId(item.provider) || "local",
 					width: item.width,
 					height: item.height,
 					blurhash: item.blurhash,

package/src/components/widgets/Archives.astro

@@ -1,5 +1,6 @@
 ---
 import { getEmDashCollection } from "../../query.js";
+import { groupEntriesByPublishedAt } from "../../widgets/archives.js";
 
 interface Props {
 	type?: "monthly" | "yearly";
@@ -8,47 +9,11 @@ interface Props {
 
 const { type = "monthly", limit = 12 } = Astro.props;
 
-// Get all posts to build archives
 const { entries: posts } = await getEmDashCollection("posts", {
 	orderBy: { published_at: "desc" },
 });
 
-// Group posts by date
-const archives = new Map<string, { label: string; count: number; url: string }>();
-
-for (const post of posts) {
-	const publishedAt = post.data.publishedAt;
-	if (typeof publishedAt !== "string") continue;
-
-	const date = new Date(publishedAt);
-	let key: string;
-	let label: string;
-	let url: string;
-
-	if (type === "yearly") {
-		const year = date.getFullYear();
-		key = `${year}`;
-		label = `${year}`;
-		url = `/archives/${year}`;
-	} else {
-		const year = date.getFullYear();
-		const month = date.getMonth() + 1;
-		key = `${year}-${month.toString().padStart(2, "0")}`;
-		label = date.toLocaleDateString("en-US", {
-			year: "numeric",
-			month: "long",
-		});
-		url = `/archives/${year}/${month.toString().padStart(2, "0")}`;
-	}
-
-	if (!archives.has(key)) {
-		archives.set(key, { label, count: 0, url });
-	}
-	archives.get(key)!.count++;
-}
-
-// Convert to array and limit
-const archiveList = [...archives.values()].slice(0, limit);
+const archiveList = groupEntriesByPublishedAt(posts, { type, limit });
 ---
 
 <ul class="widget-archives">

package/src/content/converters/index.ts

@@ -6,4 +6,6 @@
 
 export { prosemirrorToPortableText } from "./prosemirror-to-portable-text.js";
 export { portableTextToProsemirror } from "./portable-text-to-prosemirror.js";
+export type { PortableTextToProsemirrorOptions } from "./portable-text-to-prosemirror.js";
+export { portableTextIdentityExtensions } from "./portable-text-identity.js";
 export * from "./types.js";

package/src/content/converters/mark-safety.ts

@@ -22,6 +22,7 @@ const SUPPORTED_PROSEMIRROR_MARKS = new Set([
 	"superscript",
 	"code",
 	"link",
+	"emdashPortableTextSpan",
 ]);
 
 type UnknownRecord = Record<string, unknown>;

package/src/content/converters/portable-text-identity.ts

@@ -0,0 +1,139 @@
+import { Extension, Mark, Node, type Extensions } from "@tiptap/core";
+
+import type { PortableTextBlock, PortableTextMarkDef } from "./types.js";
+
+export const PORTABLE_TEXT_BLOCK_NODE = "emdashPortableTextBlock";
+export const PORTABLE_TEXT_BLOCK_ATTR = "emdashPortableTextBlock";
+export const PORTABLE_TEXT_KEY_ATTR = "emdashPortableTextKey";
+export const PORTABLE_TEXT_SPAN_MARK = "emdashPortableTextSpan";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function attrsWithPortableTextKey(
+	attrs: Record<string, unknown> | undefined,
+	key: string,
+): Record<string, unknown> {
+	return { ...attrs, [PORTABLE_TEXT_KEY_ATTR]: key };
+}
+
+export function portableTextKeyFromAttrs(
+	attrs: Record<string, unknown> | undefined,
+): string | undefined {
+	const key = attrs?.[PORTABLE_TEXT_KEY_ATTR];
+	return typeof key === "string" && key ? key : undefined;
+}
+
+export function portableTextSpanKeyFromMarks(marks: unknown[] | undefined): string | undefined {
+	for (const mark of marks ?? []) {
+		if (!isRecord(mark) || mark.type !== PORTABLE_TEXT_SPAN_MARK || !isRecord(mark.attrs)) continue;
+		const key = mark.attrs.key;
+		if (typeof key === "string" && key) return key;
+	}
+	return undefined;
+}
+
+export function portableTextMarkDefsFromMarks(marks: unknown[] | undefined): PortableTextMarkDef[] {
+	const identity = (marks ?? []).find(
+		(mark) => isRecord(mark) && mark.type === PORTABLE_TEXT_SPAN_MARK && isRecord(mark.attrs),
+	);
+	if (!isRecord(identity) || !isRecord(identity.attrs) || !Array.isArray(identity.attrs.markDefs)) {
+		return [];
+	}
+	return identity.attrs.markDefs.filter(
+		(markDef): markDef is PortableTextMarkDef =>
+			isRecord(markDef) && typeof markDef._type === "string" && typeof markDef._key === "string",
+	);
+}
+
+export function portableTextBlockFromAttrs(
+	attrs: Record<string, unknown> | undefined,
+): PortableTextBlock | undefined {
+	const block = attrs?.[PORTABLE_TEXT_BLOCK_ATTR];
+	if (!isRecord(block) || typeof block._type !== "string" || typeof block._key !== "string") {
+		return undefined;
+	}
+	return { ...block, _type: block._type, _key: block._key };
+}
+
+export const PortableTextIdentityExtension = Extension.create({
+	name: "emdashPortableTextIdentity",
+
+	addGlobalAttributes() {
+		const hiddenAttribute = { default: null, rendered: false };
+		return [
+			{
+				types: [
+					"paragraph",
+					"heading",
+					"blockquote",
+					"codeBlock",
+					"htmlBlock",
+					"image",
+					"horizontalRule",
+					"gallery",
+					PORTABLE_TEXT_BLOCK_NODE,
+				],
+				attributes: { [PORTABLE_TEXT_KEY_ATTR]: hiddenAttribute },
+			},
+		];
+	},
+});
+
+export const PortableTextSpanIdentity = Mark.create({
+	name: PORTABLE_TEXT_SPAN_MARK,
+	inclusive: false,
+	spanning: false,
+
+	addAttributes() {
+		return {
+			key: { default: null, rendered: false },
+			markDefs: { default: [], rendered: false },
+		};
+	},
+
+	parseHTML() {
+		return [];
+	},
+
+	renderHTML() {
+		return ["span", 0];
+	},
+});
+
+export const PortableTextOpaqueBlock = Node.create({
+	name: PORTABLE_TEXT_BLOCK_NODE,
+	group: "block",
+	atom: true,
+	selectable: true,
+	draggable: true,
+
+	addAttributes() {
+		return {
+			[PORTABLE_TEXT_BLOCK_ATTR]: { default: null, rendered: false },
+		};
+	},
+
+	parseHTML() {
+		return [{ tag: "div[data-emdash-portable-text-block]" }];
+	},
+
+	renderHTML({ node }) {
+		const blockType = portableTextBlockFromAttrs(node.attrs)?._type ?? "unknown";
+		return [
+			"div",
+			{
+				"data-emdash-portable-text-block": blockType,
+				contenteditable: "false",
+			},
+			`[Unknown block type: ${blockType}]`,
+		];
+	},
+});
+
+export const portableTextIdentityExtensions: Extensions = [
+	PortableTextIdentityExtension,
+	PortableTextSpanIdentity,
+	PortableTextOpaqueBlock,
+];