@cedarjs/uploads 7.0.0-canary.3114

package/dist/web/hooks/useFsUpload.js

@@ -0,0 +1,58 @@
+import { useEffect, useRef } from "react";
+import { createUppy, DEFAULT_FS_UPLOAD_PATH } from "../createUppy.js";
+import { useUploadToken } from "./useUploadToken.js";
+import { useUppyUpload } from "./useUppyUpload.js";
+function defaultEndpoint() {
+  const apiUrl = typeof RWJS_API_URL === "string" ? RWJS_API_URL.replace(/\/+$/, "") : "";
+  return `${apiUrl}${DEFAULT_FS_UPLOAD_PATH}`;
+}
+function useFsUpload({
+  profile,
+  endpoint,
+  onUploadComplete,
+  onUploadError
+}) {
+  const { requestToken, getToken, constraints } = useUploadToken({ profile });
+  const endpointRef = useRef(endpoint ?? defaultEndpoint());
+  useEffect(() => {
+    endpointRef.current = endpoint ?? defaultEndpoint();
+  }, [endpoint]);
+  const upload = useUppyUpload(
+    () => createUppy({
+      provider: "fs",
+      constraints,
+      endpoint: () => endpointRef.current,
+      getUploadToken: getToken
+    }),
+    constraints,
+    { onUploadComplete, onUploadError }
+  );
+  const { uppy } = upload;
+  useEffect(() => {
+    if (!uppy) {
+      return;
+    }
+    const onFileAdded = () => {
+      if (!getToken()) {
+        requestToken().catch((e) => {
+          onUploadError?.(e instanceof Error ? e : new Error(String(e)));
+        });
+      }
+    };
+    const ensureToken = async () => {
+      if (!getToken()) {
+        await requestToken();
+      }
+    };
+    uppy.on("file-added", onFileAdded);
+    uppy.addPreProcessor(ensureToken);
+    return () => {
+      uppy.off("file-added", onFileAdded);
+      uppy.removePreProcessor(ensureToken);
+    };
+  }, [uppy, getToken, requestToken, onUploadError]);
+  return { ...upload, requestToken };
+}
+export {
+  useFsUpload
+};

package/dist/web/hooks/useS3Upload.d.ts

@@ -0,0 +1,23 @@
+import type { UppyUploadCallbacks, UppyUploadResult } from './useUppyUpload.js';
+export interface UseS3UploadOptions extends UppyUploadCallbacks {
+    /** Name of a server-defined upload profile. */
+    profile: string;
+    /**
+     * Confirm each upload through the `confirmUpload` mutation once the PUT
+     * succeeds, before the batch is reported complete. Defaults to `true`.
+     * Turn it off when an S3 event webhook confirms uploads instead.
+     */
+    confirm?: boolean;
+}
+export type UseS3UploadResult = UppyUploadResult & {
+    /** Fetches a fresh upload token. Called automatically before uploads. */
+    requestToken: () => Promise<string>;
+};
+/**
+ * Direct-to-S3 uploads: fetches an upload token, asks the api for a
+ * presigned URL per file, PUTs the bytes with `@uppy/aws-s3`, and confirms
+ * each upload before the batch counts as complete. The returned `uppy`
+ * instance plugs into any Uppy UI.
+ */
+export declare function useS3Upload({ profile, confirm, onUploadComplete, onUploadError, }: UseS3UploadOptions): UseS3UploadResult;
+//# sourceMappingURL=useS3Upload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useS3Upload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useS3Upload.ts"],"names":[],"mappings":"AAgBA,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,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,yEAAyE;IACzE,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACpC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,OAAc,EACd,gBAAgB,EAChB,aAAa,GACd,EAAE,kBAAkB,GAAG,iBAAiB,CAwHxC"}

package/dist/web/hooks/useS3Upload.js

