@swimmesberger/elarion-jsonrpc-client-generator 0.1.0-preview.9.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @swimmesberger/elarion-jsonrpc-client-generator
 
-Generate TypeScript RPC method contracts and Zod result schemas from an Elarion `rpc-schema.json` export.
+Generate TypeScript RPC method contracts, Zod result schemas, and a portable fetch-based JSON-RPC client from an Elarion `rpc-schema.json` export.
 
 ```bash
 npm install --save-dev @swimmesberger/elarion-jsonrpc-client-generator
@@ -13,5 +13,81 @@ The generated files are:
 | --- | --- |
 | `rpc-types.ts` | `RpcMethods` interface mapping method names to params/result types. |
 | `rpc-schemas.ts` | `rpcResultSchemas` Zod map for runtime result validation. |
+| `rpc-client.ts` | Browser/Node.js fetch client with typed single calls, batching, headers, `AbortSignal`, JSON-RPC errors, and Zod-backed result validation. |
 
-The generated schema file imports `zod`, so consuming applications should install `zod` as a runtime dependency.
+The generated schema and client files import `zod`, so consuming applications should install `zod` as a runtime dependency.
+
+## Generated API client
+
+```ts
+import { createRpcApi } from './generated/rpc-client'
+
+const rpc = createRpcApi({
+  url: '/rpc',
+  headers: { Authorization: `Bearer ${token}` },
+})
+
+const abort = new AbortController()
+const client = await rpc.clients.get({ id: clientId }, { signal: abort.signal })
+```
+
+The generated API mirrors dotted JSON-RPC method names as nested properties, so `clients.get` becomes `rpc.clients.get(...)`. The file also exports the lower-level `createRpcClient(...)` generic transport for advanced cases.
+
+The API client uses `globalThis.fetch` in browsers and modern Node.js. Pass `fetch` explicitly for tests, older Node.js runtimes, server-function forwarding, or framework-specific transport wrappers:
+
+```ts
+const rpc = createRpcApi({
+  url: process.env.API_INTERNAL_URL + '/rpc',
+  fetch,
+  headers: async ({ batch, methods }) => ({
+    'X-RPC-Batch': String(batch),
+    'X-RPC-Methods': methods.join(','),
+  }),
+})
+```
+
+Batching uses generated request builders, so params and results stay tied to each RPC method. Batch results preserve input order even when the server returns JSON-RPC responses out of order. Each item returns either `{ ok: true, result }` or `{ ok: false, error }`, so one method failure does not reject the whole batch:
+
+```ts
+const [clientResult, projectsResult] = await rpc.$batch([
+  rpc.$request.clients.get({ id: clientId }),
+  rpc.$request.projects.list({ clientId }),
+] as const)
+```
+
+Result validation is enabled by default through `rpcResultSchemas`. Use `transformResult` for app-specific normalization before validation, or set `validateResults: false` when another layer validates responses.
+
+## Client-side tracing
+
+The generated client never imports an OpenTelemetry SDK. Instead it exposes an optional `instrumentation` hook so client-side tracing stays a host decision and adds zero dependencies. The client calls `startSpan` once per request (and once per batch), reads the returned span's `headers` to inject trace context into the outgoing request, then calls `setError`/`end` as the request settles:
+
+```ts
+interface RpcInstrumentation {
+  startSpan(context: { methods: readonly string[]; batch: boolean }): RpcClientSpan | undefined
+}
+
+interface RpcClientSpan {
+  readonly headers?: HeadersInit // e.g. { traceparent } — merged in last, so it stays authoritative
+  setError(error: unknown): void
+  end(): void
+}
+```
+
+Minimal, dependency-free W3C context propagation (continues the server trace; ASP.NET Core reads `traceparent` automatically):
+
+```ts
+const rpc = createRpcApi({
+  url: '/rpc',
+  instrumentation: {
+    startSpan() {
+      const traceId = crypto.getRandomValues(new Uint8Array(16))
+      const spanId = crypto.getRandomValues(new Uint8Array(8))
+      const hex = (bytes: Uint8Array) => [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')
+      const traceparent = `00-${hex(traceId)}-${hex(spanId)}-01`
+      return { headers: { traceparent }, setError() {}, end() {} }
+    },
+  },
+})
+```
+
+Hosts that already run `@opentelemetry/api` pass a small adapter that starts a real `CLIENT` span and injects context via the API's propagator — still no SDK in the generated client. Per-item application errors in a batch are returned as data (`{ ok: false, error }`), so the batch span ends without `setError`; only transport/protocol failures mark the span as errored.

package/dist/cli.js

@@ -37,6 +37,11 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (arg === '--client') {
+            options.clientFileName = next;
+            index += 1;
+            continue;
+        }
         if (arg === '--source-label') {
             options.sourceLabel = next;
             index += 1;
@@ -54,6 +59,7 @@ Options:
   --out <dir>           Output directory (default: src/generated)
   --types <file>        TypeScript types filename (default: rpc-types.ts)
   --schemas <file>      Zod schemas filename (default: rpc-schemas.ts)
+  --client <file>       Fetch client filename (default: rpc-client.ts)
   --source-label <text> Source label written into generated file headers
 `);
 }
