slicetest 0.5.0 → 0.6.0

package/dist/x509.js

@@ -0,0 +1,150 @@
+/**
+ * Just enough X.509 to impersonate hosts in tests: a throwaway certificate
+ * authority, leaf certificates for the intercepted hosts, and the CA in the
+ * formats apps read it from (PEM bundle, and a PKCS#12 trust store for Java).
+ * DER is written by hand so the package needs no crypto dependency.
+ */
+import { createHash, createPublicKey, generateKeyPairSync, randomBytes, sign, X509Certificate } from "node:crypto";
+// --- DER ---
+function len(n) {
+    if (n < 0x80)
+        return Buffer.from([n]);
+    const bytes = [];
+    for (let v = n; v > 0; v >>= 8)
+        bytes.unshift(v & 0xff);
+    return Buffer.from([0x80 | bytes.length, ...bytes]);
+}
+const tlv = (tag, ...content) => {
+    const body = Buffer.concat(content);
+    return Buffer.concat([Buffer.from([tag]), len(body.length), body]);
+};
+export const seq = (...items) => tlv(0x30, ...items);
+const set = (...items) => tlv(0x31, ...items);
+const octets = (b) => tlv(0x04, b);
+const bits = (b) => tlv(0x03, Buffer.from([0]), b);
+const utf8 = (s) => tlv(0x0c, Buffer.from(s, "utf8"));
+const bmp = (s) => tlv(0x1e, Buffer.from(s, "utf16le").swap16());
+const bool = (v) => tlv(0x01, Buffer.from([v ? 0xff : 0]));
+const explicit = (n, ...content) => tlv(0xa0 + n, ...content);
+const int = (b) => {
+    let i = 0;
+    while (i < b.length - 1 && b[i] === 0)
+        i++;
+    const v = b.subarray(i);
+    return tlv(0x02, v[0] & 0x80 ? Buffer.concat([Buffer.from([0]), v]) : v);
+};
+const oid = (dotted) => {
+    const [a, b, ...rest] = dotted.split(".").map(Number);
+    const out = [a * 40 + b];
+    for (const n of rest) {
+        const chunk = [];
+        let v = n;
+        do {
+            chunk.unshift(v & 0x7f);
+            v = Math.floor(v / 128);
+        } while (v > 0);
+        for (let i = 0; i < chunk.length - 1; i++)
+            chunk[i] |= 0x80;
+        out.push(...chunk);
+    }
+    return tlv(0x06, Buffer.from(out));
+};
+const time = (d) => {
+    // UTCTime up to 2049, GeneralizedTime after, as RFC 5280 requires.
+    const iso = d.toISOString().replace(/[-:T]/g, "").slice(0, 14);
+    return d.getUTCFullYear() < 2050 ? tlv(0x17, Buffer.from(`${iso.slice(2)}Z`)) : tlv(0x18, Buffer.from(`${iso}Z`));
+};
+const OID = {
+    ecdsaSha256: "1.2.840.10045.4.3.2",
+    commonName: "2.5.4.3",
+    organization: "2.5.4.10",
+    basicConstraints: "2.5.29.19",
+    keyUsage: "2.5.29.15",
+    extKeyUsage: "2.5.29.37",
+    serverAuth: "1.3.6.1.5.5.7.3.1",
+    subjectAltName: "2.5.29.17",
+    subjectKeyId: "2.5.29.14",
+    authorityKeyId: "2.5.29.35",
+    data: "1.2.840.113549.1.7.1",
+    certBag: "1.2.840.113549.1.12.10.1.3",
+    x509Certificate: "1.2.840.113549.1.9.22.1",
+    friendlyName: "1.2.840.113549.1.9.20",
+    // Java only treats a PKCS#12 certificate as trusted when it carries this attribute.
+    oracleTrustedKeyUsage: "2.16.840.1.113894.746875.1.1",
+    anyExtendedKeyUsage: "2.5.29.37.0",
+};
+const name = (cn) => seq(set(seq(oid(OID.organization), utf8("slicetest"))), set(seq(oid(OID.commonName), utf8(cn))));
+const extension = (id, critical, value) => seq(oid(id), ...(critical ? [bool(true)] : []), octets(value));
+const keyId = (key) => createHash("sha1").update(createPublicKey(key).export({ type: "spki", format: "der" })).digest();
+function certificate(opts) {
+    const now = Date.now();
+    const ski = keyId(opts.publicKey);
+    const extensions = [
+        extension(OID.basicConstraints, true, seq(...(opts.ca ? [bool(true)] : []))),
+        // CA: keyCertSign + cRLSign. Leaf: digitalSignature.
+        extension(OID.keyUsage, true, opts.ca ? tlv(0x03, Buffer.from([1, 0x06])) : tlv(0x03, Buffer.from([7, 0x80]))),
+        extension(OID.subjectKeyId, false, octets(ski)),
+        ...(opts.ca
+            ? []
+            : [
+                extension(OID.authorityKeyId, false, seq(tlv(0x80, opts.issuerKeyId))),
+                extension(OID.extKeyUsage, false, seq(oid(OID.serverAuth))),
+                extension(OID.subjectAltName, false, seq(...opts.hosts.map((h) => tlv(0x82, Buffer.from(h, "ascii"))))),
+            ]),
+    ];
+    const algorithm = seq(oid(OID.ecdsaSha256));
+    const tbs = seq(explicit(0, int(Buffer.from([2]))), // v3
+    int(randomBytes(16)), algorithm, name(opts.issuer), seq(time(new Date(now - 60 * 60_000)), time(new Date(now + (opts.ca ? 7 : 2) * 24 * 60 * 60_000))), name(opts.subject), createPublicKey(opts.publicKey).export({ type: "spki", format: "der" }), explicit(3, seq(...extensions)));
+    return seq(tbs, algorithm, bits(sign("sha256", tbs, opts.signer)));
+}
+const toPem = (der) => `-----BEGIN CERTIFICATE-----\n${der.toString("base64").replace(/.{64}/g, "$&\n").replace(/\n?$/, "\n")}-----END CERTIFICATE-----\n`;
+/** A certificate authority that exists for one test run. */
+export class Authority {
+    key;
+    der;
+    pem;
+    #keyId;
+    #leaves = new Map();
+    constructor() {
+        const { privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
+        this.key = privateKey;
+        this.#keyId = keyId(privateKey);
+        this.der = certificate({ subject: "slicetest test CA", publicKey: privateKey, issuer: "slicetest test CA", signer: privateKey, issuerKeyId: this.#keyId, ca: true });
+        this.pem = toPem(this.der);
+    }
+    /** A certificate for `host`, signed by this authority (cached). */
+    leaf(host) {
+        let issued = this.#leaves.get(host);
+        if (!issued) {
+            const { privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
+            const der = certificate({ subject: host, publicKey: privateKey, issuer: "slicetest test CA", signer: this.key, issuerKeyId: this.#keyId, ca: false, hosts: [host] });
+            issued = { key: privateKey, der, pem: toPem(der) };
+            this.#leaves.set(host, issued);
+        }
+        return issued;
+    }
+}
+/** PEM bundle of `extra` plus the usual public roots, for SSL_CERT_FILE and friends (which replace the default store). */
+export function pemBundle(roots, extra) {
+    return `${extra}${roots.map((r) => (r.endsWith("\n") ? r : `${r}\n`)).join("")}`;
+}
+/**
+ * A PKCS#12 trust store of certificates, readable by Java without a password
+ * (`-Djavax.net.ssl.trustStoreType=PKCS12`, no `trustStorePassword`): no MAC and
+ * unencrypted certificate bags, each marked as a trusted certificate entry.
+ */
+export function pkcs12TrustStore(certs) {
+    const bags = certs.map(({ alias, der }) => seq(oid(OID.certBag), explicit(0, seq(oid(OID.x509Certificate), explicit(0, octets(der)))), set(seq(oid(OID.friendlyName), set(bmp(alias))), seq(oid(OID.oracleTrustedKeyUsage), set(oid(OID.anyExtendedKeyUsage))))));
+    const safeContents = seq(...bags);
+    const authSafe = seq(seq(oid(OID.data), explicit(0, octets(safeContents))));
+    return seq(int(Buffer.from([3])), seq(oid(OID.data), explicit(0, octets(authSafe))));
+}
+/** DER of a PEM certificate, or undefined when it doesn't parse. */
+export function pemToDer(pem) {
+    try {
+        return Buffer.from(new X509Certificate(pem).raw);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/yaml-runtime.js

@@ -5,6 +5,7 @@ import { formatChanges } from "./db.js";
 import "./matchers.js";
 import { scenario } from "./scenario.js";
 import { signWebhook, webhookBody } from "./webhook.js";
+import { sse } from "./stub.js";
 /** Registers the scenarios of one parsed YAML file. Called from the module the plugin generates for it. */
 export function defineYamlScenarios(doc) {
     for (const sc of doc.scenarios) {
@@ -40,6 +41,8 @@ async function runSteps(doc, sc, steps, ctx, vars) {
     }
 }
 function describeStep(step) {
+    if ("submit" in step)
+        return step.submit === true ? "submit" : `submit ${JSON.stringify(step.submit)}`;
     if ("request" in step)
         return step.concurrency ? `${step.request} ×${step.concurrency}` : step.request;
     if ("stub" in step)
@@ -149,7 +152,10 @@ async function runStep(step, ctx, vars) {
         if (step.delay !== undefined)
             route = route.delay(step.delay);
         // Replies are interpolated when a call arrives, so they can echo it: {{call.params.id}}, {{call.json.name}}.
-        const answer = (template) => (call) => interpolate(template, { ...vars, call: callVars(call) });
+        const answer = (template) => (call) => {
+            const { sse: events, ...response } = interpolate(template, { ...vars, call: callVars(call) });
+            return events ? sse(events, response) : response;
+        };
         if (step.networkError)
             route.networkError();
         else if (step.sequence) {
@@ -161,6 +167,21 @@ async function runStep(step, ctx, vars) {
             route.reply(answer(step.reply ?? {}));
         return;
     }
+    if ("submit" in step) {
+        const page = ctx.http.history.at(-1);
+        if (!page)
+            throw new Error("submit needs a page with a form: request it first, e.g. `- request: GET /signup`");
+        const res = await ctx.http.submit(page, {
+            button: step.submit === true ? undefined : interpolate(step.submit, vars),
+            form: interpolate(step.form, vars),
+            fields: interpolate(step.fields, vars),
+            headers: interpolate(step.headers, vars),
+            follow: step.follow,
+        });
+        verifyResponse(res, step.expect, vars);
+        capture(step.capture, { status: res.status, json: res.json, text: res.text, headers: Object.fromEntries(res.headers) }, vars);
+        return;
+    }
     if ("request" in step) {
         const [method, rawPath] = splitCall(step.request);
         const path = interpolate(rawPath, vars);
@@ -181,18 +202,7 @@ async function runStep(step, ctx, vars) {
             opts.headers = { "content-type": signed.type, ...signWebhook(signed.body, interpolate(step.webhook, vars)), ...opts.headers };
         }
         const e = step.expect;
-        const verify = (res) => {
-            if (e?.status !== undefined)
-                expect(res).toHaveStatus(interpolate(e.status, vars));
-            if (e?.headers !== undefined) {
-                const expected = Object.fromEntries(Object.entries(e.headers).map(([k, v]) => [k.toLowerCase(), v]));
-                check(Object.fromEntries(res.headers), expected, vars, "response headers");
-            }
-            if (e?.json !== undefined)
-                check(res.json, e.json, vars, "response JSON");
-            if (e?.text !== undefined)
-                check(res.text, e.text, vars, "response text");
-        };
+        const verify = (res) => verifyResponse(res, e, vars);
         if (step.concurrency !== undefined) {
             // Each request gets its own body: a URLSearchParams body can only be read once.
             const all = await ctx.http.concurrently(step.concurrency, () => ctx.http.request(method, path, body instanceof URLSearchParams ? new URLSearchParams(body) : body, opts));
@@ -396,3 +406,15 @@ function interpolateTitle(name, row, index) {
         return v === undefined ? m : typeof v === "object" ? JSON.stringify(v) : String(v);
     });
 }
+function verifyResponse(res, e, vars) {
+    if (e?.status !== undefined)
+        expect(res).toHaveStatus(interpolate(e.status, vars));
+    if (e?.headers !== undefined) {
+        const expected = Object.fromEntries(Object.entries(e.headers).map(([k, v]) => [k.toLowerCase(), v]));
+        check(Object.fromEntries(res.headers), expected, vars, "response headers");
+    }
+    if (e?.json !== undefined)
+        check(res.json, e.json, vars, "response JSON");
+    if (e?.text !== undefined)
+        check(res.text, e.text, vars, "response text");
+}

package/dist/yaml.d.ts

@@ -21,7 +21,7 @@ export interface YamlScenario {
     timeout?: number;
     steps: Step[];
 }
-export type Step = (StubStep | RequestStep | InsertStep | MakeStep | ChaosStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep | MailStep) & {
+export type Step = (StubStep | RequestStep | SubmitStep | InsertStep | MakeStep | ChaosStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep | MailStep) & {
     line: number;
     name?: string;
 };
@@ -29,15 +29,26 @@ export interface StubStep {
     stub: string;
     on: string;
     when?: Conditions;
+    /** `sse`: a streamed reply, a list of { event, data, id } (instead of `body`). */
     reply?: {
         status?: number;
         headers?: Record<string, string>;
         body?: unknown;
+        sse?: {
+            event?: string;
+            data: unknown;
+            id?: string;
+        }[];
     };
     sequence?: {
         status?: number;
         headers?: Record<string, string>;
         body?: unknown;
+        sse?: {
+            event?: string;
+            data: unknown;
+            id?: string;
+        }[];
     }[];
     networkError?: boolean;
     times?: number;
@@ -85,6 +96,26 @@ export interface RequestStep {
     };
     capture?: Record<string, string>;
 }
+/**
+ * Submit a form of the page the last request returned, as a browser with JavaScript off would.
+ * `submit:` names the button to press (its text, value, name or id), or is `true` for the form's only button.
+ */
+export interface SubmitStep {
+    submit: string | true;
+    /** The form by id, name or 0-based position, when the page has several. */
+    form?: string | number;
+    /** Values typed into the form by field name; true / false / a list check checkboxes and radios. */
+    fields?: Record<string, string | number | boolean | (string | number)[]>;
+    headers?: Record<string, string>;
+    follow?: boolean;
+    expect?: {
+        status?: number;
+        headers?: Record<string, unknown>;
+        json?: unknown;
+        text?: unknown;
+    };
+    capture?: Record<string, string>;
+}
 export interface InsertStep {
     insert: string;
     rows: Record<string, unknown> | Record<string, unknown>[];

package/dist/yaml.js

@@ -2,6 +2,7 @@ import { isMap, isSeq, LineCounter, parseDocument } from "yaml";
 const KINDS = {
     stub: ["on", "when", "reply", "sequence", "networkError", "times", "delay"],
     request: ["headers", "query", "json", "form", "body", "follow", "auth", "webhook", "concurrency", "expect", "capture"],
+    submit: ["form", "fields", "headers", "follow", "expect", "capture"],
     insert: ["rows", "capture"],
     sql: ["params", "expect", "capture", "within"],
     db: ["where", "orderBy", "expect", "capture", "within"],
@@ -16,6 +17,7 @@ const KINDS = {
 };
 const EXPECT_KEYS = {
     request: ["status", "statuses", "headers", "json", "text", "queries"],
+    submit: ["status", "headers", "json", "text"],
     sql: ["rows", "count"],
     db: ["rows", "count"],
 };
@@ -24,7 +26,7 @@ const WEBHOOK_KEYS = ["provider", "secret", "event", "stale", "invalidSignature"
 const WEBHOOK_PROVIDERS = ["stripe", "github", "slack", "shopify", "standard"];
 const MAIL_KEYS = ["to", "from", "subject", "text", "html"];
 const CHANGE_KEYS = ["inserted", "updated", "deleted"];
-const RESPONSE_KEYS = ["status", "headers", "body"];
+const RESPONSE_KEYS = ["status", "headers", "body", "sse"];
 const SCENARIO_KEYS = ["name", "steps", "each", "skip", "only", "timeout"];
 const CALL = /^([A-Za-z]+|\*)\s+(\/\S*)$/;
 /** A request may also go to a captured URL of the app, e.g. a link from a mail: `GET {{link}}`. */
@@ -124,6 +126,22 @@ function parseStep(node, fail, lineOf) {
             if (!MAIL_KEYS.includes(k))
                 fail(at(kind), `unknown key "${k}" in mail (allowed: ${MAIL_KEYS.join(", ")})`);
     }
+    else if (kind === "submit") {
+        if (raw.submit !== true && (typeof raw.submit !== "string" || !raw.submit.trim()))
+            fail(at(kind), "`submit:` names the button to press (its text), or is `true` for the form's only button");
+        if (raw.form !== undefined && !(typeof raw.form === "string" || (Number.isInteger(raw.form) && raw.form >= 0)))
+            fail(at("form"), "`form` is the form's id or name, or its position on the page (0 for the first)");
+        const fields = raw.fields;
+        if (fields !== undefined) {
+            if (!fields || typeof fields !== "object" || Array.isArray(fields))
+                fail(at("fields"), "`fields` must map field names to values, e.g. { email: a@b.test }");
+            for (const [k, v] of Object.entries(fields)) {
+                const scalar = (x) => typeof x === "string" || typeof x === "number";
+                if (!(scalar(v) || typeof v === "boolean" || (Array.isArray(v) && v.every(scalar))))
+                    fail(at("fields"), `field "${k}" must be a string, number, true / false or a list`);
+            }
+        }
+    }
     else if (kind === "checkpoint") {
         if (raw.checkpoint !== true)
             fail(at(kind), "use `checkpoint: true`");
@@ -175,6 +193,18 @@ function parseStep(node, fail, lineOf) {
             if (answers.length !== 1)
                 fail(node, "a stub step needs exactly one of reply / sequence / networkError");
             keysOf("reply", RESPONSE_KEYS);
+            for (const [where, r] of [["reply", raw.reply], ...(Array.isArray(raw.sequence) ? raw.sequence : []).map((r) => ["sequence", r])]) {
+                if (!r || typeof r !== "object")
+                    continue;
+                const { body, sse } = r;
+                if (sse === undefined)
+                    continue;
+                if (body !== undefined)
+                    fail(at(where), "a reply has either `body` or `sse`, not both");
+                if (!Array.isArray(sse) || sse.some((e) => !e || typeof e !== "object" || Array.isArray(e) || !("data" in e) || Object.keys(e).some((k) => !["event", "data", "id"].includes(k)))) {
+                    fail(at(where), "`sse` must be a list of events such as { event: message_start, data: { ... } }");
+                }
+            }
             if (raw.sequence !== undefined && (!Array.isArray(raw.sequence) || raw.sequence.length === 0))
                 fail(at("sequence"), "`sequence` must be a non-empty list of responses");
             number("times");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicetest",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Framework-agnostic slice tests: drive a real app process over HTTP with a real Postgres, MySQL or SQLite and stubbed outbound APIs, checked against OpenAPI contracts.",
   "keywords": [
     "testing",
@@ -53,6 +53,7 @@
   },
   "files": [
     "dist",
+    "preload",
     "schema"
   ],
   "engines": {
@@ -66,9 +67,9 @@
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "peerDependencies": {
-    "vitest": ">=5",
+    "@testcontainers/mysql": ">=11",
     "mysql2": ">=3",
-    "@testcontainers/mysql": ">=11"
+    "vitest": ">=4"
   },
   "dependencies": {
     "@testcontainers/postgresql": "^12.2.0",
@@ -79,6 +80,7 @@
     "yaml": "^2.9.1"
   },
   "devDependencies": {
+    "@neondatabase/serverless": "^1.1.0",
     "@testcontainers/mysql": "^12.2.0",
     "@types/node": "^26.6.3",
     "@types/pg": "^8.23.1",

package/preload/node-proxy.cjs

@@ -0,0 +1,19 @@
+// Loaded into Node apps (NODE_OPTIONS=--require) while slicetest intercepts their outbound calls.
+// NODE_USE_ENV_PROXY covers fetch and the default agents; libraries that make their own
+// http(s).Agent (the Stripe SDK, many API clients) would otherwise go straight to the real
+// host. Agents made from here on get the proxy settings too, unless they set their own.
+"use strict";
+const http = require("node:http");
+const https = require("node:https");
+const { syncBuiltinESMExports } = require("node:module");
+
+for (const mod of [http, https]) {
+  const Original = mod.Agent;
+  class Agent extends Original {
+    constructor(options = {}) {
+      super({ proxyEnv: process.env, ...options });
+    }
+  }
+  mod.Agent = Agent;
+}
+syncBuiltinESMExports();

package/schema/scenario.schema.json

@@ -111,7 +111,33 @@
                 },
                 "body": {
                   "description": "String, or anything else to send as JSON. May use {{call.params.x}}, {{call.json.x}}, {{call.query.x}}"
+                },
+                "sse": {
+                  "type": "array",
+                  "description": "A streamed reply (Server-Sent Events), instead of body: a list of { event, data, id }. Data that isn't a string is sent as JSON",
+                  "items": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                      "data"
+                    ],
+                    "properties": {
+                      "event": {
+                        "type": "string"
+                      },
+                      "data": {},
+                      "id": {
+                        "type": "string"
+                      }
+                    }
+                  }
                 }
+              },
+              "not": {
+                "required": [
+                  "body",
+                  "sse"
+                ]
               }
             },
             "sequence": {
@@ -131,7 +157,33 @@
                   },
                   "body": {
                     "description": "String, or anything else to send as JSON. May use {{call.params.x}}, {{call.json.x}}, {{call.query.x}}"
+                  },
+                  "sse": {
+                    "type": "array",
+                    "description": "A streamed reply (Server-Sent Events), instead of body: a list of { event, data, id }. Data that isn't a string is sent as JSON",
+                    "items": {
+                      "type": "object",
+                      "additionalProperties": false,
+                      "required": [
+                        "data"
+                      ],
+                      "properties": {
+                        "event": {
+                          "type": "string"
+                        },
+                        "data": {},
+                        "id": {
+                          "type": "string"
+                        }
+                      }
+                    }
                   }
+                },
+                "not": {
+                  "required": [
+                    "body",
+                    "sse"
+                  ]
                 }
               },
               "minItems": 1
@@ -304,6 +356,94 @@
             }
           }
         },
+        {
+          "type": "object",
+          "required": [
+            "submit"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "submit": {
+              "oneOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "const": true
+                }
+              ],
+              "description": "Submit a form of the page the last request returned, as a browser with JavaScript off would (hidden fields such as CSRF tokens and Next.js server action ids included). Names the button to press by its text, value, name or id; `true` for the form's only button"
+            },
+            "name": {
+              "type": "string",
+              "description": "Label shown when this step fails"
+            },
+            "form": {
+              "type": [
+                "string",
+                "integer"
+              ],
+              "description": "The form by id, name or 0-based position, when the page has several"
+            },
+            "fields": {
+              "type": "object",
+              "description": "Values typed into the form by field name; true / false / a list of values check checkboxes and radios",
+              "additionalProperties": {
+                "oneOf": [
+                  {
+                    "type": [
+                      "string",
+                      "number",
+                      "boolean"
+                    ]
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": [
+                        "string",
+                        "number"
+                      ]
+                    }
+                  }
+                ]
+              }
+            },
+            "headers": {
+              "type": "object"
+            },
+            "follow": {
+              "type": "boolean"
+            },
+            "expect": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "status": {
+                  "type": [
+                    "integer",
+                    "string"
+                  ]
+                },
+                "headers": {
+                  "type": "object"
+                },
+                "json": {
+                  "description": "Subset of the response JSON"
+                },
+                "text": {}
+              }
+            },
+            "capture": {
+              "type": "object",
+              "description": "Save values as variables for later steps, e.g. { pollId: json.id }",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        },
         {
           "type": "object",
           "required": [