@revojs/server 0.2.65 → 0.3.0

package/dist/index.d.ts

@@ -27,6 +27,10 @@ export interface FetchOptions extends RequestInit {
     json?: unknown;
     forwardHeaders?: Array<string>;
 }
+export interface ApiMiddlewareOptions {
+    sameOrigin?: boolean;
+    contentTypes?: Array<string>;
+}
 export interface ServerContext {
     states: Record<string, unknown>;
     request: Request;
@@ -60,6 +64,12 @@ export interface Server extends Route {
     schedules: Array<Schedule>;
     schedule: (scope: Scope) => Promise<void>;
 }
+export declare class FetchError<T = unknown> extends Error {
+    readonly status: number;
+    readonly response: Response;
+    readonly data: T | undefined;
+    constructor(response: Response, data?: T);
+}
 export declare function defineRoute<T extends Route>(route: T): T;
 export declare function defineMiddleware<T extends Middleware>(middleware: T): T;
 export declare function defineSchedule<T extends Schedule>(schedule: T): T;
@@ -76,6 +86,7 @@ export declare function createServerScope(request: Request, variables: object, s
         [x: string]: {} | undefined;
     } | undefined;
 } & Scope>;
+export declare function waitUntil(scope: Scope, promise: Promise<unknown>): void;
 export declare function useSchedule(scope: Scope): ScheduleContext;
 export declare function useUrl(scope: Scope, base?: string): URL;
 export declare function requireSameOrigin(scope: Scope): void;
@@ -115,6 +126,9 @@ export declare function setState<T>(scope: Scope, name: string, value: T): void;
 export declare function fetch<T>(scope: Scope, input: string | URL, options?: FetchOptions): Promise<T>;
 export declare function invoke(scope: Scope, pipeline: Array<Middleware>, index?: number): Promise<Result>;
 export declare function invokeWebSocket(webSocket: WebSocket, connection: WebSocketConnection, invoke: () => Awaitable<void>): Promise<void>;
+export declare function createApiMiddleware(options?: ApiMiddlewareOptions): {
+    fetch(scope: Scope, next: (() => Result) | undefined): Promise<void | Response | WebSocket>;
+};
 export declare function createStaticMiddleware(resolve: (path: string | URL) => Awaitable<Blob>): {
     fetch(scope: Scope, next: (() => Result) | undefined): Promise<void | Response | WebSocket>;
 };
@@ -122,6 +136,7 @@ export declare function createServer(): Promise<Server>;
 export declare const SERVER_CONTEXT: import("revojs").Descriptor<ServerContext>;
 export declare const SERVER_ROUTER_CONTEXT: import("revojs").Descriptor<RouterContext<Route>>;
 export declare const SCHEDULE_CONTEXT: import("revojs").Descriptor<ScheduleContext>;
+export declare const WAIT_UNTIL_CONTEXT: import("revojs").Descriptor<(promise: Promise<unknown>) => void>;
 export declare const cookiePriorities: readonly ["Low", "Medium", "High"];
 export declare const cookieSameSites: readonly ["Lax", "Strict", "None"];
 export declare const httpMethods: readonly ["GET", "HEAD", "PATCH", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE"];

package/dist/index.js

@@ -5,6 +5,18 @@ import { isClient, isServer } from "#variables";
 import { Router, STATE_CONTEXT, VARIABLE_CONTEXT, createScope, defineContext, getContext, setContext, useRoute, useVariables } from "revojs";
 import { scheduleAliases } from "revojs/shared";
 //#region src/index.ts
+var FetchError = class extends Error {
+	status;
+	response;
+	data;
+	constructor(response, data) {
+		super(`Request to ${response.url || "server"} failed with ${response.status}`);
+		this.name = "FetchError";
+		this.status = response.status;
+		this.response = response;
+		this.data = data;
+	}
+};
 function defineRoute(route) {
 	return route;
 }
@@ -52,6 +64,16 @@ function createServerScope(request, variables, states = {}) {
 		}
 	} });
 }
+function waitUntil(scope, promise) {
+	const tracked = (async () => {
+		try {
+			await promise;
+		} catch (error) {
+			console.error(error);
+		}
+	})();
+	if (Object.hasOwn(scope.context, WAIT_UNTIL_CONTEXT)) getContext(scope, WAIT_UNTIL_CONTEXT)(tracked);
+}
 function useSchedule(scope) {
 	return getContext(scope, SCHEDULE_CONTEXT);
 }
