@sx3/ultra 0.0.1

package/dist/client.mjs

@@ -0,0 +1,131 @@
+//#region src/client.ts
+function proxyClient(invoke, path = []) {
+	return new Proxy(() => {}, {
+		get(_, prop) {
+			if (typeof prop === "string") return proxyClient(invoke, [...path, prop]);
+		},
+		apply(_, __, args) {
+			if (!path.length) throw new Error("Cannot call client root; select a procedure first");
+			const method = path.join("/");
+			const params = args[0];
+			const callOptions = args[1];
+			return invoke(method, params, callOptions);
+		}
+	});
+}
+function mergeHeaders(...sources) {
+	const result = new Headers();
+	for (const headersInit of sources) {
+		if (!headersInit) continue;
+		new Headers(headersInit).forEach((value, key) => result.set(key, value));
+	}
+	return result;
+}
+function createHTTPClient(clientOptions) {
+	const invoke = async (method, params, callOptions) => {
+		const options = {
+			...clientOptions,
+			...callOptions
+		};
+		const timeout = options?.timeout || 1e4;
+		const controller = new AbortController();
+		const httpMethod = options?.method || "POST";
+		let url = `${options.baseUrl}/${method}`;
+		const headers = mergeHeaders(clientOptions?.headers, options?.headers, callOptions?.headers);
+		let body = null;
+		const abortTimeout = setTimeout(() => controller.abort(`Timeout: ${timeout}`), timeout);
+		switch (true) {
+			case httpMethod === "GET": {
+				body = null;
+				if (!params) break;
+				if (typeof params !== "object") throw new Error("GET requests params to be an object for query string generation");
+				const entries = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => [k, String(v)]);
+				const queryString = new URLSearchParams(entries).toString();
+				if (queryString) url += `?${queryString}`;
+				break;
+			}
+			case params instanceof FormData:
+				body = params;
+				break;
+			case typeof params === "string":
+				headers.set("Content-Type", "text/plain");
+				body = params;
+				break;
+			default:
+				headers.set("Content-Type", "application/json");
+				body = JSON.stringify(params);
+		}
+		try {
+			const response = await fetch(url, {
+				method: httpMethod,
+				...body && { body },
+				...options,
+				signal: controller.signal,
+				headers
+			});
+			if (!response.ok) throw new Error(`HTTP error: ${response.statusText} ${response.status} `);
+			const type = response.headers.get("Content-Type") || "";
+			switch (true) {
+				case type.includes("application/json"): return await response.json();
+				case type.includes("text/"): return await response.text();
+				default: return await response.blob();
+			}
+		} catch (error) {
+			if (error.name === "AbortError") throw new Error(`Request aborted: ${error.message}`);
+			throw error;
+		} finally {
+			clearTimeout(abortTimeout);
+		}
+	};
+	return proxyClient(invoke);
+}
+function createWebSocketClient(options) {
+	const { timeout = 1e4 } = options;
+	const makeId = () => Math.random().toString(36);
+	const invoke = (method, params, callOptions) => {
+		const socket = options.socket();
+		const readyState = socket.readyState;
+		if (typeof readyState === "number" && readyState !== WebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("WebSocket is not open"));
+		const { promise, resolve, reject } = Promise.withResolvers();
+		const mergedTimeout = callOptions?.timeout ?? timeout;
+		let rejectTimeout;
+		const requestId = makeId();
+		const listener = (event) => {
+			try {
+				const response = JSON.parse(event.data);
+				if (response.id !== requestId) return;
+				clearTimeout(rejectTimeout);
+				socket.removeEventListener("message", listener);
+				if ("error" in response) return reject(response.error);
+				return resolve(response.result);
+			} catch (error) {
+				reject(error);
+			}
+		};
+		socket.addEventListener("message", listener);
+		rejectTimeout = setTimeout(() => {
+			socket.removeEventListener("message", listener);
+			reject(`Timeout: ${mergedTimeout}`);
+		}, mergedTimeout);
+		socket.send(JSON.stringify({
+			id: requestId,
+			method,
+			params
+		}));
+		return promise;
+	};
+	return proxyClient(invoke);
+}
+function createSuperClient(options) {
+	const invoke = (method, params, callOptions) => {
+		const client = options.pick(method, params, callOptions);
+		const segments = method.split("/").filter(Boolean);
+		let target = client;
+		for (const segment of segments) if (target[segment]) target = target[segment];
+		return target(params, callOptions);
+	};
+	return proxyClient(invoke);
+}
+
+//#endregion
+export { createHTTPClient, createSuperClient, createWebSocketClient };

