schema-markdown 1.1.0 → 1.1.4

package/README.md

@@ -24,13 +24,14 @@ its features at a glance:
 ## Usage
 
 To schema-validate an object, first parse its *Schema Markdown* using the
-[SchemaMarkdownParser](https://craigahobbs.github.io/schema-markdown-js/SchemaMarkdownParser.html)
+[SchemaMarkdownParser](https://craigahobbs.github.io/schema-markdown-js/module-lib_parser.SchemaMarkdownParser.html)
 class:
 
 ``` javascript
-import * as smd from 'schema_markdown/index.js';
+import {SchemaMarkdownParser} from 'schema-markdown/parser.js';
+import {validateType} from 'schema-markdown/schema.js';
 
-const parser = new smd.SchemaMarkdownParser(`\
+const parser = new SchemaMarkdownParser(`\
 # An aggregation function
 enum Aggregation
     Average
@@ -47,11 +48,11 @@ struct Operation
 ```
 
 Then, validate an object using the
-[validateType](https://craigahobbs.github.io/schema-markdown-js/global.html#validateType)
+[validateType](https://craigahobbs.github.io/schema-markdown-js/module-lib_schema.html#.validateType)
 function:
 
 ``` javascript
-const obj = smd.validateType(parser.types, 'Operation', {
+const obj = validateType(parser.types, 'Operation', {
     'numbers': [1, 2, '3', 4]
 });
 console.assert(obj.numbers[2] === 3);
@@ -62,7 +63,7 @@ Validation fails if the object does not match the schema:
 
 ``` javascript
 try {
-    smd.validateType(parser.types, 'Operation', {
+    validateType(parser.types, 'Operation', {
         'numbers': [1, 2, 'asdf', 4]
     });
 } catch ({message}) {
@@ -74,7 +75,7 @@ Validation also fails if a member contraint is violated:
 
 ``` javascript
 try {
-    smd.validateType(parser.types, 'Operation', {
+    validateType(parser.types, 'Operation', {
         'numbers': []
     });
 } catch ({message}) {

package/lib/parser.js

@@ -43,7 +43,7 @@ const RE_PART_TYPEDEF =
 const RE_TYPEDEF = new RegExp('^typedef\\s+' + RE_PART_TYPEDEF + '\\s*$');
 const RE_MEMBER = new RegExp('^\\s+(?<optional>optional\\s+)?' + RE_PART_TYPEDEF + '\\s*$');
 const RE_VALUE = new RegExp('^\\s+(?<id>' + RE_PART_ID + ')\\s*$');
-const RE_VALUE_QUOTED = new RegExp('^\\s+"(?<id>' + RE_PART_ID + '.*?)"\\s*$');
+const RE_VALUE_QUOTED = /^\s+"(?<id>.*?)"\s*$/;
 const RE_URL = /^\s+(?<method>[A-Za-z]+|\*)(?:\s+(?<path>\/[^\s]*))?/;
 
 

package/lib/schema.js

@@ -235,12 +235,12 @@ function validateTypeHelper(types, type, value, memberFqn) {
         for (let ixArrayValue = 0; ixArrayValue < valueNew.length; ixArrayValue++) {
             const memberFqnValue = memberFqn !== null ? `${memberFqn}.${ixArrayValue}` : `${ixArrayValue}`;
             let arrayValue = valueNew[ixArrayValue];
-            if (arrayValue === null || (arrayValueNullable && arrayValue === 'null')) {
+            if (arrayValueNullable && (arrayValue === null || arrayValue === 'null')) {
                 arrayValue = null;
             } else {
                 arrayValue = validateTypeHelper(types, arrayType, arrayValue, memberFqnValue);
+                validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
             }
-            validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
             valueCopy.push(arrayValue);
         }
 
@@ -269,20 +269,20 @@ function validateTypeHelper(types, type, value, memberFqn) {
             const memberFqnKey = memberFqn !== null ? `${memberFqn}.${dictKey}` : `${dictKey}`;
 
             // Validate the key
-            if (dictKey === null || (dictKeyNullable && dictKey === 'null')) {
+            if (dictKeyNullable && (dictKey === null || dictKey === 'null')) {
                 dictKey = null;
             } else {
                 dictKey = validateTypeHelper(types, dictKeyType, dictKey, memberFqn);
+                validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
             }
-            validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
 
             // Validate the value
-            if (dictValue === null || (dictValueNullable && dictValue === 'null')) {
+            if (dictValueNullable && (dictValue === null || dictValue === 'null')) {
                 dictValue = null;
             } else {
                 dictValue = validateTypeHelper(types, dictType, dictValue, memberFqnKey);
+                validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
             }
-            validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
 
             // Copy the key/value
             if (valueCopy instanceof Map) {
@@ -311,12 +311,12 @@ function validateTypeHelper(types, type, value, memberFqn) {
 
             // Validate the value
             const valueNullable = typedefAttr !== null && 'nullable' in typedefAttr && typedefAttr.nullable;
-            if (value === null || (valueNullable && value === 'null')) {
+            if (valueNullable && (value === null || value === 'null')) {
                 valueNew = null;
             } else {
                 valueNew = validateTypeHelper(types, typedef.type, value, memberFqn);
+                validateAttr(type, typedefAttr, valueNew, memberFqn);
             }
-            validateAttr(type, typedefAttr, valueNew, memberFqn);
 
         // enum?
         } else if ('enum' in userType) {
@@ -351,7 +351,8 @@ function validateTypeHelper(types, type, value, memberFqn) {
             for (const member of getStructMembers(types, struct)) {
                 const memberName = member.name;
                 const memberFqnMember = memberFqn !== null ? `${memberFqn}.${memberName}` : `${memberName}`;
-                const memberOptional = 'optional' in member ? member.optional : false;
+                const memberOptional = 'optional' in member && member.optional;
+                const memberNullable = 'attr' in member && 'nullable' in member.attr && member.attr.nullable;
 
                 // Missing non-optional member?
                 if (!(valueNew instanceof Map ? valueNew.has(memberName) : memberName in valueNew)) {
@@ -361,10 +362,12 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 } else {
                     // Validate the member value
                     let memberValue = valueNew instanceof Map ? valueNew.get(memberName) : valueNew[memberName];
-                    if (memberValue !== null) {
+                    if (memberNullable && (memberValue === null || memberValue === 'null')) {
+                        memberValue = null;
+                    } else {
                         memberValue = validateTypeHelper(types, member.type, memberValue, memberFqnMember);
+                        validateAttr(member.type, 'attr' in member ? member.attr : null, memberValue, memberFqnMember);
                     }
-                    validateAttr(member.type, 'attr' in member ? member.attr : null, memberValue, memberFqnMember);
 
                     // Copy the validated member
                     if (valueCopy instanceof Map) {
@@ -405,12 +408,7 @@ function throwMemberError(type, value, memberFqn, attr = null) {
 
 
 function validateAttr(type, attr, value, memberFqn) {
-    if (value === null) {
-        const valueNullable = attr !== null && 'nullable' in attr && attr.nullable;
-        if (!valueNullable) {
-            throwMemberError(type, value, memberFqn);
-        }
-    } else if (attr !== null) {
+    if (attr !== null) {
         const length = Array.isArray(value) || typeof value === 'string' ? value.length
             : (typeof value === 'object' ? Object.keys(value).length : null);
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.1.0",
+    "version": "1.1.4",
     "description": "Human-friendly schema definition language and schema validator",
     "keywords": [
         "schema",
@@ -26,8 +26,8 @@
     "devDependencies": {
         "ava": "^4.0.0-rc.1",
         "c8": "~7.10",
-        "eslint": "~8.3",
+        "eslint": "~8.4",
         "jsdoc": "~3.6",
-        "jsdom": "~18.1"
+        "jsdom": "~19.0"
     }
 }