edge.libx.js 0.0.1

package/src/modules/@module.ts

@@ -0,0 +1,13 @@
+import { libx } from 'libx.js/build/bundles/essentials.js';
+
+export class Module {
+	public constructor(public options?: Partial<ModuleOptions>) {
+		this.options = { ...new ModuleOptions(), ...options };
+		libx.log.v('Module:ctor');
+	}
+	
+}
+
+export class ModuleOptions {
+
+}

package/src/modules/RouterWrapper.ts

@@ -0,0 +1,68 @@
+import { libx } from 'libx.js/build/bundles/essentials.js';
+import { Route, Router, RouterType, error, json, cors, withParams, IRequest, text, ResponseHandler } from 'itty-router';
+import { createServerAdapter } from '@whatwg-node/server';
+
+type BaseRouterInitializer = (string) => { base: string; router: RouterType<IRequest, any[]> };
+
+export class RouterWrapper<TCtx = any> {
+	private static cors = cors({ origin: ['*'], allowMethods: ['POST'] });
+	private static preflight = this.cors.preflight;
+	private static corsify = this.cors.corsify;
+
+	public constructor(public base: string, public router: RouterType<Request, [], any>) {
+
+	}
+
+	private static tryCors(response, request): Response {
+		try {
+			return this.corsify(response, request);
+		} catch (err) {
+			libx.log.w('tryCors: failed to perform CORS', err);
+		}
+	}
+
+	public static getNew(base: string) {
+		const router = Router({
+			base,
+			before: [this.preflight],
+			catch: this.errorHandler,
+			finally: [this.tryCors],
+		});
+		router.all('*', withParams);
+		// router.finally.push(this.corsify);
+
+		// router.all('*', () => error(404));
+
+		return new RouterWrapper(base, router);
+	}
+
+
+	public static errorHandler(error) {
+		const isObject = libx.isObject(error);
+		const errMessage = error?.message ?? error;
+		const msg = 'Error: ' + (!isObject ? (errMessage ?? 'Server Error') : JSON.stringify(error));
+		const status = parseInt(error?.status ?? error?.statusCode ?? error?.code ?? error?.error?.code) || 500;
+		console.error('Server error: ', error, status);
+		return new Response(msg, { status })
+	}
+
+	public registerRoute(newBase: string, baseRouterInitializer: BaseRouterInitializer) {
+		const route = baseRouterInitializer(`${this.base}${newBase}`);
+		this.router.all(newBase + '/*', route.router.fetch);
+		return this.router;
+	};
+
+	public fetchHandler(request: IRequest, ctx: TCtx) {
+		// return this.router.fetch(request, ctx).then(json).then(RouterWrapper.corsify).catch(this.errorHandler);
+		return this.router.fetch(request, ctx).then(json).catch(RouterWrapper.errorHandler);
+	}
+
+	public catchNotFound() {
+		this.router.all('*', () => error(404));
+	}
+
+	public createServerAdapter() {
+		const ittyServer = createServerAdapter(this.fetchHandler.bind(this));
+		return ittyServer;
+	}
+}

package/src/modules/cors.ts

@@ -0,0 +1,153 @@
+/**
+ * Multi purpose CORS lib.
+ * Note: Based on the `cors` package in npm but using only
+ * web APIs. Feel free to use it in your own projects.
+ */
+
+type StaticOrigin = boolean | string | RegExp | (boolean | string | RegExp)[]
+
+type OriginFn = (
+  origin: string | undefined,
+  req: Request
+) => StaticOrigin | Promise<StaticOrigin>
+
+interface CorsOptions {
+  origin?: StaticOrigin | OriginFn
+  methods?: string | string[]
+  allowedHeaders?: string | string[]
+  exposedHeaders?: string | string[]
+  credentials?: boolean
+  maxAge?: number
+  preflightContinue?: boolean
+  optionsSuccessStatus?: number
+}
+
+const defaultOptions: CorsOptions = {
+  origin: '*',
+  methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+  preflightContinue: false,
+  optionsSuccessStatus: 204,
+}
+
+function isOriginAllowed(origin: string, allowed: StaticOrigin): boolean {
+  return Array.isArray(allowed)
+    ? allowed.some((o) => isOriginAllowed(origin, o))
+    : typeof allowed === 'string'
+      ? origin === allowed
+      : allowed instanceof RegExp
+        ? allowed.test(origin)
+        : !!allowed
+}
+
+function getOriginHeaders(reqOrigin: string | undefined, origin: StaticOrigin) {
+  const headers = new Headers()
+
+  if (origin === '*') {
+    // Allow any origin
+    headers.set('Access-Control-Allow-Origin', '*')
+  } else if (typeof origin === 'string') {
+    // Fixed origin
+    headers.set('Access-Control-Allow-Origin', origin)
+    headers.append('Vary', 'Origin')
+  } else {
+    const allowed = isOriginAllowed(reqOrigin ?? '', origin)
+
+    if (allowed && reqOrigin) {
+      headers.set('Access-Control-Allow-Origin', reqOrigin)
+    }
+    headers.append('Vary', 'Origin')
+  }
+
+  return headers
+}
+
+// originHeadersFromReq
+
+async function originHeadersFromReq(
+  req: Request,
+  origin: StaticOrigin | OriginFn
+) {
+  const reqOrigin = req.headers.get('Origin') || undefined
+  const value =
+    typeof origin === 'function' ? await origin(reqOrigin, req) : origin
+
+  if (!value) return
+  return getOriginHeaders(reqOrigin, value)
+}
+
+function getAllowedHeaders(req: Request, allowed?: string | string[]) {
+  const headers = new Headers()
+
+  if (!allowed) {
+    allowed = req.headers.get('Access-Control-Request-Headers')!
+    headers.append('Vary', 'Access-Control-Request-Headers')
+  } else if (Array.isArray(allowed)) {
+    // If the allowed headers is an array, turn it into a string
+    allowed = allowed.join(',')
+  }
+  if (allowed) {
+    headers.set('Access-Control-Allow-Headers', allowed)
+  }
+
+  return headers
+}
+
+export default async function cors(
+  req: Request,
+  res: Response,
+  options?: CorsOptions
+) {
+  const opts = { ...defaultOptions, ...options }
+  const { headers } = res
+  const originHeaders = await originHeadersFromReq(req, opts.origin ?? false)
+  const mergeHeaders = (v: string, k: string) => {
+    if (k === 'Vary') headers.append(k, v)
+    else headers.set(k, v)
+  }
+
+  // If there's no origin we won't touch the response
+  if (!originHeaders) return res
+
+  originHeaders.forEach(mergeHeaders)
+
+  if (opts.credentials) {
+    headers.set('Access-Control-Allow-Credentials', 'true')
+  }
+
+  const exposed = Array.isArray(opts.exposedHeaders)
+    ? opts.exposedHeaders.join(',')
+    : opts.exposedHeaders
+
+  if (exposed) {
+    headers.set('Access-Control-Expose-Headers', exposed)
+  }
+  debugger
+  // Handle the preflight request
+  if (req.method === 'OPTIONS') {
+    if (opts.methods) {
+      const methods = Array.isArray(opts.methods)
+        ? opts.methods.join(',')
+        : opts.methods
+
+      headers.set('Access-Control-Allow-Methods', methods)
+    }
+
+    getAllowedHeaders(req, opts.allowedHeaders).forEach(mergeHeaders)
+
+    if (typeof opts.maxAge === 'number') {
+      headers.set('Access-Control-Max-Age', String(opts.maxAge))
+    }
+
+    if (opts.preflightContinue) return res
+
+    headers.set('Content-Length', '0')
+    return new Response(null, { status: opts.optionsSuccessStatus, headers })
+  }
+
+  // If we got here, it's a normal request
+  return res
+}
+
+export function initCors(options?: CorsOptions) {
+  return (req: Request, res: Response) => cors(req, res, options)
+}