@@ -67,10 +73,12 @@ function main() {
         sourceLabel: options.sourceLabel ?? basename(schemaPath),
         typesFileName: options.typesFileName,
         schemasFileName: options.schemasFileName,
+        clientFileName: options.clientFileName,
     });
     mkdirSync(outDir, { recursive: true });
     writeFileSync(resolve(outDir, generated.typesFileName), generated.typesSource, 'utf-8');
     writeFileSync(resolve(outDir, generated.schemasFileName), generated.schemasSource, 'utf-8');
+    writeFileSync(resolve(outDir, generated.clientFileName), generated.clientSource, 'utf-8');
     console.log(`[jsonrpc-client-generator] Generated ${generated.methodCount} RPC method types and schemas -> ${outDir}`);
 }
 main();

package/dist/generate.js

@@ -1,16 +1,19 @@
 import { jsonSchemaToTypeScript } from './json-schema-to-ts.js';
 import { jsonSchemaToZod } from './json-schema-to-zod.js';
 import { stripNullable } from './json-schema.js';
+import { generateRpcClientSource } from './rpc-client-source.js';
 const DEFAULT_GENERATED_BY = 'elarion-jsonrpc-client-generator';
 const DEFAULT_SOURCE_LABEL = 'rpc-schema.json';
 const DEFAULT_TYPES_FILE = 'rpc-types.ts';
 const DEFAULT_SCHEMAS_FILE = 'rpc-schemas.ts';
