graphile-presigned-url-plugin 1.12.0 → 1.13.0

package/confirm-upload.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The byte-validating half of the presigned lane's confirmation.
+ *
+ * A presigned upload's bytes never pass through the server: the client PUTs them
+ * straight to S3, so at the moment the files row is written the only statements
+ * about the file are the client's own. `requested` is exactly that state — a
+ * claim — and the row must not reach `uploaded` until the bytes behind it have
+ * been looked at, because every downstream processing step (image versions,
+ * extraction, embeddings) fires on `uploaded` and would otherwise be handed
+ * whatever the client chose to upload.
+ *
+ * So confirmation answers three questions in order, and each has a distinct
+ * outcome on the row:
+ *
+ *   1. did the bytes arrive?          no  → `expired`  (the client walked away)
+ *   2. are they the file they claim?   no  → `rejected` (and the object deleted)
+ *   3. otherwise                           → `uploaded`
+ *
+ * The bytes are read with a ranged GET of the leading bytes, not downloaded: a
+ * magic-byte signature is in the first few dozen bytes, so this costs the same
+ * for a 2GB video as for an icon.
+ *
+ * This module is the decision, not the transition. The worker that owns the
+ * `storage:confirm_upload` job applies it by calling the generated
+ * `<files>_confirm_uploaded` / `_reject_file` / `_expire_file` functions — the
+ * verdict is returned rather than executed so that the same rule can be applied
+ * by any transport, and tested without a database.
+ */
+import type { S3Config } from './types';
+/**
+ * How many leading bytes to read. Signatures are far shorter than this; the
+ * margin covers formats whose signature sits at an offset (e.g. the `ftyp` box
+ * of an MP4) and gives charset detection enough text to work with.
+ */
+export declare const CONFIRM_PREFIX_BYTES = 4096;
+export interface ConfirmUploadInput {
+    s3: S3Config;
+    /** The object key the presigned PUT was signed for. */
+    key: string;
+    /** The MIME type the client declared when the row was created. */
+    declaredMime: string;
+    /** The filename recorded on the files row, if any. */
+    filename?: string | null;
+}
+export type ConfirmUploadVerdict = {
+    outcome: 'uploaded';
+    detectedMime: string | null;
+} | {
+    outcome: 'rejected';
+    reason: string;
+    detectedMime: string | null;
+} | {
+    outcome: 'expired';
+    reason: string;
+};
+/**
+ * Decide what should happen to a `requested` files row, from its object's bytes.
+ *
+ * A missing object is `expired` rather than `rejected`: nothing was uploaded, so
+ * there is nothing to reject, and the row's own retry/expiry budget governs how
+ * long the client has left. An empty object, by contrast, *was* written and is
+ * not a file.
+ */
+export declare function confirmUploadedBytes(input: ConfirmUploadInput): Promise<ConfirmUploadVerdict>;

