wrangler 0.0.0-e6733a3 → 0.0.0-e6ada079

package/vendor/@cloudflare/kv-asset-handler/dist/test/serveSinglePageApp.js

@@ -1,42 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ava_1 = require("ava");
-const mocks_1 = require("../mocks");
-const index_1 = require("../index");
-function testRequest(path) {
-    mocks_1.mockGlobal();
-    let url = new URL('https://example.com');
-    url.pathname = path;
-    let request = new Request(url.toString());
-    return request;
-}
-ava_1.default('serveSinglePageApp returns root asset path when request path ends in .html', (t) => __awaiter(void 0, void 0, void 0, function* () {
-    let path = '/foo/thing.html';
-    let request = testRequest(path);
-    let expected_request = testRequest('/index.html');
-    let actual_request = index_1.serveSinglePageApp(request);
-    t.deepEqual(expected_request, actual_request);
-}));
-ava_1.default('serveSinglePageApp returns root asset path when request path does not have extension', (t) => __awaiter(void 0, void 0, void 0, function* () {
-    let path = '/foo/thing';
-    let request = testRequest(path);
-    let expected_request = testRequest('/index.html');
-    let actual_request = index_1.serveSinglePageApp(request);
-    t.deepEqual(expected_request, actual_request);
-}));
-ava_1.default('serveSinglePageApp returns requested asset when request path has non-html extension', (t) => __awaiter(void 0, void 0, void 0, function* () {
-    let path = '/foo/thing.js';
-    let request = testRequest(path);
-    let expected_request = request;
-    let actual_request = index_1.serveSinglePageApp(request);
-    t.deepEqual(expected_request, actual_request);
-}));

package/vendor/@cloudflare/kv-asset-handler/dist/types.d.ts

@@ -1,26 +0,0 @@
-export declare type CacheControl = {
-    browserTTL: number;
-    edgeTTL: number;
-    bypassCache: boolean;
-};
-export declare type Options = {
-    cacheControl: ((req: Request) => Partial<CacheControl>) | Partial<CacheControl>;
-    ASSET_NAMESPACE: any;
-    ASSET_MANIFEST: Object | string;
-    mapRequestToAsset?: (req: Request, options?: Partial<Options>) => Request;
-    defaultMimeType: string;
-    defaultDocument: string;
-};
-export declare class KVError extends Error {
-    constructor(message?: string, status?: number);
-    status: number;
-}
-export declare class MethodNotAllowedError extends KVError {
-    constructor(message?: string, status?: number);
-}
-export declare class NotFoundError extends KVError {
-    constructor(message?: string, status?: number);
-}
-export declare class InternalError extends KVError {
-    constructor(message?: string, status?: number);
-}

package/vendor/@cloudflare/kv-asset-handler/dist/types.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalError = exports.NotFoundError = exports.MethodNotAllowedError = exports.KVError = void 0;
-class KVError extends Error {
-    constructor(message, status = 500) {
-        super(message);
-        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
-        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
-        this.name = KVError.name; // stack traces display correctly now
-        this.status = status;
-    }
-}
-exports.KVError = KVError;
-class MethodNotAllowedError extends KVError {
-    constructor(message = `Not a valid request method`, status = 405) {
-        super(message, status);
-    }
-}
-exports.MethodNotAllowedError = MethodNotAllowedError;
-class NotFoundError extends KVError {
-    constructor(message = `Not Found`, status = 404) {
-        super(message, status);
-    }
-}
-exports.NotFoundError = NotFoundError;
-class InternalError extends KVError {
-    constructor(message = `Internal Error in KV Asset Handler`, status = 500) {
-        super(message, status);
-    }
-}
-exports.InternalError = InternalError;

package/vendor/@cloudflare/kv-asset-handler/package.json

@@ -1,52 +0,0 @@
-{
-  "name": "@cloudflare/kv-asset-handler",
-  "version": "0.1.2",
-  "description": "Routes requests to KV assets",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "prepack": "npm run build",
-    "build": "tsc -d",
-    "format": "prettier --write \"**/*.{js,ts,json,md}\"",
-    "pretest": "npm run build",
-    "lint:code": "prettier --check \"**/*.{js,ts,json,md}\"",
-    "lint:markdown": "markdownlint \"**/*.md\" --ignore node_modules",
-    "test": "ava dist/test/*.js --verbose"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cloudflare/kv-asset-handler.git"
-  },
-  "keywords": [
-    "kv",
-    "cloudflare",
-    "workers",
-    "wrangler",
-    "assets"
-  ],
-  "files": [
-    "src",
-    "dist",
-    "LICENSE_APACHE",
-    "LICENSE_MIT"
-  ],
-  "author": "wrangler@cloudflare.com",
-  "license": "MIT OR Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/cloudflare/kv-asset-handler/issues"
-  },
-  "homepage": "https://github.com/cloudflare/kv-asset-handler#readme",
-  "dependencies": {
-    "wrangler-mime": "^2.5.2"
-  },
-  "devDependencies": {
-    "@ava/typescript": "^1.1.1",
-    "@cloudflare/workers-types": "^2.2.2",
-    "@types/mime": "^2.0.3",
-    "@types/node": "^15.3.0",
-    "ava": "^3.15.0",
-    "prettier": "^2.3.0",
-    "service-worker-mock": "^2.0.5",
-    "typescript": "^4.2.4"
-  }
-}

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))
-}