package/dist/context-ChCsZh7S.d.mts

@@ -0,0 +1,17 @@
+import { BunRequest, Server, ServerWebSocket } from "bun";
+
+//#region src/context.d.ts
+type DefaultSocketData = Record<string, any>;
+interface HTTPContext {
+  server: Server<DefaultSocketData>;
+  request: BunRequest;
+}
+interface WSContext<SocketData> {
+  server: Server<SocketData>;
+  ws: ServerWebSocket<SocketData>;
+}
+type BaseContext<SocketData extends DefaultSocketData = DefaultSocketData> = HTTPContext | WSContext<SocketData>;
+declare function isHTTP(context: BaseContext): context is HTTPContext;
+declare function isWS<SocketData extends DefaultSocketData = DefaultSocketData>(context: BaseContext): context is WSContext<SocketData>;
+//#endregion
+export { isHTTP as a, WSContext as i, DefaultSocketData as n, isWS as o, HTTPContext as r, BaseContext as t };

package/dist/context.d.mts

@@ -0,0 +1,2 @@
+import { a as isHTTP, i as WSContext, n as DefaultSocketData, o as isWS, r as HTTPContext, t as BaseContext } from "./context-ChCsZh7S.mjs";
+export { BaseContext, DefaultSocketData, HTTPContext, WSContext, isHTTP, isWS };

package/dist/context.mjs

@@ -0,0 +1,10 @@
+//#region src/context.ts
+function isHTTP(context) {
+	return "request" in context;
+}
+function isWS(context) {
+	return "ws" in context;
+}
+
+//#endregion
+export { isHTTP, isWS };

package/dist/cors.d.mts

