acrylblends 0.4.0 → 0.5.0

package/lib/accepts.d.ts

@@ -0,0 +1,33 @@
+import { t as Context } from "./context-Bm7rI-oK.js";
+import { t as AcceptHeader } from "./headers-tu2YYN8T.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/accepts/accepts.d.ts
+interface Accept {
+  type: string;
+  params: Record<string, string>;
+  q: number;
+}
+interface acceptsConfig {
+  header: AcceptHeader;
+  supports: string[];
+  default: string;
+}
+interface acceptsOptions extends acceptsConfig {
+  match?: (accepts: Accept[], config: acceptsConfig) => string;
+}
+/**
+ * Match the accept header with the given options.
+ * @example
+ * ```ts
+ * app.get('/users', (c) => {
+ *   const lang = accepts(c, {
+ *     header: 'Accept-Language',
+ *     supports: ['en', 'zh'],
+ *     default: 'en',
+ *   })
+ * })
+ * ```
+ */
+declare const accepts: (c: Context, options: acceptsOptions) => string;
+//#endregion
+export { accepts };

package/lib/accepts.js

@@ -0,0 +1,2 @@
+import { t as accepts } from "./accepts-XBuZPVRI.js";
+export { accepts };

package/lib/acryl-base.d.ts

@@ -0,0 +1,2 @@
+import { $ as Acryl, et as AcrylOptions } from "./context-Bm7rI-oK.js";
+export { Acryl as AcrylBase, AcrylOptions };

package/lib/acryl-base.js

