emdash 0.33.0 → 0.35.0

package/dist/astro/index.d.mts

@@ -1,15 +1,15 @@
-import { i as ContentItem } from "../types-BGWPMiBO.mjs";
-import "../options-CA4eVX6P.mjs";
-import "../types-Dc4ntQjQ.mjs";
-import { Et as ResolvedPlugin } from "../types-Cz8hNch2.mjs";
-import "../relations-G2ta7GIl.mjs";
-import { Sr as StorageDescriptor, _r as EmDashConfig, br as LocalStorageConfig, xr as S3StorageConfig, yi as MediaItem, yr as getStoredConfig } from "../index-M37iz29I.mjs";
-import "../runner-BaADli8l.mjs";
-import "../index-MGw47uWq.mjs";
-import { i as ObjectCacheRuntimeConfig, r as ObjectCacheDescriptor } from "../types-BK6U01Ro.mjs";
-import "../types-C8oz_ayJ.mjs";
-import "../hreflang-BaLCNcDx.mjs";
-import "../validate-C3oSmA7F.mjs";
+import { i as ContentItem } from "../types-DN64_zzZ.mjs";
+import "../options--hhz-jZ1.mjs";
+import "../types-DQIDRKF2.mjs";
+import { Dt as ResolvedPlugin } from "../types-DrJrVCT1.mjs";
+import "../relations-BHo5A8Zf.mjs";
+import { Dr as StorageDescriptor, Er as S3StorageConfig, Sr as EmDashConfig, Tr as LocalStorageConfig, wi as MediaItem, wr as getStoredConfig } from "../index-BVBZj4-7.mjs";
+import "../runner-BYHZn3Jy.mjs";
+import "../index-C9KuQyO-.mjs";
+import { i as ObjectCacheRuntimeConfig, r as ObjectCacheDescriptor } from "../types-Dfk8KI5R.mjs";
+import "../types-CXnOzDe1.mjs";
+import "../hreflang-DwT2E0Sa.mjs";
+import "../validate-CTqt5nuE.mjs";
 import { EmDashHandlers, EmDashManifest, ManifestCollection } from "./types.mjs";
 import { AstroIntegration } from "astro";
 

package/dist/astro/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/astro/storage/adapters.ts","../../src/astro/object-cache/adapters.ts","../../src/astro/integration/index.ts"],"mappings":";;;;;;;;;;;;;;;;;AAkFA;;;;;;;;;;;;AC3DA;;;;;AAqBA;;;;;;;;;;;;iBDiBgB,EAAA,CAAG,MAAA,GAAQ,OAAA,CAAQ,eAAA,IAAwB,iBAAA;;;;;;;;;;;;;;;iBAqB3C,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,iBAAA;;;;UC3DlC,kBAAA,SAA2B,wBAAA;EDsCgC;;;;ECjC3E,UAAA;AAAA;;;ADsDD;;;;;;;;;;;iBCtCgB,WAAA,CAAY,OAAA,GAAS,kBAAA,GAA0B,qBAAA;;;;;;iBCsN/C,MAAA,CAAO,MAAA,GAAQ,YAAA,GAAoB,gBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/astro/storage/adapters.ts","../../src/astro/object-cache/adapters.ts","../../src/astro/integration/index.ts"],"mappings":";;;;;;;;;;;;;;;;;AAkFA;;;;;;;;;;;;AC3DA;;;;;AAqBA;;;;;;;;;;;;iBDiBgB,EAAA,CAAG,MAAA,GAAQ,OAAA,CAAQ,eAAA,IAAwB,iBAAA;;;;;;;;;;;;;;;iBAqB3C,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,iBAAA;;;;UC3DlC,kBAAA,SAA2B,wBAAA;EDsCgC;;;;ECjC3E,UAAA;AAAA;;;ADsDD;;;;;;;;;;;iBCtCgB,WAAA,CAAY,OAAA,GAAS,kBAAA,GAA0B,qBAAA;;;;;;iBCoR/C,MAAA,CAAO,MAAA,GAAQ,YAAA,GAAoB,gBAAA"}

package/dist/astro/index.mjs

