json-schema-library 11.1.0 → 11.3.0

package/src/keywords/properties.ts

@@ -1,5 +1,5 @@
 import { getValue } from "../utils/getValue";
-import { JsonError, SchemaNode } from "../types";
+import { SchemaNode } from "../types";
 import {
     Keyword,
     JsonSchemaResolverParams,

package/src/keywords/propertyDependencies.ts

@@ -5,7 +5,7 @@ import {
     ValidationReturnType,
     ValidationAnnotation
 } from "../Keyword";
-import { isBooleanSchema, isJsonSchema, JsonSchema, SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { hasProperty } from "../utils/hasProperty";
 import { isObject } from "../utils/isObject";
 import { mergeSchema } from "../utils/mergeSchema";

package/src/methods/getData.ts

@@ -159,7 +159,7 @@ export function getData(node: SchemaNode, data?: unknown, opts?: TemplateOptions
         return defaultData;
     }
 
-    if (resolvedNode && resolvedNode !== currentNode) {
+    if (isSchemaNode(resolvedNode)) {
         defaultData = resolvedNode.getData(defaultData, opts) ?? defaultData;
         currentNode = resolvedNode;
     }

package/src/settings.ts

@@ -17,5 +17,31 @@ export default {
         "patternProperties",
         "propertyDependencies"
     ],
-    REGEX_FLAGS: "u"
+    REGEX_FLAGS: "u",
+    /**
+     * properties to keep from a $ref-schema when resolving a $ref (recursively)
+     * this allows to overwrite specified properties locally on a $ref-definition
+     *
+     * - draft 2019-09
+     * - draft 2020-12
+     *
+     * @example
+     * {
+     *   title: "custom component",
+     *   $ref: "#/$defs/component",
+     *
+     *   $defs: {
+     *     component: {
+     *       title: "component",
+     *       type: "object"
+     *     }
+     *   }
+     * }
+     * // results in
+     * {
+     *   title: "custom component"
+     *   type: "object"
+     * }
+     */
+    PROPERTIES_TO_MERGE: ["title", "description", "options", "x-options", "readOnly", "writeOnly"]
 };

package/src/validateNode.ts

@@ -1,8 +1,11 @@
-import { BooleanSchema, JsonSchema, SchemaNode } from "./types";
+import { BooleanSchema, isJsonError, JsonSchema, SchemaNode } from "./types";
 import { SchemaNodeWithRequired, ValidationPath, ValidationReturnType } from "./Keyword";
 import sanitizeErrors from "./utils/sanitizeErrors";
 
 export function validateNode(node: SchemaNode, data: unknown, pointer: string, path: ValidationPath) {
+    if (isJsonError(node)) {
+        return [node];
+    }
     path.push({ pointer, node });
     const schema = node.schema as BooleanSchema | JsonSchema;
     if (schema === true) {

package/tsconfig.json

@@ -7,10 +7,17 @@
         "module": "ESNext",
         "resolveJsonModule": true,
         "allowSyntheticDefaultImports": true,
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
         "lib": ["DOM", "ES2018"],
-        "exactOptionalPropertyTypes": true
+        "exactOptionalPropertyTypes": true,
+        "baseUrl": ".",
+        "paths": {
+            "json-schema-library": ["./index.ts"],
+            "json-schema-library/remotes": ["./remotes/index.ts"],
+            "json-schema-library/package.json": ["./package.json"]
+        },
+        "types": ["node", "mocha"]
     },
-    "exclude": ["src/**/*.test.ts"],
-    "include": ["index.ts", "src/**/*"]
+    "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts", "bowtie/**/*.test.ts"],
+    "include": ["index.ts", "src/**/*", "remotes/**/*", "bowtie/**/*"]
 }

package/tsconfig.test.json

@@ -5,11 +5,18 @@
         "incremental": false /* Enable incremental compilation */,
         "target": "ESNEXT" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
         "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+        "moduleResolution": "node10",
         "sourceMap": false /* Generates corresponding '.map' file. */,
         "strict": false /* Enable all strict type-checking options. */,
         "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
-        "types": ["mocha", "node"]
+        "types": ["mocha", "node"],
+        "baseUrl": ".",
+        "paths": {
+            "json-schema-library": ["./index.ts"],
+            "json-schema-library/remotes": ["./remotes/index.ts"],
+            "json-schema-library/package.json": ["./package.json"]
+        }
     },
     "exclude": [],
-    "include": ["src/**/*.test.ts"]
+    "include": ["src/**/*.test.ts", "bowtie/**/*.test.ts"]
 }

package/tsdown.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from "tsdown";
 
 export default defineConfig({
     dts: true,
-    entry: ["./index.ts"],
+    entry: ["./index.ts", "./remotes/index.ts"],
     exports: true,
     globalName: "jlib"
 });

package/Dockerfile

@@ -1,6 +0,0 @@
-FROM node:23-alpine
-COPY . /usr/app
-WORKDIR /usr/app
-#ENV NODE_ENV=production
-#RUN npm install --omit=dev
-CMD ["node", "bowtie_jlib.js"]