@@ -0,0 +1,332 @@
+import { t as compose } from "./compose-BuW2B6PZ.js";
+import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
+import { t as Context } from "./context-DDO0cfuP.js";
+import { METHODS } from "./router.js";
+import { COMPOSED_HANDLER } from "./utils/constants.js";
+//#region ../../plugins/acryl-router/src/core/app-base.ts
+/**
+* @module
+* This module is the base module for the Acryl object.
+*/
+const notFoundHandler = (c) => {
+	return c.text("404 Not Found", 404);
+};
+const errorHandler = (err, c) => {
+	if ("getResponse" in err) {
+		const res = err.getResponse();
+		return c.newResponse(res.body, res);
+	}
+	console.error(err);
+	return c.text("Internal Server Error", 500);
+};
+var Acryl = class Acryl {
+	get;
+	post;
+	put;
+	delete;
+	options;
+	patch;
+	query;
+	all;
+	on;
+	use;
+	router;
+	getPath;
+	_basePath = "/";
+	#path = "/";
+	routes = [];
+	constructor(options = {}) {
+		[...METHODS, "all"].forEach((method) => {
+			this[method] = (args1, ...args) => {
+				const methodName = method.toUpperCase();
+				if (typeof args1 === "string") this.#path = args1;
+				else this.#addRoute(methodName, this.#path, args1);
+				args.forEach((handler) => {
+					this.#addRoute(methodName, this.#path, handler);
+				});
+				return this;
+			};
+		});
+		this.on = (method, path, ...handlers) => {
+			for (const p of [path].flat()) {
+				this.#path = p;
+				for (const m of [method].flat()) {
+					const methodName = m.toUpperCase();
+					for (const handler of handlers) this.#addRoute(methodName, this.#path, handler);
+				}
+			}
+			return this;
+		};
+		this.use = (arg1, ...handlers) => {
+			if (typeof arg1 === "string") this.#path = arg1;
+			else {
+				this.#path = "*";
+				handlers.unshift(arg1);
+			}
+			handlers.forEach((handler) => {
+				this.#addRoute("ALL", this.#path, handler);
+			});
+			return this;
+		};
+		const { strict, ...optionsWithoutStrict } = options;
+		Object.assign(this, optionsWithoutStrict);
+		this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+	}
+	#clone() {
+		const clone = new Acryl({
+			router: this.router,
+			getPath: this.getPath
+		});
+		clone.errorHandler = this.errorHandler;
+		clone.#notFoundHandler = this.#notFoundHandler;
+		clone.routes = this.routes;
+		return clone;
+	}
+	#notFoundHandler = notFoundHandler;
+	errorHandler = errorHandler;
+	/**
+	* `.route()` allows grouping other Acryl instance in routes.
+	*
+	*
+	* @param {string} path - base Path
+	* @param {Acryl} app - other Acryl instance
+	* @returns {Acryl} routed Acryl instance
+	*
+	* @example
+	* ```ts
+	* const app = new Acryl()
+	* const app2 = new Acryl()
+	*
+	* app2.get("/user", (c) => c.text("user"))
+	* app.route("/api", app2) // GET /api/user
+	* ```
+	*/
+	route(path, app) {
+		const subApp = this.basePath(path);
+		app.routes.map((r) => {
+			let handler;
+			if (app.errorHandler === errorHandler) handler = r.handler;
+			else {
+				handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+				handler[COMPOSED_HANDLER] = r.handler;
+			}
+			subApp.#addRoute(r.method, r.path, handler, r.basePath);
+		});
+		return this;
+	}
+	/**
+	* `.basePath()` allows base paths to be specified.
+	*
+	*
+	* @param {string} path - base Path
+	* @returns {Acryl} changed Acryl instance
+	*
+	* @example
+	* ```ts
+	* const api = new Acryl().basePath('/api')
+	* ```
+	*/
+	basePath(path) {
+		const subApp = this.#clone();
+		subApp._basePath = mergePath(this._basePath, path);
+		return subApp;
+	}
+	/**
+	* `.onError()` handles an error and returns a customized Response.
+	*
+	*
+	* @param {ErrorHandler} handler - request Handler for error
+	* @returns {Acryl} changed Acryl instance
+	*
+	* @example
+	* ```ts
+	* app.onError((err, c) => {
+	*   console.error(`${err}`)
+	*   return c.text('Custom Error Message', 500)
+	* })
+	* ```
+	*/
+	onError = (handler) => {
+		this.errorHandler = handler;
+		return this;
+	};
+	/**
+	* `.notFound()` allows you to customize a Not Found Response.
+	*
+	*
+	* @param {NotFoundHandler} handler - request handler for not-found
+	* @returns {Acryl} changed Acryl instance
+	*
+	* @example
+	* ```ts
+	* app.notFound((c) => {
+	*   return c.text('Custom 404 Message', 404)
+	* })
+	* ```
+	*/
+	notFound = (handler) => {
+		this.#notFoundHandler = handler;
+		return this;
+	};
+	/**
+	* `.mount()` allows you to mount applications built with other frameworks into your Acryl application.
+	*
+	* @deprecated Use `mount()` from `acryl-router/mount` instead. `.mount()` will be removed in v5.
+	*
+	*
+	* @param {string} path - base Path
+	* @param {Function} applicationHandler - other Request Handler
+	* @param {MountOptions} [options] - options of `.mount()`
+	* @returns {Acryl} mounted Acryl instance
+	*
+	* @example
+	* ```ts
+	* import { Router as IttyRouter } from 'itty-router'
+	* import { Acryl } from 'acrylblends'
+	* // Create itty-router application
+	* const ittyRouter = IttyRouter()
+	* // GET /itty-router/hello
+	* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+	*
+	* const app = new Acryl()
+	* app.mount('/itty-router', ittyRouter.handle)
+	* ```
+	*
+	* @example
+	* ```ts
+	* const app = new Acryl()
+	* // Send the request to another application without modification.
+	* app.mount('/app', anotherApp, {
+	*   replaceRequest: (req) => req,
+	* })
+	* ```
+	*/
+	mount(path, applicationHandler, options) {
+		let replaceRequest;
+		let optionHandler;
+		if (options) if (typeof options === "function") optionHandler = options;
+		else {
+			optionHandler = options.optionHandler;
+			if (options.replaceRequest === false) replaceRequest = (request) => request;
+			else replaceRequest = options.replaceRequest;
+		}
+		const getOptions = optionHandler ? (c) => {
+			const options = optionHandler(c);
+			return Array.isArray(options) ? options : [options];
+		} : (c) => {
+			let executionContext = void 0;
+			try {
+				executionContext = c.executionCtx;
+			} catch {}
+			return [c.env, executionContext];
+		};
+		replaceRequest ||= (() => {
+			const mergedPath = mergePath(this._basePath, path);
+			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+			return (request) => {
+				const url = new URL(request.url);
+				url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
+				return new Request(url, request);
+			};
+		})();
+		const handler = async (c, next) => {
+			const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+			if (res) return res;
+			await next();
+		};
+		this.#addRoute("ALL", mergePath(path, "*"), handler);
+		return this;
+	}
+	#addRoute(method, path, handler, baseRoutePath) {
+		path = mergePath(this._basePath, path);
+		const r = {
+			basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+			path,
+			method,
+			handler
+		};
+		this.router.add(method, path, [handler, r]);
+		this.routes.push(r);
+	}
+	#handleError(err, c) {
+		if (err instanceof Error) return this.errorHandler(err, c);
+		throw err;
+	}
+	#dispatch(request, executionCtx, env, method) {
+		if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+		const path = this.getPath(request, { env });
+		const matchResult = this.router.match(method, path);
+		const c = new Context(request, {
+			path,
+			matchResult,
+			env,
+			executionCtx,
+			notFoundHandler: this.#notFoundHandler
+		});
+		if (matchResult[0].length === 1) {
+			let res;
+			try {
+				res = matchResult[0][0][0][0](c, async () => {
+					c.res = await this.#notFoundHandler(c);
+				});
+			} catch (err) {
+				return this.#handleError(err, c);
+			}
+			return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+		}
+		const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+		return (async () => {
+			try {
+				const context = await composed(c);
+				if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+				return context.res;
+			} catch (err) {
+				return this.#handleError(err, c);
+			}
+		})();
+	}
+	/**
+	* `.fetch()` will be entry point of your app.
+	*
+	*
+	* @param {Request} request - request Object of request
+	* @param {Env} env - env Object
+	* @param {ExecutionContext} executionCtx - context of execution
+	* @returns {Response | Promise<Response>} response of request
+	*
+	*/
+	fetch = (request, ...rest) => {
+		return this.#dispatch(request, rest[1], rest[0], request.method);
+	};
+	/**
+	* `.request()` is a useful method for testing.
+	* You can pass a URL or pathname to send a GET request.
+	* app will return a Response object.
+	* ```ts
+	* test('GET /hello is ok', async () => {
+	*   const res = await app.request('/hello')
+	*   expect(res.status).toBe(200)
+	* })
+	* ```
+	*/
+	request = (input, requestInit, Env, executionCtx) => {
+		if (input instanceof Request) return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+		input = input.toString();
+		return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
+	};
+	/**
+	* `.fire()` automatically adds a global fetch event listener.
+	* This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+	* @deprecated
+	* ACRYL ships no service-worker adapter: mount the app with `ctx.router.route(path, app)` and serve it through an ACRYL adapter instead.
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+	* @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+	*/
+	fire = () => {
+		addEventListener("fetch", (event) => {
+			event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+		});
+	};
+};
+//#endregion
+export { Acryl as AcrylBase };