@@ -0,0 +1,16 @@
+import { t as BaseContext } from "./context-ChCsZh7S.mjs";
+import "./http-BqWCMASL.mjs";
+import { t as Middleware } from "./middleware-COKreBGP.mjs";
+
+//#region src/cors.d.ts
+interface CorsConfig {
+  origin: string[];
+  methods?: string[];
+  allowedHeaders?: string[];
+  exposedHeaders?: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+declare function createCORSMiddleware(config: CorsConfig): Middleware<unknown, unknown, BaseContext>;
+//#endregion
+export { CorsConfig, createCORSMiddleware };

package/dist/cors.mjs

@@ -0,0 +1,58 @@
+import { t as toHTTPResponse } from "./response-CNhIkAYG.mjs";
+
+//#region src/cors.ts
+const DEFAULT_HEADERS = {
+	"Access-Control-Allow-Methods": [
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS"
+	].join(", "),
+	"Access-Control-Allow-Headers": [
+		"Accept-Language",
+		"Accept",
+		"Content-Type",
+		"Content-Language",
+		"Range"
+	].join(", "),
+	"Access-Control-Expose-Headers": [
+		"Cache-Control",
+		"Content-Language",
+		"Content-Type",
+		"Expires",
+		"Last-Modified",
+		"Pragma"
+	].join(", "),
+	"Access-Control-Max-Age": "3600"
+};
+function createCORSMiddleware(config) {
+	const cachedHeaders = {
+		...DEFAULT_HEADERS,
+		...config.methods?.length && { "Access-Control-Allow-Methods": config.methods.join(", ") },
+		...config.allowedHeaders?.length && { "Access-Control-Allow-Headers": config.allowedHeaders.join(", ") },
+		...config.exposedHeaders?.length && { "Access-Control-Expose-Headers": config.exposedHeaders.join(", ") },
+		...config.credentials && !config.origin.includes("*") && { "Access-Control-Allow-Credentials": "true" },
+		...config.maxAge && { "Access-Control-Max-Age": config.maxAge.toString() }
+	};
+	return async (options) => {
+		if (!("request" in options.context)) return options.next();
+		const origin = options.context.request.headers.get("Origin");
+		if (!origin || !config.origin.includes(origin)) return options.next();
+		if (options.context.request.method === "OPTIONS") return new Response(null, {
+			status: 204,
+			headers: {
+				"Access-Control-Allow-Origin": origin,
+				...cachedHeaders
+			}
+		});
+		const response = toHTTPResponse(await options.next());
+		response.headers.set("Access-Control-Allow-Origin", origin);
+		for (const header in cachedHeaders) response.headers.set(header, cachedHeaders[header]);
+		return response;
+	};
+}
+
+//#endregion
+export { createCORSMiddleware };

package/dist/crypto.d.mts

@@ -0,0 +1,7 @@
+//#region src/crypto.d.ts
+declare function sign(value: string, secret: string): string;
+declare function unsign(signedValue: string, secret: string): string | null;
+declare function encrypt(value: string, secret: string): string;
+declare function decrypt(encrypted: string, secret: string): string | null;
+//#endregion
+export { decrypt, encrypt, sign, unsign };

package/dist/crypto.mjs

@@ -0,0 +1,44 @@
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+
+//#region src/crypto.ts
+const ALGO = "aes-256-gcm";
+const ENCODING = "base64url";
+const IV_LEN = 12;
+const TAG_LEN = 16;
+function sign(value, secret) {
+	const base64 = Buffer.from(value).toString(ENCODING);
+	return `${base64}.${createHmac("sha256", secret).update(base64).digest(ENCODING)}`;
+}
+function unsign(signedValue, secret) {
+	const [base64, sig] = signedValue.split(".");
+	if (!base64 || !sig) return null;
+	const expectedSig = createHmac("sha256", secret).update(base64).digest(ENCODING);
+	const a = Buffer.from(sig, ENCODING);
+	const b = Buffer.from(expectedSig, ENCODING);
+	if (a.length !== b.length || !timingSafeEqual(a, b)) return null;
+	return Buffer.from(base64, ENCODING).toString();
+}
+function encrypt(value, secret) {
+	const iv = randomBytes(IV_LEN);
+	const cipher = createCipheriv(ALGO, secret, iv);
+	let enc = cipher.update(value, "utf-8", ENCODING);
+	enc += cipher.final(ENCODING);
+	return Buffer.concat([
+		iv,
+		cipher.getAuthTag(),
+		Buffer.from(enc, ENCODING)
+	]).toString(ENCODING);
+}
+function decrypt(encrypted, secret) {
+	const data = Buffer.from(encrypted, ENCODING);
+	if (data.length < IV_LEN + TAG_LEN) return null;
+	const iv = data.subarray(0, IV_LEN);
+	const tag = data.subarray(IV_LEN, IV_LEN + TAG_LEN);
+	const cipherText = data.subarray(IV_LEN + TAG_LEN);
+	const decipher = createDecipheriv(ALGO, secret, iv);
+	decipher.setAuthTag(tag);
+	return `${decipher.update(cipherText, void 0, "utf-8")}${decipher.final("utf-8")}`;
+}
+
+//#endregion
+export { decrypt, encrypt, sign, unsign };

package/dist/error-CII1zMOR.mjs

@@ -0,0 +1,45 @@
+//#region src/error.ts
+var UltraError = class extends Error {
+	status;
+	constructor(message, name, status) {
+		super(message);
+		this.name = name;
+		this.status = status;
+	}
+	toResponse() {
+		return Response.json({ error: {
+			name: this.name,
+			message: this.message
+		} }, { status: this.status });
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			status: this.status
+		};
+	}
+};
+var ValidationError = class extends UltraError {
+	constructor(message = "Validation failed") {
+		super(message, "ValidationError", 422);
+	}
+};
+var UnauthorizedError = class extends UltraError {
+	constructor(message = "Unauthorized") {
+		super(message, "UnauthorizedError", 401);
+	}
+};
+var NotFoundError = class extends UltraError {
+	constructor(message = "Not Found") {
+		super(message, "NotFoundError", 404);
+	}
+};
+var UnsupportedProtocolError = class extends UltraError {
+	constructor(message = "Unsupported Protocol") {
+		super(message, "UnsupportedProtocolError", 400);
+	}
+};
+
+//#endregion
+export { ValidationError as a, UnsupportedProtocolError as i, UltraError as n, UnauthorizedError as r, NotFoundError as t };

