@cedarjs/uploads 7.0.1-next.333 → 7.0.1-next.467

package/dist/variants.js

@@ -0,0 +1,498 @@
+import { randomUUID } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+import mime from "mime-types";
+import { UploadError } from "./errors.js";
+import { generateStorageKey } from "./keys.js";
+import { DB_MAX_FILE_SIZE } from "./profiles.js";
+import { toDataUri } from "./serialize.js";
+import { resolveTarget } from "./targets.js";
+const ONE_DAY = 24 * 60 * 60 * 1e3;
+const TEN_MINUTES = 10 * 60 * 1e3;
+const MIME_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+const VARIANT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function idOf(source) {
+  return typeof source === "string" ? source : source.id;
+}
+function isPrismaError(e, code) {
+  return typeof e === "object" && e !== null && "code" in e && e.code === code;
+}
+function defaultFilename(sourceFilename, name, mimeType) {
+  const base = sourceFilename.replace(/\.[^./\\]*$/, "") || "file";
+  const ext = mimeType ? mime.extension(mimeType.split(";")[0].trim()) : false;
+  return ext ? `${base}-${name}.${ext}` : `${base}-${name}`;
+}
+async function readBytes(db, targets, upload) {
+  const target = resolveTarget(targets, upload.target);
+  if (target.providerType === "db") {
+    const row = await db.upload.findUnique({ where: { id: upload.id } });
+    if (!row?.data) {
+      throw new UploadError(
+        "NOT_FOUND",
+        `Upload '${upload.id}' has no inline data.`
+      );
+    }
+    return Buffer.from(row.data);
+  }
+  if (!upload.storageKey) {
+    throw new UploadError(
+      "NOT_FOUND",
+      `Upload '${upload.id}' has no stored file.`
+    );
+  }
+  return Buffer.from(await target.read(upload.storageKey));
+}
+async function deleteVariantRow(db, targets, row) {
+  let current = row;
+  while (current) {
+    if (current.storageKey) {
+      await resolveTarget(targets, current.target).delete(current.storageKey);
+    }
+    const { count } = await db.upload.deleteMany({
+      where: {
+        id: current.id,
+        status: current.status,
+        tokenId: current.tokenId,
+        storageKey: current.storageKey
+      }
+    });
+    if (count === 1) {
+      return;
+    }
+    current = await db.upload.findUnique({
+      where: { id: current.id },
+      omit: { data: true }
+    });
+  }
+}
+async function deleteVariants(source, { db, targets }) {
+  const rows = await db.upload.findMany({
+    where: { sourceId: idOf(source) },
+    omit: { data: true }
+  });
+  for (const row of rows) {
+    await deleteVariantRow(db, targets, row);
+  }
+  return rows.length;
+}
+function defineUploadVariants(options) {
+  const {
+    db,
+    targets,
+    target: defaultTarget,
+    retryFailedAfter = ONE_DAY,
+    claimTimeout = TEN_MINUTES,
+    pollInterval = 250,
+    onError = (error, { sourceId, variant }) => console.error(
+      `[cedar uploads] could not make variant '${variant}' of ${sourceId}:`,
+      error
+    )
+  } = options;
+  const definitions = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(options.variants)) {
+    if (!VARIANT_NAME.test(name)) {
+      throw new UploadError(
+        "CONFIGURATION",
+        `Invalid variant name '${name}'. Use letters, digits, '.', '_' and '-', starting with a letter or digit.`
+      );
+    }
+    const definition = typeof value === "function" ? { generate: value } : value;
+    const target = definition.target ?? defaultTarget;
+    if (!Object.hasOwn(targets, target.name) || targets[target.name] !== target) {
+      throw new UploadError(
+        "CONFIGURATION",
+        `Variant '${name}' uses a storage target that isn't in \`targets\`.`
+      );
+    }
+    definitions.set(name, { generate: definition.generate, target });
+  }
+  const names = [...definitions.keys()];
+  const inFlight = /* @__PURE__ */ new Map();
+  const waitingFor = /* @__PURE__ */ new Map();
+  const keyOf = (sourceId, name) => `${sourceId}\0${name}`;
+  const isWaitingFor = (from, to) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [from];
+    for (let key = stack.pop(); key !== void 0; key = stack.pop()) {
+      if (key === to) {
+        return true;
+      }
+      if (!seen.has(key)) {
+        seen.add(key);
+        stack.push(...waitingFor.get(key) ?? []);
+      }
+    }
+    return false;
+  };
+  const obtainFor = async (waiter, sourceId, name, chain) => {
+    const key = keyOf(sourceId, name);
+    if (!chain.includes(name) && inFlight.has(key) && isWaitingFor(key, waiter)) {
+      throw new UploadError(
+        "CONFIGURATION",
+        `Variant '${name}' and the variant reading it depend on each other.`
+      );
+    }
+    const waits = waitingFor.get(waiter) ?? [];
+    waitingFor.set(waiter, [...waits, key]);
+    try {
+      return await obtain(sourceId, name, chain);
+    } finally {
+      const rest = waitingFor.get(waiter) ?? [];
+      rest.splice(rest.indexOf(key), 1);
+      if (rest.length === 0) {
+        waitingFor.delete(waiter);
+      }
+    }
+  };
+  const definitionOf = (name) => {
+    const definition = definitions.get(name);
+    if (!definition) {
+      throw new UploadError(
+        "CONFIGURATION",
+        `Unknown upload variant '${name}'. Configured variants: ${names.join(", ") || "(none)"}.`
+      );
+    }
+    return definition;
+  };
+  const loadSource = async (sourceId) => {
+    const source = await db.upload.findUnique({
+      where: { id: sourceId },
+      omit: { data: true }
+    });
+    if (source?.status !== "completed") {
+      throw new UploadError(
+        "NOT_FOUND",
+        `Upload '${sourceId}' does not exist or is not completed, so it cannot have variants.`
+      );
+    }
+    if (source.sourceId) {
+      throw new UploadError(
+        "NOT_SUPPORTED",
+        `Upload '${sourceId}' is itself a variant. Variants are made from original uploads only; use \`readVariant()\` in a generator to make one variant from another.`
+      );
+    }
+    return source;
+  };
+  const findRow = (sourceId, name) => db.upload.findFirst({
+    where: { sourceId, variant: name },
+    omit: { data: true }
+  });
+  const make = async (source, rowId, claim, name, chain) => {
+    const definition = definitionOf(name);
+    const target = definition.target;
+    const ours = { id: rowId, status: "pending", tokenId: claim };
+    const fail = async (error) => {
+      if (error !== void 0) {
+        onError(error, { sourceId: source.id, variant: name });
+      }
+      await db.upload.updateMany({ where: ours, data: { status: "failed" } });
+      return null;
+    };
+    let file;
+    try {
+      file = await definition.generate({
+        source,
+        variant: name,
+        readSource: () => readBytes(db, targets, source),
+        readVariant: async (other) => {
+          const made = await obtainFor(
+            keyOf(source.id, name),
+            source.id,
+            other,
+            [...chain, name]
+          );
+          return made ? readBytes(db, targets, made) : null;
+        }
+      });
+    } catch (e) {
+      return fail(e);
+    }
+    if (!file) {
+      return fail();
+    }
+    if (!MIME_TYPE.test(file.mimeType)) {
+      return fail(
+        new UploadError(
+          "MIME_TYPE_NOT_ALLOWED",
+          `Variant '${name}' returned '${file.mimeType}', which is not a valid MIME type.`
+        )
+      );
+    }
+    const isDbTarget = target.providerType === "db";
+    if (isDbTarget && file.data.byteLength > DB_MAX_FILE_SIZE) {
+      return fail(
+        new UploadError(
+          "FILE_TOO_LARGE",
+          `Variant '${name}' is ${file.data.byteLength} bytes, which exceeds the ${DB_MAX_FILE_SIZE} byte limit for target '${target.name}'.`
+        )
+      );
+    }
+    const storageKey = isDbTarget ? null : generateStorageKey(file.mimeType);
+    if (storageKey) {
+      try {
+        await target.write(storageKey, file.data, {
+          contentType: file.mimeType
+        });
+      } catch (e) {
+        await target.delete(storageKey).catch(() => void 0);
+        await db.upload.deleteMany({ where: ours });
+        throw e;
+      }
+    }
+    const { count } = await db.upload.updateMany({
+      where: ours,
+      data: {
+        status: "completed",
+        // A retry or a takeover writes to the variant's current target,
+        // which is not necessarily the one the row was created for
+        target: target.name,
+        storageKey,
+        size: BigInt(file.data.byteLength),
+        mimeType: file.mimeType,
+        filename: file.filename ?? defaultFilename(source.filename, name, file.mimeType),
+        // Copying gives Prisma the plain-ArrayBuffer-backed array its
+        // `Bytes` input requires
+        data: isDbTarget ? new Uint8Array(file.data) : null,
+        tokenId: null
+      }
+    }).catch(async (e) => {
+      if (storageKey) {
+        await target.delete(storageKey).catch(() => void 0);
+      }
+      await db.upload.deleteMany({ where: ours }).catch(() => void 0);
+      throw e;
+    });
+    if (count !== 1) {
+      if (storageKey) {
+        await target.delete(storageKey).catch(() => void 0);
+      }
+      const current = await findRow(source.id, name);
+      return current?.status === "completed" ? current : null;
+    }
+    return db.upload.findUnique({ where: { id: rowId }, omit: { data: true } });
+  };
+  const obtainUncached = async (sourceId, name, chain) => {
+    const definition = definitionOf(name);
+    const source = await loadSource(sourceId);
+    for (; ; ) {
+      const row = await findRow(sourceId, name);
+      const now = Date.now();
+      const claim = randomUUID();
+      if (!row) {
+        let created;
+        try {
+          created = await db.upload.create({
+            data: {
+              sourceId,
+              variant: name,
+              target: definition.target.name,
+              status: "pending",
+              filename: defaultFilename(source.filename, name),
+              mimeType: "application/octet-stream",
+              size: 0n,
+              tokenId: claim,
+              userId: source.userId,
+              organizationId: source.organizationId
+            }
+          });
+        } catch (e) {
+          if (isPrismaError(e, "P2002")) {
+            continue;
+          }
+          if (isPrismaError(e, "P2003")) {
+            throw new UploadError(
+              "NOT_FOUND",
+              `Upload '${sourceId}' was deleted while its variant '${name}' was being made.`,
+              e
+            );
+          }
+          throw e;
+        }
+        return make(source, created.id, claim, name, chain);
+      }
+      if (row.status === "completed") {
+        return row;
+      }
+      if (row.status === "failed") {
+        const cutoff2 = new Date(now - retryFailedAfter);
+        if (row.updatedAt >= cutoff2) {
+          return null;
+        }
+        const { count } = await db.upload.updateMany({
+          where: { id: row.id, status: "failed", updatedAt: { lt: cutoff2 } },
+          data: { status: "pending", tokenId: claim }
+        });
+        if (count === 1) {
+          return make(source, row.id, claim, name, chain);
+        }
+        continue;
+      }
+      const cutoff = new Date(now - claimTimeout);
+      if (row.updatedAt < cutoff) {
+        const { count } = await db.upload.updateMany({
+          where: {
+            id: row.id,
+            status: "pending",
+            tokenId: row.tokenId,
+            updatedAt: { lt: cutoff }
+          },
+          data: { tokenId: claim }
+        });
+        if (count === 1) {
+          return make(source, row.id, claim, name, chain);
+        }
+        continue;
+      }
+      await sleep(pollInterval);
+    }
+  };
+  const obtain = (sourceId, name, chain) => {
+    if (chain.includes(name)) {
+      return Promise.reject(
+        new UploadError(
+          "CONFIGURATION",
+          `Variant '${name}' depends on itself: ${[...chain, name].join(" -> ")}.`
+        )
+      );
+    }
+    const key = keyOf(sourceId, name);
+    const running = inFlight.get(key);
+    if (running) {
+      return running;
+    }
+    const attempt = obtainUncached(sourceId, name, chain);
+    const forget = () => {
+      if (inFlight.get(key) === attempt) {
+        inFlight.delete(key);
+      }
+    };
+    inFlight.set(key, attempt);
+    attempt.then(forget, forget);
+    return attempt;
+  };
+  const getVariant = (source, name) => obtain(idOf(source), name, []);
+  const findVariant = async (source, name) => {
+    definitionOf(name);
+    return db.upload.findFirst({
+      where: { sourceId: idOf(source), variant: name, status: "completed" },
+      omit: { data: true }
+    });
+  };
+  const findVariants = async (sourceIds, name) => {
+    definitionOf(name);
+    const rows = sourceIds.length ? await db.upload.findMany({
+      where: {
+        sourceId: { in: sourceIds },
+        variant: name,
+        status: "completed"
+      },
+      omit: { data: true }
+    }) : [];
+    const bySource = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (row.sourceId) {
+        bySource.set(row.sourceId, row);
+      }
+    }
+    return bySource;
+  };
+  const readVariant = async (source, name) => {
+    const upload = await getVariant(source, name);
+    if (!upload) {
+      return null;
+    }
+    return { upload, data: await readBytes(db, targets, upload) };
+  };
+  const getVariantUrl = async (source, name, urlOptions = {}) => {
+    const upload = await getVariant(source, name);
+    if (!upload) {
+      return null;
+    }
+    const target = resolveTarget(targets, upload.target);
+    if (target.providerType === "db") {
+      return toDataUri(upload.mimeType, await readBytes(db, targets, upload));
+    }
+    if (!upload.storageKey) {
+      return null;
+    }
+    return target.getSignedReadUrl(upload.storageKey, urlOptions);
+  };
+  const regenerateVariants = async (name, {
+    remake = true,
+    batchSize = 100
+  } = {}) => {
+    definitionOf(name);
+    const result = {
+      deleted: 0,
+      made: 0,
+      failed: 0,
+      errors: 0
+    };
+    const newest = await db.upload.findFirst({
+      where: { variant: name },
+      omit: { data: true },
+      orderBy: { createdAt: "desc" }
+    });
+    if (!newest) {
+      return result;
+    }
+    const cutoff = newest.createdAt;
+    const exclude = [];
+    for (; ; ) {
+      const rows = await db.upload.findMany({
+        where: {
+          variant: name,
+          createdAt: { lte: cutoff },
+          ...exclude.length > 0 && { id: { notIn: exclude } }
+        },
+        omit: { data: true },
+        orderBy: { createdAt: "asc" },
+        take: batchSize
+      });
+      if (rows.length === 0) {
+        return result;
+      }
+      for (const row of rows) {
+        const sourceId = row.sourceId ?? "";
+        try {
+          await deleteVariantRow(db, targets, row);
+          result.deleted += 1;
+        } catch (e) {
+          result.errors += 1;
+          exclude.push(row.id);
+          onError(e, { sourceId, variant: name });
+          continue;
+        }
+        if (remake) {
+          await inFlight.get(keyOf(sourceId, name))?.catch(() => null);
+          const made = await getVariant(sourceId, name).catch((e) => {
+            onError(e, { sourceId, variant: name });
+            return null;
+          });
+          if (made) {
+            result.made += 1;
+          } else {
+            result.failed += 1;
+          }
+          const current = await findRow(sourceId, name);
+          if (current && current.createdAt <= cutoff) {
+            exclude.push(current.id);
+          }
+        }
+      }
+    }
+  };
+  return {
+    names,
+    getVariant,
+    findVariant,
+    findVariants,
+    readVariant,
+    getVariantUrl,
+    regenerateVariants,
+    deleteVariants: (source) => deleteVariants(source, { db, targets })
+  };
+}
+export {
+  defineUploadVariants,
+  deleteVariants
+};

