silgi 0.53.5 → 0.53.6

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

@@ -1,59 +1,42 @@
 import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
-import { AfterResponseHook, BeforeErrorHook, BeforeRequestHook, MisinaHooks, RetryOptions } from "misina";
+import { Misina, Misina as Misina$1 } 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") */
+  /** 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.
+   * Misina instance the adapter dispatches through. Configure retry,
+   * timeout, hooks, plugins (`use: [...]`), idempotency keys, redirect
+   * policy, custom drivers, etc. on this instance — the adapter does not
+   * accept those options directly.
    *
-   * @default 0
+   * If omitted, the adapter calls `createMisina({ baseURL: url })`. Pass
+   * your own instance to opt into anything beyond default fetch behavior.
    */
-  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;
+  misina?: Misina$1;
   /**
    * Wire protocol for request/response encoding.
    *
    * - `'json'` — default, standard JSON
-   * - `'messagepack'` — 2-4x faster, ~50% smaller payloads
+   * - `'messagepack'` — 2–4× 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.
+   * Static headers or a per-call factory. Headers configured on the
+   * misina instance still apply; these are merged on top per call.
    */
-  idempotencyKey?: false | 'auto' | string | ((request: Request) => string);
-  /** misina hooks — direct pass-through */
-  beforeRequest?: BeforeRequestHook;
-  afterResponse?: AfterResponseHook;
-  beforeError?: BeforeErrorHook;
-  onComplete?: OnCompleteHook;
+  headers?: HeadersInit | Record<string, string | undefined> | ((options: ClientOptions<TClientContext>) => HeadersInit | Record<string, string | undefined>);
 }
 /**
  * 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 })
- * ```
+ * @see {@link LinkOptions} for the full shape and the misina-instance
+ * pattern.
  */
 declare function createLink<TClientContext extends ClientContext = ClientContext>(options: LinkOptions<TClientContext>): ClientLink<TClientContext>;
 //#endregion
-export { LinkOptions, createLink };
+export { LinkOptions, type Misina, createLink };

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

@@ -4,53 +4,76 @@ 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.
+* misina-based RPC transport — silgi client link.
 *
-* Uses misina for: retry (with Retry-After parsing), timeout, hook
-* lifecycle, redirect security, NetworkError vs HTTPError taxonomy,
-* idempotency keys for retried mutations.
+* Thin shim over a misina instance. The adapter owns four things — and
+* nothing else:
 *
-* 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.
+*   1. URL construction from the path tuple
+*   2. Protocol negotiation (json / messagepack / devalue) — sets
+*      content-type/accept and encodes the body accordingly
+*   3. Per-call `responseType: 'stream'` override so SSE subscription
+*      responses can be decoded lazily
+*   4. SilgiError lifting from the response payload, plus mapping
+*      misina's HTTPError / NetworkError / TimeoutError onto SilgiError
+*
+* Everything else — retry, timeout, hooks, idempotency, redirect policy,
+* plugins (cache, breaker, dedupe, cookies, auth, otel, …) — lives on the
+* misina instance you pass in. Configure misina once with
+* `createMisina({ baseURL, retry, use: [plugin(), …] })` and hand the
+* result here.
 *
 * @example
 * ```ts
+* import { createMisina } from "misina"
+* import { cache } from "misina/cache"
+* import { breaker } from "misina/breaker"
+* import { bearer } from "misina/auth"
 * import { createClient } from "silgi/client"
 * import { createLink } from "silgi/client/misina"
 *
-* const link = createLink({ url: "http://localhost:3000" })
+* const url = "http://localhost:3000"
+*
+* const link = createLink({
+*   url,
+*   misina: createMisina({
+*     baseURL: url,
+*     retry: 3,
+*     idempotencyKey: "auto",
+*     use: [
+*       bearer(() => store.token),
+*       cache({ ttl: 60_000 }),
+*       breaker({ failureThreshold: 5, windowMs: 30_000 }),
+*     ],
+*   }),
+* })
+*
 * const client = createClient<AppRouter>(link)
-* const users = await client.users.list({ limit: 10 })
 * ```
+*
+* If `misina` is omitted, the adapter constructs a minimal default
+* instance (`createMisina({ baseURL })`). That's fine for plain RPC; opt
+* into retries, plugins, hooks, etc. by passing your own instance.
+*/
+/**
+* Create a Silgi client link powered by misina.
+*
+* @see {@link LinkOptions} for the full shape and the misina-instance
+* pattern.
 */
 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
-		}
-	});
+	const protocol = options.protocol ?? "json";
+	const misina = options.misina ?? createMisina({ baseURL: baseUrl });
 	return { async call(path, input, callOptions) {
 		const url = `${baseUrl}/${path.map(encodeURIComponent).join("/")}`;
-		const headers = { ...typeof options.headers === "function" ? options.headers(callOptions) : options.headers };
+		const headers = resolveHeaders(options.headers, callOptions);
 		let body;
-		if (resolvedProtocol === "messagepack") {
+		if (protocol === "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") {
+		} else if (protocol === "devalue") {
 			const { encode: devalueEncode, DEVALUE_CONTENT_TYPE } = await import("../../../codec/devalue.mjs");
 			headers["content-type"] = DEVALUE_CONTENT_TYPE;
 			headers["accept"] = DEVALUE_CONTENT_TYPE;
@@ -60,14 +83,15 @@ function createLink(options) {
 			const response = (await misina.post(url, body, {
 				headers,
 				signal: callOptions.signal,
-				responseType: "stream"
+				responseType: "stream",
+				throwHttpErrors: false
 			})).raw;
 			if ((response.headers.get("content-type") ?? "").includes("text/event-stream") && response.body) return eventStreamToIterator(response.body);
 			let decoded;
-			if (resolvedProtocol === "messagepack") {
+			if (protocol === "messagepack") {
 				const buf = new Uint8Array(await response.arrayBuffer());
 				decoded = buf.length > 0 ? decode(buf) : void 0;
-			} else if (resolvedProtocol === "devalue") {
+			} else if (protocol === "devalue") {
 				const text = await response.text();
 				if (text) {
 					const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
@@ -103,5 +127,28 @@ function createLink(options) {
 		}
 	} };
 }
+function resolveHeaders(headers, callOptions) {
+	const raw = typeof headers === "function" ? headers(callOptions) : headers;
+	const out = {};
+	if (raw == null) return out;
+	if (raw instanceof Headers) {
+		raw.forEach((value, key) => {
+			out[key] = value;
+		});
+		return out;
+	}
+	if (Array.isArray(raw)) {
+		for (const [k, v] of raw) {
+			if (v == null) continue;
+			out[k] = String(v);
+		}
+		return out;
+	}
+	for (const [k, v] of Object.entries(raw)) {
+		if (v == null) continue;
+		out[k] = String(v);
+	}
+	return out;
+}
 //#endregion
 export { createLink };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.53.5",
+  "version": "0.53.6",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -253,7 +253,7 @@
     "devalue": "^5.6.4",
     "get-port-please": "^3.2.0",
     "hookable": "^6.1.0",
-    "misina": "^0.2.0",
+    "misina": "^0.4.0",
     "msgpackr": "^1.11.9",
     "ocache": "^0.1.4",
     "ofetch": "2.0.0-alpha.3",