package/dist/error.d.mts

@@ -0,0 +1,25 @@
+//#region src/error.d.ts
+declare class UltraError extends Error {
+  status: number;
+  constructor(message: string, name: string, status: number);
+  toResponse(): Response;
+  toJSON(): {
+    name: string;
+    message: string;
+    status: number;
+  };
+}
+declare class ValidationError extends UltraError {
+  constructor(message?: string);
+}
+declare class UnauthorizedError extends UltraError {
+  constructor(message?: string);
+}
+declare class NotFoundError extends UltraError {
+  constructor(message?: string);
+}
+declare class UnsupportedProtocolError extends UltraError {
+  constructor(message?: string);
+}
+//#endregion
+export { NotFoundError, UltraError, UnauthorizedError, UnsupportedProtocolError, ValidationError };

package/dist/error.mjs

@@ -0,0 +1,3 @@
+import { a as ValidationError, i as UnsupportedProtocolError, n as UltraError, r as UnauthorizedError, t as NotFoundError } from "./error-CII1zMOR.mjs";
+
+export { NotFoundError, UltraError, UnauthorizedError, UnsupportedProtocolError, ValidationError };

package/dist/http-BqWCMASL.d.mts

@@ -0,0 +1,10 @@
+import { n as DefaultSocketData } from "./context-ChCsZh7S.mjs";
+import { o as Promisable } from "./types-Cn69QrjS.mjs";
+import { BunRequest, Server } from "bun";
+
+//#region src/http.d.ts
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+type BunRouteHandler = ((request: BunRequest, server: Server<DefaultSocketData>) => Promisable<Response | undefined>) | Response;
+type BunRoutes = Record<string, Partial<Record<HTTPMethod, BunRouteHandler>> | BunRouteHandler>;
+//#endregion
+export { BunRoutes as n, HTTPMethod as r, BunRouteHandler as t };

package/dist/http.d.mts

@@ -0,0 +1,3 @@
+import "./context-ChCsZh7S.mjs";
+import { n as BunRoutes, r as HTTPMethod, t as BunRouteHandler } from "./http-BqWCMASL.mjs";
+export { BunRouteHandler, BunRoutes, HTTPMethod };

package/dist/http.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/middleware-COKreBGP.d.mts