+const DEFAULT_CLIENT_FILE = 'rpc-client.ts';
 export { UnsupportedJsonSchemaError } from './json-schema.js';
 export function generateRpcClientFiles(schema, options = {}) {
     const generatedBy = options.generatedBy ?? DEFAULT_GENERATED_BY;
     const sourceLabel = options.sourceLabel ?? DEFAULT_SOURCE_LABEL;
     const typesFileName = options.typesFileName ?? DEFAULT_TYPES_FILE;
     const schemasFileName = options.schemasFileName ?? DEFAULT_SCHEMAS_FILE;
+    const clientFileName = options.clientFileName ?? DEFAULT_CLIENT_FILE;
     const methods = Object.keys(schema.methods).sort();
     const typesLines = [
         `// Auto-generated by ${generatedBy} — DO NOT EDIT`,
@@ -46,12 +49,21 @@ export function generateRpcClientFiles(schema, options = {}) {
     schemasLines.push('');
     schemasLines.push('export type RpcResultSchemas = typeof rpcResultSchemas');
     schemasLines.push('');
+    const clientSource = generateRpcClientSource({
+        generatedBy,
+        sourceLabel,
+        typesFileName,
+        schemasFileName,
+        methods,
+    });
     return {
         methodCount: methods.length,
         typesFileName,
         schemasFileName,
+        clientFileName,
         typesSource: typesLines.join('\n'),
         schemasSource: schemasLines.join('\n'),
+        clientSource,
     };
 }
 function createContext(root, path) {

package/dist/rpc-client-source.d.ts

@@ -0,0 +1,9 @@
+interface GenerateRpcClientSourceOptions {
+    generatedBy: string;
+    sourceLabel: string;
+    typesFileName: string;
+    schemasFileName: string;
+    methods: readonly string[];
+}
+export declare function generateRpcClientSource(options: GenerateRpcClientSourceOptions): string;
+export {};

package/dist/rpc-client-source.js

@@ -0,0 +1,507 @@
+export function generateRpcClientSource(options) {
+    const typesImport = moduleSpecifier(options.typesFileName);
+    const schemasImport = moduleSpecifier(options.schemasFileName);
+    const methodTree = buildMethodTree(options.methods);
+    return [
+        `// Auto-generated by ${options.generatedBy} — DO NOT EDIT`,
+        `// Source: ${options.sourceLabel}`,
+        '',
+        `import type { RpcMethods } from '${typesImport}'`,
+        `import { rpcResultSchemas } from '${schemasImport}'`,
+        '',
+        'export type RpcMethod = keyof RpcMethods & string',
+        "export type RpcParams<M extends RpcMethod> = RpcMethods[M]['params']",
+        "export type RpcResult<M extends RpcMethod> = RpcMethods[M]['result']",
+        '',
+        'export type RpcFetchInput = string | URL | Request',
+        'export type RpcHeadersInit = Headers | Record<string, string> | readonly (readonly [string, string])[]',
+        'export type RpcFetch = (input: RpcFetchInput, init?: RequestInit) => Promise<Response>',
+        '',
+        'export interface RpcRequestContext {',
+        '  readonly methods: readonly RpcMethod[]',
+        '  readonly batch: boolean',
+        '}',
+        '',
+        'export type RpcHeaders =',
+        '  | RpcHeadersInit',
+        '  | ((context: RpcRequestContext) => RpcHeadersInit | Promise<RpcHeadersInit>)',
+        '',
+        '// Optional client-side tracing hook. Supply an adapter (for example over @opentelemetry/api, or a',
+        '// hand-rolled W3C `traceparent` generator) to start a span per request/batch, inject trace-context',
+        '// headers, and record the outcome. Zero-dependency: the generated client never imports a tracing SDK.',
+        'export interface RpcClientSpan {',
+        '  // Headers injected into the outgoing request (e.g. `{ traceparent }`); read before the fetch.',
+        '  readonly headers?: RpcHeadersInit',
+        '  // Called with the thrown transport/protocol/RPC error before it propagates.',
+        '  setError(error: unknown): void',
+        '  // Always called once the request settles (success or failure).',
+        '  end(): void',
+        '}',
+        '',
+        'export interface RpcInstrumentation {',
+        '  startSpan(context: RpcRequestContext): RpcClientSpan | undefined',
+        '}',
+        '',
+        'export interface RpcClientOptions {',
+        '  readonly url: string | URL',
+        '  readonly fetch?: RpcFetch',
+        '  readonly headers?: RpcHeaders',
+        '  readonly idGenerator?: () => string | number',
+        '  readonly validateResults?: boolean',
+        '  readonly transformResult?: <M extends RpcMethod>(method: M, result: unknown) => unknown',
+        '  readonly instrumentation?: RpcInstrumentation',
+        '}',
+        '',
+        'export interface RpcRequestOptions {',
+        '  readonly signal?: AbortSignal',
+        '  readonly headers?: RpcHeadersInit',
+        '}',
+        '',
+        'export interface BatchItem<M extends RpcMethod = RpcMethod> {',
+        '  readonly method: M',
+        '  readonly params: RpcParams<M>',
+        '}',
+        '',
+        'export type BatchItemResult<M extends RpcMethod = RpcMethod> =',
+        '  | { readonly ok: true; readonly result: RpcResult<M> }',
+        '  | { readonly ok: false; readonly error: RpcError }',
+        '',
+        'export type BatchResult<T extends readonly BatchItem[]> = {',
+        '  readonly [K in keyof T]: T[K] extends BatchItem<infer M> ? BatchItemResult<M> : never',
+        '}',
+        '',
+        ...generateApiTypeLines(methodTree),
+        'export interface RpcClient {',
+        '  call<M extends RpcMethod>(',
+        '    method: M,',
+        '    params: RpcParams<M>,',
+        '    options?: RpcRequestOptions',
+        '  ): Promise<RpcResult<M>>',
+        '',
+        '  batch<const T extends readonly BatchItem[]>(',
+        '    items: T,',
+        '    options?: RpcRequestOptions',
+        '  ): Promise<BatchResult<T>>',
+        '}',
+        '',
+        ...generateMethodNameLines(options.methods),
+        'type JsonRpcId = string | number',
+        '',
+        'interface JsonRpcRequestEnvelope<M extends RpcMethod = RpcMethod> {',
+        "  readonly jsonrpc: '2.0'",
+        '  readonly method: M',
+        '  readonly params: RpcParams<M>',
+        '  readonly id: JsonRpcId',
+        '}',
+        '',
+        'interface JsonRpcErrorObject {',
+        '  readonly code: number',
+        '  readonly message: string',
+        '  readonly data?: unknown',
+        '}',
+        '',
+        'interface JsonRpcResponseEnvelope {',
+        '  readonly id?: JsonRpcId | null',
+        '  readonly result?: unknown',
+        '  readonly error?: JsonRpcErrorObject',
+        '}',
+        '',
+        'export class RpcError extends Error {',
+        '  constructor(',
+        '    public readonly code: number,',
+        '    message: string,',
+        '    public readonly data?: unknown',
+        '  ) {',
+        '    super(message)',
+        "    this.name = 'RpcError'",
+        '  }',
+        '',
+        '  get isParseError() {',
+        '    return this.code === -32700',
+        '  }',
+        '',
+        '  get isInvalidRequest() {',
+        '    return this.code === -32600',
+        '  }',
+        '',
+        '  get isMethodNotFound() {',
+        '    return this.code === -32601',
+        '  }',
+        '',
+        '  get isInvalidParams() {',
+        '    return this.code === -32602',
+        '  }',
+        '',
+        '  get isInternalError() {',
+        '    return this.code === -32603',
+        '  }',
+        '}',
+        '',
+        'export class RpcTransportError extends Error {',
+        '  constructor(',
+        '    public readonly status: number,',
+        '    public readonly statusText: string,',
+        '    public readonly body: string',
+        '  ) {',
+        '    super(`RPC transport error: ${status} ${statusText}`.trim())',
+        "    this.name = 'RpcTransportError'",
+        '  }',
+        '}',
+        '',
+        'export class RpcProtocolError extends Error {',
+        '  constructor(message: string) {',
+        '    super(message)',
+        "    this.name = 'RpcProtocolError'",
+        '  }',
+        '}',
+        '',
+        'export function createRpcApi(options: RpcClientOptions): RpcApi {',
+        '  const client = createRpcClient(options)',
+        '  const calls: Record<string, unknown> = {}',
+        '  const requests: Record<string, unknown> = {}',
+        '',
+        '  for (const method of rpcMethodNames) {',
+        '    setApiPath(calls, method, (params: unknown, requestOptions?: RpcRequestOptions) =>',
+        '      client.call(method, params as RpcParams<typeof method>, requestOptions))',
+        '    setApiPath(requests, method, (params: unknown) => ({',
+        '      method,',
+        '      params: params as RpcParams<typeof method>,',
+        '    }))',
+        '  }',
+        '',
+        '  return {',
+        '    ...calls,',
+        '    $client: client,',
+        '    $batch: client.batch,',
+        '    $request: requests,',
+        '  } as unknown as RpcApi',
+        '}',
+        '',
+        'export function createRpcClient(options: RpcClientOptions): RpcClient {',
+        '  const fetchImpl = options.fetch ?? globalThis.fetch',
+        '  if (!fetchImpl) {',
+        "    throw new Error('No fetch implementation is available. Pass fetch in createRpcClient options.')",
+        '  }',
+        '',
+        '  let nextId = 1',
+        '  const createId = options.idGenerator ?? (() => globalThis.crypto?.randomUUID?.() ?? String(nextId++))',
+        '  const validateResults = options.validateResults ?? true',
+        '',
+        '  async function post(',
+        '    payload: unknown,',
+        '    context: RpcRequestContext,',
+        '    requestOptions?: RpcRequestOptions,',
+        '    span?: RpcClientSpan',
+        '  ): Promise<unknown> {',
+        '    const response = await fetchImpl(options.url, {',
+        "      method: 'POST',",
+        '      headers: await buildHeaders(options.headers, context, requestOptions?.headers, span?.headers),',
+        '      body: JSON.stringify(payload),',
+        '      signal: requestOptions?.signal,',
+        '    })',
+        '',
+        '    if (!response.ok) {',
+        '      throw new RpcTransportError(response.status, response.statusText, await response.text())',
+        '    }',
+        '',
+        '    return response.json()',
+        '  }',
+        '',
+        '  function parseResult<M extends RpcMethod>(method: M, result: unknown): RpcResult<M> {',
+        '    const transformed = options.transformResult?.(method, result) ?? result',
+        '    if (!validateResults) {',
+        '      return transformed as RpcResult<M>',
+        '    }',
+        '',
+        '    return rpcResultSchemas[method].parse(transformed) as RpcResult<M>',
+        '  }',
+        '',
+        '  return {',
+        '    async call<M extends RpcMethod>(',
+        '      method: M,',
+        '      params: RpcParams<M>,',
+        '      requestOptions?: RpcRequestOptions',
+        '    ): Promise<RpcResult<M>> {',
+        '      const request = createRequest(method, params, createId())',
+        '      const context: RpcRequestContext = { methods: [method], batch: false }',
+        '      const span = options.instrumentation?.startSpan(context)',
+        '      try {',
+        '        const raw = await post(request, context, requestOptions, span)',
+        '        const response = parseResponseEnvelope(raw)',
+        '        if (!idsEqual(response.id, request.id)) {',
+        "          throw new RpcProtocolError('JSON-RPC response id does not match request id.')",
+        '        }',
+        '',
+        '        if (response.error) {',
+        '          throw toRpcError(response.error)',
+        '        }',
+        '',
+        '        return parseResult(method, response.result)',
+        '      } catch (error) {',
+        '        span?.setError(error)',
+        '        throw error',
+        '      } finally {',
+        '        span?.end()',
+        '      }',
+        '    },',
+        '',
+        '    async batch<const T extends readonly BatchItem[]>(',
+        '      items: T,',
+        '      requestOptions?: RpcRequestOptions',
+        '    ): Promise<BatchResult<T>> {',
+        '      if (items.length === 0) {',
+        '        return [] as unknown as BatchResult<T>',
+        '      }',
+        '',
+        '      const requests = items.map((item) => createRequest(item.method, item.params, createId()))',
+        '      const context: RpcRequestContext = { methods: items.map((item) => item.method), batch: true }',
+        '      const span = options.instrumentation?.startSpan(context)',
+        '      try {',
+        '        const raw = await post(requests, context, requestOptions, span)',
+        '',
+        '        if (!Array.isArray(raw)) {',
+        "          throw new RpcProtocolError('Expected JSON-RPC batch response array.')",
+        '        }',
+        '',
+        '        const responsesById = new Map<string, JsonRpcResponseEnvelope>()',
+        '        for (const item of raw) {',
+        '          const response = parseResponseEnvelope(item)',
+        '          if (response.id === undefined || response.id === null) {',
+        "            throw new RpcProtocolError('JSON-RPC batch response item is missing an id.')",
+        '          }',
+        '          const responseKey = idKey(response.id)',
+        '          if (responsesById.has(responseKey)) {',
+        "            throw new RpcProtocolError('JSON-RPC batch response contains a duplicate id.')",
+        '          }',
+        '          responsesById.set(responseKey, response)',
+        '        }',
+        '',
+        '        return requests.map((request, index) => {',
+        '          const method = items[index].method',
+        '          const response = responsesById.get(idKey(request.id))',
+        '          if (!response) {',
+        "            return { ok: false, error: new RpcError(-32603, 'Missing JSON-RPC batch response item.') }",
+        '          }',
+        '',
+        '          if (response.error) {',
+        '            return { ok: false, error: toRpcError(response.error) }',
+        '          }',
+        '',
+        '          try {',
+        '            return { ok: true, result: parseResult(method, response.result) }',
+        '          } catch (error) {',
+        "            return { ok: false, error: new RpcError(-32603, 'Invalid RPC result.', error) }",
+        '          }',
+        '        }) as BatchResult<T>',
+        '      } catch (error) {',
+        '        span?.setError(error)',
+        '        throw error',
+        '      } finally {',
+        '        span?.end()',
+        '      }',
+        '    },',
+        '  }',
+        '}',
+        '',
+        'function createRequest<M extends RpcMethod>(',
+        '  method: M,',
+        '  params: RpcParams<M>,',
+        '  id: JsonRpcId',
+        '): JsonRpcRequestEnvelope<M> {',
+        "  return { jsonrpc: '2.0', method, params, id }",
+        '}',
+        '',
+        'function setApiPath(root: Record<string, unknown>, method: string, value: unknown): void {',
+        "  const segments = method.split('.')",
+        '  let node = root',
+        '',
+        '  for (let index = 0; index < segments.length - 1; index += 1) {',
+        '    const segment = segments[index]',
+        '    const existing = node[segment]',
+        '    if (isObjectLike(existing)) {',
+        '      node = existing',
+        '      continue',
+        '    }',
+        '',
+        '    const next: Record<string, unknown> = {}',
+        '    node[segment] = next',
+        '    node = next',
+        '  }',
+        '',
+        '  node[segments[segments.length - 1] ?? method] = value',
+        '}',
+        '',
+        'async function buildHeaders(',
+        '  baseHeaders: RpcHeaders | undefined,',
+        '  context: RpcRequestContext,',
+        '  requestHeaders: RpcHeadersInit | undefined,',
+        '  instrumentationHeaders: RpcHeadersInit | undefined',
+        '): Promise<Headers> {',
+        '  const headers = new Headers()',
+        "  headers.set('Content-Type', 'application/json')",
+        '',
+        '  if (baseHeaders) {',
+        '    mergeHeaders(',
+        '      headers,',
+        "      typeof baseHeaders === 'function' ? await baseHeaders(context) : baseHeaders",
+        '    )',
+        '  }',
+        '',
+        '  if (requestHeaders) {',
+        '    mergeHeaders(headers, requestHeaders)',
+        '  }',
+        '',
+        '  // Trace-context headers are applied last so instrumentation stays authoritative over propagation.',
+        '  if (instrumentationHeaders) {',
+        '    mergeHeaders(headers, instrumentationHeaders)',
+        '  }',
+        '',
+        '  return headers',
+        '}',
+        '',
+        'function mergeHeaders(target: Headers, source: RpcHeadersInit): void {',
+        '  if (source instanceof Headers) {',
+        '    source.forEach((value, key) => {',
+        '      target.set(key, value)',
+        '    })',
+        '    return',
+        '  }',
+        '',
+        '  if (Array.isArray(source)) {',
+        '    for (const [key, value] of source) {',
+        '      target.set(key, value)',
+        '    }',
+        '    return',
+        '  }',
+        '',
+        '  for (const [key, value] of Object.entries(source)) {',
+        '    target.set(key, value)',
+        '  }',
+        '}',
+        '',
+        'function idKey(id: JsonRpcId): string {',
+        '  return `${typeof id}:${String(id)}`',
+        '}',
+        '',
+        'function idsEqual(actual: JsonRpcId | null | undefined, expected: JsonRpcId): boolean {',
+        '  return actual === expected && typeof actual === typeof expected',
+        '}',
+        '',
+        'function parseResponseEnvelope(value: unknown): JsonRpcResponseEnvelope {',
+        '  if (!isRecord(value)) {',
+        "    throw new RpcProtocolError('Expected JSON-RPC response object.')",
+        '  }',
+        '',
+        '  const error = value.error',
+        '  if (error !== undefined && !isJsonRpcErrorObject(error)) {',
+        "    throw new RpcProtocolError('Invalid JSON-RPC error object.')",
+        '  }',
+        '',
+        '  const id = value.id',
+        '  if (id !== undefined && id !== null && typeof id !== ' + "'string'" + ' && typeof id !== ' + "'number'" + ') {',
+        "    throw new RpcProtocolError('Invalid JSON-RPC response id.')",
+        '  }',
+        '',
+        '  return { id, result: value.result, error }',
+        '}',
+        '',
+        'function isJsonRpcErrorObject(value: unknown): value is JsonRpcErrorObject {',
+        '  return (',
+        '    isRecord(value) &&',
+        "    typeof value.code === 'number' &&",
+        "    typeof value.message === 'string'",
+        '  )',
+        '}',
+        '',
+        'function toRpcError(error: JsonRpcErrorObject): RpcError {',
+        '  return new RpcError(error.code, error.message, error.data)',
+        '}',
+        '',
+        'function isRecord(value: unknown): value is Record<string, unknown> {',
+        "  return typeof value === 'object' && value !== null && !Array.isArray(value)",
+        '}',
+        '',
+        'function isObjectLike(value: unknown): value is Record<string, unknown> {',
+        "  return (typeof value === 'object' && value !== null) || typeof value === 'function'",
+        '}',
+        '',
+    ].join('\n');
+}
+function moduleSpecifier(fileName) {
+    const withoutExtension = fileName.replace(/[.][cm]?tsx?$/, '');
+    const relativePath = withoutExtension.startsWith('.')
+        ? withoutExtension
+        : `./${withoutExtension}`;
+    return `${relativePath}.js`;
+}
+function buildMethodTree(methods) {
+    const root = createMethodTreeNode();
+    for (const method of methods) {
+        const segments = method.split('.');
+        let node = root;
+        for (const segment of segments) {
+            let child = node.children.get(segment);
+            if (!child) {
+                child = createMethodTreeNode();
+                node.children.set(segment, child);
+            }
+            node = child;
+        }
+        node.method = method;
+    }
+    return root;
+}
+function createMethodTreeNode() {
+    return { children: new Map() };
+}
+function generateApiTypeLines(methodTree) {
+    return [
+        'export type RpcEndpoint<M extends RpcMethod> = (',
+        '  params: RpcParams<M>,',
+        '  options?: RpcRequestOptions',
+        ') => Promise<RpcResult<M>>',
+        '',
+        'export type RpcBatchRequest<M extends RpcMethod> = (params: RpcParams<M>) => BatchItem<M>',
+        '',
+        'export interface RpcApi {',
+        '  readonly $client: RpcClient',
+        "  readonly $batch: RpcClient['batch']",
+        '  readonly $request: RpcRequestApi',
+        ...emitProperties(methodTree, 'RpcEndpoint', 1),
+        '}',
+        '',
+        'export interface RpcRequestApi {',
+        ...emitProperties(methodTree, 'RpcBatchRequest', 1),
+        '}',
+        '',
+    ];
+}
+function emitProperties(node, endpointType, indent) {
+    const pad = '  '.repeat(indent);
+    return Array.from(node.children.entries())
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([segment, child]) => {
+        return `${pad}readonly ${JSON.stringify(segment)}: ${emitNodeType(child, endpointType, indent)}`;
+    });
+}
+function emitNodeType(node, endpointType, indent) {
+    const childLines = emitProperties(node, endpointType, indent + 1);
+    const childObject = childLines.length === 0
+        ? '{}'
+        : `{\n${childLines.join('\n')}\n${'  '.repeat(indent)}}`;
+    if (node.method && childLines.length > 0) {
+        return `${endpointType}<${JSON.stringify(node.method)}> & ${childObject}`;
+    }
+    if (node.method) {
+        return `${endpointType}<${JSON.stringify(node.method)}>`;
+    }
+    return childObject;
+}
+function generateMethodNameLines(methods) {
+    return [
+        'const rpcMethodNames = [',
+        ...methods.map((method) => `  ${JSON.stringify(method)},`),
+        '] as const satisfies readonly RpcMethod[]',
+        '',
+    ];
+}

package/dist/schema.d.ts

@@ -23,11 +23,14 @@ export interface GenerateRpcClientOptions {
     sourceLabel?: string;
     typesFileName?: string;
     schemasFileName?: string;
+    clientFileName?: string;
 }
 export interface GeneratedRpcClientFiles {
     methodCount: number;
     typesFileName: string;
     schemasFileName: string;
+    clientFileName: string;
     typesSource: string;
     schemasSource: string;
+    clientSource: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@swimmesberger/elarion-jsonrpc-client-generator",
-  "version": "0.1.0-preview.9.1",
-  "description": "Generate TypeScript RPC contracts and Zod result schemas from Elarion JSON-RPC schema exports.",
+  "version": "0.2.0",
+  "description": "Generate TypeScript RPC contracts, Zod schemas, and a fetch client from Elarion JSON-RPC schema exports.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {