silgi 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/client/adapters/ofetch/index.d.mts

@@ -36,8 +36,8 @@ interface LinkOptions<TClientContext extends ClientContext = ClientContext> {
   onResponse?: FetchOptions['onResponse'];
   onRequestError?: FetchOptions['onRequestError'];
   onResponseError?: FetchOptions['onResponseError'];
-  /** Route metadata — pass extractRoutes(router) or the full router. Required when procedures use $route({ path }) */
-  routes?: unknown;
+  /** Route metadata — pass extractRoutes(router), the full router, or a Promise that resolves to routes. Required when procedures use $route({ path }) */
+  routes?: unknown | Promise<unknown>;
 }
 /**
  * Create a Silgi client link powered by ofetch.

package/dist/client/adapters/ofetch/index.mjs

@@ -28,9 +28,15 @@ function createLink(options) {
 	const defaultRetry = options.retry;
 	const defaultRetryDelay = options.retryDelay ?? 0;
 	const resolvedProtocol = options.protocol ?? (options.binary ? "messagepack" : void 0) ?? (options.devalue ? "devalue" : void 0) ?? "json";
-	const routes = options.routes;
+	let resolvedRoutes = void 0;
+	const routesOption = options.routes;
+	if (routesOption && typeof routesOption?.then === "function") routesOption.then((r) => {
+		resolvedRoutes = r;
+	});
+	else resolvedRoutes = routesOption;
 	return { async call(path, input, callOptions) {
-		const resolved = routes ? resolveRoute(routes, path) : void 0;
+		if (routesOption && !resolvedRoutes && typeof routesOption?.then === "function") resolvedRoutes = await routesOption;
+		const resolved = resolvedRoutes ? resolveRoute(resolvedRoutes, path) : void 0;
 		let urlPath = resolved ? resolved.path : "/" + path.map(encodeURIComponent).join("/");
 		if (resolved) {
 			const sub = substituteParams(urlPath, input);

package/dist/contract.d.mts

@@ -30,7 +30,58 @@ type ImplementRouter<T extends ContractRouter> = { [K in keyof T]: T[K] extends
  * Type-safe: implementation must match the contract.
  */
 declare function implement<T extends ContractRouter>(contractDef: T, implementations: ImplementRouter<T>): RouterDef;
+declare class ContractBuilder {
+  private _route?;
+  private _input?;
+  private _output?;
+  private _errors?;
+  private _type?;
+  private _description?;
+  route(r: Route): this;
+  input<T extends AnySchema>(schema: T): ContractBuilder & {
+    _input: T;
+  };
+  output<T extends AnySchema>(schema: T): ContractBuilder & {
+    _output: T;
+  };
+  errors<T extends ErrorDef>(e: T): ContractBuilder & {
+    _errors: T;
+  };
+  description(d: string): this;
+  /** Build the procedure contract */
+  build(): ProcedureContract;
+}
+/**
+ * Contract builder — oRPC-style chainable API for defining procedure contracts.
+ *
+ * @example
+ * ```ts
+ * import { oc } from 'silgi/contract'
+ *
+ * const listUsers = oc
+ *   .route({ method: 'GET', path: '/api/users' })
+ *   .input(z.object({ limit: z.number().optional() }))
+ *   .output(z.array(UserSchema))
+ *   .build()
+ * ```
+ */
+declare const oc: ContractBuilder;
+/**
+ * Strip all non-metadata from a contract or router, preserving only
+ * { route: { path, method }, type } for each procedure.
+ * Safe to serialize to JSON and ship to client bundles.
+ *
+ * oRPC equivalent: `minifyContractRouter(router)`
+ *
+ * @example
+ * ```ts
+ * import { minifyContractRouter } from 'silgi/contract'
+ * const minified = minifyContractRouter(appRouter)
+ * fs.writeFileSync('routes.json', JSON.stringify(minified))
+ * ```
+ */
+declare function minifyContractRouter(def: unknown): Record<string, unknown>;
 /** Infer client type from a contract (no server code needed) */
 type InferContractClient<T extends ContractRouter> = { [K in keyof T]: T[K] extends ProcedureContract<any, infer TInput, infer TOutput> ? TInput extends AnySchema ? (input: InferSchemaInput<TInput>) => Promise<TOutput extends AnySchema ? InferSchemaOutput<TOutput> : unknown> : () => Promise<TOutput extends AnySchema ? InferSchemaOutput<TOutput> : unknown> : T[K] extends ContractRouter ? InferContractClient<T[K]> : never };
 //#endregion
