@cedarjs/uploads 7.0.1-next.314 → 7.0.1-next.466

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/web/createUppy.d.ts

@@ -37,8 +37,11 @@ export interface FsUppyOptions extends BaseUppyOptions {
     provider: 'fs';
     /** Full URL of the api's `POST {prefix}/fs` route, or a function returning it. */
     endpoint: string | (() => string);
-    /** The upload token to send. Called per request so a refreshed token is used. */
-    getUploadToken: () => string | null;
+    /**
+     * The upload token to send with `file`. Called per request, so each file
+     * can carry a different token.
+     */
+    getUploadToken: (file: Pick<CedarUppyFile, 'id'>) => string | null;
 }
 export type CreateUppyOptions = S3UppyOptions | FsUppyOptions;
 /** Response body of the api's `POST {prefix}/fs` route. */
@@ -49,6 +52,20 @@ export interface FsUploadResponseBody {
         filename: string;
     }[];
 }
+/**
+ * Applies a profile's constraints to `uppy` as restrictions. The file-count
+ * limit is checked against the files still waiting to upload, not every file
+ * in the queue: each upload batch gets a token of its own, so files that
+ * already finished uploading do not count against the next batch. Uppy's own
+ * `maxNumberOfFiles` counts finished files too, so it is not used.
+ *
+ * The limit is added on top of the instance's current `onBeforeFileAdded`
+ * callback, which still runs first: returning `false` from it rejects the
+ * file, and returning a file object adds that file instead. Calling this
+ * again with new constraints replaces the limit without wrapping the same
+ * callback twice.
+ */
+export declare function applyUploadConstraints(uppy: CedarUppy, constraints: UploadConstraints): void;
 /**
  * Creates an Uppy instance pre-configured for one of Cedar's upload flows.
  * Direct-to-S3 uploads use `@uppy/aws-s3` with the presigned URLs the api

package/dist/web/createUppy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createUppy.d.ts","sourceRoot":"","sources":["../../src/web/createUppy.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,YAAY,CAAA;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAIhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAErD,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,IAAI,CAAA;AAE5B,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErD,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,eAAe,CAAA;AAElD,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,WAAW,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACtC,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd;;;OAGG;IACH,mBAAmB,EAAE,CACnB,IAAI,EAAE,aAAa,KAChB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd,kFAAkF;IAClF,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IACjC,iFAAiF;IACjF,cAAc,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CACpC;AAED,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAAA;AAE7D,2DAA2D;AAC3D,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC5D;AAcD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,CA2EpB;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAInE"}
+{"version":3,"file":"createUppy.d.ts","sourceRoot":"","sources":["../../src/web/createUppy.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,YAAY,CAAA;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAIhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAErD,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,IAAI,CAAA;AAE5B,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErD,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,eAAe,CAAA;AAElD,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,WAAW,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACtC,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd;;;OAGG;IACH,mBAAmB,EAAE,CACnB,IAAI,EAAE,aAAa,KAChB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd,kFAAkF;IAClF,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IACjC;;;OAGG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,MAAM,GAAG,IAAI,CAAA;CACnE;AAED,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAAA;AAE7D,2DAA2D;AAC3D,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC5D;AAUD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,iBAAiB,QAwC/B;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,CA2EpB;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAInE"}

package/dist/web/createUppy.js

@@ -2,23 +2,44 @@ import Uppy from "@uppy/core";
 import { UPLOAD_TOKEN_HEADER } from "../constants.js";
 import { UPLOAD_TOKEN_HEADER as UPLOAD_TOKEN_HEADER2 } from "../constants.js";
 const DEFAULT_FS_UPLOAD_PATH = "/upload/fs";
-function restrictionsFor(constraints) {
-  if (!constraints) {
-    return {};
-  }
-  return {
-    allowedFileTypes: constraints.allowedMimeTypes,
-    maxFileSize: constraints.maxFileSize,
-    maxNumberOfFiles: constraints.maxFiles
+const wrappedCallbacks = /* @__PURE__ */ new WeakMap();
+function applyUploadConstraints(uppy, constraints) {
+  const current = uppy.opts.onBeforeFileAdded;
+  const inner = current ? wrappedCallbacks.get(current) ?? current : void 0;
+  const onBeforeFileAdded = (file, files) => {
+    const result = inner ? inner(file, files) : !Object.hasOwn(files, file.id);
+    if (result === false) {
+      return false;
+    }
+    const pending = Object.values(files).filter(
+      (queued) => !queued.isGhost && !queued.progress.uploadComplete
+    );
+    if (pending.length >= constraints.maxFiles) {
+      uppy.info(
+        uppy.i18n("youCanOnlyUploadX", { smart_count: constraints.maxFiles }),
+        "error"
+      );
+      return false;
+    }
+    return result;
   };
+  if (inner) {
+    wrappedCallbacks.set(onBeforeFileAdded, inner);
+  }
+  uppy.setOptions({
+    restrictions: {
+      allowedFileTypes: constraints.allowedMimeTypes,
+      maxFileSize: constraints.maxFileSize
+    },
+    onBeforeFileAdded
+  });
 }
 async function createUppy(options) {
   const { constraints, autoProceed = true, debug = false } = options;
-  const uppy = new Uppy({
-    autoProceed,
-    debug,
-    restrictions: restrictionsFor(constraints)
-  });
+  const uppy = new Uppy({ autoProceed, debug });
+  if (constraints) {
+    applyUploadConstraints(uppy, constraints);
+  }
   if (options.provider === "s3") {
     const { default: AwsS3 } = await import("@uppy/aws-s3");
     uppy.use(AwsS3, {
@@ -52,9 +73,9 @@ async function createUppy(options) {
     formData: true,
     fieldName: "file",
     bundle: false,
-    headers: () => {
+    headers: (file) => {
       const headers = {};
-      const token = options.getUploadToken();
+      const token = options.getUploadToken(file);
       if (token) {
         headers[UPLOAD_TOKEN_HEADER] = token;
       }
@@ -77,6 +98,7 @@ function getCedarUploadId(file) {
 export {
   DEFAULT_FS_UPLOAD_PATH,
   UPLOAD_TOKEN_HEADER2 as UPLOAD_TOKEN_HEADER,
+  applyUploadConstraints,
   createUppy,
   getCedarUploadId
 };

package/dist/web/hooks/useFsUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFsUpload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useFsUpload.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE/E,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACpC,CAAA;AAWD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,aAAa,GACd,EAAE,kBAAkB,GAAG,iBAAiB,CAyDxC"}
+{"version":3,"file":"useFsUpload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useFsUpload.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE/E,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACpC,CAAA;AAWD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,aAAa,GACd,EAAE,kBAAkB,GAAG,iBAAiB,CA6ExC"}