@@ -1,12 +1,20 @@
-import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-C-SHXmra.mjs";
-import { t as defaultSeed } from "../default-BD2FG0xV.mjs";
-import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-CG1pACtS.mjs";
-import { n as VERSION, t as COMMIT } from "../version-C4PnpmoV.mjs";
+import "../runner-C1T11CfC.mjs";
+import "../dialect-helpers-BSbfaO3F.mjs";
+import "../config-C3EBstHi.mjs";
+import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-Bc-s_r-a.mjs";
+import { t as defaultSeed } from "../default-DdDl3fxv.mjs";
+import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-DW7sYyqg.mjs";
+import { r as normalizeMigrationConfig } from "../policy-TluUIxuu.mjs";
+import { c as normalizeAstroI18n, n as MIGRATION_CONFIG_SYMBOL, o as serializeMigrationManifest, r as createMigrationIntegrationMetadata, s as validateMigrationManifest, t as buildMigrationManifest } from "../manifest-builder-B252yQUf.mjs";
+import { n as VERSION, t as COMMIT } from "../version-DB_fqCSI.mjs";
+import { r as getCoreMigrationIdentity } from "../identity-Ys6Dlc9C.mjs";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fontProviders } from "astro/config";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 //#region src/astro/storage/adapters.ts
 /**
@@ -88,6 +96,37 @@ function memoryCache(options = {}) {
 	};
 }
 
+//#endregion
+//#region src/migrations/manifest-writer.ts
+const MIGRATION_MANIFEST_PATH = ".emdash/migrations.json";
+const nodeFileSystem = {
+	mkdir: (path, options) => mkdir(path, options),
+	writeFile: (path, data, options) => writeFile(path, data, options),
+	rename: (from, to) => rename(from, to),
+	unlink: (path) => unlink(path)
+};
+async function writeMigrationManifest(projectRoot, manifest, fileSystem = nodeFileSystem) {
+	const validated = await validateMigrationManifest(manifest);
+	const outputPath = join(projectRoot, MIGRATION_MANIFEST_PATH);
+	const outputDirectory = dirname(outputPath);
+	await fileSystem.mkdir(outputDirectory, { recursive: true });
+	const temporaryPath = join(outputDirectory, `.migrations.json.${process.pid}.${randomUUID()}.tmp`);
+	let temporaryFileMayExist = false;
+	try {
+		temporaryFileMayExist = true;
+		await fileSystem.writeFile(temporaryPath, serializeMigrationManifest(validated), {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		await fileSystem.rename(temporaryPath, outputPath);
+		temporaryFileMayExist = false;
+		return outputPath;
+	} catch (error) {
+		if (temporaryFileMayExist) await fileSystem.unlink(temporaryPath).catch(() => void 0);
+		throw error;
+	}
+}
+
 //#endregion
 //#region src/astro/integration/font-provider.ts
 /**
@@ -408,6 +447,22 @@ function injectCoreRoutes(injectRoute, options = {}) {
 		pattern: "/_emdash/api/admin/media-usage/repair",
 		entrypoint: resolveRoute("api/admin/media-usage/repair.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work",
+		entrypoint: resolveRoute("api/admin/media-usage/work/index.ts")
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/work/retry.ts")
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/index.ts")
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/retry.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/import/probe",
 		entrypoint: resolveRoute("api/import/probe.ts")
@@ -516,6 +571,14 @@ function injectCoreRoutes(injectRoute, options = {}) {
 		pattern: "/_emdash/api/taxonomies",
 		entrypoint: resolveRoute("api/taxonomies/index.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]",
+		entrypoint: resolveRoute("api/taxonomies/[name].ts")
+	});
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]/translations",
+		entrypoint: resolveRoute("api/taxonomies/[name]/translations.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/taxonomies/[name]/reorder",
 		entrypoint: resolveRoute("api/taxonomies/[name]/reorder.ts")
@@ -856,7 +919,7 @@ function injectCoreRoutes(injectRoute, options = {}) {
 		pattern: "/sitemap.xml",
 		entrypoint: resolveRoute("sitemap.xml.ts")
 	});
-	injectRoute({
+	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "sitemap-[collection].xml")) injectRoute({
 		pattern: "/sitemap-[collection].xml",
 		entrypoint: resolveRoute("sitemap-[collection].xml.ts")
 	});
@@ -1056,6 +1119,8 @@ const VIRTUAL_SCHEDULER_ID = "virtual:emdash/scheduler";
 const RESOLVED_VIRTUAL_SCHEDULER_ID = "\0" + VIRTUAL_SCHEDULER_ID;
 const VIRTUAL_ENV_ID = "virtual:emdash/env";
 const RESOLVED_VIRTUAL_ENV_ID = "\0" + VIRTUAL_ENV_ID;
+const VIRTUAL_BUILD_ID = "virtual:emdash/build";
+const RESOLVED_VIRTUAL_BUILD_ID = "\0" + VIRTUAL_BUILD_ID;
 /**
 * Generates the config virtual module.
 */