package/confirm-upload.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * The byte-validating half of the presigned lane's confirmation.
+ *
+ * A presigned upload's bytes never pass through the server: the client PUTs them
+ * straight to S3, so at the moment the files row is written the only statements
+ * about the file are the client's own. `requested` is exactly that state — a
+ * claim — and the row must not reach `uploaded` until the bytes behind it have
+ * been looked at, because every downstream processing step (image versions,
+ * extraction, embeddings) fires on `uploaded` and would otherwise be handed
+ * whatever the client chose to upload.
+ *
+ * So confirmation answers three questions in order, and each has a distinct
+ * outcome on the row:
+ *
+ *   1. did the bytes arrive?          no  → `expired`  (the client walked away)
+ *   2. are they the file they claim?   no  → `rejected` (and the object deleted)
+ *   3. otherwise                           → `uploaded`
+ *
+ * The bytes are read with a ranged GET of the leading bytes, not downloaded: a
+ * magic-byte signature is in the first few dozen bytes, so this costs the same
+ * for a 2GB video as for an icon.
+ *
+ * This module is the decision, not the transition. The worker that owns the
+ * `storage:confirm_upload` job applies it by calling the generated
+ * `<files>_confirm_uploaded` / `_reject_file` / `_expire_file` functions — the
+ * verdict is returned rather than executed so that the same rule can be applied
+ * by any transport, and tested without a database.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIRM_PREFIX_BYTES = void 0;
+exports.confirmUploadedBytes = confirmUploadedBytes;
+const mime_bytes_1 = require("mime-bytes");
+const mime_bytes_2 = require("mime-bytes");
+const s3_signer_1 = require("./s3-signer");
+/**
+ * How many leading bytes to read. Signatures are far shorter than this; the
+ * margin covers formats whose signature sits at an offset (e.g. the `ftyp` box
+ * of an MP4) and gives charset detection enough text to work with.
+ */
+exports.CONFIRM_PREFIX_BYTES = 4096;
+/**
+ * Decide what should happen to a `requested` files row, from its object's bytes.
+ *
+ * A missing object is `expired` rather than `rejected`: nothing was uploaded, so
+ * there is nothing to reject, and the row's own retry/expiry budget governs how
+ * long the client has left. An empty object, by contrast, *was* written and is
+ * not a file.
+ */
+async function confirmUploadedBytes(input) {
+    const { s3, key, declaredMime, filename } = input;
+    const prefix = await (0, s3_signer_1.readObjectPrefix)(s3, key, exports.CONFIRM_PREFIX_BYTES);
+    if (prefix === null) {
+        return { outcome: 'expired', reason: `no object at key ${key}: the upload never arrived` };
+    }
+    if (prefix.length === 0) {
+        return {
+            outcome: 'rejected',
+            reason: `object at key ${key} is empty; an upload must carry at least one byte`,
+            detectedMime: null,
+        };
+    }
+    const detected = await (0, mime_bytes_1.detectFromBuffer)(prefix);
+    const detectedMime = detected?.mimeType ?? null;
+    const agreement = (0, mime_bytes_2.checkTypeAgreement)({ filename, declaredMime, detectedMime });
+    if (!agreement.ok) {
+        return { outcome: 'rejected', reason: agreement.violation.message, detectedMime };
+    }
+    return { outcome: 'uploaded', detectedMime };
+}

package/esm/confirm-upload.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The byte-validating half of the presigned lane's confirmation.
+ *
+ * A presigned upload's bytes never pass through the server: the client PUTs them
+ * straight to S3, so at the moment the files row is written the only statements
+ * about the file are the client's own. `requested` is exactly that state — a
+ * claim — and the row must not reach `uploaded` until the bytes behind it have
+ * been looked at, because every downstream processing step (image versions,
+ * extraction, embeddings) fires on `uploaded` and would otherwise be handed
+ * whatever the client chose to upload.
+ *
+ * So confirmation answers three questions in order, and each has a distinct
+ * outcome on the row:
+ *
+ *   1. did the bytes arrive?          no  → `expired`  (the client walked away)
+ *   2. are they the file they claim?   no  → `rejected` (and the object deleted)
+ *   3. otherwise                           → `uploaded`
+ *
+ * The bytes are read with a ranged GET of the leading bytes, not downloaded: a
+ * magic-byte signature is in the first few dozen bytes, so this costs the same
+ * for a 2GB video as for an icon.
+ *
+ * This module is the decision, not the transition. The worker that owns the
+ * `storage:confirm_upload` job applies it by calling the generated
+ * `<files>_confirm_uploaded` / `_reject_file` / `_expire_file` functions — the
+ * verdict is returned rather than executed so that the same rule can be applied
+ * by any transport, and tested without a database.
+ */
+import type { S3Config } from './types';
+/**
+ * How many leading bytes to read. Signatures are far shorter than this; the
+ * margin covers formats whose signature sits at an offset (e.g. the `ftyp` box
+ * of an MP4) and gives charset detection enough text to work with.
+ */
+export declare const CONFIRM_PREFIX_BYTES = 4096;
+export interface ConfirmUploadInput {
+    s3: S3Config;
+    /** The object key the presigned PUT was signed for. */
+    key: string;
+    /** The MIME type the client declared when the row was created. */
+    declaredMime: string;
+    /** The filename recorded on the files row, if any. */
+    filename?: string | null;
+}
+export type ConfirmUploadVerdict = {
+    outcome: 'uploaded';
+    detectedMime: string | null;
+} | {
+    outcome: 'rejected';
+    reason: string;
+    detectedMime: string | null;
+} | {
+    outcome: 'expired';
+    reason: string;
+};
+/**
+ * Decide what should happen to a `requested` files row, from its object's bytes.
+ *
+ * A missing object is `expired` rather than `rejected`: nothing was uploaded, so
+ * there is nothing to reject, and the row's own retry/expiry budget governs how
+ * long the client has left. An empty object, by contrast, *was* written and is
+ * not a file.
+ */
+export declare function confirmUploadedBytes(input: ConfirmUploadInput): Promise<ConfirmUploadVerdict>;

