schema-markdown 1.2.13 → 1.3.0

package/README.md

@@ -63,7 +63,7 @@ Validation fails if the object does not match the schema:
 try {
     validateType(modelTypes, 'Aggregation', {'numbers': [1, 2, 'asdf', 4]});
 } catch ({message}) {
-    console.assert(message === "Invalid value \"asdf\" (type 'string') for member 'numbers.2', expected type 'int'", message);
+    console.assert(message === 'Invalid value "asdf" (type "string") for member "numbers.2", expected type "int"', message);
 }
 ~~~
 
@@ -73,10 +73,16 @@ Validation also fails if a member constraint is violated:
 try {
     validateType(modelTypes, 'Aggregation', {'numbers': []});
 } catch ({message}) {
-    console.assert(message === "Invalid value [] (type 'object') for member 'numbers', expected type 'array' [len > 0]", message);
+    console.assert(message === 'Invalid value [] (type "object") for member "numbers", expected type "array" [len > 0]', message);
 }
 ~~~
 
+`validateType` validates JSON-like values. In this JavaScript implementation, date values are
+`Date` objects (time-of-day cleared), datetime values are `Date` objects, and uuid strings remain
+strings. A `Date` input is left as a `Date` (date values have time-of-day cleared). See
+[The Schema Markdown Language - Built-in Types](https://craigahobbs.github.io/schema-markdown-js/language/#built-in-types)
+for accepted JSON input formats and host-runtime behavior.
+
 
 ## Schema Documentation
 

package/lib/parser.js

@@ -24,7 +24,7 @@ const rFindAttrs = new RegExp(`${rPartAttr}(?:\\s*,\\s*|\\s*$)`, 'g');
 const rLineCont = /\\\s*$/;
 const rComment = /^\s*(?:#-.*|#(?<doc>.*))?$/;
 const rGroup = /^group(?:\s+"(?<group>.+?)")?\s*$/;
-const rAction = new RegExp(`^action\\s+(?<id>${rPartId})`);
+const rAction = new RegExp(`^action\\s+(?<id>${rPartId})\\s*$`);
 const rPartBaseIds = `(?:\\s*\\(\\s*(?<baseIds>${rPartId}(?:\\s*,\\s*${rPartId})*)\\s*\\)\\s*)`;
 const rBaseIdsSplit = /\s*,\s*/;
 const rDefinition = new RegExp(`^(?<type>struct|union|enum)\\s+(?<id>${rPartId})${rPartBaseIds}?\\s*$`);
@@ -311,8 +311,12 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             // Clear parser state
             userType = null;
 
-            // Update the parser state
+            // Update the parser state - attach urls immediately so a second empty
+            // "urls" section is detected as a redefinition (even with no URL lines)
             urls = [];
+            if (!(sectionString in action)) {
+                action[sectionString] = urls;
+            }
 
         // Enum value?
         } else if (matchName === 'value') {
@@ -383,9 +387,6 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             }
 
             // Add the URL
-            if (!('urls' in action)) {
-                action.urls = urls;
-            }
             urls.push(actionUrl);
 
         // Typedef?
@@ -429,6 +430,16 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         }
     }
 