-export { ContractRouter, InferContractClient, ProcedureContract, contract, implement };
+export { ContractRouter, InferContractClient, ProcedureContract, contract, implement, minifyContractRouter, oc };

package/dist/contract.mjs

@@ -36,5 +36,94 @@ function isProcedureContract(v) {
 	if (typeof v !== "object" || v === null) return false;
 	return "input" in v || "output" in v || "type" in v || "errors" in v;
 }
+var ContractBuilder = class {
+	_route;
+	_input;
+	_output;
+	_errors;
+	_type;
+	_description;
+	route(r) {
+		this._route = {
+			...this._route,
+			...r
+		};
+		return this;
+	}
+	input(schema) {
+		this._input = schema;
+		return this;
+	}
+	output(schema) {
+		this._output = schema;
+		return this;
+	}
+	errors(e) {
+		this._errors = e;
+		return this;
+	}
+	description(d) {
+		this._description = d;
+		return this;
+	}
+	/** Build the procedure contract */
+	build() {
+		return {
+			type: this._type,
+			input: this._input,
+			output: this._output,
+			errors: this._errors,
+			route: this._route,
+			description: this._description
+		};
+	}
+};
+/**
+* Contract builder — oRPC-style chainable API for defining procedure contracts.
+*
+* @example
+* ```ts
+* import { oc } from 'silgi/contract'
+*
+* const listUsers = oc
+*   .route({ method: 'GET', path: '/api/users' })
+*   .input(z.object({ limit: z.number().optional() }))
+*   .output(z.array(UserSchema))
+*   .build()
+* ```
+*/
+const oc = new ContractBuilder();
+/**
+* Strip all non-metadata from a contract or router, preserving only
+* { route: { path, method }, type } for each procedure.
+* Safe to serialize to JSON and ship to client bundles.
+*
+* oRPC equivalent: `minifyContractRouter(router)`
+*
+* @example
+* ```ts
+* import { minifyContractRouter } from 'silgi/contract'
+* const minified = minifyContractRouter(appRouter)
+* fs.writeFileSync('routes.json', JSON.stringify(minified))
+* ```
+*/
+function minifyContractRouter(def) {
+	const result = {};
+	if (def == null || typeof def !== "object") return result;
+	for (const [key, value] of Object.entries(def)) {
+		if (typeof value !== "object" || value === null) continue;
+		const obj = value;
+		const route = obj.route;
+		if (route?.path) result[key] = {
+			path: route.path,
+			method: (route.method ?? "POST").toUpperCase()
+		};
+		else if ("resolve" in obj || "input" in obj || "output" in obj || "type" in obj) {} else {
+			const nested = minifyContractRouter(value);
+			if (Object.keys(nested).length > 0) result[key] = nested;
+		}
+	}
+	return result;
+}
 //#endregion
-export { contract, implement };
+export { contract, implement, minifyContractRouter, oc };

package/dist/core/handler.mjs

@@ -120,6 +120,10 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 			const reqTrace = analyticsTraceMap.get(request);
 			if (reqTrace) ctx.__analyticsTrace = reqTrace;
 			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
