@momsfriendlydevco/cowboy 1.0.19 → 1.1.1

package/README.md

@@ -63,6 +63,21 @@ export default cowboy()
 		req => widgetStore.delete(req.params.id)
 	)
 };
+
+
+Cron schedule handling
+----------------------
+Cron scheduling is a little basic at the moment but likely to improve in the future.
+To set up a Cron handler simply install it by calling `.schedule(callback)`:
+
+```javascript
+import cowboy from '@momsfriendlydevco/cowboy';
+
+export default cowboy()
+	.schedule(async (event, env, ctx) => {
+		// Handle cron code here
+	})
+```
 ```
 
 Debugging
@@ -136,6 +151,16 @@ This function will, in order:
 6. Return the final response - if it the function did not already explicitly do so
 
 
+Cowboy.proxy(path, request, env)
+--------------------------------
+Forward from one route to another as if the second route was called first.
+
+
+Cowboy.schedule(callback)
+-------------------------
+Install a scheduled Cron handler function.
+
+
 CowboyRequest
 -------------
 ```javascript
@@ -376,3 +401,8 @@ cowboy()
 		(req, res, env) => /* ... */
 	)
 ```
+
+
+parseJwt()
+----------
+Parse the incoming request as a JWT string and decode its contents into `req.body`.

package/lib/cowboy.js

@@ -166,6 +166,55 @@ export class Cowboy {
 	}
 
 
+	/**
+	* Set up Cloudflare response to "scheduled" call
+	* This is really just a map to the last handler we installed to .schedule(cb) - for now
+	*
+	* @param {CloudflareEvent} event The Cloudflare event context passed
+	* @param {Object} env Environment variables
+	* @param {CloudflareContext} ctx The Cloudflare context to respond to
+	*/
+	scheduled(event, env, ctx) {
+		if (!this.schedule.handler) throw new Error('Attemped to access Cowboy.scheduled without first calling .schedule() to set something up!');
+		return this.schedule.handler.call(this, event, env, ctx);
+	}
+
+
+	/**
+	* Call a router function as if it were invoked directly
+	* This function exists as an easier way to remap body contents without
+	*
+	* @param {String} url The URL path to call
+	* @param {Object} request Additional request options
+	* @param {Object} env The environment object to use
+	*
+	* @returns {CloudflareResponse} The returned CloudflareResponse object
+	*/
+	async proxy(url, options, env) {
+		if (!url || !options || !env) throw new Error('Url + options + env must be specified to proxy()');
+
+		return this.fetch(new Request(new URL(url, 'http://localhost').toString(), {
+			...options,
+			body: (()=> {
+				if ( // Being handed a native Cloudflare request body?
+					!options.body
+					|| options.body instanceof FormData
+					|| options.body instanceof ReadableStream
+					|| options.body instanceof URLSearchParams
+					|| typeof options.body == 'string'
+				) {
+					return options.body;
+				} else if (typeof options.body == 'object') { // Convert POJO into Formdata
+					let body = new FormData();
+					Object.entries(options.body)
+						.forEach(([key, val]) => body.append(key, val))
+					return body;
+				}
+			})(),
+		}), env);
+	}
+
+
 	async execMiddleware({middleware, req, res, env}) {
 		let middlewareStack = middleware
 			.map(m => {
@@ -183,7 +232,7 @@ export class Cowboy {
 		while (middlewareStack.length > 0) {
 			let middleware = middlewareStack.shift();
 			try {
-				response = await middleware(req, res, env);
+				response = await middleware.call(this, req, res, env);
 				if (response?.hasSent) { // Stop middleware chain as some intermediate has signalled the chain should end
 					response = res;
 					break;
@@ -193,7 +242,7 @@ export class Cowboy {
 			} catch (e) {
 				let errorText = typeof e == 'string' ? e : e.toString();
 
-				debug('Error thrown', errorText);
+				debug('Error thrown', e);
 
 				// Form: '404: Not found'
 				if (/^(\d{3}):/.test(errorText)) {
@@ -220,14 +269,27 @@ export class Cowboy {
 	options(path, ...middleware) { return this.route('OPTIONS', path, ...middleware) }
 
 
+	/**
+	* Handle cron job scheduling
+	*
+	* @param {Function} cb The callback to install for all scheduled events. Called as `(event:CloudflareEvent, env:Object, ctx:CloudflareContext)`
+	* @returns {Cowboy} This chainable Cowboy router instance
+	*/
+	schedule(handler) {
+		console.info('Installed schedule event handler. Access via http://localhost:8787/__scheduled');
+		this.schedule.handler = handler;
+		return this;
+	}
+
+
 	/**
 	* Generial Init() sequence
 	* This will be run automatically on setup or the first fetch()
 	* @returns {Cowboy} This chainable Cowboy router instance
 	*/
 	init() {
-		debug('INIT!');
 		if (this.doneInit) return this; // Already completed init
+		debug('INIT!');
 
 		if (this.settings.patchAxios) {
 			// TODO: Patch Axios somehow

package/lib/request.js

@@ -28,6 +28,14 @@ export default class CowboyRequest {
 	/**
 	* Raw body payload provided by cfReq
 	* This gets translated into a usable object after a call to `parseBody()`
+	* @type {Buffer}
+	*/
+	text = null;
+
+
+	/**
+	* Body payload provided by cfReq (
+	* Defaults to the same value as `text` until its parsed by `parseBody()`
 	* @type {*}
 	*/
 	body = null;
@@ -60,6 +68,9 @@ export default class CowboyRequest {
 		// Slurp the headers
 		this.headers = Object.fromEntries(cfReq.headers.entries());
 
+		// Hold the raw data
+		this.text = cfReq.text.bind(cfReq),
+
 		// Hold the body element - this wont be decoded until parseBody() is called
 		this.body = {
 			json: cfReq.json.bind(cfReq),
@@ -110,7 +121,8 @@ export default class CowboyRequest {
 					throw new Error('Invalid text body');
 				}
 			default:
-				debug('Empty Body Payload');
+				debug('Empty Body Payload - assuming raw payload');
+				this.text = await this.body.text();
 				this.body = {};
 		}
 	}

package/middleware/index.js

@@ -1,4 +1,5 @@
 import cors from '#middleware/cors';
+import parseJwt from '#middleware/parseJwt';
 import validate from '#middleware/validate';
 import validateBody from '#middleware/validateBody';
 import validateHeaders from '#middleware/validateHeaders';
@@ -7,6 +8,7 @@ import validateQuery from '#middleware/validateQuery';
 
 export default {
 	cors,
+	parseJwt,
 	validate,
 	validateBody,
 	validateHeaders,

package/middleware/parseJwt.js

@@ -0,0 +1,21 @@
+/**
+* Return a parsing middleware layer which accepts a JWT body and decodes the object into req.body
+*
+* @param {Object} [options] Additional options to mutate behaviour
+* @param {Function} [options.isJwt] Async function, called as `(req, res)` to determine if the input is a JWT payload, defaults to checking the content-type header
+*/
+export default function CowboyMiddlewareParseJwt(options) {
+	let settings = {
+		async isJwt(req, res) { // eslint-disable-line no-unused-vars
+			return req.headers['content-type'] == 'application/jwt';
+		},
+		...options,
+	};
+
+	return async (req, res) => {
+		if (await !settings.isJwt(req, res)) return;
+
+		const base64 = req.text.split('.')[1].replace(/-/g, '+').replace(/_/g, '/');
+		req.body = JSON.parse(atob(base64));
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momsfriendlydevco/cowboy",
-  "version": "1.0.19",
+  "version": "1.1.1",
   "description": "Wrapper around Cloudflare Wrangler to provide a more Express-like experience",
   "scripts": {
     "lint": "eslint ."