[pull] master from glideapps:master

.github/workflows/test-pr.yaml

@@ -55,14 +55,12 @@
                     - scala3,schema-scala3
                     - scala3-upickle,schema-scala3-upickle
                     - elixir,schema-elixir,graphql-elixir
+                    - elm,schema-elm
                     - comment-injection-treesitter,comment-injection-typescript,comment-injection-typescript-zod,comment-injection-typescript-effect-schema
 
                     # Partially working
                     # - schema-typescript # TODO Unify with typescript once fixed
 
-                    # Implementation is too outdated to test in GitHub Actions
-                    # - elm,schema-elm
-
                     # Language is too niche / obscure to test easily on ubuntu-22.04
                     # - pike,schema-pike
 
@@ -136,7 +134,7 @@
             - name: Install Elm
               if: ${{ contains(matrix.fixture, 'elm') }}
               run: |
-                  curl -L -o elm.gz https://github.com/elm/compiler/releases/download/0.19.1/binary-for-linux-64-bit.gz
+                  curl -L -o elm.gz https://github.com/elm/compiler/releases/download/0.19.2/elm-0.19.2-linux-x64.gz
                   gunzip elm.gz
                   chmod +x elm
                   sudo mv elm /usr/local/bin/

CLAUDE.md

@@ -15,6 +15,9 @@ JSON to the input.
   `.N.json` samples and `.N.fail.<feature>.json` expected-failure samples. A
   fail sample must make the generated program exit nonzero; which fail
   samples run is controlled by the language's `features` list.
+- Every schema fixture test must have at least one positive (`.N.json`) and
+  one negative (`.N.fail.<feature>.json`) test case, unless there is a very
+  good reason not to.
 - Per-language configuration — which inputs run (`skipJSON`, `includeJSON`,
   `skipSchema`), renderer options, and `features` — lives in
   `test/languages.ts`; fixtures are registered in `test/fixtures.ts`.
@@ -25,7 +28,29 @@ Any change that affects generated output MUST be covered by a JSON or JSON
 Schema fixture test — by enabling existing inputs for the language or adding
 new ones. Unit tests in `test/unit/` are a complement for what fixtures cannot
 express (asserting that some code is *not* generated, API-level behavior, fast
-local iteration) — never a substitute.
+local iteration) — never a substitute. Do not add a unit test when a fixture
+test will do the job: if a fixture input already exercises the behavior, a
+unit test duplicating that coverage is superfluous and should not be added.
+
+## Known CI flakiness
+
+Three fixture-CI failure modes are infrastructure flakes, not test or PR bugs:
+
+- **scala3-upickle**: the Bloop compiler server sometimes times out after 30
+  seconds at startup, and `maven-nightlies` artifact downloads sometimes fail.
+- **elm**: the fixture setup (`rm -rf elm-stuff && elm make Warmup.elm`) can
+  race the compiler, deadlocking on `elm-stuff/*.dat` file locks.
+- **cjson**: `cJSON.c` is downloaded from raw.githubusercontent.com at test
+  time and can hit transient SSL/connection failures.
+
+Two things amplify them: the fixture matrix runs with `fail-fast: true`, so
+one flaky job cancels all sibling language jobs, and the `test-complete`
+check only mirrors the matrix — it is never an independent failure.
+
+For the time being we accept these flakes; when one happens, retry the failed
+jobs (`gh run rerun <run-id> --failed`). A failure in one of these areas only
+counts as real if it reproduces across retries or the PR actually touches
+that area.
 
 ## Releasing / version bumps
 

package.json

@@ -6,7 +6,7 @@
     "types": "dist/index.d.ts",
     "repository": "https://github.com/glideapps/quicktype",
     "engines": {
-        "node": ">=20.0.0"
+        "node": ">=20.19.0"
     },
     "scripts": {
         "pub": "script/publish-npm.sh && script/publish-vscode.sh",
@@ -48,7 +48,7 @@
         "quicktype-graphql-input": "24.0.0",
         "quicktype-typescript-input": "24.0.0",
         "readable-stream": "^4.5.2",
-        "stream-json": "1.8.0",
+        "stream-json": "3.5.0",
         "string-to-stream": "^3.0.1",
         "wordwrap": "^1.0.0"
     },
@@ -61,7 +61,6 @@
         "@types/node": "~20.19.0",
         "@types/semver": "^7.5.0",
         "@types/shelljs": "^0.10.0",
-        "@types/stream-json": "^1.7.3",
         "@types/urijs": "^1.19.26",
         "@types/wordwrap": "^1.0.3",
         "ajv": "^8.20.0",

packages/quicktype-core/src/ConvenienceRenderer.ts

@@ -995,10 +995,7 @@ export abstract class ConvenienceRenderer extends Renderer {
         f: (name: Name, jsonName: string, position: ForEachPosition) => void,
     ): void {
         const caseNames = defined(this._caseNamesStoreView).get(e);
-        const sortedCaseNames = mapSortBy(caseNames, (n) =>
-            defined(this.names.get(n)),
-        );
-        this.forEachWithBlankLines(sortedCaseNames, blankLocations, f);
+        this.forEachWithBlankLines(caseNames, blankLocations, f);
     }
 
     protected forEachTransformation(

packages/quicktype-core/src/GraphRewriting.ts

@@ -189,8 +189,14 @@ export class TypeReconstituter<TBuilder extends BaseGraphRewriteBuilder> {
     }
 
     public getUniqueArrayType(): void {
-        this.registerAndAddAttributes(
-            this.builderForNewType().getUniqueArrayType(this._forwardingRef),
+        // The attributes must be passed at creation, not added
+        // afterwards with `addAttributes`, which would assert on
+        // identity attributes such as minItems/maxItems.
+        this.register(
+            this.builderForNewType().getUniqueArrayType(
+                this._typeAttributes,
+                this._forwardingRef,
+            ),
         );
     }
 

packages/quicktype-core/src/Type/TypeBuilder.ts

@@ -479,11 +479,14 @@ export class TypeBuilder {
         this.registerType(type);
     }
 
-    public getUniqueArrayType(forwardingRef?: TypeRef): TypeRef {
+    public getUniqueArrayType(
+        attributes?: TypeAttributes,
+        forwardingRef?: TypeRef,
+    ): TypeRef {
         return this.addType(
             forwardingRef,
             (tr) => new ArrayType(tr, this.typeGraph, undefined),
-            undefined,
+            attributes,
         );
     }
 

packages/quicktype-core/src/attributes/Constraints.ts

@@ -97,7 +97,7 @@ export class MinMaxConstraintTypeAttributeKind extends TypeAttributeKind<MinMaxC
         t: Type,
         attr: MinMaxConstraint,
     ): void {
-        if (this._typeKinds.has(t.kind)) return;
+        if (!this._typeKinds.has(t.kind)) return;
 
         const [min, max] = attr;
         if (min !== undefined) {
@@ -130,6 +130,14 @@ export const minMaxLengthTypeAttributeKind: TypeAttributeKind<MinMaxConstraint>
         "maxLength",
     );
 
+export const minMaxItemsTypeAttributeKind: TypeAttributeKind<MinMaxConstraint> =
+    new MinMaxConstraintTypeAttributeKind(
+        "minMaxItems",
+        new Set<TypeKind>(["array"]),
+        "minItems",
+        "maxItems",
+    );
+
 function producer(
     schema: JSONSchema,
     minProperty: string,
@@ -179,6 +187,20 @@ export function minMaxLengthAttributeProducer(
     };
 }
 
+export function minMaxItemsAttributeProducer(
+    schema: JSONSchema,
+    _ref: Ref,
+    types: Set<JSONSchemaType>,
+): JSONSchemaAttributes | undefined {
+    if (!types.has("array")) return undefined;
+
+    const maybeMinMaxItems = producer(schema, "minItems", "maxItems");
+    if (maybeMinMaxItems === undefined) return undefined;
+    return {
+        forArray: minMaxItemsTypeAttributeKind.makeAttributes(maybeMinMaxItems),
+    };
+}
+
 export function minMaxValueForType(t: Type): MinMaxConstraint | undefined {
     return minMaxTypeAttributeKind.tryGetInAttributes(t.getAttributes());
 }
@@ -187,6 +209,10 @@ export function minMaxLengthForType(t: Type): MinMaxConstraint | undefined {
     return minMaxLengthTypeAttributeKind.tryGetInAttributes(t.getAttributes());
 }
 
+export function minMaxItemsForType(t: Type): MinMaxConstraint | undefined {
+    return minMaxItemsTypeAttributeKind.tryGetInAttributes(t.getAttributes());
+}
+
 export class PatternTypeAttributeKind extends TypeAttributeKind<string> {
     public constructor() {
         super("pattern");

packages/quicktype-core/src/input/JSONSchemaInput.ts

@@ -25,6 +25,7 @@ import URI from "urijs";
 import { accessorNamesAttributeProducer } from "../attributes/AccessorNames.js";
 import {
     minMaxAttributeProducer,
+    minMaxItemsAttributeProducer,
     minMaxLengthAttributeProducer,
     patternAttributeProducer,
 } from "../attributes/Constraints.js";
@@ -306,7 +307,7 @@ export class Ref {
     public get definitionName(): string | undefined {
         const pe = arrayGetFromEnd(this.path, 2);
         if (pe === undefined) return undefined;
-        if (keyOrIndex(pe) === "definitions")
+        if (keyOrIndex(pe) === "definitions" || keyOrIndex(pe) === "$defs")
             return keyOrIndex(defined(arrayLast(this.path)));
         return undefined;
     }
@@ -649,6 +650,7 @@ const schemaTypes = Object.getOwnPropertyNames(
 ) as JSONSchemaType[];
 
 export interface JSONSchemaAttributes {
+    forArray?: TypeAttributes;
     forCases?: TypeAttributes[];
     forNumber?: TypeAttributes;
     forObject?: TypeAttributes;
@@ -783,7 +785,7 @@ class Resolver {
             return [schema, result[1]];
         }
 
-        return schemaFetchError(base, virtualRef.address);
+        return schemaFetchError(base, virtualRef.toString());
     }
 
     public async resolveTopLevelRef(ref: Ref): Promise<[JSONSchema, Location]> {
@@ -1031,7 +1033,9 @@ async function addTypesInSchema(
             return typeBuilder.getPrimitiveType(kind, attributes);
         }
 
-        async function makeArrayType(): Promise<TypeRef> {
+        async function makeArrayType(
+            arrayAttributes: TypeAttributes,
+        ): Promise<TypeRef> {
             const singularAttributes = singularizeTypeNames(typeAttributes);
             const items = schema.items;
             // JSON Schema 2020-12 renamed the array (tuple) form of `items` to
@@ -1097,7 +1101,7 @@ async function addTypesInSchema(
             }
 
             typeBuilder.addAttributes(itemType, singularAttributes);
-            return typeBuilder.getArrayType(emptyTypeAttributes, itemType);
+            return typeBuilder.getArrayType(arrayAttributes, itemType);
         }
 
         async function makeObjectType(): Promise<TypeRef> {
@@ -1139,6 +1143,14 @@ async function addTypesInSchema(
                 additionalProperties = schema.patternProperties[".*"];
             }
 
+            // Handle unevaluatedProperties if additionalProperties is not defined
+            if (
+                additionalProperties === undefined &&
+                schema.unevaluatedProperties !== undefined
+            ) {
+                additionalProperties = schema.unevaluatedProperties;
+            }
+
             const objectAttributes = combineTypeAttributes(
                 "union",
                 inferredAttributes,
@@ -1314,7 +1326,10 @@ async function addTypesInSchema(
             }
 
             if (includeArray) {
-                unionTypes.push(await makeArrayType());
+                const arrayAttributes = combineProducedAttributes(
+                    ({ forArray }) => forArray,
+                );
+                unionTypes.push(await makeArrayType(arrayAttributes));
             }
 
             if (includeObject) {
@@ -1549,6 +1564,7 @@ export class JSONSchemaInput implements Input<JSONSchemaSourceData> {
             uriSchemaAttributesProducer,
             minMaxAttributeProducer,
             minMaxLengthAttributeProducer,
+            minMaxItemsAttributeProducer,
             patternAttributeProducer,
         ].concat(additionalAttributeProducers);
     }

packages/quicktype-core/src/input/io/NodeIO.ts

@@ -107,6 +107,11 @@ export async function readableFromFileOrURL(
             const response = await globalThis.fetch(fileOrURL, {
                 headers: parseHeaders(httpHeaders),
             });
+            if (!response.ok) {
+                throw new Error(
+                    `HTTP ${response.status} ${response.statusText}`,
+                );
+            }
 
             return readableFromResponseBody(defined(response.body));
         }