Initial commit

Author: adamlacombe

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+
+\.idea/

.npmrc

@@ -0,0 +1 @@
+package-lock=false

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Interactive.Training
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,5 @@
+# unpkg-cloudflare-worker
+
+## WIP
+
+A self-hosted version of unpkg developed specifically to run using Cloudflare Workers

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "unpkg-cloudflare-worker",
+  "version": "0.0.1",
+  "description": "",
+  "main": "src/index.ts",
+  "private": true,
+  "scripts": {
+    "build": "webpack --progress --mode production",
+    "build.dev": "webpack --progress --mode none"
+  },
+  "author": "Interactive Training",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^12.7.1",
+    "@types/pako": "^1.0.1",
+    "@udacity/types-service-worker-mock": "^1.0.1",
+    "cloudflare-worker-mock": "^1.0.1",
+    "ts-loader": "^6.0.4",
+    "types-cloudflare-worker": "^1.0.1",
+    "typescript": "^3.5.3",
+    "webpack": "^4.39.1",
+    "webpack-cli": "^3.3.6"
+  },
+  "dependencies": {
+    "pako": "^1.0.10",
+    "mime-types": "^2.1.24"
+  }
+}

src/gunzip.ts

@@ -0,0 +1,28 @@
+import * as pako from 'pako';
+
+function concatArrayBuffer(arrayBufferList = []) {
+  const resultTypedArray = new Uint8Array(arrayBufferList.reduce((o, arrayBuffer) => o + arrayBuffer.byteLength, 0));
+  let byteOffset = 0;
+  arrayBufferList.forEach((arrayBuffer) => {
+    const {byteLength} = arrayBuffer;
+    resultTypedArray.set(new Uint8Array(arrayBuffer), byteOffset);
+    byteOffset += byteLength
+  });
+  return resultTypedArray.buffer
+}
+
+// https://github.com/nodeca/pako/issues/35#issuecomment-437341187
+export function gunzipAll(arrayBuffer: ArrayBuffer) {
+  const arrayBufferList = [];
+  let byteOffset = 0;
+  let byteLeft = 1;
+  while (byteLeft > 0) {
+    const inflator = new pako.Inflate() as any;
+    inflator.push(new Uint8Array(arrayBuffer, byteOffset));
+    if (inflator.err) throw inflator.msg;
+    arrayBufferList.push(inflator.result);
+    byteOffset += inflator.strm.total_in;
+    byteLeft = inflator.strm.avail_in
+  }
+  return concatArrayBuffer(arrayBufferList)
+}

src/helpers.ts

@@ -0,0 +1,41 @@
+import {IPackageParams} from './interfaces';
+import {untarBuffer} from './tar';
+import {gunzipAll} from './gunzip';
+
+
+export function getRegistryOptions(): RequestInit {
+  let options: RequestInit = {};
+  
+  // if (process.env.NPM_TOKEN && process.env.NPM_TOKEN.trim().length > 0) {
+  //   options.headers = {authorization: `Bearer ${process.env.NPM_TOKEN.trim()}`};
+  // } else {
+  //   options.auth = `${process.env.NPM_USER}:${process.env.NPM_PASSWORD}`;
+  // }
+  
+  return options;
+}
+
+export function getPackageUrl(pkg: IPackageParams): string {
+  return `https://registry.npmjs.com/${(pkg.scope) ? `${pkg.scope}/` : ''}${pkg.package}`;
+}
+
+export async function getLatestVersion(pkg: IPackageParams): Promise<string> {
+  return new Promise(async (resolve, reject) => {
+    let res = await fetch(getPackageUrl(pkg), getRegistryOptions());
+    let body = await res.json();
+    const tags = body['dist-tags'];
+    resolve(tags[pkg.version] || tags['latest']);
+  });
+}
+
+
+export async function downloadFile(pkg: IPackageParams): Promise<string> {
+  let url = `${getPackageUrl(pkg)}/-/${pkg.package}-${pkg.version}.tgz`;
+  console.log('download', url);
+  let response = await fetch(url, getRegistryOptions());
+  
+  let arrayBuffer = await response.arrayBuffer();
+  let gunzipBuffer = gunzipAll(arrayBuffer);
+  
+  return untarBuffer(gunzipBuffer, pkg['0']);
+}

