@cedarjs/uploads 7.0.0-canary.3114

package/dist/services.js

@@ -0,0 +1,141 @@
+import { UploadError } from "./errors.js";
+import { generateStorageKey } from "./keys.js";
+import {
+  assertOwnership,
+  assertTokenAllowsFile,
+  createPendingUpload
+} from "./pending.js";
+import { resolveProfile } from "./profiles.js";
+import { resolveTarget } from "./targets.js";
+import { createUploadToken } from "./uploadToken.js";
+function issueUploadToken({
+  profiles,
+  profile: profileName,
+  secret,
+  currentUser,
+  organizationId
+}) {
+  if (!currentUser) {
+    throw new UploadError(
+      "UNAUTHENTICATED",
+      "You must be logged in to request an upload token."
+    );
+  }
+  const profile = resolveProfile(profiles, profileName);
+  const org = organizationId ?? currentUser.organizationId ?? void 0;
+  const token = createUploadToken({
+    payload: {
+      profile: profile.name,
+      allowedMimeTypes: profile.allowedMimeTypes,
+      maxFileSize: profile.maxFileSize,
+      maxFiles: profile.maxFiles,
+      target: profile.target,
+      sub: String(currentUser.id),
+      ...org ? { organizationId: org } : {}
+    },
+    secret,
+    expiresIn: profile.expiresIn
+  });
+  return {
+    token,
+    allowedMimeTypes: profile.allowedMimeTypes,
+    maxFileSize: BigInt(profile.maxFileSize),
+    maxFiles: profile.maxFiles
+  };
+}
+function toBigInt(value, what) {
+  try {
+    return BigInt(value);
+  } catch {
+    throw new UploadError("FILE_TOO_LARGE", `Invalid ${what}: ${value}`);
+  }
+}
+async function createPresignedUpload({
+  db,
+  targets,
+  tokenPayload,
+  input
+}) {
+  const size = toBigInt(input.size, "file size");
+  assertTokenAllowsFile(tokenPayload, { contentType: input.contentType, size });
+  const target = resolveTarget(targets, tokenPayload.target);
+  const storageKey = generateStorageKey(input.contentType);
+  const upload = await createPendingUpload({
+    db,
+    payload: tokenPayload,
+    filename: input.filename,
+    mimeType: input.contentType,
+    size,
+    storageKey
+  });
+  let presigned;
+  try {
+    presigned = await target.getPresignedUploadUrl(storageKey, {
+      contentType: input.contentType,
+      size
+    });
+  } catch (e) {
+    await db.upload.delete({ where: { id: upload.id } }).catch(() => void 0);
+    throw e;
+  }
+  return { uploadId: upload.id, ...presigned };
+}
+async function confirmUpload({
+  db,
+  targets,
+  uploadId,
+  currentUser
+}) {
+  const upload = await db.upload.findFirst({
+    where: { id: uploadId },
+    omit: { data: true }
+  });
+  if (!upload) {
+    throw new UploadError("NOT_FOUND", "Upload not found.");
+  }
+  assertOwnership(upload, currentUser, "this upload");
+  if (upload.status !== "pending" || !upload.storageKey) {
+    throw new UploadError("NOT_PENDING", "Upload is not awaiting confirmation.");
+  }
+  const target = resolveTarget(targets, upload.target);
+  if (!await target.exists(upload.storageKey)) {
+    throw new UploadError("NOT_IN_STORAGE", "Upload not found in storage.");
+  }
+  const actualSize = await target.getObjectSize(upload.storageKey);
+  if (actualSize === null || BigInt(actualSize) !== upload.size) {
+    const { count: count2 } = await db.upload.updateMany({
+      where: { id: uploadId, status: "pending" },
+      data: { status: "failed" }
+    });
+    if (count2 === 1) {
+      await target.delete(upload.storageKey);
+    }
+    throw new UploadError(
+      "SIZE_MISMATCH",
+      `Uploaded object is ${actualSize ?? "of unknown"} bytes but ${upload.size} bytes were authorized.`
+    );
+  }
+  const { count } = await db.upload.updateMany({
+    where: { id: uploadId, status: "pending" },
+    data: { status: "completed" }
+  });
+  const confirmed = await db.upload.findFirst({
+    where: { id: uploadId },
+    omit: { data: true }
+  });
+  if (!confirmed) {
+    throw new UploadError("NOT_FOUND", "Upload not found.");
+  }
+  if (count === 0 && confirmed.status !== "completed") {
+    throw new UploadError(
+      "NOT_PENDING",
+      "Upload was marked failed before it could be confirmed."
+    );
+  }
+  return confirmed;
+}
+export {
+  confirmUpload,
+  createPresignedUpload,
+  issueUploadToken
+};