@@ -0,0 +1,43 @@
+import { t as BaseContext } from "./context-ChCsZh7S.mjs";
+import { o as Promisable } from "./types-Cn69QrjS.mjs";
+import { r as HTTPMethod } from "./http-BqWCMASL.mjs";
+import { c as StandardSchemaV1 } from "./validation-CkRfxQJ_.mjs";
+
+//#region src/procedure.d.ts
+interface ProcedureOptions<I, C> {
+  input: I;
+  context: C;
+}
+type ProcedureHandler<I, O, C extends BaseContext> = (options: ProcedureOptions<I, C>) => Promisable<O>;
+interface HTTPOptions {
+  enabled?: boolean;
+  method?: HTTPMethod;
+}
+declare class Procedure<I = any, O = any, C extends BaseContext = BaseContext> {
+  protected inputSchema?: StandardSchemaV1<I>;
+  protected outputSchema?: StandardSchemaV1<O>;
+  protected handlerFunction?: ProcedureHandler<I, O, C>;
+  protected middleware: Set<Middleware<I, O, C>>;
+  protected httpOptions?: HTTPOptions;
+  input<const NI>(schema?: StandardSchemaV1<NI>): Procedure<NI, O, C>;
+  output<const NO>(schema?: StandardSchemaV1<NO>): Procedure<I, NO, C>;
+  handler<const ActualOutput>(handler: ProcedureHandler<I, ActualOutput, C>): Procedure<I, ActualOutput, C>;
+  http(options?: {
+    method?: HTTPMethod;
+  }): Procedure<I, O, C>;
+  use(middleware: Middleware<I, O, C>): Procedure<I, O, C>;
+  wrap(): ProcedureHandler<I, O, C>;
+  getInfo(): {
+    http: HTTPOptions | undefined;
+    hasInput: boolean;
+    hasOutput: boolean;
+  };
+}
+//#endregion
+//#region src/middleware.d.ts
+interface MiddlewareOptions<I, O, C extends BaseContext = BaseContext> extends ProcedureOptions<I, C> {
+  next: () => ReturnType<ProcedureHandler<I, O, C>>;
+}
+type Middleware<I, O, C extends BaseContext> = (options: MiddlewareOptions<I, O, C>) => Awaited<ReturnType<ProcedureHandler<I, O, C>>>;
+//#endregion
+export { ProcedureHandler as a, Procedure as i, MiddlewareOptions as n, ProcedureOptions as o, HTTPOptions as r, Middleware as t };

package/dist/middleware.d.mts

@@ -0,0 +1,4 @@
+import "./context-ChCsZh7S.mjs";
+import "./http-BqWCMASL.mjs";
+import { n as MiddlewareOptions, t as Middleware } from "./middleware-COKreBGP.mjs";
+export { Middleware, MiddlewareOptions };

package/dist/middleware.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/procedure-BN1rLLRX.mjs

@@ -0,0 +1,86 @@
+import { t as validate } from "./validation-Cop5Wvlr.mjs";
+
+//#region src/procedure.ts
+var Procedure = class {
+	inputSchema;
+	outputSchema;
+	handlerFunction;
+	middleware = /* @__PURE__ */ new Set();
+	httpOptions;
+	input(schema) {
+		if (schema) this.inputSchema = schema;
+		return this;
+	}
+	output(schema) {
+		if (schema) this.outputSchema = schema;
+		return this;
+	}
+	handler(handler) {
+		this.handlerFunction = handler;
+		return this;
+	}
+	http(options) {
+		this.httpOptions = {
+			...options,
+			enabled: true
+		};
+		return this;
+	}
+	use(middleware) {
+		this.middleware.add(middleware);
+		return this;
+	}
+	wrap() {
+		if (!this.handlerFunction) throw new Error("Procedure handler is not defined");
+		if (!this.inputSchema && !this.outputSchema && !this.middleware.size) return this.handlerFunction;
+		let composed = this.handlerFunction;
+		switch (true) {
+			case !this.inputSchema && !this.outputSchema: break;
+			case !this.inputSchema: {
+				const previous = composed;
+				composed = async (options) => validate(this.outputSchema, await previous(options));
+				break;
+			}
+			case !this.outputSchema: {
+				const previous = composed;
+				composed = async (options) => previous({
+					...options,
+					input: await validate(this.inputSchema, options.input)
+				});
+				break;
+			}
+			default: {
+				const previous = composed;
+				composed = async (options) => {
+					const result = await previous({
+						...options,
+						input: await validate(this.inputSchema, options.input)
+					});
+					return validate(this.outputSchema, result);
+				};
+			}
+		}
+		if (this.middleware.size) {
+			const middleware = Array.from(this.middleware);
+			for (let i = middleware.length - 1; i >= 0; i--) {
+				const mw = middleware[i];
+				const previous = composed;
+				composed = (options) => mw({
+					...options,
+					next: () => previous(options)
+				});
+			}
+		}
+		return composed;
+	}
+	getInfo() {
+		return {
+			http: this.httpOptions,
+			hasInput: !!this.inputSchema,
+			hasOutput: !!this.outputSchema
+		};
+	}
+};
+
+//#endregion
+export { Procedure as t };

package/dist/procedure.d.mts