src/index.ts

@@ -0,0 +1,88 @@
+import CloudflareWorkerGlobalScope from 'types-cloudflare-worker';
+import {IPackageParams} from './interfaces';
+import {downloadFile, getLatestVersion} from './helpers';
+import * as mime from 'mime-types';
+
+declare var self: CloudflareWorkerGlobalScope;
+
+export class Worker {
+  public async handle(event: FetchEvent) {
+    let url = new URL(event.request.url);
+    let path = url.pathname;
+    let scope: string;
+    let pkg: string;
+    let version: string;
+    let file: string = path.slice(1).split('/').map(el => el.split('@')).slice(2).join("/");
+    const splits = path.slice(1).split('/').map(el => el.split('@')).slice(0, 2);
+    
+    if (splits[0] instanceof Array && splits[0][0].length === 0) {
+      scope = splits[0][1];
+      pkg = splits[1][0];
+      version = splits[1][1];
+    } else {
+      pkg = splits[0][0];
+      version = splits[0][1];
+      file = (file && file.length > 0) ? [splits[1][0], file].join("/") : splits[1][0];
+    }
+    
+    let params: IPackageParams = {
+      ['package']: pkg,
+      version: version,
+      scope: (scope && scope.length > 0) ? `@${scope}` : undefined,
+      '0': file
+    };
+    
+    if (!params.version) {
+      params.version = 'latest';
+    }
+    
+    if (!params.version.includes('.')) {
+      params.version = await getLatestVersion(params);
+      const redirectUrl = `${url.origin}/${(params.scope) ? `${params.scope}/` : ``}${params.package}@${params.version}/${params['0']}`;
+      console.log('redirect', redirectUrl);
+      return Response.redirect(redirectUrl, 302);
+    }
+    
+    // if file path is empty - respond with directory listing
+    if (params['0'] === '') {
+      //await getPackageFileList(params);
+      return new Response(JSON.stringify({route: 'browse'}), {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'public, max-age=31536000'
+        }
+      });
+    } else {
+      return new Response(await downloadFile(params), {
+        status: 200,
+        headers: {
+          'Content-Type': mime.lookup(params['0']),
+          'Cache-Control': 'public, max-age=31536000'
+        }
+      });
+    }
+  }
+  
+  
+  public async handleTwo(event: FetchEvent) {
+    return new Response(JSON.stringify({test: 'route-2'}), {status: 200});
+  }
+}
+
+self.addEventListener('fetch', (event: FetchEvent) => {
+  const worker = new Worker();
+  // const url = new URL(event.request.url);
+  //
+  // const route = (): keyof Worker => {
+  //   if (url.host === 'test.example.com') {
+  //     return 'handle';
+  //   } else if (url.host === 'test2.example.com') {
+  //     return 'handleTwo';
+  //   }
+  // };
+  //
+  // event.respondWith(worker[route()](event));
+  
+  event.respondWith(worker.handle(event));
+});

src/interfaces.ts

@@ -0,0 +1,32 @@
+export interface IPackageParams {
+  scope?: string;
+  package: string;
+  version?: string;
+  0?: string;
+}
+
+export interface ITarFile {
+  name: string;
+  mode: string;
+  mtime: number;
+  uid: any;
+  gid: any;
+  size: number;
+  checksum: number;
+  type: string;
+  linkname: string;
+  ustarFormat: string;
+  version: string;
+  uname: string;
+  gname: string;
+  devmajor: number;
+  devminor: number;
+  namePrefix: string;
+  buffer: ArrayBuffer;
+  content: string;
+}
+
+export interface IPAXField {
+  name: string;
+  value: string;
+}