package/dist/storeFile.d.ts

@@ -0,0 +1,27 @@
+import type { StorageProvider, UploadDatabase, UploadRecord } from './types.js';
+export interface StoreFileOptions {
+    db: UploadDatabase;
+    filename: string;
+    mimeType: string;
+    data: Uint8Array;
+    /**
+     * Reject `data` larger than this many bytes. Defaults to the 1 MB DB cap
+     * for `providerType: 'db'` targets and to unlimited for object storage.
+     */
+    maxSize?: number;
+    /**
+     * Owner of the file, when it belongs to a user. Persisted so the ownership
+     * checks that guard user uploads apply to server-stored files too.
+     */
+    userId?: string;
+    /** Owning organization, for multi-tenant apps. */
+    organizationId?: string;
+}
+/**
+ * Stores a file directly on a target and creates its `Upload` row. This is
+ * the path for server-generated files (PDFs, exports, thumbnails) and for
+ * files that arrive as base64 through GraphQL. It bypasses tokens, the
+ * upload routes, and Uppy entirely.
+ */
+export declare function storeFile(target: StorageProvider, options: StoreFileOptions): Promise<UploadRecord>;
+//# sourceMappingURL=storeFile.d.ts.map

package/dist/storeFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeFile.d.ts","sourceRoot":"","sources":["../src/storeFile.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAK/E,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,cAAc,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,UAAU,CAAA;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CAyDvB"}

package/dist/storeFile.js

@@ -0,0 +1,53 @@
+import { UploadError } from "./errors.js";
+import { generateStorageKey } from "./keys.js";
+import { DB_MAX_FILE_SIZE } from "./profiles.js";
+const MIME_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+async function storeFile(target, options) {
+  const { db, filename, mimeType, data, maxSize, userId, organizationId } = options;
+  if (!MIME_TYPE.test(mimeType)) {
+    throw new UploadError(
+      "MIME_TYPE_NOT_ALLOWED",
+      `'${mimeType}' is not a valid MIME type.`
+    );
+  }
+  const isDbProvider = target.providerType === "db";
+  const cap = maxSize ?? (isDbProvider ? DB_MAX_FILE_SIZE : void 0);
+  if (cap !== void 0 && data.byteLength > cap) {
+    throw new UploadError(
+      "FILE_TOO_LARGE",
+      `File is ${data.byteLength} bytes, which exceeds the ${cap} byte limit for target '${target.name}'.`
+    );
+  }
+  const key = isDbProvider ? null : generateStorageKey(mimeType);
+  if (key) {
+    await target.write(key, data, { contentType: mimeType });
+  }
+  try {
+    return await createRow();
+  } catch (e) {
+    if (key) {
+      await target.delete(key).catch(() => void 0);
+    }
+    throw e;
+  }
+  function createRow() {
+    return db.upload.create({
+      data: {
+        target: target.name,
+        status: "completed",
+        filename,
+        mimeType,
+        size: BigInt(data.byteLength),
+        storageKey: key,
+        // Copying gives Prisma the plain-ArrayBuffer-backed array its `Bytes`
+        // input requires, whatever `data` was backed by
+        data: isDbProvider ? new Uint8Array(data) : null,
+        userId: userId ?? null,
+        organizationId: organizationId ?? null
+      }
+    });
+  }
+}
+export {
+  storeFile
+};