package/lib/adapter.d.ts

@@ -0,0 +1,12 @@
+import { t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/adapter/index.d.ts
+type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'other';
+declare const env: <T extends Record<string, unknown>, C extends Context = Context<{
+  Bindings: T;
+}>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
+declare const knownUserAgents: Partial<Record<Runtime, string>>;
+declare const getRuntimeKey: () => Runtime;
+declare const checkUserAgentEquals: (platform: string) => boolean;
+//#endregion
+export { Runtime, checkUserAgentEquals, env, getRuntimeKey, knownUserAgents };

package/lib/adapter.js

@@ -0,0 +1,37 @@
+//#region ../../plugins/acryl-router/src/core/helper/adapter/index.ts
+const env = (c, runtime) => {
+	const globalEnv = globalThis?.process?.env;
+	runtime ??= getRuntimeKey();
+	return {
+		bun: () => globalEnv,
+		node: () => globalEnv,
+		"edge-light": () => globalEnv,
+		deno: () => {
+			return Deno.env.toObject();
+		},
+		workerd: () => c.env,
+		fastly: () => ({}),
+		other: () => ({})
+	}[runtime]();
+};
+const knownUserAgents = {
+	deno: "Deno",
+	bun: "Bun",
+	workerd: "Cloudflare-Workers",
+	node: "Node.js"
+};
+const getRuntimeKey = () => {
+	const global = globalThis;
+	if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string") {
+		for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) if (checkUserAgentEquals(userAgent)) return runtimeKey;
+	}
+	if (typeof global?.EdgeRuntime === "string") return "edge-light";
+	if (global?.fastly !== void 0) return "fastly";
+	if (global?.process?.release?.name === "node") return "node";
+	return "other";
+};
+const checkUserAgentEquals = (platform) => {
+	return navigator.userAgent.startsWith(platform);
+};
+//#endregion
+export { checkUserAgentEquals, env, getRuntimeKey, knownUserAgents };

