@warlock.js/core 5.30.0 → 5.32.0

package/esm/http/uploads/purge-image-variants.mjs

@@ -1,8 +1,9 @@
+import { purgeVariantCacheEntries, variantCacheEntries, variantSourceCacheEntries } from "./image-variant-cache-entries.mjs";
+import { variantSourceDirectory, variantSourceKey } from "./variant-cache-key.mjs";
 import { purgeImageVariantsOfFile, variantCacheDirectoryFor } from "./image-variant-cache.mjs";
-import { ImageVariantsConfigError } from "./image-variants-config-error.mjs";
 import { localDiskRoot } from "./local-disk-root.mjs";
+import { remoteVariantDisk, remoteVariantPath } from "./remote-variant-source.mjs";
 import path from "node:path";
-import fs from "node:fs/promises";
 
 //#region ../../packages/core/src/http/uploads/purge-image-variants.ts
 /**
@@ -14,29 +15,28 @@ import fs from "node:fs/promises";
 *   `uploads.images.cacheDirectory` is set, that directory is shared by every
 *   local disk, so this clears all of them.
 *
+* Only recognized derivative, source-manifest and temporary files in the
+* generated cache layout are removed. The cache root, directories, unrelated
+* files and symlinks stay in place. Use a dedicated folder for derivatives.
+*
 * Deleting or moving a file through local storage (`storage.delete`,
 * `deleteMany`, `move`) already purges its derivatives; call this for files
 * removed some other way.
 *
+* @throws ImageVariantsConfigError when the cache equals or contains any
+* configured local disk root, including through a symlink
 * @returns `true` when something was removed
-* @throws ImageVariantsConfigError when the disk is not a local disk
 */
 async function purgeImageVariants(relativePath, options = {}) {
 	const diskRoot = localDiskRoot(options.disk);
-	if (!diskRoot) throw new ImageVariantsConfigError(options.disk === void 0 ? "purgeImageVariants needs a local storage driver with a root." : `purgeImageVariants needs a local disk; "${options.disk}" is not one.`);
-	if (relativePath === void 0) {
-		const directory = variantCacheDirectoryFor(diskRoot);
-		try {
-			await fs.access(directory);
-		} catch {
-			return false;
-		}
-		await fs.rm(directory, {
-			recursive: true,
-			force: true
-		});
-		return true;
+	if (!diskRoot) {
+		const disk = remoteVariantDisk(options.disk);
+		const location = relativePath === void 0 ? void 0 : remoteVariantPath(relativePath);
+		if (relativePath !== void 0 && location === void 0) return false;
+		const cache = variantCacheDirectoryFor(disk.cacheRoot);
+		return purgeVariantCacheEntries(location === void 0 ? variantCacheEntries(cache) : variantSourceCacheEntries(variantSourceDirectory(cache, variantSourceKey(disk.root, disk.driver.applyPrefix(location)))));
 	}
+	if (relativePath === void 0) return purgeVariantCacheEntries(variantCacheEntries(variantCacheDirectoryFor(diskRoot)));
 	const location = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
 	return purgeImageVariantsOfFile(diskRoot, path.resolve(diskRoot, location));
 }

package/esm/http/uploads/purge-image-variants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"purge-image-variants.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/purge-image-variants.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { purgeImageVariantsOfFile, variantCacheDirectoryFor } from \"./image-variant-cache\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport { localDiskRoot } from \"./local-disk-root\";\n\n/**\n * Options for {@link purgeImageVariants}\n */\nexport type PurgeImageVariantsOptions = {\n  /**\n   * Local disk the source lives on; the default disk when omitted\n   */\n  disk?: StorageDriverName;\n};\n\n/**\n * Remove cached image derivatives.\n *\n * - With a path: every derivative of that file, in every variant and format.\n *   The file itself is untouched and does not need to exist.\n * - Without a path: the whole derivative cache of the disk. When\n *   `uploads.images.cacheDirectory` is set, that directory is shared by every\n *   local disk, so this clears all of them.\n *\n * Deleting or moving a file through local storage (`storage.delete`,\n * `deleteMany`, `move`) already purges its derivatives; call this for files\n * removed some other way.\n *\n * @returns `true` when something was removed\n * @throws ImageVariantsConfigError when the disk is not a local disk\n */\nexport async function purgeImageVariants(\n  relativePath?: string,\n  options: PurgeImageVariantsOptions = {},\n): Promise<boolean> {\n  const diskRoot = localDiskRoot(options.disk);\n\n  if (!diskRoot) {\n    throw new ImageVariantsConfigError(\n      options.disk === undefined\n        ? \"purgeImageVariants needs a local storage driver with a root.\"\n        : `purgeImageVariants needs a local disk; \"${options.disk}\" is not one.`,\n    );\n  }\n\n  if (relativePath === undefined) {\n    const directory = variantCacheDirectoryFor(diskRoot);\n\n    try {\n      await fs.access(directory);\n    } catch {\n      return false;\n    }\n\n    await fs.rm(directory, { recursive: true, force: true });\n\n    return true;\n  }\n\n  const location = relativePath.replace(/\\\\/g, \"/\").replace(/^\\/+/, \"\");\n\n  return purgeImageVariantsOfFile(diskRoot, path.resolve(diskRoot, location));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAiCA,eAAsB,mBACpB,cACA,UAAqC,CAAC,GACpB;CAClB,MAAM,WAAW,cAAc,QAAQ,IAAI;CAE3C,IAAI,CAAC,UACH,MAAM,IAAI,yBACR,QAAQ,SAAS,SACb,iEACA,2CAA2C,QAAQ,KAAK,cAC9D;CAGF,IAAI,iBAAiB,QAAW;EAC9B,MAAM,YAAY,yBAAyB,QAAQ;EAEnD,IAAI;GACF,MAAM,GAAG,OAAO,SAAS;EAC3B,QAAQ;GACN,OAAO;EACT;EAEA,MAAM,GAAG,GAAG,WAAW;GAAE,WAAW;GAAM,OAAO;EAAK,CAAC;EAEvD,OAAO;CACT;CAEA,MAAM,WAAW,aAAa,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,QAAQ,EAAE;CAEpE,OAAO,yBAAyB,UAAU,KAAK,QAAQ,UAAU,QAAQ,CAAC;AAC5E"}
+{"version":3,"file":"purge-image-variants.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/purge-image-variants.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { purgeImageVariantsOfFile, variantCacheDirectoryFor } from \"./image-variant-cache\";\nimport { remoteVariantDisk, remoteVariantPath } from \"./remote-variant-source\";\nimport { variantSourceDirectory, variantSourceKey } from \"./variant-cache-key\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport {\n  purgeVariantCacheEntries,\n  variantCacheEntries,\n  variantSourceCacheEntries,\n} from \"./image-variant-cache-entries\";\n\n/**\n * Options for {@link purgeImageVariants}\n */\nexport type PurgeImageVariantsOptions = {\n  /**\n   * Disk the source lives on; the default disk when omitted\n   */\n  disk?: StorageDriverName;\n};\n\n/**\n * Remove cached image derivatives.\n *\n * - With a path: every derivative of that file, in every variant and format.\n *   The file itself is untouched and does not need to exist.\n * - Without a path: the whole derivative cache of the disk. When\n *   `uploads.images.cacheDirectory` is set, that directory is shared by every\n *   local disk, so this clears all of them.\n *\n * Only recognized derivative, source-manifest and temporary files in the\n * generated cache layout are removed. The cache root, directories, unrelated\n * files and symlinks stay in place. Use a dedicated folder for derivatives.\n *\n * Deleting or moving a file through local storage (`storage.delete`,\n * `deleteMany`, `move`) already purges its derivatives; call this for files\n * removed some other way.\n *\n * @throws ImageVariantsConfigError when the cache equals or contains any\n * configured local disk root, including through a symlink\n * @returns `true` when something was removed\n */\nexport async function purgeImageVariants(\n  relativePath?: string,\n  options: PurgeImageVariantsOptions = {},\n): Promise<boolean> {\n  const diskRoot = localDiskRoot(options.disk);\n\n  if (!diskRoot) {\n    const disk = remoteVariantDisk(options.disk);\n    const location = relativePath === undefined ? undefined : remoteVariantPath(relativePath);\n    if (relativePath !== undefined && location === undefined) return false;\n    const cache = variantCacheDirectoryFor(disk.cacheRoot);\n    return purgeVariantCacheEntries(\n      location === undefined\n        ? variantCacheEntries(cache)\n        : variantSourceCacheEntries(\n            variantSourceDirectory(\n              cache,\n              variantSourceKey(disk.root, disk.driver.applyPrefix(location)),\n            ),\n          ),\n    );\n  }\n\n  if (relativePath === undefined) {\n    return purgeVariantCacheEntries(variantCacheEntries(variantCacheDirectoryFor(diskRoot)));\n  }\n\n  const location = relativePath.replace(/\\\\/g, \"/\").replace(/^\\/+/, \"\");\n\n  return purgeImageVariantsOfFile(diskRoot, path.resolve(diskRoot, location));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,eAAsB,mBACpB,cACA,UAAqC,CAAC,GACpB;CAClB,MAAM,WAAW,cAAc,QAAQ,IAAI;CAE3C,IAAI,CAAC,UAAU;EACb,MAAM,OAAO,kBAAkB,QAAQ,IAAI;EAC3C,MAAM,WAAW,iBAAiB,SAAY,SAAY,kBAAkB,YAAY;EACxF,IAAI,iBAAiB,UAAa,aAAa,QAAW,OAAO;EACjE,MAAM,QAAQ,yBAAyB,KAAK,SAAS;EACrD,OAAO,yBACL,aAAa,SACT,oBAAoB,KAAK,IACzB,0BACE,uBACE,OACA,iBAAiB,KAAK,MAAM,KAAK,OAAO,YAAY,QAAQ,CAAC,CAC/D,CACF,CACN;CACF;CAEA,IAAI,iBAAiB,QACnB,OAAO,yBAAyB,oBAAoB,yBAAyB,QAAQ,CAAC,CAAC;CAGzF,MAAM,WAAW,aAAa,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,QAAQ,EAAE;CAEpE,OAAO,yBAAyB,UAAU,KAAK,QAAQ,UAAU,QAAQ,CAAC;AAC5E"}

