@revojs/server 0.2.8 → 0.2.9

package/dist/index.d.ts

@@ -64,8 +64,17 @@ export declare function isResponse(result: Result): result is Response;
 export declare function isWebSocket(result: Result): result is WebSocket;
 export declare function useRouter(scope: Scope): RouterContext<Route>;
 export declare function useServer(scope: Scope): ServerContext;
+export declare function createServerScope(request: Request, variables: object, states?: ServerContext["states"]): Promise<{
+    hooks?: {
+        [x: string]: ArrayLike<import("revojs").Hook> | undefined;
+    } | undefined;
+    context?: {
+        [x: string]: {} | undefined;
+    } | undefined;
+} & Scope>;
 export declare function useSchedule(scope: Scope): ScheduleContext;
 export declare function useUrl(scope: Scope, base?: string): URL;
+export declare function requireSameOrigin(scope: Scope): void;
 export declare function useParameters(scope: Scope): Record<string, string>;
 export declare function useParameters<T extends StandardSchemaV1>(scope: Scope, schema: T): StandardSchemaV1.InferOutput<T>;
 export declare function useParametersAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
@@ -101,16 +110,16 @@ export declare function getState<T>(scope: Scope, name: string): T;
 export declare function setState<T>(scope: Scope, name: string, value: T): void;
 export declare function fetch<T>(scope: Scope, input: string | URL, options?: RequestInit): 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 createStaticMiddleware(resolve: (path: string | URL) => Awaitable<Blob>): {
     fetch(scope: Scope, next: (() => Result) | undefined): Promise<void | Response | WebSocket>;
 };
 export declare function createServer(): Promise<Server>;
-export declare let STATES: Record<string, unknown>;
 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 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"];
-export declare const encodings: readonly ["ascii", "utf8", "utf8", "utf16le", "ucs2", "ucs-2", "base64", "latin1", "binary", "hex"];
+export declare const encodings: readonly ["ascii", "utf8", "utf16le", "ucs2", "ucs-2", "base64", "latin1", "binary", "hex"];
 export declare const statusCodes: readonly [100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 420, 421, 422, 423, 424, 425, 426, 428, 429, 431, 444, 450, 451, 497, 498, 499, 500, 501, 502, 503, 504, 506, 507, 508, 509, 510, 511, 521, 522, 523, 525, 530, 599];

package/dist/index.js

@@ -2,7 +2,7 @@ import assets from "#assets";
 import routes from "#routes";
 import schedules from "#schedules";
 import { isClient, isServer } from "#variables";