package/esm/confirm-upload.js

@@ -0,0 +1,66 @@
+/**
+ * The byte-validating half of the presigned lane's confirmation.
+ *
+ * A presigned upload's bytes never pass through the server: the client PUTs them
+ * straight to S3, so at the moment the files row is written the only statements
+ * about the file are the client's own. `requested` is exactly that state — a
+ * claim — and the row must not reach `uploaded` until the bytes behind it have
+ * been looked at, because every downstream processing step (image versions,
+ * extraction, embeddings) fires on `uploaded` and would otherwise be handed
+ * whatever the client chose to upload.
+ *
+ * So confirmation answers three questions in order, and each has a distinct
+ * outcome on the row:
+ *
+ *   1. did the bytes arrive?          no  → `expired`  (the client walked away)
+ *   2. are they the file they claim?   no  → `rejected` (and the object deleted)
+ *   3. otherwise                           → `uploaded`
+ *
+ * The bytes are read with a ranged GET of the leading bytes, not downloaded: a
+ * magic-byte signature is in the first few dozen bytes, so this costs the same
+ * for a 2GB video as for an icon.
+ *
+ * This module is the decision, not the transition. The worker that owns the
+ * `storage:confirm_upload` job applies it by calling the generated
+ * `<files>_confirm_uploaded` / `_reject_file` / `_expire_file` functions — the
+ * verdict is returned rather than executed so that the same rule can be applied
+ * by any transport, and tested without a database.
+ */
+import { detectFromBuffer } from 'mime-bytes';
+import { checkTypeAgreement } from 'mime-bytes';
+import { readObjectPrefix } from './s3-signer';
+/**
+ * How many leading bytes to read. Signatures are far shorter than this; the
+ * margin covers formats whose signature sits at an offset (e.g. the `ftyp` box
+ * of an MP4) and gives charset detection enough text to work with.
+ */
+export const CONFIRM_PREFIX_BYTES = 4096;
+/**
+ * Decide what should happen to a `requested` files row, from its object's bytes.
+ *
+ * A missing object is `expired` rather than `rejected`: nothing was uploaded, so
+ * there is nothing to reject, and the row's own retry/expiry budget governs how
+ * long the client has left. An empty object, by contrast, *was* written and is
+ * not a file.
+ */
+export async function confirmUploadedBytes(input) {
+    const { s3, key, declaredMime, filename } = input;
+    const prefix = await readObjectPrefix(s3, key, CONFIRM_PREFIX_BYTES);
+    if (prefix === null) {
+        return { outcome: 'expired', reason: `no object at key ${key}: the upload never arrived` };
+    }
+    if (prefix.length === 0) {
+        return {
+            outcome: 'rejected',
+            reason: `object at key ${key} is empty; an upload must carry at least one byte`,
+            detectedMime: null,
+        };
+    }
+    const detected = await detectFromBuffer(prefix);
+    const detectedMime = detected?.mimeType ?? null;
+    const agreement = checkTypeAgreement({ filename, declaredMime, detectedMime });
+    if (!agreement.ok) {
+        return { outcome: 'rejected', reason: agreement.violation.message, detectedMime };
+    }
+    return { outcome: 'uploaded', detectedMime };
+}

package/esm/index.d.ts

@@ -26,6 +26,7 @@
  * };
  * ```
  */
+export { CONFIRM_PREFIX_BYTES, confirmUploadedBytes, type ConfirmUploadInput, type ConfirmUploadVerdict, } from './confirm-upload';
 export type { ResolvedBucketCoordinate } from './default-bucket';
 export { resolveDefaultBucket } from './default-bucket';
 export { createDownloadUrlPlugin } from './download-url-field';
@@ -36,6 +37,6 @@ export { mintPhysicalBucketName, provisionAndRecordPhysicalBucket, resolveS3, re
 export { createPresignedUrlPlugin, PresignedUrlPlugin } from './plugin';
 export { PresignedUrlPreset } from './preset';
 export { type WithPgClient, withRequestPgClient } from './request-pg-client';
-export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject } from './s3-signer';
+export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject, readObjectPrefix } from './s3-signer';
 export { clearBucketCache, clearStorageModuleCache, getBucketConfig, getStorageModuleConfig, getStorageModuleConfigForOwner, isS3BucketProvisioned, loadAllStorageModules, markS3BucketProvisioned, resolveStorageConfigFromCodec, resolveStorageModuleByFileId } from './storage-module-cache';
 export type { BucketConfig, BucketNameResolver, EnsureBucketProvisioned, PresignedUrlPluginOptions, RequestUploadUrlInput, RequestUploadUrlPayload, S3Config, S3ConfigOrGetter, StorageModuleConfig, } from './types';

package/esm/index.js

@@ -26,6 +26,7 @@
  * };
  * ```
  */