@@ -0,0 +1,99 @@
+import { useCallback, useEffect, useRef } from "react";
+import { useMutation } from "@apollo/client/react";
+import { createUppy, UPLOAD_TOKEN_HEADER } from "../createUppy.js";
+import { CONFIRM_UPLOAD, CREATE_PRESIGNED_UPLOAD_URL } from "../graphql.js";
+import { useUploadToken } from "./useUploadToken.js";
+import { useUppyUpload } from "./useUppyUpload.js";
+function useS3Upload({
+  profile,
+  confirm = true,
+  onUploadComplete,
+  onUploadError
+}) {
+  const { requestToken, getToken, constraints } = useUploadToken({ profile });
+  const [createPresignedUploadUrl] = useMutation(CREATE_PRESIGNED_UPLOAD_URL);
+  const [confirmUpload] = useMutation(CONFIRM_UPLOAD);
+  const getUploadParameters = useCallback(
+    async (file) => {
+      const uploadToken = getToken() ?? await requestToken();
+      const result = await createPresignedUploadUrl({
+        variables: {
+          input: {
+            filename: file.name ?? "file",
+            contentType: file.type || "application/octet-stream",
+            size: String(file.size ?? 0)
+          }
+        },
+        context: { headers: { [UPLOAD_TOKEN_HEADER]: uploadToken } }
+      });
+      const data = result.data?.createPresignedUploadUrl;
+      if (!data) {
+        throw new Error("The presigned URL mutation returned no data.");
+      }
+      return data;
+    },
+    [createPresignedUploadUrl, getToken, requestToken]
+  );
+  const getUploadParametersRef = useRef(getUploadParameters);
+  useEffect(() => {
+    getUploadParametersRef.current = getUploadParameters;
+  }, [getUploadParameters]);
+  const upload = useUppyUpload(
+    () => createUppy({
+      provider: "s3",
+      constraints,
+      getUploadParameters: (file) => getUploadParametersRef.current(file)
+    }),
+    constraints,
+    { onUploadComplete, onUploadError }
+  );
+  const { uppy } = upload;
+  useEffect(() => {
+    if (!uppy) {
+      return;
+    }
+    const onFileAdded = () => {
+      if (!getToken()) {
+        requestToken().catch((e) => {
+          onUploadError?.(e instanceof Error ? e : new Error(String(e)));
+        });
+      }
+    };
+    const confirmAll = async (fileIDs) => {
+      if (!confirm) {
+        return;
+      }
+      for (const fileID of fileIDs) {
+        const file = uppy.getFile(fileID);
+        const uploadId = file?.meta.cedarUploadId;
+        if (!file || typeof uploadId !== "string") {
+          continue;
+        }
+        try {
+          const result = await confirmUpload({ variables: { uploadId } });
+          if (result.data?.confirmUpload.status !== "completed") {
+            throw new Error(`Upload ${uploadId} could not be confirmed.`);
+          }
+        } catch (e) {
+          const error = e instanceof Error ? e : new Error(String(e));
+          uppy.setFileMeta(fileID, { cedarUploadId: void 0 });
+          uppy.setFileState(fileID, {
+            error: error.message,
+            response: void 0
+          });
+          uppy.emit("upload-error", file, error);
+        }
+      }
+    };
+    uppy.on("file-added", onFileAdded);
+    uppy.addPostProcessor(confirmAll);
+    return () => {
+      uppy.off("file-added", onFileAdded);
+      uppy.removePostProcessor(confirmAll);
+    };
+  }, [uppy, confirm, confirmUpload, getToken, requestToken, onUploadError]);
+  return { ...upload, requestToken };
+}
+export {
+  useS3Upload
+};

package/dist/web/hooks/useUploadToken.d.ts

@@ -0,0 +1,34 @@
+import type { ErrorLike } from '@apollo/client';
+import type { UploadConstraints } from '../graphql.js';
+export interface UseUploadTokenOptions {
+    /** Name of a server-defined upload profile. */
+    profile: string;
+}
+export interface UseUploadTokenResult {
+    /**
+     * Fetches a fresh token and resolves with it. Concurrent calls share one
+     * in-flight request.
+     */
+    requestToken: () => Promise<string>;
+    /**
+     * Returns the most recently fetched token, or `null`, without triggering
+     * a render. Meant for event handlers and Uppy callbacks.
+     */
+    getToken: () => string | null;
+    /** The most recently fetched token, or `null`. */
+    token: string | null;
+    /**
+     * The profile's constraints, echoed by the server alongside the token for
+     * client-side UX. `null` until the first successful fetch.
+     */
+    constraints: UploadConstraints | null;
+    loading: boolean;
+    error: ErrorLike | undefined;
+}
+/**
+ * Fetches upload tokens for a profile from the `requestUploadToken` query.
+ * Tokens expire, so the query runs with `fetchPolicy: 'no-cache'` and only
+ * when `requestToken()` is called, never on mount.
+ */
+export declare function useUploadToken({ profile, }: UseUploadTokenOptions): UseUploadTokenResult;
+//# sourceMappingURL=useUploadToken.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUploadToken.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useUploadToken.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI/C,OAAO,KAAK,EAGV,iBAAiB,EAClB,MAAM,eAAe,CAAA;AAEtB,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC;;;OAGG;IACH,QAAQ,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAC7B,kDAAkD;IAClD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB;;;OAGG;IACH,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,SAAS,GAAG,SAAS,CAAA;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,GACR,EAAE,qBAAqB,GAAG,oBAAoB,CA4E9C"}

package/dist/web/hooks/useUploadToken.js

@@ -0,0 +1,60 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useLazyQuery } from "@apollo/client/react";
+import { REQUEST_UPLOAD_TOKEN } from "../graphql.js";
+function useUploadToken({
+  profile
+}) {
+  const [token, setToken] = useState(null);
+  const [constraints, setConstraints] = useState(null);
+  const tokenRef = useRef(null);
+  const inFlight = useRef(null);
+  const profileRef = useRef(profile);
+  useEffect(() => {
+    profileRef.current = profile;
+    tokenRef.current = null;
+    inFlight.current = null;
+    setToken(null);
+    setConstraints(null);
+  }, [profile]);
+  const [execute, { loading, error }] = useLazyQuery(REQUEST_UPLOAD_TOKEN, { fetchPolicy: "no-cache" });
+  const requestToken = useCallback(() => {
+    if (inFlight.current) {
+      return inFlight.current;
+    }
+    const requestedProfile = profile;
+    const request = (async () => {
+      const result = await execute({ variables: { profile: requestedProfile } });
+      if (requestedProfile !== profileRef.current) {
+        throw new Error(
+          "The upload profile changed while a token was requested."
+        );
+      }
+      if (result.error) {
+        throw result.error instanceof Error ? result.error : new Error(result.error.message);
+      }
+      const data = result.data?.requestUploadToken;
+      if (!data) {
+        throw new Error("The upload token query returned no data.");
+      }
+      tokenRef.current = data.token;
+      setToken(data.token);
+      setConstraints({
+        allowedMimeTypes: data.allowedMimeTypes,
+        maxFileSize: Number(data.maxFileSize),
+        maxFiles: data.maxFiles
+      });
+      return data.token;
+    })().finally(() => {
+      if (inFlight.current === request) {
+        inFlight.current = null;
+      }
+    });
+    inFlight.current = request;
+    return request;
+  }, [execute, profile]);
+  const getToken = useCallback(() => tokenRef.current, []);
+  return { requestToken, getToken, token, constraints, loading, error };
+}
+export {
+  useUploadToken
+};

package/dist/web/hooks/useUppyUpload.d.ts

@@ -0,0 +1,23 @@
+import type { CedarUppy } from '../createUppy.js';
+import type { UploadConstraints } from '../graphql.js';
+export interface UppyUploadCallbacks {
+    /** Called with the `Upload` ids of every file once a batch finishes. */
+    onUploadComplete?: (uploadIds: string[]) => void;
+    onUploadError?: (error: Error) => void;
+}
+export interface UppyUploadResult {
+    /** The Uppy instance, or `null` while it is being created. */
+    uppy: CedarUppy | null;
+    /** `Upload` ids of every file that finished, across batches. */
+    completedUploads: string[];
+    isUploading: boolean;
+}
+/**
+ * Shared plumbing for `useS3Upload` and `useFsUpload`: creates the Uppy
+ * instance once per mount, re-applies restrictions when the token's
+ * constraints arrive, tracks completion, and destroys the instance on
+ * unmount. `create` runs once, so anything it closes over (an endpoint, a
+ * presign callback) must read changing values through refs.
+ */
+export declare function useUppyUpload(create: () => Promise<CedarUppy>, constraints: UploadConstraints | null, { onUploadComplete, onUploadError }: UppyUploadCallbacks): UppyUploadResult;
+//# sourceMappingURL=useUppyUpload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUppyUpload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useUppyUpload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,kBAAkB,CAAA;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAEtD,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;IAChD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAChC,WAAW,EAAE,iBAAiB,GAAG,IAAI,EACrC,EAAE,gBAAgB,EAAE,aAAa,EAAE,EAAE,mBAAmB,GACvD,gBAAgB,CAoGlB"}

package/dist/web/hooks/useUppyUpload.js

@@ -0,0 +1,76 @@
+import { useEffect, useRef, useState } from "react";
+import { getCedarUploadId } from "../createUppy.js";
+function useUppyUpload(create, constraints, { onUploadComplete, onUploadError }) {
+  const [uppy, setUppy] = useState(null);
+  const [completedUploads, setCompletedUploads] = useState([]);
+  const [isUploading, setIsUploading] = useState(false);
+  const callbacks = useRef({ onUploadComplete, onUploadError });
+  useEffect(() => {
+    callbacks.current = { onUploadComplete, onUploadError };
+  }, [onUploadComplete, onUploadError]);
+  useEffect(() => {
+    let instance = null;
+    let cancelled = false;
+    create().then((created) => {
+      if (cancelled) {
+        created.destroy();
+        return;
+      }
+      instance = created;
+      setUppy(created);
+    }).catch((e) => {
+      callbacks.current.onUploadError?.(
+        e instanceof Error ? e : new Error(String(e))
+      );
+    });
+    return () => {
+      cancelled = true;
+      instance?.destroy();
+      setUppy(null);
+    };
+  }, []);
+  useEffect(() => {
+    if (!uppy || !constraints) {
+      return;
+    }
+    uppy.setOptions({
+      restrictions: {
+        allowedFileTypes: constraints.allowedMimeTypes,
+        maxFileSize: constraints.maxFileSize,
+        maxNumberOfFiles: constraints.maxFiles
+      }
+    });
+  }, [uppy, constraints]);
+  useEffect(() => {
+    if (!uppy) {
+      return;
+    }
+    const onStart = () => setIsUploading(true);
+    const onComplete = (result) => {
+      setIsUploading(false);
+      const ids = (result.successful ?? []).map((file) => getCedarUploadId(uppy.getFile(file.id) ?? file)).filter((id) => Boolean(id));
+      if (ids.length > 0) {
+        setCompletedUploads((prev) => [...prev, ...ids]);
+        callbacks.current.onUploadComplete?.(ids);
+      }
+    };
+    const onError = (_file, error) => {
+      setIsUploading(false);
+      callbacks.current.onUploadError?.(
+        error instanceof Error ? error : new Error(error.message)
+      );
+    };
+    uppy.on("upload-start", onStart);
+    uppy.on("complete", onComplete);
+    uppy.on("upload-error", onError);
+    return () => {
+      uppy.off("upload-start", onStart);
+      uppy.off("complete", onComplete);
+      uppy.off("upload-error", onError);
+    };
+  }, [uppy]);
+  return { uppy, completedUploads, isUploading };
+}
+export {
+  useUppyUpload
+};

package/dist/web/index.d.ts