+    // Drop empty action urls arrays (type model requires len > 0 when present)
+    for (const userTypeIter of Object.values(types)) {
+        if ('action' in userTypeIter) {
+            const actionType = userTypeIter.action;
+            if ('urls' in actionType && actionType.urls.length === 0) {
+                delete actionType.urls;
+            }
+        }
+    }
+
     // Validate the type model, if requested
     if (validate) {
         for (const [typeName, memberName, errorMsg] of validateTypeModelErrors(types)) {

package/lib/schema.js

@@ -120,6 +120,12 @@ export class ValidationError extends Error {
  * Type-validate a value using a user type model. Container values are duplicated since some member types are
  * transformed during validation.
  *
+ * Validates JSON-like values. In this implementation, date values are `Date` objects (time-of-day
+ * cleared), datetime values are `Date` objects, and uuid strings remain strings. A `Date` input is
+ * left as a `Date` (date values have time-of-day cleared). See the language documentation on
+ * [built-in types]{@link https://craigahobbs.github.io/schema-markdown-js/language/#built-in-types}
+ * for accepted JSON input formats and host-runtime behavior.
+ *
  * @param {Object} types - The [type model]{@link https://craigahobbs.github.io/bare-script/model/#var.vURL=''&var.vName='Types'}
  * @param {string} typeName - The type name
  * @param {Object} value - The value object to validate
@@ -129,7 +135,7 @@ export class ValidationError extends Error {
  */
 export function validateType(types, typeName, value, memberFqn = null) {
     if (!(typeName in types)) {
-        throw new ValidationError(`Unknown type '${typeName}'`);
+        throw new ValidationError(`Unknown type "${typeName}"`);
     }
     return validateTypeHelper(types, {'user': typeName}, value, memberFqn);
 }
@@ -137,7 +143,8 @@ export function validateType(types, typeName, value, memberFqn = null) {
 
 // Regular expressions used by validateTypeHelper
 const rDate = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/;
-const rDatetime = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$/;
+const rDatetime = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
+const rUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 
 function validateTypeHelper(types, type, value, memberFqn) {
@@ -147,15 +154,19 @@ function validateTypeHelper(types, type, value, memberFqn) {
     if ('builtin' in type) {
         const {builtin} = type;
 
-        // string or uuid?
-        if (builtin === 'string' || builtin === 'uuid') {
+        // string?
+        if (builtin === 'string') {
             // Not a string?
             if (typeof value !== 'string') {
                 throwMemberError(type, value, memberFqn);
             }
 
-            // Not a valid UUID?
-            if (builtin === 'uuid' && !value.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i)) {
+        // uuid?
+        } else if (builtin === 'uuid') {
+            if (typeof value !== 'string') {
+                throwMemberError(type, value, memberFqn);
+            }
+            if (!rUuid.test(value)) {
                 throwMemberError(type, value, memberFqn);
             }
 
@@ -195,31 +206,52 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 throwMemberError(type, value, memberFqn);
             }
 
-        // date or datetime?
-        } else if (builtin === 'date' || builtin === 'datetime') {
+        // date?
+        } else if (builtin === 'date') {
             // Convert string?
             if (typeof value === 'string') {
-                // Valid date format?
+                // Date-only?
                 const mDate = value.match(rDate);
                 if (mDate !== null) {
                     const year = Number.parseInt(mDate.groups.year, 10);
                     const month = Number.parseInt(mDate.groups.month, 10);
                     const day = Number.parseInt(mDate.groups.day, 10);
                     valueNew = new Date(year, month - 1, day);
-                } else if (rDatetime.test(value)) {
-                    valueNew = new Date(value);
+                    // new Date rolls an out-of-range month/day over (e.g. Feb 30 -> Mar 1); reject that
+                    if (valueNew.getMonth() !== month - 1) {
+                        throwMemberError(type, value, memberFqn);
+                    }
                 } else {
                     throwMemberError(type, value, memberFqn);
                 }
 
-            // Not a date?
-            } else if (!(value instanceof Date)) {
+            // Not a date, or a date with a time-of-day?
+            } else if (!(value instanceof Date) ||
+                value.getHours() + value.getMinutes() + value.getSeconds() + value.getMilliseconds() !== 0) {
                 throwMemberError(type, value, memberFqn);
             }
 
-            // For date type, clear hours, minutes, seconds, and milliseconds
-            if (builtin === 'date') {
-                valueNew = new Date(valueNew.getFullYear(), valueNew.getMonth(), valueNew.getDate());
+        // datetime?
+        } else if (builtin === 'datetime') {
+            // Convert string?
+            if (typeof value === 'string') {
+                const mDatetime = value.match(rDatetime);
+                if (mDatetime !== null) {
+                    valueNew = new Date(value);
+                    const year = Number.parseInt(mDatetime.groups.year, 10);
+                    const month = Number.parseInt(mDatetime.groups.month, 10);
+                    const day = Number.parseInt(mDatetime.groups.day, 10);
+                    // new Date rolls an out-of-range day over (e.g. Feb 30 -> Mar 1); reject that
+                    if (Number.isNaN(valueNew.getTime()) || new Date(year, month - 1, day).getMonth() !== month - 1) {
+                        throwMemberError(type, value, memberFqn);
+                    }
+                } else {
+                    throwMemberError(type, value, memberFqn);
+                }
+
+            // Not a datetime?
+            } else if (!(value instanceof Date)) {
+                throwMemberError(type, value, memberFqn);
             }
         }
 
@@ -263,7 +295,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
         const dictKeyAttr = 'keyAttr' in dict ? dict.keyAttr : null;
         if (value === '') {
             valueNew = {};
-        } else if (value === null || typeof value !== 'object') {
+        } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
             throwMemberError(type, value, memberFqn);
         }
 
@@ -340,7 +372,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
             // Valid value type?
             if (value === '') {
                 valueNew = {};
-            } else if (value === null || typeof value !== 'object') {
+            } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
                 throwMemberError({'user': struct.name}, value, memberFqn);
             }
 
@@ -363,7 +395,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 // Missing non-optional member?
                 if (!(valueNew instanceof Map ? valueNew.has(memberName) : memberName in valueNew)) {
                     if (!memberOptional && !isUnion) {
-                        throw new ValidationError(`Required member '${memberFqnMember}' missing`);
+                        throw new ValidationError(`Required member "${memberFqnMember}" missing`);
                     }
                 } else {
                     // Validate the member value
@@ -391,7 +423,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 const memberSet = new Set(getStructMembers(types, struct).map((member) => member.name));
                 const [unknownKey] = valueNewKeys.filter((key) => !memberSet.has(key));
                 const unknownFqn = memberFqn !== null ? `${memberFqn}.${unknownKey}` : `${unknownKey}`;
-                throw new ValidationError(`Unknown member '${unknownFqn.slice(0, 100)}'`);
+                throw new ValidationError(`Unknown member "${unknownFqn.slice(0, 100)}"`);
             }
 
             // Return the validated, transformed copy
@@ -404,11 +436,11 @@ function validateTypeHelper(types, type, value, memberFqn) {
 
 
 function throwMemberError(type, value, memberFqn, attr = null) {
-    const memberPart = memberFqn !== null ? ` for member '${memberFqn}'` : '';
+    const memberPart = memberFqn !== null ? ` for member "${memberFqn}"` : '';
     const typeName = 'builtin' in type ? type.builtin : ('array' in type ? 'array' : ('dict' in type ? 'dict' : type.user));
     const attrPart = attr !== null ? ` [${attr}]` : '';
     const valueStr = `${JSON.stringify(value)}`;
-    const msg = `Invalid value ${valueStr.slice(0, 100)} (type '${typeof value}')${memberPart}, expected type '${typeName}'${attrPart}`;
+    const msg = `Invalid value ${valueStr.slice(0, 100)} (type "${typeof value}")${memberPart}, expected type "${typeName}"${attrPart}`;
     throw new ValidationError(msg, memberFqn);
 }
 
@@ -532,6 +564,23 @@ export function validateTypeModel(types) {
     // Do additional type model validation
     const errors = validateTypeModelErrors(validatedTypes);
     if (errors.length) {
+        // Sort by (typeName, memberName, message); null memberName as ''
+        errors.sort((errorA, errorB) => {
+            let result = 0;
+            for (let ixPart = 0; ixPart < 3; ixPart++) {
+                const partA = errorA[ixPart] ?? '';
+                const partB = errorB[ixPart] ?? '';
+                if (partA < partB) {
+                    result = -1;
+                    break;
+                }
+                if (partA > partB) {
+                    result = 1;
+                    break;
+                }
+            }
+            return result;
+        });
         throw new ValidationError(errors.map(([,, message]) => message).join('\n'));
     }
 

package/lib/schemaUtil.js

@@ -21,7 +21,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== struct.name) {
-                errors.push([typeName, null, `Inconsistent type name '${struct.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${struct.name}" for "${typeName}"`]);
             }
 
             // Check base types
@@ -36,7 +36,7 @@ export function validateTypeModelErrors(types) {
                         }
                     }
                     if (invalidBase) {
-                        errors.push([typeName, null, `Invalid struct base type '${baseName}'`]);
+                        errors.push([typeName, null, `Invalid struct base type "${baseName}"`]);
                     }
                 }
             }
@@ -51,14 +51,14 @@ export function validateTypeModelErrors(types) {
                     if (!(memberName in members)) {
                         members[memberName] = true;
                     } else {
-                        errors.push([typeName, memberName, `Redefinition of '${typeName}' member '${memberName}'`]);
+                        errors.push([typeName, memberName, `Redefinition of "${typeName}" member "${memberName}"`]);
                     }
 
                     // Check member type and attributes
                     validateTypeModelType(errors, types, member.type, 'attr' in member ? member.attr : null, struct.name, member.name);
                 }
             } catch {
-                errors.push([typeName, null, `Circular base type detected for type '${typeName}'`]);
+                errors.push([typeName, null, `Circular base type detected for type "${typeName}"`]);
             }
 
         // Enum?
@@ -67,7 +67,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== enum_.name) {
-                errors.push([typeName, null, `Inconsistent type name '${enum_.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${enum_.name}" for "${typeName}"`]);
             }
 
             // Check base types
@@ -75,7 +75,7 @@ export function validateTypeModelErrors(types) {
                 for (const baseName of enum_.bases) {
                     const baseUserType = getEffectiveUserType(types, baseName);
                     if (baseUserType === null || !('enum' in baseUserType)) {
-                        errors.push([typeName, null, `Invalid enum base type '${baseName}'`]);
+                        errors.push([typeName, null, `Invalid enum base type "${baseName}"`]);
                     }
                 }
             }
@@ -90,11 +90,11 @@ export function validateTypeModelErrors(types) {
                     if (!(valueName in values)) {
                         values[valueName] = true;
                     } else {
-                        errors.push([typeName, valueName, `Redefinition of '${typeName}' value '${valueName}'`]);
+                        errors.push([typeName, valueName, `Redefinition of "${typeName}" value "${valueName}"`]);
                     }
                 }
             } catch {
-                errors.push([typeName, null, `Circular base type detected for type '${typeName}'`]);
+                errors.push([typeName, null, `Circular base type detected for type "${typeName}"`]);
             }
 
         // Typedef?
@@ -103,7 +103,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== typedef.name) {
-                errors.push([typeName, null, `Inconsistent type name '${typedef.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${typedef.name}" for "${typeName}"`]);
             }
 
             // Check the type and its attributes
@@ -115,7 +115,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== action.name) {
-                errors.push([typeName, null, `Inconsistent type name '${action.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${action.name}" for "${typeName}"`]);
             }
 
             // Check action section types
@@ -159,7 +159,7 @@ export function validateTypeModelErrors(types) {
             for (const [memberName, memberSectionNames] of Object.entries(memberSections)) {
                 if (memberSectionNames.length > 1) {
                     for (const sectionType of memberSectionNames.sort()) {
-                        errors.push([sectionType, memberName, `Redefinition of '${sectionType}' member '${memberName}'`]);
+                        errors.push([sectionType, memberName, `Redefinition of "${sectionType}" member "${memberName}"`]);
                     }
                 }
             }
@@ -256,9 +256,9 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
     // Helper function to push an error tuple
     const error = (message) => {
         if (memberName !== null) {
-            errors.push([typeName, memberName, `${message} from '${typeName}' member '${memberName}'`]);
+            errors.push([typeName, memberName, `${message} from "${typeName}" member "${memberName}"`]);
         } else {
-            errors.push([typeName, null, `${message} from '${typeName}'`]);
+            errors.push([typeName, null, `${message} from "${typeName}"`]);
         }
     };
 
@@ -296,13 +296,13 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
 
         // Unknown user type?
         if (!(userTypeName in types)) {
-            error(`Unknown type '${userTypeName}'`);
+            error(`Unknown type "${userTypeName}"`);
         } else {
             const userType = types[userTypeName];
 
             // Action type references not allowed
             if ('action' in userType) {
-                error(`Invalid reference to action '${userTypeName}'`);
+                error(`Invalid reference to action "${userTypeName}"`);
             }
         }
     }
@@ -324,7 +324,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
             for (const attrKey of Object.keys(disallowedAttr)) {
                 const attrValue = `${attr[attrKey]}`;
                 const attrText = `${attrToText[attrKey]} ${attrValue}`;
-                error(`Invalid attribute '${attrText}'`);
+                error(`Invalid attribute "${attrText}"`);
             }
         }
     }

package/lib/typeModel.js

@@ -108,16 +108,16 @@ struct Array
 # A dictionary type
 struct Dict
 
-    # The contained key type
+    # The contained value type
     Type type
 
-    # The contained key type's attributes
+    # The contained value type's attributes
     optional Attributes attr
 
-    # The contained value type
+    # The contained key type
     optional Type keyType
 
-    # The contained value type's attributes
+    # The contained key type's attributes
     optional Attributes keyAttr
 
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.2.13",
+    "version": "1.3.0",
     "description": "A schema definition and validation library",
     "keywords": [
         "schema",
@@ -26,8 +26,8 @@
     "devDependencies": {
         "@eslint/js": "~10.0",
         "c8": "~11.0",
-        "eslint": "~10.1",
-        "globals": "~17.4",
+        "eslint": "~10.6",
+        "globals": "~17.7",
         "jsdoc": "~4.0"
     }
 }