Add support for fingerprint generation in FileSource classes

lib/browser/BrowserFileReader.ts

@@ -6,7 +6,7 @@ import {
   supportedTypes as supportedBaseTypes,
 } from '../commonFileReader.js'
 import type { FileReader, FileSource, UploadInput } from '../options.js'
-import { BlobFileSource } from '../sources/BlobFileSource.js'
+import { ReactNativeFileSource } from "../sources/ReactNativeFileSource.js";
 
 export class BrowserFileReader implements FileReader {
   async openFile(input: UploadInput, chunkSize: number): Promise<FileSource> {
@@ -20,8 +20,7 @@ export class BrowserFileReader implements FileReader {
       }
 
       try {
-        const blob = await uriToBlob(input.uri)
-        return new BlobFileSource(blob)
+        return new ReactNativeFileSource(input)
       } catch (err) {
         throw new Error(
           `tus: cannot fetch \`file.uri\` as Blob, make sure the uri is correct and accessible. ${err}`,

lib/browser/fileSignature.ts

@@ -1,13 +1,9 @@
 import type { ReactNativeFile, UploadInput, UploadOptions } from '../options.js'
-import { isReactNativeFile, isReactNativePlatform } from '../reactnative/isReactNative.js'
 
 /**
  * Generate a fingerprint for a file which will be used the store the endpoint
  */
 export function fingerprint(file: UploadInput, options: UploadOptions) {
-  if (isReactNativePlatform() && isReactNativeFile(file)) {
-    return Promise.resolve(reactNativeFingerprint(file, options))
-  }
 
   if (file instanceof Blob) {
     return Promise.resolve(
@@ -19,24 +15,3 @@ export function fingerprint(file: UploadInput, options: UploadOptions) {
 
   return Promise.resolve(null)
 }
-
-function reactNativeFingerprint(file: ReactNativeFile, options: UploadOptions): string {
-  const exifHash = file.exif ? hashCode(JSON.stringify(file.exif)) : 'noexif'
-  return ['tus-rn', file.name || 'noname', file.size || 'nosize', exifHash, options.endpoint].join(
-    '/',
-  )
-}
-
-function hashCode(str: string): number {
-  // from https://stackoverflow.com/a/8831937/151666
-  let hash = 0
-  if (str.length === 0) {
-    return hash
-  }
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i)
-    hash = (hash << 5) - hash + char
-    hash &= hash // Convert to 32bit integer
-  }
-  return hash
-}

lib/node/sources/NodeStreamFileSource.ts

@@ -1,5 +1,5 @@
-import type { Readable } from 'node:stream'
-import type { FileSource } from '../../options.js'
+import { Readable, Transform } from 'node:stream'
+import type { FileSource, UploadOptions } from '../../options.js'
 
 /**
  * readChunk reads a chunk with the given size from the given
@@ -74,9 +74,16 @@ export class NodeStreamFileSource implements FileSource {
     })
   }
 
+  // TODO: Implement fingerprint calculation for NodeStreamFileSource.
+  // This should likely involve reading the stream and creating a hash/checksum
+  // while preserving the stream's content for later use.
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    throw new Error("fingerprint not implemented for NodeStreamFileSource")
+  }
+
   async slice(start: number, end: number) {
     // Fail fast if the caller requests a proportion of the data which is not
-    // available any more.
+    // available anymore.
     if (start < this._bufPos) {
       throw new Error('cannot slice from position which we already seeked away')
     }

lib/node/sources/PathFileSource.ts

@@ -1,5 +1,5 @@
-import { type ReadStream, createReadStream, promises as fsPromises } from 'node:fs'
-import type { FileSource, PathReference } from '../../options.js'
+import { createReadStream, promises as fsPromises, type ReadStream } from 'node:fs'
+import type { FileSource, PathReference, UploadOptions } from '../../options.js'
 
 export async function getFileSourceFromPath(file: PathReference): Promise<PathFileSource> {
   const path = file.path.toString()
@@ -34,6 +34,14 @@ export class PathFileSource implements FileSource {
     this.size = size
   }
 
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    if (typeof options.fingerprint === 'function') {
+      return Promise.resolve(options.fingerprint(this._file, options))
+    }
+
+    return Promise.resolve([this._file, this.size, this._path, options.endpoint, options.projectId].join('-'))
+  }
+
   slice(start: number, end: number) {
     // TODO: Does this create multiple file descriptors? Can we reduce this by
     // using a file handle instead?

lib/options.ts

@@ -23,7 +23,7 @@ export interface ReactNativeFile {
 /**
  * PathReference is a reference to a file on disk. Currently, it's only supported
  * in Node.js. It can be supplied as a normal object or as an instance of `fs.ReadStream`,
- * which also statisfies this interface.
+ * which also satisfies this interface.
  *
  * Optionally, a start and/or end position can be defined to define a range of bytes from
  * the file that should be uploaded instead of the entire file. Both start and end are
@@ -51,6 +51,8 @@ export type UploadInput =
 export interface UploadOptions {
   endpoint?: string
 
+  projectId?: string
+
   uploadUrl?: string
   metadata: { [key: string]: string }
   metadataForPartialUploads: UploadOptions['metadata']
@@ -117,6 +119,7 @@ export interface FileSource {
   size: number | null
   slice(start: number, end: number): Promise<SliceResult>
   close(): void
+  fingerprint(options: UploadOptions): Promise<string | null>
 }
 
 // TODO: Allow Web Streams' ReadableStream as well

lib/sources/ArrayBufferViewFileSource.ts

@@ -1,4 +1,4 @@
-import type { FileSource, SliceResult } from '../options.js'
+import type { FileSource, SliceResult, UploadOptions } from '../options.js'
 
 /**
  * ArrayBufferViewFileSource implements FileSource for ArrayBufferView instances
@@ -8,7 +8,7 @@ import type { FileSource, SliceResult } from '../options.js'
  * or it will lead to weird behavior.
  */
 export class ArrayBufferViewFileSource implements FileSource {
-  private _view: ArrayBufferView
+  private readonly _view: ArrayBufferView
 
   size: number
 
@@ -17,6 +17,12 @@ export class ArrayBufferViewFileSource implements FileSource {
     this.size = view.byteLength
   }
 
+  // TODO: Consider implementing a fingerprint function that uses a checksum/hash of the ArrayBufferView data
+  // TODO: Could also include byteOffset, byteLength and buffer.byteLength in fingerprint calculation
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    return Promise.resolve(null);
+  }
+
   slice(start: number, end: number): Promise<SliceResult> {
     const buffer = this._view.buffer
     const startInBuffer = this._view.byteOffset + start

lib/sources/BlobFileSource.ts

@@ -1,12 +1,12 @@
 import { isCordova } from '../cordova/isCordova.js'
 import { readAsByteArray } from '../cordova/readAsByteArray.js'
-import type { FileSource, SliceResult } from '../options.js'
+import type { FileSource, SliceResult, UploadOptions } from '../options.js'
 
 /**
  * BlobFileSource implements FileSource for Blobs (and therefore also for File instances).
  */
 export class BlobFileSource implements FileSource {
-  private _file: Blob
+  private readonly _file: Blob
 
   size: number
 
@@ -15,6 +15,24 @@ export class BlobFileSource implements FileSource {
     this.size = file.size
   }
 
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    if (typeof options.fingerprint === 'function') {
+      return Promise.resolve(options.fingerprint(this._file, options));
+    }
+
+    let name, lastModified;
+    const projectId = options.projectId || 'defaultProjectId';
+    if (this._file instanceof File) {
+      name = this._file.name;
+      lastModified = this._file.lastModified;
+    } else {
+      name = 'blob';
+      lastModified = 0;
+    }
+
+    return Promise.resolve(['tus-br', name, this._file.type, this._file.size, lastModified, options.endpoint, projectId].join('-'));
+  }
+
   async slice(start: number, end: number): Promise<SliceResult> {
     // TODO: This looks fishy. We should test how this actually works in Cordova
     // and consider moving this into the lib/cordova/ directory.

lib/sources/ReactNativeFileSource.ts

@@ -0,0 +1,55 @@
+import { FileSource, ReactNativeFile, SliceResult, UploadOptions } from "../options.js";
+
+export class ReactNativeFileSource implements FileSource {
+  private readonly _file: ReactNativeFile
+  size: number;
+
+  constructor(file: ReactNativeFile) {
+    this._file = file
+    this.size = Number(file.size)
+  }
+
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    if (typeof options.fingerprint === 'function') {
+      return Promise.resolve(options.fingerprint(this._file, options))
+    }
+
+    return Promise.resolve(this.reactNativeFingerprint(this._file, options))
+  }
+
+  // TODO: Implement the slice method to read file content from start to end positions
+  // The implementation should:
+  // 1. Read the file content from the ReactNative file URI
+  // 2. Return the sliced content as value
+  // 3. Calculate proper size and done values
+  async slice(start: number, end: number): Promise<SliceResult> {
+    let value = null, size = null, done = true;
+
+    return { value, size, done }
+  }
+
+  close(): void {
+    // Nothing to do here since we don't need to release any resources.
+  }
+
+  private reactNativeFingerprint(file: ReactNativeFile, options: UploadOptions): string {
+    const exifHash = file.exif ? this.hashCode(JSON.stringify(file.exif)) : 'noexif'
+    return ['tus-rn', file.name || 'noname', file.size || 'nosize', exifHash, options.endpoint].join(
+        '/',
+    )
+  }
+
+  private hashCode(str: string): number {
+    // from https://stackoverflow.com/a/8831937/151666
+    let hash = 0
+    if (str.length === 0) {
+      return hash
+    }
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i)
+      hash = (hash << 5) - hash + char
+      hash &= hash // Convert to 32bit integer
+    }
+    return hash
+  }
+}

lib/sources/WebStreamFileSource.ts

@@ -1,4 +1,4 @@
-import type { FileSource, SliceResult } from '../options.js'
+import type {FileSource, SliceResult, UploadOptions} from '../options.js'
 
 function len(blobOrArray: WebStreamFileSource['_buffer']): number {
   if (blobOrArray === undefined) return 0
@@ -28,7 +28,7 @@ function concat<T extends WebStreamFileSource['_buffer']>(a: T, b: T): T {
  */
 // TODO: Can we share code with NodeStreamFileSource?
 export class WebStreamFileSource implements FileSource {
-  private _reader: ReadableStreamDefaultReader<Uint8Array>
+  private readonly _reader: ReadableStreamDefaultReader<Uint8Array>
 
   private _buffer: Blob | Uint8Array | undefined
 
@@ -39,6 +39,8 @@ export class WebStreamFileSource implements FileSource {
 
   private _done = false
 
+  private _stream: ReadableStream
+
   // Setting the size to null indicates that we have no calculation available
   // for how much data this stream will emit requiring the user to specify
   // it manually (see the `uploadSize` option).
@@ -50,10 +52,14 @@ export class WebStreamFileSource implements FileSource {
         'Readable stream is already locked to reader. tus-js-client cannot obtain a new reader.',
       )
     }
-
+    this._stream = stream
     this._reader = stream.getReader()
   }
 
+  fingerprint(options: UploadOptions): Promise<string | null> {
+    return Promise.resolve(null);
+  }
+
   async slice(start: number, end: number): Promise<SliceResult> {
     if (start < this._bufferOffset) {
       throw new Error("Requested data is before the reader's current offset")

lib/upload.ts

@@ -71,7 +71,7 @@ export class BaseUpload {
   // The fingerpinrt for the current file (set after start())
   private _fingerprint: string | null = null
 
-  // The key that the URL storage returned when saving an URL with a fingerprint,
+  // The key that the URL storage returned when saving a URL with a fingerprint,
   private _urlStorageKey?: string
 
   // The offset used in the current PATCH request
@@ -223,7 +223,10 @@ export class BaseUpload {
   }
 
   private async _prepareAndStartUpload(): Promise<void> {
-    this._fingerprint = await this.options.fingerprint(this.file, this.options)
+    if (this._source == null) {
+      this._source = await this.options.fileReader.openFile(this.file, this.options.chunkSize)
+    }
+    this._fingerprint = await this._source.fingerprint(this.options);
     if (this._fingerprint == null) {
       log(
         'No fingerprint was calculated meaning that the upload cannot be stored in the URL storage.',
@@ -232,10 +235,6 @@ export class BaseUpload {
       log(`Calculated fingerprint: ${this._fingerprint}`)
     }
 
-    if (this._source == null) {
-      this._source = await this.options.fileReader.openFile(this.file, this.options.chunkSize)
-    }
-
     // First, we look at the uploadLengthDeferred option.
     // Next, we check if the caller has supplied a manual upload size.
     // Finally, we try to use the calculated size from the source object.
@@ -1218,5 +1217,6 @@ export async function terminate(url: string, options: UploadOptions): Promise<vo
 
     await wait(delay)
     await terminate(url, newOptions)
+
   }
 }