@@ -0,0 +1,22 @@
+export { createUppy, DEFAULT_FS_UPLOAD_PATH, getCedarUploadId, UPLOAD_TOKEN_HEADER, } from './createUppy.js';
+export type { BaseUppyOptions, CedarUppy, CedarUppyFile, CreateUppyOptions, FsUploadResponseBody, FsUppyOptions, PresignedUploadParameters, S3UppyOptions, } from './createUppy.js';
+export { CONFIRM_UPLOAD, CREATE_PRESIGNED_UPLOAD_URL, REQUEST_UPLOAD_TOKEN, } from './graphql.js';
+export type { ConfirmUploadData, ConfirmUploadVariables, CreatePresignedUploadUrlData, CreatePresignedUploadUrlVariables, RequestUploadTokenData, RequestUploadTokenVariables, UploadConstraints, } from './graphql.js';
+export { useUploadToken } from './hooks/useUploadToken.js';
+export type { UseUploadTokenOptions, UseUploadTokenResult, } from './hooks/useUploadToken.js';
+export { useS3Upload } from './hooks/useS3Upload.js';
+export type { UseS3UploadOptions, UseS3UploadResult, } from './hooks/useS3Upload.js';
+export { useFsUpload } from './hooks/useFsUpload.js';
+export type { UseFsUploadOptions, UseFsUploadResult, } from './hooks/useFsUpload.js';
+export { useDbUpload } from './hooks/useDbUpload.js';
+export type { DbUploadFile, UseDbUploadOptions, UseDbUploadResult, } from './hooks/useDbUpload.js';
+export type { UppyUploadCallbacks, UppyUploadResult, } from './hooks/useUppyUpload.js';
+export { UppyUploader } from './components/UppyUploader.js';
+export type { UploaderVariant, UppyUploaderProps, } from './components/UppyUploader.js';
+export { S3Uploader } from './components/S3Uploader.js';
+export type { S3UploaderProps } from './components/S3Uploader.js';
+export { FsUploader } from './components/FsUploader.js';
+export type { FsUploaderProps } from './components/FsUploader.js';
+export { DbInput } from './components/DbInput.js';
+export type { DbInputProps } from './components/DbInput.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,eAAe,EACf,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,aAAa,GACd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,cAAc,EACd,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,4BAA4B,EAC5B,iCAAiC,EACjC,sBAAsB,EACtB,2BAA2B,EAC3B,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,YAAY,EACV,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,YAAY,EACV,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,YAAY,EACV,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAC3D,YAAY,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACjD,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/web/index.js

@@ -0,0 +1,36 @@
+import {
+  createUppy,
+  DEFAULT_FS_UPLOAD_PATH,
+  getCedarUploadId,
+  UPLOAD_TOKEN_HEADER
+} from "./createUppy.js";
+import {
+  CONFIRM_UPLOAD,
+  CREATE_PRESIGNED_UPLOAD_URL,
+  REQUEST_UPLOAD_TOKEN
+} from "./graphql.js";
+import { useUploadToken } from "./hooks/useUploadToken.js";
+import { useS3Upload } from "./hooks/useS3Upload.js";
+import { useFsUpload } from "./hooks/useFsUpload.js";
+import { useDbUpload } from "./hooks/useDbUpload.js";
+import { UppyUploader } from "./components/UppyUploader.js";
+import { S3Uploader } from "./components/S3Uploader.js";
+import { FsUploader } from "./components/FsUploader.js";
+import { DbInput } from "./components/DbInput.js";
+export {
+  CONFIRM_UPLOAD,
+  CREATE_PRESIGNED_UPLOAD_URL,
+  DEFAULT_FS_UPLOAD_PATH,
+  DbInput,
+  FsUploader,
+  REQUEST_UPLOAD_TOKEN,
+  S3Uploader,
+  UPLOAD_TOKEN_HEADER,
+  UppyUploader,
+  createUppy,
+  getCedarUploadId,
+  useDbUpload,
+  useFsUpload,
+  useS3Upload,
+  useUploadToken
+};

package/dist/webhooks/s3.d.ts