@@ -0,0 +1,4 @@
+import "./context-ChCsZh7S.mjs";
+import "./http-BqWCMASL.mjs";
+import { a as ProcedureHandler, i as Procedure, o as ProcedureOptions, r as HTTPOptions } from "./middleware-COKreBGP.mjs";
+export { HTTPOptions, Procedure, ProcedureHandler, ProcedureOptions };

package/dist/procedure.mjs

@@ -0,0 +1,3 @@
+import { t as Procedure } from "./procedure-BN1rLLRX.mjs";
+
+export { Procedure };

package/dist/response-CNhIkAYG.mjs

@@ -0,0 +1,59 @@
+import { n as UltraError } from "./error-CII1zMOR.mjs";
+
+//#region src/response.ts
+function toHTTPResponse(data) {
+	switch (true) {
+		case data instanceof Response: return data;
+		case data instanceof UltraError: return data.toResponse();
+		case data instanceof Error: return new Response("Internal Server Error", { status: 500 });
+		case typeof data === "object": return Response.json(data);
+		case !data: return new Response(null, { status: 204 });
+		default: return new Response(String(data));
+	}
+}
+function toRPCResponse(id, data) {
+	let result;
+	switch (true) {
+		case data instanceof UltraError:
+			result = {
+				id,
+				error: {
+					code: data.status,
+					message: data.message
+				}
+			};
+			break;
+		case data instanceof Error:
+			result = {
+				id,
+				error: {
+					code: 500,
+					message: data.message
+				}
+			};
+			break;
+		case data instanceof Response:
+			result = {
+				id,
+				error: {
+					code: data.status,
+					message: data.statusText
+				}
+			};
+			break;
+		case typeof data === "object" || typeof data === "number" || typeof data === "boolean":
+			result = {
+				id,
+				result: data
+			};
+			break;
+		default: result = {
+			id,
+			result: String(data)
+		};
+	}
+	return JSON.stringify(result);
+}
+
+//#endregion
+export { toRPCResponse as n, toHTTPResponse as t };

package/dist/response.d.mts

@@ -0,0 +1,5 @@
+//#region src/response.d.ts
+declare function toHTTPResponse(data: unknown): Response;
+declare function toRPCResponse(id: string, data: unknown): string;
+//#endregion
+export { toHTTPResponse, toRPCResponse };

package/dist/response.mjs

@@ -0,0 +1,3 @@
+import { n as toRPCResponse, t as toHTTPResponse } from "./response-CNhIkAYG.mjs";
+
+export { toHTTPResponse, toRPCResponse };

package/dist/rpc-Ch2UXReT.d.mts

@@ -0,0 +1,23 @@
+import { a as JSONValue } from "./types-Cn69QrjS.mjs";
+
+//#region src/rpc.d.ts
+interface ErrorResult {
+  id: string;
+  error: {
+    code: number;
+    message: string;
+  };
+}
+interface SuccessResult {
+  id: string;
+  result: JSONValue;
+}
+type Result = ErrorResult | SuccessResult;
+interface Payload {
+  id: string;
+  method: string;
+  params?: JSONValue;
+}
+declare function isRPC(value: any): value is Payload;
+//#endregion
+export { isRPC as a, SuccessResult as i, Payload as n, Result as r, ErrorResult as t };

package/dist/rpc-_rBI0z-9.mjs

@@ -0,0 +1,7 @@
+//#region src/rpc.ts
+function isRPC(value) {
+	return !!value && typeof value === "object" && "id" in value && "method" in value;
+}
+
+//#endregion
+export { isRPC as t };

package/dist/rpc.d.mts

@@ -0,0 +1,2 @@
+import { a as isRPC, i as SuccessResult, n as Payload, r as Result, t as ErrorResult } from "./rpc-Ch2UXReT.mjs";
+export { ErrorResult, Payload, Result, SuccessResult, isRPC };

package/dist/rpc.mjs

@@ -0,0 +1,3 @@
+import { t as isRPC } from "./rpc-_rBI0z-9.mjs";
+
+export { isRPC };