@@ -1076,26 +1141,30 @@ function generateConfigModule(serializableConfig) {
 * exist on SQLite, libSQL, PostgreSQL, or other adapters.
 */
 function generateDialectModule(opts) {
-	const { entrypoint, supportsRequestScope, supportsCoalescing } = opts;
+	const { entrypoint, supportsRequestScope, supportsCoalescing, supportsCollectionDeletionGuard } = opts;
 	if (!entrypoint) return [
 		`export const createDialect = undefined;`,
 		`export const dialectType = "sqlite";`,
 		`export const createRequestScopedDb = (_opts) => null;`,
-		`export const createCoalescingDialect = undefined;`
+		`export const createCoalescingDialect = undefined;`,
+		`export const executeCollectionDeletionGuard = undefined;`
 	].join("\n");
 	const type = opts.type ?? "sqlite";
 	const coalescingExport = supportsCoalescing ? `import { createCoalescingDialect as _createCoalescingDialect } from "${entrypoint}";
 export const createCoalescingDialect = _createCoalescingDialect;` : `export const createCoalescingDialect = undefined;`;
+	const collectionDeletionExport = supportsCollectionDeletionGuard ? `export { executeCollectionDeletionGuard } from "${entrypoint}";` : `export const executeCollectionDeletionGuard = undefined;`;
 	if (supportsRequestScope) return `
 import { createDialect as _createDialect } from "${entrypoint}";
 export { createRequestScopedDb } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 `;
 	return `
 import { createDialect as _createDialect } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 export const createRequestScopedDb = (_opts) => null;
@@ -1366,6 +1435,18 @@ function generateEnvModule(adapterName) {
 	return `export const env = undefined;`;
 }
 /**
+* Generates the build virtual module.
+*
+* Content-hashed `/_astro/*` names make the response depend on the build, not
+* only on the content. Exposing the build timestamp lets the middleware fold
+* that dimension into the cache validator, so a code-only deploy stops
+* answering conditional requests with 304 while the assets the cached HTML
+* references are already gone.
+*/
+function generateBuildModule(buildTime) {
+	return `export const buildTime = ${buildTime};`;
+}
+/**
 * Generates the scheduler virtual module.
 *
 * Decides — at build time, from the Astro adapter — whether the runtime gets a
@@ -1577,6 +1658,7 @@ function resolveIntegrationShim(fileName) {
 function createVirtualModulesPlugin(options, astroCommand) {
 	const { serializableConfig, resolvedConfig, pluginDescriptors, astroConfig } = options;
 	let viteCommand;
+	const buildTime = Date.now();
 	return {
 		name: "emdash-virtual-modules",
 		configResolved(config) {
@@ -1599,6 +1681,7 @@ function createVirtualModulesPlugin(options, astroCommand) {
 			if (id === VIRTUAL_WAIT_UNTIL_ID) return RESOLVED_VIRTUAL_WAIT_UNTIL_ID;
 			if (id === VIRTUAL_SCHEDULER_ID) return RESOLVED_VIRTUAL_SCHEDULER_ID;
 			if (id === VIRTUAL_ENV_ID) return RESOLVED_VIRTUAL_ENV_ID;
+			if (id === VIRTUAL_BUILD_ID) return RESOLVED_VIRTUAL_BUILD_ID;
 		},
 		load(id) {
 			if (id === RESOLVED_VIRTUAL_CONFIG_ID) return generateConfigModule(serializableConfig);
@@ -1606,7 +1689,8 @@ function createVirtualModulesPlugin(options, astroCommand) {
 				entrypoint: resolvedConfig.database?.entrypoint,
 				type: resolvedConfig.database?.type,
 				supportsRequestScope: resolvedConfig.database?.supportsRequestScope ?? false,
-				supportsCoalescing: resolvedConfig.database?.supportsCoalescing ?? false
+				supportsCoalescing: resolvedConfig.database?.supportsCoalescing ?? false,
+				supportsCollectionDeletionGuard: resolvedConfig.database?.supportsCollectionDeletionGuard ?? false
 			});
 			if (id === RESOLVED_VIRTUAL_STORAGE_ID) return generateStorageModule(resolvedConfig.storage?.entrypoint);
 			if (id === RESOLVED_VIRTUAL_OBJECT_CACHE_ID) return generateObjectCacheModule(resolvedConfig.objectCache?.entrypoint, resolvedConfig.objectCache?.config);
@@ -1632,6 +1716,7 @@ function createVirtualModulesPlugin(options, astroCommand) {
 				return generateSchedulerModule(astroConfig.adapter?.name, schedulerCommand);
 			}
 			if (id === RESOLVED_VIRTUAL_ENV_ID) return generateEnvModule(astroConfig.adapter?.name);
+			if (id === RESOLVED_VIRTUAL_BUILD_ID) return generateBuildModule(buildTime);
 		}
 	};
 }
@@ -1721,7 +1806,6 @@ function createViteConfig(options, command) {
 					"emdash > @unpic/placeholder",
 					"emdash > blurhash",
 					"emdash > croner",
-					"emdash > image-size",
 					"emdash > jose",
 					"emdash > jpeg-js",
 					"emdash > kysely",
@@ -1944,13 +2028,52 @@ function printDevServerInfo(baseUrl, mcpEnabled) {
 	console.log(`    ${dim("Skips passkey setup/auth and signs you in as a dev admin")}`);
 	console.log("");
 }
+function buildMiddlewareEntries(config, root) {
+	const entries = [];
+	if (config.middleware !== void 0) {
+		const configuredEntrypoint = config.middleware?.outer;
+		if (typeof configuredEntrypoint !== "string" && !(configuredEntrypoint instanceof URL) || typeof configuredEntrypoint === "string" && configuredEntrypoint.trim() === "") throw new Error("middleware.outer must be a non-empty module specifier string or URL.");
+		const entrypoint = typeof configuredEntrypoint === "string" && (configuredEntrypoint.startsWith("./") || configuredEntrypoint.startsWith("../")) ? new URL(configuredEntrypoint, root) : configuredEntrypoint;
+		entries.push({
+			entrypoint,
+			order: "pre"
+		});
+	}
+	if (config.playground) entries.push({
+		entrypoint: config.playground.middlewareEntrypoint,
+		order: "pre"
+	});
+	entries.push({
+		entrypoint: "emdash/middleware",
+		order: "pre"
+	}, {
+		entrypoint: "emdash/middleware/redirect",
+		order: "pre"
+	});
+	if (!config.playground) entries.push({
+		entrypoint: "emdash/middleware/setup",
+		order: "pre"
+	}, {
+		entrypoint: "emdash/middleware/auth",
+		order: "pre"
+	});
+	entries.push({
+		entrypoint: "emdash/middleware/media-usage-write-fence",
+		order: "pre"
+	}, {
+		entrypoint: "emdash/middleware/request-context",
+		order: "pre"
+	});
+	return entries;
+}
 /**
 * Create the EmDash Astro integration
 */
 function emdash(config = {}) {
 	const resolvedConfig = {
 		...config,
-		storage: config.storage ?? DEFAULT_STORAGE
+		storage: config.storage ?? DEFAULT_STORAGE,
+		migrations: normalizeMigrationConfig(config.migrations)
 	};
 	if (resolvedConfig.marketplace) {
 		const url = resolvedConfig.marketplace;
@@ -1991,6 +2114,7 @@ function emdash(config = {}) {
 	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.`);
 	const serializableConfig = {
 		database: resolvedConfig.database,
+		migrations: resolvedConfig.migrations,
 		storage: resolvedConfig.storage,
 		auth: resolvedConfig.auth,
 		authProviders: resolvedConfig.authProviders,
@@ -2004,7 +2128,9 @@ function emdash(config = {}) {
 	};
 	const useExternalAuth = !!(resolvedConfig.auth && "entrypoint" in resolvedConfig.auth);
 	let astroCommand;
-	return {
+	let normalizedI18n = null;
+	const migrationMetadata = createMigrationIntegrationMetadata(resolvedConfig.database);
+	const integration = {
 		name: "emdash",
 		hooks: {
 			"astro:config:setup": ({ injectRoute, addMiddleware, logger, updateConfig, config: astroConfig, command }) => {
@@ -2014,15 +2140,8 @@ function emdash(config = {}) {
 				if (astroVersion !== void 0) serializableConfig.astroVersion = astroVersion;
 				serializableConfig.astroCspEnabled = Boolean(astroConfig.security.csp);
 				serializableConfig.trailingSlash = astroConfig.trailingSlash;
-				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
-					};
-				}
+				normalizedI18n = normalizeAstroI18n(astroConfig.i18n);
+				if (normalizedI18n) serializableConfig.i18n = normalizedI18n;
 				const securityConfig = {
 					checkOrigin: false,
 					...resolvedConfig.siteUrl ? { allowedDomains: [{ hostname: new URL(resolvedConfig.siteUrl).hostname }] } : {}
@@ -2075,36 +2194,26 @@ function emdash(config = {}) {
 				if (resolvedConfig.authProviders?.length) injectAuthProviderRoutes(injectRoute, resolvedConfig.authProviders);
 				if (!useExternalAuth) injectBuiltinAuthRoutes(injectRoute);
 				if (resolvedConfig.mcp !== false) injectMcpRoute(injectRoute);
-				if (resolvedConfig.playground) addMiddleware({
-					entrypoint: resolvedConfig.playground.middlewareEntrypoint,
-					order: "pre"
-				});
-				addMiddleware({
-					entrypoint: "emdash/middleware",
-					order: "pre"
-				});
-				addMiddleware({
-					entrypoint: "emdash/middleware/redirect",
-					order: "pre"
-				});
-				if (!resolvedConfig.playground) {
-					addMiddleware({
-						entrypoint: "emdash/middleware/setup",
-						order: "pre"
-					});
-					addMiddleware({
-						entrypoint: "emdash/middleware/auth",
-						order: "pre"
-					});
-				}
-				addMiddleware({
-					entrypoint: "emdash/middleware/request-context",
-					order: "pre"
-				});
+				for (const middleware of buildMiddlewareEntries(resolvedConfig, astroConfig.root)) addMiddleware(middleware);
 			},
-			"astro:config:done": ({ config: finalConfig, logger }) => {
+			"astro:config:done": async ({ config: finalConfig, logger }) => {
 				const warning = missingReactIntegrationWarning(finalConfig.integrations);
 				if (warning) logger.warn(warning);
+				if (astroCommand !== "build" && astroCommand !== "sync") return;
+				if (!migrationMetadata.database) {
+					logger.warn("EmDash migration manifest was not written because no database adapter is configured.");
+					return;
+				}
+				if (!migrationMetadata.database.migrations) {
+					logger.warn("EmDash migration manifest was not written because the configured database adapter does not support deployment migrations.");
+					return;
+				}
+				const manifest = await buildMigrationManifest({
+					identity: await getCoreMigrationIdentity(),
+					i18n: normalizedI18n,
+					database: migrationMetadata.database
+				});
+				await writeMigrationManifest(fileURLToPath(finalConfig.root), manifest);
 			},
 			"astro:server:setup": ({ server, logger }) => {
 				if (astroCommand === "dev") server.httpServer?.once("listening", () => {
@@ -2152,6 +2261,11 @@ function emdash(config = {}) {
 			}
 		}
 	};
+	Object.defineProperty(integration, MIGRATION_CONFIG_SYMBOL, {
+		value: migrationMetadata,
+		enumerable: false
+	});
+	return integration;
 }
 
 //#endregion