-import { Router, VARIABLE_CONTEXT, createScope, defineContext, getContext, setContext, useRoute, useVariables } from "revojs";
+import { Router, STATE_CONTEXT, VARIABLE_CONTEXT, createScope, defineContext, getContext, setContext, useRoute, useVariables } from "revojs";
 import { scheduleAliases } from "revojs/shared";
 //#region src/index.ts
 function defineRoute(route) {
@@ -23,7 +23,7 @@ function isResponse(result) {
 	return result instanceof Response;
 }
 function isWebSocket(result) {
-	return typeof result === "object" && "open" in result && "message" in result && "close" in result && "error" in result;
+	return result !== null && typeof result === "object" && "open" in result && "message" in result && "close" in result && "error" in result;
 }
 function parseSchema(scope, schema, value) {
 	const output = schema["~standard"].validate(value);
@@ -42,6 +42,16 @@ function useRouter(scope) {
 function useServer(scope) {
 	return getContext(scope, SERVER_CONTEXT);
 }
+function createServerScope(request, variables, states = {}) {
+	return createScope({ context: {
+		[VARIABLE_CONTEXT]: variables,
+		[SERVER_CONTEXT]: {
+			states,
+			request,
+			response: { headers: new Headers() }
+		}
+	} });
+}
 function useSchedule(scope) {
 	return getContext(scope, SCHEDULE_CONTEXT);
 }
@@ -50,13 +60,16 @@ function useUrl(scope, base) {
 	const fallback = typeof globalThis.window === "undefined" ? "about:blank" : globalThis.location.href;
 	return new URL(request?.url ?? fallback, base);
 }
+function requireSameOrigin(scope) {
+	const headers = useHeaders(scope);
+	if (headers.origin && headers.origin !== useUrl(scope).origin || headers["sec-fetch-site"] === "cross-site") throw sendForbidden(scope);
+}
 function useParameters(scope, schema) {
 	const { parameters } = useRoute(scope);
 	return schema ? parseSchema(scope, schema, parameters) : parameters;
 }
 function useParametersAsync(scope, schema) {
-	const { parameters } = useRoute(scope);
-	return parseSchemaAsync(scope, schema, parameters);
+	return parseSchemaAsync(scope, schema, useParameters(scope));
 }
 function useHeaders(scope, schema) {
 	const { request } = useServer(scope);
@@ -64,8 +77,7 @@ function useHeaders(scope, schema) {
 	return schema ? parseSchema(scope, schema, entries) : entries;
 }
 function useHeadersAsync(scope, schema) {
-	const { request } = useServer(scope);
-	return parseSchemaAsync(scope, schema, Object.fromEntries(request?.headers ?? []));
+	return parseSchemaAsync(scope, schema, useHeaders(scope));
 }
 function useQuery(scope, schema) {
 	const { searchParams } = useUrl(scope);
@@ -73,17 +85,22 @@ function useQuery(scope, schema) {
 	return schema ? parseSchema(scope, schema, entries) : entries;
 }
 function useQueryAsync(scope, schema) {
-	const { searchParams } = useUrl(scope);
-	return parseSchemaAsync(scope, schema, searchParams);
+	return parseSchemaAsync(scope, schema, useQuery(scope));
 }
 function withQuery(scope, input, query) {
 	const url = new URL(input, useUrl(scope));
 	for (const [name, value] of new URLSearchParams(query)) url.searchParams.set(name, value);
 	return url.href;
 }
-async function readBody(request) {
+async function readBody(scope) {
+	const { request } = useServer(scope);
 	const contentType = request.headers.get("Content-Type");
-	if (contentType?.includes("application/json")) return request.json();
+	if (contentType?.includes("application/json")) try {
+		return await request.json();
+	} catch (error) {
+		if (error instanceof SyntaxError) throw sendBadRequest(scope);
+		throw error;
+	}
 	if (contentType?.includes("multipart/form-data") || contentType?.includes("application/x-www-form-urlencoded")) {
 		const formData = await request.formData();
 		return Object.fromEntries(formData.entries());
@@ -91,13 +108,11 @@ async function readBody(request) {
 	return {};
 }
 async function useBody(scope, schema) {
-	const { request } = useServer(scope);
-	const entries = await readBody(request);
+	const entries = await readBody(scope);
 	return schema ? parseSchema(scope, schema, entries) : entries;
 }
 async function useBodyAsync(scope, schema) {
-	const { request } = useServer(scope);
-	return parseSchemaAsync(scope, schema, await readBody(request));
+	return parseSchemaAsync(scope, schema, await readBody(scope));
 }
 function parseCookiePair(cookie) {
 	const index = cookie.indexOf("=");
@@ -121,12 +136,7 @@ function useCookies(scope, schema) {
 	return schema ? parseSchema(scope, schema, entries) : entries;
 }
 function useCookiesAsync(scope, schema) {
-	const { request } = useServer(scope);
-	return parseSchemaAsync(scope, schema, (isClient ? document.cookie : request.headers.get("Cookie") ?? "").split(/;\s*/).reduce((result, cookie) => {
-		const pair = parseCookiePair(cookie);
-		if (pair) result[pair[0]] = pair[1];
-		return result;
-	}, {}));
+	return parseSchemaAsync(scope, schema, useCookies(scope));
 }
 function useSetCookies(scope, schema) {
 	const { request } = useServer(scope);
@@ -138,12 +148,7 @@ function useSetCookies(scope, schema) {
 	return schema ? parseSchema(scope, schema, entries) : entries;
 }
 function useSetCookiesAsync(scope, schema) {
-	const { request } = useServer(scope);
-	return parseSchemaAsync(scope, schema, (request.headers.getSetCookie?.() ?? []).reduce((result, cookie) => {
-		const pair = parseCookiePair(cookie.split(";").at(0) ?? "");
-		if (pair) result[pair[0]] = pair[1];
-		return result;
-	}, {}));
+	return parseSchemaAsync(scope, schema, useSetCookies(scope));
 }
 function setCookie(scope, name, value, options) {
 	const { response } = useServer(scope);
@@ -238,43 +243,25 @@ function sendNotFound(scope, body, config) {
 	response.status = 404;
 	return sendResponse(scope, body, config);
 }
-function getState(scope, name) {
+function useStates(scope) {
 	if (isServer) {
 		const { states } = useServer(scope);
-		return states[name];
-	} else {
-		if (STATES === void 0) {
-			const element = document.getElementById("states");
-			STATES = element?.textContent ? JSON.parse(element.textContent) : {};
-		}
-		return STATES[name];
+		return states;
 	}
+	return Object.hasOwn(scope.context, STATE_CONTEXT) ? getContext(scope, STATE_CONTEXT) : setContext(scope, STATE_CONTEXT, {});
+}
+function getState(scope, name) {
+	return useStates(scope)[name];
 }
 function setState(scope, name, value) {
-	if (isServer) {
-		const { states } = useServer(scope);
-		states[name] = value;
-	} else {
-		if (STATES === void 0) {
-			const element = document.getElementById("states");
-			STATES = element?.textContent ? JSON.parse(element.textContent) : {};
-		}
-		STATES[name] = value;
-	}
+	useStates(scope)[name] = value;
 }
 async function fetch(scope, input, options) {
 	let response;
 	if (isServer) {
 		const { states, request } = useServer(scope);
 		const url = new URL(input.toString(), request.url);
-		const next = await createScope({ context: {
-			[VARIABLE_CONTEXT]: useVariables(scope),
-			[SERVER_CONTEXT]: {
-				states,
-				request: new Request(url, options),
-				response: { headers: new Headers() }
-			}
-		} });
+		const next = await createServerScope(new Request(url, options), useVariables(scope), states);
 		const previous = new URL(request.url);
 		if (url.origin === previous.origin) {
 			const result = await (await import("#server")).default.fetch(next);
@@ -308,6 +295,14 @@ async function fetch(scope, input, options) {
 async function invoke(scope, pipeline, index = 0) {
 	return await pipeline.at(index)?.fetch(scope, async () => await invoke(scope, pipeline, index + 1));
 }
+async function invokeWebSocket(webSocket, connection, invoke) {
+	try {
+		await invoke();
+	} catch (error) {
+		if (error instanceof Error) await webSocket.error(connection, error);
+		else throw error;
+	}
+}
 function createStaticMiddleware(resolve) {
 	return defineMiddleware({ async fetch(scope, next) {
 		const { pathname } = useUrl(scope);
@@ -323,7 +318,9 @@ 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);
-		router.use(segments, await resolve());
+		const route = await resolve();
+		if (segments.at(-1)?.startsWith("+")) for (const method of httpMethods) router.use([method.toLowerCase(), ...segments], route);
+		else router.use(segments, route);
 	}
 	for (const source of Object.values(schedules)) for (const resolve of Object.values(source)) {
 		const schedule = await resolve();
@@ -354,7 +351,6 @@ async function createServer() {
 		}
 	};
 }
-var STATES;
 var SERVER_CONTEXT = defineContext("SERVER_CONTEXT");
 var SERVER_ROUTER_CONTEXT = defineContext("SERVER_ROUTER_CONTEXT");
 var SCHEDULE_CONTEXT = defineContext("SCHEDULE_CONTEXT");
@@ -382,7 +378,6 @@ var httpMethods = [
 var encodings = [
 	"ascii",
 	"utf8",
-	"utf8",
 	"utf16le",
 	"ucs2",
 	"ucs-2",
@@ -468,4 +463,4 @@ var statusCodes = [
 	599
 ];
 //#endregion
-export { SCHEDULE_CONTEXT, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, STATES, cookiePriorities, cookieSameSites, createServer, createStaticMiddleware, createWebSocket, defineMiddleware, defineRoute, defineSchedule, deleteCookie, encodings, fetch, getState, httpMethods, invoke, isResponse, isWebSocket, parseCookiePair, 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 { 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 };

package/dist/module/index.d.ts

@@ -1,3 +1,5 @@
+import { type Config } from "revojs/module";
+export declare function addRoutes(config: Config, ...directories: Array<string>): void;
 declare const _default: import("revojs/module").Module<"server", Record<string, never>, []>;
 export default _default;
 export declare const SERVER = "ssr";

package/dist/module/index.js

@@ -6,17 +6,14 @@ import { addTypes, addVirtual, defineModule } from "revojs/module";
 import { isRunnableDevEnvironment } from "vite";
 import { WebSocketServer } from "ws";
 //#region src/module/index.ts
-function isResponse(result) {
-	return result instanceof Response;
-}
-function isWebSocket(result) {
-	return typeof result === "object" && "open" in result && "message" in result && "close" in result && "error" in result;
+function addRoutes(config, ...directories) {
+	config.sources.routes?.from?.push(...directories);
 }
 var module_default = defineModule({
 	name: "server",
 	setup(config) {
 		addVirtual(config, "server", () => "import { createServer } from '@revojs/server'; export default await createServer()");
-		addTypes(config, "server", () => `declare module "#server" { import type { Server } from "revojs"; const server: Server; export default server; }`);
+		addTypes(config, "server", () => `declare module "#server" { import type { Server } from "@revojs/server"; const server: Server; export default server; }`);
 		return {
 			sources: {
 				routes: {
@@ -58,7 +55,7 @@ var module_default = defineModule({
 						const target = devServer.environments["ssr"];
 						if (isRunnableDevEnvironment(target)) {
 							const { createScope, VARIABLE_CONTEXT } = await target.runner.import("revojs");
-							const { invoke, SCHEDULE_CONTEXT, SERVER_CONTEXT } = await target.runner.import("@revojs/server");
+							const { createServerScope, invoke, invokeWebSocket, isResponse, isWebSocket, SCHEDULE_CONTEXT } = await target.runner.import("@revojs/server");
 							const server = await target.runner.import("#server").then((module) => module.default);
 							if (server) {
 								for (const schedule of server.schedules) new Cron(schedule.when, async () => {
@@ -78,44 +75,22 @@ var module_default = defineModule({
 										}
 									};
 									webSocket.on("open", async () => {
-										try {
-											await webSocket.interneWebSocket.open(connection);
-										} catch (error) {
-											if (error instanceof Error) await webSocket.interneWebSocket.error(connection, error);
-											else throw error;
-										}
+										await invokeWebSocket(webSocket.interneWebSocket, connection, () => webSocket.interneWebSocket.open(connection));
 									});
 									webSocket.on("message", async (message) => {
-										try {
-											await webSocket.interneWebSocket.message(connection, Array.isArray(message) ? Buffer.concat(message) : message);
-										} catch (error) {
-											if (error instanceof Error) await webSocket.interneWebSocket.error(connection, error);
-											else throw error;
-										}
+										await invokeWebSocket(webSocket.interneWebSocket, connection, () => webSocket.interneWebSocket.message(connection, Array.isArray(message) ? Buffer.concat(message) : message));
 									});
 									webSocket.on("error", async (error) => {
 										await webSocket.interneWebSocket.error(connection, error);
 									});
 									webSocket.on("close", async (code, reason) => {
-										try {
-											await webSocket.interneWebSocket.close(connection, code, reason.toString());
-										} catch (error) {
-											if (error instanceof Error) await webSocket.interneWebSocket.error(connection, error);
-											else throw error;
-										}
+										await invokeWebSocket(webSocket.interneWebSocket, connection, () => webSocket.interneWebSocket.close(connection, code, reason.toString()));
 									});
 								});
 								devServer.httpServer?.on("upgrade", async (request, socket, head) => {
 									const protocol = request.headers["sec-websocket-protocol"];
 									if (protocol === "vite-hmr" || protocol === "vite-ping") return;
-									const scope = await createScope({ context: {
-										[VARIABLE_CONTEXT]: process.env,
-										[SERVER_CONTEXT]: {
-											states: {},
-											request: fromNodeRequest(request, new ServerResponse(request)),
-											response: { headers: new Headers() }
-										}
-									} });
+									const scope = await createServerScope(fromNodeRequest(request, new ServerResponse(request)), process.env);
 									const result = await invoke(scope, [server]);
 									if (isWebSocket(result)) webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
 										webSocket.interneWebSocket = result;
@@ -126,14 +101,7 @@ var module_default = defineModule({
 								return () => {
 									devServer.middlewares.use(async (request, response, next) => {
 										request.url = request.originalUrl;
-										const scope = await createScope({ context: {
-											[VARIABLE_CONTEXT]: process.env,
-											[SERVER_CONTEXT]: {
-												states: {},
-												request: fromNodeRequest(request, response),
-												response: { headers: new Headers() }
-											}
-										} });
+										const scope = await createServerScope(fromNodeRequest(request, response), process.env);
 										const result = await invoke(scope, [server]);
 										if (isResponse(result)) await toNodeRequest(result, response);
 										next();
@@ -149,4 +117,4 @@ var module_default = defineModule({
 });
 var SERVER = "ssr";
 //#endregion
-export { SERVER, module_default as default };
+export { SERVER, addRoutes, module_default as default };

package/dist/package.js

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "@revojs/server";
-var version = "0.2.8";
+var version = "0.2.9";
 var repository = {
 	"type": "git",
 	"url": "git+https://github.com/tellua/revojs.git"
@@ -22,6 +22,7 @@ var exports = {
 };
 var scripts = {
 	"build": "vite build",
+	"typecheck": "tsc --noEmit -p tsconfig.json",
 	"watch": "vite build --watch"
 };
 var dependencies = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/server",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -25,6 +25,7 @@
     },
     "scripts": {
         "build": "vite build",
+        "typecheck": "tsc --noEmit -p tsconfig.json",
         "watch": "vite build --watch"
     },
     "dependencies": {