package/bowtie_jlib.js

@@ -1,140 +0,0 @@
-/**
- * test file for bowtie integration
- *
- * - Tutorial: https://docs.bowtie.report/en/stable/implementers/
- *
- * Build Dockerfile:
- *
- * ```
- * docker build -t localhost/jlib .
- * ````
- *
- * Test setup:
- *
- * ```
-bowtie run -i localhost/jlib -V <<EOF
-{"description": "test case 1", "schema": {}, "tests": [{"description": "a test", "instance": {}}] }
-{"description": "test case 2", "schema": {"const": 37}, "tests": [{"description": "not 37", "instance": {}}, {"description": "is 37", "instance": 37}] }
-EOF
- *
- * Test draft
- *
- * ```
- * bowtie suite -i localhost/jlib draft7 | bowtie summary --show failures
- * ```
- *
- */
-const readline = require("readline/promises");
-const process = require("process");
-const os = require("os");
-const packageJson = require("./package.json");
-const jlib = require("./dist/jsonSchemaLibrary.js");
-
-const compileSchema = jlib.compileSchema;
-
-const stdio = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false
-});
-
-// const schemaIds: { [id: string]: SchemaDraft } = {
-//     "https://json-schema.org/draft/2020-12/schema": SchemaDraft.v2020_12,
-//     "https://json-schema.org/draft/2019-09/schema": SchemaDraft.v2019_09,
-//     "http://json-schema.org/draft-07/schema#": SchemaDraft.v7,
-//     "http://json-schema.org/draft-06/schema#": SchemaDraft.v6,
-//     "http://json-schema.org/draft-04/schema#": SchemaDraft.v4
-// };
-
-function send(data) {
-    console.log(JSON.stringify(data));
-}
-
-let started = false;
-// let dialect;
-
-const cmds = {
-    start: async (args) => {
-        console.assert(args.version === 1, { args });
-        started = true;
-        return {
-            version: 1,
-            implementation: {
-                language: "javascript",
-                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(started, "Not started!");
-        // dialect = schemaIds[args.dialect];
-        return { ok: true };
-    },
-
-    run: async (args) => {
-        console.assert(started, "Not started!");
-
-        // for (const id in testCase.registry) {
-        //         ajv.addSchema(testCase.registry[id], id);
-        // }
-
-        const testCase = args.case;
-        //  as {
-        //     registry: Recors<sring, string>;
-        //     schema: Record<string, any>;
-        //     tests: {
-        //         /** testdata */
-        //         instance: unknown;
-        //     }[];
-        // };
-
-        const node = compileSchema(testCase.schema);
-        const results = testCase.tests.map((test) => {
-            try {
-                const errors = node.validate(test.instance);
-                return { valid: errors.length === 0 };
-            } catch (error) {
-                return {
-                    errored: true,
-                    context: {
-                        traceback: error.stack,
-                        message: error.message
-                    }
-                };
-            }
-        });
-
-        return { seq: args.seq, results: results };
-    },
-
-    stop: async (_) => {
-        console.assert(started, "Not started!");
-        process.exit(0);
-    }
-};
-
-async function main() {
-    for await (const line of stdio) {
-        const request = JSON.parse(line);
-        const response = await cmds[request.cmd](request);
-        send(response);
-    }
-}
-
-main();

package/remotes/draft04.json

@@ -1,150 +0,0 @@
-{
-    "id": "http://json-schema.org/draft-04/schema#",
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Core schema meta-schema",
-    "definitions": {
-        "schemaArray": {
-            "type": "array",
-            "minItems": 1,
-            "items": { "$ref": "#" }
-        },
-        "positiveInteger": {
-            "type": "integer",
-            "minimum": 0
-        },
-        "positiveIntegerDefault0": {
-            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
-        },
-        "simpleTypes": {
-            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
-        },
-        "stringArray": {
-            "type": "array",
-            "items": { "type": "string" },
-            "minItems": 1,
-            "uniqueItems": true
-        }
-    },
-    "type": "object",
-    "properties": {
-        "id": {
-            "type": "string",
-            "format": "uri"
-        },
-        "$schema": {
-            "type": "string",
-            "format": "uri"
-        },
-        "title": {
-            "type": "string"
-        },
-        "description": {
-            "type": "string"
-        },
-        "default": {},
-        "multipleOf": {
-            "type": "number",
-            "minimum": 0,
-            "exclusiveMinimum": true
-        },
-        "maximum": {
-            "type": "number"
-        },
-        "exclusiveMaximum": {
-            "type": "boolean",
-            "default": false
-        },
-        "minimum": {
-            "type": "number"
-        },
-        "exclusiveMinimum": {
-            "type": "boolean",
-            "default": false
-        },
-        "maxLength": { "$ref": "#/definitions/positiveInteger" },
-        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
-        "pattern": {
-            "type": "string",
-            "format": "regex"
-        },
-        "additionalItems": {
-            "anyOf": [
-                { "type": "boolean" },
-                { "$ref": "#" }
-            ],
-            "default": {}
-        },
-        "items": {
-            "anyOf": [
-                { "$ref": "#" },
-                { "$ref": "#/definitions/schemaArray" }
-            ],
-            "default": {}
-        },
-        "maxItems": { "$ref": "#/definitions/positiveInteger" },
-        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
-        "uniqueItems": {
-            "type": "boolean",
-            "default": false
-        },
-        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
-        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
-        "required": { "$ref": "#/definitions/stringArray" },
-        "additionalProperties": {
-            "anyOf": [
-                { "type": "boolean" },
-                { "$ref": "#" }
-            ],
-            "default": {}
-        },
-        "definitions": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "properties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "patternProperties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "dependencies": {
-            "type": "object",
-            "additionalProperties": {
-                "anyOf": [
-                    { "$ref": "#" },
-                    { "$ref": "#/definitions/stringArray" }
-                ]
-            }
-        },
-        "enum": {
-            "type": "array",
-            "minItems": 1,
-            "uniqueItems": true
-        },
-        "type": {
-            "anyOf": [
-                { "$ref": "#/definitions/simpleTypes" },
-                {
-                    "type": "array",
-                    "items": { "$ref": "#/definitions/simpleTypes" },
-                    "minItems": 1,
-                    "uniqueItems": true
-                }
-            ]
-        },
-        "allOf": { "$ref": "#/definitions/schemaArray" },
-        "anyOf": { "$ref": "#/definitions/schemaArray" },
-        "oneOf": { "$ref": "#/definitions/schemaArray" },
-        "not": { "$ref": "#" }
-    },
-    "dependencies": {
-        "exclusiveMaximum": [ "maximum" ],
-        "exclusiveMinimum": [ "minimum" ]
-    },
-    "default": {}
-}

package/remotes/draft06.json

@@ -1,155 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-06/schema#",
-    "$id": "http://json-schema.org/draft-06/schema#",
-    "title": "Core schema meta-schema",
-    "definitions": {
-        "schemaArray": {
-            "type": "array",
-            "minItems": 1,
-            "items": { "$ref": "#" }
-        },
-        "nonNegativeInteger": {
-            "type": "integer",
-            "minimum": 0
-        },
-        "nonNegativeIntegerDefault0": {
-            "allOf": [
-                { "$ref": "#/definitions/nonNegativeInteger" },
-                { "default": 0 }
-            ]
-        },
-        "simpleTypes": {
-            "enum": [
-                "array",
-                "boolean",
-                "integer",
-                "null",
-                "number",
-                "object",
-                "string"
-            ]
-        },
-        "stringArray": {
-            "type": "array",
-            "items": { "type": "string" },
-            "uniqueItems": true,
-            "default": []
-        }
-    },
-    "type": ["object", "boolean"],
-    "properties": {
-        "$id": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$schema": {
-            "type": "string",
-            "format": "uri"
-        },
-        "$ref": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "title": {
-            "type": "string"
-        },
-        "description": {
-            "type": "string"
-        },
-        "default": {},
-        "examples": {
-            "type": "array",
-            "items": {}
-        },
-        "multipleOf": {
-            "type": "number",
-            "exclusiveMinimum": 0
-        },
-        "maximum": {
-            "type": "number"
-        },
-        "exclusiveMaximum": {
-            "type": "number"
-        },
-        "minimum": {
-            "type": "number"
-        },
-        "exclusiveMinimum": {
-            "type": "number"
-        },
-        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "pattern": {
-            "type": "string",
-            "format": "regex"
-        },
-        "additionalItems": { "$ref": "#" },
-        "items": {
-            "anyOf": [
-                { "$ref": "#" },
-                { "$ref": "#/definitions/schemaArray" }
-            ],
-            "default": {}
-        },
-        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "uniqueItems": {
-            "type": "boolean",
-            "default": false
-        },
-        "contains": { "$ref": "#" },
-        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "required": { "$ref": "#/definitions/stringArray" },
-        "additionalProperties": { "$ref": "#" },
-        "definitions": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "properties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "patternProperties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "propertyNames": { "format": "regex" },
-            "default": {}
-        },
-        "dependencies": {
-            "type": "object",
-            "additionalProperties": {
-                "anyOf": [
-                    { "$ref": "#" },
-                    { "$ref": "#/definitions/stringArray" }
-                ]
-            }
-        },
-        "propertyNames": { "$ref": "#" },
-        "const": {},
-        "enum": {
-            "type": "array",
-            "minItems": 1,
-            "uniqueItems": true
-        },
-        "type": {
-            "anyOf": [
-                { "$ref": "#/definitions/simpleTypes" },
-                {
-                    "type": "array",
-                    "items": { "$ref": "#/definitions/simpleTypes" },
-                    "minItems": 1,
-                    "uniqueItems": true
-                }
-            ]
-        },
-        "format": { "type": "string" },
-        "allOf": { "$ref": "#/definitions/schemaArray" },
-        "anyOf": { "$ref": "#/definitions/schemaArray" },
-        "oneOf": { "$ref": "#/definitions/schemaArray" },
-        "not": { "$ref": "#" }
-    },
-    "default": {}
-}