package/dist/targets.d.ts

@@ -0,0 +1,14 @@
+import type { StorageProvider, StorageTargets } from './types.js';
+/**
+ * Names each provider after its key so that `targets.avatars` works for direct
+ * access and `targets[upload.target]` works for lookup from a database row.
+ * Returns the same object, typed.
+ */
+export declare function defineStorageTargets<T extends StorageTargets>(targets: T): T;
+/**
+ * Looks a target up by name, throwing an `UploadError` with code
+ * `UNKNOWN_TARGET` that lists the configured names when it is missing. Use it
+ * when the name comes from an `Upload` row's `target` column.
+ */
+export declare function resolveTarget(targets: StorageTargets, name: string): StorageProvider;
+//# sourceMappingURL=targets.d.ts.map

package/dist/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEjE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAM5E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,GACX,eAAe,CAcjB"}

package/dist/targets.js

@@ -0,0 +1,21 @@
+import { UploadError } from "./errors.js";
+function defineStorageTargets(targets) {
+  for (const [name, provider] of Object.entries(targets)) {
+    provider.name = name;
+  }
+  return targets;
+}
+function resolveTarget(targets, name) {
+  const target = Object.hasOwn(targets, name) ? targets[name] : void 0;
+  if (!target) {
+    throw new UploadError(
+      "UNKNOWN_TARGET",
+      `Unknown storage target '${name}'. Available targets: ${Object.keys(targets).join(", ") || "(none)"}.`
+    );
+  }
+  return target;
+}
+export {
+  defineStorageTargets,
+  resolveTarget
+};

package/dist/types.d.ts

