chore: cleanup

Author: sagold

src/compileSchema.ts

@@ -6,7 +6,7 @@ import { draft07 } from "./draft07";
 import { draft2019 } from "./draft2019";
 import { draft2020 } from "./draft2020";
 import { pick } from "./utils/pick";
-import { JsonSchema, Draft } from "./types";
+import { JsonSchema, Draft, BooleanSchema } from "./types";
 import { TemplateOptions } from "./methods/getData";
 import { SchemaNode, SchemaNodeMethods, addKeywords, isSchemaNode } from "./SchemaNode";
 
@@ -29,7 +29,6 @@ function getDraft(drafts: Draft[], $schema: string) {
  * node will be reused for each task, but will create a compiledNode for bound data.
  */
 export function compileSchema(schema: JsonSchema, options: CompileOptions = {}) {
-    /** @todo this option has to be passed to all drafts (remotes) */
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
     const draft = getDraft(drafts, schema?.$schema);

src/draft04/keywords/$ref.ts

@@ -145,5 +145,6 @@ function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
         // console.error("REF: UNFOUND 2", $ref);
         return undefined;
     }
-    console.error("REF: UNHANDLED", $ref);
+
+    console.error("REF: INVALID", $ref);
 }

src/draft2019-09/keywords/items.ts

@@ -57,7 +57,6 @@ function validateItems({ node, data, pointer = "#", path }: JsonSchemaValidatorP
         // note: schema is valid when data does not have enough elements as defined by array-list
         for (let i = 0; i < Math.min(node.prefixItems.length, data.length); i += 1) {
             const itemData = data[i];
-            // @todo v1 reevaluate: incomplete schema is created here?
             const itemNode = node.prefixItems[i];
             const result = validateNode(itemNode, itemData, `${pointer}/${i}`, path);
             errors.push(...result);

src/draft2019-09/methods/getData.ts

@@ -309,7 +309,6 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
         // @ts-expect-error asd
         if ((node.items && canResolveRef(node.items, opts)) || data?.length > 0) {
             // @attention this should disable cache or break intended behaviour as we reset it after loop
-            // @todo test recursion of items
             // intention: reset cache after each property. last call will add counters
             const cache = { ...opts.cache };
             for (let i = 0, l = Math.max(minItems, d.length); i < l; i += 1) {

src/keywords/$defs.ts

@@ -1,14 +1,6 @@
 import { Keyword } from "../Keyword";
 import { SchemaNode } from "../types";
 
-// @todo this should be done with every added property in evaluationPath
-// @todo this creates a mixed schema, where $defs, etc are not uri-encoded (would be %24defs)
-function urlEncodeJsonPointerProperty(property: string) {
-    property = property.replace(/~/g, "~0");
-    property = property.replace(/\//g, "~1");
-    return encodeURIComponent(property);
-}
-
 export const $defsKeyword: Keyword = {
     id: "$defs",
     keyword: "$defs",
@@ -37,3 +29,9 @@ export function parseDefs(node: SchemaNode) {
         });
     }
 }
+
+function urlEncodeJsonPointerProperty(property: string) {
+    property = property.replace(/~/g, "~0");
+    property = property.replace(/\//g, "~1");
+    return encodeURIComponent(property);
+}

src/keywords/$ref.ts

@@ -194,14 +194,11 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefi
             return compileNext(node.context.remotes[$ref], node.evaluationPath);
         }
         if ($ref[0] === "#") {
-            // @todo there is a bug joining multiple fragments to e.g. #/base#/examples/0
-            // from "$id": "/base" +  $ref "#/examples/0" (in refOfUnknownKeyword spec)
-            const ref = $ref.match(/#[^#]*$/)?.pop(); // sanitize pointer
             // support refOfUnknownKeyword
             const rootSchema = node.context.rootNode.schema;
-            const targetSchema = get(rootSchema, ref);
+            const targetSchema = get(rootSchema, $ref);
             if (targetSchema) {
-                return node.compileSchema(targetSchema, `${node.evaluationPath}/$ref`, ref);
+                return node.compileSchema(targetSchema, `${node.evaluationPath}/$ref`, $ref);
             }
         }
         // console.error("REF: UNFOUND 1", $ref);

src/types.ts

@@ -2,7 +2,7 @@ import { Draft } from "./Draft";
 import { errors } from "./errors/errors";
 import { SchemaNode, isSchemaNode, GetNodeOptions } from "./SchemaNode";
 
-export type JsonBooleanSchema = boolean;
+export type BooleanSchema = boolean;
 export interface JsonSchema {
     [p: string]: any;
 }

src/utils/getSchemaType.ts

@@ -1,6 +1,6 @@
 import { getTypeOf } from "./getTypeOf";
 import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { BooleanSchema, JsonSchema, SchemaNode } from "../types";
 
 export const SCHEMA_TYPES = ["string", "number", "integer", "boolean", "null", "array", "object"];
 const OBJECT_PROPERTIES = [
@@ -45,22 +45,22 @@ const ARRAY_PROPERTIES = [
  */
 export function getSchemaType(node: SchemaNode, data: unknown): keyof typeof SCHEMA_TYPES | undefined {
     const dataType = getTypeOf(data);
-    // @ts-expect-error boolean schema true
-    if (node.schema === true) {
+    const schema = node.schema as JsonSchema | BooleanSchema;
+    if (schema === true) {
         return SCHEMA_TYPES.includes(dataType) ? (dataType as keyof typeof SCHEMA_TYPES) : undefined;
     }
     // boolean schema false or invalid schema
-    if (!isObject(node.schema)) {
+    if (!isObject(schema)) {
         return undefined;
     }
-    const schemaType = node.schema.type;
+    const schemaType = schema.type;
 
     // type: []
     if (Array.isArray(schemaType)) {
         if (schemaType.includes(dataType)) {
             return dataType as keyof typeof SCHEMA_TYPES;
         }
-        const defaultType = getTypeOf(node.schema.default);
+        const defaultType = getTypeOf(schema.default);
         if (schemaType.includes(defaultType)) {
             return defaultType as keyof typeof SCHEMA_TYPES;
         }
@@ -73,13 +73,13 @@ export function getSchemaType(node: SchemaNode, data: unknown): keyof typeof SCH
     }
 
     // type: undefined, enum: []
-    if (Array.isArray(node.schema.enum)) {
-        const schemaEnum: unknown[] = node.schema.enum;
+    if (Array.isArray(schema.enum)) {
+        const schemaEnum: unknown[] = schema.enum;
         const enumSchemaType = schemaEnum.map((value) => getTypeOf(value)).filter((p, i, l) => l.indexOf(p) === i);
         if (enumSchemaType.includes(dataType)) {
             return dataType as keyof typeof SCHEMA_TYPES;
         }
-        const defaultType = getTypeOf(node.schema.default);
+        const defaultType = getTypeOf(schema.default);
         if (enumSchemaType.includes(defaultType)) {
             return defaultType as keyof typeof SCHEMA_TYPES;
         }

src/utils/joinId.test.ts

@@ -79,4 +79,12 @@ describe("joinId", () => {
 
         assert.equal(url, "https://example.com/absref/foobar.json");
     });
+
+    it("should ignore relative origin when next id starts with fragment url", () => {
+        // there is a bug joining multiple fragments to e.g. #/base#/examples/0
+        // from "$id": "/base" +  $ref "#/examples/0" (in refOfUnknownKeyword spec)
+        const url = joinId("/base", "#/examples/0");
+
+        assert.equal(url, "#/examples/0");
+    });
 });

src/utils/joinId.ts

@@ -20,6 +20,10 @@ function _joinScope(previous?: string, id?: string) {
         return id.replace(trailingHash, "");
     }
     if (id[0] === "#") {
+        if (previous[0] === "/") {
+            return id;
+        }
+
         return `${previous.replace(idAndPointer, "")}${id.replace(suffixes, "")}`;
     }
     if (isDomain.test(id)) {