package/lib/app-BM0rTCp7.js

@@ -0,0 +1,26 @@
+import { AcrylBase as Acryl$1 } from "./acryl-base.js";
+import { i as RegExpRouter } from "./reg-exp-router-DC1R3qoY.js";
+import { t as SmartRouter } from "./smart-router-C5CZ5XSM.js";
+import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
+//#region ../../plugins/acryl-router/src/core/app.ts
+/**
+* The Acryl class extends the functionality of the AcrylBase class.
+* It sets up routing and allows for custom options to be passed.
+*
+* @template E - The environment type.
+* @template S - The schema type.
+* @template BasePath - The base path type.
+*/
+var Acryl = class extends Acryl$1 {
+	/**
+	* Creates an instance of the Acryl class.
+	*
+	* @param options - Optional configuration options for the Acryl instance.
+	*/
+	constructor(options = {}) {
+		super(options);
+		this.router = options.router ?? new SmartRouter({ routers: [new RegExpRouter(), new TrieRouter()] });
+	}
+};
+//#endregion
+export { Acryl as t };

package/lib/app-CmAYW1Al.d.ts

@@ -0,0 +1,21 @@
+import { $ as Acryl$1, J as Schema, _ as Env, et as AcrylOptions, h as BlankSchema, p as BlankEnv } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/app.d.ts
+/**
+ * The Acryl class extends the functionality of the AcrylBase class.
+ * It sets up routing and allows for custom options to be passed.
+ *
+ * @template E - The environment type.
+ * @template S - The schema type.
+ * @template BasePath - The base path type.
+ */
+declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Acryl$1<E, S, BasePath> {
+  /**
+   * Creates an instance of the Acryl class.
+   *
+   * @param options - Optional configuration options for the Acryl instance.
+   */
+  constructor(options?: AcrylOptions<E>);
+}
+//#endregion
+export { Acryl as t };

package/lib/basic-auth.d.ts

@@ -0,0 +1,72 @@
+import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/basic-auth/index.d.ts
+type MessageFunction = (c: Context) => string | object | Promise<string | object>;
+type BasicAuthOptions = {
+  username: string;
+  password: string;
+  realm?: string;
+  hashFunction?: Function;
+  invalidUserMessage?: string | object | MessageFunction;
+  onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
+} | {
+  verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
+  realm?: string;
+  hashFunction?: Function;
+  invalidUserMessage?: string | object | MessageFunction;
+  onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
+};
+/**
+ * Basic Auth Middleware for Acryl.
+ *
+ *
+ * @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+ * @param {string} options.username - The username for authentication.
+ * @param {string} options.password - The password for authentication.
+ * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+ * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {Function} [options.verifyUser] - The function to verify user credentials.
+ * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
+ * @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: process.env.BASIC_AUTH_USERNAME,
+ *     password: process.env.BASIC_AUTH_PASSWORD,
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With onAuthSuccess callback
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: process.env.BASIC_AUTH_USERNAME,
+ *     password: process.env.BASIC_AUTH_PASSWORD,
+ *     onAuthSuccess: (c, username) => {
+ *       c.set('user', { name: username, role: 'admin' })
+ *       console.log(`User ${username} authenticated`)
+ *     },
+ *   })
+ * )
+ * ```
+ */
+declare const basicAuth: (options: BasicAuthOptions, ...users: {
+  username: string;
+  password: string;
+}[]) => MiddlewareHandler;
+//#endregion
+export { basicAuth };

