schema-markdown 1.3.0 → 1.3.2

package/lib/encode.js

@@ -106,11 +106,18 @@ export function decodeQueryString(paramStr) {
                 if (obj === null) {
                     obj = {};
                     parent[keyParent] = obj;
+                } else if (typeof obj !== 'object') {
+                    throw new Error(`Invalid key '${keyFqn.slice(0, 100)}'`);
                 }
 
-                // Create the index for this key
-                if (!(key in obj)) {
-                    obj[key] = null;
+                // Create the index for this key - check own properties only, and define "__proto__"
+                // directly since assignment would invoke the prototype setter
+                if (!Object.hasOwn(obj, key)) {
+                    if (key === '__proto__') {
+                        Object.defineProperty(obj, key, {'value': null, 'enumerable': true, 'writable': true, 'configurable': true});
+                    } else {
+                        obj[key] = null;
+                    }
                 }
             }
 

package/lib/parser.js

@@ -49,6 +49,7 @@ const rValue = new RegExp(`^\\s+(?<id>${rPartId})\\s*$`);
 const rValueQuoted = /^\s+"(?<id>.*?)"\s*$/;
 const rURL = /^\s+(?<method>[A-Za-z]+|\*)(?:\s+(?<path>\/\S*))?/;
 const rLineSplit = /\r?\n/;
+const rIndent = /^\s/;
 
 
 /**
@@ -96,6 +97,9 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         lines.push(...text.split(rLineSplit));
     } else {
         for (const textPart of text) {
+            if (typeof textPart !== 'string') {
+                throw new TypeError(`Invalid Schema Markdown text ${JSON.stringify(textPart)}`.slice(0, 100));
+            }
             lines.push(...textPart.split(rLineSplit));
         }
     }
@@ -107,65 +111,67 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         linenum += 1;
 
         // Line continuation?
-        const linePartNoContinuation = linePart.replace(rLineCont, '');
-        if (lineContinuation.length || linePartNoContinuation !== linePart) {
-            lineContinuation.push(linePartNoContinuation);
-        }
-        if (linePartNoContinuation !== linePart) {
-            continue;
-        }
+        const linePartNoContinuation = linePart.includes('\\') ? linePart.replace(rLineCont, '') : linePart;
         let line;
-        if (lineContinuation.length) {
+        if (linePartNoContinuation === linePart && !lineContinuation.length) {
+            line = linePart;
+        } else {
+            lineContinuation.push(linePartNoContinuation);
+            if (linePartNoContinuation !== linePart) {
+                continue;
+            }
             line = lineContinuation.join('');
             lineContinuation.length = 0;
-        } else {
-            line = linePart;
         }
 
-        // Match syntax
+        // Match syntax - each regex is guarded by a cheap string test that only skips it when it cannot match
+        const lineTrimmed = line.trim();
         let matchName = 'comment';
-        let match = line.match(rComment);
+        let match = (lineTrimmed === '' || lineTrimmed.startsWith('#')) ? line.match(rComment) : null;
+
+        // Not a comment or blank line? Try the remaining syntax
         if (match === null) {
+            const lineIndented = rIndent.test(line);
             matchName = 'group';
-            match = line.match(rGroup);
-        }
-        if (match === null) {
-            matchName = 'action';
-            match = line.match(rAction);
-        }
-        if (match === null) {
-            matchName = 'definition';
-            match = line.match(rDefinition);
-        }
-        if (match === null && action !== null) {
-            matchName = 'section';
-            match = line.match(rSection);
-        }
-        if (match === null && action !== null) {
-            matchName = 'sectionPlain';
-            match = line.match(rSectionPlain);
-        }
-        if (match === null && userType !== null && 'enum' in userType) {
-            matchName = 'value';
-            match = line.match(rValue);
+            match = line.startsWith('group') ? line.match(rGroup) : null;
             if (match === null) {
-                match = line.match(rValueQuoted);
+                matchName = 'action';
+                match = line.startsWith('action') ? line.match(rAction) : null;
+            }
+            if (match === null) {
+                matchName = 'definition';
+                match = (line.startsWith('struct') || line.startsWith('union') || line.startsWith('enum')) ? line.match(rDefinition) : null;
+            }
+            if (match === null && action !== null && lineIndented) {
+                matchName = 'section';
+                match = line.match(rSection);
+            }
+            if (match === null && action !== null && lineIndented) {
+                matchName = 'sectionPlain';
+                match = line.match(rSectionPlain);
+            }
+            if (match === null && userType !== null && 'enum' in userType && lineIndented) {
+                matchName = 'value';
+                match = line.match(rValue);
+                if (match === null) {
+                    match = line.match(rValueQuoted);
+                }
+            }
+            if (match === null && userType !== null && 'struct' in userType && lineIndented) {
+                matchName = 'member';
+                match = line.match(rMember);
+            }
+            if (match === null && urls !== null && lineIndented) {
+                matchName = 'urls';
+                match = line.match(rURL);
+            }
+            if (match === null) {
+                matchName = 'typedef';
+                match = line.startsWith('typedef') ? line.match(rTypedef) : null;
+            }
+            if (match === null) {
+                matchName = null;
             }
-        }
-        if (match === null && userType !== null && 'struct' in userType) {
-            matchName = 'member';
-            match = line.match(rMember);
-        }
-        if (match === null && urls !== null) {
-            matchName = 'urls';
-            match = line.match(rURL);
-        }
-        if (match === null) {
-            matchName = 'typedef';
-            match = line.match(rTypedef);
-        }
-        if (match === null) {
-            matchName = null;
         }
 
         // Comment?
@@ -175,39 +181,36 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
                 doc.push(!docString.startsWith(' ') ? docString : docString.slice(1));
             }
 
-        // Documentation group?
-        } else if (matchName === 'group') {
-            docGroup = match.groups.group;
-            if (typeof docGroup !== 'undefined') {
-                docGroup = docGroup.trim();
-            } else {
-                docGroup = null;
-            }
-
-        // Action?
-        } else if (matchName === 'action') {
-            const actionId = match.groups.id;
+        // Struct member?
+        } else if (matchName === 'member') {
+            const optional = typeof match.groups.optional !== 'undefined';
+            const memberName = match.groups.id;
 
-            // Action already defined?
-            if (actionId in types) {
-                addError(`Redefinition of action '${actionId}'`, filename, linenum);
+            // Add the member
+            const {struct} = userType;
+            if (!('members' in struct)) {
+                struct.members = [];
             }
-
-            // Clear parser state
-            urls = null;
-            userType = null;
-            const actionDoc = getDoc();
-
-            // Create the new action
-            action = {'name': actionId};
-            types[actionId] = {'action': action};
-            if (actionDoc !== null) {
-                action.doc = actionDoc;
+            const [memberType, memberAttr] = parseTypedef(match);
+            const memberDoc = getDoc();
+            const member = {
+                'name': memberName,
+                'type': memberType
+            };
+            struct.members.push(member);
+            if (memberAttr !== null) {
+                member.attr = memberAttr;
             }
-            if (docGroup !== null) {
-                action.docGroup = docGroup;
+            if (memberDoc !== null) {
+                member.doc = memberDoc;
+            }
+            if (optional) {
+                member.optional = true;
             }
 
+            // Record the definition's line number
+            filepos[`${struct.name}.${memberName}`] = linenum;
+
         // Definition?
         } else if (matchName === 'definition') {
             const definitionString = match.groups.type;
@@ -215,7 +218,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const definitionBaseIds = match.groups.baseIds;
 
             // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
                 addError(`Redefinition of type '${definitionId}'`, filename, linenum);
             }
 
@@ -264,6 +267,93 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             // Record the definition's line number
             filepos[definitionId] = linenum;
 
+        // Enum value?
+        } else if (matchName === 'value') {
+            const valueString = match.groups.id;
+
+            // Add the enum value
+            const enum_ = userType.enum;
+            if (!('values' in enum_)) {
+                enum_.values = [];
+            }
+            const enumValue = {'name': valueString};
+            enum_.values.push(enumValue);
+            const enumValueDoc = getDoc();
+            if (enumValueDoc !== null) {
+                enumValue.doc = enumValueDoc;
+            }
+
+            // Record the definition's line number
+            filepos[`${enum_.name}.${valueString}`] = linenum;
+
+        // Typedef?
+        } else if (matchName === 'typedef') {
+            const definitionId = match.groups.id;
+
+            // Type already defined?
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
+                addError(`Redefinition of type '${definitionId}'`, filename, linenum);
+            }
+
+            // Clear parser state
+            action = null;
+            urls = null;
+            userType = null;
+            const typedefDoc = getDoc();
+
+            // Create the typedef
+            const [typedefType, typedefAttr] = parseTypedef(match);
+            const typedef = {
+                'name': definitionId,
+                'type': typedefType
+            };
+            types[definitionId] = {'typedef': typedef};
+            if (typedefAttr !== null) {
+                typedef.attr = typedefAttr;
+            }
+            if (typedefDoc !== null) {
+                typedef.doc = typedefDoc;
+            }
+            if (docGroup !== null) {
+                typedef.docGroup = docGroup;
+            }
+
+            // Record the definition's line number
+            filepos[definitionId] = linenum;
+
+        // Documentation group?
+        } else if (matchName === 'group') {
+            docGroup = match.groups.group;
+            if (typeof docGroup !== 'undefined') {
+                docGroup = docGroup.trim();
+            } else {
+                docGroup = null;
+            }
+
+        // Action?
+        } else if (matchName === 'action') {
+            const actionId = match.groups.id;
+
+            // Action already defined?
+            if (Object.hasOwn(types, actionId)) {
+                addError(`Redefinition of action '${actionId}'`, filename, linenum);
+            }
+
+            // Clear parser state
+            urls = null;
+            userType = null;
+            const actionDoc = getDoc();
+
+            // Create the new action
+            action = {'name': actionId};
+            types[actionId] = {'action': action};
+            if (actionDoc !== null) {
+                action.doc = actionDoc;
+            }
+            if (docGroup !== null) {
+                action.docGroup = docGroup;
+            }
+
         // Action section?
         } else if (matchName === 'section') {
             const sectionString = match.groups.type;
@@ -318,55 +408,6 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
                 action[sectionString] = urls;
             }
 
-        // Enum value?
-        } else if (matchName === 'value') {
-            const valueString = match.groups.id;
-
-            // Add the enum value
-            const enum_ = userType.enum;
-            if (!('values' in enum_)) {
-                enum_.values = [];
-            }
-            const enumValue = {'name': valueString};
-            enum_.values.push(enumValue);
-            const enumValueDoc = getDoc();
-            if (enumValueDoc !== null) {
-                enumValue.doc = enumValueDoc;
-            }
-
-            // Record the definition's line number
-            filepos[`${enum_.name}.${valueString}`] = linenum;
-
-        // Struct member?
-        } else if (matchName === 'member') {
-            const optional = typeof match.groups.optional !== 'undefined';
-            const memberName = match.groups.id;
-
-            // Add the member
-            const {struct} = userType;
-            if (!('members' in struct)) {
-                struct.members = [];
-            }
-            const [memberType, memberAttr] = parseTypedef(match);
-            const memberDoc = getDoc();
-            const member = {
-                'name': memberName,
-                'type': memberType
-            };
-            struct.members.push(member);
-            if (memberAttr !== null) {
-                member.attr = memberAttr;
-            }
-            if (memberDoc !== null) {
-                member.doc = memberDoc;
-            }
-            if (optional) {
-                member.optional = true;
-            }
-
-            // Record the definition's line number
-            filepos[`${struct.name}.${memberName}`] = linenum;
-
         // URL?
         } else if (matchName === 'urls') {
             const {method, path} = match.groups;
@@ -389,41 +430,6 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             // Add the URL
             urls.push(actionUrl);
 
-        // Typedef?
-        } else if (matchName === 'typedef') {
-            const definitionId = match.groups.id;
-
-            // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
-                addError(`Redefinition of type '${definitionId}'`, filename, linenum);
-            }
-
-            // Clear parser state
-            action = null;
-            urls = null;
-            userType = null;
-            const typedefDoc = getDoc();
-
-            // Create the typedef
-            const [typedefType, typedefAttr] = parseTypedef(match);
-            const typedef = {
-                'name': definitionId,
-                'type': typedefType
-            };
-            types[definitionId] = {'typedef': typedef};
-            if (typedefAttr !== null) {
-                typedef.attr = typedefAttr;
-            }
-            if (typedefDoc !== null) {
-                typedef.doc = typedefDoc;
-            }
-            if (docGroup !== null) {
-                typedef.docGroup = docGroup;
-            }
-
-            // Record the definition's line number
-            filepos[definitionId] = linenum;
-
         // Unrecognized line syntax
         } else {
             addError('Syntax error', filename, linenum);
@@ -449,7 +455,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
                 errorLinenum = filepos[`${typeName}.${memberName}`] ?? null;
             }
             if (errorLinenum === null) {
-                errorLinenum = filepos[typeName] ?? null;
+                errorLinenum = Object.hasOwn(filepos, typeName) ? filepos[typeName] : null;
             }
             if (errorLinenum === null) {
                 errorFilename = '';
@@ -527,7 +533,7 @@ function parseTypedef(matchTypedef) {
 
 // Helper function to create a type model
 function createType(typeName) {
-    if (typeName in builtinDeprecated) {
+    if (Object.hasOwn(builtinDeprecated, typeName)) {
         return {'builtin': builtinDeprecated[typeName]};
     }
     if (builtinTypes.has(typeName)) {

package/lib/schema.js

@@ -39,9 +39,9 @@ function getReferencedTypesHelper(types, type, referencedTypes) {
         const typeName = type.user;
 
         // Already encountered?
-        if (!(typeName in referencedTypes)) {
-            const userType = types[typeName];
-            referencedTypes[typeName] = userType;
+        if (!Object.hasOwn(referencedTypes, typeName)) {
+            const userType = getUserType(types, typeName);
+            setValue(referencedTypes, typeName, userType);
 
             // Struct?
             if ('struct' in userType) {
@@ -116,6 +116,27 @@ export class ValidationError extends Error {
 }
 
 
+// Helper to look up a user type by name - throws ValidationError for unknown type names
+function getUserType(types, typeName) {
+    const userType = Object.hasOwn(types, typeName) ? types[typeName] : null;
+    if (userType === null) {
+        throw new ValidationError(`Unknown type "${typeName}"`);
+    }
+    return userType;
+}
+
+
+// Helper to set an own property on a plain-object copy - the "__proto__" key is defined directly
+// since assignment would invoke the inherited prototype setter instead of creating an own property
+function setValue(obj, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(obj, key, {'value': value, 'enumerable': true, 'writable': true, 'configurable': true});
+    } else {
+        obj[key] = value;
+    }
+}
+
+
 /**
  * Type-validate a value using a user type model. Container values are duplicated since some member types are
  * transformed during validation.
@@ -134,9 +155,6 @@ export class ValidationError extends Error {
  * @throws [ValidationError]{@link module:lib/schema.ValidationError}
  */
 export function validateType(types, typeName, value, memberFqn = null) {
-    if (!(typeName in types)) {
-        throw new ValidationError(`Unknown type "${typeName}"`);
-    }
     return validateTypeHelper(types, {'user': typeName}, value, memberFqn);
 }
 
@@ -147,6 +165,10 @@ const rDatetime = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T\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;
 
 
+// Default dict key type used by validateTypeHelper
+const defaultDictKeyType = {'builtin': 'string'};
+
+
 function validateTypeHelper(types, type, value, memberFqn) {
     let valueNew = value;
 
@@ -161,23 +183,14 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 throwMemberError(type, value, memberFqn);
             }
 
-        // uuid?
-        } else if (builtin === 'uuid') {
-            if (typeof value !== 'string') {
-                throwMemberError(type, value, memberFqn);
-            }
-            if (!rUuid.test(value)) {
-                throwMemberError(type, value, memberFqn);
-            }
-
         // int or float?
         } else if (builtin === 'int' || builtin === 'float') {
             // Convert string?
             if (typeof value === 'string') {
-                if (isNaN(value)) {
+                valueNew = parseFloat(value);
+                if (isNaN(value) || !Number.isFinite(valueNew)) {
                     throwMemberError(type, value, memberFqn);
                 }
-                valueNew = parseFloat(value);
 
             // Not a number?
             } else if (typeof value !== 'number') {
@@ -253,89 +266,20 @@ function validateTypeHelper(types, type, value, memberFqn) {
             } else if (!(value instanceof Date)) {
                 throwMemberError(type, value, memberFqn);
             }
-        }
-
-    // array?
-    } else if ('array' in type) {
-        // Valid value type?
-        const {array} = type;
-        const arrayType = array.type;
-        const arrayAttr = 'attr' in array ? array.attr : null;
-        if (value === '') {
-            valueNew = [];
-        } else if (!Array.isArray(value)) {
-            throwMemberError(type, value, memberFqn);
-        }
-
-        // Validate the list contents
-        const valueCopy = [];
-        const arrayValueNullable = arrayAttr !== null && 'nullable' in arrayAttr && arrayAttr.nullable;
-        for (let ixArrayValue = 0; ixArrayValue < valueNew.length; ixArrayValue++) {
-            const memberFqnValue = memberFqn !== null ? `${memberFqn}.${ixArrayValue}` : `${ixArrayValue}`;
-            let arrayValue = valueNew[ixArrayValue];
-            if (arrayValueNullable && (arrayValue === null || arrayValue === 'null')) {
-                arrayValue = null;
-            } else {
-                arrayValue = validateTypeHelper(types, arrayType, arrayValue, memberFqnValue);
-                validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
-            }
-            valueCopy.push(arrayValue);
-        }
-
-        // Return the validated, transformed copy
-        valueNew = valueCopy;
-
-    // dict?
-    } else if ('dict' in type) {
-        // Valid value type?
-        const {dict} = type;
-        const dictType = dict.type;
-        const dictAttr = 'attr' in dict ? dict.attr : null;
-        const dictKeyType = 'keyType' in dict ? dict.keyType : {'builtin': 'string'};
-        const dictKeyAttr = 'keyAttr' in dict ? dict.keyAttr : null;
-        if (value === '') {
-            valueNew = {};
-        } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-            throwMemberError(type, value, memberFqn);
-        }
-
-        // Validate the dict key/value pairs
-        const valueCopy = valueNew instanceof Map ? new Map() : {};
-        const dictKeyNullable = dictKeyAttr !== null && 'nullable' in dictKeyAttr && dictKeyAttr.nullable;
-        const dictValueNullable = dictAttr !== null && 'nullable' in dictAttr && dictAttr.nullable;
-        for (let [dictKey, dictValue] of (valueNew instanceof Map ? valueNew.entries() : Object.entries(valueNew))) {
-            const memberFqnKey = memberFqn !== null ? `${memberFqn}.${dictKey}` : `${dictKey}`;
 
-            // Validate the key
-            if (dictKeyNullable && (dictKey === null || dictKey === 'null')) {
-                dictKey = null;
-            } else {
-                dictKey = validateTypeHelper(types, dictKeyType, dictKey, memberFqn);
-                validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
-            }
-
-            // Validate the value
-            if (dictValueNullable && (dictValue === null || dictValue === 'null')) {
-                dictValue = null;
-            } else {
-                dictValue = validateTypeHelper(types, dictType, dictValue, memberFqnKey);
-                validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+        // uuid?
+        } else if (builtin === 'uuid') {
+            if (typeof value !== 'string') {
+                throwMemberError(type, value, memberFqn);
             }
-
-            // Copy the key/value
-            if (valueCopy instanceof Map) {
-                valueCopy.set(dictKey, dictValue);
-            } else {
-                valueCopy[dictKey] = dictValue;
+            if (!rUuid.test(value)) {
+                throwMemberError(type, value, memberFqn);
             }
         }
 
-        // Return the validated, transformed copy
-        valueNew = valueCopy;
-
     // User type?
     } else if ('user' in type) {
-        const userType = types[type.user];
+        const userType = getUserType(types, type.user);
 
         // action?
         if ('action' in userType) {
@@ -353,7 +297,9 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 valueNew = null;
             } else {
                 valueNew = validateTypeHelper(types, typedef.type, value, memberFqn);
-                validateAttr(type, typedefAttr, valueNew, memberFqn);
+                if (typedefAttr !== null) {
+                    validateAttr(type, typedefAttr, valueNew, memberFqn);
+                }
             }
 
         // enum?
@@ -377,94 +323,209 @@ function validateTypeHelper(types, type, value, memberFqn) {
             }
 
             // Valid union?
+            const isMap = valueNew instanceof Map;
             const isUnion = 'union' in struct ? struct.union : false;
             if (isUnion) {
-                if (Object.keys(value).length !== 1) {
+                if ((isMap ? valueNew.size : Object.keys(valueNew).length) !== 1) {
                     throwMemberError({'user': struct.name}, value, memberFqn);
                 }
             }
 
             // Validate the struct members
-            const valueCopy = valueNew instanceof Map ? new Map() : {};
+            const valueCopy = isMap ? new Map() : {};
             for (const member of getStructMembers(types, struct)) {
                 const memberName = member.name;
-                const memberFqnMember = memberFqn !== null ? `${memberFqn}.${memberName}` : `${memberName}`;
+                const memberFqnMember = [memberFqn, memberName];
                 const memberOptional = 'optional' in member && member.optional;
-                const memberNullable = 'attr' in member && 'nullable' in member.attr && member.attr.nullable;
+                const memberAttr = 'attr' in member ? member.attr : null;
 
-                // Missing non-optional member?
-                if (!(valueNew instanceof Map ? valueNew.has(memberName) : memberName in valueNew)) {
+                // Missing non-optional member? Check own properties only - "in" matches inherited
+                // Object.prototype properties for member names like "constructor"
+                if (!(isMap ? valueNew.has(memberName) : Object.hasOwn(valueNew, memberName))) {
                     if (!memberOptional && !isUnion) {
-                        throw new ValidationError(`Required member "${memberFqnMember}" missing`);
+                        throw new ValidationError(`Required member "${memberFqnStr(memberFqnMember)}" missing`);
                     }
                 } else {
                     // Validate the member value
-                    let memberValue = valueNew instanceof Map ? valueNew.get(memberName) : valueNew[memberName];
-                    if (memberNullable && (memberValue === null || memberValue === 'null')) {
+                    let memberValue = isMap ? valueNew.get(memberName) : valueNew[memberName];
+
+                    // No member attributes? Validate the member value directly
+                    if (memberAttr === null) {
+                        memberValue = validateTypeHelper(types, member.type, memberValue, memberFqnMember);
+
+                    // Nullable null?
+                    } else if ('nullable' in memberAttr && memberAttr.nullable &&
+                               (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, memberAttr, memberValue, memberFqnMember);
                     }
 
                     // Copy the validated member
-                    if (valueCopy instanceof Map) {
+                    if (isMap) {
                         valueCopy.set(memberName, memberValue);
                     } else {
-                        valueCopy[memberName] = memberValue;
+                        setValue(valueCopy, memberName, memberValue);
                     }
                 }
             }
 
             // Any unknown members?
-            const valueCopyKeys = valueCopy instanceof Map ? Array.from(valueCopy.keys()) : Object.keys(valueCopy);
-            const valueNewKeys = valueNew instanceof Map ? Array.from(valueNew.keys()) : Object.keys(valueNew);
-            if (valueCopyKeys.length !== valueNewKeys.length) {
+            const valueCopyCount = isMap ? valueCopy.size : Object.keys(valueCopy).length;
+            const valueNewCount = isMap ? valueNew.size : Object.keys(valueNew).length;
+            if (valueCopyCount !== valueNewCount) {
                 const memberSet = new Set(getStructMembers(types, struct).map((member) => member.name));
+                const valueNewKeys = isMap ? Array.from(valueNew.keys()) : Object.keys(valueNew);
                 const [unknownKey] = valueNewKeys.filter((key) => !memberSet.has(key));
-                const unknownFqn = memberFqn !== null ? `${memberFqn}.${unknownKey}` : `${unknownKey}`;
+                const unknownFqn = memberFqnStr([memberFqn, unknownKey]);
                 throw new ValidationError(`Unknown member "${unknownFqn.slice(0, 100)}"`);
             }
 
             // Return the validated, transformed copy
             valueNew = valueCopy;
         }
+
+    // array?
+    } else if ('array' in type) {
+        // Valid value type?
+        const {array} = type;
+        const arrayType = array.type;
+        const arrayAttr = 'attr' in array ? array.attr : null;
+        if (value === '') {
+            valueNew = [];
+        } else if (!Array.isArray(value)) {
+            throwMemberError(type, value, memberFqn);
+        }
+
+        // Validate the list contents
+        const valueCopy = [];
+        const arrayValueNullable = arrayAttr !== null && 'nullable' in arrayAttr && arrayAttr.nullable;
+        for (let ixArrayValue = 0; ixArrayValue < valueNew.length; ixArrayValue++) {
+            const memberFqnValue = [memberFqn, ixArrayValue];
+            let arrayValue = valueNew[ixArrayValue];
+            if (arrayValueNullable && (arrayValue === null || arrayValue === 'null')) {
+                arrayValue = null;
+            } else {
+                arrayValue = validateTypeHelper(types, arrayType, arrayValue, memberFqnValue);
+                if (arrayAttr !== null) {
+                    validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
+                }
+            }
+            valueCopy.push(arrayValue);
+        }
+
+        // Return the validated, transformed copy
+        valueNew = valueCopy;
+
+    // dict?
+    } else if ('dict' in type) {
+        // Valid value type?
+        const {dict} = type;
+        const dictType = dict.type;
+        const dictAttr = 'attr' in dict ? dict.attr : null;
+        const dictKeyType = 'keyType' in dict ? dict.keyType : defaultDictKeyType;
+        const dictKeyAttr = 'keyAttr' in dict ? dict.keyAttr : null;
+        if (value === '') {
+            valueNew = {};
+        } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throwMemberError(type, value, memberFqn);
+        }
+
+        // Validate the dict key/value pairs
+        const isMap = valueNew instanceof Map;
+        const valueCopy = isMap ? new Map() : {};
+        const dictKeyNullable = dictKeyAttr !== null && 'nullable' in dictKeyAttr && dictKeyAttr.nullable;
+        const dictValueNullable = dictAttr !== null && 'nullable' in dictAttr && dictAttr.nullable;
+        for (let [dictKey, dictValue] of (isMap ? valueNew.entries() : Object.entries(valueNew))) {
+            const memberFqnKey = [memberFqn, dictKey];
+
+            // Validate the key
+            if (dictKeyNullable && (dictKey === null || dictKey === 'null')) {
+                dictKey = null;
+            } else {
+                dictKey = validateTypeHelper(types, dictKeyType, dictKey, memberFqn);
+                if (dictKeyAttr !== null) {
+                    validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
+                }
+            }
+
+            // Validate the value
+            if (dictValueNullable && (dictValue === null || dictValue === 'null')) {
+                dictValue = null;
+            } else {
+                dictValue = validateTypeHelper(types, dictType, dictValue, memberFqnKey);
+                if (dictAttr !== null) {
+                    validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+                }
+            }
+
+            // Copy the key/value
+            if (isMap) {
+                valueCopy.set(dictKey, dictValue);
+            } else {
+                setValue(valueCopy, dictKey, dictValue);
+            }
+        }
+
+        // Return the validated, transformed copy
+        valueNew = valueCopy;
     }
 
     return valueNew;
 }
 
 
+// Helper to materialize a member's fully-qualified name string. For performance, member FQNs are
+// built lazily as [parent, key] pairs and only converted to strings on error.
+function memberFqnStr(memberFqn) {
+    if (memberFqn === null || typeof memberFqn === 'string') {
+        return memberFqn;
+    }
+    const parts = [];
+    let fqnPart = memberFqn;
+    while (Array.isArray(fqnPart)) {
+        parts.push(`${fqnPart[1]}`);
+        [fqnPart] = fqnPart;
+    }
+    if (fqnPart !== null) {
+        parts.push(`${fqnPart}`);
+    }
+    parts.reverse();
+    return parts.join('.');
+}
+
+
 function throwMemberError(type, value, memberFqn, attr = null) {
-    const memberPart = memberFqn !== null ? ` for member "${memberFqn}"` : '';
+    const memberFqnValue = memberFqnStr(memberFqn);
+    const memberPart = memberFqnValue ? ` for member "${memberFqnValue}"` : '';
     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}`;
-    throw new ValidationError(msg, memberFqn);
+    throw new ValidationError(msg, memberFqnValue);
 }
 
 
 function validateAttr(type, attr, value, memberFqn) {
-    if (attr !== null) {
+    if ('eq' in attr && !(value === attr.eq)) {
+        throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
+    }
+    if ('lt' in attr && !(value < attr.lt)) {
+        throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
+    }
+    if ('lte' in attr && !(value <= attr.lte)) {
+        throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
+    }
+    if ('gt' in attr && !(value > attr.gt)) {
+        throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
+    }
+    if ('gte' in attr && !(value >= attr.gte)) {
+        throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
+    }
+    if ('lenEq' in attr || 'lenLT' in attr || 'lenLTE' in attr || 'lenGT' in attr || 'lenGTE' in attr) {
         const length = Array.isArray(value) || typeof value === 'string' ? value.length
-            : (typeof value === 'object' ? Object.keys(value).length : null);
-
-        if ('eq' in attr && !(value === attr.eq)) {
-            throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
-        }
-        if ('lt' in attr && !(value < attr.lt)) {
-            throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
-        }
-        if ('lte' in attr && !(value <= attr.lte)) {
-            throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
-        }
-        if ('gt' in attr && !(value > attr.gt)) {
-            throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
-        }
-        if ('gte' in attr && !(value >= attr.gte)) {
-            throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
-        }
+            : (value instanceof Map ? value.size : (typeof value === 'object' ? Object.keys(value).length : null));
         if ('lenEq' in attr && !(length === attr.lenEq)) {
             throwMemberError(type, value, memberFqn, `len == ${attr.lenEq}`);
         }
@@ -501,9 +562,9 @@ export function getStructMembers(types, struct) {
     // Get base struct members
     const members = [];
     for (const base of struct.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         members.push(...getStructMembers(types, baseUserType.struct));
     }
@@ -534,9 +595,9 @@ export function getEnumValues(types, enum_) {
     // Get base enum values
     const values = [];
     for (const base of enum_.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         values.push(...getEnumValues(types, baseUserType.enum));
     }

package/lib/schemaUtil.js

@@ -43,13 +43,13 @@ export function validateTypeModelErrors(types) {
 
             // Iterate the members
             try {
-                const members = {};
+                const members = new Set();
                 for (const member of getStructMembers(types, struct)) {
                     const memberName = member.name;
 
                     // Duplicate member?
-                    if (!(memberName in members)) {
-                        members[memberName] = true;
+                    if (!members.has(memberName)) {
+                        members.add(memberName);
                     } else {
                         errors.push([typeName, memberName, `Redefinition of "${typeName}" member "${memberName}"`]);
                     }
@@ -82,13 +82,13 @@ export function validateTypeModelErrors(types) {
 
             // Get the enumeration values
             try {
-                const values = {};
+                const values = new Set();
                 for (const value of getEnumValues(types, enum_)) {
                     const valueName = value.name;
 
                     // Duplicate value?
-                    if (!(valueName in values)) {
-                        values[valueName] = true;
+                    if (!values.has(valueName)) {
+                        values.add(valueName);
                     } else {
                         errors.push([typeName, valueName, `Redefinition of "${typeName}" value "${valueName}"`]);
                     }
@@ -106,6 +106,23 @@ export function validateTypeModelErrors(types) {
                 errors.push([typeName, null, `Inconsistent type name "${typedef.name}" for "${typeName}"`]);
             }
 
+            // Circular typedef?
+            const visited = new Set([typeName]);
+            let typedefType = typedef.type;
+            while ('user' in typedefType) {
+                const typedefUserName = typedefType.user;
+                const typedefUserType = Object.hasOwn(types, typedefUserName) ? types[typedefUserName] : null;
+                if (typedefUserType === null || !('typedef' in typedefUserType)) {
+                    break;
+                }
+                if (visited.has(typedefUserName)) {
+                    errors.push([typeName, null, `Circular typedef detected for type "${typeName}"`]);
+                    break;
+                }
+                visited.add(typedefUserName);
+                typedefType = typedefUserType.typedef.type;
+            }
+
             // Check the type and its attributes
             validateTypeModelType(errors, types, typedef.type, 'attr' in typedef ? typedef.attr : null, typeName, null);
 
@@ -129,11 +146,11 @@ export function validateTypeModelErrors(types) {
             }
 
             // Compute effective input member counts
-            const memberSections = {};
+            const memberSections = new Map();
             for (const section of ['path', 'query', 'input']) {
                 if (section in action) {
                     const sectionTypeName = action[section];
-                    if (sectionTypeName in types) {
+                    if (Object.hasOwn(types, sectionTypeName)) {
                         const sectionUserType = getEffectiveUserType(types, sectionTypeName);
                         if (sectionUserType !== null && 'struct' in sectionUserType) {
                             const sectionStruct = sectionUserType.struct;
@@ -142,10 +159,10 @@ export function validateTypeModelErrors(types) {
                             try {
                                 for (const member of getStructMembers(types, sectionStruct)) {
                                     const memberName = member.name;
-                                    if (!(memberName in memberSections)) {
-                                        memberSections[memberName] = [];
+                                    if (!memberSections.has(memberName)) {
+                                        memberSections.set(memberName, []);
                                     }
-                                    memberSections[memberName].push(sectionStruct.name);
+                                    memberSections.get(memberName).push(sectionStruct.name);
                                 }
                             } catch {
                                 // Do nothing
@@ -156,7 +173,7 @@ export function validateTypeModelErrors(types) {
             }
 
             // Check for duplicate input members
-            for (const [memberName, memberSectionNames] of Object.entries(memberSections)) {
+            for (const [memberName, memberSectionNames] of memberSections.entries()) {
                 if (memberSectionNames.length > 1) {
                     for (const sectionType of memberSectionNames.sort()) {
                         errors.push([sectionType, memberName, `Redefinition of "${sectionType}" member "${memberName}"`]);
@@ -170,11 +187,12 @@ export function validateTypeModelErrors(types) {
 }
 
 
-function getEffectiveType(types, type) {
-    if ('user' in type && type.user in types) {
+function getEffectiveType(types, type, visited = new Set()) {
+    if ('user' in type && Object.hasOwn(types, type.user) && !visited.has(type.user)) {
         const userType = types[type.user];
         if ('typedef' in userType) {
-            return getEffectiveType(types, userType.typedef.type);
+            visited.add(type.user);
+            return getEffectiveType(types, userType.typedef.type, visited);
         }
     }
     return type;
@@ -182,24 +200,24 @@ function getEffectiveType(types, type) {
 
 
 function getEffectiveUserType(types, userTypeName) {
-    const userType = userTypeName in types ? types[userTypeName] : null;
+    const userType = Object.hasOwn(types, userTypeName) ? types[userTypeName] : null;
     if (userType !== null && 'typedef' in userType) {
         const typeEffective = getEffectiveType(types, userType.typedef.type);
         if (!('user' in typeEffective)) {
             return null;
         }
-        return typeEffective.user in types ? types[typeEffective.user] : null;
+        return Object.hasOwn(types, typeEffective.user) ? types[typeEffective.user] : null;
     }
     return userType;
 }
 
 
-function getStructMembers(types, struct, visited = {}) {
+function getStructMembers(types, struct, visited = new Set()) {
     return getTypeItems(types, struct, visited, 'struct', 'members');
 }
 
 
-function getEnumValues(types, enum_, visited = {}) {
+function getEnumValues(types, enum_, visited = new Set()) {
     return getTypeItems(types, enum_, visited, 'enum', 'values');
 }
 
@@ -211,8 +229,8 @@ function getTypeItems(types, type, visited, defName, memberName) {
             const userType = getEffectiveUserType(types, base);
             if (userType !== null && defName in userType) {
                 const userTypeName = userType[defName].name;
-                if (!(userTypeName in visited)) {
-                    visited[userTypeName] = true;
+                if (!visited.has(userTypeName)) {
+                    visited.add(userTypeName);
                     items.push(...getTypeItems(types, userType[defName], visited, defName, memberName));
                 } else {
                     throw new TypeError();
@@ -285,7 +303,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
 
             // Valid dict key type (string or enum)
             if (!('builtin' in dictKeyType && dictKeyType.builtin === 'string') &&
-                !('user' in dictKeyType && dictKeyType.user in types && 'enum' in types[dictKeyType.user])) {
+                !('user' in dictKeyType && Object.hasOwn(types, dictKeyType.user) && 'enum' in types[dictKeyType.user])) {
                 error('Invalid dictionary key type');
             }
         }
@@ -295,7 +313,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const userTypeName = type.user;
 
         // Unknown user type?
-        if (!(userTypeName in types)) {
+        if (!Object.hasOwn(types, userTypeName)) {
             error(`Unknown type "${userTypeName}"`);
         } else {
             const userType = types[userTypeName];
@@ -312,7 +330,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const typeEffective = getEffectiveType(types, type);
         const [typeKey] = Object.keys(typeEffective);
         const typeAttrKey = typeKey === 'builtin' ? typeEffective[typeKey] : typeKey;
-        const allowedAttr = typeAttrKey in typeToAllowedAttr ? typeToAllowedAttr[typeAttrKey] : null;
+        const allowedAttr = Object.hasOwn(typeToAllowedAttr, typeAttrKey) ? typeToAllowedAttr[typeAttrKey] : null;
         const disallowedAttr = Object.fromEntries(Object.keys(attr).map((attrKey) => [attrKey, null]));
         delete disallowedAttr.nullable;
         if (allowedAttr !== null) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "description": "A schema definition and validation library",
     "keywords": [
         "schema",