move config from requests

Author: rwv

src/get/config/Config.ts

@@ -0,0 +1,41 @@
+import { defaultConfig } from './default'
+import type { FastFetchGetConfig, FetchInput, ChunkCallback, SegmentStrategy, Logger, SelectRangeStrategy } from './types'
+
+export class Config {
+  readonly config: FastFetchGetConfig
+
+  constructor (config: FastFetchGetConfig) {
+    this.config = config
+  }
+
+  get maxRetries (): number {
+    return this.config.maxRetries ?? defaultConfig.maxRetries
+  }
+
+  get retryDelay (): number {
+    return this.config.retryDelay ?? defaultConfig.retryDelay
+  }
+
+  get chunkCallback (): ChunkCallback {
+    return this.config.chunkCallback ?? defaultConfig.chunkCallback
+  }
+
+  get segmentStrategy (): SegmentStrategy {
+    return this.config.segmentStrategy ?? defaultConfig.segmentStrategy
+  }
+
+  get selectRangeStrategy (): SelectRangeStrategy {
+    return this.config.selectRangeStrategy ?? defaultConfig.selectRangeStrategy
+  }
+
+  get logger (): Logger {
+    return {
+      ...defaultConfig.logger,
+      ...this.config.logger
+    }
+  }
+
+  get mirrorURLs (): FetchInput[] {
+    return this.config.mirrorURLs ?? []
+  }
+}

src/get/request/defaultConfig.ts renamed to src/get/config/default.ts

@@ -1,11 +1,19 @@
 import { defaultSelectRangeStrategy } from '../range/selectRangeStrategy'
 import { defaultSegmentStrategy } from '../range/segmentStrategy'
 
+const placeholder = (): void => {}
+
 export const defaultConfig = {
+  mirrorURLs: [],
   maxRetries: 5,
   retryDelay: 3000,
-  sequential: false,
   chunkCallback: () => undefined,
   selectRangeStrategy: defaultSelectRangeStrategy,
-  segmentStrategy: defaultSegmentStrategy
+  segmentStrategy: defaultSegmentStrategy,
+  logger: {
+    info: placeholder,
+    error: placeholder,
+    debug: placeholder,
+    warning: placeholder
+  }
 } as const

src/get/config/index.ts

@@ -0,0 +1,2 @@
+export type { FastFetchGetConfig, FetchInput, ChunkCallback, SegmentStrategy, Logger, SelectRangeStrategy } from './types'
+export { Config } from './Config'

src/get/config/types.ts

@@ -0,0 +1,22 @@
+export interface Logger {
+  info: (message: string) => void
+  error: (message: string) => void
+  debug: (message: string) => void
+  warning: (message: string) => void
+}
+
+type FetchParams = Parameters<typeof fetch>
+export type FetchInput = FetchParams[0]
+export type ChunkCallback = (chunk: Blob, range: [number, number], input: FetchInput) => void
+export type SegmentStrategy = (contentLength: number) => Array<[number, number]>
+export type SelectRangeStrategy = (downloaderCounter: Map<number, number>) => number
+
+export interface FastFetchGetConfig {
+  mirrorURLs?: FetchInput[]
+  maxRetries?: number
+  retryDelay?: number
+  logger?: Partial<Logger>
+  chunkCallback?: ChunkCallback
+  segmentStrategy?: SegmentStrategy
+  selectRangeStrategy?: SelectRangeStrategy
+}

src/get/get.ts

@@ -10,14 +10,14 @@ export async function GET (input: FetchInput, init?: GETInit): Promise<Response>
 
     if (metadata.status !== 200) {
       const message = `Status code is not 200: ${metadata.status}`
-      requestConfig.logger.error(message)
+      requestConfig.config.logger.error(message)
       throw new Error(message)
     }
 
     const manager = new DownloadManger(requestConfig, metadata)
     return manager.response
   } catch {
-    requestConfig.logger.error('Fallback to normal fetch')
+    requestConfig.config.logger.error('Fallback to normal fetch')
     // fallback to normal fetch
     return await fetch(input, init)
   }

src/get/index.ts

@@ -1,2 +1,3 @@
 export { GET } from './get'
-export type { GETInit, FastFetchGetConfig } from './request'
+export type { GETInit } from './request'
+export type { FastFetchGetConfig } from './config'

src/get/manager/DownloadManger.ts