package/dist/verifyStoredContentType.d.ts

@@ -0,0 +1,19 @@
+import type { StorageProvider } from './types.js';
+/**
+ * Checks an object that was uploaded straight to storage against the type
+ * the client declared for it when it asked for the upload URL. The declared
+ * type was checked against the upload profile then, and is the
+ * `Content-Type` the object was stored with, so the bytes must be that type
+ * (or an alias of it). Reads the first `DETECT_CONTENT_TYPE_BYTES`, plus the
+ * last `DETECT_CONTENT_TYPE_TAIL_BYTES` when the head is a ZIP, plus the
+ * start of the ZIP's central directory when that begins before the tail
+ * (at most `MAX_ZIP_DIRECTORY_BYTES`).
+ *
+ * Returns the canonical type to record, or `null` when the bytes aren't the
+ * declared type.
+ */
+export declare function verifyStoredContentType(target: StorageProvider, key: string, { size, declaredType }: {
+    size: number;
+    declaredType: string;
+}): Promise<string | null>;
+//# sourceMappingURL=verifyStoredContentType.d.ts.map

package/dist/verifyStoredContentType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyStoredContentType.d.ts","sourceRoot":"","sources":["../src/verifyStoredContentType.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAmBjD;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,MAAM,EACX,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC7D,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsCxB"}