package/esm/http/uploads/remote-variant-source.mjs

@@ -0,0 +1,115 @@
+import { storagePath } from "../../utils/paths.mjs";
+import { HttpError } from "../errors/errors.mjs";
+import { storage } from "../../storage/storage.mjs";
+import "../../storage/index.mjs";
+import { detectImageFormat, isVariantSourceFormat } from "./detect-image-format.mjs";
+import { loadVariantSource } from "./load-variant-source.mjs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+//#region ../../packages/core/src/http/uploads/remote-variant-source.ts
+const activeSources = /* @__PURE__ */ new Map();
+function remoteVariantDisk(disk) {
+	const driver = disk === void 0 ? storage.activeDriver : storage.getDriver(disk);
+	const { bucket, endpoint, region } = driver.options;
+	return {
+		driver,
+		root: JSON.stringify([
+			driver.name,
+			bucket,
+			endpoint,
+			region
+		]),
+		cacheRoot: storagePath()
+	};
+}
+/** Object keys are normalized once, without URL decoding, before prefixing. */
+function remoteVariantPath(location) {
+	if (!location || location.includes("\0") || location.includes("\\") || path.posix.isAbsolute(location) || path.win32.isAbsolute(location) || /^[A-Za-z]:/.test(location) || location.split("/").includes("..")) return void 0;
+	const normalized = path.posix.normalize(location);
+	return normalized === "." ? void 0 : normalized;
+}
+async function remoteVariantSource(location, disk, images) {
+	const relativePath = remoteVariantPath(location);
+	if (!relativePath) return void 0;
+	const objectPath = relativePath;
+	let metadata;
+	try {
+		metadata = await disk.driver.metadata(relativePath);
+	} catch (error) {
+		const detail = error;
+		if ([
+			"ENOENT",
+			"NoSuchKey",
+			"NotFound"
+		].includes(detail.code ?? detail.name ?? "") || detail.$metadata?.httpStatusCode === 404) return void 0;
+		throw error;
+	}
+	if (metadata.isDirectory) return void 0;
+	if (metadata.size > images.maxSourceBytes) throw new HttpError(413, "The source image is too large.");
+	const sourcePath = disk.driver.applyPrefix(relativePath);
+	const metadataGeneration = metadata.etag ? createHash("sha256").update(JSON.stringify([
+		metadata.etag,
+		metadata.size,
+		metadata.lastModified?.getTime()
+	])).digest("hex") : void 0;
+	const activeKey = JSON.stringify([
+		disk.root,
+		sourcePath,
+		metadataGeneration,
+		images.maxSourceBytes,
+		images.maxSourcePixels
+	]);
+	const existing = activeSources.get(activeKey);
+	if (existing) {
+		existing.references++;
+		return existing.source;
+	}
+	let loaded;
+	async function load() {
+		const stream = await disk.driver.getStream(objectPath);
+		const chunks = [];
+		let size = 0;
+		try {
+			for await (const chunk of stream) {
+				const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+				size += bytes.length;
+				if (size > images.maxSourceBytes) throw new HttpError(413, "The source image is too large.");
+				chunks.push(bytes);
+			}
+		} finally {
+			stream.destroy();
+		}
+		const buffer = Buffer.concat(chunks);
+		const sourceFormat = detectImageFormat(buffer);
+		if (!isVariantSourceFormat(sourceFormat)) throw new HttpError(415, "Variants are only available for jpeg, png, webp and avif images.");
+		return {
+			image: await loadVariantSource(buffer, {
+				maxSourceBytes: images.maxSourceBytes,
+				maxSourcePixels: images.maxSourcePixels,
+				expectedFormat: sourceFormat
+			}),
+			sourceFormat,
+			generation: metadataGeneration ?? createHash("sha256").update(buffer).digest("hex")
+		};
+	}
+	const source = {
+		relativePath,
+		sourcePath,
+		metadataGeneration,
+		load: () => loaded ??= load(),
+		release() {
+			const active = activeSources.get(activeKey);
+			if (active && --active.references === 0) activeSources.delete(activeKey);
+		}
+	};
+	activeSources.set(activeKey, {
+		source,
+		references: 1
+	});
+	return source;
+}
+
+//#endregion
+export { remoteVariantDisk, remoteVariantPath, remoteVariantSource };
+//# sourceMappingURL=remote-variant-source.mjs.map

package/esm/http/uploads/remote-variant-source.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-variant-source.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/remote-variant-source.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport type { StorageDriverContract, StorageDriverName } from \"../../storage/types\";\nimport { storage } from \"../../storage\";\nimport { storagePath } from \"../../utils/paths\";\nimport { HttpError } from \"../errors\";\nimport { detectImageFormat, isVariantSourceFormat } from \"./detect-image-format\";\nimport type { ResolvedImageVariantsConfig } from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport type { Image } from \"../../image\";\nimport type { VariantSourceFormat } from \"./image-variant-types\";\n\ntype LoadedRemoteSource = { image: Image; sourceFormat: VariantSourceFormat; generation: string };\nexport type RemoteVariantSource = {\n  relativePath: string;\n  sourcePath: string;\n  metadataGeneration?: string;\n  load(): Promise<LoadedRemoteSource>;\n  release(): void;\n};\nconst activeSources = new Map<string, { references: number; source: RemoteVariantSource }>();\n\nexport function remoteVariantDisk(disk?: StorageDriverName): {\n  driver: StorageDriverContract;\n  root: string;\n  cacheRoot: string;\n} {\n  const driver = disk === undefined ? storage.activeDriver : storage.getDriver(disk);\n  const { bucket, endpoint, region } = driver.options;\n  return {\n    driver,\n    root: JSON.stringify([driver.name, bucket, endpoint, region]),\n    cacheRoot: storagePath(),\n  };\n}\n\n/** Object keys are normalized once, without URL decoding, before prefixing. */\nexport function remoteVariantPath(location: string): string | undefined {\n  if (\n    !location ||\n    location.includes(\"\\0\") ||\n    location.includes(\"\\\\\") ||\n    path.posix.isAbsolute(location) ||\n    path.win32.isAbsolute(location) ||\n    /^[A-Za-z]:/.test(location) ||\n    location.split(\"/\").includes(\"..\")\n  )\n    return undefined;\n  const normalized = path.posix.normalize(location);\n  return normalized === \".\" ? undefined : normalized;\n}\n\nexport async function remoteVariantSource(\n  location: string,\n  disk: ReturnType<typeof remoteVariantDisk>,\n  images: ResolvedImageVariantsConfig,\n): Promise<RemoteVariantSource | undefined> {\n  const relativePath = remoteVariantPath(location);\n  if (!relativePath) return undefined;\n  const objectPath = relativePath;\n  let metadata;\n  try {\n    metadata = await disk.driver.metadata(relativePath);\n  } catch (error) {\n    const detail = error as {\n      code?: string;\n      name?: string;\n      $metadata?: { httpStatusCode?: number };\n    };\n    if (\n      [\"ENOENT\", \"NoSuchKey\", \"NotFound\"].includes(detail.code ?? detail.name ?? \"\") ||\n      detail.$metadata?.httpStatusCode === 404\n    )\n      return undefined;\n    throw error;\n  }\n  if (metadata.isDirectory) return undefined;\n  if (metadata.size > images.maxSourceBytes)\n    throw new HttpError(413, \"The source image is too large.\");\n  // The identity includes the effective prefix, including tenant context.\n  const sourcePath = disk.driver.applyPrefix(relativePath);\n  const metadataGeneration = metadata.etag\n    ? createHash(\"sha256\")\n        .update(JSON.stringify([metadata.etag, metadata.size, metadata.lastModified?.getTime()]))\n        .digest(\"hex\")\n    : undefined;\n  const activeKey = JSON.stringify([\n    disk.root,\n    sourcePath,\n    metadataGeneration,\n    images.maxSourceBytes,\n    images.maxSourcePixels,\n  ]);\n  const existing = activeSources.get(activeKey);\n  if (existing) {\n    existing.references++;\n    return existing.source;\n  }\n  let loaded: Promise<LoadedRemoteSource> | undefined;\n  async function load() {\n    const stream = await disk.driver.getStream(objectPath);\n    const chunks: Buffer[] = [];\n    let size = 0;\n    try {\n      for await (const chunk of stream) {\n        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);\n        size += bytes.length;\n        if (size > images.maxSourceBytes)\n          throw new HttpError(413, \"The source image is too large.\");\n        chunks.push(bytes);\n      }\n    } finally {\n      stream.destroy();\n    }\n    const buffer = Buffer.concat(chunks);\n    const sourceFormat = detectImageFormat(buffer);\n    if (!isVariantSourceFormat(sourceFormat))\n      throw new HttpError(415, \"Variants are only available for jpeg, png, webp and avif images.\");\n    const image = await loadVariantSource(buffer, {\n      maxSourceBytes: images.maxSourceBytes,\n      maxSourcePixels: images.maxSourcePixels,\n      expectedFormat: sourceFormat,\n    });\n    return {\n      image,\n      sourceFormat,\n      generation: metadataGeneration ?? createHash(\"sha256\").update(buffer).digest(\"hex\"),\n    };\n  }\n  const source: RemoteVariantSource = {\n    relativePath,\n    sourcePath,\n    metadataGeneration,\n    load: () => (loaded ??= load()),\n    release() {\n      const active = activeSources.get(activeKey);\n      if (active && --active.references === 0) activeSources.delete(activeKey);\n    },\n  };\n  activeSources.set(activeKey, { source, references: 1 });\n  return source;\n}\n"],"mappings":"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"}