@@ -174,10 +196,8 @@ function sendResponse(scope, body, config) {
 	const { response } = useServer(scope);
 	if (body !== null && body !== void 0 && !response.headers.has("Content-Type")) {
 		if (typeof body === "object" && !ArrayBuffer.isView(body)) {
-			if (body instanceof FormData) response.headers.set("Content-Type", "multipart/form-data");
-			else if (body instanceof URLSearchParams) response.headers.set("Content-Type", "application/x-www-form-urlencoded");
-			else if (body instanceof ReadableStream) response.headers.set("Content-Type", "application/octet-stream");
-			else if (!(body instanceof Blob)) {
+			if (body instanceof ReadableStream) response.headers.set("Content-Type", "application/octet-stream");
+			else if (!(body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams)) {
 				response.headers.set("Content-Type", "application/json");
 				body = JSON.stringify(body);
 			}
@@ -256,6 +276,15 @@ function getState(scope, name) {
 function setState(scope, name, value) {
 	useStates(scope)[name] = value;
 }
+async function readResponse(response) {
+	const contentType = response.headers.get("Content-Type")?.split(";").shift()?.trim().toLowerCase() ?? "";
+	if (response.status === 204 || response.status === 205 || response.body === null) return;
+	if (contentType === "application/json" || contentType.endsWith("+json")) return response.json();
+	if (contentType === "" || contentType === "text/event-stream") return response;
+	if (contentType.startsWith("text/") || contentType === "application/javascript" || contentType === "application/xml" || contentType.endsWith("+xml")) return response.text();
+	if (contentType === "multipart/form-data") return response.formData();
+	return response.blob();
+}
 async function fetch(scope, input, options = {}) {
 	const { json, forwardHeaders, ...init } = options;
 	const headers = new Headers(init.headers);
@@ -276,33 +305,23 @@ async function fetch(scope, input, options = {}) {
 				const value = request.headers.get(name);
 				if (value !== null && !headers.has(name)) headers.set(name, value);
 			}
-			const result = await (await import("#server")).default.fetch(await createServerScope(new Request(url, init), useVariables(scope), states));
+			const child = await createServerScope(new Request(url, init), useVariables(scope), states);
+			if (Object.hasOwn(scope.context, WAIT_UNTIL_CONTEXT)) setContext(child, WAIT_UNTIL_CONTEXT, getContext(scope, WAIT_UNTIL_CONTEXT));
+			const result = await (await import("#server")).default.fetch(child);
 			if (isResponse(result)) response = result;
 		}
 	}
 	response ??= await globalThis.fetch(input, init);
-	if (response.ok === false) throw response;
-	switch (response.headers.get("Content-Type")?.split(";").shift() ?? "") {
-		case "application/json": return response.json();
-		case "text/plain":
-		case "text/html":
-		case "text/css":
-		case "text/xml":
-		case "application/xml":
-		case "application/javascript": return response.text();
-		case "application/octet-stream":
-		case "application/pdf":
-		case "application/zip":
-		case "image/png":
-		case "image/jpeg":
-		case "image/gif":
-		case "image/webp":
-		case "image/svg+xml":
-		case "audio/mpeg":
-		case "video/mp4": return response.blob();
-		case "multipart/form-data": return response.formData();
-		default: return response;
+	if (!response.ok) {
+		let data;
+		try {
+			data = await readResponse(response.clone());
+		} catch {
+			data = void 0;
+		}
+		throw new FetchError(response, data);
 	}
+	return await readResponse(response);
 }
 async function invoke(scope, pipeline, index = 0) {
 	return await pipeline.at(index)?.fetch(scope, async () => await invoke(scope, pipeline, index + 1));
@@ -311,10 +330,31 @@ async function invokeWebSocket(webSocket, connection, invoke) {
 	try {
 		await invoke();
 	} catch (error) {
-		if (error instanceof Error) await webSocket.error(connection, error);
-		else throw error;
+		let cause = new Error(String(error), { cause: error });
+		if (error instanceof Error) cause = error;
+		try {
+			await webSocket.error(connection, cause);
+		} catch (failure) {
+			console.error(failure);
+		}
 	}
 }
+function createApiMiddleware(options = {}) {
+	return defineMiddleware({ async fetch(scope, next) {
+		const { request, response } = useServer(scope);
+		response.headers.set("Cache-Control", "no-store");
+		if (![
+			"GET",
+			"HEAD",
+			"OPTIONS"
+		].includes(request.method)) {
+			if (options.sameOrigin !== false) requireSameOrigin(scope);
+			const contentType = request.headers.get("Content-Type")?.split(";").shift()?.trim().toLowerCase();
+			if (options.contentTypes && request.body !== null && (contentType === void 0 || !options.contentTypes.includes(contentType))) return sendResponse(scope, `Content-Type must be ${options.contentTypes.join(" or ")}`, { status: 415 });
+		}
+		return next?.();
+	} });
+}
 function createStaticMiddleware(resolve) {
 	return defineMiddleware({ async fetch(scope, next) {
 		const { pathname } = useUrl(scope);
@@ -345,7 +385,18 @@ async function createServer() {
 		const segments = path.split("/");
 		for (const attribute of segments.pop()?.split(".") ?? []) if (httpMethods.includes(attribute.toUpperCase())) segments.unshift(attribute);
 		else segments.push(attribute);
-		const route = await resolve();
+		let loading;
+		const route = { async fetch(scope, next) {
+			loading ??= resolve();
+			let loaded;
+			try {
+				loaded = await loading;
+			} catch (error) {
+				loading = void 0;
+				throw error;
+			}
+			return await loaded?.fetch(scope, next);
+		} };
 		if (segments.at(-1)?.startsWith("+")) for (const method of httpMethods) router.use([method.toLowerCase(), ...segments], route);
 		else router.use(segments, route);
 	}
@@ -371,16 +422,24 @@ async function createServer() {
 		async schedule(scope) {
 			const { when } = useSchedule(scope);
 			const expression = scheduleAliases[when.trim().toLowerCase()] ?? when.trim();
+			const errors = new Array();
 			for (const schedule of scheduled) {
 				if ((scheduleAliases[schedule.when.trim().toLowerCase()] ?? schedule.when.trim()) !== expression) continue;
-				await schedule.run(scope);
+				try {
+					await schedule.run(scope);
+				} catch (error) {
+					console.error(error);
+					errors.push(error);
+				}
 			}
+			if (errors.length > 0) throw new AggregateError(errors, `${errors.length} schedules failed for "${when}"`);
 		}
 	};
 }
 var SERVER_CONTEXT = defineContext("SERVER_CONTEXT");
 var SERVER_ROUTER_CONTEXT = defineContext("SERVER_ROUTER_CONTEXT");
 var SCHEDULE_CONTEXT = defineContext("SCHEDULE_CONTEXT");
+var WAIT_UNTIL_CONTEXT = defineContext("WAIT_UNTIL_CONTEXT");
 var cookiePriorities = [
 	"Low",
 	"Medium",
@@ -490,4 +549,4 @@ var statusCodes = [
 	599
 ];
 //#endregion
-export { SCHEDULE_CONTEXT, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, cookiePriorities, cookieSameSites, createServer, createServerScope, createStaticMiddleware, createWebSocket, defineMiddleware, defineRoute, defineSchedule, deleteCookie, encodings, fetch, getState, httpMethods, invoke, invokeWebSocket, isResponse, isWebSocket, parseCookiePair, requireSameOrigin, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useBodyAsync, useCookies, useCookiesAsync, useHeaders, useHeadersAsync, useParameters, useParametersAsync, useQuery, useQueryAsync, useRouter, useSchedule, useServer, useSetCookies, useSetCookiesAsync, useUrl, withQuery };
+export { FetchError, SCHEDULE_CONTEXT, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, WAIT_UNTIL_CONTEXT, cookiePriorities, cookieSameSites, createApiMiddleware, createServer, createServerScope, createStaticMiddleware, createWebSocket, defineMiddleware, defineRoute, defineSchedule, deleteCookie, encodings, fetch, getState, httpMethods, invoke, invokeWebSocket, isResponse, isWebSocket, parseCookiePair, requireSameOrigin, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useBodyAsync, useCookies, useCookiesAsync, useHeaders, useHeadersAsync, useParameters, useParametersAsync, useQuery, useQueryAsync, useRouter, useSchedule, useServer, useSetCookies, useSetCookiesAsync, useUrl, waitUntil, withQuery };

package/dist/package.js

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "@revojs/server";
-var version = "0.2.65";
+var version = "0.3.0";
 var repository = {
 	"type": "git",
 	"url": "git+https://github.com/tellua/revojs.git"
@@ -28,11 +28,11 @@ var scripts = {
 var dependencies = {
 	"@standard-schema/spec": "^1.1.0",
 	"croner": "^10.0.1",
-	"revojs": "*",
+	"revojs": "0.3.0",
 	"ws": "^8.22.0"
 };
 var devDependencies = {
-	"@revojs/tsconfig": "*",
+	"@revojs/tsconfig": "0.3.0",
 	"@types/ws": "^8.18.2"
 };
 var package_default = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/server",
-    "version": "0.2.65",
+    "version": "0.3.0",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -31,11 +31,11 @@
     "dependencies": {
         "@standard-schema/spec": "^1.1.0",
         "croner": "^10.0.1",
-        "revojs": "*",
+        "revojs": "0.3.0",
         "ws": "^8.22.0"
     },
     "devDependencies": {
-        "@revojs/tsconfig": "*",
+        "@revojs/tsconfig": "0.3.0",
         "@types/ws": "^8.18.2"
     }
 }