json-schema-library 11.1.0 → 11.3.0

package/.mocharc.js

@@ -1,4 +1,5 @@
 process.env.TS_NODE_PROJECT = "./tsconfig.test.json";
+process.env.JLIB_TEST_RUN = "true";
 
 module.exports = {
     "node-option": ["import=tsx"]

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## Changelog
 
+### v11.3.0
+
+- added option 'draft' as fallback for a missing `$schema` id
+- added properties to merge when resolvinf a $ref to `settings.PROPERTIES_TO_MERGE`
+
+### v11.2.0
+
+- introduced `throwOnInvalidRef` to abort validation when a $ref cannot be resolved
+- added export of meta-schema for all drafts using `import "json-schema-library/remotes"`
+- added support for format validations: `idn-hostname`, `iri`, `iri-reference`
+
 ### v11.1.0
 
 - introduced upcoming keyword `propertyDependenciesKeyword` to package export

package/README.md

@@ -58,6 +58,12 @@ type CompileOptions = {
   remote: SchemaNode;
   // if format-validations should create errors. Defaults to true
   formatAssertion: boolean | "meta-schema";
+  /** set to true to throw an Error on errors in input schema. Defaults to false */
+  throwOnInvalidSchema?: boolean;
+  /** set to true to collect unknown keywords of input schema in `node.schemaAnnotations`. Defaults to false */
+  withSchemaAnnotations?: boolean;
+  /** set to true to throw an Error when encountering an unresolvable ref  */
+  throwOnInvalidRef?: boolean;
   // default options for all calls to node.getData()
   getDataDefaultOptions?: {
     // Add all properties (required and optional) to the generated data
@@ -110,7 +116,7 @@ const root = compileSchema({ properties: 123 }, { throwOnInvalidSchema: true });
 // throws Error
 ```
 
-<details><summary>Example for validation errors</summary>
+<details><summary>Example for schema validation errors</summary>
 
 ---
 
@@ -148,19 +154,21 @@ This collects all JSON Schema keywords not part of the used draft and any custom
 ---
 
 ```ts
-const { schemaErrors } = compileSchema({ options: {} }, { withSchemaAnnotations: true });
-console.log(schemaErrors[0]);
+const { schemaAnnotations } = compileSchema({ unknown: true }, { withSchemaAnnotations: true });
+console.log(schemaAnnotations[0]);
 {
-   type: 'annotation',
-   code: 'unknown-keyword-warning',
-   message: "Keyword 'options' is not a valid keyword to draft 'draft-2020-12'",
-   data: {
-     pointer: '#/options',
-     schema: { options: {} },
-     value: 'options',
-     draft: 'draft-2020-12'
-   }
- }
+  type: "annotation",
+  code: "unknown-keyword-warning",
+  message: "Keyword 'unknown' is not a valid keyword to draft 'draft-2020-12'",
+  data: {
+    pointer: "#/unknown",
+    schema: {
+      unknown: true
+    },
+    value: "unknown",
+    draft: "draft-2020-12"
+  }
+}
 ```
 
 ---

package/bowtie/.editorconfig

@@ -0,0 +1,21 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+indent_size = 2
+
+[package.json]
+indent_style = space
+indent_size = 2

package/bowtie/.prettierrc

@@ -0,0 +1,6 @@
+{
+    "printWidth": 120,
+    "singleQuote": false,
+    "bracketSpacing": true,
+    "trailingComma": "none"
+}

package/bowtie/BOWTIE.md

@@ -0,0 +1,54 @@
+# install
+
+brew install bowtie-json-schema/tap/bowtie
+https://docs.bowtie.report/en/stable/implementers/
+
+> docker build -t localhost/jlib .
+> bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 | bowtie summary --show failures
+> bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/blob/main/tests/draft7 --fail-fast
+
+# build
+
+docker build -t localhost/jlib .
+
+# test without bowtie
+
+docker run --rm localhost/jlib
+echo '{"cmd":"start","version":1}' | docker run -i jlib
+echo '{"cmd":"run","seq":1,"case":{"schema":{"type": "string"},"tests":["valid",999]}}' | docker run -i jlib
+echo '{"cmd":"dialect","dialect":"http://json-schema.org/draft-07/schema#"}' | docker run -i jlib
+echo '{"cmd":"stop"}' | docker run -i jlib
+
+# test with bowtie
+
+> docker build -t localhost/jlib .
+> then:
+
+bowtie smoke -i localhost/jlib
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/blob/main/tests/draft7/type.json | bowtie summary --show failures
+
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft4 | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft6 | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft7 | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2019-09 | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 | bowtie summary --show failures
+
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft7 > draft7.json
+
+**Fails**
+bowtie suite $(bowtie filter-implementations | sed 's/^/-i /') https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 >draft2020-12.json
+
+bowtie suite $(bowtie filter-implementations | sed 's/^jlib/-i /') https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 >draft2020-12.json
+
+bowtie suite -i localhost/jlib draft7 | bowtie summary
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/blob/main/tests/draft7/type.json | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/blob/main/tests/draft7 | bowtie summary --show failures
+bowtie suite -i localhost/jlib draft7 | bowtie summary --show failures
+bowtie validate -i localhost/jlib draft7 | bowtie summary --show failures
+
+**Does not finish**
+bowtie run --dialect 7 -i localhost/jlib
+bowtie validate -i localhost/jlib <(printf '{"type": "integer"}') <(printf 37) <(printf '"foo"')
+bowtie run -i localhost/jlib draft7 | bowtie summary --show failures
+bowtie run -i localhost/jlib -V '{"description": "test case 1", "schema": {}, "tests": [{"description": "a test", "instance": {}}]}'
+bowtie run -i localhost/jlib -V --fail-fast

package/bowtie/Dockerfile

@@ -0,0 +1,6 @@
+FROM node:24-alpine
+COPY . /usr/app
+WORKDIR /usr/app
+RUN npm install --omit=dev
+RUN npm -g install tsm
+CMD ["tsm", "bowtie-jlib.ts"]

package/bowtie/bowtie-api.ts

@@ -0,0 +1,101 @@
+import readline from "readline/promises";
+import { JsonSchema } from "src/types";
+
+export type Dialect =
+    | "https://json-schema.org/draft/2020-12/schema"
+    | "https://json-schema.org/draft/2019-09/schema"
+    | "http://json-schema.org/draft-07/schema#"
+    | "http://json-schema.org/draft-06/schema#"
+    | "http://json-schema.org/draft-04/schema#"
+    | "http://json-schema.org/draft-03/schema#";
+
+type StartCmd = {
+    cmd: "start";
+    version: number;
+};
+
+type StartCmdResponse = {
+    version: number;
+    implementation: {
+        /** library language */
+        language: "typescript" | "typescript";
+        /** library name */
+        name: string;
+        /** library version */
+        version: string;
+        homepage: string;
+        issues: string;
+        source: string;
+        dialects: Dialect[];
+        /** operating system platform */
+        os: string;
+        /** operating system version */
+        os_version: string;
+        /** Node.js version */
+        language_version: string;
+    };
+};
+
+type DialectCommand = {
+    cmd: "dialect";
+    dialect: Dialect;
+};
+
+type DialectCmdResponse = { ok: true };
+
+type RunCmd = {
+    cmd: "run";
+    seq: number;
+    // dialect: Dialect;
+    case: {
+        schema: JsonSchema;
+        tests: {
+            description: string;
+            instance: unknown;
+        }[];
+        registry: Record<string, JsonSchema>;
+    };
+};
+
+export type RunCmdResponse = {
+    seq: number;
+    results: ({ valid: boolean } | ErrorResponse)[];
+};
+
+export type ErrorResponse = {
+    errored: true;
+    context: {
+        traceback?: string | undefined;
+        message: string | undefined;
+    };
+};
+
+type StopCommand = {
+    cmd: "stop";
+};
+
+export type Command = StartCmd | RunCmd | DialectCommand | StopCommand;
+export type CommandResponse = RunCmdResponse | StartCmdResponse | DialectCmdResponse | ErrorResponse | undefined;
+
+export type CommandMap = {
+    /** Start nxet test run, informing bowtie of suppored draft versions and general metadata */
+    start: (args: StartCmd) => Promise<StartCmdResponse>;
+    /** Set JSON Schema draft-version of following tests */
+    dialect: (args: DialectCommand) => Promise<DialectCmdResponse>;
+    /** Run test cases for a specfic schema */
+    run: (args: RunCmd) => Promise<RunCmdResponse>;
+    /** Finalize test run and exit container */
+    stop: (args: StopCommand, stdio?: readline.Interface) => Promise<void>;
+};
+
+export const createBowtieError = (message: string, stack?: string): ErrorResponse => ({
+    errored: true,
+    context: {
+        message: message,
+        traceback: stack
+    }
+});
+
+export function sendToBowtie(data?: Record<string, unknown>) {
+    console.log(JSON.stringify(data ?? createBowtieError("missing response")));
+}

package/bowtie/bowtie-jlib.ts

@@ -0,0 +1,150 @@
+/* json-schema-library bowtie integration (test harness) */
+import readline from "readline/promises";
+import process from "node:process";
+import os from "os";
+import packageJson from "json-schema-library/package.json";
+import { compileSchema, type SchemaNode } from "json-schema-library";
+import { remotes } from "json-schema-library/remotes";
+import {
+    createBowtieError,
+    type Command,
+    type CommandMap,
+    type CommandResponse,
+    type Dialect,
+    RunCmdResponse,
+    sendToBowtie
+} from "./bowtie-api";
+
+/** track command sequence and abort if something is off */
+let state: "started" | "dialect" | "testing" | "stopped" = "stopped";
+/** current JSON Schema draft version to test */
+let dialect: Dialect;
+/** all meta-schemata added as remtoes */
+let remote: SchemaNode;
+
+const cmds: CommandMap = {
+    start: async (args) => {
+        console.assert(args.version === 1, { args });
+        console.assert(state === "stopped");
+        state = "started";
+
+        return {
+            version: 1,
+            implementation: {
+                language: "typescript",
+                name: "json-schema-library",
+                version: packageJson.version,
+                homepage: "https://github.com/sagold/json-schema-library",
+                issues: "https://github.com/sagold/json-schema-library/issues",
+                source: "https://github.com/sagold/json-schema-library",
+
+                dialects: [
+                    "https://json-schema.org/draft/2020-12/schema",
+                    "https://json-schema.org/draft/2019-09/schema",
+                    "http://json-schema.org/draft-07/schema#",
+                    "http://json-schema.org/draft-06/schema#",
+                    "http://json-schema.org/draft-04/schema#"
+                ],
+                os: os.platform(),
+                os_version: os.release(),
+                language_version: process.version
+            }
+        };
+    },
+
+    dialect: async (args) => {
+        console.assert(state === "started");
+        state = "dialect";
+
+        dialect = args.dialect;
+        remote = compileSchema({ $schema: dialect });
+        remotes.forEach((schema) => remote.addRemoteSchema(schema.$id ?? schema.id, schema));
+        return { ok: true };
+    },
+
+    run: async (args) => {
+        console.assert(state === "dialect" || state === "testing");
+        state = "testing";
+
+        const node = compileSchema(args.case.schema, { remote, draft: dialect, formatAssertion: false });
+        for (const id in args.case.registry) {
+            node.addRemoteSchema(id, args.case.registry[id]);
+        }
+        // run test cases and collect results to be sent back to bowtie
+        const results: RunCmdResponse["results"] = args.case.tests.map((test) => {
+            try {
+                return { valid: node.validate(test.instance).valid };
+            } catch (e) {
+                return createBowtieError(e.message ?? e, e.stack);
+            }
+        });
+        // response to bowtie for run command
+        return { seq: args.seq, results: results };
+    },
+
+    stop: async (_, stdio) => {
+        console.assert(state === "testing");
+        state = "stopped";
+
+        if (process.env.JLIB_TEST_RUN !== "true") {
+            stdio?.close();
+            process.exit(0);
+        }
+    }
+} as const;
+
+export async function runCommand(request: Command, stdio?: readline.Interface) {
+    let response: CommandResponse = undefined;
+    switch (request.cmd) {
+        case "start":
+            response = await cmds.start(request);
+            break;
+        case "dialect":
+            response = await cmds.dialect(request);
+            break;
+        case "run":
+            try {
+                response = await cmds.run(request);
+                return response;
+            } catch (error) {
+                response = {
+                    seq: request.seq,
+                    ...createBowtieError((error as Error).message ?? error, (error as Error).stack)
+                };
+            }
+            break;
+        case "stop":
+            await cmds.stop(request, stdio);
+            break;
+    }
+    return response;
+}
+
+function isCommand(value: unknown): value is Command {
+    return value != null && typeof value === "object" && "cmd" in value && cmds[value.cmd as keyof typeof cmds] != null;
+}
+
+/** listen for commands to be sent to container */
+async function waitForBowtieCommands() {
+    const stdio = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+    for await (const line of stdio) {
+        let response;
+        try {
+            const request = JSON.parse(line);
+            response = isCommand(request)
+                ? await runCommand(request, stdio)
+                : createBowtieError(`Unsupported command received: '${line}'`);
+        } catch (e) {
+            response = createBowtieError(`Invalid json received: '${line}': ${(e as Error)?.message}`);
+        }
+        sendToBowtie(response);
+    }
+}
+
+if (process.env.JLIB_TEST_RUN !== "true") {
+    waitForBowtieCommands();
+}