diff --git a/head/schema-cplusplus/test/inputs/schema/description-unification.schema/default/quicktype.hpp b/head/schema-cplusplus/test/inputs/schema/description-unification.schema/default/quicktype.hpp new file mode 100644 index 0000000..fa7c6d2 --- /dev/null +++ b/head/schema-cplusplus/test/inputs/schema/description-unification.schema/default/quicktype.hpp @@ -0,0 +1,126 @@ +// To parse this JSON data, first install +// +// json.hpp https://github.com/nlohmann/json +// +// Then include this file, and then do +// +// TopLevel data = nlohmann::json::parse(jsonString); + +#pragma once + +#include "json.hpp" + +#include +#include +#include + +namespace quicktype { + using nlohmann::json; + + #ifndef NLOHMANN_UNTYPED_quicktype_HELPER + #define NLOHMANN_UNTYPED_quicktype_HELPER + inline json get_untyped(const json & j, const char * property) { + if (j.find(property) != j.end()) { + return j.at(property).get(); + } + return json(); + } + + inline json get_untyped(const json & j, std::string property) { + return get_untyped(j, property.data()); + } + #endif + + class Allow { + public: + Allow() = default; + virtual ~Allow() = default; + + private: + std::map labels; + + public: + /** + * The labels to apply to the policy + */ + const std::map & get_labels() const { return labels; } + std::map & get_mutable_labels() { return labels; } + void set_labels(const std::map & value) { this->labels = value; } + }; + + class Metadata { + public: + Metadata() = default; + virtual ~Metadata() = default; + + private: + std::map annotations; + + public: + /** + * Additional annotations for the generated resource + */ + const std::map & get_annotations() const { return annotations; } + std::map & get_mutable_annotations() { return annotations; } + void set_annotations(const std::map & value) { this->annotations = value; } + }; + + class TopLevel { + public: + TopLevel() = default; + virtual ~TopLevel() = default; + + private: + Allow allow; + Metadata metadata; + + public: + const Allow & get_allow() const { return allow; } + Allow & get_mutable_allow() { return allow; } + void set_allow(const Allow & value) { this->allow = value; } + + const Metadata & get_metadata() const { return metadata; } + Metadata & get_mutable_metadata() { return metadata; } + void set_metadata(const Metadata & value) { this->metadata = value; } + }; +} + +namespace quicktype { + void from_json(const json & j, Allow & x); + void to_json(json & j, const Allow & x); + + void from_json(const json & j, Metadata & x); + void to_json(json & j, const Metadata & x); + + void from_json(const json & j, TopLevel & x); + void to_json(json & j, const TopLevel & x); + + inline void from_json(const json & j, Allow& x) { + x.set_labels(j.at("labels").get>()); + } + + inline void to_json(json & j, const Allow & x) { + j = json::object(); + j["labels"] = x.get_labels(); + } + + inline void from_json(const json & j, Metadata& x) { + x.set_annotations(j.at("annotations").get>()); + } + + inline void to_json(json & j, const Metadata & x) { + j = json::object(); + j["annotations"] = x.get_annotations(); + } + + inline void from_json(const json & j, TopLevel& x) { + x.set_allow(j.at("allow").get()); + x.set_metadata(j.at("metadata").get()); + } + + inline void to_json(json & j, const TopLevel & x) { + j = json::object(); + j["allow"] = x.get_allow(); + j["metadata"] = x.get_metadata(); + } +} diff --git a/head/schema-csharp/test/inputs/schema/description-unification.schema/default/QuickType.cs b/head/schema-csharp/test/inputs/schema/description-unification.schema/default/QuickType.cs new file mode 100644 index 0000000..dde5f18 --- /dev/null +++ b/head/schema-csharp/test/inputs/schema/description-unification.schema/default/QuickType.cs @@ -0,0 +1,82 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial class TopLevel + { + [JsonProperty("allow", Required = Required.Always)] + public Allow Allow { get; set; } + + [JsonProperty("metadata", Required = Required.Always)] + public Metadata Metadata { get; set; } + } + + public partial class Allow + { + /// + /// The labels to apply to the policy + /// + [JsonProperty("labels", Required = Required.Always)] + public Dictionary Labels { get; set; } + } + + public partial class Metadata + { + /// + /// Additional annotations for the generated resource + /// + [JsonProperty("annotations", Required = Required.Always)] + public Dictionary Annotations { get; set; } + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-csharp-SystemTextJson/test/inputs/schema/description-unification.schema/default/QuickType.cs b/head/schema-csharp-SystemTextJson/test/inputs/schema/description-unification.schema/default/QuickType.cs new file mode 100644 index 0000000..85919c0 --- /dev/null +++ b/head/schema-csharp-SystemTextJson/test/inputs/schema/description-unification.schema/default/QuickType.cs @@ -0,0 +1,190 @@ +// +// +// To parse this JSON data, add NuGet 'System.Text.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Text.Json; + using System.Text.Json.Serialization; + using System.Globalization; + + public partial class TopLevel + { + [JsonRequired] + [JsonPropertyName("allow")] + public Allow Allow { get; set; } + + [JsonRequired] + [JsonPropertyName("metadata")] + public Metadata Metadata { get; set; } + } + + public partial class Allow + { + /// + /// The labels to apply to the policy + /// + [JsonRequired] + [JsonPropertyName("labels")] + public Dictionary Labels { get; set; } + } + + public partial class Metadata + { + /// + /// Additional annotations for the generated resource + /// + [JsonRequired] + [JsonPropertyName("annotations")] + public Dictionary Annotations { get; set; } + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonSerializer.Deserialize(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonSerializer.Serialize(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General) + { + Converters = + { + new DateOnlyConverter(), + new TimeOnlyConverter(), + IsoDateTimeOffsetConverter.Singleton + }, + }; + } + + public class DateOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + public DateOnlyConverter() : this(null) { } + + public DateOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "yyyy-MM-dd"; + } + + public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return DateOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + public class TimeOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + + public TimeOnlyConverter() : this(null) { } + + public TimeOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff"; + } + + public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return TimeOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + internal class IsoDateTimeOffsetConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(DateTimeOffset); + + private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; + + private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind; + private string? _dateTimeFormat; + private CultureInfo? _culture; + + public DateTimeStyles DateTimeStyles + { + get => _dateTimeStyles; + set => _dateTimeStyles = value; + } + + public string? DateTimeFormat + { + get => _dateTimeFormat ?? string.Empty; + set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value; + } + + public CultureInfo Culture + { + get => _culture ?? CultureInfo.CurrentCulture; + set => _culture = value; + } + + public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options) + { + string text; + + + if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal + || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) + { + value = value.ToUniversalTime(); + } + + text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); + + writer.WriteStringValue(text); + } + + public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + string? dateText = reader.GetString(); + + if (string.IsNullOrEmpty(dateText) == false) + { + if (!string.IsNullOrEmpty(_dateTimeFormat)) + { + return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles); + } + else + { + return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles); + } + } + else + { + return default(DateTimeOffset); + } + } + + + public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 diff --git a/head/schema-csharp-records/test/inputs/schema/description-unification.schema/default/QuickType.cs b/head/schema-csharp-records/test/inputs/schema/description-unification.schema/default/QuickType.cs new file mode 100644 index 0000000..bd6ca32 --- /dev/null +++ b/head/schema-csharp-records/test/inputs/schema/description-unification.schema/default/QuickType.cs @@ -0,0 +1,82 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial record TopLevel + { + [JsonProperty("allow", Required = Required.Always)] + public Allow Allow { get; set; } + + [JsonProperty("metadata", Required = Required.Always)] + public Metadata Metadata { get; set; } + } + + public partial record Allow + { + /// + /// The labels to apply to the policy + /// + [JsonProperty("labels", Required = Required.Always)] + public Dictionary Labels { get; set; } + } + + public partial record Metadata + { + /// + /// Additional annotations for the generated resource + /// + [JsonProperty("annotations", Required = Required.Always)] + public Dictionary Annotations { get; set; } + } + + public partial record TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-dart/test/inputs/schema/description-unification.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/description-unification.schema/default/TopLevel.dart new file mode 100644 index 0000000..95f9304 --- /dev/null +++ b/head/schema-dart/test/inputs/schema/description-unification.schema/default/TopLevel.dart @@ -0,0 +1,65 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final Allow allow; + final Metadata metadata; + + TopLevel({ + required this.allow, + required this.metadata, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + allow: Allow.fromJson(json["allow"]), + metadata: Metadata.fromJson(json["metadata"]), + ); + + Map toJson() => { + "allow": allow.toJson(), + "metadata": metadata.toJson(), + }; +} + +class Allow { + + ///The labels to apply to the policy + final Map labels; + + Allow({ + required this.labels, + }); + + factory Allow.fromJson(Map json) => Allow( + labels: Map.from(json["labels"]).map((k, v) => MapEntry(k, v)), + ); + + Map toJson() => { + "labels": Map.from(labels).map((k, v) => MapEntry(k, v)), + }; +} + +class Metadata { + + ///Additional annotations for the generated resource + final Map annotations; + + Metadata({ + required this.annotations, + }); + + factory Metadata.fromJson(Map json) => Metadata( + annotations: Map.from(json["annotations"]).map((k, v) => MapEntry(k, v)), + ); + + Map toJson() => { + "annotations": Map.from(annotations).map((k, v) => MapEntry(k, v)), + }; +} diff --git a/head/schema-elm/test/inputs/schema/description-unification.schema/default/QuickType.elm b/head/schema-elm/test/inputs/schema/description-unification.schema/default/QuickType.elm new file mode 100644 index 0000000..dc958ee --- /dev/null +++ b/head/schema-elm/test/inputs/schema/description-unification.schema/default/QuickType.elm @@ -0,0 +1,92 @@ +-- To decode the JSON data, add this file to your project, run +-- +-- elm install NoRedInk/elm-json-decode-pipeline +-- +-- add these imports +-- +-- import Json.Decode exposing (decodeString) +-- import QuickType exposing (quickType) +-- +-- and you're off to the races with +-- +-- decodeString quickType myJsonString + +module QuickType exposing + ( QuickType + , quickTypeToString + , quickType + , Allow + , Metadata + ) + +import Json.Decode as Jdec +import Json.Decode.Pipeline as Jpipe +import Json.Encode as Jenc +import Dict exposing (Dict) + +type alias QuickType = + { allow : Allow + , metadata : Metadata + } + +{-| labels: +The labels to apply to the policy +-} +type alias Allow = + { labels : Dict String String + } + +{-| annotations: +Additional annotations for the generated resource +-} +type alias Metadata = + { annotations : Dict String String + } + +-- decoders and encoders + +quickTypeToString : QuickType -> String +quickTypeToString r = Jenc.encode 0 (encodeQuickType r) + +quickType : Jdec.Decoder QuickType +quickType = + Jdec.succeed QuickType + |> Jpipe.required "allow" allow + |> Jpipe.required "metadata" metadata + +encodeQuickType : QuickType -> Jenc.Value +encodeQuickType x = + Jenc.object + [ ("allow", encodeAllow x.allow) + , ("metadata", encodeMetadata x.metadata) + ] + +allow : Jdec.Decoder Allow +allow = + Jdec.succeed Allow + |> Jpipe.required "labels" (Jdec.dict Jdec.string) + +encodeAllow : Allow -> Jenc.Value +encodeAllow x = + Jenc.object + [ ("labels", Jenc.dict identity Jenc.string x.labels) + ] + +metadata : Jdec.Decoder Metadata +metadata = + Jdec.succeed Metadata + |> Jpipe.required "annotations" (Jdec.dict Jdec.string) + +encodeMetadata : Metadata -> Jenc.Value +encodeMetadata x = + Jenc.object + [ ("annotations", Jenc.dict identity Jenc.string x.annotations) + ] + +--- encoder helpers + +makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value +makeNullableEncoder f m = + case m of + Just x -> f x + Nothing -> Jenc.null diff --git a/head/schema-flow/test/inputs/schema/description-unification.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/description-unification.schema/default/TopLevel.js new file mode 100644 index 0000000..8fb04aa --- /dev/null +++ b/head/schema-flow/test/inputs/schema/description-unification.schema/default/TopLevel.js @@ -0,0 +1,213 @@ +// @flow + +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + allow: Allow; + metadata: Metadata; + [property: string]: mixed; +}; + +export type Allow = { + /** + * The labels to apply to the policy + */ + labels: { [key: string]: string }; + [property: string]: mixed; +}; + +export type Metadata = { + /** + * Additional annotations for the generated resource + */ + annotations: { [key: string]: string }; + [property: string]: mixed; +}; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ: any, val: any, key: any, parent: any = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "allow", js: "allow", typ: r("Allow") }, + { json: "metadata", js: "metadata", typ: r("Metadata") }, + ], "any"), + "Allow": o([ + { json: "labels", js: "labels", typ: m("") }, + ], "any"), + "Metadata": o([ + { json: "annotations", js: "annotations", typ: m("") }, + ], "any"), +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-golang/test/inputs/schema/description-unification.schema/default/quicktype.go b/head/schema-golang/test/inputs/schema/description-unification.schema/default/quicktype.go new file mode 100644 index 0000000..cb7a433 --- /dev/null +++ b/head/schema-golang/test/inputs/schema/description-unification.schema/default/quicktype.go @@ -0,0 +1,34 @@ +// Code generated from JSON Schema using quicktype. DO NOT EDIT. +// To parse and unparse this JSON data, add this code to your project and do: +// +// topLevel, err := UnmarshalTopLevel(bytes) +// bytes, err = topLevel.Marshal() + +package main + +import "encoding/json" + +func UnmarshalTopLevel(data []byte) (TopLevel, error) { + var r TopLevel + err := json.Unmarshal(data, &r) + return r, err +} + +func (r *TopLevel) Marshal() ([]byte, error) { + return json.Marshal(r) +} + +type TopLevel struct { + Allow Allow `json:"allow"` + Metadata Metadata `json:"metadata"` +} + +type Allow struct { + // The labels to apply to the policy + Labels map[string]string `json:"labels"` +} + +type Metadata struct { + // Additional annotations for the generated resource + Annotations map[string]string `json:"annotations"` +} diff --git a/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java new file mode 100644 index 0000000..aa9ea4a --- /dev/null +++ b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Allow { + private Map labels; + + /** + * The labels to apply to the policy + */ + @JsonProperty("labels") + public Map getLabels() { return labels; } + @JsonProperty("labels") + public void setLabels(Map value) { this.labels = value; } +} diff --git a/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..a8eb236 --- /dev/null +++ b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,101 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java new file mode 100644 index 0000000..d3eeb36 --- /dev/null +++ b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Metadata { + private Map annotations; + + /** + * Additional annotations for the generated resource + */ + @JsonProperty("annotations") + public Map getAnnotations() { return annotations; } + @JsonProperty("annotations") + public void setAnnotations(Map value) { this.annotations = value; } +} diff --git a/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..2d7c2a8 --- /dev/null +++ b/head/schema-java/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private Allow allow; + private Metadata metadata; + + @JsonProperty("allow") + public Allow getAllow() { return allow; } + @JsonProperty("allow") + public void setAllow(Allow value) { this.allow = value; } + + @JsonProperty("metadata") + public Metadata getMetadata() { return metadata; } + @JsonProperty("metadata") + public void setMetadata(Metadata value) { this.metadata = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java new file mode 100644 index 0000000..aa9ea4a --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Allow { + private Map labels; + + /** + * The labels to apply to the policy + */ + @JsonProperty("labels") + public Map getLabels() { return labels; } + @JsonProperty("labels") + public void setLabels(Map value) { this.labels = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..7d4811b --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,121 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.util.Date; +import java.text.SimpleDateFormat; + +public class Converter { + // Date-time helpers + + private static final String[] DATE_TIME_FORMATS = { + "yyyy-MM-dd'T'HH:mm:ss.SX", + "yyyy-MM-dd'T'HH:mm:ss.S", + "yyyy-MM-dd'T'HH:mm:ssX", + "yyyy-MM-dd'T'HH:mm:ss", + "yyyy-MM-dd HH:mm:ss.SX", + "yyyy-MM-dd HH:mm:ss.S", + "yyyy-MM-dd HH:mm:ssX", + "yyyy-MM-dd HH:mm:ss", + "HH:mm:ss.SZ", + "HH:mm:ss.S", + "HH:mm:ssZ", + "HH:mm:ss", + "yyyy-MM-dd", + }; + + public static Date parseAllDateTimeString(String str) { + for (String format : DATE_TIME_FORMATS) { + try { + return new SimpleDateFormat(format).parse(str); + } catch (Exception ex) { + // Ignored + } + } + return null; + } + + public static String serializeDateTime(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ").format(datetime); + } + + public static String serializeDate(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd").format(datetime); + } + + public static String serializeTime(Date datetime) { + return new SimpleDateFormat("hh:mm:ssZ").format(datetime); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java new file mode 100644 index 0000000..d3eeb36 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Metadata { + private Map annotations; + + /** + * Additional annotations for the generated resource + */ + @JsonProperty("annotations") + public Map getAnnotations() { return annotations; } + @JsonProperty("annotations") + public void setAnnotations(Map value) { this.annotations = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..2d7c2a8 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private Allow allow; + private Metadata metadata; + + @JsonProperty("allow") + public Allow getAllow() { return allow; } + @JsonProperty("allow") + public void setAllow(Allow value) { this.allow = value; } + + @JsonProperty("metadata") + public Metadata getMetadata() { return metadata; } + @JsonProperty("metadata") + public void setMetadata(Metadata value) { this.metadata = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java new file mode 100644 index 0000000..aa9ea4a --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Allow.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Allow { + private Map labels; + + /** + * The labels to apply to the policy + */ + @JsonProperty("labels") + public Map getLabels() { return labels; } + @JsonProperty("labels") + public void setLabels(Map value) { this.labels = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..a8eb236 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,101 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java new file mode 100644 index 0000000..d3eeb36 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/Metadata.java @@ -0,0 +1,16 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Map; + +public class Metadata { + private Map annotations; + + /** + * Additional annotations for the generated resource + */ + @JsonProperty("annotations") + public Map getAnnotations() { return annotations; } + @JsonProperty("annotations") + public void setAnnotations(Map value) { this.annotations = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..2d7c2a8 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/description-unification.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,18 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class TopLevel { + private Allow allow; + private Metadata metadata; + + @JsonProperty("allow") + public Allow getAllow() { return allow; } + @JsonProperty("allow") + public void setAllow(Allow value) { this.allow = value; } + + @JsonProperty("metadata") + public Metadata getMetadata() { return metadata; } + @JsonProperty("metadata") + public void setMetadata(Metadata value) { this.metadata = value; } +} diff --git a/head/schema-javascript/test/inputs/schema/description-unification.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/description-unification.schema/default/TopLevel.js new file mode 100644 index 0000000..e8c614e --- /dev/null +++ b/head/schema-javascript/test/inputs/schema/description-unification.schema/default/TopLevel.js @@ -0,0 +1,189 @@ +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json) { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value) { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ, val, key, parent = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ) { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ) { + if (typ.jsonToJS === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ) { + if (typ.jsToJSON === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val, typ, getProps, key = '', parent = '') { + function transformPrimitive(typ, val) { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs, val) { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases, val) { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ, val) { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val) { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props, additional, val) { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val, typ) { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val, typ) { + return transform(val, typ, jsToJSONProps); +} + +function l(typ) { + return { literal: typ }; +} + +function a(typ) { + return { arrayItems: typ }; +} + +function u(...typs) { + return { unionMembers: typs }; +} + +function o(props, additional) { + return { props, additional }; +} + +function m(additional) { + const props = []; + return { props, additional }; +} + +function r(name) { + return { ref: name }; +} + +const typeMap = { + "TopLevel": o([ + { json: "allow", js: "allow", typ: r("Allow") }, + { json: "metadata", js: "metadata", typ: r("Metadata") }, + ], "any"), + "Allow": o([ + { json: "labels", js: "labels", typ: m("") }, + ], "any"), + "Metadata": o([ + { json: "annotations", js: "annotations", typ: m("") }, + ], "any"), +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-kotlin/test/inputs/schema/description-unification.schema/default/TopLevel.kt b/head/schema-kotlin/test/inputs/schema/description-unification.schema/default/TopLevel.kt new file mode 100644 index 0000000..2b498b3 --- /dev/null +++ b/head/schema-kotlin/test/inputs/schema/description-unification.schema/default/TopLevel.kt @@ -0,0 +1,34 @@ +// To parse the JSON, install Klaxon and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import com.beust.klaxon.* + +private val klaxon = Klaxon() + +data class TopLevel ( + val allow: Allow, + val metadata: Metadata +) { + public fun toJson() = klaxon.toJsonString(this) + + companion object { + public fun fromJson(json: String) = klaxon.parse(json) + } +} + +data class Allow ( + /** + * The labels to apply to the policy + */ + val labels: Map +) + +data class Metadata ( + /** + * Additional annotations for the generated resource + */ + val annotations: Map +) diff --git a/head/schema-kotlin-jackson/test/inputs/schema/description-unification.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/description-unification.schema/default/TopLevel.kt new file mode 100644 index 0000000..3eacaf1 --- /dev/null +++ b/head/schema-kotlin-jackson/test/inputs/schema/description-unification.schema/default/TopLevel.kt @@ -0,0 +1,49 @@ +// To parse the JSON, install jackson-module-kotlin and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import com.fasterxml.jackson.annotation.* +import com.fasterxml.jackson.core.* +import com.fasterxml.jackson.databind.* +import com.fasterxml.jackson.databind.deser.std.StdDeserializer +import com.fasterxml.jackson.databind.module.SimpleModule +import com.fasterxml.jackson.databind.node.* +import com.fasterxml.jackson.databind.ser.std.StdSerializer +import com.fasterxml.jackson.module.kotlin.* + +val mapper = jacksonObjectMapper().apply { + propertyNamingStrategy = PropertyNamingStrategy.LOWER_CAMEL_CASE + setSerializationInclusion(JsonInclude.Include.NON_NULL) +} + +data class TopLevel ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val allow: Allow, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val metadata: Metadata +) { + fun toJson() = mapper.writeValueAsString(this) + + companion object { + fun fromJson(json: String) = mapper.readValue(json) + } +} + +data class Allow ( + /** + * The labels to apply to the policy + */ + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val labels: Map +) + +data class Metadata ( + /** + * Additional annotations for the generated resource + */ + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val annotations: Map +) diff --git a/head/schema-kotlinx/test/inputs/schema/description-unification.schema/default/TopLevel.kt b/head/schema-kotlinx/test/inputs/schema/description-unification.schema/default/TopLevel.kt new file mode 100644 index 0000000..474aadb --- /dev/null +++ b/head/schema-kotlinx/test/inputs/schema/description-unification.schema/default/TopLevel.kt @@ -0,0 +1,33 @@ +// To parse the JSON, install kotlin's serialization plugin and do: +// +// val json = Json { allowStructuredMapKeys = true } +// val topLevel = json.parse(TopLevel.serializer(), jsonString) + +package quicktype + +import kotlinx.serialization.* +import kotlinx.serialization.json.* +import kotlinx.serialization.descriptors.* +import kotlinx.serialization.encoding.* + +@Serializable +data class TopLevel ( + val allow: Allow, + val metadata: Metadata +) + +@Serializable +data class Allow ( + /** + * The labels to apply to the policy + */ + val labels: Map +) + +@Serializable +data class Metadata ( + /** + * Additional annotations for the generated resource + */ + val annotations: Map +) diff --git a/head/schema-php/test/inputs/schema/description-unification.schema/default/TopLevel.php b/head/schema-php/test/inputs/schema/description-unification.schema/default/TopLevel.php new file mode 100644 index 0000000..2237b9c --- /dev/null +++ b/head/schema-php/test/inputs/schema/description-unification.schema/default/TopLevel.php @@ -0,0 +1,406 @@ +allow = $allow; + $this->metadata = $metadata; + } + + /** + * @param stdClass $value + * @throws Exception + * @return Allow + */ + public static function fromAllow(stdClass $value): Allow { + return Allow::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toAllow(): stdClass { + if (TopLevel::validateAllow($this->allow)) { + return $this->allow->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::allow'); + } + + /** + * @param Allow + * @return bool + * @throws Exception + */ + public static function validateAllow(Allow $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return Allow + */ + public function getAllow(): Allow { + if (TopLevel::validateAllow($this->allow)) { + return $this->allow; + } + throw new Exception('never get to getAllow TopLevel::allow'); + } + + /** + * @return Allow + */ + public static function sampleAllow(): Allow { + return Allow::sample(); /*31:allow*/ + } + + /** + * @param stdClass $value + * @throws Exception + * @return Metadata + */ + public static function fromMetadata(stdClass $value): Metadata { + return Metadata::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toMetadata(): stdClass { + if (TopLevel::validateMetadata($this->metadata)) { + return $this->metadata->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::metadata'); + } + + /** + * @param Metadata + * @return bool + * @throws Exception + */ + public static function validateMetadata(Metadata $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return Metadata + */ + public function getMetadata(): Metadata { + if (TopLevel::validateMetadata($this->metadata)) { + return $this->metadata; + } + throw new Exception('never get to getMetadata TopLevel::metadata'); + } + + /** + * @return Metadata + */ + public static function sampleMetadata(): Metadata { + return Metadata::sample(); /*32:metadata*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return TopLevel::validateAllow($this->allow) + || TopLevel::validateMetadata($this->metadata); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'allow'} = $this->toAllow(); + $out->{'metadata'} = $this->toMetadata(); + return $out; + } + + /** + * @param stdClass $obj + * @return TopLevel + * @throws Exception + */ + public static function from(stdClass $obj): TopLevel { + return new TopLevel( + TopLevel::fromAllow($obj->{'allow'}) + ,TopLevel::fromMetadata($obj->{'metadata'}) + ); + } + + /** + * @return TopLevel + */ + public static function sample(): TopLevel { + return new TopLevel( + TopLevel::sampleAllow() + ,TopLevel::sampleMetadata() + ); + } +} + +// This is an autogenerated file:Allow + +class Allow { + private stdClass $labels; // json:labels Required + + /** + * @param stdClass $labels + */ + public function __construct(stdClass $labels) { + $this->labels = $labels; + } + + /** + * The labels to apply to the policy + * + * @param stdClass $value + * @throws Exception + * @return stdClass + */ + public static function fromLabels(stdClass $value): stdClass { + $out = new stdClass(); + foreach ($value as $k => $v) { + $out->$k = $v; /*string*/ + } + return $out; + } + + /** + * The labels to apply to the policy + * + * @throws Exception + * @return stdClass + */ + public function toLabels(): stdClass { + if (Allow::validateLabels($this->labels)) { + $out = new stdClass(); + foreach ($this->labels as $k => $v) { + $out->$k = $v; /*string*/ + } + return $out; + } + throw new Exception('never get to this Allow::labels'); + } + + /** + * The labels to apply to the policy + * + * @param stdClass + * @return bool + * @throws Exception + */ + public static function validateLabels(stdClass $value): bool { + foreach ($value as $k => $v) { + if (!is_string($v)) { + throw new Exception("Attribute Error:Allow::labels"); + } + } + return true; + } + + /** + * The labels to apply to the policy + * + * @throws Exception + * @return stdClass + */ + public function getLabels(): stdClass { + if (Allow::validateLabels($this->labels)) { + return $this->labels; + } + throw new Exception('never get to getLabels Allow::labels'); + } + + /** + * The labels to apply to the policy + * + * @return stdClass + */ + public static function sampleLabels(): stdClass { + return (function () { + $out = new stdClass(); + $out->{'Allow'} = 'Allow::labels::31'; /*31:labels*/ + return $out; + })(); /* 31:labels*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return Allow::validateLabels($this->labels); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'labels'} = $this->toLabels(); + return $out; + } + + /** + * @param stdClass $obj + * @return Allow + * @throws Exception + */ + public static function from(stdClass $obj): Allow { + return new Allow( + Allow::fromLabels($obj->{'labels'}) + ); + } + + /** + * @return Allow + */ + public static function sample(): Allow { + return new Allow( + Allow::sampleLabels() + ); + } +} + +// This is an autogenerated file:Metadata + +class Metadata { + private stdClass $annotations; // json:annotations Required + + /** + * @param stdClass $annotations + */ + public function __construct(stdClass $annotations) { + $this->annotations = $annotations; + } + + /** + * Additional annotations for the generated resource + * + * @param stdClass $value + * @throws Exception + * @return stdClass + */ + public static function fromAnnotations(stdClass $value): stdClass { + $out = new stdClass(); + foreach ($value as $k => $v) { + $out->$k = $v; /*string*/ + } + return $out; + } + + /** + * Additional annotations for the generated resource + * + * @throws Exception + * @return stdClass + */ + public function toAnnotations(): stdClass { + if (Metadata::validateAnnotations($this->annotations)) { + $out = new stdClass(); + foreach ($this->annotations as $k => $v) { + $out->$k = $v; /*string*/ + } + return $out; + } + throw new Exception('never get to this Metadata::annotations'); + } + + /** + * Additional annotations for the generated resource + * + * @param stdClass + * @return bool + * @throws Exception + */ + public static function validateAnnotations(stdClass $value): bool { + foreach ($value as $k => $v) { + if (!is_string($v)) { + throw new Exception("Attribute Error:Metadata::annotations"); + } + } + return true; + } + + /** + * Additional annotations for the generated resource + * + * @throws Exception + * @return stdClass + */ + public function getAnnotations(): stdClass { + if (Metadata::validateAnnotations($this->annotations)) { + return $this->annotations; + } + throw new Exception('never get to getAnnotations Metadata::annotations'); + } + + /** + * Additional annotations for the generated resource + * + * @return stdClass + */ + public static function sampleAnnotations(): stdClass { + return (function () { + $out = new stdClass(); + $out->{'Metadata'} = 'Metadata::annotations::31'; /*31:annotations*/ + return $out; + })(); /* 31:annotations*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return Metadata::validateAnnotations($this->annotations); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'annotations'} = $this->toAnnotations(); + return $out; + } + + /** + * @param stdClass $obj + * @return Metadata + * @throws Exception + */ + public static function from(stdClass $obj): Metadata { + return new Metadata( + Metadata::fromAnnotations($obj->{'annotations'}) + ); + } + + /** + * @return Metadata + */ + public static function sample(): Metadata { + return new Metadata( + Metadata::sampleAnnotations() + ); + } +} diff --git a/head/schema-pike/test/inputs/schema/description-unification.schema/default/TopLevel.pmod b/head/schema-pike/test/inputs/schema/description-unification.schema/default/TopLevel.pmod new file mode 100644 index 0000000..cb747b4 --- /dev/null +++ b/head/schema-pike/test/inputs/schema/description-unification.schema/default/TopLevel.pmod @@ -0,0 +1,76 @@ +// This source has been automatically generated by quicktype. +// ( https://github.com/quicktype/quicktype ) +// +// To use this code, simply import it into your project as a Pike module. +// To JSON-encode your object, you can pass it to `Standards.JSON.encode` +// or call `encode_json` on it. +// +// To decode a JSON string, first pass it to `Standards.JSON.decode`, +// and then pass the result to `_from_JSON`. +// It will return an instance of . +// Bear in mind that these functions have unexpected behavior, +// and will likely throw an error, if the JSON string does not +// match the expected interface, even if the JSON itself is valid. + +class TopLevel { + Allow allow; // json: "allow" + Metadata metadata; // json: "metadata" + + string encode_json() { + mapping(string:mixed) json = ([ + "allow" : allow, + "metadata" : metadata, + ]); + + return Standards.JSON.encode(json); + } +} + +TopLevel TopLevel_from_JSON(mixed json) { + TopLevel retval = TopLevel(); + + retval.allow = json["allow"]; + retval.metadata = json["metadata"]; + + return retval; +} + +class Allow { + mapping(string:string) labels; // json: "labels" + + string encode_json() { + mapping(string:mixed) json = ([ + "labels" : labels, + ]); + + return Standards.JSON.encode(json); + } +} + +Allow Allow_from_JSON(mixed json) { + Allow retval = Allow(); + + retval.labels = json["labels"]; + + return retval; +} + +class Metadata { + mapping(string:string) annotations; // json: "annotations" + + string encode_json() { + mapping(string:mixed) json = ([ + "annotations" : annotations, + ]); + + return Standards.JSON.encode(json); + } +} + +Metadata Metadata_from_JSON(mixed json) { + Metadata retval = Metadata(); + + retval.annotations = json["annotations"]; + + return retval; +} diff --git a/head/schema-python/test/inputs/schema/description-unification.schema/default/quicktype.py b/head/schema-python/test/inputs/schema/description-unification.schema/default/quicktype.py new file mode 100644 index 0000000..c5344f8 --- /dev/null +++ b/head/schema-python/test/inputs/schema/description-unification.schema/default/quicktype.py @@ -0,0 +1,81 @@ +from dataclasses import dataclass +from typing import Any, TypeVar, Callable, Type, cast + + +T = TypeVar("T") + + +def from_dict(f: Callable[[Any], T], x: Any) -> dict[str, T]: + assert isinstance(x, dict) + return { k: f(v) for (k, v) in x.items() } + + +def from_str(x: Any) -> str: + assert isinstance(x, str) + return x + + +def to_class(c: Type[T], x: Any) -> dict: + assert isinstance(x, c) + return cast(Any, x).to_dict() + + +@dataclass +class Allow: + labels: dict[str, str] + """The labels to apply to the policy""" + + @staticmethod + def from_dict(obj: Any) -> 'Allow': + assert isinstance(obj, dict) + labels = from_dict(from_str, obj.get("labels")) + return Allow(labels) + + def to_dict(self) -> dict: + result: dict = {} + result["labels"] = from_dict(from_str, self.labels) + return result + + +@dataclass +class Metadata: + annotations: dict[str, str] + """Additional annotations for the generated resource""" + + @staticmethod + def from_dict(obj: Any) -> 'Metadata': + assert isinstance(obj, dict) + annotations = from_dict(from_str, obj.get("annotations")) + return Metadata(annotations) + + def to_dict(self) -> dict: + result: dict = {} + result["annotations"] = from_dict(from_str, self.annotations) + return result + + +@dataclass +class TopLevel: + allow: Allow + metadata: Metadata + + @staticmethod + def from_dict(obj: Any) -> 'TopLevel': + assert isinstance(obj, dict) + allow = Allow.from_dict(obj.get("allow")) + metadata = Metadata.from_dict(obj.get("metadata")) + return TopLevel(allow, metadata) + + def to_dict(self) -> dict: + result: dict = {} + result["allow"] = to_class(Allow, self.allow) + result["metadata"] = to_class(Metadata, self.metadata) + return result + + +def top_level_from_dict(s: Any) -> TopLevel: + return TopLevel.from_dict(s) + + +def top_level_to_dict(x: TopLevel) -> Any: + return to_class(TopLevel, x) diff --git a/head/schema-ruby/test/inputs/schema/description-unification.schema/default/TopLevel.rb b/head/schema-ruby/test/inputs/schema/description-unification.schema/default/TopLevel.rb new file mode 100644 index 0000000..9c8503f --- /dev/null +++ b/head/schema-ruby/test/inputs/schema/description-unification.schema/default/TopLevel.rb @@ -0,0 +1,102 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.metadata.annotations["…"] +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Hash = Strict::Hash + String = Strict::String +end + +class Allow < Dry::Struct + + # The labels to apply to the policy + attribute :labels, Types::Hash.meta(of: Types::String) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + labels: Types::Hash[d.fetch("labels")].map { |k, v| [k, Types::String[v]] }.to_h, + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "labels" => labels, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Metadata < Dry::Struct + + # Additional annotations for the generated resource + attribute :annotations, Types::Hash.meta(of: Types::String) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + annotations: Types::Hash[d.fetch("annotations")].map { |k, v| [k, Types::String[v]] }.to_h, + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "annotations" => annotations, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TopLevel < Dry::Struct + attribute :allow, Allow + attribute :metadata, Metadata + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + allow: Allow.from_dynamic!(d.fetch("allow")), + metadata: Metadata.from_dynamic!(d.fetch("metadata")), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "allow" => allow.to_dynamic, + "metadata" => metadata.to_dynamic, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/head/schema-rust/test/inputs/schema/description-unification.schema/default/module_under_test.rs b/head/schema-rust/test/inputs/schema/description-unification.schema/default/module_under_test.rs new file mode 100644 index 0000000..239340f --- /dev/null +++ b/head/schema-rust/test/inputs/schema/description-unification.schema/default/module_under_test.rs @@ -0,0 +1,34 @@ +// Example code that deserializes and serializes the model. +// extern crate serde; +// #[macro_use] +// extern crate serde_derive; +// extern crate serde_json; +// +// use generated_module::TopLevel; +// +// fn main() { +// let json = r#"{"answer": 42}"#; +// let model: TopLevel = serde_json::from_str(&json).unwrap(); +// } + +use serde::{Serialize, Deserialize}; +use std::collections::HashMap; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct TopLevel { + pub allow: Allow, + + pub metadata: Metadata, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Allow { + /// The labels to apply to the policy + pub labels: HashMap, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Metadata { + /// Additional annotations for the generated resource + pub annotations: HashMap, +} diff --git a/head/schema-scala3/test/inputs/schema/description-unification.schema/default/TopLevel.scala b/head/schema-scala3/test/inputs/schema/description-unification.schema/default/TopLevel.scala new file mode 100644 index 0000000..f1885d0 --- /dev/null +++ b/head/schema-scala3/test/inputs/schema/description-unification.schema/default/TopLevel.scala @@ -0,0 +1,27 @@ +package quicktype + +import io.circe.syntax._ +import io.circe._ +import cats.syntax.functor._ + +// If a union has a null in, then we'll need this too... +type NullValue = None.type + +case class TopLevel ( + val allow : Allow, + val metadata : Metadata +) derives Encoder.AsObject, Decoder + +case class Allow ( + /** + * The labels to apply to the policy + */ + val labels : Map[String, String] +) derives Encoder.AsObject, Decoder + +case class Metadata ( + /** + * Additional annotations for the generated resource + */ + val annotations : Map[String, String] +) derives Encoder.AsObject, Decoder diff --git a/head/schema-scala3-upickle/test/inputs/schema/description-unification.schema/default/TopLevel.scala b/head/schema-scala3-upickle/test/inputs/schema/description-unification.schema/default/TopLevel.scala new file mode 100644 index 0000000..cb5b6be --- /dev/null +++ b/head/schema-scala3-upickle/test/inputs/schema/description-unification.schema/default/TopLevel.scala @@ -0,0 +1,85 @@ +package quicktype + +// Custom pickler so that missing keys and JSON nulls both read as None, +// and None is left out when writing (upickle's default for Option is a +// JSON array). +object OptionPickler extends upickle.AttributeTagged: + import upickle.default.Writer + import upickle.default.Reader + override implicit def OptionWriter[T: Writer]: Writer[Option[T]] = + implicitly[Writer[T]].comap[Option[T]] { + case None => null.asInstanceOf[T] + case Some(x) => x + } + + override implicit def OptionReader[T: Reader]: Reader[Option[T]] = { + new Reader.Delegate[Any, Option[T]](implicitly[Reader[T]].map(Some(_))){ + override def visitNull(index: Int) = None + } + } +end OptionPickler + +// If a union has a null in, then we'll need this too... +type NullValue = None.type +given OptionPickler.ReadWriter[NullValue] = OptionPickler.readwriter[ujson.Value].bimap[NullValue]( + _ => ujson.Null, + json => if json.isNull then None else throw new upickle.core.Abort("not null") +) + +object JsonExt: + val valueReader = OptionPickler.readwriter[ujson.Value] + + // upickle's built-in primitive readers are lenient -- the numeric and + // boolean readers accept strings, and the string reader accepts + // numbers and booleans -- so untagged unions need strict readers to + // pick the right member. + val strictString: OptionPickler.Reader[String] = valueReader.map { + case ujson.Str(s) => s + case json => throw new upickle.core.Abort("expected string, got " + json) + } + val strictLong: OptionPickler.Reader[Long] = valueReader.map { + case ujson.Num(n) if n.isWhole => n.toLong + case json => throw new upickle.core.Abort("expected integer, got " + json) + } + val strictDouble: OptionPickler.Reader[Double] = valueReader.map { + case ujson.Num(n) => n + case json => throw new upickle.core.Abort("expected number, got " + json) + } + val strictBoolean: OptionPickler.Reader[Boolean] = valueReader.map { + case ujson.Bool(b) => b + case json => throw new upickle.core.Abort("expected boolean, got " + json) + } + + def badMerge[T](r1: => OptionPickler.Reader[?], rest: OptionPickler.Reader[?]*): OptionPickler.Reader[T] = valueReader.map { json => + var t: T | Null = null + val stack = Vector.newBuilder[Throwable] + (r1 +: rest).foreach { reader => + if t == null then + try + t = OptionPickler.read[T](json, trace = true)(using reader.asInstanceOf[OptionPickler.Reader[T]]) + catch + case exc => stack += exc + } + if t != null then t.nn else throw new Exception(json.toString(), stack.result().headOption.getOrElse(null)) + } +end JsonExt + + +case class TopLevel ( + val allow : Allow, + val metadata : Metadata +) derives OptionPickler.ReadWriter + +case class Allow ( + /** + * The labels to apply to the policy + */ + val labels : Map[String, String] +) derives OptionPickler.ReadWriter + +case class Metadata ( + /** + * Additional annotations for the generated resource + */ + val annotations : Map[String, String] +) derives OptionPickler.ReadWriter diff --git a/head/schema-schema/test/inputs/schema/description-unification.schema/default/TopLevel.schema b/head/schema-schema/test/inputs/schema/description-unification.schema/default/TopLevel.schema new file mode 100644 index 0000000..e6b31f6 --- /dev/null +++ b/head/schema-schema/test/inputs/schema/description-unification.schema/default/TopLevel.schema @@ -0,0 +1,57 @@ +{ + "$schema": "http://json-schema.org/draft-06/schema#", + "$ref": "#/definitions/TopLevel", + "definitions": { + "TopLevel": { + "type": "object", + "additionalProperties": {}, + "properties": { + "allow": { + "$ref": "#/definitions/Allow" + }, + "metadata": { + "$ref": "#/definitions/Metadata" + } + }, + "required": [ + "allow", + "metadata" + ], + "title": "TopLevel" + }, + "Allow": { + "type": "object", + "additionalProperties": {}, + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "The labels to apply to the policy" + } + }, + "required": [ + "labels" + ], + "title": "Allow" + }, + "Metadata": { + "type": "object", + "additionalProperties": {}, + "properties": { + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional annotations for the generated resource" + } + }, + "required": [ + "annotations" + ], + "title": "Metadata" + } + } +} diff --git a/base/schema-schema/test/inputs/schema/vega-lite.schema/default/TopLevel.schema b/head/schema-schema/test/inputs/schema/vega-lite.schema/default/TopLevel.schema index acaeea5..4ea8de9 100644 --- a/base/schema-schema/test/inputs/schema/vega-lite.schema/default/TopLevel.schema +++ b/head/schema-schema/test/inputs/schema/vega-lite.schema/default/TopLevel.schema @@ -270,7 +270,7 @@ "additionalProperties": { "$ref": "#/definitions/VGMarkConfig" }, - "description": "An object hash that defines key-value mappings to determine default properties for marks with a given [style](mark.html#mark-def). The keys represent styles names; the value are valid [mark configuration objects](mark.html#config). " + "description": "An object hash that defines key-value mappings to determine default properties for marks\nwith a given [style](mark.html#mark-def). The keys represent styles names; the value are\nvalid [mark configuration objects](mark.html#config)." }, "text": { "$ref": "#/definitions/TextConfig", @@ -2871,7 +2871,7 @@ "type": "null" } ], - "description": "The sort order. One of `\"ascending\"` (default) or `\"descending\"`.\nSort order for a facet field.\nThis can be `\"ascending\"`, `\"descending\"`." + "description": "The sort order. One of `\"ascending\"` (default) or `\"descending\"`." } }, "required": [ @@ -2908,7 +2908,7 @@ "type": "null" } ], - "description": "The sort order. One of `\"ascending\"` (default) or `\"descending\"`.\nSort order for a facet field.\nThis can be `\"ascending\"`, `\"descending\"`." + "description": "Sort order for a facet field.\nThis can be `\"ascending\"`, `\"descending\"`." }, "timeUnit": { "$ref": "#/definitions/TimeUnit", @@ -3087,7 +3087,7 @@ "type": "null" } ], - "description": "The sort order. One of `\"ascending\"` (default) or `\"descending\"`.\nSort order for a facet field.\nThis can be `\"ascending\"`, `\"descending\"`." + "description": "The sort order. One of `\"ascending\"` (default) or `\"descending\"`." }, "timeUnit": { "$ref": "#/definitions/TimeUnit", @@ -3231,7 +3231,7 @@ "type": "null" } ], - "description": "Type of stacking offset if the field should be stacked.\n`stack` is only applicable for `x` and `y` channels with continuous domains.\nFor example, `stack` of `y` can be used to customize stacking for a vertical bar chart.\n\n`stack` can be one of the following values:\n\n- `\"zero\"`: stacking with baseline offset at zero value of the scale (for creating typical stacked [bar](stack.html#bar) and [area](stack.html#area) chart).\n- `\"normalize\"` - stacking with normalized domain (for creating [normalized stacked bar and area charts](stack.html#normalized).
\n- `\"center\"` - stacking with center baseline (for [streamgraph](stack.html#streamgraph)).\n- `null` - No-stacking. This will produce layered [bar](stack.html#layered-bar-chart) and area chart.\n\n__Default value:__ `zero` for plots with all of the following conditions are true:\n\n1. The mark is `bar` or `area`;\n2. The stacked measure channel (x or y) has a linear scale;\n3. At least one of non-position channels mapped to an unaggregated field that is different from x and y. Otherwise, `null` by default." + "description": "Type of stacking offset if the field should be stacked.\n`stack` is only applicable for `x` and `y` channels with continuous domains.\nFor example, `stack` of `y` can be used to customize stacking for a vertical bar chart.\n\n`stack` can be one of the following values:\n\n- `\"zero\"`: stacking with baseline offset at zero value of the scale (for creating\ntypical stacked [bar](stack.html#bar) and [area](stack.html#area) chart).\n- `\"normalize\"` - stacking with normalized domain (for creating [normalized stacked bar\nand area charts](stack.html#normalized).
\n- `\"center\"` - stacking with center baseline (for [streamgraph](stack.html#streamgraph)).\n- `null` - No-stacking. This will produce layered [bar](stack.html#layered-bar-chart) and\narea chart.\n\n__Default value:__ `zero` for plots with all of the following conditions are true:\n\n1. The mark is `bar` or `area`;\n2. The stacked measure channel (x or y) has a linear scale;\n3. At least one of non-position channels mapped to an unaggregated field that is\ndifferent from x and y. Otherwise, `null` by default." }, "timeUnit": { "$ref": "#/definitions/TimeUnit", diff --git a/head/schema-swift/test/inputs/schema/description-unification.schema/default/quicktype.swift b/head/schema-swift/test/inputs/schema/description-unification.schema/default/quicktype.swift new file mode 100644 index 0000000..f8862de --- /dev/null +++ b/head/schema-swift/test/inputs/schema/description-unification.schema/default/quicktype.swift @@ -0,0 +1,180 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let allow: Allow + let metadata: Metadata + + enum CodingKeys: String, CodingKey { + case allow = "allow" + case metadata = "metadata" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + allow: Allow? = nil, + metadata: Metadata? = nil + ) -> TopLevel { + return TopLevel( + allow: allow ?? self.allow, + metadata: metadata ?? self.metadata + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Allow +struct Allow: Codable { + /// The labels to apply to the policy + let labels: [String: String] + + enum CodingKeys: String, CodingKey { + case labels = "labels" + } +} + +// MARK: Allow convenience initializers and mutators + +extension Allow { + init(data: Data) throws { + self = try newJSONDecoder().decode(Allow.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + labels: [String: String]? = nil + ) -> Allow { + return Allow( + labels: labels ?? self.labels + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Metadata +struct Metadata: Codable { + /// Additional annotations for the generated resource + let annotations: [String: String] + + enum CodingKeys: String, CodingKey { + case annotations = "annotations" + } +} + +// MARK: Metadata convenience initializers and mutators + +extension Metadata { + init(data: Data) throws { + self = try newJSONDecoder().decode(Metadata.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + annotations: [String: String]? = nil + ) -> Metadata { + return Metadata( + annotations: annotations ?? self.annotations + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} diff --git a/head/schema-typescript/test/inputs/schema/description-unification.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/description-unification.schema/default/TopLevel.ts new file mode 100644 index 0000000..589018f --- /dev/null +++ b/head/schema-typescript/test/inputs/schema/description-unification.schema/default/TopLevel.ts @@ -0,0 +1,208 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + allow: Allow; + metadata: Metadata; + [property: string]: unknown; +} + +export interface Allow { + /** + * The labels to apply to the policy + */ + labels: { [key: string]: string }; + [property: string]: unknown; +} + +export interface Metadata { + /** + * Additional annotations for the generated resource + */ + annotations: { [key: string]: string }; + [property: string]: unknown; +} + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "allow", js: "allow", typ: r("Allow") }, + { json: "metadata", js: "metadata", typ: r("Metadata") }, + ], "any"), + "Allow": o([ + { json: "labels", js: "labels", typ: m("") }, + ], "any"), + "Metadata": o([ + { json: "annotations", js: "annotations", typ: m("") }, + ], "any"), +}; diff --git a/head/schema-typescript-zod/test/inputs/schema/description-unification.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/description-unification.schema/default/TopLevel.ts new file mode 100644 index 0000000..5353520 --- /dev/null +++ b/head/schema-typescript-zod/test/inputs/schema/description-unification.schema/default/TopLevel.ts @@ -0,0 +1,18 @@ +import * as z from "zod"; + + +export const AllowSchema = z.object({ + "labels": z.record(z.string(), z.string()), +}); +export type Allow = z.infer; + +export const MetadataSchema = z.object({ + "annotations": z.record(z.string(), z.string()), +}); +export type Metadata = z.infer; + +export const TopLevelSchema = z.object({ + "allow": AllowSchema, + "metadata": MetadataSchema, +}); +export type TopLevel = z.infer;