+			if (match.params && Object.keys(match.params).length > 0) rawInput = rawInput != null && typeof rawInput === "object" ? {
+				...match.params,
+				...rawInput
+			} : match.params;
 			callHook("request", {
 				path: pathname,
 				input: rawInput

package/dist/core/router-utils.mjs

@@ -31,18 +31,26 @@ function assignPaths(def, prefix = []) {
 function extractRoutes(def, prefix = []) {
 	const result = {};
 	if (def == null || typeof def !== "object") return result;
-	for (const [key, value] of Object.entries(def)) if (isProcedureDef(value)) {
-		const route = value.route;
+	for (const [key, value] of Object.entries(def)) {
+		const route = getRouteFromEntry(value);
 		if (route?.path) result[key] = {
 			path: route.path,
 			method: (route.method ?? "POST").toUpperCase()
 		};
-	} else if (typeof value === "object" && value !== null) {
-		const nested = extractRoutes(value, [...prefix, key]);
-		if (Object.keys(nested).length > 0) result[key] = nested;
+		else if (typeof value === "object" && value !== null && !isProcedureDef(value)) {
+			const nested = extractRoutes(value, [...prefix, key]);
+			if (Object.keys(nested).length > 0) result[key] = nested;
+		}
 	}
 	return result;
 }
+/** Extract route metadata from a ProcedureDef or ProcedureContract */
+function getRouteFromEntry(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const obj = value;
+	if (isProcedureDef(value)) return obj.route;
+	if ("route" in obj && typeof obj.route === "object" && obj.route !== null) return obj.route;
+}
 /** Check if a value is an extracted route leaf (has path + method, not a nested object) */
 function isExtractedRoute(value) {
 	return typeof value === "object" && value !== null && "path" in value && "method" in value && !("resolve" in value);
@@ -55,14 +63,11 @@ function resolveRoute(routes, path) {
 		current = current[segment];
 	}
 	if (isExtractedRoute(current)) return current;
-	if (isProcedureDef(current)) {
-		const route = current.route;
-		if (!route?.path) return void 0;
-		return {
-			path: route.path,
-			method: (route.method ?? "POST").toUpperCase()
-		};
-	}
+	const route = getRouteFromEntry(current);
+	if (route?.path) return {
+		path: route.path,
+		method: (route.method ?? "POST").toUpperCase()
+	};
 }
 /**
 * Substitute :param placeholders in a route path with values from input.

package/dist/silgi.mjs

@@ -142,12 +142,20 @@ function silgi(config) {
 		serve: async (routerDef, options) => {
 			const { createServeHandler } = await import("./core/serve.mjs");
 			const server = await createServeHandler(routerDef, contextFactory, hooks, options);
-			const { collectCronTasks, startCronJobs } = await import("./core/task.mjs");
+			const { collectCronTasks, startCronJobs, stopCronJobs } = await import("./core/task.mjs");
 			const cronTasks = collectCronTasks(routerDef);
 			if (cronTasks.length > 0) {
 				await startCronJobs(cronTasks);
 				console.log(`  ${cronTasks.length} cron task(s) scheduled`);
 			}
+			const originalClose = server.close.bind(server);
+			server.close = async (force) => {
+				stopCronJobs();
+				return originalClose(force);
+			};
+			const onSignal = () => stopCronJobs();
+			process.once("SIGINT", onSignal);
+			process.once("SIGTERM", onSignal);
 			return server;
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.1.0-beta.10",
+  "version": "0.1.0-beta.12",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -270,6 +270,7 @@
     "ocache": "^0.1.4",
     "ofetch": "2.0.0-alpha.3",
     "ohash": "^2.0.11",
+    "silgi": "link:",
     "srvx": "^0.11.13",
     "unstorage": "^2.0.0-alpha.7"
   },
@@ -333,7 +334,7 @@
   "packageManager": "pnpm@10.33.0",
   "pnpm": {
     "overrides": {
-      "silgi": "workspace:*"
+      "silgi": "link:"
     }
   }
 }