package/lib/basic-auth.js

@@ -0,0 +1,95 @@
+import { HTTPException } from "./http-exception.js";
+import { timingSafeEqual } from "./utils/buffer.js";
+import { auth } from "./utils/basic-auth.js";
+//#region ../../plugins/acryl-router/src/core/middleware/basic-auth/index.ts
+/**
+* Basic Auth Middleware for Acryl.
+*
+*
+* @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+* @param {string} options.username - The username for authentication.
+* @param {string} options.password - The password for authentication.
+* @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+* @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+* @param {Function} [options.verifyUser] - The function to verify user credentials.
+* @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
+* @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.
+* @returns {MiddlewareHandler} The middleware handler function.
+* @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(
+*   '/auth/*',
+*   basicAuth({
+*     username: process.env.BASIC_AUTH_USERNAME,
+*     password: process.env.BASIC_AUTH_PASSWORD,
+*   })
+* )
+*
+* app.get('/auth/page', (c) => {
+*   return c.text('You are authorized')
+* })
+* ```
+*
+* @example
+* ```ts
+* // With onAuthSuccess callback
+* app.use(
+*   '/auth/*',
+*   basicAuth({
+*     username: process.env.BASIC_AUTH_USERNAME,
+*     password: process.env.BASIC_AUTH_PASSWORD,
+*     onAuthSuccess: (c, username) => {
+*       c.set('user', { name: username, role: 'admin' })
+*       console.log(`User ${username} authenticated`)
+*     },
+*   })
+* )
+* ```
+*/
+const basicAuth = (options, ...users) => {
+	const usernamePasswordInOptions = "username" in options && "password" in options;
+	const verifyUserInOptions = "verifyUser" in options;
+	if (!(usernamePasswordInOptions || verifyUserInOptions)) throw new Error("basic auth middleware requires options for \"username and password\" or \"verifyUser\"");
+	if (!options.realm) options.realm = "Secure Area";
+	if (!options.invalidUserMessage) options.invalidUserMessage = "Unauthorized";
+	if (usernamePasswordInOptions) users.unshift({
+		username: options.username,
+		password: options.password
+	});
+	return async function basicAuth(ctx, next) {
+		const requestUser = auth(ctx.req.raw);
+		if (requestUser) if (verifyUserInOptions) {
+			if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+				if (options.onAuthSuccess) await options.onAuthSuccess(ctx, requestUser.username);
+				await next();
+				return;
+			}
+		} else for (const user of users) {
+			const [usernameEqual, passwordEqual] = await Promise.all([timingSafeEqual(user.username, requestUser.username, options.hashFunction), timingSafeEqual(user.password, requestUser.password, options.hashFunction)]);
+			if (usernameEqual && passwordEqual) {
+				if (options.onAuthSuccess) await options.onAuthSuccess(ctx, requestUser.username);
+				await next();
+				return;
+			}
+		}
+		const status = 401;
+		const headers = { "WWW-Authenticate": "Basic realm=\"" + options.realm?.replace(/"/g, "\\\"") + "\"" };
+		const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
+		throw new HTTPException(status, { res: typeof responseMessage === "string" ? new Response(responseMessage, {
+			status,
+			headers
+		}) : new Response(JSON.stringify(responseMessage), {
+			status,
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			}
+		}) });
+	};
+};
+//#endregion
+export { basicAuth };