@sanity/runtime-cli 10.4.0 → 10.5.0

package/dist/utils/vendor/parser-validator.js

@@ -1,514 +0,0 @@
-const firstVersion = '2024-10-01';
-const formatProperties = [
-    '$schema',
-    'blueprintVersion',
-    'resources',
-    'parameters',
-    'values',
-    'outputs',
-    'metadata',
-];
-const parameterTypes = ['arg', 'env-var', 'stdin', 'config'];
-const versionFormat = /^\d{4}-\d{2}-\d{2}$/; // YYYY-MM-DD
-const nameFormat = /^[a-zA-Z][a-zA-Z0-9-_]*(?<![-_])$/;
-const typeFormat = /^[a-zA-Z]([a-zA-Z0-9-_]+\.?)*(?<![-_\.])$/;
-// Types
-const array = (item) => Array.isArray(item);
-// const bool = (item) => typeof item === 'boolean'
-const defined = (item) => typeof item !== 'undefined';
-// const nullish = (item) => typeof item === 'undefined' || item === null
-const number = (item) => Number.isInteger(item) || (typeof item === 'number' && !Number.isNaN(item));
-const object = (item) => item && typeof item === 'object' && !Array.isArray(item);
-const ref = (item) => string(item) && item.startsWith('$.');
-const scalar = (item) => string(item) || number(item);
-const string = (item) => typeof item === 'string';
-var is = {
-    array,
-    defined,
-    number,
-    object,
-    ref,
-    scalar,
-    string,
-};
-var references = { find, resolve };
-function find(rawBlueprint, options) {
-    const { resources, parameters, outputs } = rawBlueprint;
-    const { debug } = options;
-    const foundRefs = [];
-    function walk(item, path) {
-        if (is.object(item)) {
-            for (const [name, value] of Object.entries(item)) {
-                const cur = `${path}.${name}`;
-                if (is.ref(value))
-                    foundRefs.push({ path: cur, property: name, ref: value, item });
-                else if (is.object(value) || is.array(value))
-                    walk(value, cur);
-            }
-        }
-        if (is.array(item)) {
-            item.forEach((value, index) => {
-                const cur = `${path}[${index}]`;
-                if (is.ref(value))
-                    foundRefs.push({ path: cur, property: value, ref: value, item, index });
-                else if (is.object(value))
-                    walk(value, cur);
-            });
-        }
-    }
-    // Top-level Blueprint properties that may contain a reference
-    const properties = ['resources', 'parameters', 'outputs'];
-    for (const property of properties) {
-        // Run over the list
-        if (rawBlueprint[property]?.length) {
-            // Inspect each property, or (recursively) walk if it's an object
-            for (const item of rawBlueprint[property]) {
-                const top = `${property}.${item.name}`;
-                walk(item, top);
-            }
-        }
-    }
-    /* c8 ignore next 4 */
-    if (debug) {
-        console.log(`[Debug] Found ${foundRefs.length} references:`, foundRefs.length ? foundRefs : '');
-    }
-    return foundRefs;
-}
-function resolve(rawBlueprint, foundRefs, options) {
-    const { parameters = {} } = options;
-    const refs = {};
-    const unresolvedRefs = [];
-    const refErrors = [];
-    for (const foundRef of foundRefs) {
-        const { path, property, ref, item } = foundRef;
-        const refPath = ref.replace(/^\$\./, '');
-        // Early return from an already found reference
-        if (refs[refPath]) {
-            item[property] = refs[refPath];
-            continue;
-        }
-        // Parameters are special, (try to) find them in options.parameters passed by the caller
-        const parts = refPath.split('.');
-        const param = parts[1];
-        if (['parameters', 'params'].includes(parts[0])) {
-            const found = parameters[param];
-            if (is.scalar(found)) {
-                refs[refPath] = found;
-                if (is.object(item))
-                    item[property] = refs[refPath];
-                if (is.array(item)) {
-                    const index = item.findIndex(i => i === property);
-                    item[index] = refs[refPath];
-                }
-            }
-            else {
-                refErrors.push({
-                    message: `Reference error '${ref}': '${param}' not found in passed parameters`,
-                    type: 'missing_parameter',
-                });
-            }
-            continue;
-        }
-        // Will prob need to refactor the following to get a bit more readable, and introduce more subtle behavior
-        const found = parts.reduce((obj, i) => {
-            if (obj?.[i])
-                return obj[i];
-            if (is.array(obj))
-                return obj.find(({ name }) => name === i);
-        }, rawBlueprint);
-        if (is.scalar(found)) {
-            refs[refPath] = found;
-            if (is.object(item))
-                item[property] = refs[refPath];
-            if (is.array(item)) {
-                const index = item.findIndex(i => i === property);
-                item[index] = refs[refPath];
-            }
-        }
-        else {
-            unresolvedRefs.push(foundRef);
-        }
-    }
-    return {
-        resolvedBlueprint: rawBlueprint,
-        unresolvedRefs: unresolvedRefs.length ? unresolvedRefs : undefined,
-        refErrors,
-    };
-}
-var validate = {
-    version: (blueprintVersion) => {
-        const errors = [];
-        const type = 'invalid_version';
-        if (!is.string(blueprintVersion) || !versionFormat.test(blueprintVersion)) {
-            return errors.push({ message: `Invalid version: ${blueprintVersion}`, type });
-        }
-        const [y, m, d] = blueprintVersion.split('-');
-        if (y < '2024') {
-            errors.push({ message: `Invalid version year: ${y}`, type });
-        }
-        if (m < '01' || m > '12') {
-            errors.push({ message: `Invalid version month: ${m}`, type });
-        }
-        if (d < '01' || d > '31') {
-            errors.push({ message: `Invalid version day: ${d}`, type });
-        }
-        if (errors.length)
-            return errors;
-    },
-    resources: (resources) => {
-        if (!is.defined(resources))
-            return;
-        if (!is.array(resources)) {
-            return [
-                {
-                    message: 'Resources must be an array',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-        const errors = [];
-        const names = [];
-        resources.forEach((resource) => {
-            if (!is.object(resource)) {
-                return errors.push({
-                    // Maybe we should break out the stringified resource into a data field?
-                    message: `Resources must be an object, found: ${JSON.stringify(resource)}`,
-                    type: 'invalid_type',
-                });
-            }
-            const { name, type } = resource;
-            if (!is.defined(name)) {
-                errors.push({
-                    message: `Resource must have a 'name' property`,
-                    type: 'missing_required_property',
-                });
-            }
-            else if (!is.string(name)) {
-                errors.push({
-                    message: `Resource 'name' property must be a string, found: ${name}`,
-                    type: 'invalid_type',
-                });
-            }
-            else {
-                if (names.includes(name)) {
-                    errors.push({
-                        message: `All resource 'name' properties must be unique, found: ${name}`,
-                        type: 'duplicate_name',
-                    });
-                }
-                if (!nameFormat.test(name)) {
-                    errors.push({
-                        message: `Resource 'name' property is invalid, must conform to '${nameFormat}', found: ${name}`,
-                        type: 'invalid_format',
-                    });
-                }
-                names.push(name);
-            }
-            if (!is.defined(type)) {
-                errors.push({
-                    message: `Resource must have a 'type' property`,
-                    type: 'missing_required_property',
-                });
-            }
-            else if (!is.string(type)) {
-                errors.push({
-                    message: `Resource 'type' property must be a string, found: ${type}`,
-                    type: 'invalid_type',
-                });
-            }
-            else if (!typeFormat.test(type)) {
-                errors.push({
-                    message: `Resource 'type' property is invalid, must conform to '${typeFormat}', found: ${type}`,
-                    type: 'invalid_format',
-                });
-            }
-        });
-        if (errors.length)
-            return errors;
-    },
-    values: (values) => {
-        if (!is.defined(values))
-            return;
-        if (!is.object(values)) {
-            return [
-                {
-                    message: 'Values must be an object',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-        const errors = [];
-        if (Object.keys(values).length) {
-            Object.entries(values).forEach(([name, value]) => {
-                if (!is.scalar(value)) {
-                    errors.push({
-                        message: `Values property '${name}' must be scalar (string or number)`,
-                        type: 'invalid_type',
-                    });
-                }
-                if (is.ref(value)) {
-                    errors.push({
-                        message: `Values property '${name}' cannot be a reference, found: ${value}`,
-                        type: 'invalid_type',
-                    });
-                }
-            });
-        }
-        if (errors.length)
-            return errors;
-    },
-    parameters: (parameters) => {
-        if (!is.defined(parameters))
-            return;
-        if (!is.array(parameters)) {
-            return [
-                {
-                    message: 'Parameters must be an array',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-        const errors = [];
-        const names = [];
-        if (parameters.length) {
-            parameters.forEach((param) => {
-                if (!is.object(param)) {
-                    return errors.push({
-                        // Maybe we should break out the stringified parameter into a data field?
-                        message: `Parameters must be an object, found: ${JSON.stringify(param)}`,
-                        type: 'invalid_type',
-                    });
-                }
-                const { name, type } = param;
-                if (!is.defined(name)) {
-                    errors.push({
-                        message: `Parameter must have a 'name' property`,
-                        type: 'missing_required_property',
-                    });
-                }
-                else if (!is.string(name)) {
-                    errors.push({
-                        message: `Parameter 'name' property must be a string, found: ${name}`,
-                        type: 'invalid_type',
-                    });
-                }
-                else {
-                    if (names.includes(name)) {
-                        errors.push({
-                            message: `All parameter 'name' properties must be unique, found: ${name}`,
-                            type: 'duplicate_name',
-                        });
-                    }
-                    if (!nameFormat.test(name)) {
-                        errors.push({
-                            message: `Parameter 'name' property is invalid, must conform to '${nameFormat}', found: ${name}`,
-                            type: 'invalid_format',
-                        });
-                    }
-                    names.push(name);
-                }
-                if (!is.defined(type)) {
-                    errors.push({
-                        message: `Parameter must have a 'type' property`,
-                        type: 'missing_required_property',
-                    });
-                }
-                else if (!is.string(type)) {
-                    errors.push({
-                        message: `Parameter 'type' property must be a string, found: ${type}`,
-                        type: 'invalid_type',
-                    });
-                }
-                else if (!parameterTypes.includes(type)) {
-                    errors.push({
-                        message: `Unknown parameter 'type', found: ${type}`,
-                        type: 'invalid_value',
-                    });
-                }
-            });
-        }
-        if (errors.length)
-            return errors;
-    },
-    outputs: (outputs) => {
-        if (!is.defined(outputs))
-            return;
-        if (!is.array(outputs)) {
-            return [
-                {
-                    message: 'Outputs must be an array',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-        const errors = [];
-        const names = [];
-        outputs.forEach((output) => {
-            if (!is.object(output)) {
-                return errors.push({
-                    // Maybe we should break out the stringified output into a data field?
-                    message: `Outputs must be an object, found: ${JSON.stringify(output)}`,
-                    type: 'invalid_type',
-                });
-            }
-            const { name, value } = output;
-            if (!is.defined(name)) {
-                errors.push({
-                    message: `Output must have a 'name' property`,
-                    type: 'missing_required_property',
-                });
-            }
-            else if (!is.string(name)) {
-                errors.push({
-                    message: `Output 'name' property must be a string, found: ${name}`,
-                    type: 'invalid_type',
-                });
-            }
-            else {
-                if (names.includes(name)) {
-                    errors.push({
-                        message: `All output 'name' properties must be unique, found: ${name}`,
-                        type: 'duplicate_name',
-                    });
-                }
-                if (!nameFormat.test(name)) {
-                    errors.push({
-                        message: `Output 'name' property is invalid, must conform to '${nameFormat}', found: ${name}`,
-                        type: 'invalid_format',
-                    });
-                }
-                names.push(name);
-            }
-            if (!is.defined(value)) {
-                errors.push({
-                    message: `Output must have a 'value' property`,
-                    type: 'missing_required_property',
-                });
-            }
-        });
-        if (errors.length)
-            return errors;
-    },
-    metadata: (metadata) => {
-        if (!is.defined(metadata))
-            return;
-        if (!is.object(metadata)) {
-            return [
-                {
-                    message: 'Metadata must be an object',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-    },
-    else: (rawBlueprint) => {
-        const properties = Object.keys(rawBlueprint);
-        if (!properties.length)
-            return;
-        const errors = [];
-        for (const property of properties) {
-            if (!formatProperties.includes(property)) {
-                errors.push({
-                    message: `Found invalid Blueprint property: ${property}`,
-                    type: 'invalid_property',
-                });
-            }
-        }
-        if (errors.length)
-            return errors;
-    },
-    passedParameters: (options) => {
-        const { parameters } = options;
-        if (!is.defined(parameters))
-            return;
-        if (!is.object(parameters)) {
-            return [
-                {
-                    message: 'Passed parameters must be an object',
-                    type: 'invalid_type',
-                },
-            ];
-        }
-        const errors = [];
-        for (const [name, value] of Object.entries(parameters)) {
-            if (!is.scalar(value)) {
-                errors.push({
-                    message: `Passed parameter '${name}' must be scalar (string or number)`,
-                    type: 'invalid_type',
-                });
-            }
-        }
-        if (errors.length)
-            return errors;
-    },
-};
-function blueprintParserValidator(input, options = {}) {
-    try {
-        const { rawBlueprint, parseErrors } = parse(input);
-        if (parseErrors?.length) {
-            return {
-                blueprint: rawBlueprint || input,
-                errors: parseErrors,
-            };
-        }
-        const version = rawBlueprint.blueprintVersion || firstVersion;
-        // Aggregate basic structural, spec violation, or input errors
-        const initialErrors = []
-            .concat(validate.version(version), validate.resources(rawBlueprint.resources), validate.values(rawBlueprint.values), validate.parameters(rawBlueprint.parameters), validate.outputs(rawBlueprint.outputs), validate.metadata(rawBlueprint.metadata), validate.else(rawBlueprint), validate.passedParameters(options))
-            .filter(Boolean);
-        if (initialErrors.length) {
-            return {
-                blueprint: rawBlueprint,
-                errors: initialErrors,
-            };
-        }
-        const foundRefs = references.find(rawBlueprint, options);
-        if (!foundRefs.length) {
-            return {
-                blueprint: rawBlueprint,
-            };
-        }
-        const { resolvedBlueprint, unresolvedRefs, refErrors } = references.resolve(rawBlueprint, foundRefs, options);
-        const output = { blueprint: resolvedBlueprint };
-        if (unresolvedRefs?.length)
-            output.unresolvedRefs = unresolvedRefs;
-        if (refErrors.length)
-            output.errors = refErrors;
-        return output;
-        /* c8 ignore next 4 */
-    }
-    catch (error) {
-        console.log('Unknown Blueprint error', error);
-        throw error;
-    }
-}
-function parse(input) {
-    if (is.string(input) || input instanceof Buffer) {
-        try {
-            return { rawBlueprint: JSON.parse(input) };
-        }
-        catch (error) {
-            return {
-                parseErrors: [
-                    {
-                        message: 'Invalid Blueprint JSON',
-                        type: 'json_validation_error',
-                        error,
-                    },
-                ],
-            };
-        }
-    }
-    else if (is.object(input)) {
-        return { rawBlueprint: structuredClone(input) };
-    }
-    return {
-        parseErrors: [
-            {
-                message: 'Invalid input',
-                type: 'invalid_input',
-            },
-        ],
-    };
-}
-export { blueprintParserValidator };