@@ -0,0 +1,52 @@
+import type { StorageTargets, UploadDatabase } from '../types.js';
+import type { FetchCertificate } from './sns.js';
+/** The parts of an S3 event notification record this handler reads. */
+export interface S3EventRecord {
+    eventName: string;
+    s3: {
+        bucket: {
+            name: string;
+        };
+        object: {
+            key: string;
+            size?: number;
+        };
+    };
+}
+export interface S3Event {
+    Records: S3EventRecord[];
+}
+export type S3EventOutcome = 'completed' | 'failed' | 'ignored' | 'not-found' | 'no-target';
+/**
+ * Settles the `pending` row for one `s3:ObjectCreated:*` record. The row is
+ * matched on target plus storage key, the object's size is compared with
+ * the size authorized at presign time, and the row is flipped `pending` to
+ * `completed` (or claimed `failed` and the object deleted on a mismatch).
+ * Both transitions are conditional, so a duplicate notification or a row
+ * the cleanup job already claimed is left alone.
+ */
+export declare function processS3EventRecord(record: S3EventRecord, { db, targets }: {
+    db: UploadDatabase;
+    targets: StorageTargets;
+}): Promise<S3EventOutcome>;
+export interface S3WebhookOptions {
+    db: UploadDatabase;
+    targets: StorageTargets;
+    /** The trusted SNS topic. Messages from any other topic are rejected. */
+    topicArn: string;
+    fetchCertificate?: FetchCertificate;
+    /** Used to confirm subscriptions. Defaults to global `fetch`. */
+    fetch?: typeof fetch;
+}
+export interface S3WebhookResult {
+    type: 'Notification' | 'SubscriptionConfirmation' | 'UnsubscribeConfirmation';
+    outcomes: S3EventOutcome[];
+}
+/**
+ * Handles one SNS delivery carrying S3 event notifications: verifies the
+ * signature and topic, confirms subscriptions, and settles every
+ * `ObjectCreated` record. Throws an `UploadError` for anything that must be
+ * rejected; the plugin turns that into the HTTP status.
+ */
+export declare function handleS3Webhook(rawBody: string, options: S3WebhookOptions): Promise<S3WebhookResult>;
+//# sourceMappingURL=s3.d.ts.map

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

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

package/dist/webhooks/s3.js

