@takeshape/schema 11.40.0 → 11.41.0

package/dist/cjs/src/validate.js

@@ -0,0 +1,1087 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureValidProjectSchemaImport = exports.validateProjectSchemaImport = exports.ensureValidRoleImport = exports.validateRoleInput = exports.ensureValidLatestSchemaSyntax = exports.validateSchema = exports.validateSchemaSyntax = exports.formatError = exports.builtInShapeNames = void 0;
+const jsonpath_plus_1 = require("jsonpath-plus");
+const json_schema_1 = require("@takeshape/json-schema");
+const errors_1 = require("@takeshape/errors");
+const coerce_js_1 = __importDefault(require("semver/functions/coerce.js"));
+const neq_js_1 = __importDefault(require("semver/functions/neq.js"));
+const lt_js_1 = __importDefault(require("semver/functions/lt.js"));
+const gte_js_1 = __importDefault(require("semver/functions/gte.js"));
+const isUndefined_js_1 = __importDefault(require("lodash/isUndefined.js"));
+const util_1 = require("@takeshape/util");
+const uniqBy_js_1 = __importDefault(require("lodash/uniqBy.js"));
+const initial_js_1 = __importDefault(require("lodash/initial.js"));
+const last_js_1 = __importDefault(require("lodash/last.js"));
+const get_js_1 = __importDefault(require("lodash/get.js"));
+const size_js_1 = __importDefault(require("lodash/size.js"));
+const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
+const pick_js_1 = __importDefault(require("lodash/pick.js"));
+const p_map_1 = __importDefault(require("p-map"));
+const lodash_1 = require("lodash");
+const versions_1 = require("./versions");
+const workflows_1 = require("./workflows");
+const schemas_1 = require("./schemas");
+const auth_schemas_json_1 = __importDefault(require("./schemas/auth-schemas.json"));
+const schema_util_1 = require("./schema-util");
+const builtin_schema_1 = require("./builtin-schema");
+const template_shapes_1 = require("./template-shapes");
+const utils_1 = require("./types/utils");
+const refs_1 = require("./refs");
+const scalars_1 = require("./scalars");
+const unions_1 = require("./unions");
+const enum_1 = require("./enum");
+const relationships_1 = require("./relationships");
+const types_1 = require("./types/types");
+const project_schema_1 = require("./project-schema");
+const shapes_1 = require("./util/shapes");
+const ai_tools_1 = require("./util/ai-tools");
+exports.builtInShapeNames = new Set([...Object.keys(builtin_schema_1.builtInShapes), ...scalars_1.scalars, 'object']);
+function findDuplicates(items) {
+    const seen = {};
+    for (const item of items) {
+        if (seen[item.value]) {
+            seen[item.value].push(item.path);
+        }
+        else {
+            seen[item.value] = [item.path];
+        }
+    }
+    return Object.entries(seen)
+        .filter(entry => entry[1].length > 1)
+        .flatMap(entry => ({ value: entry[0], paths: entry[1] }));
+}
+function checkShapeIds(shapes) {
+    const items = Object.entries(shapes).map(entry => ({ path: ['shapes', entry[0], 'id'], value: entry[1].id }));
+    return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+        path,
+        type: 'conflict',
+        message: `Shapes must have unique ids. "${dupe.value}" is not unique.`
+    })));
+}
+function checkShapeNames(shapes) {
+    Object.entries(shapes).map(entry => ({ path: ['shapes', entry[0], 'id'], value: entry[1].id }));
+    return Object.entries(shapes)
+        .filter(([name, shape]) => name !== shape.name)
+        .map(([name, shape]) => ({
+        path: ['shapes', name, 'name'],
+        type: 'conflict',
+        message: `Shape.name "${shape.name}" must match key "${name}".`
+    }));
+}
+function checkWorkflowStepNames(workflows) {
+    return Object.entries(workflows).flatMap(([name, workflow]) => {
+        const items = workflow.steps.map((step, i) => ({
+            path: ['workflows', name, 'steps', i, 'name'],
+            value: step.name.toLowerCase()
+        }));
+        return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+            path,
+            type: 'conflict',
+            message: `Workflow steps must have unique names. "${dupe.value}" is not unique in workflow "${workflow.name}."`
+        })));
+    });
+}
+function checkWorkflowStepKeys(workflows) {
+    const items = Object.entries(workflows).flatMap(([name, workflow]) => workflow.steps.map((step, i) => ({ path: ['workflows', name, 'steps', i, 'key'], value: step.key })));
+    return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
+        path,
+        type: 'conflict',
+        message: `Workflow keys must be unique at the schema level. Key "${dupe.value}" is not unique.`
+    })));
+}
+function validateWorkflowVersion(projectSchema) {
+    const errors = [];
+    if (projectSchema.apiVersion === versions_1.LEGACY_API_VERSION && Object.keys(projectSchema.workflows).length) {
+        errors.push({
+            path: ['workflows'],
+            type: 'invalidVersion',
+            message: `apiVersion ${projectSchema.apiVersion} does not support workflows`
+        });
+    }
+    return errors;
+}
+function validateWorkflows(projectSchema) {
+    const errors = validateWorkflowVersion(projectSchema);
+    for (const name of Object.keys(projectSchema.shapes)) {
+        const shape = projectSchema.shapes[name];
+        if (shape.workflow && shape.workflow !== workflows_1.defaultWorkflow.name && !projectSchema.workflows[shape.workflow]) {
+            errors.push({
+                type: 'notFound',
+                path: ['shapes', name, 'workflow'],
+                message: `Invalid Workflow "${shape.workflow}" for shape "${shape.name}"`
+            });
+        }
+    }
+    return errors;
+}
+function getSemver(schemaVersion) {
+    return (0, coerce_js_1.default)(schemaVersion) ?? versions_1.LEGACY_SCHEMA_VERSION;
+}
+function pushErrors(errors, error) {
+    if (error) {
+        errors.push(error);
+    }
+}
+function enumerateBasicResolvers(resolver, path) {
+    const results = [];
+    const visit = (resolver, path) => {
+        if ((0, utils_1.isComposeResolver)(resolver)) {
+            resolver.compose.forEach((resolver, i) => {
+                visit(resolver, [...path, 'compose', i]);
+            });
+        }
+        else {
+            results.push([resolver, path]);
+        }
+    };
+    visit(resolver, path);
+    return results;
+}
+const validateAIToolConfig = (projectSchema, getNamespace, tool, basePath) => {
+    const toolRef = (0, ai_tools_1.getToolRef)(tool);
+    const path = typeof tool === 'string' ? basePath : basePath.concat('ref');
+    const parsed = (0, refs_1.parsePropertyRef)(toolRef);
+    if (!parsed) {
+        return {
+            type: 'conflict',
+            path,
+            message: `Unable to parse property ref "${toolRef}"`
+        };
+    }
+    if (parsed.serviceId !== 'local') {
+        return;
+    }
+    const propertyPath = (0, refs_1.propertyRefItemToPath)(getNamespace, parsed);
+    if (propertyPath[0] !== 'queries' && propertyPath[0] !== 'mutations') {
+        return {
+            type: 'conflict',
+            path,
+            message: `Tools must be a query or mutation`
+        };
+    }
+    const property = (0, get_js_1.default)(projectSchema, propertyPath);
+    if (!property) {
+        return {
+            type: 'notFound',
+            path,
+            message: `Missing tool ${propertyPath[0] === 'queries' ? 'query' : 'mutation'} "${toolRef}"`
+        };
+    }
+};
+function validateResolver(projectSchema, basePath, baseResolver) {
+    const errors = [];
+    const isValidShapeName = (shapeName) => {
+        if (!shapeName) {
+            return false;
+        }
+        const shape = (0, shapes_1.getShape)(projectSchema, shapeName) ?? (0, shapes_1.getShape)({ shapes: builtin_schema_1.builtInShapes }, shapeName);
+        if (shape?.model) {
+            return true;
+        }
+        return Boolean(shape?.cache?.enabled && shape.loaders);
+    };
+    const validateDeletgateResolver = (resolver, path) => {
+        const parsed = (0, refs_1.parsePropertyRef)(resolver.to);
+        if (!parsed) {
+            return {
+                type: 'conflict',
+                path: path.concat('to'),
+                message: `Unable to parse property ref "${resolver.to}"`
+            };
+        }
+        if (parsed.serviceId !== 'local') {
+            return;
+        }
+        const targetResolver = (0, get_js_1.default)(projectSchema, (0, refs_1.propertyRefItemToResolverPath)(getNamespace, parsed));
+        if (!(0, utils_1.isBasicResolver)(targetResolver) && !(0, utils_1.isComposeResolver)(targetResolver)) {
+            return {
+                type: 'notFound',
+                path: basePath.concat('to'),
+                message: `Missing resolver config at property ref "${resolver.to}"`
+            };
+        }
+    };
+    const validateAITGuardrail = (guardrail, basePath) => {
+        if (guardrail.name === 'similarity') {
+            if (!isValidShapeName(guardrail.shape)) {
+                return {
+                    type: 'notFound',
+                    path: basePath.concat('shape'),
+                    message: `Invalid shape "${guardrail.shape}" for ${guardrail.shape}, must use an indexed shape`
+                };
+            }
+        }
+    };
+    const validateAIGenerateTextResolver = (resolver, path) => {
+        if (resolver.tools) {
+            for (let i = 0, n = resolver.tools.length; i < n; i++) {
+                pushErrors(errors, validateAIToolConfig(projectSchema, getNamespace, resolver.tools[i], path.concat(['tools', i])));
+            }
+        }
+        if (resolver.guardrails) {
+            for (let i = 0, n = resolver.guardrails.length; i < n; i++) {
+                pushErrors(errors, validateAITGuardrail(resolver.guardrails[i], path.concat(['guardrails', i])));
+            }
+        }
+        const { toolChoice } = resolver.options ?? {};
+        if (toolChoice === 'required') {
+            if (!resolver.tools?.length) {
+                errors.push({
+                    type: 'notFound',
+                    path: path.concat(['options', 'toolChoice']),
+                    message: `Must have at least one tool configured to specify "required"`
+                });
+            }
+        }
+        else if (toolChoice && toolChoice !== 'auto' && toolChoice !== 'none') {
+            const parsed = (0, refs_1.parsePropertyRef)(toolChoice);
+            if (parsed) {
+                const matchingTool = resolver.tools?.find(tool => (0, isEqual_js_1.default)(parsed, (0, refs_1.parsePropertyRef)((0, ai_tools_1.getToolRef)(tool))));
+                if (!matchingTool) {
+                    errors.push({
+                        type: 'notFound',
+                        path: path.concat(['options', 'toolChoice']),
+                        message: `Missing tool "${toolChoice}" must be specified in "tools" array`
+                    });
+                }
+            }
+            else {
+                errors.push({
+                    type: 'conflict',
+                    path: path.concat(['options', 'toolChoice']),
+                    message: `Unable to parse property ref "${toolChoice}"`
+                });
+            }
+        }
+    };
+    const getNamespace = (0, refs_1.createGetNamespace)(projectSchema);
+    for (const [resolver, path] of enumerateBasicResolvers(baseResolver, basePath)) {
+        if ((0, utils_1.isBasicResolver)(resolver)) {
+            if ('service' in resolver &&
+                resolver.service !== 'shapedb' &&
+                resolver.service !== 'takeshape' &&
+                !projectSchema.services?.[resolver.service]) {
+                errors.push({
+                    type: 'notFound',
+                    path: path.concat(['service']),
+                    message: `Invalid service "${resolver.service}"`
+                });
+            }
+            if (resolver.shapeName) {
+                const { shapeName } = resolver;
+                if (!isValidShapeName(shapeName)) {
+                    errors.push({
+                        type: 'notFound',
+                        path: path.concat(['shapeName']),
+                        message: `Invalid Model Shape "${shapeName ?? ''}"`
+                    });
+                }
+            }
+            if (resolver.name === 'delegate') {
+                pushErrors(errors, validateDeletgateResolver(resolver, path));
+            }
+            else if ((0, utils_1.isAIResolver)(resolver)) {
+                validateAIGenerateTextResolver(resolver, path);
+            }
+        }
+        else {
+            errors.push({
+                type: 'notFound',
+                path,
+                message: `Invalid resolver`
+            });
+        }
+    }
+    return errors;
+}
+function validateLocalQueryConfig(projectSchema, query, operation, name) {
+    const location = operation === 'query' ? 'queries' : 'mutations';
+    return validateResolver(projectSchema, [location, name, 'resolver'], query.resolver);
+}
+const operationProps = [['query', 'queries'], ['mutation', 'mutations']];
+function validateLocalQueryConfigs(projectSchema) {
+    const errors = [];
+    for (const [operation, prop] of operationProps) {
+        for (const name of Object.keys(projectSchema[prop])) {
+            errors.push(...validateLocalQueryConfig(projectSchema, projectSchema[prop][name], operation, name));
+        }
+    }
+    return errors;
+}
+function allowDisconnected(context, status) {
+    return Boolean(context.allowDisconnectedLayers) && status !== 'notAvailable';
+}
+function isValidShapeReference(context, layerState, shapeName) {
+    if (layerState.status !== 'ok') {
+        return allowDisconnected(context, layerState.status);
+    }
+    return Boolean(layerState.schema.shapes[shapeName]);
+}
+async function validateResolverReferences(context, projectSchema, basePath, baseResolver) {
+    const errors = [];
+    const isInvalidPropertyRef = async (refStr) => {
+        const ref = (0, refs_1.parsePropertyRef)(refStr);
+        // ref string format and local refs are validated in validateResolver()
+        if (!ref || ref.serviceId === 'local') {
+            return false;
+        }
+        const layerState = await context.resolveLayer(ref.serviceId);
+        return layerState.status === 'ok'
+            ? !(0, get_js_1.default)(layerState.schema, (0, refs_1.propertyRefItemToPath)((0, util_1.value)(''), ref))
+            : !allowDisconnected(context, layerState.status);
+    };
+    await (0, p_map_1.default)(enumerateBasicResolvers(baseResolver, basePath), async ([resolver, path]) => {
+        if (resolver.name === 'graphql:query' || resolver.name === 'graphql:mutation') {
+            const { service, fieldName } = resolver;
+            const prop = resolver.name === 'graphql:query' ? 'queries' : 'mutations';
+            const layerState = await context.resolveLayer(service);
+            const valid = layerState.status === 'ok'
+                ? Boolean(layerState.schema[prop][fieldName])
+                : allowDisconnected(context, layerState.status);
+            if (!valid) {
+                const operation = resolver.name === 'graphql:query' ? 'query' : 'mutation';
+                errors.push({
+                    type: 'notFound',
+                    path: path.concat('fieldName'),
+                    message: `Missing ${operation} "${resolver.fieldName}" in service layer "${service}"`
+                });
+            }
+        }
+        else if (resolver.name === 'delegate') {
+            if (await isInvalidPropertyRef(resolver.to)) {
+                errors.push({
+                    type: 'notFound',
+                    path: path.concat('to'),
+                    message: `Missing resolver config at property ref "${resolver.to}"`
+                });
+            }
+        }
+        else if ((0, utils_1.isAIResolver)(resolver)) {
+            if (resolver.tools) {
+                await (0, p_map_1.default)(resolver.tools, async (tool, i) => {
+                    const toolRef = (0, ai_tools_1.getToolRef)(tool);
+                    if (await isInvalidPropertyRef(toolRef)) {
+                        errors.push({
+                            type: 'notFound',
+                            path: path.concat(typeof tool === 'string' ? ['tools', i] : ['tools', i, 'ref']),
+                            message: `Invalid ref "${toolRef}"`
+                        });
+                    }
+                });
+            }
+        }
+    });
+    return errors;
+}
+async function validateQueryConfig(context, projectSchema, { query, name, operation }) {
+    const location = operation === 'query' ? 'queries' : 'mutations';
+    return validateResolverReferences(context, projectSchema, [location, name, 'resolver'], query.resolver);
+}
+async function validateQueryConfigs(context, projectSchema) {
+    const isLessThanV3_9_0 = (0, lt_js_1.default)(getSemver(projectSchema.schemaVersion), '3.9.0');
+    if (isLessThanV3_9_0) {
+        return [];
+    }
+    const promises = [];
+    for (const [operation, prop] of operationProps) {
+        for (const name of Object.keys(projectSchema[prop])) {
+            promises.push(validateQueryConfig(context, projectSchema, {
+                query: projectSchema[prop][name],
+                operation,
+                name
+            }));
+        }
+    }
+    return (0, lodash_1.flatten)(await Promise.all(promises));
+}
+function listShapeJoins(projectSchema) {
+    const joins = [];
+    for (const shapeKey of Object.keys(projectSchema.shapes)) {
+        const shape = projectSchema.shapes[shapeKey];
+        if (shape.joins) {
+            for (const joinRef of Object.keys(shape.joins)) {
+                const join = shape.joins[joinRef];
+                joins.push({ ref: joinRef, path: ['shapes', shapeKey, 'joins', joinRef], join });
+            }
+        }
+    }
+    return joins;
+}
+function validateLocalShapeJoinRef(projectSchema, item) {
+    const refItem = (0, refs_1.atRefToRefItem)(projectSchema, item.ref);
+    if (refItem.serviceKey === 'local') {
+        const shape = (0, refs_1.refItemToShape)(projectSchema, refItem);
+        if (!shape) {
+            return [
+                {
+                    type: 'notFound',
+                    path: item.path,
+                    message: `Invalid join "${item.ref}" not found`
+                }
+            ];
+        }
+    }
+    return [];
+}
+function validateLocalShapeJoins(projectSchema) {
+    return listShapeJoins(projectSchema).flatMap(item => validateLocalShapeJoinRef(projectSchema, item).concat(validateResolver(projectSchema, item.path.concat('resolver'), item.join.resolver)));
+}
+async function validateShapeJoinRef(context, projectSchema, item) {
+    const refItem = (0, refs_1.atRefToRefItem)(projectSchema, item.ref);
+    if (refItem) {
+        const layer = await context.resolveLayer(refItem.serviceKey);
+        const valid = isValidRef(context, projectSchema, layer, refItem);
+        if (!valid) {
+            return [
+                {
+                    type: 'notFound',
+                    path: item.path,
+                    message: `Invalid join "${item.ref}" not found`
+                }
+            ];
+        }
+    }
+    return [];
+}
+async function validateShapeJoins(context, projectSchema) {
+    const promises = [];
+    for (const item of listShapeJoins(projectSchema)) {
+        promises.push(validateShapeJoinRef(context, projectSchema, item), validateResolverReferences(context, projectSchema, item.path, item.join.resolver));
+    }
+    return (0, lodash_1.flatten)(await Promise.all(promises));
+}
+function validateShapeLoaders(context, projectSchema, shape) {
+    const errors = [];
+    if (shape.loaders) {
+        const getNamespace = (0, refs_1.createGetNamespace)(projectSchema);
+        const listLoader = shape.loaders.list;
+        if (listLoader) {
+            (0, util_1.ensureArray)(listLoader).forEach((config, i) => {
+                const ref = (0, refs_1.parsePropertyRef)(config.query);
+                const query = ref && (0, get_js_1.default)(projectSchema, (0, refs_1.propertyRefItemToPath)(getNamespace, ref));
+                if (!query) {
+                    errors.push({
+                        path: Array.isArray(listLoader)
+                            ? ['shapes', shape.name, 'loaders', 'list', i, 'query']
+                            : ['shapes', shape.name, 'loaders', 'list', 'query'],
+                        type: 'notFound',
+                        message: `Invalid query "${config.query}"`
+                    });
+                }
+            });
+        }
+        const getLoader = shape.loaders.get;
+        if (getLoader) {
+            const ref = (0, refs_1.parsePropertyRef)(getLoader.query);
+            const query = ref && (0, get_js_1.default)(projectSchema, (0, refs_1.propertyRefItemToPath)(getNamespace, ref));
+            if (!query) {
+                errors.push({
+                    path: ['shapes', shape.name, 'loaders', 'get', 'query'],
+                    type: 'notFound',
+                    message: `Invalid query "${getLoader.query}"`
+                });
+            }
+        }
+    }
+    if (shape.cache?.triggers) {
+        const min = context.entitlements?.minScheduleTriggerInterval ?? util_1.DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL;
+        for (let i = 0; i < shape.cache.triggers.length; i++) {
+            const trigger = shape.cache.triggers[i];
+            if (trigger.type === 'schedule' && trigger.interval < min) {
+                errors.push({
+                    path: ['shapes', shape.name, 'cache', 'triggers', i, 'interval'],
+                    type: 'entitlement',
+                    message: `Trigger interval ${trigger.interval} is below minimum ${min}`
+                });
+            }
+        }
+    }
+    return errors;
+}
+function visitProperties(projectSchema, callback) {
+    (0, jsonpath_plus_1.JSONPath)('$..properties.*', projectSchema, (property, _type, { path: propertyPath }) => {
+        callback(property, propertyPath.slice(3, -2).split(`']['`));
+    }, undefined);
+}
+function validateIndexedShapes(context, projectSchema) {
+    const errors = [];
+    const { shapes } = projectSchema;
+    for (const shape of Object.values(shapes)) {
+        const newErrors = validateShapeLoaders(context, projectSchema, shape);
+        if (newErrors.length) {
+            errors.push(...newErrors);
+        }
+    }
+    let nestedCount = 0;
+    visitProperties(projectSchema, (property, propertyPath) => {
+        const indexed = property['@indexed'];
+        if ((0, util_1.isRecord)(indexed) && indexed.nested) {
+            nestedCount += 1;
+            if (property.type !== 'array') {
+                errors.push({
+                    path: propertyPath,
+                    type: 'location',
+                    message: 'Nested indexes may only appear next to fields of type: "array"'
+                });
+            }
+        }
+    });
+    if (nestedCount > 50) {
+        errors.push({
+            path: ['shapes'],
+            type: 'tooMany',
+            message: `${nestedCount} nested indexes found`
+        });
+    }
+    return errors;
+}
+/**
+ * Verify the path has an allOf schema and not just prop named "allOf"
+ */
+function isAllOfPath(path) {
+    const index = path.indexOf('allOf');
+    return index !== -1 && (0, util_1.isIntegerLike)(path[index + 1]);
+}
+function validateLocalRefs(projectSchema) {
+    const errors = [];
+    const shapeNames = new Set([...exports.builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
+    const refs = (0, schema_util_1.getAllRefs)(projectSchema).filter(item => !item.isForeign);
+    for (const item of refs) {
+        if (item.template && !(0, template_shapes_1.isValidTemplate)(item.template)) {
+            errors.push({
+                type: 'notFound',
+                path: item.path,
+                message: `Invalid template "${item.template}"`
+            });
+        }
+        const shapeName = (0, refs_1.refItemToNamespacedShapeName)(item);
+        if (!shapeNames.has(shapeName)) {
+            const invalidRef = (0, get_js_1.default)(projectSchema, item.path);
+            const path = invalidRef.items ? [...item.path, 'items', '@ref'] : item.path;
+            const ref = (0, get_js_1.default)(projectSchema, path);
+            errors.push({
+                type: 'notFound',
+                path,
+                message: `Invalid ref "${ref}"`
+            });
+        }
+        // Make sure refs inside allOf don't refer to their own Shape
+        if (item.path[1] === shapeName && isAllOfPath(item.path)) {
+            errors.push({
+                type: 'conflict',
+                path: item.path,
+                message: `allOf cannot be self-referential`
+            });
+        }
+        const parentPath = (0, initial_js_1.default)(item.path);
+        const parentSchema = (0, get_js_1.default)(projectSchema, parentPath);
+        const propName = (0, last_js_1.default)(item.path);
+        if (propName === '@ref' && parentSchema.$ref) {
+            errors.push({
+                type: 'conflict',
+                path: parentPath,
+                message: `Ref cannot have both @ref and $ref`
+            });
+        }
+    }
+    return errors;
+}
+function isValidRef(context, projectSchema, layer, item) {
+    const { serviceKey: layerId } = item;
+    const shapeName = (0, refs_1.refItemToNamespacedShapeName)(item);
+    const localShapeExists = Boolean(projectSchema.shapes[shapeName]) || exports.builtInShapeNames.has(shapeName);
+    return (item.isValidService &&
+        (layerId === 'local' ? localShapeExists : localShapeExists || isValidShapeReference(context, layer, shapeName)));
+}
+function mustBeInterface({ path }) {
+    return path[0] === 'shapes' && path[2] === 'interfaces';
+}
+async function validateRefs(context, projectSchema) {
+    const { resolveLayer } = context;
+    const errors = [];
+    const refs = (0, schema_util_1.getAllRefs)(projectSchema);
+    const layerIds = new Set();
+    for (const item of refs) {
+        if (item.serviceKey !== 'local') {
+            layerIds.add(item.serviceKey);
+        }
+    }
+    const layersById = Object.fromEntries(await (0, p_map_1.default)(layerIds, async (layerId) => [layerId, await resolveLayer(layerId)]));
+    for (const item of refs) {
+        if (item.template && !(0, template_shapes_1.isValidTemplate)(item.template)) {
+            errors.push({
+                type: 'notFound',
+                path: item.path,
+                message: `Invalid template "${item.path}"`
+            });
+        }
+        const { serviceKey: layerId } = item;
+        const layer = layersById[layerId];
+        const valid = isValidRef(context, projectSchema, layer, item);
+        if (!valid) {
+            errors.push({
+                type: 'notFound',
+                path: item.path,
+                message: `Invalid ref "${(0, get_js_1.default)(projectSchema, item.path)}"`
+            });
+        }
+        else if (mustBeInterface(item) && (layerId === 'local' || layer?.status === 'ok')) {
+            // only validate interfaces with connected layers isValidRef above handles when allowDisconnectedLayers false
+            const context = layer?.schema ?? projectSchema;
+            const shape = (0, get_js_1.default)(context, item.path.slice(0, 2));
+            errors.push(...validateShapeImplementsInterface(context, shape, item, item.path));
+        }
+    }
+    return errors;
+}
+function visitShapePropertiesJson(projectSchema, callback) {
+    (0, jsonpath_plus_1.JSONPath)('shapes.*.schema.properties.*', projectSchema, (property, _type, { path: propertyPath }) => {
+        callback(property, propertyPath.slice(3, -2).split(`']['`));
+    }, undefined);
+}
+function validateDirectives(projectSchema) {
+    const errors = [];
+    visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
+        const resolver = property['@resolver'];
+        if (resolver) {
+            const propPath = propertyPath.concat('@resolver');
+            const resolverErrors = validateResolver(projectSchema, propPath, resolver);
+            if (resolverErrors) {
+                errors.push(...resolverErrors);
+            }
+        }
+    });
+    return errors;
+}
+function validateOneOfs(projectSchema) {
+    const errors = [];
+    visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
+        const oneOfPath = property.items ? ['items', 'oneOf'] : ['oneOf'];
+        const relationship = (0, relationships_1.getRelationship)(property);
+        const schema = (property.items ? property.items : property);
+        const isUnion = (0, unions_1.isUnionSchema)(schema);
+        if (schema.oneOf && !relationship && !isUnion && !(0, enum_1.isEnumLikeSchema)(schema)) {
+            errors.push({
+                type: 'conflict',
+                path: propertyPath.concat(oneOfPath),
+                message: `Invalid oneOf must contain only @ref or title + enum/const schemas`
+            });
+        }
+        if (isUnion &&
+            schema.oneOf.length !== (0, uniqBy_js_1.default)(schema.oneOf, refSchema => (0, refs_1.getRefShapeName)(projectSchema, refSchema)).length) {
+            errors.push({
+                type: 'conflict',
+                path: propertyPath.concat(oneOfPath),
+                message: `Invalid oneOf must not contain duplicate references`
+            });
+        }
+    });
+    return errors;
+}
+function validateLocales(projectSchema) {
+    const { locales, defaultLocale } = projectSchema;
+    const errors = [];
+    if (locales && !locales.includes(defaultLocale)) {
+        errors.push({
+            type: 'notFound',
+            path: ['locales'],
+            message: `Default locale "${defaultLocale}" missing from locales`
+        });
+    }
+    return errors;
+}
+const importantFields = ['type', '@ref', 'allOf', 'oneOf', 'anyOf', 'extends', 'items', '@tag'];
+function isSchemaEqual(a, b) {
+    return (0, isEqual_js_1.default)((0, pick_js_1.default)(a, importantFields), (0, pick_js_1.default)(b, importantFields));
+}
+function matchesInterface(shape, interfaceShape, path) {
+    const errors = [];
+    const { schema } = shape;
+    const interfaceSchema = interfaceShape.schema;
+    for (const name of Object.keys(interfaceSchema.properties)) {
+        const propSchema = schema.properties[name];
+        const interfacePropSchema = interfaceSchema.properties[name];
+        if (!propSchema) {
+            errors.push({
+                type: 'notFound',
+                path,
+                message: `"${shape.name}" is missing property "${name}" required by interface "${interfaceShape.name}"`
+            });
+        }
+        else if (!isSchemaEqual(propSchema, interfacePropSchema)) {
+            errors.push({
+                type: 'conflict',
+                path: [...path, name],
+                message: `"${shape.name}.${name}" must match "${interfaceShape.name}.${name}"`
+            });
+        }
+        else {
+            const propRequired = Boolean(schema.required?.includes(name));
+            const interfacePropRequired = Boolean(interfaceSchema.required?.includes(name));
+            if (interfacePropRequired !== propRequired) {
+                errors.push({
+                    type: 'conflict',
+                    path: [...path, name],
+                    message: `"${shape.name}.${name}" must ${interfacePropRequired ? '' : 'not '}be required to  match "${interfaceShape.name}.${name}"`
+                });
+            }
+        }
+    }
+    return errors;
+}
+function validateShapeImplementsInterface(projectSchema, shape, interfaceRefItem, path) {
+    const errors = [];
+    const interfaceShape = (0, refs_1.refItemToShape)(projectSchema, interfaceRefItem);
+    if (!interfaceShape) {
+        errors.push({
+            type: 'notFound',
+            path,
+            message: `Invalid interface "${(0, refs_1.refItemToAtRef)(interfaceRefItem)}" not found`
+        });
+    }
+    else if (interfaceShape.type !== 'interface') {
+        errors.push({
+            type: 'conflict',
+            path,
+            message: `"${shape.name}" cannot implement non-interface "${interfaceShape.name}"`
+        });
+    }
+    else if ((0, utils_1.isExtendsSchema)(shape.schema)) {
+        // TODO stricter extends validation needs https://app.shortcut.com/takeshape/story/9783/use-service-schemas-during-schema-validation
+    }
+    else if ((0, utils_1.isObjectSchema)(shape.schema) && (0, utils_1.isObjectSchema)(interfaceShape.schema)) {
+        const matchErrors = matchesInterface(shape, interfaceShape, [
+            'shapes',
+            shape.name,
+            'schema',
+            'properties'
+        ]);
+        if (matchErrors.length) {
+            errors.push(...matchErrors);
+        }
+    }
+    return errors;
+}
+function validateInterfaceImplementations(projectSchema) {
+    const errors = [];
+    for (const shape of Object.values(projectSchema.shapes)) {
+        if (shape.interfaces?.length) {
+            if (!(0, utils_1.isObjectSchema)(shape.schema) && !(0, utils_1.isExtendsSchema)(shape.schema)) {
+                return [
+                    {
+                        path: ['shapes', shape.name, 'schema'],
+                        type: 'conflict',
+                        message: `"${shape.name}" must have an object or extends schema to implement interfaces`
+                    }
+                ];
+            }
+        }
+    }
+    return errors;
+}
+function validateAgents(projectSchema) {
+    const getNamespace = (0, refs_1.createGetNamespace)(projectSchema);
+    const errors = [];
+    const agents = projectSchema['ai-experimental']?.agents;
+    if (!agents) {
+        return errors;
+    }
+    for (const [agentName, agent] of Object.entries(agents)) {
+        const stateNames = new Set();
+        for (const [stateId, state] of Object.entries(agent.states)) {
+            const statePath = ['ai-experimental', 'agents', agentName, 'states', stateId];
+            if (stateNames.has(state.name)) {
+                errors.push({
+                    path: [...statePath, 'name'],
+                    type: 'conflict',
+                    message: `Duplicate state name "${state.name}"`
+                });
+            }
+            else {
+                stateNames.add(state.name);
+            }
+            if (state.execution.type === 'generate' || state.execution.type === 'chat') {
+                if (!state.execution.tools) {
+                    continue;
+                }
+                state.execution.tools.forEach((tool, toolIndex) => {
+                    pushErrors(errors, validateAIToolConfig(projectSchema, getNamespace, tool, [
+                        ...statePath,
+                        'execution',
+                        'tools',
+                        toolIndex,
+                        'ref'
+                    ]));
+                });
+            }
+        }
+    }
+    return errors;
+}
+function validateInterfaces(projectSchema) {
+    const errors = [];
+    // Validate interface shapes must be an object schema with at least one property
+    for (const shape of Object.values(projectSchema.shapes)) {
+        if (shape.type === 'interface') {
+            if (shape.model) {
+                errors.push({
+                    path: ['shapes', shape.name, 'model'],
+                    type: 'conflict',
+                    message: `"${shape.name}" may not be both an interface and model. Create a separate model shape which implements this interface.`
+                });
+            }
+            else if ((0, utils_1.isObjectSchema)(shape.schema)) {
+                if ((0, size_js_1.default)(shape.schema.properties) === 0) {
+                    errors.push({
+                        path: ['shapes', shape.name, 'schema', 'properties'],
+                        type: 'conflict',
+                        message: `Interface "${shape.name}" must define at least one property`
+                    });
+                }
+            }
+            else {
+                errors.push({
+                    path: ['shapes', shape.name, 'schema'],
+                    type: 'conflict',
+                    message: `Interface "${shape.name}" must define an object schema`
+                });
+            }
+        }
+    }
+    return errors;
+}
+function formatError(error) {
+    let pathStr = error.instancePath;
+    let message = error.message ?? '';
+    if ('missingProperty' in error.params) {
+        pathStr = `${pathStr}.${error.params.missingProperty}`;
+    }
+    if ('additionalProperty' in error.params) {
+        pathStr = `${pathStr}.${error.params.additionalProperty}`;
+        message = `${message} "${error.params.additionalProperty}"`;
+    }
+    if ('allowedValues' in error.params) {
+        message = `${message} "${error.params.allowedValues.join('", "')}"`;
+    }
+    const path = pathStr === '' ? [] : pathStr.substr(1).split(/\.|\/|\['|']\./);
+    return {
+        type: 'json',
+        message,
+        path
+    };
+}
+exports.formatError = formatError;
+function isValidateReferencesContext(context) {
+    return Boolean(context.resolveLayer);
+}
+const ajv = (0, json_schema_1.createAjv)();
+function validateStructure(schemaVersion, context, schema, ref) {
+    const coerced = (0, coerce_js_1.default)(schemaVersion);
+    const versionStr = coerced?.format();
+    const hasExperimental = Boolean(coerced && (0, gte_js_1.default)(coerced, '3.48.0'));
+    const relevantSchemas = schemas_1.allProjectSchemas.filter(metaSchema => (hasExperimental && metaSchema.$id.endsWith('experimental#')) || metaSchema.$id.endsWith(`v${versionStr}#`));
+    for (const relevantSchema of relevantSchemas) {
+        if (!ajv.getSchema(relevantSchema.$id)) {
+            ajv.addSchema(relevantSchema);
+        }
+    }
+    ajv.validate(`https://schema.takeshape.io/project-schema/v${versionStr}#${ref ?? ''}`, schema);
+    let errors = ajv.errors?.map(formatError) ?? [];
+    const { suppressErrorPaths } = context;
+    if (errors.length && suppressErrorPaths) {
+        errors = errors.filter(error => {
+            return !suppressErrorPaths.includes(error.path.join('.'));
+        });
+    }
+    if (errors.length) {
+        return {
+            valid: false,
+            schema: undefined,
+            errors
+        };
+    }
+    return { valid: true, schema: schema, errors: undefined };
+}
+function formatValidationResult(context, errors, schema) {
+    const { suppressErrorPaths } = context;
+    if (suppressErrorPaths) {
+        errors = errors.filter(error => {
+            return !suppressErrorPaths.includes(error.path.join('.'));
+        });
+    }
+    return errors.length ? { valid: false, schema: undefined, errors } : { valid: true, schema, errors: undefined };
+}
+function validateSyntax(context, schema) {
+    let errors = [];
+    errors = errors
+        .concat(checkShapeNames(schema.shapes))
+        .concat(checkShapeIds(schema.shapes))
+        .concat(validateWorkflows(schema))
+        .concat(validateLocalQueryConfigs(schema))
+        .concat(validateLocalRefs(schema))
+        .concat(validateLocalShapeJoins(schema))
+        .concat(validateDirectives(schema))
+        .concat(validateLocales(schema))
+        .concat(checkWorkflowStepNames(schema.workflows))
+        .concat(checkWorkflowStepKeys(schema.workflows))
+        .concat(validateOneOfs(schema))
+        .concat(validateIndexedShapes(context, schema))
+        .concat(validateInterfaces(schema))
+        .concat(validateInterfaceImplementations(schema))
+        .concat(validateAgents(schema));
+    return formatValidationResult(context, errors, schema);
+}
+async function validateReferences(context, schema) {
+    const errors = (0, lodash_1.flatten)(await Promise.all([
+        validateRefs(context, schema),
+        validateQueryConfigs(context, schema),
+        validateShapeJoins(context, schema)
+    ]));
+    return formatValidationResult(context, errors, schema);
+}
+const schemaUndefinedResult = {
+    valid: false,
+    schema: undefined,
+    errors: [{ path: [], type: 'undefined', message: 'Schema is undefined' }]
+};
+const invalidVersionResult = {
+    valid: false,
+    schema: undefined,
+    errors: [{ path: [], type: 'invalidVersion', message: 'Unknown schema version' }]
+};
+function normalizeSchemaVersion(obj) {
+    if ((0, util_1.isRecord)(obj)) {
+        return typeof obj.schemaVersion === 'string' ? obj.schemaVersion : '1';
+    }
+}
+function validateSchemaSyntax(obj, options = {}) {
+    if ((0, isUndefined_js_1.default)(obj)) {
+        return schemaUndefinedResult;
+    }
+    const schemaVersion = normalizeSchemaVersion(obj);
+    if (!schemaVersion) {
+        return invalidVersionResult;
+    }
+    return validateStructure(schemaVersion, options, obj);
+}
+exports.validateSchemaSyntax = validateSchemaSyntax;
+/**
+ * Validates a schema using a matching validation based on the `schemaVersion` property.
+ */
+async function validateSchema(context, obj) {
+    if ((0, isUndefined_js_1.default)(obj)) {
+        return schemaUndefinedResult;
+    }
+    const contextWithDefaults = {
+        allowDisconnectedLayers: true,
+        ...context
+    };
+    const schemaVersion = normalizeSchemaVersion(obj);
+    if (!schemaVersion) {
+        return invalidVersionResult;
+    }
+    const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj);
+    if (!structuralValidation.valid) {
+        return structuralValidation;
+    }
+    const { schema } = structuralValidation;
+    if (!(0, project_schema_1.isLatestProjectSchemaJSON)(schema)) {
+        return invalidVersionResult;
+    }
+    const syntaxValidation = validateSyntax(contextWithDefaults, schema);
+    if (!syntaxValidation.valid || !isValidateReferencesContext(contextWithDefaults)) {
+        return syntaxValidation;
+    }
+    return validateReferences(contextWithDefaults, schema);
+}
+exports.validateSchema = validateSchema;
+function ensureValidLatestSchemaSyntax(obj) {
+    const { valid, schema, errors } = validateSchemaSyntax(obj);
+    if (!valid && errors) {
+        throw new Error(`Invalid Schema "${errors[0].path.join(',')}": "${errors[0].message}"`);
+    }
+    if ((0, isUndefined_js_1.default)(schema)) {
+        throw new Error(`Invalid schema: schema is undefined`);
+    }
+    if ((0, neq_js_1.default)(versions_1.CURRENT_SCHEMA_VERSION, (0, coerce_js_1.default)(schema.schemaVersion) ?? versions_1.LEGACY_SCHEMA_VERSION)) {
+        throw new Error(`Expected schemaVersion: "${versions_1.CURRENT_SCHEMA_VERSION}", got "${schema.schemaVersion}"`);
+    }
+    return schema;
+}
+exports.ensureValidLatestSchemaSyntax = ensureValidLatestSchemaSyntax;
+/**
+ * The roles import validator ensures required properties, and strips several
+ * which might exist in an export but wouldn't apply to an import operation.
+ */
+function createRoleInputValidator() {
+    const validator = (0, json_schema_1.createAjv)({ useDefaults: true, removeAdditional: true });
+    const { RoleInput, ...definitions } = auth_schemas_json_1.default.definitions;
+    return validator.compile({
+        $id: 'RoleInput',
+        definitions,
+        ...RoleInput
+    });
+}
+/**
+ * Validates and returns a `RoleInput`, which is a subset of the `Role`
+ * type's properties suitable for importing.
+ */
+function validateRoleInput(maybeRoleInput) {
+    const validate = createRoleInputValidator();
+    if (validate(maybeRoleInput)) {
+        return maybeRoleInput;
+    }
+    throw new errors_1.SchemaValidationError('RoleInput was invalid', validate.errors?.map(formatError));
+}
+exports.validateRoleInput = validateRoleInput;
+/**
+ * The roles import validator ensures required properties, and strips several
+ * which might exist in an export but wouldn't apply to an import operation.
+ */
+function createRoleImportValidator() {
+    const validator = (0, json_schema_1.createAjv)({ useDefaults: true, removeAdditional: true });
+    const { RoleImport, ...definitions } = auth_schemas_json_1.default.definitions;
+    return validator.compile({
+        $id: 'RoleImport',
+        definitions,
+        ...RoleImport
+    });
+}
+/**
+ * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
+ */
+function ensureValidRoleImport(maybeRoles) {
+    const validate = createRoleImportValidator();
+    if (validate(maybeRoles)) {
+        return maybeRoles;
+    }
+    throw new errors_1.SchemaValidationError('Roles were invalid', validate.errors?.map(formatError));
+}
+exports.ensureValidRoleImport = ensureValidRoleImport;
+/**
+ * Only use when validating an imported schema! ignore fields optional when importing
+ */
+function validateProjectSchemaImport(maybeSchema) {
+    return validateSchemaSyntax(maybeSchema, {
+        suppressErrorPaths: [...types_1.projectSchemaImportOptionalProps, ...types_1.legacyProjectSchemaImportOptionalProps]
+    });
+}
+exports.validateProjectSchemaImport = validateProjectSchemaImport;
+/**
+ * Only use when validating an imported schema!
+ *
+ * New style validation for parity with the `validateRoleImport` fn. Returns
+ * a valid, clean `ImportProjectSchema` or throws a `SchemaValidationError`.
+ */
+function ensureValidProjectSchemaImport(maybeSchema) {
+    const validateResult = validateProjectSchemaImport(maybeSchema);
+    if (validateResult.valid) {
+        return validateResult.schema;
+    }
+    throw new errors_1.SchemaValidationError('ProjectSchema could not be validated', validateResult.errors);
+}
+exports.ensureValidProjectSchemaImport = ensureValidProjectSchemaImport;