@@ -21,11 +21,11 @@ export class DownloadManger {
     this.workers = workerInputs.map(
       (input) => new DownloadWorker(input, requestConfig)
     )
-    requestConfig.logger.info(`Workers Count: ${this.workers.length}`)
+    requestConfig.config.logger.info(`Workers Count: ${this.workers.length}`)
 
     const contentLength = getContentLength(metadata.headers)
-    this.rangeProvider = new RangeProvider(contentLength, this.requestConfig.segmentStrategy, this.requestConfig.selectRangeStrategy)
-    requestConfig.logger.info(`Content length: ${contentLength}`)
+    this.rangeProvider = new RangeProvider(contentLength, this.requestConfig.config.segmentStrategy, this.requestConfig.config.selectRangeStrategy)
+    requestConfig.config.logger.info(`Content length: ${contentLength}`)
 
     this.streamer = new DownloadStreamer(this.rangeProvider.maxRangeIndex, requestConfig?.init?.signal)
 
@@ -35,16 +35,16 @@ export class DownloadManger {
 
   // start fetching
   private async startFetching (): Promise<void> {
-    this.requestConfig.logger.info('Start fetching.')
+    this.requestConfig.config.logger.info('Start fetching.')
 
     const promises = this.workers.map(async (worker, idx) =>
       await this.assignWorkToWorker(worker, idx)
     )
     try {
       await Promise.any(promises)
-      this.requestConfig.logger.info('Fetching done.')
+      this.requestConfig.config.logger.info('Fetching done.')
     } catch {
-      this.requestConfig.logger.error('All workers failed, stream aborted.')
+      this.requestConfig.config.logger.error('All workers failed, stream aborted.')
       // all workers failed
       this.streamer.abort('All workers failed')
     }
@@ -73,13 +73,13 @@ export class DownloadManger {
           })
         }
 
-        this.requestConfig.logger.debug(
+        this.requestConfig.config.logger.debug(
           `Worker ${workerIndex} is fetching range ${rangeIndex}.`
         )
         const blob = await worker.download(range, workSignal)
-        this.requestConfig.chunkCallback(blob, range, worker.input)
+        this.requestConfig.config.chunkCallback(blob, range, worker.input)
 
-        this.requestConfig.logger.debug(
+        this.requestConfig.config.logger.debug(
           `Worker ${workerIndex} fetched range ${rangeIndex} successfully.`
         )
 
@@ -90,12 +90,12 @@ export class DownloadManger {
       } catch (e) {
         if ((e as DOMException)?.name !== 'AbortError') {
           // worker failed other than AbortError
-          this.requestConfig.logger.error(
+          this.requestConfig.config.logger.error(
             `Worker ${workerIndex} failed to fetch range ${rangeIndex}: ${(e as DOMException).message}.`
           )
           currentRetry += 1
-          if (currentRetry > this.requestConfig.maxRetries) {
-            this.requestConfig.logger.error(
+          if (currentRetry > this.requestConfig.config.maxRetries) {
+            this.requestConfig.config.logger.error(
               `Worker ${workerIndex} failed to fetch range ${rangeIndex} after ${currentRetry} retries.`
             )
             throw new Error(`Worker ${workerIndex} failed to fetch range after retries ${currentRetry}`)
@@ -104,7 +104,7 @@ export class DownloadManger {
           this.rangeProvider.removeDownloader(rangeIndex)
 
           // sleep for retryDelay
-          await new Promise((resolve) => setTimeout(resolve, this.requestConfig.retryDelay))
+          await new Promise((resolve) => setTimeout(resolve, this.requestConfig.config.retryDelay))
           continue
         }
 

src/get/request/RequestConfig.ts

@@ -1,52 +1,18 @@
-import type { FetchInput, GETInit, FastFetchGetConfig, ChunkCallback } from './types'
-import type { Logger } from '../logger'
-import { defaultConfig } from './defaultConfig'
+import type { FetchInput, GETInit } from './types'
+import { Config } from '../config'
 
 export class GETRequestConfig {
   readonly input: FetchInput
   readonly init: GETInit
+  readonly config: Config
 
   constructor (input: FetchInput, init: GETInit) {
     this.input = input
     this.init = init
+    this.config = new Config(init?.fastFetch ?? {})
   }
 
   get inputs (): FetchInput[] {
-    return [this.input, ...(this.init?.fastFetch?.mirrorURLs ?? [])]
-  }
-
-  private get fastFetchConfig (): FastFetchGetConfig | undefined {
-    return this.init?.fastFetch
-  }
-
-  get logger (): Logger {
-    const placeholder = (): void => {}
-
-    return {
-      info: this.fastFetchConfig?.logger?.info ?? placeholder,
-      error: this.fastFetchConfig?.logger?.error ?? placeholder,
-      debug: this.fastFetchConfig?.logger?.debug ?? placeholder,
-      warning: this.fastFetchConfig?.logger?.warning ?? placeholder
-    }
-  }
-
-  get maxRetries (): number {
-    return this.fastFetchConfig?.maxRetries ?? defaultConfig.maxRetries
-  }
-
-  get retryDelay (): number {
-    return this.fastFetchConfig?.retryDelay ?? defaultConfig.retryDelay
-  }
-
-  get chunkCallback (): ChunkCallback {
-    return this.fastFetchConfig?.chunkCallback ?? defaultConfig.chunkCallback
-  }
-
-  get segmentStrategy (): ((contentLength: number) => Array<[number, number]>) {
-    return this.fastFetchConfig?.segmentStrategy ?? defaultConfig.segmentStrategy
-  }
-
-  get selectRangeStrategy (): ((downloaderCounter: Map<number, number>) => number) {
-    return this.fastFetchConfig?.selectRangeStrategy ?? defaultConfig.selectRangeStrategy
+    return [this.input, ...(this.config.mirrorURLs)]
   }
 }

src/get/request/index.ts

@@ -1,2 +1,2 @@
 export { GETRequestConfig } from './RequestConfig'
-export type { GETInit, FetchInput, FastFetchGetConfig } from './types'
+export type { GETInit, FetchInput } from './types'

src/get/request/types.ts

@@ -1,18 +1,7 @@
-import type { Logger } from '../logger'
+import type { FastFetchGetConfig } from '../config'
 
 type FetchParams = Parameters<typeof fetch>
 export type FetchInput = FetchParams[0]
-export type ChunkCallback = (chunk: Blob, range: [number, number], input: FetchInput) => void
-
-export interface FastFetchGetConfig {
-  mirrorURLs?: FetchInput[]
-  maxRetries?: number
-  retryDelay?: number
-  logger?: Partial<Logger>
-  chunkCallback?: ChunkCallback
-  segmentStrategy?: (contentLength: number) => Array<[number, number]>
-  selectRangeStrategy?: (downloaderCounter: Map<number, number>) => number
-}
 
 interface FastFetchGETInit {
   fastFetch?: FastFetchGetConfig