@revojs/server 0.1.58

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { Router, type RouterContext, type Scope } from "revojs";
+import type { Awaitable, Mergeable } from "revojs/shared";
+export type ScheduleWhen = "@yearly" | "@annually" | "@monthly" | "@weekly" | "@daily" | "@midnight" | "@hourly" | "* * * * *" | "0 * * * *" | "0 0 * * *" | "0 0 * * 0" | "0 0 1 * *" | "0 0 1 1 *" | `${string} ${string} ${string} ${string} ${string}` | (string & {});
+export type CookiePriority = (typeof cookiePriorities)[number];
+export type CookieSameSite = (typeof cookieSameSites)[number];
+export type HttpMethod = (typeof httpMethods)[number];
+export type Encoding = (typeof encodings)[number];
+export type StatusCode = (typeof statusCodes)[number];
+export type Result = Awaitable<void | Response | WebSocket>;
+export interface CookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    priority?: CookiePriority;
+    sameSite?: CookieSameSite;
+    secure?: boolean;
+}
+export interface ResponseConfig extends Record<string, unknown> {
+    status?: StatusCode;
+    statusText?: string;
+    headers: Headers;
+}
+export interface ServerContext {
+    states: Record<string, unknown>;
+    request: Request;
+    response: ResponseConfig;
+}
+export interface WebSocketConnection {
+    send: (message: string | BufferSource) => Promise<void>;
+    close: (code?: number, reason?: string) => Promise<void>;
+}
+export interface WebSocket {
+    open: (connection: WebSocketConnection) => Awaitable<void>;
+    message: (connection: WebSocketConnection, message: string | ArrayBuffer | ArrayBufferView) => Awaitable<void>;
+    error: (connection: WebSocketConnection, error: Error) => Awaitable<void>;
+    close: (connection: WebSocketConnection, code?: number, reason?: string) => Awaitable<void>;
+}
+export interface Schedule {
+    when: ScheduleWhen;
+    run: (scope: Scope) => Awaitable<void>;
+}
+export interface ScheduleContext {
+    when: string;
+}
+export interface Route {
+    fetch: (scope: Scope) => Result;
+}
+export interface Middleware {
+    fetch: (scope: Scope, next?: () => Result) => Result;
+}
+export interface Server extends Route {
+    router: Router<Route>;
+    schedules: Array<Schedule>;
+    schedule: (scope: Scope) => Promise<void>;
+}
+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;
+export declare function createWebSocket<T extends WebSocket>(scope: Scope, webSocket: T): T;
+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 useSchedule(scope: Scope): ScheduleContext;
+export declare function useUrl(scope: Scope, base?: string): URL;
+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>>;
+export declare function useHeaders(scope: Scope): Record<string, string>;
+export declare function useHeaders<T extends StandardSchemaV1>(scope: Scope, schema: T): StandardSchemaV1.InferOutput<T>;
+export declare function useHeadersAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function useQuery(scope: Scope): Record<string, string>;
+export declare function useQuery<T extends StandardSchemaV1>(scope: Scope, schema: T): StandardSchemaV1.InferOutput<T>;
+export declare function useQueryAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function withQuery(scope: Scope, input: string, query: Record<string, string>): string;
+export declare function useBody(scope: Scope): Promise<Record<string, unknown>>;
+export declare function useBody<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function useBodyAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function parseCookiePair(cookie: string): readonly [string, string] | undefined;
+export declare function useCookies(scope: Scope): Record<string, string>;
+export declare function useCookies<T extends StandardSchemaV1>(scope: Scope, schema: T): StandardSchemaV1.InferOutput<T>;
+export declare function useCookiesAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function useSetCookies(scope: Scope): Record<string, string>;
+export declare function useSetCookies<T extends StandardSchemaV1>(scope: Scope, schema: T): StandardSchemaV1.InferOutput<T>;
+export declare function useSetCookiesAsync<T extends StandardSchemaV1>(scope: Scope, schema: T): Promise<StandardSchemaV1.InferOutput<T>>;
+export declare function setCookie(scope: Scope, name: string, value: string, options?: CookieOptions): void;
+export declare function deleteCookie(scope: Scope, name: string, options?: Omit<CookieOptions, "expires" | "maxAge">): void;
+export declare function sendResponse<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendOk<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendCreated<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendNoContent(scope: Scope, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendRedirect(scope: Scope, path: string, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendBadRequest<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendUnauthorized<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendForbidden<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+export declare function sendNotFound<T>(scope: Scope, body?: T | BodyInit, config?: Mergeable<ResponseConfig>): Response;
+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 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 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

@@ -0,0 +1,471 @@
+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 { scheduleAliases } from "revojs/shared";
+//#region src/index.ts
+function defineRoute(route) {
+	return route;
+}
+function defineMiddleware(middleware) {
+	return middleware;
+}
+function defineSchedule(schedule) {
+	return schedule;
+}
+function createWebSocket(scope, webSocket) {
+	const { upgrade } = useHeaders(scope);
+	if (upgrade === "websocket") return webSocket;
+	throw sendBadRequest(scope);
+}
+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 parseSchema(scope, schema, value) {
+	const output = schema["~standard"].validate(value);
+	if (output instanceof Promise) throw new Error("Schema validation is async. Use the async variant (e.g., useHeadersAsync).");
+	if ("issues" in output) throw sendBadRequest(scope, output);
+	return output.value;
+}
+async function parseSchemaAsync(scope, schema, value) {
+	const output = await schema["~standard"].validate(value);
+	if ("issues" in output) throw sendBadRequest(scope, output);
+	return output.value;
+}
+function useRouter(scope) {
+	return getContext(scope, SERVER_ROUTER_CONTEXT);
+}
+function useServer(scope) {
+	return getContext(scope, SERVER_CONTEXT);
+}
+function useSchedule(scope) {
+	return getContext(scope, SCHEDULE_CONTEXT);
+}
+function useUrl(scope, base) {
+	const { request } = useServer(scope);
+	const fallback = typeof globalThis.window === "undefined" ? "about:blank" : globalThis.location.href;
+	return new URL(request?.url ?? fallback, base);
+}
+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);
+}
+function useHeaders(scope, schema) {
+	const { request } = useServer(scope);
+	const entries = Object.fromEntries(request?.headers ?? []);
+	return schema ? parseSchema(scope, schema, entries) : entries;
+}
+function useHeadersAsync(scope, schema) {
+	const { request } = useServer(scope);
+	return parseSchemaAsync(scope, schema, Object.fromEntries(request?.headers ?? []));
+}
+function useQuery(scope, schema) {
+	const { searchParams } = useUrl(scope);
+	const entries = Object.fromEntries(searchParams);
+	return schema ? parseSchema(scope, schema, entries) : entries;
+}
+function useQueryAsync(scope, schema) {
+	const { searchParams } = useUrl(scope);
+	return parseSchemaAsync(scope, schema, searchParams);
+}
+function withQuery(scope, input, query) {
+	const url = new URL(input, useUrl(scope));
+	for (const name in query) url.searchParams.set(name, query[name]);
+	return url.href;
+}
+async function readBody(request) {
+	const contentType = request.headers.get("Content-Type");
+	if (contentType?.includes("application/json")) return request.json();
+	if (contentType?.includes("multipart/form-data") || contentType?.includes("application/x-www-form-urlencoded")) {
+		const formData = await request.formData();
+		return Object.fromEntries(formData.entries());
+	}
+	return {};
+}
+async function useBody(scope, schema) {
+	const { request } = useServer(scope);
+	const entries = await readBody(request);
+	return schema ? parseSchema(scope, schema, entries) : entries;
+}
+async function useBodyAsync(scope, schema) {
+	const { request } = useServer(scope);
+	return parseSchemaAsync(scope, schema, await readBody(request));
+}
+function parseCookiePair(cookie) {
+	const index = cookie.indexOf("=");
+	if (index <= 0) return;
+	const name = cookie.slice(0, index).trim();
+	const value = cookie.slice(index + 1);
+	if (name.length === 0) return;
+	try {
+		return [name, decodeURIComponent(value)];
+	} catch {
+		return [name, value];
+	}
+}
+function useCookies(scope, schema) {
+	const { request } = useServer(scope);
+	const entries = (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 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;
+	}, {}));
+}
+function useSetCookies(scope, schema) {
+	const { request } = useServer(scope);
+	const entries = (request.headers.getSetCookie?.() ?? []).reduce((result, cookie) => {
+		const pair = parseCookiePair(cookie.split(";").at(0) ?? "");
+		if (pair) result[pair[0]] = pair[1];
+		return result;
+	}, {});
+	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;
+	}, {}));
+}
+function setCookie(scope, name, value, options) {
+	const { response } = useServer(scope);
+	let cookie = name + "=" + encodeURIComponent(value);
+	if (options?.domain) cookie += `; Domain=${options.domain}`;
+	if (options?.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+	if (options?.httpOnly) cookie += `; HttpOnly`;
+	if (options?.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
+	if (options?.path) cookie += `; Path=${options.path}`;
+	if (options?.priority) cookie += `; Priority=${options.priority}`;
+	if (options?.sameSite) cookie += `; SameSite=${options.sameSite}`;
+	if (options?.secure) cookie += `; Secure`;
+	if (isServer) response.headers.append("Set-Cookie", cookie);
+	else document.cookie = cookie;
+}
+function deleteCookie(scope, name, options) {
+	setCookie(scope, name, "", {
+		...options,
+		maxAge: 0
+	});
+}
+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)) {
+				response.headers.set("Content-Type", "application/json");
+				body = JSON.stringify(body);
+			}
+		} else if (typeof body === "string") {
+			const content = body.trimStart().toLowerCase();
+			if (content.startsWith("<!doctype") || content.startsWith("<html") || content.startsWith("<head")) response.headers.set("Content-Type", "text/html");
+			else response.headers.set("Content-Type", "text/plain");
+		} else if (typeof body === "boolean" || typeof body === "number") {
+			response.headers.set("Content-Type", "application/json");
+			body = JSON.stringify(body);
+		}
+	}
+	if (config?.headers instanceof Headers) for (const [key, value] of config.headers.entries()) response.headers.set(key, value);
+	const { status, statusText, headers, ...variables } = {
+		...response,
+		...config
+	};
+	return new Response(body, {
+		...variables,
+		status,
+		statusText,
+		headers
+	});
+}
+function sendOk(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 200;
+	return sendResponse(scope, body, config);
+}
+function sendCreated(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 201;
+	return sendResponse(scope, body, config);
+}
+function sendNoContent(scope, config) {
+	const { response } = useServer(scope);
+	response.status = 204;
+	return sendResponse(scope, void 0, config);
+}
+function sendRedirect(scope, path, config) {
+	const { response } = useServer(scope);
+	response.status = 302;
+	response.headers.set("Location", path);
+	return sendResponse(scope, void 0, config);
+}
+function sendBadRequest(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 400;
+	return sendResponse(scope, body, config);
+}
+function sendUnauthorized(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 401;
+	return sendResponse(scope, body, config);
+}
+function sendForbidden(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 403;
+	return sendResponse(scope, body, config);
+}
+function sendNotFound(scope, body, config) {
+	const { response } = useServer(scope);
+	response.status = 404;
+	return sendResponse(scope, body, config);
+}
+function getState(scope, name) {
+	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];
+	}
+}
+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;
+	}
+}
+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 previous = new URL(request.url);
+		if (url.origin === previous.origin) {
+			const result = await (await import("#server")).default.fetch(next);
+			if (isResponse(result)) response = result;
+		}
+	}
+	response ??= await globalThis.fetch(input, options);
+	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;
+	}
+}
+async function invoke(scope, pipeline, index = 0) {
+	return await pipeline.at(index)?.fetch(scope, async () => await invoke(scope, pipeline, index + 1));
+}
+function createStaticMiddleware(resolve) {
+	return defineMiddleware({ async fetch(scope, next) {
+		const { pathname } = useUrl(scope);
+		const asset = assets[pathname];
+		if (asset) return sendOk(scope, await resolve(asset.relative), { headers: new Headers({ "Content-Type": asset.type }) });
+		return next?.();
+	} });
+}
+async function createServer() {
+	const router = new Router();
+	const scheduled = new Array();
+	for (const source of Object.values(routes)) for (const [path, resolve] of Object.entries(source)) {
+		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());
+	}
+	for (const source of Object.values(schedules)) for (const resolve of Object.values(source)) {
+		const schedule = await resolve();
+		if (schedule) scheduled.push(schedule);
+	}
+	return {
+		router,
+		schedules: scheduled,
+		async fetch(scope) {
+			try {
+				const { request } = useServer(scope);
+				const { pathname } = useUrl(scope);
+				const context = setContext(scope, SERVER_ROUTER_CONTEXT, await router.resolve(scope, (request.method.toLowerCase() + pathname).split("/")));
+				if (context.match) context.hooks.push(context.match);
+				return await invoke(scope, context.hooks) ?? sendNotFound(scope);
+			} catch (error) {
+				if (error instanceof Response) return error;
+				throw error;
+			}
+		},
+		async schedule(scope) {
+			const { when } = useSchedule(scope);
+			const expression = scheduleAliases[when.trim().toLowerCase()] ?? when.trim();
+			for (const schedule of scheduled) {
+				if ((scheduleAliases[schedule.when.trim().toLowerCase()] ?? schedule.when.trim()) !== expression) continue;
+				await schedule.run(scope);
+			}
+		}
+	};
+}
+var STATES;
+var SERVER_CONTEXT = defineContext("SERVER_CONTEXT");
+var SERVER_ROUTER_CONTEXT = defineContext("SERVER_ROUTER_CONTEXT");
+var SCHEDULE_CONTEXT = defineContext("SCHEDULE_CONTEXT");
+var cookiePriorities = [
+	"Low",
+	"Medium",
+	"High"
+];
+var cookieSameSites = [
+	"Lax",
+	"Strict",
+	"None"
+];
+var httpMethods = [
+	"GET",
+	"HEAD",
+	"PATCH",
+	"POST",
+	"PUT",
+	"DELETE",
+	"CONNECT",
+	"OPTIONS",
+	"TRACE"
+];
+var encodings = [
+	"ascii",
+	"utf8",
+	"utf8",
+	"utf16le",
+	"ucs2",
+	"ucs-2",
+	"base64",
+	"latin1",
+	"binary",
+	"hex"
+];
+var statusCodes = [
+	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
+];
+//#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 };

