silgi 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/compile.d.mts

@@ -24,6 +24,8 @@ interface CompiledRoute {
   cacheControl?: string;
   /** Procedure is accessible over WebSocket */
   ws?: boolean;
+  /** Skip body parsing — procedure receives raw request (e.g. catch-all proxy) */
+  passthrough?: boolean;
 }
 /** Compiled router function — returns matched route + params */
 type CompiledRouterFn = (method: string, path: string) => MatchedRoute<CompiledRoute> | undefined;

package/dist/compile.mjs

@@ -259,7 +259,8 @@ function compileRouter(def) {
 				handler: compileProcedure(proc),
 				stringify: compileStringify(proc.output),
 				cacheControl,
-				ws: route?.ws ?? void 0
+				ws: route?.ws ?? void 0,
+				passthrough: routePath.includes("**") || void 0
 			};
 			addRoute(radix, method, routePath, compiled);
 			addRoute(radix, "", routePath, compiled);

package/dist/core/handler.mjs

@@ -232,7 +232,7 @@ location.reload();
 		});
 		const route = match.data;
 		const method = request.method;
-		if (ctxFactoryIsSync && (method === "GET" || !request.body)) {
+		if (ctxFactoryIsSync && (method === "GET" || !request.body || route.passthrough)) {
 			const usePool = !ctxFactoryIsEmpty || match.params || collector;
 			const ctx = usePool ? ctxPool.borrow() : emptyCtx;
 			let t0 = 0;
@@ -376,7 +376,7 @@ location.reload();
 				ctx.__analyticsTrace = reqTrace;
 				ctx.trace = reqTrace.trace.bind(reqTrace);
 			}
-			if (request.method === "GET") {
+			if (route.passthrough) {} else if (request.method === "GET") {
 				if (qMark !== -1) {
 					const searchStr = url.slice(qMark + 1);
 					const dataIdx = searchStr.indexOf("data=");

package/dist/scalar.mjs

@@ -7,8 +7,18 @@ function generateOpenAPI(router, options = {}) {
 	const tags = /* @__PURE__ */ new Map();
 	collectProcedures(router, [], (path, proc) => {
 		const route = proc.route;
-		const httpPath = route?.path ?? "/" + path.join("/");
-		const method = route?.method?.toLowerCase() ?? "post";
+		const httpPath = (route?.path ?? "/" + path.join("/")).replace(/\/\*\*$/, "/{path}").replace(/\/\*\*/g, "/{path}");
+		const rawMethod = route?.method?.toLowerCase() ?? "post";
+		const methods = rawMethod === "*" ? [
+			"get",
+			"put",
+			"post",
+			"delete",
+			"options",
+			"head",
+			"patch",
+			"trace"
+		] : [rawMethod];
 		const operationId = path.join("_");
 		if (path.length > 1) {
 			const tagName = path[0];
@@ -31,23 +41,9 @@ function generateOpenAPI(router, options = {}) {
 		if (!operation.description) delete operation.description;
 		if (!operation.deprecated) delete operation.deprecated;
 		if (options.security) operation.security = [{ auth: [] }];
-		if (proc.input) {
-			const schema = zodToJsonSchema(proc.input);
-			if (method === "get") operation.parameters = objectSchemaToParams(schema);
-			else operation.requestBody = {
-				required: true,
-				content: { "application/json": { schema } }
-			};
-		}
+		const inputSchema = proc.input ? zodToJsonSchema(proc.input) : null;
 		const successStatus = route?.successStatus ?? 200;
 		const successDesc = route?.successDescription ?? "Successful response";
-		if (proc.output) {
-			const schema = zodToJsonSchema(proc.output);
-			operation.responses[String(successStatus)] = {
-				description: successDesc,
-				content: { "application/json": { schema } }
-			};
-		} else operation.responses[String(successStatus)] = { description: successDesc };
 		const guards = (proc.use ?? []).filter((m) => m.kind === "guard" && m.errors);
 		let allErrors = proc.errors ? { ...proc.errors } : null;
 		for (const guard of guards) {
@@ -57,54 +53,73 @@ function generateOpenAPI(router, options = {}) {
 				...ge
 			} : { ...ge };
 		}
-		if (allErrors) {
-			const byStatus = /* @__PURE__ */ new Map();
-			for (const [code, def] of Object.entries(allErrors)) {
-				const status = typeof def === "number" ? def : def.status;
-				if (!byStatus.has(status)) byStatus.set(status, []);
-				const entry = { code };
-				if (typeof def === "object" && def.data) entry.schema = zodToJsonSchema(def.data);
-				byStatus.get(status).push(entry);
-			}
-			for (const [status, errors] of byStatus) {
-				const errorSchemas = errors.map((e) => {
-					const s = {
-						type: "object",
-						properties: {
-							code: {
-								const: e.code,
-								type: "string"
-							},
-							status: {
-								const: status,
-								type: "integer"
+		paths[httpPath] ??= {};
+		for (const method of methods) {
+			const op = {
+				...operation,
+				responses: {}
+			};
+			if (methods.length > 1) op.operationId = `${operationId}_${method}`;
+			if (inputSchema) if (method === "get") op.parameters = objectSchemaToParams(inputSchema);
+			else op.requestBody = {
+				required: true,
+				content: { "application/json": { schema: inputSchema } }
+			};
+			if (proc.output) {
+				const schema = zodToJsonSchema(proc.output);
+				op.responses[String(successStatus)] = {
+					description: successDesc,
+					content: { "application/json": { schema } }
+				};
+			} else op.responses[String(successStatus)] = { description: successDesc };
+			if (allErrors) {
+				const byStatus = /* @__PURE__ */ new Map();
+				for (const [code, def] of Object.entries(allErrors)) {
+					const status = typeof def === "number" ? def : def.status;
+					if (!byStatus.has(status)) byStatus.set(status, []);
+					const entry = { code };
+					if (typeof def === "object" && def.data) entry.schema = zodToJsonSchema(def.data);
+					byStatus.get(status).push(entry);
+				}
+				for (const [status, errors] of byStatus) {
+					const errorSchemas = errors.map((e) => {
+						const s = {
+							type: "object",
+							properties: {
+								code: {
+									const: e.code,
+									type: "string"
+								},
+								status: {
+									const: status,
+									type: "integer"
+								},
+								message: { type: "string" }
 							},
-							message: { type: "string" }
-						},
-						required: [
-							"code",
-							"status",
-							"message"
-						]
+							required: [
+								"code",
+								"status",
+								"message"
+							]
+						};
+						if (e.schema) {
+							s.properties.data = e.schema;
+							s.required.push("data");
+						}
+						return s;
+					});
+					op.responses[String(status)] = {
+						description: errors.map((e) => e.code).join(" | "),
+						content: { "application/json": { schema: errorSchemas.length === 1 ? errorSchemas[0] : { oneOf: errorSchemas } } }
 					};
-					if (e.schema) {
-						s.properties.data = e.schema;
-						s.required.push("data");
-					}
-					return s;
-				});
-				operation.responses[String(status)] = {
-					description: errors.map((e) => e.code).join(" | "),
-					content: { "application/json": { schema: errorSchemas.length === 1 ? errorSchemas[0] : { oneOf: errorSchemas } } }
-				};
+				}
 			}
+			if (proc.type === "subscription") op.responses[String(successStatus)] = {
+				description: "SSE event stream",
+				content: { "text/event-stream": { schema: { type: "string" } } }
+			};
+			paths[httpPath][method] = op;
 		}
-		if (proc.type === "subscription") operation.responses[String(successStatus)] = {
-			description: "SSE event stream",
-			content: { "text/event-stream": { schema: { type: "string" } } }
-		};
-		paths[httpPath] ??= {};
-		paths[httpPath][method] = operation;
 	});
 	const doc = {
 		openapi: "3.1.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.2",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [