@malloydata/malloy-tag 0.0.339 → 0.0.340

package/dist/schema.spec.js

@@ -1,980 +0,0 @@
-"use strict";
-/*
- * Copyright Contributors to the Malloy project
- * SPDX-License-Identifier: MIT
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const peggy_1 = require("./peggy");
-const schema_1 = require("./schema");
-// Load the meta-schema from file
-const metaSchemaPath = path.join(__dirname, 'motly-schema.motly');
-const metaSchemaSource = fs.readFileSync(metaSchemaPath, 'utf-8');
-const { tag: metaSchema, log: metaSchemaLog } = (0, peggy_1.parseTag)(metaSchemaSource);
-// Fail fast if meta-schema has parse errors
-if (metaSchemaLog.length > 0) {
-    throw new Error(`Meta-schema failed to parse:\n${metaSchemaLog.map(e => e.message).join('\n')}`);
-}
-describe('schema validation', () => {
-    describe('missing required properties', () => {
-        test('errors when required property is missing', () => {
-            const { tag } = (0, peggy_1.parseTag)('');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Missing required property 'name'",
-                path: ['name'],
-                code: 'missing-required',
-            });
-        });
-        test('errors for multiple missing required properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(2);
-            expect(errors.map(e => e.path)).toEqual([['name'], ['age']]);
-        });
-        test('errors for missing nested required property', () => {
-            const { tag } = (0, peggy_1.parseTag)('size { width=10 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { size: { Required: { width=number height=number } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Missing required property 'height'",
-                path: ['size', 'height'],
-                code: 'missing-required',
-            });
-        });
-    });
-    describe('wrong type errors', () => {
-        test('errors when string expected but number provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Property 'name' has wrong type: expected 'string', got 'number'",
-                path: ['name'],
-                code: 'wrong-type',
-            });
-        });
-        test('errors when number expected but string provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('age=hello');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Property 'age' has wrong type: expected 'number', got 'string'",
-                path: ['age'],
-                code: 'wrong-type',
-            });
-        });
-        test('errors when boolean expected but string provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('enabled=yes');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { enabled=boolean }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'boolean'");
-        });
-        test('errors when date expected but string provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('created=yesterday');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { created=date }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'date'");
-        });
-        test('errors when tag expected but scalar provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('config=value');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { config=tag }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'tag'");
-        });
-        test('validates tag type correctly', () => {
-            const { tag } = (0, peggy_1.parseTag)('config { a=1 b=2 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { config=tag }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('validates flag type correctly', () => {
-            const { tag } = (0, peggy_1.parseTag)('hidden readonly');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { hidden=flag readonly=flag }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('errors when flag expected but scalar provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('hidden=@true');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { hidden=flag }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'flag'");
-            expect(errors[0].message).toContain("got 'boolean'");
-        });
-        test('errors when flag expected but tag with properties provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('hidden { x=1 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { hidden=flag }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'flag'");
-            expect(errors[0].message).toContain("got 'tag'");
-        });
-        test('optional flag works when present', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=test deprecated');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: { name=string }
-        Optional: { deprecated=flag }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('optional flag works when absent', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=test');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: { name=string }
-        Optional: { deprecated=flag }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('unknown property errors', () => {
-        test('errors on unknown property', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice unknown=value');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Unknown property 'unknown'",
-                path: ['unknown'],
-                code: 'unknown-property',
-            });
-        });
-        test('allows unknown properties with Additional flag', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice extra=value');
-            const { tag: schema } = (0, peggy_1.parseTag)('Additional Required: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('errors on unknown nested property', () => {
-            const { tag } = (0, peggy_1.parseTag)('size { width=10 extra=5 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { size: { Required: { width=number } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Unknown property 'extra'",
-                path: ['size', 'extra'],
-                code: 'unknown-property',
-            });
-        });
-    });
-    describe('valid tags pass validation', () => {
-        test('valid tag with required properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice age=30');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('valid tag with optional properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string } Optional: { age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('valid tag with optional property present', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice age=30');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string } Optional: { age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('valid nested properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('size { width=100 height=200 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { size: { Required: { width=number height=number } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('array type validation', () => {
-        test('validates string[] type', () => {
-            const { tag } = (0, peggy_1.parseTag)('colors=[red, green, blue]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { colors="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('errors when string[] expected but number[] provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('values=[1, 2, 3]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { values="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'string[]'");
-            expect(errors[0].message).toContain("got 'number[]'");
-        });
-        test('validates number[] type', () => {
-            const { tag } = (0, peggy_1.parseTag)('counts=[1, 2, 3]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { counts="number[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('validates boolean[] type', () => {
-            const { tag } = (0, peggy_1.parseTag)('flags=[@true, @false, @true]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { flags="boolean[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('validates date[] type', () => {
-            const { tag } = (0, peggy_1.parseTag)('dates=[@2024-01-01, @2024-02-01]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { dates="date[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any[] accepts any array', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[1, 2, 3]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="any[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('errors when array expected but scalar provided', () => {
-            const { tag } = (0, peggy_1.parseTag)('colors=red');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { colors="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-        });
-        test('empty array matches any array type', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('any type validation', () => {
-        test('any accepts string', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=hello');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts number', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts boolean', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=@true');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts date', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=@2024-01-15');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts tag', () => {
-            const { tag } = (0, peggy_1.parseTag)('value { a=1 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts array', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=[1, 2, 3]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('any accepts flag', () => {
-            const { tag } = (0, peggy_1.parseTag)('value');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { value=any }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('full form type syntax', () => {
-        test('validates with type in full form', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name: { Type=string } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('validates nested with full form', () => {
-            const { tag } = (0, peggy_1.parseTag)('person { name=alice age=30 }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: {
-          person: {
-            Type=tag
-            Required: {
-              name=string
-              age=number
-            }
-          }
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('errors on type mismatch with full form', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name: { Type=string } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-        });
-    });
-    describe('optional property type validation', () => {
-        test('validates type of optional property when present', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice age=notanumber');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string } Optional: { age=number }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0]).toEqual({
-                message: "Property 'age' has wrong type: expected 'number', got 'string'",
-                path: ['age'],
-                code: 'wrong-type',
-            });
-        });
-    });
-    describe('complex schemas', () => {
-        test('validates complex nested schema', () => {
-            const { tag } = (0, peggy_1.parseTag)(`
-        config {
-          database {
-            host=localhost
-            port=5432
-          }
-          features {
-            enabled=@true
-            flags=[@true, @false]
-          }
-        }
-      `);
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: {
-          config: {
-            Required: {
-              database: {
-                Required: {
-                  host=string
-                  port=number
-                }
-              }
-              features: {
-                Required: {
-                  enabled=boolean
-                }
-                Optional: {
-                  flags="boolean[]"
-                }
-              }
-            }
-          }
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('collects multiple errors from complex schema', () => {
-            const { tag } = (0, peggy_1.parseTag)(`
-        config {
-          database {
-            host=123
-          }
-          extra=bad
-        }
-      `);
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: {
-          config: {
-            Required: {
-              database: {
-                Required: {
-                  host=string
-                  port=number
-                }
-              }
-            }
-          }
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            // Should have: wrong type for host, missing port, unknown extra
-            expect(errors.length).toBeGreaterThanOrEqual(3);
-            expect(errors.map(e => e.code)).toContain('wrong-type');
-            expect(errors.map(e => e.code)).toContain('missing-required');
-            expect(errors.map(e => e.code)).toContain('unknown-property');
-        });
-    });
-    describe('edge cases', () => {
-        test('empty tag against schema with only optional properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('');
-            const { tag: schema } = (0, peggy_1.parseTag)('Optional: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('empty schema passes any tag', () => {
-            const { tag } = (0, peggy_1.parseTag)('anything=goes here=too');
-            const { tag: schema } = (0, peggy_1.parseTag)('');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            // Empty schema = no rules = all lawful
-            expect(errors).toHaveLength(0);
-        });
-        test('empty schema with Additional passes any tag', () => {
-            const { tag } = (0, peggy_1.parseTag)('anything=goes here=too');
-            const { tag: schema } = (0, peggy_1.parseTag)('Additional');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('property with no type in schema allows any value', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            // No type specified, so any value is OK
-            expect(errors).toHaveLength(0);
-        });
-        test('mixed array reports as mixed type', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[1, hello, @true]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("got 'mixed[]'");
-        });
-        test('any[] accepts mixed arrays', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[1, hello, @true]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="any[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('value with properties validates only value type', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice { extra=1 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=string }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            // Only value type is checked; nested properties aren't validated
-            // unless schema has required/optional sections
-            expect(errors).toHaveLength(0);
-        });
-        test('value with properties and nested schema (full form)', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice { extra=1 }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: {
-          name: {
-            Type=string
-            Optional: { extra=number }
-          }
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('value with properties and nested schema (shorthand)', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice { extra=1 }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: {
-          name=string { Optional: { extra=number } }
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('arrays of objects have tag element type', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{a=1}, {b=2}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="string[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("got 'tag[]'");
-        });
-        test('tag[] validates arrays of objects', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{a=1}, {b=2}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('tag[] rejects arrays of scalars', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[1, 2, 3]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'tag[]'");
-        });
-        test('tag[] with element schema validates each element', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{size=10 color=red}, {size=20 color=blue}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" { Required: { size=number color=string } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('tag[] element schema reports errors with index in path', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{size=10 color=red}, {size=bad color=blue}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" { Required: { size=number color=string } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].path).toEqual(['items', '1', 'size']);
-        });
-        test('tag[] element schema catches missing required', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{size=10}, {color=blue}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" { Required: { size=number color=string } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(2);
-            expect(errors[0].path).toEqual(['items', '0', 'color']);
-            expect(errors[1].path).toEqual(['items', '1', 'size']);
-        });
-        test('tag[] element schema catches unknown properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('items=[{size=10 color=red extra=bad}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { items="tag[]" { Required: { size=number color=string } } }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('unknown-property');
-            expect(errors[0].path).toEqual(['items', '0', 'extra']);
-        });
-        test('misspelled type in schema reports invalid-schema error', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name=stirng }'); // typo
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-schema');
-            expect(errors[0].message).toContain("Invalid type 'stirng'");
-        });
-        test('invalid type in full form reports invalid-schema error', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=42');
-            const { tag: schema } = (0, peggy_1.parseTag)('Required: { name: { Type=nubmer } }'); // typo
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-schema');
-            expect(errors[0].message).toContain("Invalid type 'nubmer'");
-        });
-    });
-    describe('custom types', () => {
-        test('validates using custom type reference', () => {
-            const { tag } = (0, peggy_1.parseTag)('person { name=alice age=30 }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          personType: {
-            Required: { name=string age=number }
-          }
-        }
-        Required: { person=personType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('reports error when custom type validation fails', () => {
-            const { tag } = (0, peggy_1.parseTag)('person { name=alice }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          personType: {
-            Required: { name=string age=number }
-          }
-        }
-        Required: { person=personType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('missing-required');
-            expect(errors[0].path).toEqual(['person', 'age']);
-        });
-        test('validates array of custom type', () => {
-            const { tag } = (0, peggy_1.parseTag)('people=[{name=alice age=30}, {name=bob age=25}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Types: { personType: { Required: { name=string age=number } } } Required: { people="personType[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('reports error in array of custom type with index', () => {
-            const { tag } = (0, peggy_1.parseTag)('people=[{name=alice age=30}, {name=bob}]');
-            const { tag: schema } = (0, peggy_1.parseTag)('Types: { personType: { Required: { name=string age=number } } } Required: { people="personType[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('missing-required');
-            expect(errors[0].path).toEqual(['people', '1', 'age']);
-        });
-        test('custom type array rejects non-array', () => {
-            const { tag } = (0, peggy_1.parseTag)('person { name=alice age=30 }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Types: { personType: { Required: { name=string age=number } } } Required: { person="personType[]" }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain("expected 'personType[]'");
-        });
-        test('recursive type validates nested structure', () => {
-            const { tag } = (0, peggy_1.parseTag)('node { value=1 children=[{ value=2 }, { value=3 children=[{ value=4 }] }] }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Types: { treeNode: { Required: { value=number } Optional: { children="treeNode[]" } } } Required: { node=treeNode }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('recursive type catches deep errors', () => {
-            const { tag } = (0, peggy_1.parseTag)('node { value=1 children=[{ value=2 }, { value=bad }] }');
-            const { tag: schema } = (0, peggy_1.parseTag)('Types: { treeNode: { Required: { value=number } Optional: { children="treeNode[]" } } } Required: { node=treeNode }');
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].path).toEqual(['node', 'children', '1', 'value']);
-        });
-        test('multiple custom types in same schema', () => {
-            const { tag } = (0, peggy_1.parseTag)(`
-        user { name=alice }
-        address { city=boston }
-      `);
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          userType: { Required: { name=string } }
-          addressType: { Required: { city=string } }
-        }
-        Required: {
-          user=userType
-          address=addressType
-        }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('custom type with type constraint on value', () => {
-            const { tag } = (0, peggy_1.parseTag)('config=settings { debug=@true }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          configType: {
-            Type=string
-            Optional: { debug=boolean }
-          }
-        }
-        Required: { config=configType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('meta-schema validates itself', () => {
-            // The meta-schema loaded from motly-schema.motly should validate against itself
-            const errors = (0, schema_1.validateTag)(metaSchema, metaSchema);
-            expect(errors).toHaveLength(0);
-        });
-        test('meta-schema validates a simple schema', () => {
-            const { tag: simpleSchema } = (0, peggy_1.parseTag)(`
-        Required: { name=string age=number }
-        Optional: { email=string }
-      `);
-            const errors = (0, schema_1.validateTag)(simpleSchema, metaSchema);
-            expect(errors).toHaveLength(0);
-        });
-        test('meta-schema validates schema with custom types', () => {
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          PersonType: {
-            Required: { name=string }
-            Optional: { age=number }
-          }
-        }
-        Required: { person=PersonType }
-      `);
-            const errors = (0, schema_1.validateTag)(schema, metaSchema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('enum types', () => {
-        test('validates string enum', () => {
-            const { tag } = (0, peggy_1.parseTag)('status=active');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { statusType = [pending, active, completed] }
-        Required: { status=statusType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects invalid enum value', () => {
-            const { tag } = (0, peggy_1.parseTag)('status=unknown');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { statusType = [pending, active, completed] }
-        Required: { status=statusType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-enum-value');
-            expect(errors[0].message).toContain('unknown');
-            expect(errors[0].message).toContain('pending, active, completed');
-        });
-        test('validates numeric enum', () => {
-            const { tag } = (0, peggy_1.parseTag)('level=2');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { levelType = [1, 2, 3] }
-        Required: { level=levelType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects invalid numeric enum value', () => {
-            const { tag } = (0, peggy_1.parseTag)('level=5');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { levelType = [1, 2, 3] }
-        Required: { level=levelType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-enum-value');
-        });
-        test('validates array of enum type', () => {
-            const { tag } = (0, peggy_1.parseTag)('statuses=[active, pending]');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { statusType = [pending, active, completed] }
-        Required: { statuses="statusType[]" }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects invalid value in enum array', () => {
-            const { tag } = (0, peggy_1.parseTag)('statuses=[active, invalid]');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { statusType = [pending, active, completed] }
-        Required: { statuses="statusType[]" }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-enum-value');
-            expect(errors[0].path).toEqual(['statuses', '1']);
-        });
-        test('rejects empty enum type', () => {
-            const { tag } = (0, peggy_1.parseTag)('status=active');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { statusType = [] }
-        Required: { status=statusType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-schema');
-            expect(errors[0].message).toContain('no values');
-        });
-        test('rejects mixed type enum', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=1');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { mixedType = [1, two, 3] }
-        Required: { value=mixedType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-schema');
-            expect(errors[0].message).toContain('mixed types');
-        });
-    });
-    describe('pattern types', () => {
-        test('validates string matching pattern', () => {
-            const { tag } = (0, peggy_1.parseTag)('email="test@example.com"');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { emailType.matches = "^[^@]+@[^@]+$" }
-        Required: { email=emailType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects string not matching pattern', () => {
-            const { tag } = (0, peggy_1.parseTag)('email="not-an-email"');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { emailType.matches = "^[^@]+@[^@]+$" }
-        Required: { email=emailType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('pattern-mismatch');
-        });
-        test('rejects non-string for pattern type', () => {
-            const { tag } = (0, peggy_1.parseTag)('email=123');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { emailType.matches = ".*" }
-        Required: { email=emailType }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-        });
-        test('validates array of pattern type', () => {
-            const { tag } = (0, peggy_1.parseTag)('emails=["a@b.com", "c@d.org"]');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { emailType.matches = "^[^@]+@[^@]+$" }
-        Required: { emails="emailType[]" }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects invalid value in pattern array', () => {
-            const { tag } = (0, peggy_1.parseTag)('emails=["a@b.com", "invalid"]');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { emailType.matches = "^[^@]+@[^@]+$" }
-        Required: { emails="emailType[]" }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('pattern-mismatch');
-            expect(errors[0].path).toEqual(['emails', '1']);
-        });
-        test('reports error for invalid regex in schema', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=test');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { badPattern.matches = "[invalid" }
-        Required: { value=badPattern }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('invalid-schema');
-        });
-    });
-    describe('oneOf union types', () => {
-        test('validates value matching first type in oneOf', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=hello');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { StringOrNumber.oneOf = [string, number] }
-        Required: { value=StringOrNumber }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('validates value matching second type in oneOf', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=42');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { StringOrNumber.oneOf = [string, number] }
-        Required: { value=StringOrNumber }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('rejects value not matching any type in oneOf', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=@true');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { StringOrNumber.oneOf = [string, number] }
-        Required: { value=StringOrNumber }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].message).toContain('oneOf');
-        });
-        test('oneOf with custom structural types', () => {
-            const { tag } = (0, peggy_1.parseTag)('item { name=test }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          TypeA: { Required: { name=string } }
-          TypeB: { Required: { count=number } }
-          AorB.oneOf = [TypeA, TypeB]
-        }
-        Required: { item=AorB }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('oneOf with enum type', () => {
-            const { tag } = (0, peggy_1.parseTag)('value=active');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          StatusEnum = [pending, active, completed]
-          StringOrStatus.oneOf = [number, StatusEnum]
-        }
-        Required: { value=StringOrStatus }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('array of oneOf type', () => {
-            const { tag } = (0, peggy_1.parseTag)('values=[hello, 42, world]');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: { StringOrNumber.oneOf = [string, number] }
-        Required: { values="StringOrNumber[]" }
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-    describe('typed Additional', () => {
-        test('Additional with type validates unknown properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice extra1=hello extra2=world');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: { name=string }
-        Additional=string
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('Additional with type rejects invalid unknown properties', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice extra=42');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: { name=string }
-        Additional=string
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].code).toBe('wrong-type');
-            expect(errors[0].path).toEqual(['extra']);
-        });
-        test('Additional with custom type', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=test prop1 { x=1 } prop2 { x=2 }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          PropType: { Required: { x=number } }
-        }
-        Required: { name=string }
-        Additional=PropType
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-        test('Additional with custom type catches errors', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=test prop1 { x=bad }');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Types: {
-          PropType: { Required: { x=number } }
-        }
-        Required: { name=string }
-        Additional=PropType
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].path).toEqual(['prop1', 'x']);
-        });
-        test('Additional flag is same as Additional=any', () => {
-            const { tag } = (0, peggy_1.parseTag)('name=alice anything=goes here=too');
-            const { tag: schema } = (0, peggy_1.parseTag)(`
-        Required: { name=string }
-        Additional
-      `);
-            const errors = (0, schema_1.validateTag)(tag, schema);
-            expect(errors).toHaveLength(0);
-        });
-    });
-});
-//# sourceMappingURL=schema.spec.js.map