+export { CONFIRM_PREFIX_BYTES, confirmUploadedBytes, } from './confirm-upload';
 export { resolveDefaultBucket } from './default-bucket';
 export { createDownloadUrlPlugin } from './download-url-field';
 export { clearFileRefFieldCache, FileRefFieldNotRegisteredError, getFileRefFieldBinding } from './file-ref-registry';
@@ -34,5 +35,5 @@ export { mintPhysicalBucketName, provisionAndRecordPhysicalBucket, resolveS3, re
 export { createPresignedUrlPlugin, PresignedUrlPlugin } from './plugin';
 export { PresignedUrlPreset } from './preset';
 export { withRequestPgClient } from './request-pg-client';
-export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject } from './s3-signer';
+export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject, readObjectPrefix } from './s3-signer';
 export { clearBucketCache, clearStorageModuleCache, getBucketConfig, getStorageModuleConfig, getStorageModuleConfigForOwner, isS3BucketProvisioned, loadAllStorageModules, markS3BucketProvisioned, resolveStorageConfigFromCodec, resolveStorageModuleByFileId } from './storage-module-cache';

package/esm/plugin.js

@@ -19,6 +19,7 @@
 import 'graphile-build';
 import { Logger } from '@pgpmjs/logger';
 import { access, context as grafastContext, lambda, object } from 'grafast';
+import { checkTypeAgreement } from 'mime-bytes';
 import { resolveDefaultBucket } from './default-bucket';
 import { buildFileProjection } from './managed-upload';
 import { provisionAndRecordPhysicalBucket, resolveS3ForDatabase } from './physical-bucket';
@@ -505,6 +506,16 @@ async function processSingleFile(options, txClient, storageConfig, databaseId, b
             throw new Error('INVALID_FILENAME');
         }
     }