package/dist/verifyStoredContentType.js

@@ -0,0 +1,41 @@
+import {
+  acceptedContentType,
+  DETECT_CONTENT_TYPE_BYTES,
+  DETECT_CONTENT_TYPE_TAIL_BYTES,
+  findZipCentralDirectory
+} from "./detectContentType.js";
+const ZIP_LOCAL_HEADER = [80, 75, 3, 4];
+async function readRange(target, key, offset, length) {
+  if (target.readRange) {
+    return target.readRange(key, { offset, length });
+  }
+  return (await target.read(key)).subarray(offset, offset + length);
+}
+async function verifyStoredContentType(target, key, { size, declaredType }) {
+  const headLength = Math.min(size, DETECT_CONTENT_TYPE_BYTES);
+  const head = await readRange(target, key, 0, headLength);
+  let tail;
+  const isZip = ZIP_LOCAL_HEADER.every((byte, i) => head[i] === byte);
+  if (isZip && size > head.length) {
+    const tailLength = Math.min(size, DETECT_CONTENT_TYPE_TAIL_BYTES);
+    const tailStart = size - tailLength;
+    tail = await readRange(target, key, tailStart, tailLength);
+    const directory = findZipCentralDirectory(tail);
+    if (directory && directory.offset < tailStart && directory.offset + directory.size > tailStart) {
+      const missing = await readRange(
+        target,
+        key,
+        directory.offset,
+        tailStart - directory.offset
+      );
+      const joined = new Uint8Array(missing.length + tail.length);
+      joined.set(missing);
+      joined.set(tail, missing.length);
+      tail = joined;
+    }
+  }
+  return acceptedContentType(head, [declaredType], declaredType, { tail });
+}
+export {
+  verifyStoredContentType
+};

