@malloydata/motly-ts-parser 0.0.1

package/build/validate.js

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReferences = validateReferences;
+exports.validateSchema = validateSchema;
+// ── Helpers ─────────────────────────────────────────────────────
+function isRef(node) {
+    return "linkTo" in node;
+}
+function getEqString(node) {
+    return typeof node.eq === "string" ? node.eq : undefined;
+}
+function valueEqString(node) {
+    if (isRef(node))
+        return undefined;
+    return getEqString(node);
+}
+function extractSection(node, name) {
+    if (!node.properties)
+        return undefined;
+    const section = node.properties[name];
+    if (section === undefined || isRef(section))
+        return undefined;
+    return section.properties;
+}
+// ── Reference Validation ────────────────────────────────────────
+function validateReferences(root) {
+    const errors = [];
+    const path = [];
+    const ancestors = [root];
+    walkRefs(root, path, ancestors, root, errors);
+    return errors;
+}
+function walkRefs(node, path, ancestors, root, errors) {
+    // Check array elements in eq
+    if (node.eq !== undefined && Array.isArray(node.eq)) {
+        walkArrayRefs(node.eq, path, ancestors, node, root, errors);
+    }
+    if (node.properties) {
+        for (const key of Object.keys(node.properties)) {
+            const value = node.properties[key];
+            path.push(key);
+            if (isRef(value)) {
+                const errMsg = checkLink(value, ancestors, root);
+                if (errMsg !== null) {
+                    errors.push({
+                        message: errMsg,
+                        path: [...path],
+                        code: "unresolved-reference",
+                    });
+                }
+            }
+            else {
+                ancestors.push(node);
+                walkRefs(value, path, ancestors, root, errors);
+                ancestors.pop();
+            }
+            path.pop();
+        }
+    }
+}
+function walkArrayRefs(arr, path, ancestors, parentNode, root, errors) {
+    for (let i = 0; i < arr.length; i++) {
+        const elem = arr[i];
+        const idxKey = `[${i}]`;
+        path.push(idxKey);
+        if (isRef(elem)) {
+            const errMsg = checkLink(elem, ancestors, root);
+            if (errMsg !== null) {
+                errors.push({
+                    message: errMsg,
+                    path: [...path],
+                    code: "unresolved-reference",
+                });
+            }
+        }
+        else {
+            ancestors.push(parentNode);
+            walkRefs(elem, path, ancestors, root, errors);
+            ancestors.pop();
+        }
+        path.pop();
+    }
+}
+function checkLink(link, ancestors, root) {
+    const { ups, segments } = parseLinkString(link.linkTo);
+    let start;
+    if (ups === 0) {
+        start = root;
+    }
+    else {
+        const idx = ancestors.length - ups;
+        if (idx < 0 || idx >= ancestors.length) {
+            return `Reference "${link.linkTo}" goes ${ups} level(s) up but only ${ancestors.length} ancestor(s) available`;
+        }
+        start = ancestors[idx];
+    }
+    return resolvePath(start, segments, link.linkTo);
+}
+function parseLinkString(s) {
+    let i = 0;
+    if (i < s.length && s[i] === "$")
+        i++;
+    let ups = 0;
+    while (i < s.length && s[i] === "^") {
+        ups++;
+        i++;
+    }
+    const segments = [];
+    let nameBuf = "";
+    while (i < s.length) {
+        const ch = s[i];
+        if (ch === ".") {
+            if (nameBuf.length > 0) {
+                segments.push({ kind: "name", name: nameBuf });
+                nameBuf = "";
+            }
+            i++;
+        }
+        else if (ch === "[") {
+            if (nameBuf.length > 0) {
+                segments.push({ kind: "name", name: nameBuf });
+                nameBuf = "";
+            }
+            i++;
+            let idxBuf = "";
+            while (i < s.length && s[i] !== "]") {
+                idxBuf += s[i];
+                i++;
+            }
+            if (i < s.length)
+                i++; // skip ']'
+            const idx = parseInt(idxBuf, 10);
+            if (!isNaN(idx) && idx >= 0) {
+                segments.push({ kind: "index", index: idx });
+            }
+        }
+        else {
+            nameBuf += ch;
+            i++;
+        }
+    }
+    if (nameBuf.length > 0) {
+        segments.push({ kind: "name", name: nameBuf });
+    }
+    return { ups, segments };
+}
+function resolvePath(start, segments, linkStr) {
+    let current = { kind: "node", node: start };
+    for (const seg of segments) {
+        if (current.kind === "terminal") {
+            return `Reference "${linkStr}" could not be resolved: cannot follow path through a link`;
+        }
+        const node = current.node;
+        if (seg.kind === "name") {
+            if (!node.properties) {
+                return `Reference "${linkStr}" could not be resolved: property "${seg.name}" not found (node has no properties)`;
+            }
+            const child = node.properties[seg.name];
+            if (child === undefined) {
+                return `Reference "${linkStr}" could not be resolved: property "${seg.name}" not found`;
+            }
+            if (isRef(child)) {
+                current = { kind: "terminal" };
+            }
+            else {
+                current = { kind: "node", node: child };
+            }
+        }
+        else {
+            if (node.eq === undefined || !Array.isArray(node.eq)) {
+                return `Reference "${linkStr}" could not be resolved: index [${seg.index}] used on non-array`;
+            }
+            if (seg.index >= node.eq.length) {
+                return `Reference "${linkStr}" could not be resolved: index [${seg.index}] out of bounds (array length ${node.eq.length})`;
+            }
+            const elem = node.eq[seg.index];
+            if (isRef(elem)) {
+                current = { kind: "terminal" };
+            }
+            else {
+                current = { kind: "node", node: elem };
+            }
+        }
+    }
+    return null;
+}
+// ── Schema Validation ───────────────────────────────────────────
+function validateSchema(tag, schema) {
+    const errors = [];
+    const types = extractSection(schema, "Types");
+    validateNodeAgainstSchema(tag, schema, types, [], errors);
+    return errors;
+}
+function getAdditionalPolicy(schema) {
+    if (!schema.properties)
+        return { kind: "reject" };
+    const additional = schema.properties["Additional"];
+    if (additional === undefined)
+        return { kind: "reject" };
+    if (isRef(additional))
+        return { kind: "reject" };
+    const eqStr = getEqString(additional);
+    if (eqStr !== undefined) {
+        if (eqStr === "allow")
+            return { kind: "allow" };
+        if (eqStr === "reject")
+            return { kind: "reject" };
+        return { kind: "validateAs", typeName: eqStr };
+    }
+    return { kind: "allow" };
+}
+function validateNodeAgainstSchema(tag, schema, types, path, errors) {
+    const required = extractSection(schema, "Required");
+    const optional = extractSection(schema, "Optional");
+    const additional = getAdditionalPolicy(schema);
+    const tagProps = tag.properties;
+    // Check required properties
+    if (required) {
+        for (const key of Object.keys(required)) {
+            const propPath = [...path, key];
+            const tagValue = tagProps ? tagProps[key] : undefined;
+            if (tagValue === undefined) {
+                errors.push({
+                    message: `Missing required property "${key}"`,
+                    path: propPath,
+                    code: "missing-required",
+                });
+            }
+            else {
+                validateValueType(tagValue, required[key], types, propPath, errors);
+            }
+        }
+    }
+    // Check optional properties that exist
+    if (optional && tagProps) {
+        for (const key of Object.keys(optional)) {
+            const tagValue = tagProps[key];
+            if (tagValue !== undefined) {
+                validateValueType(tagValue, optional[key], types, [...path, key], errors);
+            }
+        }
+    }
+    // Check for unknown properties
+    if (tagProps) {
+        const knownKeys = new Set();
+        if (required)
+            for (const k of Object.keys(required))
+                knownKeys.add(k);
+        if (optional)
+            for (const k of Object.keys(optional))
+                knownKeys.add(k);
+        for (const key of Object.keys(tagProps)) {
+            if (knownKeys.has(key))
+                continue;
+            const propPath = [...path, key];
+            switch (additional.kind) {
+                case "reject":
+                    errors.push({
+                        message: `Unknown property "${key}"`,
+                        path: propPath,
+                        code: "unknown-property",
+                    });
+                    break;
+                case "allow":
+                    break;
+                case "validateAs": {
+                    const synthetic = makeTypeSpecNode(additional.typeName);
+                    validateValueType(tagProps[key], synthetic, types, propPath, errors);
+                    break;
+                }
+            }
+        }
+    }
+}
+function makeTypeSpecNode(typeName) {
+    return { eq: typeName };
+}
+function validateValueType(value, typeSpec, types, path, errors) {
+    if (isRef(typeSpec))
+        return;
+    // Check for union type (oneOf)
+    if (typeSpec.properties) {
+        const oneOf = typeSpec.properties["oneOf"];
+        if (oneOf !== undefined && !isRef(oneOf)) {
+            validateUnion(value, oneOf, types, path, errors);
+            return;
+        }
+    }
+    // Check for enum (eq) or pattern (matches)
+    if (typeSpec.properties) {
+        const eqProp = typeSpec.properties["eq"];
+        if (eqProp !== undefined && !isRef(eqProp)) {
+            if (Array.isArray(eqProp.eq)) {
+                validateEnum(value, eqProp.eq, path, errors);
+                return;
+            }
+        }
+        const matchesProp = typeSpec.properties["matches"];
+        if (matchesProp !== undefined && !isRef(matchesProp)) {
+            const baseType = getEqString(typeSpec);
+            if (baseType !== undefined) {
+                validateBaseType(value, baseType, types, path, errors);
+            }
+            validatePattern(value, matchesProp, path, errors);
+            return;
+        }
+    }
+    // Get the type name from the spec's eq value
+    const typeName = getEqString(typeSpec);
+    if (typeName === undefined) {
+        // Nested schema (has Required/Optional/Additional)
+        if (typeSpec.properties &&
+            ("Required" in typeSpec.properties ||
+                "Optional" in typeSpec.properties ||
+                "Additional" in typeSpec.properties)) {
+            if (isRef(value)) {
+                errors.push({
+                    message: "Expected a tag but found a link",
+                    path: [...path],
+                    code: "wrong-type",
+                });
+            }
+            else {
+                validateNodeAgainstSchema(value, typeSpec, types, path, errors);
+            }
+        }
+        return;
+    }
+    validateBaseType(value, typeName, types, path, errors);
+}
+function validateBaseType(value, typeName, types, path, errors) {
+    // Array types: "string[]", "number[]", etc.
+    if (typeName.endsWith("[]")) {
+        const innerType = typeName.slice(0, -2);
+        validateArrayType(value, innerType, types, path, errors);
+        return;
+    }
+    switch (typeName) {
+        case "string":
+            validateTypeString(value, path, errors);
+            break;
+        case "number":
+            validateTypeNumber(value, path, errors);
+            break;
+        case "boolean":
+            validateTypeBoolean(value, path, errors);
+            break;
+        case "date":
+            validateTypeDate(value, path, errors);
+            break;
+        case "tag":
+            validateTypeTag(value, path, errors);
+            break;
+        case "flag":
+            validateTypeFlag(value, path, errors);
+            break;
+        case "any":
+            break;
+        default: {
+            // Custom type
+            if (types) {
+                const typeDef = types[typeName];
+                if (typeDef !== undefined) {
+                    validateValueType(value, typeDef, types, path, errors);
+                }
+                else {
+                    errors.push({
+                        message: `Unknown type "${typeName}" in schema`,
+                        path: [...path],
+                        code: "invalid-schema",
+                    });
+                }
+            }
+            else {
+                errors.push({
+                    message: `Unknown type "${typeName}" (no Types section in schema)`,
+                    path: [...path],
+                    code: "invalid-schema",
+                });
+            }
+        }
+    }
+}
+function validateTypeString(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "string" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (typeof value.eq !== "string") {
+        errors.push({
+            message: 'Expected type "string"',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateTypeNumber(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "number" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (typeof value.eq !== "number") {
+        errors.push({
+            message: 'Expected type "number"',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateTypeBoolean(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "boolean" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (typeof value.eq !== "boolean") {
+        errors.push({
+            message: 'Expected type "boolean"',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateTypeDate(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "date" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (!(value.eq instanceof Date)) {
+        errors.push({
+            message: 'Expected type "date"',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateTypeTag(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "tag" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateTypeFlag(value, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: 'Expected type "flag" but found a link',
+            path: [...path],
+            code: "wrong-type",
+        });
+    }
+}
+function validateArrayType(value, innerType, types, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: `Expected type "${innerType}[]" but found a link`,
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (!Array.isArray(value.eq)) {
+        errors.push({
+            message: `Expected type "${innerType}[]" but value is not an array`,
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    for (let i = 0; i < value.eq.length; i++) {
+        const elemPath = [...path, `[${i}]`];
+        validateBaseType(value.eq[i], innerType, types, elemPath, errors);
+    }
+}
+function validateEnum(value, allowed, path, errors) {
+    if (isRef(value)) {
+        errors.push({
+            message: "Expected an enum value but found a link",
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    const nodeEq = value.eq;
+    if (nodeEq === undefined ||
+        (typeof nodeEq !== "string" &&
+            typeof nodeEq !== "number" &&
+            typeof nodeEq !== "boolean" &&
+            !(nodeEq instanceof Date))) {
+        errors.push({
+            message: "Expected an enum value",
+            path: [...path],
+            code: "invalid-enum-value",
+        });
+        return;
+    }
+    const matches = allowed.some((a) => {
+        if (isRef(a))
+            return false;
+        const aeq = a.eq;
+        if (aeq instanceof Date && nodeEq instanceof Date) {
+            return aeq.getTime() === nodeEq.getTime();
+        }
+        return aeq === nodeEq;
+    });
+    if (!matches) {
+        const allowedStrs = allowed
+            .filter((a) => !isRef(a))
+            .map((a) => {
+            const aeq = a.eq;
+            return JSON.stringify(String(aeq));
+        });
+        errors.push({
+            message: `Value does not match any allowed enum value. Allowed: [${allowedStrs.join(", ")}]`,
+            path: [...path],
+            code: "invalid-enum-value",
+        });
+    }
+}
+function validatePattern(value, matchesNode, path, errors) {
+    const pattern = getEqString(matchesNode);
+    if (pattern === undefined)
+        return;
+    if (isRef(value)) {
+        errors.push({
+            message: "Expected a value matching a pattern but found a link",
+            path: [...path],
+            code: "wrong-type",
+        });
+        return;
+    }
+    if (typeof value.eq !== "string") {
+        errors.push({
+            message: `Expected a string matching pattern "${pattern}"`,
+            path: [...path],
+            code: "pattern-mismatch",
+        });
+        return;
+    }
+    try {
+        const re = new RegExp(pattern);
+        if (!re.test(value.eq)) {
+            errors.push({
+                message: `Value "${value.eq}" does not match pattern "${pattern}"`,
+                path: [...path],
+                code: "pattern-mismatch",
+            });
+        }
+    }
+    catch (e) {
+        errors.push({
+            message: `Invalid regex pattern "${pattern}": ${e}`,
+            path: [...path],
+            code: "invalid-schema",
+        });
+    }
+}
+function validateUnion(value, oneOfNode, types, path, errors) {
+    if (!Array.isArray(oneOfNode.eq))
+        return;
+    for (const typeVal of oneOfNode.eq) {
+        const typeName = valueEqString(typeVal);
+        if (typeName === undefined)
+            continue;
+        const trialErrors = [];
+        const synthetic = makeTypeSpecNode(typeName);
+        validateValueType(value, synthetic, types, path, trialErrors);
+        if (trialErrors.length === 0)
+            return;
+    }
+    const typeStrs = oneOfNode.eq
+        .map((v) => valueEqString(v))
+        .filter((s) => s !== undefined);
+    errors.push({
+        message: `Value does not match any type in oneOf: [${typeStrs.join(", ")}]`,
+        path: [...path],
+        code: "wrong-type",
+    });
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@malloydata/motly-ts-parser",
+  "version": "0.0.1",
+  "description": "MOTLY text to wire format parser — pure TypeScript",
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/malloydata/motly.git",
+    "directory": "bindings/typescript/parser"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:test": "tsc -p test/tsconfig.json",
+    "test": "npm run build && npm run build:test && node --test build-test/test.js",
+    "clean": "rm -rf build build-test",
+    "pack": "npm run build && npm pack"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.2",
+    "motly-ts-interface": "file:../interface",
+    "typescript": "^5.0.0"
+  }
+}