+    // The bytes are not here to be examined — the client PUTs them straight to S3 —
+    // so this checks the two claims that *are* here against each other. It is the
+    // cheap half of the rule: an upload declaring `image/jpeg` under the name
+    // `payload.html` is refused before a row exists, without reading a byte. The
+    // bytes themselves are checked on confirmation, before the row leaves
+    // `requested`.
+    const agreement = checkTypeAgreement({ filename, declaredMime: contentType });
+    if (!agreement.ok) {
+        throw new Error(`UPLOAD_TYPE_MISMATCH: ${agreement.violation.message}`);
+    }
     // Validate content type against bucket's allowed_mime_types
     if (bucket.allowed_mime_types && bucket.allowed_mime_types.length > 0) {
         const allowed = bucket.allowed_mime_types;

package/esm/s3-signer.d.ts

@@ -49,6 +49,22 @@ export declare function deleteS3Object(s3Config: S3Config, key: string): Promise
  * @param contentType - MIME type to record on the destination object
  */
 export declare function copyS3Object(s3Config: S3Config, sourceKey: string, destinationKey: string, contentType: string): Promise<void>;
+/**
+ * Read the leading bytes of an object.
+ *
+ * A ranged GET, because the only reason to touch bytes the client uploaded
+ * directly is to see what they actually are: a magic-byte signature lives in the
+ * first few dozen bytes, so validating a 2GB video costs the same as validating
+ * an icon.
+ *
+ * Returns null when the object is not there — the presigned lane's ordinary
+ * "client never PUT it" case, which is an expiry rather than a failure.
+ *
+ * @param s3Config - S3 client and bucket configuration
+ * @param key - S3 object key
+ * @param byteCount - How many leading bytes to read
+ */
+export declare function readObjectPrefix(s3Config: S3Config, key: string, byteCount: number): Promise<Buffer | null>;
 /**
  * Check if an object exists in S3 and optionally verify its content-type.
  *

package/esm/s3-signer.js

@@ -90,6 +90,44 @@ export async function copyS3Object(s3Config, sourceKey, destinationKey, contentT
     }));
     log.debug(`Copied S3 object: bucket=${s3Config.bucket}, ${sourceKey} → ${destinationKey}`);
 }
+/**
+ * Read the leading bytes of an object.
+ *
+ * A ranged GET, because the only reason to touch bytes the client uploaded
+ * directly is to see what they actually are: a magic-byte signature lives in the
+ * first few dozen bytes, so validating a 2GB video costs the same as validating
+ * an icon.
+ *
+ * Returns null when the object is not there — the presigned lane's ordinary
+ * "client never PUT it" case, which is an expiry rather than a failure.
+ *
+ * @param s3Config - S3 client and bucket configuration
+ * @param key - S3 object key
+ * @param byteCount - How many leading bytes to read
+ */
+export async function readObjectPrefix(s3Config, key, byteCount) {
+    try {
+        const response = await s3Config.client.send(new GetObjectCommand({
+            Bucket: s3Config.bucket,
+            Key: key,
+            Range: `bytes=0-${byteCount - 1}`,
+        }));
+        const body = response.Body;
+        if (!body)
+            return Buffer.alloc(0);
+        const chunks = [];
+        for await (const chunk of body) {
+            chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+    catch (e) {
+        if (e.name === 'NoSuchKey' || e.name === 'NotFound' || e.$metadata?.httpStatusCode === 404) {
+            return null;
+        }
+        throw e;
+    }
+}
 /**
  * Check if an object exists in S3 and optionally verify its content-type.
  *

package/index.d.ts

@@ -26,6 +26,7 @@
  * };
  * ```
  */
+export { CONFIRM_PREFIX_BYTES, confirmUploadedBytes, type ConfirmUploadInput, type ConfirmUploadVerdict, } from './confirm-upload';
 export type { ResolvedBucketCoordinate } from './default-bucket';
 export { resolveDefaultBucket } from './default-bucket';
 export { createDownloadUrlPlugin } from './download-url-field';
@@ -36,6 +37,6 @@ export { mintPhysicalBucketName, provisionAndRecordPhysicalBucket, resolveS3, re
 export { createPresignedUrlPlugin, PresignedUrlPlugin } from './plugin';
 export { PresignedUrlPreset } from './preset';
 export { type WithPgClient, withRequestPgClient } from './request-pg-client';
-export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject } from './s3-signer';
+export { copyS3Object, deleteS3Object, generatePresignedGetUrl, generatePresignedPutUrl, headObject, readObjectPrefix } from './s3-signer';
 export { clearBucketCache, clearStorageModuleCache, getBucketConfig, getStorageModuleConfig, getStorageModuleConfigForOwner, isS3BucketProvisioned, loadAllStorageModules, markS3BucketProvisioned, resolveStorageConfigFromCodec, resolveStorageModuleByFileId } from './storage-module-cache';
 export type { BucketConfig, BucketNameResolver, EnsureBucketProvisioned, PresignedUrlPluginOptions, RequestUploadUrlInput, RequestUploadUrlPayload, S3Config, S3ConfigOrGetter, StorageModuleConfig, } from './types';

package/index.js

@@ -28,7 +28,10 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveStorageModuleByFileId = exports.resolveStorageConfigFromCodec = exports.markS3BucketProvisioned = exports.loadAllStorageModules = exports.isS3BucketProvisioned = exports.getStorageModuleConfigForOwner = exports.getStorageModuleConfig = exports.getBucketConfig = exports.clearStorageModuleCache = exports.clearBucketCache = exports.headObject = exports.generatePresignedPutUrl = exports.generatePresignedGetUrl = exports.deleteS3Object = exports.copyS3Object = exports.withRequestPgClient = exports.PresignedUrlPreset = exports.PresignedUrlPlugin = exports.createPresignedUrlPlugin = exports.resolveS3ForDatabase = exports.resolveS3 = exports.provisionAndRecordPhysicalBucket = exports.mintPhysicalBucketName = exports.resolveManagedUploadTarget = exports.finalizeStagedUpload = exports.buildFileProjection = exports.assertUploadAllowedByBucket = exports.getFileRefFieldBinding = exports.FileRefFieldNotRegisteredError = exports.clearFileRefFieldCache = exports.createDownloadUrlPlugin = exports.resolveDefaultBucket = void 0;
+exports.resolveStorageModuleByFileId = exports.resolveStorageConfigFromCodec = exports.markS3BucketProvisioned = exports.loadAllStorageModules = exports.isS3BucketProvisioned = exports.getStorageModuleConfigForOwner = exports.getStorageModuleConfig = exports.getBucketConfig = exports.clearStorageModuleCache = exports.clearBucketCache = exports.readObjectPrefix = exports.headObject = exports.generatePresignedPutUrl = exports.generatePresignedGetUrl = exports.deleteS3Object = exports.copyS3Object = exports.withRequestPgClient = exports.PresignedUrlPreset = exports.PresignedUrlPlugin = exports.createPresignedUrlPlugin = exports.resolveS3ForDatabase = exports.resolveS3 = exports.provisionAndRecordPhysicalBucket = exports.mintPhysicalBucketName = exports.resolveManagedUploadTarget = exports.finalizeStagedUpload = exports.buildFileProjection = exports.assertUploadAllowedByBucket = exports.getFileRefFieldBinding = exports.FileRefFieldNotRegisteredError = exports.clearFileRefFieldCache = exports.createDownloadUrlPlugin = exports.resolveDefaultBucket = exports.confirmUploadedBytes = exports.CONFIRM_PREFIX_BYTES = void 0;
+var confirm_upload_1 = require("./confirm-upload");
+Object.defineProperty(exports, "CONFIRM_PREFIX_BYTES", { enumerable: true, get: function () { return confirm_upload_1.CONFIRM_PREFIX_BYTES; } });
+Object.defineProperty(exports, "confirmUploadedBytes", { enumerable: true, get: function () { return confirm_upload_1.confirmUploadedBytes; } });
 var default_bucket_1 = require("./default-bucket");
 Object.defineProperty(exports, "resolveDefaultBucket", { enumerable: true, get: function () { return default_bucket_1.resolveDefaultBucket; } });
 var download_url_field_1 = require("./download-url-field");
@@ -60,6 +63,7 @@ Object.defineProperty(exports, "deleteS3Object", { enumerable: true, get: functi
 Object.defineProperty(exports, "generatePresignedGetUrl", { enumerable: true, get: function () { return s3_signer_1.generatePresignedGetUrl; } });
 Object.defineProperty(exports, "generatePresignedPutUrl", { enumerable: true, get: function () { return s3_signer_1.generatePresignedPutUrl; } });
 Object.defineProperty(exports, "headObject", { enumerable: true, get: function () { return s3_signer_1.headObject; } });
+Object.defineProperty(exports, "readObjectPrefix", { enumerable: true, get: function () { return s3_signer_1.readObjectPrefix; } });
 var storage_module_cache_1 = require("./storage-module-cache");
 Object.defineProperty(exports, "clearBucketCache", { enumerable: true, get: function () { return storage_module_cache_1.clearBucketCache; } });
 Object.defineProperty(exports, "clearStorageModuleCache", { enumerable: true, get: function () { return storage_module_cache_1.clearStorageModuleCache; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-presigned-url-plugin",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Presigned URL upload plugin for PostGraphile v5 — requestUploadUrl mutation and downloadUrl computed field",
   "author": "Constructive <developers@constructive.io>",
   "homepage": "https://github.com/constructive-io/constructive",
@@ -44,7 +44,8 @@
     "@aws-sdk/s3-request-presigner": "^3.1052.0",
     "@pgpmjs/logger": "^2.24.1",
     "@pgsql/quotes": "^18.2.4",
-    "lru-cache": "^11.2.7"
+    "lru-cache": "^11.2.7",
+    "mime-bytes": "^0.31.0"
   },
   "peerDependencies": {
     "grafast": "^1.1.1",
@@ -60,5 +61,5 @@
     "@types/node": "^22.19.11",
     "makage": "^0.3.0"
   },
-  "gitHead": "44f56ee80a348f649a22e5bd32b35f2822726509"
+  "gitHead": "d0d796b7eb0d16c8c19405a49c0ca62ce3df117b"
 }

package/plugin.js

@@ -23,6 +23,7 @@ exports.createPresignedUrlPlugin = createPresignedUrlPlugin;
 require("graphile-build");
 const logger_1 = require("@pgpmjs/logger");
 const grafast_1 = require("grafast");
+const mime_bytes_1 = require("mime-bytes");
 const default_bucket_1 = require("./default-bucket");
 const managed_upload_1 = require("./managed-upload");
 const physical_bucket_1 = require("./physical-bucket");
@@ -509,6 +510,16 @@ async function processSingleFile(options, txClient, storageConfig, databaseId, b
             throw new Error('INVALID_FILENAME');
         }
     }
+    // The bytes are not here to be examined — the client PUTs them straight to S3 —
+    // so this checks the two claims that *are* here against each other. It is the
+    // cheap half of the rule: an upload declaring `image/jpeg` under the name
+    // `payload.html` is refused before a row exists, without reading a byte. The
+    // bytes themselves are checked on confirmation, before the row leaves
+    // `requested`.
+    const agreement = (0, mime_bytes_1.checkTypeAgreement)({ filename, declaredMime: contentType });
+    if (!agreement.ok) {
+        throw new Error(`UPLOAD_TYPE_MISMATCH: ${agreement.violation.message}`);
+    }
     // Validate content type against bucket's allowed_mime_types
     if (bucket.allowed_mime_types && bucket.allowed_mime_types.length > 0) {
         const allowed = bucket.allowed_mime_types;

package/s3-signer.d.ts

@@ -49,6 +49,22 @@ export declare function deleteS3Object(s3Config: S3Config, key: string): Promise
  * @param contentType - MIME type to record on the destination object
  */
 export declare function copyS3Object(s3Config: S3Config, sourceKey: string, destinationKey: string, contentType: string): Promise<void>;
+/**
+ * Read the leading bytes of an object.
+ *
+ * A ranged GET, because the only reason to touch bytes the client uploaded
+ * directly is to see what they actually are: a magic-byte signature lives in the
+ * first few dozen bytes, so validating a 2GB video costs the same as validating
+ * an icon.
+ *
+ * Returns null when the object is not there — the presigned lane's ordinary
+ * "client never PUT it" case, which is an expiry rather than a failure.
+ *
+ * @param s3Config - S3 client and bucket configuration
+ * @param key - S3 object key
+ * @param byteCount - How many leading bytes to read
+ */
+export declare function readObjectPrefix(s3Config: S3Config, key: string, byteCount: number): Promise<Buffer | null>;
 /**
  * Check if an object exists in S3 and optionally verify its content-type.
  *

package/s3-signer.js

@@ -4,6 +4,7 @@ exports.generatePresignedPutUrl = generatePresignedPutUrl;
 exports.generatePresignedGetUrl = generatePresignedGetUrl;
 exports.deleteS3Object = deleteS3Object;
 exports.copyS3Object = copyS3Object;
+exports.readObjectPrefix = readObjectPrefix;
 exports.headObject = headObject;
 const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
@@ -97,6 +98,44 @@ async function copyS3Object(s3Config, sourceKey, destinationKey, contentType) {
     }));
     log.debug(`Copied S3 object: bucket=${s3Config.bucket}, ${sourceKey} → ${destinationKey}`);
 }
+/**
+ * Read the leading bytes of an object.
+ *
+ * A ranged GET, because the only reason to touch bytes the client uploaded
+ * directly is to see what they actually are: a magic-byte signature lives in the
+ * first few dozen bytes, so validating a 2GB video costs the same as validating
+ * an icon.
+ *
+ * Returns null when the object is not there — the presigned lane's ordinary
+ * "client never PUT it" case, which is an expiry rather than a failure.
+ *
+ * @param s3Config - S3 client and bucket configuration
+ * @param key - S3 object key
+ * @param byteCount - How many leading bytes to read
+ */
+async function readObjectPrefix(s3Config, key, byteCount) {
+    try {
+        const response = await s3Config.client.send(new client_s3_1.GetObjectCommand({
+            Bucket: s3Config.bucket,
+            Key: key,
+            Range: `bytes=0-${byteCount - 1}`,
+        }));
+        const body = response.Body;
+        if (!body)
+            return Buffer.alloc(0);
+        const chunks = [];
+        for await (const chunk of body) {
+            chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+    catch (e) {
+        if (e.name === 'NoSuchKey' || e.name === 'NotFound' || e.$metadata?.httpStatusCode === 404) {
+            return null;
+        }
+        throw e;
+    }
+}
 /**
  * Check if an object exists in S3 and optionally verify its content-type.
  *