package/dist/webhooks/s3.d.ts

@@ -17,21 +17,30 @@ export interface S3Event {
     Records: S3EventRecord[];
 }
 export type S3EventOutcome = 'completed' | 'failed' | 'ignored' | 'not-found' | 'no-target';
+export interface ProcessS3EventRecordOptions {
+    db: UploadDatabase;
+    targets: StorageTargets;
+    /**
+     * Checks the object's bytes against the type declared when the upload URL
+     * was issued, as `confirmUpload` does. Defaults to `true`.
+     */
+    verifyContentType?: boolean;
+}
 /**
  * Settles the `pending` row for one `s3:ObjectCreated:*` record. The row is
  * matched on target plus storage key, the object's size is compared with
- * the size authorized at presign time, and the row is flipped `pending` to
- * `completed` (or claimed `failed` and the object deleted on a mismatch).
- * Both transitions are conditional, so a duplicate notification or a row
- * the cleanup job already claimed is left alone.
+ * the size authorized at presign time and, with `verifyContentType` (the
+ * default), its bytes with the type declared then, and the row is flipped
+ * `pending` to `completed` (or claimed `failed` and the object deleted on a
+ * mismatch). Both transitions are conditional, so a duplicate notification
+ * or a row the cleanup job already claimed is left alone.
  */
