wrangler 0.0.0-e88a54e → 0.0.0-e8a2a1d9

package/vendor/@cloudflare/kv-asset-handler/src/index.ts

@@ -1,296 +0,0 @@
-import * as mime from 'mime'
-import { Options, CacheControl, MethodNotAllowedError, NotFoundError, InternalError } from './types'
-
-declare global {
-  var __STATIC_CONTENT: any, __STATIC_CONTENT_MANIFEST: string
-}
-
-const defaultCacheControl: CacheControl = {
-  browserTTL: null,
-  edgeTTL: 2 * 60 * 60 * 24, // 2 days
-  bypassCache: false, // do not bypass Cloudflare's cache
-}
-
-function assignOptions(options?: Partial<Options>): Options {
-  // Assign any missing options passed in to the default
-  // options.mapRequestToAsset is handled manually later
-  return Object.assign(
-    {
-      ASSET_NAMESPACE: __STATIC_CONTENT,
-      ASSET_MANIFEST: __STATIC_CONTENT_MANIFEST,
-      cacheControl: defaultCacheControl,
-      defaultMimeType: 'text/plain',
-      defaultDocument: 'index.html',
-    },
-    options,
-  )
-}
-
-/**
- * maps the path of incoming request to the request pathKey to look up
- * in bucket and in cache
- * e.g.  for a path '/' returns '/index.html' which serves
- * the content of bucket/index.html
- * @param {Request} request incoming request
- */
-const mapRequestToAsset = (request: Request, options?: Partial<Options>) => {
-  options = assignOptions(options)
-
-  const parsedUrl = new URL(request.url)
-  let pathname = parsedUrl.pathname
-
-  if (pathname.endsWith('/')) {
-    // If path looks like a directory append options.defaultDocument
-    // e.g. If path is /about/ -> /about/index.html
-    pathname = pathname.concat(options.defaultDocument)
-  } else if (!mime.getType(pathname)) {
-    // If path doesn't look like valid content
-    //  e.g. /about.me ->  /about.me/index.html
-    pathname = pathname.concat('/' + options.defaultDocument)
-  }
-
-  parsedUrl.pathname = pathname
-  return new Request(parsedUrl.toString(), request)
-}
-
-/**
- * maps the path of incoming request to /index.html if it evaluates to
- * any HTML file.
- * @param {Request} request incoming request
- */
-function serveSinglePageApp(request: Request, options?: Partial<Options>): Request {
-  options = assignOptions(options)
-
-  // First apply the default handler, which already has logic to detect
-  // paths that should map to HTML files.
-  request = mapRequestToAsset(request, options)
-
-  const parsedUrl = new URL(request.url)
-
-  // Detect if the default handler decided to map to
-  // a HTML file in some specific directory.
-  if (parsedUrl.pathname.endsWith('.html')) {
-    // If expected HTML file was missing, just return the root index.html (or options.defaultDocument)
-    return new Request(`${parsedUrl.origin}/${options.defaultDocument}`, request)
-  } else {
-    // The default handler decided this is not an HTML page. It's probably
-    // an image, CSS, or JS file. Leave it as-is.
-    return request
-  }
-}
-
-/**
- * takes the path of the incoming request, gathers the appropriate content from KV, and returns
- * the response
- *
- * @param {FetchEvent} event the fetch event of the triggered request
- * @param {{mapRequestToAsset: (string: Request) => Request, cacheControl: {bypassCache:boolean, edgeTTL: number, browserTTL:number}, ASSET_NAMESPACE: any, ASSET_MANIFEST:any}} [options] configurable options
- * @param {CacheControl} [options.cacheControl] determine how to cache on Cloudflare and the browser
- * @param {typeof(options.mapRequestToAsset)} [options.mapRequestToAsset]  maps the path of incoming request to the request pathKey to look up
- * @param {Object | string} [options.ASSET_NAMESPACE] the binding to the namespace that script references
- * @param {any} [options.ASSET_MANIFEST] the map of the key to cache and store in KV
- * */
-const getAssetFromKV = async (event: FetchEvent, options?: Partial<Options>): Promise<Response> => {
-  options = assignOptions(options)
-
-  const request = event.request
-  const ASSET_NAMESPACE = options.ASSET_NAMESPACE
-  const ASSET_MANIFEST =
-    typeof options.ASSET_MANIFEST === 'string'
-      ? JSON.parse(options.ASSET_MANIFEST)
-      : options.ASSET_MANIFEST
-
-  if (typeof ASSET_NAMESPACE === 'undefined') {
-    throw new InternalError(`there is no KV namespace bound to the script`)
-  }
-
-  const rawPathKey = new URL(request.url).pathname.replace(/^\/+/, '') // strip any preceding /'s
-  let pathIsEncoded = false
-  let requestKey
-  // if options.mapRequestToAsset is explicitly passed in, always use it and assume user has own intentions
-  // otherwise handle request as normal, with default mapRequestToAsset below
-  if (options.mapRequestToAsset) {
-    requestKey = options.mapRequestToAsset(request)
-  } else if (ASSET_MANIFEST[rawPathKey]) {
-    requestKey = request
-  } else if (ASSET_MANIFEST[decodeURIComponent(rawPathKey)]) {
-    pathIsEncoded = true
-    requestKey = request
-  } else {
-    const mappedRequest = mapRequestToAsset(request)
-    const mappedRawPathKey = new URL(mappedRequest.url).pathname.replace(/^\/+/, '')
-    if (ASSET_MANIFEST[decodeURIComponent(mappedRawPathKey)]) {
-      pathIsEncoded = true
-      requestKey = mappedRequest
-    } else {
-      // use default mapRequestToAsset
-      requestKey = mapRequestToAsset(request, options)
-    }
-  }
-
-  const SUPPORTED_METHODS = ['GET', 'HEAD']
-  if (!SUPPORTED_METHODS.includes(requestKey.method)) {
-    throw new MethodNotAllowedError(`${requestKey.method} is not a valid request method`)
-  }
-
-  const parsedUrl = new URL(requestKey.url)
-  const pathname = pathIsEncoded ? decodeURIComponent(parsedUrl.pathname) : parsedUrl.pathname // decode percentage encoded path only when necessary
-
-  // pathKey is the file path to look up in the manifest
-  let pathKey = pathname.replace(/^\/+/, '') // remove prepended /
-
-  // @ts-ignore
-  const cache = caches.default
-  let mimeType = mime.getType(pathKey) || options.defaultMimeType
-  if (mimeType.startsWith('text') || mimeType === 'application/javascript') {
-    mimeType += '; charset=utf-8'
-  }
-
-  let shouldEdgeCache = false // false if storing in KV by raw file path i.e. no hash
-  // check manifest for map from file path to hash
-  if (typeof ASSET_MANIFEST !== 'undefined') {
-    if (ASSET_MANIFEST[pathKey]) {
-      pathKey = ASSET_MANIFEST[pathKey]
-      // if path key is in asset manifest, we can assume it contains a content hash and can be cached
-      shouldEdgeCache = true
-    }
-  }
-
-  // TODO this excludes search params from cache, investigate ideal behavior
-  let cacheKey = new Request(`${parsedUrl.origin}/${pathKey}`, request)
-
-  // if argument passed in for cacheControl is a function then
-  // evaluate that function. otherwise return the Object passed in
-  // or default Object
-  const evalCacheOpts = (() => {
-    switch (typeof options.cacheControl) {
-      case 'function':
-        return options.cacheControl(request)
-      case 'object':
-        return options.cacheControl
-      default:
-        return defaultCacheControl
-    }
-  })()
-
-  // formats the etag depending on the response context. if the entityId
-  // is invalid, returns an empty string (instead of null) to prevent the
-  // the potentially disastrous scenario where the value of the Etag resp
-  // header is "null". Could be modified in future to base64 encode etc
-  const formatETag = (entityId: any = pathKey, validatorType: string = 'strong') => {
-    if (!entityId) {
-      return ''
-    }
-    switch (validatorType) {
-      case 'weak':
-        if (!entityId.startsWith('W/')) {
-          return `W/${entityId}`
-        }
-        return entityId
-      case 'strong':
-        if (entityId.startsWith(`W/"`)) {
-          entityId = entityId.replace('W/', '')
-        }
-        if (!entityId.endsWith(`"`)) {
-          entityId = `"${entityId}"`
-        }
-        return entityId
-      default:
-        return ''
-    }
-  }
-
-  options.cacheControl = Object.assign({}, defaultCacheControl, evalCacheOpts)
-
-  // override shouldEdgeCache if options say to bypassCache
-  if (
-    options.cacheControl.bypassCache ||
-    options.cacheControl.edgeTTL === null ||
-    request.method == 'HEAD'
-  ) {
-    shouldEdgeCache = false
-  }
-  // only set max-age if explicitly passed in a number as an arg
-  const shouldSetBrowserCache = typeof options.cacheControl.browserTTL === 'number'
-
-  let response = null
-  if (shouldEdgeCache) {
-    response = await cache.match(cacheKey)
-  }
-
-  if (response) {
-    if (response.status > 300 && response.status < 400) {
-      if (response.body && 'cancel' in Object.getPrototypeOf(response.body)) {
-        response.body.cancel()
-        console.log('Body exists and environment supports readable streams. Body cancelled')
-      } else {
-        console.log('Environment doesnt support readable streams')
-      }
-      response = new Response(null, response)
-    } else {
-      // fixes #165
-      let opts = {
-        headers: new Headers(response.headers),
-        status: 0,
-        statusText: '',
-      }
-
-      opts.headers.set('cf-cache-status', 'HIT')
-
-      if (response.status) {
-        opts.status = response.status
-        opts.statusText = response.statusText
-      } else if (opts.headers.has('Content-Range')) {
-        opts.status = 206
-        opts.statusText = 'Partial Content'
-      } else {
-        opts.status = 200
-        opts.statusText = 'OK'
-      }
-      response = new Response(response.body, opts)
-    }
-  } else {
-    const body = await ASSET_NAMESPACE.get(pathKey, 'arrayBuffer')
-    if (body === null) {
-      throw new NotFoundError(`could not find ${pathKey} in your content namespace`)
-    }
-    response = new Response(body)
-
-    if (shouldEdgeCache) {
-      response.headers.set('Accept-Ranges', 'bytes')
-      response.headers.set('Content-Length', body.length)
-      // set etag before cache insertion
-      if (!response.headers.has('etag')) {
-        response.headers.set('etag', formatETag(pathKey, 'strong'))
-      }
-      // determine Cloudflare cache behavior
-      response.headers.set('Cache-Control', `max-age=${options.cacheControl.edgeTTL}`)
-      event.waitUntil(cache.put(cacheKey, response.clone()))
-      response.headers.set('CF-Cache-Status', 'MISS')
-    }
-  }
-  response.headers.set('Content-Type', mimeType)
-
-  if (response.status === 304) {
-    let etag = formatETag(response.headers.get('etag'), 'strong')
-    let ifNoneMatch = cacheKey.headers.get('if-none-match')
-    let proxyCacheStatus = response.headers.get('CF-Cache-Status')
-    if (etag) {
-      if (ifNoneMatch && ifNoneMatch === etag && proxyCacheStatus === 'MISS') {
-        response.headers.set('CF-Cache-Status', 'EXPIRED')
-      } else {
-        response.headers.set('CF-Cache-Status', 'REVALIDATED')
-      }
-      response.headers.set('etag', formatETag(etag, 'weak'))
-    }
-  }
-  if (shouldSetBrowserCache) {
-    response.headers.set('Cache-Control', `max-age=${options.cacheControl.browserTTL}`)
-  } else {
-    response.headers.delete('Cache-Control')
-  }
-  return response
-}
-
-export { getAssetFromKV, mapRequestToAsset, serveSinglePageApp }
-export { Options, CacheControl, MethodNotAllowedError, NotFoundError, InternalError }

