silgi 0.53.3 → 0.53.5

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

@@ -0,0 +1,59 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+import { AfterResponseHook, BeforeErrorHook, BeforeRequestHook, MisinaHooks, RetryOptions } from "misina";
+
+//#region src/client/adapters/misina/index.d.ts
+type OnCompleteHook = Exclude<MisinaHooks['onComplete'], undefined> extends infer H ? (H extends readonly (infer U)[] ? U : H) : never;
+interface LinkOptions<TClientContext extends ClientContext = ClientContext> {
+  /** Server base URL (e.g. "http://localhost:3000") */
+  url: string;
+  /** Static headers or dynamic header factory */
+  headers?: Record<string, string> | ((options: ClientOptions<TClientContext>) => Record<string, string>);
+  /**
+   * Retry policy. Number sets the limit; pass a full `RetryOptions` to
+   * tune backoff, status codes, jitter. `false` disables retries.
+   *
+   * @default 0
+   */
+  retry?: number | boolean | RetryOptions;
+  /** Per-attempt timeout in ms. `false` disables. (default: 30000) */
+  timeout?: number | false;
+  /** Wall-clock deadline across all attempts (ms). `false` disables. */
+  totalTimeout?: number | false;
+  /**
+   * Wire protocol for request/response encoding.
+   *
+   * - `'json'` — default, standard JSON
+   * - `'messagepack'` — 2-4x faster, ~50% smaller payloads
+   * - `'devalue'` — preserves Date, Map, Set, BigInt, circular refs
+   *
+   * @default 'json'
+   */
+  protocol?: 'json' | 'messagepack' | 'devalue';
+  /**
+   * Auto-generate `Idempotency-Key` for retried mutations. `'auto'` uses
+   * `crypto.randomUUID()` when retries are enabled. Pass a string to
+   * pin one, or a function for custom generation.
+   */
+  idempotencyKey?: false | 'auto' | string | ((request: Request) => string);
+  /** misina hooks — direct pass-through */
+  beforeRequest?: BeforeRequestHook;
+  afterResponse?: AfterResponseHook;
+  beforeError?: BeforeErrorHook;
+  onComplete?: OnCompleteHook;
+}
+/**
+ * Create a Silgi client link powered by misina.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from "silgi/client"
+ * import { createLink } from "silgi/client/misina"
+ *
+ * const link = createLink({ url: "http://localhost:3000" })
+ * const client = createClient<AppRouter>(link)
+ * const users = await client.users.list({ limit: 10 })
+ * ```
+ */
+declare function createLink<TClientContext extends ClientContext = ClientContext>(options: LinkOptions<TClientContext>): ClientLink<TClientContext>;
+//#endregion
+export { LinkOptions, createLink };

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

