schema-markdown 1.0.6 → 1.1.3

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}) {
@@ -85,8 +86,8 @@ try {
 
 ## Development
 
-This project is developed using [javascript-build](https://github.com/craigahobbs/javascript-build#readme). It was started
-using [javascript-template](https://github.com/craigahobbs/javascript-template#readme) as follows:
+schema-markdown is developed using [javascript-build](https://github.com/craigahobbs/javascript-build#readme)
+and it was started using [javascript-template](https://github.com/craigahobbs/javascript-template#readme):
 
 ```
 template-specialize javascript-template/template/ schema-markdown-js/ -k package schema-markdown -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k noapp 1

package/lib/encode.js

@@ -0,0 +1,130 @@
+// Licensed under the MIT License
+// https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
+
+/** @module lib/encode */
+
+
+/**
+ * Encode an object as a query/hash string. Dictionaries, lists, and tuples are recursed. Each member key is expressed
+ * in fully-qualified form. List keys are the index into the list, and are in order.
+ *
+ * @param {Object} obj - The parameters object
+ * @returns {string}
+ */
+export function encodeQueryString(obj) {
+    return encodeQueryStringHelper(obj).join('&');
+}
+
+
+// Helper function for encodeQueryString
+function encodeQueryStringHelper(obj, memberFqn = null, keyValues = []) {
+    const objType = typeof obj;
+    if (Array.isArray(obj)) {
+        if (obj.length === 0) {
+            keyValues.push(memberFqn !== null ? `${memberFqn}=` : '');
+        } else {
+            for (let ix = 0; ix < obj.length; ix++) {
+                encodeQueryStringHelper(obj[ix], memberFqn !== null ? `${memberFqn}.${ix}` : `${ix}`, keyValues);
+            }
+        }
+    } else if (obj instanceof Date) {
+        const objEncoded = encodeURIComponent(obj.toISOString());
+        keyValues.push(memberFqn !== null ? `${memberFqn}=${objEncoded}` : `${objEncoded}`);
+    } else if (obj !== null && typeof obj === 'object') {
+        const keys = Object.keys(obj).sort();
+        if (keys.length === 0) {
+            keyValues.push(memberFqn !== null ? `${memberFqn}=` : '');
+        } else {
+            for (const key of keys) {
+                const keyEncoded = encodeQueryStringHelper(key);
+                encodeQueryStringHelper(obj[key], memberFqn !== null ? `${memberFqn}.${keyEncoded}` : `${keyEncoded}`, keyValues);
+            }
+        }
+    } else if (obj === null || objType === 'boolean' || objType === 'number') {
+        keyValues.push(memberFqn !== null ? `${memberFqn}=${obj}` : `${obj}`);
+    } else {
+        const objEncoded = encodeURIComponent(obj);
+        keyValues.push(memberFqn !== null ? `${memberFqn}=${objEncoded}` : `${objEncoded}`);
+    }
+    return keyValues;
+}
+
+
+/**
+ * Decode an object from a query/hash string. Each member key of the query string is expressed in fully-qualified
+ * form. List keys are the index into the list, must be in order.
+ *
+ * @param {string} paramStr - The parameters string
+ * @returns {Object}
+ */
+export function decodeQueryString(paramStr) {
+    // Decode the parameter string key/values
+    const result = [null];
+    const keyValues = paramStr.split('&');
+    keyValues.forEach((keyValue, ixKeyValue) => {
+        const [keyFqn, valueEncoded = null] = keyValue.split('=', 2);
+        if (valueEncoded === null) {
+            // Ignore hash IDs
+            if (ixKeyValue === keyValues.length - 1) {
+                return;
+            }
+            throw new Error(`Invalid key/value pair '${keyValue.slice(0, 100)}'`);
+        }
+        const value = decodeURIComponent(valueEncoded);
+
+        // Find/create the object on which to set the value
+        let parent = result;
+        let keyParent = 0;
+        const keys = keyFqn.split('.');
+        for (const keyEncoded of keys) {
+            let key = decodeURIComponent(keyEncoded);
+            let obj = parent[keyParent];
+
+            // Array key?  First "key" of an array must start with "0".
+            if (Array.isArray(obj) || (obj === null && key === '0')) {
+                // Create this key's container, if necessary
+                if (obj === null) {
+                    obj = [];
+                    parent[keyParent] = obj;
+                }
+
+                // Parse the key as an integer
+                if (isNaN(key)) {
+                    throw new Error(`Invalid array index '${key.slice(0, 100)}' in key '${keyFqn.slice(0, 100)}'`);
+                }
+                const keyOrig = key;
+                key = parseInt(key, 10);
+
+                // Append the value placeholder null
+                if (key === obj.length) {
+                    obj.push(null);
+                } else if (key < 0 || key > obj.length) {
+                    throw new Error(`Invalid array index '${keyOrig.slice(0, 100)}' in key '${keyFqn.slice(0, 100)}'`);
+                }
+            } else {
+                // Create this key's container, if necessary
+                if (obj === null) {
+                    obj = {};
+                    parent[keyParent] = obj;
+                }
+
+                // Create the index for this key
+                if (!(key in obj)) {
+                    obj[key] = null;
+                }
+            }
+
+            // Update the parent object and key
+            parent = obj;
+            keyParent = key;
+        }
+
+        // Set the value
+        if (parent[keyParent] !== null) {
+            throw new Error(`Duplicate key '${keyFqn.slice(0, 100)}'`);
+        }
+        parent[keyParent] = value;
+    });
+
+    return result[0] !== null ? result[0] : {};
+}

package/{src/schema-markdown → lib}/parser.js

@@ -1,6 +1,8 @@
 // Licensed under the MIT License
 // https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
 
+/** @module lib/parser */
+
 import {validateTypeModelTypesErrors} from './schemaUtil.js';
 
 /* eslint-disable prefer-template */

package/{src/schema-markdown → lib}/schema.js

@@ -1,6 +1,8 @@
 // Licensed under the MIT License
 // https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
 
+/** @module lib/schema */
+
 import {typeModel} from './typeModel.js';
 import {validateTypeModelTypesErrors} from './schemaUtil.js';
 
@@ -233,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);
         }
 
@@ -267,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) {
@@ -309,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) {
@@ -349,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)) {
@@ -359,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) {
@@ -403,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/{src/schema-markdown → lib}/typeModel.js

@@ -1,6 +1,8 @@
 // Licensed under the MIT License
 // https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
 
+/** @module lib/typeModel */
+
 import {SchemaMarkdownParser} from './parser.js';
 
 
@@ -251,7 +253,9 @@ struct ActionURL
 `;
 
 
-// The Schema Markdown type model
+/**
+ * The Schema Markdown type model
+ */
 export const typeModel = {
     'title': 'The Schema Markdown Type Model',
     'types': (new SchemaMarkdownParser(typeModelSmd)).types

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.0.6",
+    "version": "1.1.3",
     "description": "Human-friendly schema definition language and schema validator",
     "keywords": [
         "schema",
@@ -18,17 +18,16 @@
         "url": "https://github.com/craigahobbs"
     },
     "files": [
-        "index.js",
-        "src/schema-markdown/**/*"
+        "lib/**/*"
     ],
     "scripts": {
-        "test": "ava -v 'src/tests/**/*.js'"
+        "test": "ava -v test/"
     },
     "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"
     }
 }

package/index.js

@@ -1,4 +0,0 @@
-// Licensed under the MIT License
-// https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
-
-export * from './src/schema-markdown/index.js';

package/src/schema-markdown/encode.js

@@ -1,129 +0,0 @@
-// Licensed under the MIT License
-// https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
-
-
-/**
- * Encode an object as a query/hash string. Dictionaries, lists, and tuples are recursed. Each member key is expressed
- * in fully-qualified form. List keys are the index into the list, and are in order.
- *
- * @param {Object} obj - The parameters object
- * @returns {string}
- */
-export function encodeQueryString(obj) {
-    return encodeQueryStringHelper(obj).join('&');
-}
-
-
-// Helper function for encodeQueryString
-function encodeQueryStringHelper(obj, memberFqn = null, keyValues = []) {
-    const objType = typeof obj;
-    if (Array.isArray(obj)) {
-        if (obj.length === 0) {
-            keyValues.push(memberFqn !== null ? `${memberFqn}=` : '');
-        } else {
-            for (let ix = 0; ix < obj.length; ix++) {
-                encodeQueryStringHelper(obj[ix], memberFqn !== null ? `${memberFqn}.${ix}` : `${ix}`, keyValues);
-            }
-        }
-    } else if (obj instanceof Date) {
-        const objEncoded = encodeURIComponent(obj.toISOString());
-        keyValues.push(memberFqn !== null ? `${memberFqn}=${objEncoded}` : `${objEncoded}`);
-    } else if (obj !== null && typeof obj === 'object') {
-        const keys = Object.keys(obj).sort();
-        if (keys.length === 0) {
-            keyValues.push(memberFqn !== null ? `${memberFqn}=` : '');
-        } else {
-            for (const key of keys) {
-                const keyEncoded = encodeQueryStringHelper(key);
-                encodeQueryStringHelper(obj[key], memberFqn !== null ? `${memberFqn}.${keyEncoded}` : `${keyEncoded}`, keyValues);
-            }
-        }
-    } else if (obj === null || objType === 'boolean' || objType === 'number') {
-        keyValues.push(memberFqn !== null ? `${memberFqn}=${obj}` : `${obj}`);
-    } else {
-        const objEncoded = encodeURIComponent(obj);
-        keyValues.push(memberFqn !== null ? `${memberFqn}=${objEncoded}` : `${objEncoded}`);
-    }
-    return keyValues;
-}
-
-
-/**
- * Decode an object from a query/hash string. Each member key of the query string is expressed in fully-qualified
- * form. List keys are the index into the list, must be in order.
- *
- * @param {string} paramStr - The parameters string
- * @returns {Object}
- */
-export function decodeQueryString(paramStr) {
-    // Decode the parameter string key/values
-    const result = [null];
-    paramStr.split('&').forEach(
-        (keyValue, ixKeyValue, keyValuesFiltered) => {
-            const [keyFqn, valueEncoded = null] = keyValue.split('=', 2);
-            if (valueEncoded === null) {
-                // Ignore hash IDs
-                if (ixKeyValue === keyValuesFiltered.length - 1) {
-                    return;
-                }
-                throw new Error(`Invalid key/value pair '${keyValue.slice(0, 100)}'`);
-            }
-            const value = decodeURIComponent(valueEncoded);
-
-            // Find/create the object on which to set the value
-            let parent = result;
-            let keyParent = 0;
-            const keys = keyFqn.split('.');
-            for (const keyEncoded of keys) {
-                let key = decodeURIComponent(keyEncoded);
-                let obj = parent[keyParent];
-
-                // Array key?  First "key" of an array must start with "0".
-                if (Array.isArray(obj) || (obj === null && key === '0')) {
-                    // Create this key's container, if necessary
-                    if (obj === null) {
-                        obj = [];
-                        parent[keyParent] = obj;
-                    }
-
-                    // Parse the key as an integer
-                    if (isNaN(key)) {
-                        throw new Error(`Invalid array index '${key.slice(0, 100)}' in key '${keyFqn.slice(0, 100)}'`);
-                    }
-                    const keyOrig = key;
-                    key = parseInt(key, 10);
-
-                    // Append the value placeholder null
-                    if (key === obj.length) {
-                        obj.push(null);
-                    } else if (key < 0 || key > obj.length) {
-                        throw new Error(`Invalid array index '${keyOrig.slice(0, 100)}' in key '${keyFqn.slice(0, 100)}'`);
-                    }
-                } else {
-                    // Create this key's container, if necessary
-                    if (obj === null) {
-                        obj = {};
-                        parent[keyParent] = obj;
-                    }
-
-                    // Create the index for this key
-                    if (!(key in obj)) {
-                        obj[key] = null;
-                    }
-                }
-
-                // Update the parent object and key
-                parent = obj;
-                keyParent = key;
-            }
-
-            // Set the value
-            if (parent[keyParent] !== null) {
-                throw new Error(`Duplicate key '${keyFqn.slice(0, 100)}'`);
-            }
-            parent[keyParent] = value;
-        }
-    );
-
-    return result[0] !== null ? result[0] : {};
-}

package/src/schema-markdown/index.js

@@ -1,26 +0,0 @@
-// Licensed under the MIT License
-// https://github.com/craigahobbs/schema-markdown-js/blob/main/LICENSE
-
-export {
-    decodeQueryString,
-    encodeQueryString
-} from './encode.js';
-
-export {
-    SchemaMarkdownParser,
-    SchemaMarkdownParserError
-} from './parser.js';
-
-export {
-    ValidationError,
-    getEnumValues,
-    getReferencedTypes,
-    getStructMembers,
-    validateType,
-    validateTypeModel,
-    validateTypeModelTypes
-} from './schema.js';
-
-export {
-    typeModel
-} from './typeModel.js';