@swimmesberger/elarion-jsonrpc-client-generator 0.2.5-preview.99.1 → 0.2.5

package/dist/events-client-source.js

@@ -296,7 +296,8 @@ function createTopicTreeNode() {
 function emitProperties(node, indent) {
     const pad = '  '.repeat(indent);
     return Array.from(node.children.entries())
-        .sort(([left], [right]) => left.localeCompare(right))
+        // Code-unit comparison, never localeCompare: output must be byte-identical regardless of host locale.
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
         .map(([segment, child]) => `${pad}readonly ${JSON.stringify(segment)}: ${emitNodeType(child, indent)}`);
 }
 function emitNodeType(node, indent) {

package/dist/json-schema-to-ts.js

@@ -1,6 +1,6 @@
-import { baseType, childContext, formatPropertyName, isNullable, resolveSchema, stripNullable, } from './json-schema.js';
+import { baseType, childContext, formatPropertyName, isNullable, resolveSchema, } from './json-schema.js';
 export function jsonSchemaToTypeScript(schema, ctx, indent = 0) {
-    const resolved = resolveSchema(schema, ctx);
+    const { schema: resolved, ctx: resolvedCtx } = resolveSchema(schema, ctx);
     const pad = '  '.repeat(indent);
     const nullable = isNullable(resolved);
     const base = baseType(resolved);
@@ -26,14 +26,17 @@ export function jsonSchemaToTypeScript(schema, ctx, indent = 0) {
         return nullable ? 'boolean | null | undefined' : 'boolean';
     }
     if (base === 'array' && resolved.items) {
-        const itemType = jsonSchemaToTypeScript(stripNullable(resolved.items), childContext(ctx, 'items'), indent);
-        return nullable ? `(${itemType})[] | null | undefined` : `${itemType}[]`;
+        // Unstripped items: the recursion emits the item's own nullability (`string | null | undefined`).
+        const itemType = jsonSchemaToTypeScript(resolved.items, childContext(resolvedCtx, 'items'), indent);
+        // A union item type must be parenthesized — `"red" | "green"[]` is `"red" | ("green"[])`.
+        const element = itemType.includes('|') ? `(${itemType})` : itemType;
+        return nullable ? `${element}[] | null | undefined` : `${element}[]`;
     }
     if (base === 'object' && resolved.properties) {
         const required = new Set(resolved.required ?? []);
         const lines = Object.entries(resolved.properties).map(([key, property]) => {
             const optional = required.has(key) ? '' : '?';
-            const propertyType = jsonSchemaToTypeScript(property, childContext(ctx, `properties.${key}`), indent + 1);
+            const propertyType = jsonSchemaToTypeScript(property, childContext(resolvedCtx, `properties.${key}`), indent + 1);
             return `${pad}  ${formatPropertyName(key)}${optional}: ${propertyType}`;
         });
         const objectType = `{\n${lines.join('\n')}\n${pad}}`;

package/dist/json-schema-to-zod.js

@@ -1,6 +1,6 @@
-import { baseType, childContext, formatPropertyName, isNullable, resolveSchema, stripNullable, } from './json-schema.js';
+import { baseType, childContext, formatPropertyName, isNullable, resolveSchema, } from './json-schema.js';
 export function jsonSchemaToZod(schema, ctx, indent = 0) {
-    const resolved = resolveSchema(schema, ctx);
+    const { schema: resolved, ctx: resolvedCtx } = resolveSchema(schema, ctx);
     const nullable = isNullable(resolved);
     const base = baseType(resolved);
     // Schemas validate the user-facing shape: a file field is a native File on both sides of a call (the
@@ -33,14 +33,17 @@ export function jsonSchemaToZod(schema, ctx, indent = 0) {
         return nullish('z.boolean()', nullable);
     }
     if (base === 'array' && resolved.items) {
-        const itemSchema = jsonSchemaToZod(stripNullable(resolved.items), childContext(ctx, 'items'), indent);
+        // The item schema goes in unstripped: the recursion handles item-level nullability, so a
+        // `["string","null"]` item emits `z.string().nullish()` and a legal `["a", null]` element validates.
+        // Nullability is only ever stripped at the top-level params/result envelope.
+        const itemSchema = jsonSchemaToZod(resolved.items, childContext(resolvedCtx, 'items'), indent);
         return nullish(arraySchema(`z.array(${itemSchema})`, resolved), nullable);
     }
     if (base === 'object' && resolved.properties) {
         const required = new Set(resolved.required ?? []);
         const pad = '  '.repeat(indent + 1);
         const fields = Object.entries(resolved.properties).map(([key, property]) => {
-            let fieldSchema = jsonSchemaToZod(property, childContext(ctx, `properties.${key}`), indent + 1);
+            let fieldSchema = jsonSchemaToZod(property, childContext(resolvedCtx, `properties.${key}`), indent + 1);
             if (!required.has(key)) {
                 fieldSchema += '.optional()';
             }

package/dist/json-schema.d.ts

@@ -11,7 +11,17 @@ export interface SchemaContext {
 export declare function isNullable(schema: JsonSchema): boolean;
 export declare function baseType(schema: JsonSchema): string | undefined;
 export declare function stripNullable(schema: JsonSchema): JsonSchema;
-export declare function resolveSchema(schema: JsonSchema, ctx: SchemaContext): JsonSchema;
+export interface ResolvedSchema {
+    schema: JsonSchema;
+    /**
+     * The context after resolution, carrying every `$ref` traversed to reach the schema. Recursion into
+     * properties/items must continue from this context (not the caller's), so a cycle that re-enters one of
+     * those refs through a property (the shape STJ emits for self-referential DTOs) is detected instead of
+     * overflowing the stack.
+     */
+    ctx: SchemaContext;
+}
+export declare function resolveSchema(schema: JsonSchema, ctx: SchemaContext): ResolvedSchema;
 export declare function childContext(ctx: SchemaContext, segment: string): SchemaContext;
 export declare function formatPropertyName(key: string): string;
 /**

package/dist/json-schema.js

@@ -35,7 +35,7 @@ export function stripNullable(schema) {
 export function resolveSchema(schema, ctx) {
     assertSupportedComposition(schema, ctx.path);
     if (!schema.$ref) {
-        return schema;
+        return { schema, ctx };
     }
     if (!schema.$ref.startsWith('#/')) {
         throw new UnsupportedJsonSchemaError(ctx.path, `only local JSON Pointer $ref values are supported (${schema.$ref})`);
@@ -75,17 +75,17 @@ export function collectFilePaths(schema, ctx) {
     return paths;
 }
 function visitFileNodes(schema, ctx, prefix, paths) {
-    const resolved = resolveSchema(schema, ctx);
+    const { schema: resolved, ctx: resolvedCtx } = resolveSchema(schema, ctx);
     if (resolved['x-elarion-file'] === true) {
         paths.push(prefix);
         return;
     }
     if (resolved.items) {
-        visitFileNodes(stripNullable(resolved.items), childContext(ctx, 'items'), [...prefix, '*'], paths);
+        visitFileNodes(stripNullable(resolved.items), childContext(resolvedCtx, 'items'), [...prefix, '*'], paths);
     }
     if (resolved.properties) {
         for (const [key, property] of Object.entries(resolved.properties)) {
-            visitFileNodes(property, childContext(ctx, `properties.${key}`), [...prefix, key], paths);
+            visitFileNodes(property, childContext(resolvedCtx, `properties.${key}`), [...prefix, key], paths);
         }
     }
 }

package/dist/rpc-client-source.js

@@ -326,7 +326,8 @@ export function generateRpcClientSource(options) {
         '  }',
         '',
         '  function parseResult<M extends RpcMethod>(method: M, result: unknown): RpcResult<M> {',
-        '    const transformed = options.transformResult?.(method, result) ?? result',
+        '    // A transform returning null/undefined is a legitimate result — never ??-fallback to the raw value.',
+        '    const transformed = options.transformResult ? options.transformResult(method, result) : result',
         '    if (!validateResults) {',
         '      return transformed as RpcResult<M>',
         '    }',
@@ -351,6 +352,12 @@ export function generateRpcClientSource(options) {
         '      try {',
         '        const raw = await post(request, context, requestOptions, span)',
         '        const response = parseResponseEnvelope(raw)',
+        '        // A spec-compliant server reports request-level failures (e.g. parse errors) with "id": null —',
+        '        // surface the server error instead of a generic id-mismatch protocol error.',
+        '        if (response.error && (response.id === null || response.id === undefined)) {',
+        '          throw toRpcError(response.error)',
+        '        }',
+        '',
         '        if (!idsEqual(response.id, request.id)) {',
         "          throw new RpcProtocolError('JSON-RPC response id does not match request id.')",
         '        }',
@@ -412,6 +419,11 @@ export function generateRpcClientSource(options) {
         '        const raw = await post(requests, context, requestOptions, span)',
         '',
         '        if (!Array.isArray(raw)) {',
+        '          // JSON-RPC 2.0: a whole-batch failure (invalid JSON, batch too large, ...) is a single error',
+        '          // response object — surface the server error instead of a generic protocol error.',
+        '          if (isRecord(raw) && isJsonRpcErrorObject(raw.error)) {',
+        '            throw toRpcError(raw.error)',
+        '          }',
         "          throw new RpcProtocolError('Expected JSON-RPC batch response array.')",
         '        }',
         '',
@@ -652,7 +664,8 @@ function generateApiTypeLines(methodTree) {
 function emitProperties(node, endpointType, indent) {
     const pad = '  '.repeat(indent);
     return Array.from(node.children.entries())
-        .sort(([left], [right]) => left.localeCompare(right))
+        // Code-unit comparison, never localeCompare: output must be byte-identical regardless of host locale.
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
         .map(([segment, child]) => {
         return `${pad}readonly ${JSON.stringify(segment)}: ${emitNodeType(child, endpointType, indent)}`;
     });

package/package.json

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