acrylblends 0.4.1 → 0.5.1

package/lib/combine.js

@@ -0,0 +1,137 @@
+import { t as compose } from "./compose-BuW2B6PZ.js";
+import "./router.js";
+import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
+//#region ../../plugins/acryl-router/src/core/middleware/combine/index.ts
+/**
+* @module
+* Combine Middleware for Acryl.
+*/
+/**
+* Create a composed middleware that runs the first middleware that returns true.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware exits without returning
+* an exception first, subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns true
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some } from 'acrylblends/combine'
+* import { bearerAuth } from 'acrylblends/bearer-auth'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client has a valid token, then skip rate limiting.
+* // Otherwise, apply rate limiting.
+* app.use('/api/*', some(
+*   bearerAuth({ token }),
+*   myRateLimit({ limit: 100 }),
+* ));
+* ```
+*/
+const some = (...middleware) => {
+	return async function some(c, next) {
+		let isNextCalled = false;
+		const wrappedNext = () => {
+			isNextCalled = true;
+			return next();
+		};
+		let lastError;
+		let response;
+		for (const handler of middleware) try {
+			const result = await handler(c, wrappedNext);
+			if (result === true && !c.finalized) await wrappedNext();
+			else if (result === false) {
+				lastError = /* @__PURE__ */ new Error("No successful middleware found");
+				continue;
+			} else if (result && result !== true) response = result;
+			lastError = void 0;
+			break;
+		} catch (error) {
+			lastError = error;
+			if (isNextCalled) break;
+		}
+		if (lastError) throw lastError;
+		return response;
+	};
+};
+/**
+* Create a composed middleware that runs all middleware and throws an error if any of them fail.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware throws an error,
+* subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns false
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some, every } from 'acrylblends/combine'
+* import { bearerAuth } from 'acrylblends/bearer-auth'
+* import { myCheckLocalNetwork } from '@/check-local-network'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client is in local network, then skip authentication and rate limiting.
+* // Otherwise, apply authentication and rate limiting.
+* app.use('/api/*', some(
+*   myCheckLocalNetwork(),
+*   every(
+*     bearerAuth({ token }),
+*     myRateLimit({ limit: 100 }),
+*   ),
+* ));
+* ```
+*/
+const every = (...middleware) => {
+	return async function every(c, next) {
+		const currentRouteIndex = c.req.routeIndex;
+		await compose(middleware.map((m) => [[async (c, next) => {
+			c.req.routeIndex = currentRouteIndex;
+			const res = await m(c, next);
+			if (res === false) throw new Error("Unmet condition");
+			return res;
+		}]]))(c, next);
+	};
+};
+/**
+* Create a composed middleware that runs all middleware except when the condition is met.
+*
+* @param condition - A string or Condition function.
+* If there are multiple targets to match any of them, they can be passed as an array.
+* If a string is passed, it will be treated as a path pattern to match.
+* If a Condition function is passed, it will be evaluated against the request context.
+* @param middleware - Middleware to run when the condition is not met.
+* Multiple middleware can be passed, and they are applied in the order they are passed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { except } from 'acrylblends/combine'
+* import { bearerAuth } from 'acrylblends/bearer-auth'
+*
+* // If client is accessing public API, then skip authentication.
+* // Otherwise, require a valid token.
+* app.use('/api/*', except(
+*   '/api/public/*',
+*   bearerAuth({ token }),
+* ));
+* ```
+*/
+const except = (condition, ...middleware) => {
+	let router = void 0;
+	const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition) => {
+		if (typeof condition === "string") {
+			router ||= new TrieRouter();
+			router.add("ALL", condition, true);
+		} else return condition;
+	}).filter(Boolean);
+	if (router) conditions.unshift((c) => !!router?.match("ALL", c.req.path)?.[0]?.[0]?.[0]);
+	const handler = some((c) => conditions.some((cond) => cond(c)), every(...middleware));
+	return async function except(c, next) {
+		await handler(c, next);
+	};
+};
+//#endregion
+export { every, except, some };

package/lib/compose-BuW2B6PZ.js

@@ -0,0 +1,50 @@
+//#region ../../plugins/acryl-router/src/core/compose.ts
+/**
+* Compose middleware functions into a single function based on `koa-compose` package.
+*
+* @template E - The environment type.
+*
+* @param {[[Function, unknown], unknown][] | [[Function]][]} middleware - An array of middleware functions and their corresponding parameters.
+* @param {ErrorHandler<E>} [onError] - An optional error handler function.
+* @param {NotFoundHandler<E>} [onNotFound] - An optional not-found handler function.
+*
+* @returns {(context: Context, next?: Next) => Promise<Context>} - A composed middleware function.
+*/
+const compose = (middleware, onError, onNotFound) => {
+	return (context, next) => {
+		let index = -1;
+		return dispatch(0);
+		/**
+		* Dispatch the middleware functions.
+		*
+		* @param {number} i - The current index in the middleware array.
+		*
+		* @returns {Promise<Context>} - A promise that resolves to the context.
+		*/
+		async function dispatch(i) {
+			if (i <= index) throw new Error("next() called multiple times");
+			index = i;
+			let res;
+			let isError = false;
+			let handler;
+			if (middleware[i]) {
+				handler = middleware[i][0][0];
+				context.req.routeIndex = i;
+			} else handler = i === middleware.length && next || void 0;
+			if (handler) try {
+				res = await handler(context, () => dispatch(i + 1));
+			} catch (err) {
+				if (err instanceof Error && onError) {
+					context.error = err;
+					res = await onError(err, context);
+					isError = true;
+				} else throw err;
+			}
+			else if (context.finalized === false && onNotFound) res = await onNotFound(context);
+			if (res && (context.finalized === false || isError)) context.res = res;
+			return context;
+		}
+	};
+};
+//#endregion
+export { compose as t };

package/lib/compress.d.ts

@@ -0,0 +1,38 @@
+import { I as MiddlewareHandler } from "./context-Bm7rI-oK.js";
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/compress/index.d.ts
+declare const ENCODING_TYPES: readonly ["gzip", "deflate"];
+type Encoding = (typeof ENCODING_TYPES)[number];
+type ContentTypeFilter = RegExp | ((contentType: string) => boolean);
+interface CompressionOptions {
+  encoding?: Encoding;
+  threshold?: number;
+  contentTypeFilter?: ContentTypeFilter;
+}
+/**
+ * Compress Middleware for Acryl.
+ *
+ *
+ * @param {CompressionOptions} [options] - The options for the compress middleware.
+ * @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+ * @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+ * @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.use(compress())
+ *
+ * // Compress only JSON responses
+ * app.use(compress({ contentTypeFilter: /^application\/json/ }))
+ *
+ * // Compress based on custom Content-Type logic
+ * app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
+ * ```
+ */
+declare const compress: (options?: CompressionOptions) => MiddlewareHandler;
+//#endregion
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX, compress };

package/lib/compress.js

@@ -0,0 +1,79 @@
+import { parseAccept } from "./utils/accept.js";
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
+//#region ../../plugins/acryl-router/src/core/middleware/compress/index.ts
+const ENCODING_TYPES = ["gzip", "deflate"];
+const cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
+const selectEncoding = (header, candidates) => {
+	if (header === void 0) return;
+	const accepts = parseAccept(header);
+	const wildcardQ = accepts.find((a) => a.type === "*")?.q;
+	let best;
+	for (const enc of candidates) {
+		const explicit = accepts.find((a) => a.type.toLowerCase() === enc);
+		const q = explicit ? explicit.q : wildcardQ ?? 0;
+		if (q === 1) return enc;
+		else if (q > 0 && (!best || q > best.q)) best = {
+			encoding: enc,
+			q
+		};
+	}
+	return best?.encoding;
+};
+const varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i;
+/**
+* Compress Middleware for Acryl.
+*
+*
+* @param {CompressionOptions} [options] - The options for the compress middleware.
+* @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+* @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+* @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(compress())
+*
+* // Compress only JSON responses
+* app.use(compress({ contentTypeFilter: /^application\/json/ }))
+*
+* // Compress based on custom Content-Type logic
+* app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
+* ```
+*/
+const compress = (options) => {
+	const threshold = options?.threshold ?? 1024;
+	const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;
+	const contentTypeFilter = options?.contentTypeFilter ?? COMPRESSIBLE_CONTENT_TYPE_REGEX;
+	const shouldCompress = typeof contentTypeFilter === "function" ? (res) => {
+		const type = res.headers.get("Content-Type");
+		return type && contentTypeFilter(type);
+	} : (res) => {
+		const type = res.headers.get("Content-Type");
+		return type && contentTypeFilter.test(type);
+	};
+	return async function compress(ctx, next) {
+		await next();
+		const contentLength = ctx.res.headers.get("Content-Length");
+		if (ctx.res.status === 206 || ctx.res.headers.has("Content-Encoding") || ctx.res.headers.has("Transfer-Encoding") || ctx.req.method === "HEAD" || contentLength && Number(contentLength) < threshold || !shouldCompress(ctx.res) || !shouldTransform(ctx.res)) return;
+		const current = ctx.res.headers.get("Vary");
+		if (current !== "*" && !(current && varyAcceptEncodingRegExp.test(current))) ctx.header("Vary", current ? `${current}, Accept-Encoding` : "Accept-Encoding");
+		const accepted = ctx.req.header("Accept-Encoding");
+		const encoding = selectEncoding(accepted, candidates);
+		if (!encoding || !ctx.res.body) return;
+		const stream = new CompressionStream(encoding);
+		ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res);
+		ctx.res.headers.delete("Content-Length");
+		ctx.res.headers.set("Content-Encoding", encoding);
+		const etag = ctx.res.headers.get("ETag");
+		if (etag && !etag.startsWith("W/")) ctx.res.headers.set("ETag", `W/${etag}`);
+	};
+};
+const shouldTransform = (res) => {
+	const cacheControl = res.headers.get("Cache-Control");
+	return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl);
+};
+//#endregion
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX, compress };

package/lib/connection-C7xgP1hP.js

@@ -0,0 +1,24 @@
+import { isIP } from "node:net";
+//#region ../../plugins/acryl-router/src/connection.ts
+/**
+* Transport facts: who is on the other end of the socket and which local port it reached. The caller of `router.fetch` supplies them
+* (an HTTP adapter passes the socket's peer address and real port); they travel in `c.env.connection`, beside the request and never in a header.
+*/
+const NONE = Object.freeze({});
+/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
+function connectionOf(c) {
+	return c.env?.connection ?? NONE;
+}
+/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
+const getConnInfo = (c) => {
+	const { remoteAddress } = connectionOf(c);
+	if (remoteAddress === void 0) return { remote: {} };
+	const family = isIP(remoteAddress.replace(/^\[|\]$/gu, ""));
+	return { remote: {
+		transport: "tcp",
+		address: remoteAddress,
+		addressType: family === 6 ? "IPv6" : family === 4 ? "IPv4" : void 0
+	} };
+};
+//#endregion
+export { getConnInfo as n, connectionOf as t };

package/lib/conninfo.d.ts

@@ -0,0 +1,25 @@
+import { t as Context } from "./context-Bm7rI-oK.js";
+import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-CDO6I3B0.js";
+
+//#region ../../plugins/acryl-router/src/connection.d.ts
+/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
+interface ConnectionInfo {
+  /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
+  readonly remoteAddress?: string | undefined;
+  /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
+  readonly localPort?: number | undefined;
+}
+/** What the router puts in `c.env`. */
+interface RouterBindings {
+  readonly connection: ConnectionInfo;
+}
+/** The `Env` of an `Acryl` that wants `c.env.connection` typed: `new Acryl<RouterEnv>()`. */
+interface RouterEnv {
+  Bindings: RouterBindings;
+}
+/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
+declare function connectionOf(c: Context): ConnectionInfo;
+/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { type AddressType, type ConnInfo, type ConnectionInfo, type GetConnInfo, type NetAddrInfo, type RouterBindings, type RouterEnv, connectionOf, getConnInfo };

package/lib/conninfo.js

@@ -0,0 +1,2 @@
+import { n as getConnInfo, t as connectionOf } from "./connection-C7xgP1hP.js";
+export { connectionOf, getConnInfo };

package/lib/constants-Dy7ZvN1H.js

@@ -0,0 +1,4 @@
+//#region ../../plugins/acryl-router/src/core/request/constants.ts
+const GET_MATCH_RESULT = Symbol();
+//#endregion
+export { GET_MATCH_RESULT as t };