@@ -0,0 +1,122 @@
+import { UploadError } from "../errors.js";
+import {
+  assertTrustedSnsUrl,
+  isSnsMessage,
+  SNS_FETCH_TIMEOUT_MS,
+  verifySnsMessage
+} from "./sns.js";
+function isS3Event(value) {
+  if (typeof value !== "object" || value === null || !("Records" in value)) {
+    return false;
+  }
+  const records = value.Records;
+  return Array.isArray(records) && records.every(
+    (r) => typeof r === "object" && r !== null && typeof r.eventName === "string" && typeof r.s3?.bucket?.name === "string" && typeof r.s3?.object?.key === "string"
+  );
+}
+function matchTarget(targets, bucket, key) {
+  let best = null;
+  for (const [name, target] of Object.entries(targets)) {
+    if (target.providerType !== "s3") {
+      continue;
+    }
+    const config = target.getConfig();
+    const keyPrefix = typeof config.keyPrefix === "string" ? config.keyPrefix : "";
+    if (config.bucket === bucket && key.startsWith(keyPrefix) && (!best || keyPrefix.length > best.keyPrefix.length)) {
+      best = { name, keyPrefix };
+    }
+  }
+  return best ? { name: best.name, storageKey: key.slice(best.keyPrefix.length) } : null;
+}
+async function processS3EventRecord(record, { db, targets }) {
+  if (!record.eventName.startsWith("ObjectCreated")) {
+    return "ignored";
+  }
+  const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, " "));
+  const match = matchTarget(targets, record.s3.bucket.name, key);
+  if (!match) {
+    return "no-target";
+  }
+  const upload = await db.upload.findFirst({
+    where: {
+      target: match.name,
+      storageKey: match.storageKey,
+      status: "pending"
+    },
+    omit: { data: true }
+  });
+  if (!upload) {
+    return "not-found";
+  }
+  const target = targets[match.name];
+  const reportedSize = record.s3.object.size;
+  const actualSize = typeof reportedSize === "number" ? reportedSize : await target.getObjectSize(match.storageKey);
+  if (actualSize === null || BigInt(actualSize) !== upload.size) {
+    const { count: count2 } = await db.upload.updateMany({
+      where: { id: upload.id, status: "pending" },
+      data: { status: "failed" }
+    });
+    if (count2 === 1) {
+      await target.delete(match.storageKey);
+    }
+    return "failed";
+  }
+  const { count } = await db.upload.updateMany({
+    where: { id: upload.id, status: "pending" },
+    data: { status: "completed", size: BigInt(actualSize) }
+  });
+  return count === 1 ? "completed" : "ignored";
+}
+async function handleS3Webhook(rawBody, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    throw new UploadError("INVALID_KEY", "Webhook body is not JSON.");
+  }
+  if (!isSnsMessage(parsed)) {
+    throw new UploadError("INVALID_KEY", "Webhook body is not an SNS message.");
+  }
+  await verifySnsMessage(parsed, {
+    topicArn: options.topicArn,
+    fetchCertificate: options.fetchCertificate
+  });
+  if (parsed.Type === "SubscriptionConfirmation") {
+    if (!parsed.SubscribeURL) {
+      throw new UploadError("INVALID_KEY", "Missing SubscribeURL.");
+    }
+    assertTrustedSnsUrl(parsed.SubscribeURL);
+    const doFetch = options.fetch ?? fetch;
+    const res = await doFetch(parsed.SubscribeURL, {
+      signal: AbortSignal.timeout(SNS_FETCH_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      throw new UploadError(
+        "CONFIGURATION",
+        `Could not confirm the SNS subscription (HTTP ${res.status}).`
+      );
+    }
+    return { type: parsed.Type, outcomes: [] };
+  }
+  if (parsed.Type === "UnsubscribeConfirmation") {
+    return { type: parsed.Type, outcomes: [] };
+  }
+  let event;
+  try {
+    event = JSON.parse(parsed.Message);
+  } catch {
+    throw new UploadError("INVALID_KEY", "SNS message is not an S3 event.");
+  }
+  if (!isS3Event(event)) {
+    return { type: parsed.Type, outcomes: [] };
+  }
+  const outcomes = [];
+  for (const record of event.Records) {
+    outcomes.push(await processS3EventRecord(record, options));
+  }
+  return { type: parsed.Type, outcomes };
+}
+export {
+  handleS3Webhook,
+  processS3EventRecord
+};

package/dist/webhooks/sns.d.ts

@@ -0,0 +1,34 @@
+/** An Amazon SNS HTTP(S) delivery, as posted to a subscribed endpoint. */
+export interface SnsMessage {
+    Type: 'Notification' | 'SubscriptionConfirmation' | 'UnsubscribeConfirmation';
+    MessageId: string;
+    TopicArn: string;
+    Message: string;
+    Timestamp: string;
+    SignatureVersion: string;
+    Signature: string;
+    SigningCertURL: string;
+    Subject?: string;
+    SubscribeURL?: string;
+    Token?: string;
+}
+/** Deadline for the outbound calls the webhook makes to SNS. */
+export declare const SNS_FETCH_TIMEOUT_MS = 10000;
+export declare function isSnsMessage(value: unknown): value is SnsMessage;
+/** Only `https://sns.<region>.amazonaws.com/...` may supply a signing cert. */
+export declare function assertTrustedSnsUrl(url: string): void;
+/** Builds the canonical string SNS signed, per the SNS signature spec. */
+export declare function snsStringToSign(message: SnsMessage): string;
+export type FetchCertificate = (url: string) => Promise<string>;
+export interface VerifySnsMessageOptions {
+    /** The only topic whose messages are accepted. */
+    topicArn: string;
+    fetchCertificate?: FetchCertificate;
+}
+/**
+ * Verifies an SNS message's signature against the certificate it names and
+ * requires its `TopicArn` to exactly match the configured topic. A validly
+ * signed message from any other topic is rejected.
+ */
+export declare function verifySnsMessage(message: SnsMessage, { topicArn, fetchCertificate, }: VerifySnsMessageOptions): Promise<void>;
+//# sourceMappingURL=sns.d.ts.map