@@ -0,0 +1,212 @@
+import type { Readable } from 'node:stream';
+/** Lifecycle state of an `Upload` row. */
+export type UploadStatus = 'pending' | 'completed' | 'failed';
+/**
+ * How a served file asks the browser to handle it. `attachment` downloads;
+ * `inline` renders in place. Serving defaults to `attachment` because the
+ * stored MIME type is client-asserted.
+ */
+export type ContentDisposition = 'attachment' | 'inline';
+/**
+ * One row of the `Upload` table the setup command adds to `schema.prisma`.
+ * `data` is optional because most code paths deliberately leave the inline
+ * bytes out of the query.
+ */
+export interface UploadRecord {
+    id: string;
+    target: string;
+    status: string;
+    filename: string;
+    mimeType: string;
+    size: bigint;
+    storageKey: string | null;
+    data?: Uint8Array | null;
+    userId: string | null;
+    tokenId: string | null;
+    organizationId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UploadCreateData {
+    target: string;
+    status: UploadStatus;
+    filename: string;
+    mimeType: string;
+    size: bigint;
+    storageKey?: string | null;
+    data?: Uint8Array<ArrayBuffer> | null;
+    userId?: string | null;
+    tokenId?: string | null;
+    organizationId?: string | null;
+}
+export interface UploadWhere {
+    id?: string | {
+        in: string[];
+    };
+    target?: string;
+    status?: string | {
+        in: string[];
+    };
+    storageKey?: string | null | {
+        not: null;
+    };
+    tokenId?: string;
+    createdAt?: {
+        lt?: Date;
+        gte?: Date;
+    };
+    updatedAt?: {
+        lt?: Date;
+        gte?: Date;
+    };
+}
+export interface UploadUpdateData {
+    status?: UploadStatus;
+    size?: bigint;
+    storageKey?: string | null;
+}
+/**
+ * The subset of Prisma's generated `Upload` delegate this package calls. The
+ * generated client satisfies it structurally, so apps pass their `db` as-is.
+ */
+export interface UploadDelegate {
+    create(args: {
+        data: UploadCreateData;
+    }): Promise<UploadRecord>;
+    findUnique(args: {
+        where: {
+            id: string;
+        };
+    }): Promise<UploadRecord | null>;
+    findUniqueOrThrow(args: {
+        where: {
+            id: string;
+        };
+    }): Promise<UploadRecord>;
+    findFirst(args: {
+        where: UploadWhere;
+        omit?: {
+            data?: boolean;
+        };
+    }): Promise<UploadRecord | null>;
+    findMany(args: {
+        where: UploadWhere;
+        omit?: {
+            data?: boolean;
+        };
+        orderBy?: {
+            createdAt: 'asc' | 'desc';
+        };
+        take?: number;
+    }): Promise<UploadRecord[]>;
+    updateMany(args: {
+        where: UploadWhere;
+        data: UploadUpdateData;
+    }): Promise<{
+        count: number;
+    }>;
+    delete(args: {
+        where: {
+            id: string;
+        };
+    }): Promise<UploadRecord>;
+    count(args: {
+        where: UploadWhere;
+    }): Promise<number>;
+}
+/** What a Prisma interactive transaction hands to its callback. */
+export interface UploadTransactionClient {
+    upload: UploadDelegate;
+}
+/**
+ * The subset of a Prisma client this package needs: the `Upload` delegate and
+ * interactive transactions. Any generated client whose schema contains the
+ * `Upload` model satisfies it.
+ */
+export interface UploadDatabase extends UploadTransactionClient {
+    $transaction<T>(fn: (tx: UploadTransactionClient) => Promise<T>, options?: {
+        isolationLevel?: 'Serializable';
+    }): Promise<T>;
+}
+/**
+ * The shape Uppy's S3 plugin (and any other direct-upload client) needs to
+ * PUT a file straight into object storage.
+ */
+export interface PresignedUploadUrl {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+}
+/**
+ * The contract every storage provider implements with its native SDK. It is
+ * the minimum the framework needs to write, read, serve, and delete files;
+ * provider-specific features stay on the provider's own client.
+ */
+export interface StorageProvider {
+    /** Name of this provider instance, assigned by `defineStorageTargets()`. */
+    name: string;
+    /**
+     * `'db'` marks the provider that stores bytes inline in the `Upload` row.
+     * Every other value (`'fs'`, `'s3'`, or a third-party string) is treated
+     * identically as object storage.
+     */
+    providerType: 'db' | (string & {});
+    /** Write bytes under `key`. */
+    write(key: string, data: Uint8Array, opts: {
+        contentType: string;
+    }): Promise<void>;
+    /** Read the whole object into memory. */
+    read(key: string): Promise<Buffer>;
+    /**
+     * Stream the object. Optional; the serve route falls back to `read()` when
+     * a provider does not implement it.
+     */
+    readStream?(key: string): Promise<Readable>;
+    /** Delete the object. A missing object is not an error. */
+    delete(key: string): Promise<void>;
+    /** Whether the object exists. */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Size of the object in bytes, or `null` when the provider cannot know.
+     * Completion-time verification treats `null` as a failed check.
+     */
+    getObjectSize(key: string): Promise<number | null>;
+    /**
+     * A time-limited URL for reading the object. Defaults to attachment
+     * disposition wherever the provider controls response headers.
+     */
+    getSignedReadUrl(key: string, opts?: {
+        expiresIn?: number;
+        disposition?: ContentDisposition;
+    }): Promise<string>;
+    /**
+     * A presigned URL for direct client upload. Providers that cannot do this
+     * (FS, DB) throw an `UploadError` with code `PRESIGN_NOT_SUPPORTED`.
+     */
+    getPresignedUploadUrl(key: string, opts: {
+        contentType: string;
+        size?: bigint;
+        expiresIn?: number;
+    }): Promise<PresignedUploadUrl>;
+    /**
+     * Provider-specific configuration for third-party integrations. S3 returns
+     * `{ bucket, region, keyPrefix }`, FS returns `{ uploadDir }`, DB `{}`.
+     */
+    getConfig(): Record<string, unknown>;
+}
+export type StorageTargets = Record<string, StorageProvider>;
+/** A serialized `Upload` row, safe to return from a route or resolver. */
+export interface SerializedUpload {
+    id: string;
+    target: string;
+    status: string;
+    filename: string;
+    mimeType: string;
+    size: string;
+    storageKey: string | null;
+    userId: string | null;
+    organizationId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/uploadLoader.d.ts

@@ -0,0 +1,11 @@
+import type { UploadDatabase, UploadRecord } from './types.js';
+/**
+ * Loads an `Upload` row by id, batching every call made during the same
+ * tick for the same `scope` into one query. A transformer directive runs
+ * once per field per row, so a list of a hundred rows would otherwise be a
+ * hundred queries. Scope on the GraphQL context so the batch and its cache
+ * live exactly one request. The batch query leaves out `data`, so inline
+ * blobs are never dragged into memory for object-storage rows.
+ */
+export declare function loadUpload(scope: object, db: UploadDatabase, id: string): Promise<UploadRecord | null>;
+//# sourceMappingURL=uploadLoader.d.ts.map

package/dist/uploadLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadLoader.d.ts","sourceRoot":"","sources":["../src/uploadLoader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AA4C9D;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,cAAc,EAClB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA4B9B"}

package/dist/uploadLoader.js

@@ -0,0 +1,47 @@
+const loaders = /* @__PURE__ */ new WeakMap();
+function flush(loader, db) {
+  loader.scheduled = false;
+  const batch = loader.queue;
+  loader.queue = /* @__PURE__ */ new Map();
+  const ids = [...batch.keys()];
+  db.upload.findMany({ where: { id: { in: ids } }, omit: { data: true } }).then((rows) => {
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    for (const [id, waiters] of batch) {
+      const row = byId.get(id) ?? null;
+      for (const waiter of waiters) {
+        waiter.resolve(row);
+      }
+    }
+  }).catch((e) => {
+    for (const waiters of batch.values()) {
+      for (const waiter of waiters) {
+        waiter.reject(e);
+      }
+    }
+  });
+}
+function loadUpload(scope, db, id) {
+  let loader = loaders.get(scope);
+  if (!loader) {
+    loader = { cache: /* @__PURE__ */ new Map(), queue: /* @__PURE__ */ new Map(), scheduled: false };
+    loaders.set(scope, loader);
+  }
+  const cached = loader.cache.get(id);
+  if (cached) {
+    return cached;
+  }
+  const promise = new Promise((resolve, reject) => {
+    const waiters = loader.queue.get(id) ?? [];
+    waiters.push({ resolve, reject });
+    loader.queue.set(id, waiters);
+  });
+  loader.cache.set(id, promise);
+  if (!loader.scheduled) {
+    loader.scheduled = true;
+    queueMicrotask(() => flush(loader, db));
+  }
+  return promise;
+}
+export {
+  loadUpload
+};

package/dist/uploadToken.d.ts

@@ -0,0 +1,43 @@
+import type { SignedTokenExpiresIn } from '@cedarjs/api';
+/** Purpose claim that separates upload tokens from every other signed token. */
+export declare const UPLOAD_TOKEN_PURPOSE = "cedar-upload";
+export { UPLOAD_TOKEN_HEADER } from './constants.js';
+/**
+ * The claims inside an upload token. Constraints come from the server-side
+ * profile; `sub` binds the token to the user it was issued to and `jti`
+ * lets the server count how many files one token has created.
+ */
+export interface UploadTokenPayload {
+    /** The profile the token was issued for. */
+    profile: string;
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+    maxFiles: number;
+    /** The storage target files created with this token land on. */
+    target: string;
+    /** Id of the user the token was issued to. */
+    sub: string;
+    /** Unique token id, stamped onto each `Upload` row the token creates. */
+    jti: string;
+    /** The organization the token was issued under, in multi-tenant apps. */
+    organizationId?: string;
+}
+export interface CreateUploadTokenOptions {
+    payload: Omit<UploadTokenPayload, 'jti'> & {
+        jti?: string;
+    };
+    secret: string;
+    expiresIn?: SignedTokenExpiresIn;
+}
+/** Signs an upload token. A fresh `jti` is generated unless one is passed. */
+export declare function createUploadToken({ payload, secret, expiresIn, }: CreateUploadTokenOptions): string;
+/**
+ * Verifies an upload token and returns its claims. Throws an `UploadError`
+ * with code `INVALID_TOKEN` for a missing, expired, tampered, or foreign
+ * token. The token argument accepts `null` and `undefined` so a header value
+ * can be passed straight in.
+ */
+export declare function verifyUploadToken(token: string | null | undefined, { secret }: {
+    secret: string;
+}): UploadTokenPayload;
+//# sourceMappingURL=uploadToken.d.ts.map

package/dist/uploadToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadToken.d.ts","sourceRoot":"","sources":["../src/uploadToken.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAKxD,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,iBAAiB,CAAA;AAElD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAA;IACX,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAA;IACX,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,GAAG;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3D,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,oBAAoB,CAAA;CACjC;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,MAAM,EACN,SAA2C,GAC5C,EAAE,wBAAwB,GAAG,MAAM,CAOnC;AAyBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7B,kBAAkB,CA2BpB"}

package/dist/uploadToken.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import {
+  createSignedToken,
+  SignedTokenError,
+  verifySignedToken
+} from "@cedarjs/api";
+import { UploadError } from "./errors.js";
+import { DEFAULT_UPLOAD_TOKEN_EXPIRES_IN } from "./profiles.js";
+const UPLOAD_TOKEN_PURPOSE = "cedar-upload";
+import { UPLOAD_TOKEN_HEADER } from "./constants.js";
+function createUploadToken({
+  payload,
+  secret,
+  expiresIn = DEFAULT_UPLOAD_TOKEN_EXPIRES_IN
+}) {
+  return createSignedToken({
+    payload: { ...payload, jti: payload.jti ?? randomUUID() },
+    purpose: UPLOAD_TOKEN_PURPOSE,
+    expiresIn,
+    secret
+  });
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isUploadTokenPayload(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const p = value;
+  return typeof p.profile === "string" && isStringArray(p.allowedMimeTypes) && typeof p.maxFileSize === "number" && typeof p.maxFiles === "number" && typeof p.target === "string" && typeof p.sub === "string" && typeof p.jti === "string" && (p.organizationId === void 0 || typeof p.organizationId === "string");
+}
+function verifyUploadToken(token, { secret }) {
+  let payload;
+  try {
+    payload = verifySignedToken(token, {
+      purpose: UPLOAD_TOKEN_PURPOSE,
+      secret
+    });
+  } catch (e) {
+    if (e instanceof SignedTokenError && e.code === "MISSING_SECRET") {
+      throw new UploadError("CONFIGURATION", e.message, e);
+    }
+    const detail = e instanceof SignedTokenError ? e.code : "INVALID";
+    throw new UploadError(
+      "INVALID_TOKEN",
+      `Invalid upload token (${detail}).`,
+      e
+    );
+  }
+  if (!isUploadTokenPayload(payload)) {
+    throw new UploadError("INVALID_TOKEN", "Invalid upload token (MALFORMED).");
+  }
+  return payload;
+}
+export {
+  UPLOAD_TOKEN_HEADER,
+  UPLOAD_TOKEN_PURPOSE,
+  createUploadToken,
+  verifyUploadToken
+};