package/esm/http/uploads/resolve-image-variant.d.mts

@@ -1,12 +1,11 @@
 import { StorageDriverName } from "../../storage/types.mjs";
 import { VariantOutputFormat } from "./image-variant-types.mjs";
-
 //#region ../../packages/core/src/http/uploads/resolve-image-variant.d.ts
 /**
- * What to render: a file on a local disk and a variant named in
+ * What to render: a file on a storage disk and a variant named in
  * `uploads.images.variants`
  */
-type ResolveImageVariantInput = {
+export type ResolveImageVariantInput = {
   /**
    * Path of the source, relative to the disk root
    */
@@ -21,14 +20,14 @@ type ResolveImageVariantInput = {
    */
   format?: VariantOutputFormat;
   /**
-   * Local disk the source lives on; the default disk when omitted
+   * Disk the source lives on; the default disk when omitted
    */
   disk?: StorageDriverName;
 };
 /**
  * A derivative on disk, ready to send
  */
-type ResolvedImageVariant = {
+export type ResolvedImageVariant = {
   /**
    * Absolute path of the cached derivative
    */
@@ -41,7 +40,7 @@ type ResolvedImageVariant = {
   contentType: string;
 };
 /**
- * Resolve, and render on a cache miss, one variant of an image on a local
+ * Resolve, and render on a cache miss, one variant of an image on a storage
  * disk. This is what `uploadedFileController` serves; call it from your own
  * route to serve variants of a private disk behind authentication:
  *
@@ -61,13 +60,11 @@ type ResolvedImageVariant = {
  * are pruned once a new derivative is written.
  *
  * @returns `undefined` when the path does not resolve to a file on the disk
- * @throws ImageVariantsConfigError when the disk is not a local disk
  * @throws HttpError(400) when variants are not configured, or the variant or
  * format is not allowed
  * @throws HttpError(413) when the source is over the configured limits
  * @throws HttpError(415) when the source is not jpeg, png, webp or avif
  */
-declare function resolveImageVariant(input: ResolveImageVariantInput): Promise<ResolvedImageVariant | undefined>;
+export declare function resolveImageVariant(input: ResolveImageVariantInput): Promise<ResolvedImageVariant | undefined>;
 //#endregion
-export { ResolveImageVariantInput, ResolvedImageVariant, resolveImageVariant };
 //# sourceMappingURL=resolve-image-variant.d.mts.map

package/esm/http/uploads/resolve-image-variant.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-image-variant.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variant.ts"],"mappings":";;;;;;AAoCA;;KAAY,wBAAA;EAoBc;;;EAhBxB,IAAA;EAWS;;;EANT,OAAA;EAWwB;AAM1B;;;EAXE,MAAA,GAAS,mBAAA;EAeT;;;EAVA,IAAA,GAAO,iBAAiB;AAAA;;AAmBb;AAwCb;KArDY,oBAAA;;;;EAIV,YAAA;EAmDQ;;;EA9CR,IAAA;EAEA,MAAA,EAAQ,mBAAmB;EAE3B,WAAA;AAAA;AA0C6B;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iBAFT,mBAAA,CACpB,KAAA,EAAO,wBAAA,GACN,OAAA,CAAQ,oBAAA"}
+{"version":3,"file":"resolve-image-variant.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variant.ts"],"mappings":";;;;;;;YAoCY;;;;EAIV;;;;EAKA;;;;;EAMA,SAAS;;;;EAKT,OAAO;;;;;YAMG;;;;EAIV;;;;EAKA;EAEA,QAAQ;EAER;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BoB,oBACpB,OAAO,2BACN,QAAQ"}

package/esm/http/uploads/resolve-image-variant.mjs

@@ -2,14 +2,14 @@ import { HttpError } from "../errors/errors.mjs";
 import { uploadsConfig } from "../uploads-config.mjs";
 import { variantCacheKey, variantCachePath, variantGenerationTag, variantSourceDirectory, variantSourceKey } from "./variant-cache-key.mjs";
 import { pruneStaleVariantGenerationsIfCurrent, retryOnVanishedDirectory, warnIfVariantCacheIsPublic } from "./image-variant-cache.mjs";
-import { generateImageVariant } from "./generate-image-variant.mjs";
-import { ImageVariantsConfigError } from "./image-variants-config-error.mjs";
+import { localDiskRoot } from "./local-disk-root.mjs";
 import { loadVariantSource } from "./load-variant-source.mjs";
+import { generateImageVariant } from "./generate-image-variant.mjs";
 import { resolveImageVariantsConfig } from "./resolve-image-variants-config.mjs";
-import { resolveVariantCandidate } from "./resolve-variant-candidate.mjs";
+import { freshImageVariant, scheduleImageVariantCacheTrim } from "./trim-image-variant-cache.mjs";
 import { variantGenerations } from "./variant-generations.mjs";
-import { localDiskRoot } from "./local-disk-root.mjs";
-import fs from "node:fs/promises";
+import { resolveRemoteImageVariant } from "./resolve-remote-image-variant.mjs";
+import { resolveVariantCandidate } from "./resolve-variant-candidate.mjs";
 
 //#region ../../packages/core/src/http/uploads/resolve-image-variant.ts
 const CONTENT_TYPES = {
@@ -18,16 +18,8 @@ const CONTENT_TYPES = {
 	webp: "image/webp",
 	avif: "image/avif"
 };
-async function exists(target) {
-	try {
-		await fs.access(target);
-		return true;
-	} catch {
-		return false;
-	}
-}
 /**
-* Resolve, and render on a cache miss, one variant of an image on a local
+* Resolve, and render on a cache miss, one variant of an image on a storage
 * disk. This is what `uploadedFileController` serves; call it from your own
 * route to serve variants of a private disk behind authentication:
 *
@@ -47,7 +39,6 @@ async function exists(target) {
 * are pruned once a new derivative is written.
 *
 * @returns `undefined` when the path does not resolve to a file on the disk
-* @throws ImageVariantsConfigError when the disk is not a local disk
 * @throws HttpError(400) when variants are not configured, or the variant or
 * format is not allowed
 * @throws HttpError(413) when the source is over the configured limits
@@ -55,7 +46,7 @@ async function exists(target) {
 */
 async function resolveImageVariant(input) {
 	const diskRoot = localDiskRoot(input.disk);
-	if (!diskRoot) throw new ImageVariantsConfigError(input.disk === void 0 ? "Image variants need a local storage driver with a root." : `Image variants need a local disk; "${input.disk}" is not one.`);
+	if (!diskRoot) return resolveRemoteImageVariant(input);
 	const images = resolveImageVariantsConfig(uploadsConfig("images"), diskRoot);
 	if (!images) throw new HttpError(400, "Image variants are not configured.");
 	const variant = Object.prototype.hasOwnProperty.call(images.variants, input.variant) ? images.variants[input.variant] : void 0;
@@ -79,8 +70,8 @@ async function resolveImageVariant(input) {
 		sourceKey,
 		generation
 	}, hash, format);
-	if (!await exists(target)) await variantGenerations.run(target, async () => {
-		if (await exists(target)) return;
+	if (!await freshImageVariant(target, images.maxCacheAge)) await variantGenerations.run(target, async () => {
+		if (await freshImageVariant(target, images.maxCacheAge)) return;
 		const image = await loadVariantSource(source.absolutePath, {
 			maxSourceBytes: images.maxSourceBytes,
 			maxSourcePixels: images.maxSourcePixels,
@@ -92,6 +83,7 @@ async function resolveImageVariant(input) {
 			format,
 			targetPath: target
 		}));
+		scheduleImageVariantCacheTrim(images, target);
 		await pruneStaleVariantGenerationsIfCurrent(source.absolutePath, variantSourceDirectory(images.cacheDirectory, sourceKey), generation);
 	});
 	return {

package/esm/http/uploads/resolve-image-variant.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-image-variant.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variant.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { HttpError } from \"../errors\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport {\n  pruneStaleVariantGenerationsIfCurrent,\n  retryOnVanishedDirectory,\n  warnIfVariantCacheIsPublic,\n} from \"./image-variant-cache\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport { resolveVariantCandidate } from \"./resolve-variant-candidate\";\nimport {\n  variantCacheKey,\n  variantCachePath,\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\nimport { variantGenerations } from \"./variant-generations\";\n\nconst CONTENT_TYPES: Record<VariantOutputFormat, string> = {\n  jpeg: \"image/jpeg\",\n  png: \"image/png\",\n  webp: \"image/webp\",\n  avif: \"image/avif\",\n};\n\n/**\n * What to render: a file on a local disk and a variant named in\n * `uploads.images.variants`\n */\nexport type ResolveImageVariantInput = {\n  /**\n   * Path of the source, relative to the disk root\n   */\n  path: string;\n\n  /**\n   * Variant name from `uploads.images.variants`\n   */\n  variant: string;\n\n  /**\n   * Output format; defaults to the source's own format. Must be the source\n   * format or one listed in `uploads.images.formats`.\n   */\n  format?: VariantOutputFormat;\n\n  /**\n   * Local disk the source lives on; the default disk when omitted\n   */\n  disk?: StorageDriverName;\n};\n\n/**\n * A derivative on disk, ready to send\n */\nexport type ResolvedImageVariant = {\n  /**\n   * Absolute path of the cached derivative\n   */\n  absolutePath: string;\n\n  /**\n   * sha256 of everything the derivative depends on; a strong ETag value\n   */\n  hash: string;\n\n  format: VariantOutputFormat;\n\n  contentType: string;\n};\n\nasync function exists(target: string): Promise<boolean> {\n  try {\n    await fs.access(target);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve, and render on a cache miss, one variant of an image on a local\n * disk. This is what `uploadedFileController` serves; call it from your own\n * route to serve variants of a private disk behind authentication:\n *\n * ```ts\n * const variant = await resolveImageVariant({ disk: \"private\", path, variant: \"thumb\" });\n * if (!variant) return response.notFound();\n * return response.sendBuffer(await fs.readFile(variant.absolutePath), {\n *   contentType: variant.contentType,\n * });\n * ```\n *\n * The same guards apply as on the public route: the path must stay inside\n * the disk root and outside the derivative cache, the source must be a\n * jpeg/png/webp/avif within `maxSourceBytes`/`maxSourcePixels`, and only\n * declared variants and formats render. Derivatives are generated once per\n * key, even under concurrent calls, and older versions of a rewritten source\n * are pruned once a new derivative is written.\n *\n * @returns `undefined` when the path does not resolve to a file on the disk\n * @throws ImageVariantsConfigError when the disk is not a local disk\n * @throws HttpError(400) when variants are not configured, or the variant or\n * format is not allowed\n * @throws HttpError(413) when the source is over the configured limits\n * @throws HttpError(415) when the source is not jpeg, png, webp or avif\n */\nexport async function resolveImageVariant(\n  input: ResolveImageVariantInput,\n): Promise<ResolvedImageVariant | undefined> {\n  const diskRoot = localDiskRoot(input.disk);\n\n  if (!diskRoot) {\n    throw new ImageVariantsConfigError(\n      input.disk === undefined\n        ? \"Image variants need a local storage driver with a root.\"\n        : `Image variants need a local disk; \"${input.disk}\" is not one.`,\n    );\n  }\n\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), diskRoot);\n\n  if (!images) {\n    throw new HttpError(400, \"Image variants are not configured.\");\n  }\n\n  const variant = Object.prototype.hasOwnProperty.call(images.variants, input.variant)\n    ? images.variants[input.variant]\n    : undefined;\n\n  if (variant === undefined) {\n    throw new HttpError(400, `Unknown variant \"${input.variant}\".`);\n  }\n\n  if (input.format !== undefined && !images.formats.includes(input.format as never)) {\n    throw new HttpError(400, `Format \"${input.format}\" is not allowed.`);\n  }\n\n  warnIfVariantCacheIsPublic(images.cacheDirectory);\n\n  const candidate = await resolveVariantCandidate(input.path, diskRoot, images);\n\n  if (!candidate) return undefined;\n\n  const { source, stats, sourceFormat } = candidate;\n  const format: VariantOutputFormat = input.format ?? sourceFormat;\n  const hash = variantCacheKey({\n    relativePath: source.relativePath,\n    sourceSize: stats.size,\n    sourceMtimeMs: stats.mtimeMs,\n    variant,\n    format,\n  });\n  const sourceKey = variantSourceKey(source.root, source.relativePath);\n  const generation = variantGenerationTag(stats.size, stats.mtimeMs);\n  const target = variantCachePath(images.cacheDirectory, { sourceKey, generation }, hash, format);\n\n  if (!(await exists(target))) {\n    // Keyed on the target path, which includes the disk's real root: the\n    // same file on two disks (a mirror copied with its mtime) has the same\n    // `hash`, and joining the other disk's flight would leave this target\n    // unwritten.\n    await variantGenerations.run(target, async () => {\n      if (await exists(target)) return;\n\n      const image = await loadVariantSource(source.absolutePath, {\n        maxSourceBytes: images.maxSourceBytes,\n        maxSourcePixels: images.maxSourcePixels,\n        expectedFormat: sourceFormat,\n      });\n\n      await retryOnVanishedDirectory(() =>\n        generateImageVariant({ image: image.clone(), variant, format, targetPath: target }),\n      );\n      await pruneStaleVariantGenerationsIfCurrent(\n        source.absolutePath,\n        variantSourceDirectory(images.cacheDirectory, sourceKey),\n        generation,\n      );\n    });\n  }\n\n  return { absolutePath: target, hash, format, contentType: CONTENT_TYPES[format] };\n}\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAM,gBAAqD;CACzD,MAAM;CACN,KAAK;CACL,MAAM;CACN,MAAM;AACR;AAgDA,eAAe,OAAO,QAAkC;CACtD,IAAI;EACF,MAAM,GAAG,OAAO,MAAM;EAEtB,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,oBACpB,OAC2C;CAC3C,MAAM,WAAW,cAAc,MAAM,IAAI;CAEzC,IAAI,CAAC,UACH,MAAM,IAAI,yBACR,MAAM,SAAS,SACX,4DACA,sCAAsC,MAAM,KAAK,cACvD;CAGF,MAAM,SAAS,2BAA2B,cAAc,QAAQ,GAAG,QAAQ;CAE3E,IAAI,CAAC,QACH,MAAM,IAAI,UAAU,KAAK,oCAAoC;CAG/D,MAAM,UAAU,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,MAAM,OAAO,IAC/E,OAAO,SAAS,MAAM,WACtB;CAEJ,IAAI,YAAY,QACd,MAAM,IAAI,UAAU,KAAK,oBAAoB,MAAM,QAAQ,GAAG;CAGhE,IAAI,MAAM,WAAW,UAAa,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAe,GAC9E,MAAM,IAAI,UAAU,KAAK,WAAW,MAAM,OAAO,kBAAkB;CAGrE,2BAA2B,OAAO,cAAc;CAEhD,MAAM,YAAY,MAAM,wBAAwB,MAAM,MAAM,UAAU,MAAM;CAE5E,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,EAAE,QAAQ,OAAO,iBAAiB;CACxC,MAAM,SAA8B,MAAM,UAAU;CACpD,MAAM,OAAO,gBAAgB;EAC3B,cAAc,OAAO;EACrB,YAAY,MAAM;EAClB,eAAe,MAAM;EACrB;EACA;CACF,CAAC;CACD,MAAM,YAAY,iBAAiB,OAAO,MAAM,OAAO,YAAY;CACnE,MAAM,aAAa,qBAAqB,MAAM,MAAM,MAAM,OAAO;CACjE,MAAM,SAAS,iBAAiB,OAAO,gBAAgB;EAAE;EAAW;CAAW,GAAG,MAAM,MAAM;CAE9F,IAAI,CAAE,MAAM,OAAO,MAAM,GAKvB,MAAM,mBAAmB,IAAI,QAAQ,YAAY;EAC/C,IAAI,MAAM,OAAO,MAAM,GAAG;EAE1B,MAAM,QAAQ,MAAM,kBAAkB,OAAO,cAAc;GACzD,gBAAgB,OAAO;GACvB,iBAAiB,OAAO;GACxB,gBAAgB;EAClB,CAAC;EAED,MAAM,+BACJ,qBAAqB;GAAE,OAAO,MAAM,MAAM;GAAG;GAAS;GAAQ,YAAY;EAAO,CAAC,CACpF;EACA,MAAM,sCACJ,OAAO,cACP,uBAAuB,OAAO,gBAAgB,SAAS,GACvD,UACF;CACF,CAAC;CAGH,OAAO;EAAE,cAAc;EAAQ;EAAM;EAAQ,aAAa,cAAc;CAAQ;AAClF"}
+{"version":3,"file":"resolve-image-variant.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variant.ts"],"sourcesContent":["import type { StorageDriverName } from \"../../storage/types\";\nimport { HttpError } from \"../errors\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport {\n  pruneStaleVariantGenerationsIfCurrent,\n  retryOnVanishedDirectory,\n  warnIfVariantCacheIsPublic,\n} from \"./image-variant-cache\";\nimport { resolveRemoteImageVariant } from \"./resolve-remote-image-variant\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport { resolveVariantCandidate } from \"./resolve-variant-candidate\";\nimport {\n  variantCacheKey,\n  variantCachePath,\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\nimport { freshImageVariant, scheduleImageVariantCacheTrim } from \"./trim-image-variant-cache\";\nimport { variantGenerations } from \"./variant-generations\";\n\nconst CONTENT_TYPES: Record<VariantOutputFormat, string> = {\n  jpeg: \"image/jpeg\",\n  png: \"image/png\",\n  webp: \"image/webp\",\n  avif: \"image/avif\",\n};\n\n/**\n * What to render: a file on a storage disk and a variant named in\n * `uploads.images.variants`\n */\nexport type ResolveImageVariantInput = {\n  /**\n   * Path of the source, relative to the disk root\n   */\n  path: string;\n\n  /**\n   * Variant name from `uploads.images.variants`\n   */\n  variant: string;\n\n  /**\n   * Output format; defaults to the source's own format. Must be the source\n   * format or one listed in `uploads.images.formats`.\n   */\n  format?: VariantOutputFormat;\n\n  /**\n   * Disk the source lives on; the default disk when omitted\n   */\n  disk?: StorageDriverName;\n};\n\n/**\n * A derivative on disk, ready to send\n */\nexport type ResolvedImageVariant = {\n  /**\n   * Absolute path of the cached derivative\n   */\n  absolutePath: string;\n\n  /**\n   * sha256 of everything the derivative depends on; a strong ETag value\n   */\n  hash: string;\n\n  format: VariantOutputFormat;\n\n  contentType: string;\n};\n\n/**\n * Resolve, and render on a cache miss, one variant of an image on a storage\n * disk. This is what `uploadedFileController` serves; call it from your own\n * route to serve variants of a private disk behind authentication:\n *\n * ```ts\n * const variant = await resolveImageVariant({ disk: \"private\", path, variant: \"thumb\" });\n * if (!variant) return response.notFound();\n * return response.sendBuffer(await fs.readFile(variant.absolutePath), {\n *   contentType: variant.contentType,\n * });\n * ```\n *\n * The same guards apply as on the public route: the path must stay inside\n * the disk root and outside the derivative cache, the source must be a\n * jpeg/png/webp/avif within `maxSourceBytes`/`maxSourcePixels`, and only\n * declared variants and formats render. Derivatives are generated once per\n * key, even under concurrent calls, and older versions of a rewritten source\n * are pruned once a new derivative is written.\n *\n * @returns `undefined` when the path does not resolve to a file on the disk\n * @throws HttpError(400) when variants are not configured, or the variant or\n * format is not allowed\n * @throws HttpError(413) when the source is over the configured limits\n * @throws HttpError(415) when the source is not jpeg, png, webp or avif\n */\nexport async function resolveImageVariant(\n  input: ResolveImageVariantInput,\n): Promise<ResolvedImageVariant | undefined> {\n  const diskRoot = localDiskRoot(input.disk);\n\n  if (!diskRoot) return resolveRemoteImageVariant(input);\n\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), diskRoot);\n\n  if (!images) {\n    throw new HttpError(400, \"Image variants are not configured.\");\n  }\n\n  const variant = Object.prototype.hasOwnProperty.call(images.variants, input.variant)\n    ? images.variants[input.variant]\n    : undefined;\n\n  if (variant === undefined) {\n    throw new HttpError(400, `Unknown variant \"${input.variant}\".`);\n  }\n\n  if (input.format !== undefined && !images.formats.includes(input.format as never)) {\n    throw new HttpError(400, `Format \"${input.format}\" is not allowed.`);\n  }\n\n  warnIfVariantCacheIsPublic(images.cacheDirectory);\n\n  const candidate = await resolveVariantCandidate(input.path, diskRoot, images);\n\n  if (!candidate) return undefined;\n\n  const { source, stats, sourceFormat } = candidate;\n  const format: VariantOutputFormat = input.format ?? sourceFormat;\n  const hash = variantCacheKey({\n    relativePath: source.relativePath,\n    sourceSize: stats.size,\n    sourceMtimeMs: stats.mtimeMs,\n    variant,\n    format,\n  });\n  const sourceKey = variantSourceKey(source.root, source.relativePath);\n  const generation = variantGenerationTag(stats.size, stats.mtimeMs);\n  const target = variantCachePath(images.cacheDirectory, { sourceKey, generation }, hash, format);\n\n  if (!(await freshImageVariant(target, images.maxCacheAge))) {\n    // Keyed on the target path, which includes the disk's real root: the\n    // same file on two disks (a mirror copied with its mtime) has the same\n    // `hash`, and joining the other disk's flight would leave this target\n    // unwritten.\n    await variantGenerations.run(target, async () => {\n      if (await freshImageVariant(target, images.maxCacheAge)) return;\n\n      const image = await loadVariantSource(source.absolutePath, {\n        maxSourceBytes: images.maxSourceBytes,\n        maxSourcePixels: images.maxSourcePixels,\n        expectedFormat: sourceFormat,\n      });\n\n      await retryOnVanishedDirectory(() =>\n        generateImageVariant({ image: image.clone(), variant, format, targetPath: target }),\n      );\n      scheduleImageVariantCacheTrim(images, target);\n      await pruneStaleVariantGenerationsIfCurrent(\n        source.absolutePath,\n        variantSourceDirectory(images.cacheDirectory, sourceKey),\n        generation,\n      );\n    });\n  }\n\n  return { absolutePath: target, hash, format, contentType: CONTENT_TYPES[format] };\n}\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAM,gBAAqD;CACzD,MAAM;CACN,KAAK;CACL,MAAM;CACN,MAAM;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,eAAsB,oBACpB,OAC2C;CAC3C,MAAM,WAAW,cAAc,MAAM,IAAI;CAEzC,IAAI,CAAC,UAAU,OAAO,0BAA0B,KAAK;CAErD,MAAM,SAAS,2BAA2B,cAAc,QAAQ,GAAG,QAAQ;CAE3E,IAAI,CAAC,QACH,MAAM,IAAI,UAAU,KAAK,oCAAoC;CAG/D,MAAM,UAAU,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,MAAM,OAAO,IAC/E,OAAO,SAAS,MAAM,WACtB;CAEJ,IAAI,YAAY,QACd,MAAM,IAAI,UAAU,KAAK,oBAAoB,MAAM,QAAQ,GAAG;CAGhE,IAAI,MAAM,WAAW,UAAa,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAe,GAC9E,MAAM,IAAI,UAAU,KAAK,WAAW,MAAM,OAAO,kBAAkB;CAGrE,2BAA2B,OAAO,cAAc;CAEhD,MAAM,YAAY,MAAM,wBAAwB,MAAM,MAAM,UAAU,MAAM;CAE5E,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,EAAE,QAAQ,OAAO,iBAAiB;CACxC,MAAM,SAA8B,MAAM,UAAU;CACpD,MAAM,OAAO,gBAAgB;EAC3B,cAAc,OAAO;EACrB,YAAY,MAAM;EAClB,eAAe,MAAM;EACrB;EACA;CACF,CAAC;CACD,MAAM,YAAY,iBAAiB,OAAO,MAAM,OAAO,YAAY;CACnE,MAAM,aAAa,qBAAqB,MAAM,MAAM,MAAM,OAAO;CACjE,MAAM,SAAS,iBAAiB,OAAO,gBAAgB;EAAE;EAAW;CAAW,GAAG,MAAM,MAAM;CAE9F,IAAI,CAAE,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GAKtD,MAAM,mBAAmB,IAAI,QAAQ,YAAY;EAC/C,IAAI,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GAAG;EAEzD,MAAM,QAAQ,MAAM,kBAAkB,OAAO,cAAc;GACzD,gBAAgB,OAAO;GACvB,iBAAiB,OAAO;GACxB,gBAAgB;EAClB,CAAC;EAED,MAAM,+BACJ,qBAAqB;GAAE,OAAO,MAAM,MAAM;GAAG;GAAS;GAAQ,YAAY;EAAO,CAAC,CACpF;EACA,8BAA8B,QAAQ,MAAM;EAC5C,MAAM,sCACJ,OAAO,cACP,uBAAuB,OAAO,gBAAgB,SAAS,GACvD,UACF;CACF,CAAC;CAGH,OAAO;EAAE,cAAc;EAAQ;EAAM;EAAQ,aAAa,cAAc;CAAQ;AAClF"}

package/esm/http/uploads/resolve-image-variants-config.mjs

@@ -1,5 +1,5 @@
 import { ImageVariantsConfigError } from "./image-variants-config-error.mjs";
-import path from "node:path";
+import { variantCacheDirectoryFor } from "./image-variant-cache.mjs";
 
 //#region ../../packages/core/src/http/uploads/resolve-image-variants-config.ts
 /**
@@ -9,7 +9,7 @@ const MAX_VARIANT_DIMENSION = 8192;
 /**
 * Default `maxSourceBytes`: 25 MB
 */
-const DEFAULT_MAX_SOURCE_BYTES = 25 * 1024 * 1024;
+const DEFAULT_MAX_SOURCE_BYTES = 26214400;
 /**
 * Default `maxSourcePixels`
 */
@@ -76,16 +76,18 @@ function resolveImageVariantsConfig(images, storageRoot) {
 	if (!rawVariants || typeof rawVariants !== "object" || Object.keys(rawVariants).length === 0) throw new ImageVariantsConfigError("uploads.images.variants must declare at least one variant.");
 	const variants = {};
 	for (const [name, raw] of Object.entries(rawVariants)) variants[name] = resolveVariant(name, raw);
-	const cacheDirectory = images.cacheDirectory ? path.resolve(images.cacheDirectory) : path.join(storageRoot, ".cache", "image-variants");
+	const cacheDirectory = variantCacheDirectoryFor(storageRoot, images);
 	return {
 		variants,
 		formats: resolveFormats(images.formats),
 		maxSourceBytes: resolveLimit("maxSourceBytes", images.maxSourceBytes, DEFAULT_MAX_SOURCE_BYTES),
 		maxSourcePixels: resolveLimit("maxSourcePixels", images.maxSourcePixels, DEFAULT_MAX_SOURCE_PIXELS),
-		cacheDirectory
+		cacheDirectory,
+		maxCacheBytes: resolveLimit("maxCacheBytes", images.maxCacheBytes, 536870912),
+		maxCacheAge: resolveLimit("maxCacheAge", images.maxCacheAge, 604800)
 	};
 }
 
 //#endregion
-export { resolveImageVariantsConfig };
+export { DEFAULT_MAX_SOURCE_BYTES, DEFAULT_MAX_SOURCE_PIXELS, MAX_VARIANT_DIMENSION, resolveImageVariantsConfig };
 //# sourceMappingURL=resolve-image-variants-config.mjs.map

package/esm/http/uploads/resolve-image-variants-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-image-variants-config.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variants-config.ts"],"sourcesContent":["import path from \"node:path\";\nimport type {\n  ImageVariantDefinition,\n  ImageVariantFit,\n  ImageVariantOutputFormat,\n  UploadsImagesConfigurations,\n} from \"../uploads-types\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport type { ResolvedImageVariantsConfig } from \"./image-variant-types\";\n\n/**\n * Largest width or height a variant may declare\n */\nexport const MAX_VARIANT_DIMENSION = 8192;\n\n/**\n * Default `maxSourceBytes`: 25 MB\n */\nexport const DEFAULT_MAX_SOURCE_BYTES = 25 * 1024 * 1024;\n\n/**\n * Default `maxSourcePixels`\n */\nexport const DEFAULT_MAX_SOURCE_PIXELS = 40_000_000;\n\nconst FITS: readonly ImageVariantFit[] = [\"cover\", \"contain\", \"inside\"];\n\nconst OUTPUT_FORMATS: readonly ImageVariantOutputFormat[] = [\"avif\", \"webp\"];\n\nconst VARIANT_NAME = /^[A-Za-z0-9_-]+$/;\n\nfunction isPositiveInteger(value: unknown, max = Number.MAX_SAFE_INTEGER): value is number {\n  return typeof value === \"number\" && Number.isInteger(value) && value >= 1 && value <= max;\n}\n\nfunction resolveVariant(name: string, raw: unknown): ImageVariantDefinition {\n  const key = `uploads.images.variants.${name}`;\n\n  if (!VARIANT_NAME.test(name)) {\n    throw new ImageVariantsConfigError(\n      `${key}: a variant name may only use letters, digits, \"-\" and \"_\".`,\n    );\n  }\n\n  if (!raw || typeof raw !== \"object\") {\n    throw new ImageVariantsConfigError(`${key} must be an object with a width.`);\n  }\n\n  const { width, height, fit, quality, enlarge } = raw as Record<string, unknown>;\n\n  if (!isPositiveInteger(width, MAX_VARIANT_DIMENSION)) {\n    throw new ImageVariantsConfigError(\n      `${key}.width must be an integer from 1 to ${MAX_VARIANT_DIMENSION}, got ${JSON.stringify(width)}.`,\n    );\n  }\n\n  const variant: ImageVariantDefinition = { width };\n\n  if (height !== undefined) {\n    if (!isPositiveInteger(height, MAX_VARIANT_DIMENSION)) {\n      throw new ImageVariantsConfigError(\n        `${key}.height must be an integer from 1 to ${MAX_VARIANT_DIMENSION}, got ${JSON.stringify(height)}.`,\n      );\n    }\n\n    variant.height = height;\n  }\n\n  if (fit !== undefined) {\n    if (!FITS.includes(fit as ImageVariantFit)) {\n      throw new ImageVariantsConfigError(\n        `${key}.fit must be one of ${FITS.join(\", \")}, got ${JSON.stringify(fit)}.`,\n      );\n    }\n\n    variant.fit = fit as ImageVariantFit;\n  }\n\n  if (quality !== undefined) {\n    if (!isPositiveInteger(quality, 100)) {\n      throw new ImageVariantsConfigError(\n        `${key}.quality must be an integer from 1 to 100, got ${JSON.stringify(quality)}.`,\n      );\n    }\n\n    variant.quality = quality;\n  }\n\n  if (enlarge !== undefined && typeof enlarge !== \"boolean\") {\n    throw new ImageVariantsConfigError(\n      `${key}.enlarge must be a boolean, got ${JSON.stringify(enlarge)}.`,\n    );\n  }\n\n  // Always set, never left undefined: the effective flag (default false) is\n  // part of the normalized variant, so toggling it changes the cache key.\n  variant.enlarge = enlarge === true;\n\n  return variant;\n}\n\nfunction resolveFormats(raw: unknown): readonly ImageVariantOutputFormat[] {\n  if (raw === undefined) return [];\n\n  if (!Array.isArray(raw)) {\n    throw new ImageVariantsConfigError(`uploads.images.formats must be an array.`);\n  }\n\n  for (const format of raw) {\n    if (!OUTPUT_FORMATS.includes(format)) {\n      throw new ImageVariantsConfigError(\n        `uploads.images.formats may only contain ${OUTPUT_FORMATS.join(\", \")}, got ${JSON.stringify(format)}.`,\n      );\n    }\n  }\n\n  return [...new Set(raw as ImageVariantOutputFormat[])];\n}\n\nfunction resolveLimit(name: string, raw: unknown, fallback: number): number {\n  if (raw === undefined) return fallback;\n\n  if (!isPositiveInteger(raw)) {\n    throw new ImageVariantsConfigError(\n      `uploads.images.${name} must be a positive integer, got ${JSON.stringify(raw)}.`,\n    );\n  }\n\n  return raw;\n}\n\n/**\n * Validate the `uploads.images` config and apply its defaults.\n *\n * Every variant is copied field by field, so an unknown key in the config can\n * never reach sharp, and the result is what the cache key is computed from.\n *\n * @param images - the raw `uploads.images` value\n * @param storageRoot - the local storage root, base of the default cache directory\n * @returns the resolved config, or `undefined` when variants are not configured\n * @throws ImageVariantsConfigError when any value is out of bounds\n */\nexport function resolveImageVariantsConfig(\n  images: UploadsImagesConfigurations | undefined,\n  storageRoot: string,\n): ResolvedImageVariantsConfig | undefined {\n  if (images === undefined || images === null) return undefined;\n\n  if (typeof images !== \"object\") {\n    throw new ImageVariantsConfigError(\"uploads.images must be an object.\");\n  }\n\n  const rawVariants = (images as { variants?: unknown }).variants;\n\n  if (!rawVariants || typeof rawVariants !== \"object\" || Object.keys(rawVariants).length === 0) {\n    throw new ImageVariantsConfigError(\n      \"uploads.images.variants must declare at least one variant.\",\n    );\n  }\n\n  const variants: Record<string, ImageVariantDefinition> = {};\n\n  for (const [name, raw] of Object.entries(rawVariants)) {\n    variants[name] = resolveVariant(name, raw);\n  }\n\n  const cacheDirectory = images.cacheDirectory\n    ? path.resolve(images.cacheDirectory)\n    : path.join(storageRoot, \".cache\", \"image-variants\");\n\n  return {\n    variants,\n    formats: resolveFormats(images.formats),\n    maxSourceBytes: resolveLimit(\"maxSourceBytes\", images.maxSourceBytes, DEFAULT_MAX_SOURCE_BYTES),\n    maxSourcePixels: resolveLimit(\n      \"maxSourcePixels\",\n      images.maxSourcePixels,\n      DEFAULT_MAX_SOURCE_PIXELS,\n    ),\n    cacheDirectory,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"resolve-image-variants-config.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-image-variants-config.ts"],"sourcesContent":["import type {\n  ImageVariantDefinition,\n  ImageVariantFit,\n  ImageVariantOutputFormat,\n  UploadsImagesConfigurations,\n} from \"../uploads-types\";\nimport { variantCacheDirectoryFor } from \"./image-variant-cache\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport type { ResolvedImageVariantsConfig } from \"./image-variant-types\";\n\n/**\n * Largest width or height a variant may declare\n */\nexport const MAX_VARIANT_DIMENSION = 8192;\n\n/**\n * Default `maxSourceBytes`: 25 MB\n */\nexport const DEFAULT_MAX_SOURCE_BYTES = 25 * 1024 * 1024;\n\n/**\n * Default `maxSourcePixels`\n */\nexport const DEFAULT_MAX_SOURCE_PIXELS = 40_000_000;\n\nconst FITS: readonly ImageVariantFit[] = [\"cover\", \"contain\", \"inside\"];\n\nconst OUTPUT_FORMATS: readonly ImageVariantOutputFormat[] = [\"avif\", \"webp\"];\n\nconst VARIANT_NAME = /^[A-Za-z0-9_-]+$/;\n\nfunction isPositiveInteger(value: unknown, max = Number.MAX_SAFE_INTEGER): value is number {\n  return typeof value === \"number\" && Number.isInteger(value) && value >= 1 && value <= max;\n}\n\nfunction resolveVariant(name: string, raw: unknown): ImageVariantDefinition {\n  const key = `uploads.images.variants.${name}`;\n\n  if (!VARIANT_NAME.test(name)) {\n    throw new ImageVariantsConfigError(\n      `${key}: a variant name may only use letters, digits, \"-\" and \"_\".`,\n    );\n  }\n\n  if (!raw || typeof raw !== \"object\") {\n    throw new ImageVariantsConfigError(`${key} must be an object with a width.`);\n  }\n\n  const { width, height, fit, quality, enlarge } = raw as Record<string, unknown>;\n\n  if (!isPositiveInteger(width, MAX_VARIANT_DIMENSION)) {\n    throw new ImageVariantsConfigError(\n      `${key}.width must be an integer from 1 to ${MAX_VARIANT_DIMENSION}, got ${JSON.stringify(width)}.`,\n    );\n  }\n\n  const variant: ImageVariantDefinition = { width };\n\n  if (height !== undefined) {\n    if (!isPositiveInteger(height, MAX_VARIANT_DIMENSION)) {\n      throw new ImageVariantsConfigError(\n        `${key}.height must be an integer from 1 to ${MAX_VARIANT_DIMENSION}, got ${JSON.stringify(height)}.`,\n      );\n    }\n\n    variant.height = height;\n  }\n\n  if (fit !== undefined) {\n    if (!FITS.includes(fit as ImageVariantFit)) {\n      throw new ImageVariantsConfigError(\n        `${key}.fit must be one of ${FITS.join(\", \")}, got ${JSON.stringify(fit)}.`,\n      );\n    }\n\n    variant.fit = fit as ImageVariantFit;\n  }\n\n  if (quality !== undefined) {\n    if (!isPositiveInteger(quality, 100)) {\n      throw new ImageVariantsConfigError(\n        `${key}.quality must be an integer from 1 to 100, got ${JSON.stringify(quality)}.`,\n      );\n    }\n\n    variant.quality = quality;\n  }\n\n  if (enlarge !== undefined && typeof enlarge !== \"boolean\") {\n    throw new ImageVariantsConfigError(\n      `${key}.enlarge must be a boolean, got ${JSON.stringify(enlarge)}.`,\n    );\n  }\n\n  // Always set, never left undefined: the effective flag (default false) is\n  // part of the normalized variant, so toggling it changes the cache key.\n  variant.enlarge = enlarge === true;\n\n  return variant;\n}\n\nfunction resolveFormats(raw: unknown): readonly ImageVariantOutputFormat[] {\n  if (raw === undefined) return [];\n\n  if (!Array.isArray(raw)) {\n    throw new ImageVariantsConfigError(`uploads.images.formats must be an array.`);\n  }\n\n  for (const format of raw) {\n    if (!OUTPUT_FORMATS.includes(format)) {\n      throw new ImageVariantsConfigError(\n        `uploads.images.formats may only contain ${OUTPUT_FORMATS.join(\", \")}, got ${JSON.stringify(format)}.`,\n      );\n    }\n  }\n\n  return [...new Set(raw as ImageVariantOutputFormat[])];\n}\n\nfunction resolveLimit(name: string, raw: unknown, fallback: number): number {\n  if (raw === undefined) return fallback;\n\n  if (!isPositiveInteger(raw)) {\n    throw new ImageVariantsConfigError(\n      `uploads.images.${name} must be a positive integer, got ${JSON.stringify(raw)}.`,\n    );\n  }\n\n  return raw;\n}\n\n/**\n * Validate the `uploads.images` config and apply its defaults.\n *\n * Every variant is copied field by field, so an unknown key in the config can\n * never reach sharp, and the result is what the cache key is computed from.\n *\n * @param images - the raw `uploads.images` value\n * @param storageRoot - the local storage root, base of the default cache directory\n * @returns the resolved config, or `undefined` when variants are not configured\n * @throws ImageVariantsConfigError when any value is out of bounds\n */\nexport function resolveImageVariantsConfig(\n  images: UploadsImagesConfigurations | undefined,\n  storageRoot: string,\n): ResolvedImageVariantsConfig | undefined {\n  if (images === undefined || images === null) return undefined;\n\n  if (typeof images !== \"object\") {\n    throw new ImageVariantsConfigError(\"uploads.images must be an object.\");\n  }\n\n  const rawVariants = (images as { variants?: unknown }).variants;\n\n  if (!rawVariants || typeof rawVariants !== \"object\" || Object.keys(rawVariants).length === 0) {\n    throw new ImageVariantsConfigError(\n      \"uploads.images.variants must declare at least one variant.\",\n    );\n  }\n\n  const variants: Record<string, ImageVariantDefinition> = {};\n\n  for (const [name, raw] of Object.entries(rawVariants)) {\n    variants[name] = resolveVariant(name, raw);\n  }\n\n  const cacheDirectory = variantCacheDirectoryFor(storageRoot, images);\n\n  return {\n    variants,\n    formats: resolveFormats(images.formats),\n    maxSourceBytes: resolveLimit(\"maxSourceBytes\", images.maxSourceBytes, DEFAULT_MAX_SOURCE_BYTES),\n    maxSourcePixels: resolveLimit(\n      \"maxSourcePixels\",\n      images.maxSourcePixels,\n      DEFAULT_MAX_SOURCE_PIXELS,\n    ),\n    cacheDirectory,\n    maxCacheBytes: resolveLimit(\"maxCacheBytes\", images.maxCacheBytes, 512 * 1024 * 1024),\n    maxCacheAge: resolveLimit(\"maxCacheAge\", images.maxCacheAge, 7 * 24 * 60 * 60),\n  };\n}\n"],"mappings":"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"}

package/esm/http/uploads/resolve-original-content-type.mjs

@@ -8,7 +8,7 @@ import mime from "mime";
 * upload served under its real type is stored XSS the moment it is fetched
 * from the app's own origin.
 */
-const INLINE_EXECUTABLE_MIME_TYPES = new Set([
+const INLINE_EXECUTABLE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/svg+xml",
 	"text/html",
 	"application/xhtml+xml",

package/esm/http/uploads/resolve-original-content-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-original-content-type.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-original-content-type.ts"],"sourcesContent":["import mime from \"mime\";\n\n/**\n * Extension-derived MIME types that are never safe to advertise as-is: a\n * browser that trusts one of these will parse and execute the response body\n * (inline `<script>` in an svg, markup and script in html/xhtml/xml), so an\n * upload served under its real type is stored XSS the moment it is fetched\n * from the app's own origin.\n */\nconst INLINE_EXECUTABLE_MIME_TYPES = new Set([\n  \"image/svg+xml\",\n  \"text/html\",\n  \"application/xhtml+xml\",\n  \"text/xml\",\n  \"application/xml\",\n]);\n\n/**\n * Content type for an upload original that is being served as an\n * `attachment` (see `uploaded-file.controller.ts`): the extension-derived\n * type, except the svg/html/xml family, which is downgraded to\n * `application/octet-stream` so a browser never sniffs or renders it.\n */\nexport function resolveOriginalContentType(filePath: string): string {\n  const type = mime.getType(filePath) || \"application/octet-stream\";\n\n  return INLINE_EXECUTABLE_MIME_TYPES.has(type) ? \"application/octet-stream\" : type;\n}\n"],"mappings":";;;;;;;;;;AASA,MAAM,+BAA+B,IAAI,IAAI;CAC3C;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;AAQD,SAAgB,2BAA2B,UAA0B;CACnE,MAAM,OAAO,KAAK,QAAQ,QAAQ,KAAK;CAEvC,OAAO,6BAA6B,IAAI,IAAI,IAAI,6BAA6B;AAC/E"}
+{"version":3,"file":"resolve-original-content-type.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-original-content-type.ts"],"sourcesContent":["import mime from \"mime\";\n\n/**\n * Extension-derived MIME types that are never safe to advertise as-is: a\n * browser that trusts one of these will parse and execute the response body\n * (inline `<script>` in an svg, markup and script in html/xhtml/xml), so an\n * upload served under its real type is stored XSS the moment it is fetched\n * from the app's own origin.\n */\nconst INLINE_EXECUTABLE_MIME_TYPES = new Set([\n  \"image/svg+xml\",\n  \"text/html\",\n  \"application/xhtml+xml\",\n  \"text/xml\",\n  \"application/xml\",\n]);\n\n/**\n * Content type for an upload original that is being served as an\n * `attachment` (see `uploaded-file.controller.ts`): the extension-derived\n * type, except the svg/html/xml family, which is downgraded to\n * `application/octet-stream` so a browser never sniffs or renders it.\n */\nexport function resolveOriginalContentType(filePath: string): string {\n  const type = mime.getType(filePath) || \"application/octet-stream\";\n\n  return INLINE_EXECUTABLE_MIME_TYPES.has(type) ? \"application/octet-stream\" : type;\n}\n"],"mappings":";;;;;;;;;;AASA,MAAM,+CAA+B,IAAI,IAAI;CAC3C;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;AAQD,SAAgB,2BAA2B,UAA0B;CACnE,MAAM,OAAO,KAAK,QAAQ,QAAQ,KAAK;CAEvC,OAAO,6BAA6B,IAAI,IAAI,IAAI,6BAA6B;AAC/E"}

package/esm/http/uploads/resolve-remote-image-variant.mjs

@@ -0,0 +1,89 @@
+import { HttpError } from "../errors/errors.mjs";
+import { uploadsConfig } from "../uploads-config.mjs";
+import { variantCacheKey, variantCachePath, variantSourceDirectory, variantSourceKey } from "./variant-cache-key.mjs";
+import { retryOnVanishedDirectory, warnIfVariantCacheIsPublic } from "./image-variant-cache.mjs";
+import { isVariantSourceFormat } from "./detect-image-format.mjs";
+import { remoteVariantDisk, remoteVariantSource } from "./remote-variant-source.mjs";
+import { generateImageVariant } from "./generate-image-variant.mjs";
+import { resolveImageVariantsConfig } from "./resolve-image-variants-config.mjs";
+import { freshImageVariant, scheduleImageVariantCacheTrim } from "./trim-image-variant-cache.mjs";
+import { variantGenerations } from "./variant-generations.mjs";
+import path from "node:path";
+import { atomicWriteAsync } from "@warlock.js/fs";
+import fs from "node:fs/promises";
+
+//#region ../../packages/core/src/http/uploads/resolve-remote-image-variant.ts
+/** Cloud sources are read through their driver; derivatives remain in a local cache. */
+async function resolveRemoteImageVariant(input) {
+	const disk = remoteVariantDisk(input.disk);
+	const images = resolveImageVariantsConfig(uploadsConfig("images"), disk.cacheRoot);
+	if (!images) throw new HttpError(400, "Image variants are not configured.");
+	if (!Object.prototype.hasOwnProperty.call(images.variants, input.variant)) throw new HttpError(400, `Unknown variant "${input.variant}".`);
+	if (input.format !== void 0 && !images.formats.includes(input.format)) throw new HttpError(400, `Format "${input.format}" is not allowed.`);
+	const source = await remoteVariantSource(input.path, disk, images);
+	if (!source) return void 0;
+	try {
+		return await renderRemoteImageVariant(input, disk, images, source);
+	} finally {
+		source.release();
+	}
+}
+/** Ingest rendering reuses one source handle and its memoized bounded download. */
+async function renderRemoteImageVariant(input, disk, images, source) {
+	const variant = Object.prototype.hasOwnProperty.call(images.variants, input.variant) ? images.variants[input.variant] : void 0;
+	if (!variant) throw new HttpError(400, `Unknown variant "${input.variant}".`);
+	if (input.format !== void 0 && !images.formats.includes(input.format)) throw new HttpError(400, `Format "${input.format}" is not allowed.`);
+	const generation = source.metadataGeneration ?? (await source.load()).generation;
+	const sourceKey = variantSourceKey(disk.root, source.sourcePath);
+	const manifestPath = path.join(variantSourceDirectory(images.cacheDirectory, sourceKey), generation, "source.json");
+	let format = input.format;
+	if (!format) {
+		try {
+			const savedFormat = JSON.parse(await fs.readFile(manifestPath, "utf8"))?.format;
+			if (isVariantSourceFormat(savedFormat)) format = savedFormat;
+		} catch (error) {
+			if (error.code !== "ENOENT" && !(error instanceof SyntaxError)) throw error;
+		}
+		format ??= (await source.load()).sourceFormat;
+	}
+	const hash = variantCacheKey({
+		relativePath: JSON.stringify([
+			disk.root,
+			source.sourcePath,
+			generation
+		]),
+		sourceSize: 0,
+		sourceMtimeMs: 0,
+		variant,
+		format
+	});
+	const target = variantCachePath(images.cacheDirectory, {
+		sourceKey,
+		generation
+	}, hash, format);
+	warnIfVariantCacheIsPublic(images.cacheDirectory);
+	if (!await freshImageVariant(target, images.maxCacheAge)) await variantGenerations.run(target, async () => {
+		if (await freshImageVariant(target, images.maxCacheAge)) return;
+		const loaded = await source.load();
+		await retryOnVanishedDirectory(async () => {
+			await generateImageVariant({
+				image: loaded.image.clone(),
+				variant,
+				format,
+				targetPath: target
+			});
+			await atomicWriteAsync(manifestPath, JSON.stringify({ format: loaded.sourceFormat }));
+		});
+		scheduleImageVariantCacheTrim(images, target);
+	});
+	return {
+		absolutePath: target,
+		hash,
+		format,
+		contentType: `image/${format}`
+	};
+}
+
+//#endregion
+export { renderRemoteImageVariant, resolveRemoteImageVariant };
+//# sourceMappingURL=resolve-remote-image-variant.mjs.map

package/esm/http/uploads/resolve-remote-image-variant.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-remote-image-variant.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/resolve-remote-image-variant.ts"],"sourcesContent":["import { atomicWriteAsync } from \"@warlock.js/fs\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { HttpError } from \"../errors\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport { isVariantSourceFormat } from \"./detect-image-format\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport { retryOnVanishedDirectory, warnIfVariantCacheIsPublic } from \"./image-variant-cache\";\nimport type { ResolvedImageVariantsConfig, VariantOutputFormat } from \"./image-variant-types\";\nimport {\n  remoteVariantDisk,\n  remoteVariantSource,\n  type RemoteVariantSource,\n} from \"./remote-variant-source\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport type { ResolveImageVariantInput, ResolvedImageVariant } from \"./resolve-image-variant\";\nimport { freshImageVariant, scheduleImageVariantCacheTrim } from \"./trim-image-variant-cache\";\nimport {\n  variantCacheKey,\n  variantCachePath,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\nimport { variantGenerations } from \"./variant-generations\";\n\n/** Cloud sources are read through their driver; derivatives remain in a local cache. */\nexport async function resolveRemoteImageVariant(\n  input: ResolveImageVariantInput,\n): Promise<ResolvedImageVariant | undefined> {\n  const disk = remoteVariantDisk(input.disk);\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), disk.cacheRoot);\n  if (!images) throw new HttpError(400, \"Image variants are not configured.\");\n  if (!Object.prototype.hasOwnProperty.call(images.variants, input.variant))\n    throw new HttpError(400, `Unknown variant \"${input.variant}\".`);\n  if (input.format !== undefined && !images.formats.includes(input.format as never))\n    throw new HttpError(400, `Format \"${input.format}\" is not allowed.`);\n  const source = await remoteVariantSource(input.path, disk, images);\n  if (!source) return undefined;\n  try {\n    return await renderRemoteImageVariant(input, disk, images, source);\n  } finally {\n    source.release();\n  }\n}\n\n/** Ingest rendering reuses one source handle and its memoized bounded download. */\nexport async function renderRemoteImageVariant(\n  input: ResolveImageVariantInput,\n  disk: ReturnType<typeof remoteVariantDisk>,\n  images: ResolvedImageVariantsConfig,\n  source: RemoteVariantSource,\n): Promise<ResolvedImageVariant> {\n  const variant = Object.prototype.hasOwnProperty.call(images.variants, input.variant)\n    ? images.variants[input.variant]\n    : undefined;\n  if (!variant) throw new HttpError(400, `Unknown variant \"${input.variant}\".`);\n  if (input.format !== undefined && !images.formats.includes(input.format as never))\n    throw new HttpError(400, `Format \"${input.format}\" is not allowed.`);\n  const generation = source.metadataGeneration ?? (await source.load()).generation;\n  const sourceKey = variantSourceKey(disk.root, source.sourcePath);\n  const manifestPath = path.join(\n    variantSourceDirectory(images.cacheDirectory, sourceKey),\n    generation,\n    \"source.json\",\n  );\n  let format: VariantOutputFormat | undefined = input.format;\n  if (!format) {\n    try {\n      const saved: unknown = JSON.parse(await fs.readFile(manifestPath, \"utf8\"));\n      const savedFormat = (saved as { format?: unknown } | null)?.format;\n      if (isVariantSourceFormat(savedFormat as never)) format = savedFormat as VariantOutputFormat;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== \"ENOENT\" && !(error instanceof SyntaxError))\n        throw error;\n    }\n    format ??= (await source.load()).sourceFormat;\n  }\n  const hash = variantCacheKey({\n    relativePath: JSON.stringify([disk.root, source.sourcePath, generation]),\n    sourceSize: 0,\n    sourceMtimeMs: 0,\n    variant,\n    format,\n  });\n  const target = variantCachePath(images.cacheDirectory, { sourceKey, generation }, hash, format);\n  warnIfVariantCacheIsPublic(images.cacheDirectory);\n  if (!(await freshImageVariant(target, images.maxCacheAge))) {\n    await variantGenerations.run(target, async () => {\n      if (await freshImageVariant(target, images.maxCacheAge)) return;\n      const loaded = await source.load();\n      await retryOnVanishedDirectory(async () => {\n        await generateImageVariant({\n          image: loaded.image.clone(),\n          variant,\n          format,\n          targetPath: target,\n        });\n        await atomicWriteAsync(manifestPath, JSON.stringify({ format: loaded.sourceFormat }));\n      });\n      scheduleImageVariantCacheTrim(images, target);\n      // Retain other generations: an older concurrent download must not prune\n      // a newer object's derivatives. Background eviction reclaims them.\n    });\n  }\n  return { absolutePath: target, hash, format, contentType: `image/${format}` };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA0BA,eAAsB,0BACpB,OAC2C;CAC3C,MAAM,OAAO,kBAAkB,MAAM,IAAI;CACzC,MAAM,SAAS,2BAA2B,cAAc,QAAQ,GAAG,KAAK,SAAS;CACjF,IAAI,CAAC,QAAQ,MAAM,IAAI,UAAU,KAAK,oCAAoC;CAC1E,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,MAAM,OAAO,GACtE,MAAM,IAAI,UAAU,KAAK,oBAAoB,MAAM,QAAQ,GAAG;CAChE,IAAI,MAAM,WAAW,UAAa,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAe,GAC9E,MAAM,IAAI,UAAU,KAAK,WAAW,MAAM,OAAO,kBAAkB;CACrE,MAAM,SAAS,MAAM,oBAAoB,MAAM,MAAM,MAAM,MAAM;CACjE,IAAI,CAAC,QAAQ,OAAO;CACpB,IAAI;EACF,OAAO,MAAM,yBAAyB,OAAO,MAAM,QAAQ,MAAM;CACnE,UAAU;EACR,OAAO,QAAQ;CACjB;AACF;;AAGA,eAAsB,yBACpB,OACA,MACA,QACA,QAC+B;CAC/B,MAAM,UAAU,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,MAAM,OAAO,IAC/E,OAAO,SAAS,MAAM,WACtB;CACJ,IAAI,CAAC,SAAS,MAAM,IAAI,UAAU,KAAK,oBAAoB,MAAM,QAAQ,GAAG;CAC5E,IAAI,MAAM,WAAW,UAAa,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAe,GAC9E,MAAM,IAAI,UAAU,KAAK,WAAW,MAAM,OAAO,kBAAkB;CACrE,MAAM,aAAa,OAAO,uBAAuB,MAAM,OAAO,KAAK,EAAC,CAAE;CACtE,MAAM,YAAY,iBAAiB,KAAK,MAAM,OAAO,UAAU;CAC/D,MAAM,eAAe,KAAK,KACxB,uBAAuB,OAAO,gBAAgB,SAAS,GACvD,YACA,aACF;CACA,IAAI,SAA0C,MAAM;CACpD,IAAI,CAAC,QAAQ;EACX,IAAI;GAEF,MAAM,cADiB,KAAK,MAAM,MAAM,GAAG,SAAS,cAAc,MAAM,CAC/C,CAAC,EAAkC;GAC5D,IAAI,sBAAsB,WAAoB,GAAG,SAAS;EAC5D,SAAS,OAAO;GACd,IAAK,MAAgC,SAAS,YAAY,EAAE,iBAAiB,cAC3E,MAAM;EACV;EACA,YAAY,MAAM,OAAO,KAAK,EAAC,CAAE;CACnC;CACA,MAAM,OAAO,gBAAgB;EAC3B,cAAc,KAAK,UAAU;GAAC,KAAK;GAAM,OAAO;GAAY;EAAU,CAAC;EACvE,YAAY;EACZ,eAAe;EACf;EACA;CACF,CAAC;CACD,MAAM,SAAS,iBAAiB,OAAO,gBAAgB;EAAE;EAAW;CAAW,GAAG,MAAM,MAAM;CAC9F,2BAA2B,OAAO,cAAc;CAChD,IAAI,CAAE,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GACtD,MAAM,mBAAmB,IAAI,QAAQ,YAAY;EAC/C,IAAI,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GAAG;EACzD,MAAM,SAAS,MAAM,OAAO,KAAK;EACjC,MAAM,yBAAyB,YAAY;GACzC,MAAM,qBAAqB;IACzB,OAAO,OAAO,MAAM,MAAM;IAC1B;IACA;IACA,YAAY;GACd,CAAC;GACD,MAAM,iBAAiB,cAAc,KAAK,UAAU,EAAE,QAAQ,OAAO,aAAa,CAAC,CAAC;EACtF,CAAC;EACD,8BAA8B,QAAQ,MAAM;CAG9C,CAAC;CAEH,OAAO;EAAE,cAAc;EAAQ;EAAM;EAAQ,aAAa,SAAS;CAAS;AAC9E"}