package/dist/module/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("revojs/module").Module<"server", Record<string, never>, []>;
+export default _default;
+export declare const SERVER = "ssr";

package/dist/module/index.js

@@ -0,0 +1,150 @@
+import { fromNodeRequest, toNodeRequest } from "../node/index.js";
+import package_default from "../package.js";
+import { Cron } from "croner";
+import { ServerResponse } from "http";
+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;
+}
+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; }`);
+		return {
+			sources: {
+				routes: {
+					match: [
+						"**/{get,head,post,put,delete,connect,options,trace,patch}.js",
+						"**/{get,head,post,put,delete,connect,options,trace,patch}.ts",
+						"**/+middleware.js",
+						"**/+middleware.ts",
+						"!*.d.ts"
+					],
+					from: ["./routes"]
+				},
+				schedules: {
+					match: [
+						"**/*.js",
+						"**/*.ts",
+						"!*.d.ts"
+					],
+					from: ["./schedules"]
+				}
+			},
+			vite: {
+				environments: { ["ssr"]: {
+					consumer: "server",
+					build: {
+						rolldownOptions: { output: {
+							entryFileNames: "assets/[hash].js",
+							chunkFileNames: "assets/[hash].js",
+							assetFileNames: "assets/[hash][extname]"
+						} },
+						outDir: "./dist/server"
+					}
+				} },
+				plugins: [{
+					name: package_default.name,
+					async configureServer(devServer) {
+						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 server = await target.runner.import("#server").then((module) => module.default);
+							if (server) {
+								for (const schedule of server.schedules) new Cron(schedule.when, async () => {
+									await server.schedule(await createScope({ context: {
+										[VARIABLE_CONTEXT]: process.env,
+										[SCHEDULE_CONTEXT]: { when: schedule.when }
+									} }));
+								});
+								const webSocketServer = new WebSocketServer({ noServer: true });
+								webSocketServer.on("connection", async (webSocket) => {
+									const connection = {
+										async send(message) {
+											webSocket.send(message);
+										},
+										async close(code, reason) {
+											webSocket.close(code, reason);
+										}
+									};
+									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;
+										}
+									});
+									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;
+										}
+									});
+									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;
+										}
+									});
+								});
+								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 result = await invoke(scope, [server]);
+									if (isWebSocket(result)) webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
+										webSocket.interneWebSocket = result;
+										webSocketServer.emit("connection", webSocket, request);
+									});
+									else socket.destroy();
+								});
+								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 result = await invoke(scope, [server]);
+										if (isResponse(result)) await toNodeRequest(result, response);
+										next();
+									});
+								};
+							}
+						}
+					}
+				}]
+			}
+		};
+	}
+});
+var SERVER = "ssr";
+//#endregion
+export { SERVER, module_default as default };

package/dist/node/index.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "http";
+export declare function fromNodeRequest(nodeReq: IncomingMessage, nodeRes: ServerResponse): Request;
+export declare function toNodeRequest(res: Response, nodeRes: ServerResponse): Promise<void>;

package/dist/node/index.js

@@ -0,0 +1,50 @@
+import { once } from "events";
+import { Readable } from "stream";
+//#region src/node/index.ts
+function createReadableStreamFromReadable(source) {
+	return Readable.toWeb(source);
+}
+function fromNodeHeaders(nodeHeaders) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(nodeHeaders)) if (value) {
+		if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+		else headers.set(key, value);
+	}
+	return headers;
+}
+function fromNodeRequest(nodeReq, nodeRes) {
+	const origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+	const url = new URL(nodeReq.url ?? "", origin);
+	let controller = new AbortController();
+	const init = {
+		method: nodeReq.method,
+		headers: fromNodeHeaders(nodeReq.headers),
+		signal: controller.signal
+	};
+	if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+		init.body = createReadableStreamFromReadable(nodeReq);
+		init.duplex = "half";
+	}
+	nodeRes.on("finish", () => {
+		controller = null;
+	});
+	nodeRes.on("close", () => controller?.abort());
+	return new Request(url.href, init);
+}
+async function toNodeRequest(res, nodeRes) {
+	nodeRes.statusCode = res.status;
+	nodeRes.statusMessage = res.statusText;
+	const cookiesStrings = [];
+	for (const [name, value] of res.headers) if (name === "set-cookie") {
+		const cookieArray = Array.isArray(value) ? value : [value ?? ""];
+		cookiesStrings.push(...cookieArray.flatMap((c) => c.split(/,\s*(?=[^=]+=)/)));
+	} else nodeRes.setHeader(name, value);
+	if (cookiesStrings.length) nodeRes.setHeader("set-cookie", cookiesStrings);
+	if (res.body) {
+		const readable = Readable.fromWeb(res.body);
+		readable.pipe(nodeRes);
+		await once(readable, "end");
+	} else nodeRes.end();
+}
+//#endregion
+export { fromNodeRequest, toNodeRequest };

package/dist/package.js

@@ -0,0 +1,53 @@
+//#region package.json
+var name = "@revojs/server";
+var version = "0.1.58";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/tellua/revojs.git"
+};
+var files = ["dist"];
+var type = "module";
+var main = "./dist/index.js";
+var module = "./dist/index.js";
+var types = "./dist/index.d.ts";
+var exports = {
+	".": {
+		"types": "./dist/index.d.ts",
+		"import": "./dist/index.js"
+	},
+	"./module": {
+		"types": "./dist/module/index.d.ts",
+		"import": "./dist/module/index.js"
+	}
+};
+var scripts = {
+	"build": "vite build",
+	"watch": "vite build --watch"
+};
+var dependencies = {
+	"@standard-schema/spec": "^1.1.0",
+	"croner": "^10.0.1",
+	"revojs": "*",
+	"ws": "^8.21.3"
+};
+var devDependencies = {
+	"@revojs/tsconfig": "*",
+	"@types/ws": "^8.18.1"
+};
+var package_default = {
+	name,
+	version,
+	license: "MIT",
+	repository,
+	files,
+	type,
+	main,
+	module,
+	types,
+	exports,
+	scripts,
+	dependencies,
+	devDependencies
+};
+//#endregion
+export { package_default as default, dependencies, devDependencies, exports, files, main, module, name, repository, scripts, type, types, version };

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+declare module "#server" {
+    import type { Server } from "@revojs/server";
+
+    const server: Server;
+    export default server;
+}
+
+declare module "#routes" {
+    import type { Route } from "@revojs/server";
+    import type { Source } from "revojs";
+
+    const entries: Source<Route>;
+    export default entries;
+}
+
+declare module "#schedules" {
+    import type { Schedule } from "@revojs/server";
+    import type { Source } from "revojs";
+
+    const entries: Source<Schedule>;
+    export default entries;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@revojs/server",
+    "version": "0.1.58",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tellua/revojs.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./module": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js"
+        }
+    },
+    "scripts": {
+        "build": "vite build",
+        "watch": "vite build --watch"
+    },
+    "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "croner": "^10.0.1",
+        "revojs": "*",
+        "ws": "^8.21.3"
+    },
+    "devDependencies": {
+        "@revojs/tsconfig": "*",
+        "@types/ws": "^8.18.1"
+    }
+}