-export declare function processS3EventRecord(record: S3EventRecord, { db, targets }: {
-    db: UploadDatabase;
-    targets: StorageTargets;
-}): Promise<S3EventOutcome>;
+export declare function processS3EventRecord(record: S3EventRecord, { db, targets, verifyContentType }: ProcessS3EventRecordOptions): Promise<S3EventOutcome>;
 export interface S3WebhookOptions {
     db: UploadDatabase;
     targets: StorageTargets;
+    /** See `ProcessS3EventRecordOptions`. Defaults to `true`. */
+    verifyContentType?: boolean;
     /** The trusted SNS topic. Messages from any other topic are rejected. */
     topicArn: string;
     fetchCertificate?: FetchCertificate;

package/dist/webhooks/s3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"s3.d.ts","sourceRoot":"","sources":["../../src/webhooks/s3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAQjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE;QACF,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;QACxB,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACvC,CAAA;CACF;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAsBD,MAAM,MAAM,cAAc,GACxB,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,CAAA;AAkChE;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE;IAAE,EAAE,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,cAAc,CAAA;CAAE,GAC/D,OAAO,CAAC,cAAc,CAAC,CAoDzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,cAAc,CAAA;IAClB,OAAO,EAAE,cAAc,CAAA;IACvB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,cAAc,GAAG,0BAA0B,GAAG,yBAAyB,CAAA;IAC7E,QAAQ,EAAE,cAAc,EAAE,CAAA;CAC3B;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+D1B"}
+{"version":3,"file":"s3.d.ts","sourceRoot":"","sources":["../../src/webhooks/s3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AASjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE;QACF,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;QACxB,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACvC,CAAA;CACF;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAsBD,MAAM,MAAM,cAAc,GACxB,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,CAAA;AAkChE,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,cAAc,CAAA;IAClB,OAAO,EAAE,cAAc,CAAA;IACvB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,EAAE,EAAE,EAAE,OAAO,EAAE,iBAAwB,EAAE,EAAE,2BAA2B,GACrE,OAAO,CAAC,cAAc,CAAC,CA2EzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,cAAc,CAAA;IAClB,OAAO,EAAE,cAAc,CAAA;IACvB,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,cAAc,GAAG,0BAA0B,GAAG,yBAAyB,CAAA;IAC7E,QAAQ,EAAE,cAAc,EAAE,CAAA;CAC3B;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+D1B"}

package/dist/webhooks/s3.js

@@ -1,4 +1,5 @@
 import { UploadError } from "../errors.js";
+import { verifyStoredContentType } from "../verifyStoredContentType.js";
 import {
   assertTrustedSnsUrl,
   isSnsMessage,
@@ -28,7 +29,7 @@ function matchTarget(targets, bucket, key) {
   }
   return best ? { name: best.name, storageKey: key.slice(best.keyPrefix.length) } : null;
 }
-async function processS3EventRecord(record, { db, targets }) {
+async function processS3EventRecord(record, { db, targets, verifyContentType = true }) {
   if (!record.eventName.startsWith("ObjectCreated")) {
     return "ignored";
   }
@@ -51,7 +52,7 @@ async function processS3EventRecord(record, { db, targets }) {
   const target = targets[match.name];
   const reportedSize = record.s3.object.size;
   const actualSize = typeof reportedSize === "number" ? reportedSize : await target.getObjectSize(match.storageKey);
-  if (actualSize === null || BigInt(actualSize) !== upload.size) {
+  const fail = async () => {
     const { count: count2 } = await db.upload.updateMany({
       where: { id: upload.id, status: "pending" },
       data: { status: "failed" }
@@ -60,10 +61,28 @@ async function processS3EventRecord(record, { db, targets }) {
       await target.delete(match.storageKey);
     }
     return "failed";
+  };
+  if (actualSize === null || BigInt(actualSize) !== upload.size) {
+    return fail();
+  }
+  let mimeType = upload.mimeType;
+  if (verifyContentType) {
+    const verified = await verifyStoredContentType(target, match.storageKey, {
+      size: actualSize,
+      declaredType: upload.mimeType
+    });
+    if (!verified) {
+      return fail();
+    }
+    mimeType = verified;
   }
   const { count } = await db.upload.updateMany({
     where: { id: upload.id, status: "pending" },
-    data: { status: "completed", size: BigInt(actualSize) }
+    data: {
+      status: "completed",
+      size: BigInt(actualSize),
+      ...mimeType !== upload.mimeType ? { mimeType } : {}
+    }
   });
   return count === 1 ? "completed" : "ignored";
 }