@@ -0,0 +1,107 @@
+import { SilgiError, fromSilgiErrorJSON, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { eventStreamToIterator } from "../../../core/sse.mjs";
+import { MSGPACK_CONTENT_TYPE, decode, encode } from "../../../codec/msgpack.mjs";
+import { createMisina, isHTTPError, isNetworkError, isTimeoutError } from "misina";
+//#region src/client/adapters/misina/index.ts
+/**
+* misina-based RPC transport — v2 client link.
+*
+* Uses misina for: retry (with Retry-After parsing), timeout, hook
+* lifecycle, redirect security, NetworkError vs HTTPError taxonomy,
+* idempotency keys for retried mutations.
+*
+* Side-by-side alternative to the ofetch link. Same Silgi semantics,
+* different transport. Pick whichever fits your stack.
+*/
+/**
+* Create a Silgi client link powered by misina.
+*
+* @example
+* ```ts
+* import { createClient } from "silgi/client"
+* import { createLink } from "silgi/client/misina"
+*
+* const link = createLink({ url: "http://localhost:3000" })
+* const client = createClient<AppRouter>(link)
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+function createLink(options) {
+	const baseUrl = options.url.endsWith("/") ? options.url.slice(0, -1) : options.url;
+	const resolvedProtocol = options.protocol ?? "json";
+	const misina = createMisina({
+		timeout: options.timeout ?? 3e4,
+		totalTimeout: options.totalTimeout,
+		retry: options.retry ?? 0,
+		idempotencyKey: options.idempotencyKey,
+		throwHttpErrors: false,
+		hooks: {
+			beforeRequest: options.beforeRequest,
+			afterResponse: options.afterResponse,
+			beforeError: options.beforeError,
+			onComplete: options.onComplete
+		}
+	});
+	return { async call(path, input, callOptions) {
+		const url = `${baseUrl}/${path.map(encodeURIComponent).join("/")}`;
+		const headers = { ...typeof options.headers === "function" ? options.headers(callOptions) : options.headers };
+		let body;
+		if (resolvedProtocol === "messagepack") {
+			headers["content-type"] = MSGPACK_CONTENT_TYPE;
+			headers["accept"] = MSGPACK_CONTENT_TYPE;
+			body = input !== void 0 && input !== null ? encode(input) : void 0;
+		} else if (resolvedProtocol === "devalue") {
+			const { encode: devalueEncode, DEVALUE_CONTENT_TYPE } = await import("../../../codec/devalue.mjs");
+			headers["content-type"] = DEVALUE_CONTENT_TYPE;
+			headers["accept"] = DEVALUE_CONTENT_TYPE;
+			body = input !== void 0 && input !== null ? devalueEncode(input) : void 0;
+		} else body = input !== void 0 && input !== null ? input : void 0;
+		try {
+			const response = (await misina.post(url, body, {
+				headers,
+				signal: callOptions.signal,
+				responseType: "stream"
+			})).raw;
+			if ((response.headers.get("content-type") ?? "").includes("text/event-stream") && response.body) return eventStreamToIterator(response.body);
+			let decoded;
+			if (resolvedProtocol === "messagepack") {
+				const buf = new Uint8Array(await response.arrayBuffer());
+				decoded = buf.length > 0 ? decode(buf) : void 0;
+			} else if (resolvedProtocol === "devalue") {
+				const text = await response.text();
+				if (text) {
+					const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
+					decoded = devalueDecode(text);
+				} else decoded = void 0;
+			} else {
+				const text = await response.text();
+				if (!text) decoded = void 0;
+				else try {
+					decoded = JSON.parse(text);
+				} catch {
+					decoded = text;
+				}
+			}
+			if (isSilgiErrorJSON(decoded)) throw fromSilgiErrorJSON(decoded);
+			return decoded;
+		} catch (error) {
+			if (error instanceof SilgiError) throw error;
+			if (isHTTPError(error)) {
+				const data = error.data;
+				if (isSilgiErrorJSON(data)) throw fromSilgiErrorJSON(data);
+				throw new SilgiError("INTERNAL_SERVER_ERROR", {
+					status: error.status ?? 500,
+					message: error.message,
+					data
+				});
+			}
+			if (isNetworkError(error) || isTimeoutError(error)) throw new SilgiError("INTERNAL_SERVER_ERROR", {
+				status: 0,
+				message: error.message
+			});
+			throw error;
+		}
+	} };
+}
+//#endregion
+export { createLink };

package/dist/types.d.mts

@@ -98,8 +98,13 @@ interface ResolveContext<TCtx, TInput, TErrors extends ErrorDef> {
 type RouterDef = {
   [key: string]: ProcedureDef<any, any, any, any> | TaskDef<any, any> | RouterDef;
 };
-/** Return type wrapper — subscription yields, query/mutation returns Promise */
-type ProcedureResult<TType extends ProcedureType, TOutput> = TType extends 'subscription' ? AsyncIterableIterator<TOutput> : Promise<TOutput>;
+/**
+ * Return type wrapper — every procedure call resolves through the link's
+ * async `call`, so the client always returns a `Promise`. Subscriptions
+ * resolve to an `AsyncIterableIterator` (the open SSE/WS stream); queries
+ * and mutations resolve to the procedure's output value.
+ */
+type ProcedureResult<TType extends ProcedureType, TOutput> = TType extends 'subscription' ? Promise<AsyncIterableIterator<TOutput>> : Promise<TOutput>;
 /** Infer client type from router */
 type InferClient<T> = T extends ProcedureDef<infer TType, infer TInput, infer TOutput> ? undefined extends TInput ? () => ProcedureResult<TType, TOutput> : (input: TInput) => ProcedureResult<TType, TOutput> : T extends Record<string, unknown> ? { [K in keyof T]: InferClient<T[K]> } : never;
 //#endregion

package/lib/misina.d.mts

@@ -0,0 +1 @@
+export * from 'misina'

package/lib/misina.mjs

@@ -0,0 +1 @@
+export * from 'misina'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.53.3",
+  "version": "0.53.5",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -59,6 +59,10 @@
       "import": "./dist/client/adapters/ofetch/index.mjs",
       "types": "./dist/client/adapters/ofetch/index.d.mts"
     },
+    "./client/misina": {
+      "import": "./dist/client/adapters/misina/index.mjs",
+      "types": "./dist/client/adapters/misina/index.d.mts"
+    },
     "./client/plugins": {
       "import": "./dist/client/plugins/index.mjs",
       "types": "./dist/client/plugins/index.d.mts"
@@ -231,6 +235,10 @@
       "import": "./lib/ofetch.mjs",
       "types": "./lib/ofetch.d.mts"
     },
+    "./misina": {
+      "import": "./lib/misina.mjs",
+      "types": "./lib/misina.d.mts"
+    },
     "./srvx": {
       "import": "./lib/srvx.mjs",
       "types": "./lib/srvx.d.mts"
@@ -245,6 +253,7 @@
     "devalue": "^5.6.4",
     "get-port-please": "^3.2.0",
     "hookable": "^6.1.0",
+    "misina": "^0.2.0",
     "msgpackr": "^1.11.9",
     "ocache": "^0.1.4",
     "ofetch": "2.0.0-alpha.3",