@palbase/backend 8.1.0 → 8.2.0

package/dist/index.d.cts

@@ -714,20 +714,18 @@ type ParameterDecorator$1 = (target: object, propertyKey: string | symbol, param
  * — the client cannot exceed what it declared.
  */
 interface UploadConfig {
-    /** Target bucket NAME. MUST exist in `config/storage.ts` `defineStorage(...)`. */
-    bucket: string;
-    /**
-     * Max object size in BYTES. Enforced twice: the authorize pre-flight rejects a
-     * larger declared size, and the signed URL pins it so storage rejects a larger
-     * PUT. When omitted, the bucket's own `fileSizeLimit` applies.
-     */
-    maxSize?: number;
     /**
-     * MIME allowlist for the object. The authorize pre-flight rejects a
-     * non-matching declared content-type, and the signed URL pins the exact type.
-     * When omitted, the bucket's own `allowedMimeTypes` applies (or any type).
+     * Target bucket NAME. MUST exist in `config/storage.ts` `defineStorage(...)`.
+     *
+     * The bucket is the SINGLE SOURCE OF TRUTH for the size limit + MIME allowlist:
+     * `bucket({ fileSizeLimit, allowedMimeTypes })`. Storage enforces those at the
+     * actual PUT (the only guard a client cannot skip), so `@Upload` deliberately
+     * does NOT take its own `maxSize`/`allowedTypes` — duplicating them here would
+     * let a route declare a tighter limit than its bucket that storage would not
+     * enforce (a real bypass: declare 10 bytes at authorize, then PUT up to the
+     * bucket ceiling straight at the signed URL). One bucket, one limit, enforced.
      */
-    allowedTypes?: string[];
+    bucket: string;
     /**
      * SERVER-side object key template. The client NEVER chooses the path. Tokens:
      * `{userId}` (authenticated user id), `{uploadId}` (server-minted), and
@@ -742,9 +740,10 @@ interface UploadConfig {
  * guard + signed-URL pinning.
  *
  * @example
- * ＠Upload("/", { bucket: "docs", maxSize: 25 * 1024 * 1024,
- *                allowedTypes: ["application/pdf"], pathTemplate: "{userId}/{uploadId}-{filename}" })
+ * ＠Upload("/", { bucket: "docs", pathTemplate: "{userId}/{uploadId}-{filename}" })
  * async upload(＠UploadedObject() obj: UploadedObject, ＠User() user): Promise<DocResult> { ... }
+ * // The size limit + MIME allowlist come from the "docs" bucket in
+ * // config/storage.ts — storage enforces them at the PUT.
  */
 declare function Upload(subpath: string, config: UploadConfig & Pick<RouteOptions, "auth" | "rateLimit">): MethodDecorator$1;
 /**
@@ -777,10 +776,13 @@ interface UploadedObject {
 declare function UploadedObject(): ParameterDecorator$1;
 /**
  * Cross-check one `@Upload` route's uploadConfig against the project's
- * {@link StorageConfig}: the bucket must exist, the upload's `maxSize` must not
- * exceed the bucket's `fileSizeLimit`, and the upload's `allowedTypes` must be a
- * subset of the bucket's `allowedMimeTypes`. Throws a precise error so a
- * mismatch fails at deploy, not at the first user upload.
+ * {@link StorageConfig}: the named bucket MUST exist in `defineStorage(...)`.
+ * Throws a precise error so a typo fails at deploy, not at the first user upload.
+ *
+ * That is the ONLY cross-check: the size limit + MIME allowlist live on the
+ * bucket (`bucket({ fileSizeLimit, allowedMimeTypes })`) and are enforced by
+ * storage at the PUT. `@Upload` carries no `maxSize`/`allowedTypes` of its own,
+ * so there is nothing to compare — one bucket, one limit, no drift.
  *
  * `routeLabel` is used only for error messages (e.g. `docs.upload`).
  */

package/dist/index.d.ts

@@ -714,20 +714,18 @@ type ParameterDecorator$1 = (target: object, propertyKey: string | symbol, param
  * — the client cannot exceed what it declared.
  */
 interface UploadConfig {
-    /** Target bucket NAME. MUST exist in `config/storage.ts` `defineStorage(...)`. */
-    bucket: string;
-    /**
-     * Max object size in BYTES. Enforced twice: the authorize pre-flight rejects a
-     * larger declared size, and the signed URL pins it so storage rejects a larger
-     * PUT. When omitted, the bucket's own `fileSizeLimit` applies.
-     */
-    maxSize?: number;
     /**
-     * MIME allowlist for the object. The authorize pre-flight rejects a
-     * non-matching declared content-type, and the signed URL pins the exact type.
-     * When omitted, the bucket's own `allowedMimeTypes` applies (or any type).
+     * Target bucket NAME. MUST exist in `config/storage.ts` `defineStorage(...)`.
+     *
+     * The bucket is the SINGLE SOURCE OF TRUTH for the size limit + MIME allowlist:
+     * `bucket({ fileSizeLimit, allowedMimeTypes })`. Storage enforces those at the
+     * actual PUT (the only guard a client cannot skip), so `@Upload` deliberately
+     * does NOT take its own `maxSize`/`allowedTypes` — duplicating them here would
+     * let a route declare a tighter limit than its bucket that storage would not
+     * enforce (a real bypass: declare 10 bytes at authorize, then PUT up to the
+     * bucket ceiling straight at the signed URL). One bucket, one limit, enforced.
      */
-    allowedTypes?: string[];
+    bucket: string;
     /**
      * SERVER-side object key template. The client NEVER chooses the path. Tokens:
      * `{userId}` (authenticated user id), `{uploadId}` (server-minted), and
@@ -742,9 +740,10 @@ interface UploadConfig {
  * guard + signed-URL pinning.
  *
  * @example
- * ＠Upload("/", { bucket: "docs", maxSize: 25 * 1024 * 1024,
- *                allowedTypes: ["application/pdf"], pathTemplate: "{userId}/{uploadId}-{filename}" })
+ * ＠Upload("/", { bucket: "docs", pathTemplate: "{userId}/{uploadId}-{filename}" })
  * async upload(＠UploadedObject() obj: UploadedObject, ＠User() user): Promise<DocResult> { ... }
+ * // The size limit + MIME allowlist come from the "docs" bucket in
+ * // config/storage.ts — storage enforces them at the PUT.
  */
 declare function Upload(subpath: string, config: UploadConfig & Pick<RouteOptions, "auth" | "rateLimit">): MethodDecorator$1;
 /**
@@ -777,10 +776,13 @@ interface UploadedObject {
 declare function UploadedObject(): ParameterDecorator$1;
 /**
  * Cross-check one `@Upload` route's uploadConfig against the project's
- * {@link StorageConfig}: the bucket must exist, the upload's `maxSize` must not
- * exceed the bucket's `fileSizeLimit`, and the upload's `allowedTypes` must be a
- * subset of the bucket's `allowedMimeTypes`. Throws a precise error so a
- * mismatch fails at deploy, not at the first user upload.
+ * {@link StorageConfig}: the named bucket MUST exist in `defineStorage(...)`.
+ * Throws a precise error so a typo fails at deploy, not at the first user upload.
+ *
+ * That is the ONLY cross-check: the size limit + MIME allowlist live on the
+ * bucket (`bucket({ fileSizeLimit, allowedMimeTypes })`) and are enforced by
+ * storage at the PUT. `@Upload` carries no `maxSize`/`allowedTypes` of its own,
+ * so there is nothing to compare — one bucket, one limit, no drift.
  *
  * `routeLabel` is used only for error messages (e.g. `docs.upload`).
  */

package/dist/index.js

@@ -476,7 +476,6 @@ var Patch = makeMethodDecorator("PATCH");
 var Delete = makeMethodDecorator("DELETE");
 
 // src/decorators/upload.ts
-var MIME_RE2 = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9*][A-Za-z0-9!#$&^_.+-]*$/;
 function Upload(subpath, config) {
   const { auth: auth2, rateLimit, ...uploadConfig } = config;
   validateUploadConfigShape(uploadConfig);
@@ -507,21 +506,6 @@ function validateUploadConfigShape(c) {
   if (typeof c.pathTemplate !== "string" || c.pathTemplate.length === 0) {
     throw new Error("@Upload config.pathTemplate must be a non-empty key template");
   }
-  if (c.maxSize !== void 0) {
-    if (!Number.isInteger(c.maxSize) || c.maxSize <= 0) {
-      throw new Error(`@Upload config.maxSize must be a positive integer byte count, got ${c.maxSize}`);
-    }
-  }
-  if (c.allowedTypes !== void 0) {
-    if (!Array.isArray(c.allowedTypes) || c.allowedTypes.length === 0) {
-      throw new Error("@Upload config.allowedTypes must be a non-empty array of MIME types when present");
-    }
-    for (const t of c.allowedTypes) {
-      if (typeof t !== "string" || !MIME_RE2.test(t.trim())) {
-        throw new Error(`@Upload config.allowedTypes entry "${t}" is not a valid MIME type (e.g. "image/png")`);
-      }
-    }
-  }
 }
 function validateUploadAgainstStorage(uploadConfig, storage2, routeLabel) {
   const def = storage2.buckets[uploadConfig.bucket];
@@ -531,28 +515,6 @@ function validateUploadAgainstStorage(uploadConfig, storage2, routeLabel) {
       `@Upload route ${routeLabel} targets bucket "${uploadConfig.bucket}" which is not declared in defineStorage(...). ` + (known.length ? `Known buckets: ${known.join(", ")}.` : "No buckets are declared.")
     );
   }
-  if (uploadConfig.maxSize !== void 0 && def.fileSizeLimit !== null && uploadConfig.maxSize > def.fileSizeLimit) {
-    throw new Error(
-      `@Upload route ${routeLabel} maxSize (${uploadConfig.maxSize} bytes) exceeds bucket "${uploadConfig.bucket}" fileSizeLimit (${def.fileSizeLimit} bytes)`
-    );
-  }
-  if (uploadConfig.allowedTypes !== void 0 && def.allowedMimeTypes !== null) {
-    const bucketAllows = (mime) => def.allowedMimeTypes.some((b) => {
-      if (b === mime) return true;
-      const slash = b.indexOf("/");
-      if (slash > 0 && b.slice(slash + 1) === "*") {
-        return mime.startsWith(b.slice(0, slash + 1));
-      }
-      return false;
-    });
-    for (const t of uploadConfig.allowedTypes) {
-      if (!bucketAllows(t)) {
-        throw new Error(
-          `@Upload route ${routeLabel} allows MIME "${t}" which bucket "${uploadConfig.bucket}" does not (bucket allows: ${def.allowedMimeTypes.join(", ")})`
-        );
-      }
-    }
-  }
 }
 
 // src/decorators/params.ts