package/vendor/@cloudflare/kv-asset-handler/src/mocks.ts

@@ -1,136 +0,0 @@
-const makeServiceWorkerEnv = require('service-worker-mock')
-
-const HASH = '123HASHBROWN'
-
-export const getEvent = (request: Request): any => {
-  const waitUntil = async (callback: any) => {
-    await callback
-  }
-  return {
-    request,
-    waitUntil,
-  }
-}
-const store: any = {
-  'key1.123HASHBROWN.txt': 'val1',
-  'key1.123HASHBROWN.png': 'val1',
-  'index.123HASHBROWN.html': 'index.html',
-  'cache.123HASHBROWN.html': 'cache me if you can',
-  '测试.123HASHBROWN.html': 'My filename is non-ascii',
-  '%not-really-percent-encoded.123HASHBROWN.html': 'browser percent encoded',
-  '%2F.123HASHBROWN.html': 'user percent encoded',
-  '你好.123HASHBROWN.html': 'I shouldnt be served',
-  '%E4%BD%A0%E5%A5%BD.123HASHBROWN.html': 'Im important',
-  'nohash.txt': 'no hash but still got some result',
-  'sub/blah.123HASHBROWN.png': 'picturedis',
-  'sub/index.123HASHBROWN.html': 'picturedis',
-  'client.123HASHBROWN': 'important file',
-  'client.123HASHBROWN/index.html': 'Im here but serve my big bro above',
-  '你好/index.123HASHBROWN.html': 'My path is non-ascii',
-}
-export const mockKV = (store: any) => {
-  return {
-    get: (path: string) => store[path] || null,
-  }
-}
-
-export const mockManifest = () => {
-  return JSON.stringify({
-    'key1.txt': `key1.${HASH}.txt`,
-    'key1.png': `key1.${HASH}.png`,
-    'cache.html': `cache.${HASH}.html`,
-    '测试.html': `测试.${HASH}.html`,
-    '你好.html': `你好.${HASH}.html`,
-    '%not-really-percent-encoded.html': `%not-really-percent-encoded.${HASH}.html`,
-    '%2F.html': `%2F.${HASH}.html`,
-    '%E4%BD%A0%E5%A5%BD.html': `%E4%BD%A0%E5%A5%BD.${HASH}.html`,
-    'index.html': `index.${HASH}.html`,
-    'sub/blah.png': `sub/blah.${HASH}.png`,
-    'sub/index.html': `sub/index.${HASH}.html`,
-    client: `client.${HASH}`,
-    'client/index.html': `client.${HASH}`,
-    '你好/index.html': `你好/index.${HASH}.html`,
-  })
-}
-
-let cacheStore: any = new Map()
-interface CacheKey {
-  url: object
-  headers: object
-}
-export const mockCaches = () => {
-  return {
-    default: {
-      async match(key: any) {
-        let cacheKey: CacheKey = {
-          url: key.url,
-          headers: {},
-        }
-        let response
-        if (key.headers.has('if-none-match')) {
-          let makeStrongEtag = key.headers.get('if-none-match').replace('W/', '')
-          Reflect.set(cacheKey.headers, 'etag', makeStrongEtag)
-          response = cacheStore.get(JSON.stringify(cacheKey))
-        } else {
-          // if client doesn't send if-none-match, we need to iterate through these keys
-          // and just test the URL
-          const activeCacheKeys: Array<string> = Array.from(cacheStore.keys())
-          for (const cacheStoreKey of activeCacheKeys) {
-            if (JSON.parse(cacheStoreKey).url === key.url) {
-              response = cacheStore.get(cacheStoreKey)
-            }
-          }
-        }
-        // TODO: write test to accomodate for rare scenarios with where range requests accomodate etags
-        if (response && !key.headers.has('if-none-match')) {
-          // this appears overly verbose, but is necessary to document edge cache behavior
-          // The Range request header triggers the response header Content-Range ...
-          const range = key.headers.get('range')
-          if (range) {
-            response.headers.set(
-              'content-range',
-              `bytes ${range.split('=').pop()}/${response.headers.get('content-length')}`,
-            )
-          }
-          // ... which we are using in this repository to set status 206
-          if (response.headers.has('content-range')) {
-            response.status = 206
-          } else {
-            response.status = 200
-          }
-          let etag = response.headers.get('etag')
-          if (etag && !etag.includes('W/')) {
-            response.headers.set('etag', `W/${etag}`)
-          }
-        }
-        return response
-      },
-      async put(key: any, val: Response) {
-        let headers = new Headers(val.headers)
-        let url = new URL(key.url)
-        let resWithBody = new Response(val.body, { headers, status: 200 })
-        let resNoBody = new Response(null, { headers, status: 304 })
-        let cacheKey: CacheKey = {
-          url: key.url,
-          headers: {
-            etag: `"${url.pathname.replace('/', '')}"`,
-          },
-        }
-        cacheStore.set(JSON.stringify(cacheKey), resNoBody)
-        cacheKey.headers = {}
-        cacheStore.set(JSON.stringify(cacheKey), resWithBody)
-        return
-      },
-    },
-  }
-}
-
-export function mockGlobal() {
-  Object.assign(global, makeServiceWorkerEnv())
-  Object.assign(global, { __STATIC_CONTENT_MANIFEST: mockManifest() })
-  Object.assign(global, { __STATIC_CONTENT: mockKV(store) })
-  Object.assign(global, { caches: mockCaches() })
-}
-export const sleep = (milliseconds: number) => {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds))
-}