@takeshape/schema 11.52.0 → 11.55.0

package/dist/__tests__/validate.test.js

@@ -0,0 +1,1926 @@
+import rickAndMortyLayer from '@/examples/latest/layers/rick-and-morty-layer.json';
+import shopifyLayer from '@/examples/latest/layers/shopify-layer-2023-01.json';
+import { assert, DEFAULT_ENTITLEMENTS, deepClone } from '@takeshape/util';
+import get from 'lodash/get.js';
+import omit from 'lodash/omit.js';
+import set from 'lodash/set.js';
+import shortid from 'shortid';
+import { describe, expect, it, test } from 'vitest';
+import agentSchemaJson from '../../examples/latest/agent-schema.json';
+import shapeBooksLatestJson from '../../examples/latest/shape-books.json';
+import shopifySchemaWithInterfacesJson from '../../examples/latest/shopify-product-2022-07.json';
+import shopifySchemaLatestJson from '../../examples/latest/shopify-store-with-widget.json';
+import { createMockSchema, createMockStoredServiceConfig } from "../mocks.js";
+import { applyDefaultsToSchema, createShape } from "../schema-util.js";
+import { ensureValidProjectSchemaImport, ensureValidRoleImport, validateRoleInput, validateSchema } from "../validate/validate.js";
+const layers = {
+    shopify: shopifyLayer,
+    rick: rickAndMortyLayer,
+    'gregs-takeshape-store': shopifyLayer
+};
+const openaiService = {
+    id: 'openai',
+    provider: 'openai',
+    serviceType: 'openapi',
+    namespace: 'OpenAI',
+    title: 'OpenAI',
+    authenticationType: 'none'
+};
+const validateContext = {
+    entitlements: DEFAULT_ENTITLEMENTS,
+    async resolveLayer(layerId) {
+        if (layers[layerId]) {
+            return { id: layerId, status: 'ok', schema: layers[layerId] };
+        }
+        return { id: layerId, status: 'error', schema: undefined };
+    }
+};
+/**
+ * Tests that run against the latest schema version only, can use migrated schemas.
+ */
+describe('latest', () => {
+    function shapeBooksSchemaLatest() {
+        return deepClone(applyDefaultsToSchema(shapeBooksLatestJson));
+    }
+    function shopifySchemaLatest() {
+        return deepClone(applyDefaultsToSchema(shopifySchemaLatestJson));
+    }
+    function shopifySchemaLatestWithInterfaces() {
+        return deepClone(applyDefaultsToSchema(shopifySchemaWithInterfacesJson));
+    }
+    function agentSchema() {
+        return deepClone(applyDefaultsToSchema(agentSchemaJson));
+    }
+    test('validateSchema - shopify valid', async () => {
+        const validSchema = shopifySchemaLatestWithInterfaces();
+        const { valid, schema, errors } = await validateSchema(validateContext, validSchema);
+        expect(errors).toEqual(undefined);
+        expect(valid).toBe(true);
+        expect(schema).toEqual(validSchema);
+        expect(errors).toEqual(undefined);
+    });
+    test('validateSchema - validates with missing property errors suppressed', async () => {
+        const mockProjectSchema = omit(shapeBooksSchemaLatest(), [
+            'projectId',
+            'locales',
+            'defaultLocale',
+            'author'
+        ]);
+        const { valid, schema, errors } = await validateSchema({
+            ...validateContext,
+            suppressErrorPaths: ['projectId', 'locales', 'defaultLocale', 'author']
+        }, mockProjectSchema);
+        expect(errors).toEqual(undefined);
+        expect(valid).toBe(true);
+        expect(schema).toEqual(mockProjectSchema);
+    });
+    test('validateSchema - conflicting shape ids', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['shapes', 'Post', 'id'], 'rJBYXVyuQ');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'conflict',
+                message: 'Shapes must have unique ids. "rJBYXVyuQ" is not unique.',
+                path: ['shapes', 'Tag', 'id']
+            },
+            {
+                type: 'conflict',
+                message: 'Shapes must have unique ids. "rJBYXVyuQ" is not unique.',
+                path: ['shapes', 'Post', 'id']
+            }
+        ]);
+    });
+    test('validateSchema - invalid workflow', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['shapes', 'Book', 'workflow'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid Workflow "bogus" for shape "Book"',
+                path: ['shapes', 'Book', 'workflow']
+            }
+        ]);
+    });
+    test('validateSchema - invalid ref due to invalid $ref path', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        validSchema.shapes.Book.schema.properties.author['@ref'] = undefined;
+        const invalidSchema = set(validSchema, ['shapes', 'Book', 'schema', 'properties', 'author', '$ref'], '#/shapes/bogus/schema');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "#/shapes/bogus/schema"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'author', '$ref']
+            }
+        ]);
+    });
+    test('validateSchema - invalid ref due to unknown service id', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        validSchema.shapes.Book.schema.properties.author['@ref'] = undefined;
+        const invalidSchema = set(validSchema, ['shapes', 'Book', 'schema', 'properties', 'author', '@ref'], 'bogus:Book');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "bogus:Book"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'author', '@ref']
+            }
+        ]);
+    });
+    test('validateSchema - invalid ref for array type', async () => {
+        const invalidSchema = shapeBooksSchemaLatest();
+        invalidSchema.shapes.Book.schema.properties.author['@ref'] = undefined;
+        set(invalidSchema, ['shapes', 'Book', 'schema', 'properties', 'author', 'type'], 'array');
+        set(invalidSchema, ['shapes', 'Book', 'schema', 'properties', 'author', 'items', '@ref'], 'local:Bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "local:Bogus"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'author', 'items', '@ref']
+            }
+        ]);
+    });
+    test('validateSchema - allows built-in shapes to be used in resolvers', async () => {
+        const validSchema = createMockSchema('project-id', {
+            queries: {
+                listAssets: {
+                    shape: 'PaginatedList<Asset>',
+                    resolver: {
+                        name: 'shapedb:list',
+                        service: 'shapedb',
+                        shapeName: 'Asset'
+                    },
+                    args: 'TSListArgs<Asset>'
+                }
+            }
+        });
+        const { valid } = await validateSchema(validateContext, validSchema);
+        expect(valid).toBe(true);
+    });
+    test('validateSchema - broken query shape', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['queries', 'getBook', 'shape'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "bogus"',
+                path: ['queries', 'getBook', 'shape']
+            }
+        ]);
+    });
+    test('validateSchema - broken mutation shape', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['mutations', 'createBook', 'shape'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "bogus"',
+                path: ['mutations', 'createBook', 'shape']
+            }
+        ]);
+    });
+    test('validateSchema - broken relationship', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['shapes', 'Book', 'schema', 'properties', 'author', 'oneOf'], [{ '@ref': 'local:bogus' }]);
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid ref "local:bogus"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'author', 'oneOf', '0', '@ref']
+            }
+        ]);
+    });
+    test('validateSchema - invalid resolver.name', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['queries', 'getBook', 'resolver', 'name'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toMatchSnapshot();
+    });
+    test('validateSchema - invalid takeshape resolver.service', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['queries', 'getBook', 'resolver', 'service'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toMatchSnapshot();
+    });
+    test('validateSchema - invalid regular resolver.service', async () => {
+        const validSchema = shopifySchemaLatest();
+        const invalidSchema = set(validSchema, ['shapes', 'Product', 'schema', 'properties', 'gregsTakeshapeStore', '@resolver', 'service'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid service "bogus"',
+                path: ['shapes', 'Product', 'schema', 'properties', 'gregsTakeshapeStore', '@resolver', 'service']
+            }
+        ]);
+    });
+    test('validateSchema - invalid resolver.service in compose', async () => {
+        const validSchema = shopifySchemaLatest();
+        const resolverPath = ['shapes', 'Product', 'schema', 'properties', 'gregsTakeshapeStore', '@resolver'];
+        const resolver = get(validSchema, resolverPath);
+        const invalidComposedResolver = {
+            compose: [
+                {
+                    ...resolver,
+                    service: 'bogus'
+                }
+            ]
+        };
+        const invalidSchema = set(validSchema, resolverPath, invalidComposedResolver);
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid service "bogus"',
+                path: [...resolverPath, 'compose', 0, 'service']
+            }
+        ]);
+    });
+    test('validateSchema - invalid Shape.name', async () => {
+        const schema = shapeBooksSchemaLatest();
+        schema.shapes.Book.name = 'NotBook';
+        // Avoid the noisy extra error generated by a bad relationship
+        set(schema, ['shapes', 'Homepage', 'schema', 'properties', 'featuredBook'], { type: 'string' });
+        expect(await validateSchema(validateContext, schema)).toEqual({
+            errors: [
+                {
+                    message: 'Shape.name "NotBook" must match key "Book".',
+                    path: ['shapes', 'Book', 'name'],
+                    type: 'conflict'
+                }
+            ],
+            valid: false
+        });
+    });
+    test('validateSchema - invalid @resolver.name', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['shapes', 'Product', 'schema', 'properties', 'gregsTakeshapeStore', '@resolver', 'name'], 'bogus');
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toMatchSnapshot();
+    });
+    test('validateSchema - defaultLocale missing from locales', async () => {
+        const validSchema = shapeBooksSchemaLatest();
+        const invalidSchema = set(validSchema, ['locales'], ['de-de', 'es-es']);
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Default locale "en-us" missing from locales',
+                path: ['locales'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - valid delegate resolver', async () => {
+        const query = {
+            shape: 'Shopify_Product',
+            resolver: { name: 'delegate', to: 'shopify:Query.products' }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), 'queries.delegateProducts', query);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual(undefined);
+    });
+    test('validateSchema - invalid delegate resolver property ref', async () => {
+        const query = {
+            shape: 'Shopify_Product',
+            resolver: { name: 'delegate', to: 'mr.super.bogus' }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), 'queries.delegateProducts', query);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Unable to parse property ref "mr.super.bogus"',
+                path: ['queries', 'delegateProducts', 'resolver', 'to'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - invalid delegate resolver missing resolver config', async () => {
+        const query = {
+            shape: 'Shopify_Product',
+            resolver: { name: 'delegate', to: 'Query.bogusProducts' }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), 'queries.delegateProducts', query);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Missing resolver config at property ref "Query.bogusProducts"',
+                path: ['queries', 'delegateProducts', 'resolver', 'to'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - invalid delegate resolver - missing remote property', async () => {
+        const query = {
+            shape: 'Shopify_Product',
+            resolver: { name: 'delegate', to: 'shopify:Query.bogusProducts' }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), 'queries.delegateProducts', query);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Missing resolver config at property ref "shopify:Query.bogusProducts"',
+                path: ['queries', 'delegateProducts', 'resolver', 'to'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - valid ai:generateText resolver', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant'
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual(undefined);
+    });
+    test('validateSchema - ai:generateText invalid tools', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant',
+                tools: [
+                    'bogus',
+                    {
+                        ref: 'shopify:customer'
+                    },
+                    {
+                        ref: 'anotherBogus'
+                    }
+                ]
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Missing tool query "bogus"',
+                path: ['mutations', 'chat', 'resolver', 'tools', 0],
+                type: 'notFound'
+            },
+            {
+                message: 'Missing tool query "anotherBogus"',
+                path: ['mutations', 'chat', 'resolver', 'tools', 2, 'ref'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - ai:generateText invalid remote tools', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant',
+                tools: [
+                    'shopify:customer',
+                    {
+                        ref: 'shopify:bogus'
+                    }
+                ]
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid ref "shopify:bogus"',
+                path: ['mutations', 'chat', 'resolver', 'tools', 1, 'ref'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - ai:generateText invalid options.toolChoice "required"', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant',
+                options: {
+                    toolChoice: 'required'
+                }
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Must have at least one tool configured to specify "required"',
+                path: ['mutations', 'chat', 'resolver', 'options', 'toolChoice'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - ai:generateText valid options.toolChoice', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant',
+                tools: [{ ref: 'shopify:customer' }],
+                options: {
+                    toolChoice: 'shopify:Query.customer'
+                }
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual(undefined);
+    });
+    test('validateSchema - ai:generateText invalid options.toolChoice missing', async () => {
+        const query = {
+            shape: 'TSChatResponse',
+            resolver: {
+                name: 'ai:generateText',
+                service: 'openai',
+                model: 'gpt-4o',
+                systemPrompt: 'You are a helpful assistant',
+                tools: ['shopify:customer'],
+                options: {
+                    toolChoice: 'bogus'
+                }
+            }
+        };
+        let projectSchema = shopifySchemaLatestWithInterfaces();
+        projectSchema = set(projectSchema, 'mutations.chat', query);
+        projectSchema = set(projectSchema, 'services.openai', openaiService);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Missing tool "bogus" must be specified in "tools" array',
+                path: ['mutations', 'chat', 'resolver', 'options', 'toolChoice'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - joins - invalid local shape', async () => {
+        const join = {
+            resolver: {
+                name: 'shapedb:get',
+                service: 'shapedb',
+                shapeName: 'BOGUS'
+            }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), ['shapes', 'Shopify_Product', 'joins', 'local:Bogus'], join);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid join "local:Bogus" not found',
+                path: ['shapes', 'Shopify_Product', 'joins', 'local:Bogus'],
+                type: 'notFound'
+            },
+            {
+                message: 'Invalid Model Shape "BOGUS"',
+                path: ['shapes', 'Shopify_Product', 'joins', 'local:Bogus', 'resolver', 'shapeName'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - joins - invalid shapedb join', async () => {
+        const join = {
+            resolver: {
+                name: 'shapedb:get',
+                service: 'shapedb',
+                shapeName: 'BOGUS'
+            }
+        };
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), ['shapes', 'Shopify_Product', 'joins', 'local:Bogus'], join);
+        set(projectSchema, ['shapes', 'Bogus'], createShape('Bogus', { type: 'object', properties: {} }));
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid Model Shape "BOGUS"',
+                path: ['shapes', 'Shopify_Product', 'joins', 'local:Bogus', 'resolver', 'shapeName'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - joins - valid delegate join', async () => {
+        const shape = createShape('Product', {
+            type: 'object',
+            properties: {
+                shopifyProductId: { type: 'string' }
+            }
+        }, {
+            joins: {
+                'shopify:Product': {
+                    resolver: {
+                        name: 'delegate',
+                        to: 'shopify:Query.product',
+                        args: {
+                            ops: [{ path: 'id', mapping: '$source.shopifyProductId' }]
+                        }
+                    }
+                }
+            }
+        });
+        const projectSchema = set(shopifySchemaLatestWithInterfaces(), ['shapes', 'Product'], shape);
+        const { errors } = await validateSchema(validateContext, projectSchema);
+        expect(errors).toEqual(undefined);
+    });
+    function createPetSchema() {
+        return {
+            ...createMockSchema('project-id'),
+            shapes: {
+                Petstore: {
+                    id: 'i8tv9QutR',
+                    name: 'Petstore',
+                    title: 'Petstore',
+                    workflow: 'default',
+                    model: { type: 'multiple' },
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            pets: {
+                                type: 'array',
+                                '@mapping': 'shapedb:Petstore.aaa3LRPxC',
+                                items: {
+                                    oneOf: [{ '@ref': 'local:Dog' }, { '@ref': 'local:Cat' }]
+                                },
+                                title: 'Pets'
+                            }
+                        }
+                    }
+                },
+                Dog: {
+                    id: '7PSFIZU-N',
+                    name: 'Dog',
+                    title: 'Dog',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                title: 'Name',
+                                '@mapping': 'shapedb:Dog.i7S3LRPxC'
+                            },
+                            rank: {
+                                type: 'string',
+                                title: 'Rank',
+                                '@mapping': 'shapedb:Dog.yOvol-ZPg'
+                            }
+                        }
+                    }
+                },
+                Cat: {
+                    id: 'k49WhBWPs',
+                    name: 'Cat',
+                    title: 'Cat',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                title: 'Name',
+                                '@mapping': 'shapedb:Cat.tbWPT2kvU'
+                            },
+                            breed: {
+                                type: 'string',
+                                title: 'Breed',
+                                '@mapping': 'shapedb:Cat.XuyPh7IHw',
+                                oneOf: [
+                                    {
+                                        title: 'Maine Coon',
+                                        enum: ['stuart']
+                                    },
+                                    {
+                                        title: 'Tabby',
+                                        enum: ['tabby']
+                                    },
+                                    {
+                                        title: 'Russian Blue',
+                                        enum: ['pelmeni']
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    test('validateSchema - mixed oneOf', async () => {
+        const invalidSchema = set(createPetSchema(), ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items'], {
+            oneOf: [{ '@ref': 'local:Dog' }, { type: 'string' }]
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid oneOf must contain only @ref or title + enum/const schemas',
+                path: ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items', 'oneOf'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - ref with @ref and $ref', async () => {
+        const invalidSchema = set(createPetSchema(), ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items'], {
+            oneOf: [{ '@ref': 'local:Dog', $ref: '#/shapes/Cat/schema' }]
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Ref cannot have both @ref and $ref',
+                path: ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items', 'oneOf', '0'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - oneOf with duplicate', async () => {
+        const invalidSchema = set(createPetSchema(), ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items'], {
+            oneOf: [{ '@ref': 'local:Dog' }, { '@ref': 'local:Dog' }]
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid oneOf must not contain duplicate references',
+                path: ['shapes', 'Petstore', 'schema', 'properties', 'pets', 'items', 'oneOf'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - self-referential allOf', async () => {
+        const invalidSchema = {
+            ...createMockSchema('project-id'),
+            shapes: {
+                BadShape: {
+                    name: 'BadShape',
+                    title: 'BadShape',
+                    id: 'BadShape',
+                    schema: {
+                        allOf: [{ '@ref': 'local:BadShape' }]
+                    }
+                }
+            }
+        };
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'allOf cannot be self-referential',
+                path: ['shapes', 'BadShape', 'schema', 'allOf', '0', '@ref'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - cannot be both model and interface', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                FooBar: {
+                    name: 'FooBar',
+                    title: 'FooBar',
+                    id: 'FooBar',
+                    type: 'interface',
+                    model: { type: 'multiple' },
+                    schema: {
+                        enum: ['foo', 'bar', 'baz']
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"FooBar" may not be both an interface and model. Create a separate model shape which implements this interface.',
+                path: ['shapes', 'FooBar', 'model'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - invalid non-object interface', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                FooBar: {
+                    name: 'FooBar',
+                    title: 'FooBar',
+                    id: 'FooBar',
+                    type: 'interface',
+                    schema: {
+                        enum: ['foo', 'bar', 'baz']
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Interface "FooBar" must define an object schema',
+                path: ['shapes', 'FooBar', 'schema'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - invalid empty object interface', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                FooBar: {
+                    name: 'FooBar',
+                    title: 'FooBar',
+                    id: 'FooBar',
+                    type: 'interface',
+                    schema: {
+                        type: 'object',
+                        properties: {}
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Interface "FooBar" must define at least one property',
+                path: ['shapes', 'FooBar', 'schema', 'properties'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - missing interface', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['Node'],
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            title: {
+                                type: 'string'
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid ref "Node"',
+                path: ['shapes', 'Book', 'interfaces', 0],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - interface ref to disconnected layer', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['disconnected:Node'],
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            title: {
+                                type: 'string'
+                            }
+                        }
+                    }
+                }
+            },
+            services: {
+                disconnected: {
+                    id: 'disconnected',
+                    provider: 'shopify',
+                    title: 'Shopify',
+                    namespace: 'Shopify',
+                    serviceType: 'graphql',
+                    authenticationType: 'custom'
+                }
+            }
+        });
+        expect((await validateSchema({ ...validateContext, allowDisconnectedLayers: true }, invalidSchema)).valid).toBe(true);
+        const { valid, schema, errors } = await validateSchema({ ...validateContext, allowDisconnectedLayers: false }, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: 'Invalid ref "disconnected:Node"',
+                path: ['shapes', 'Book', 'interfaces', 0],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - implement non-interface', async () => {
+        const objectSchema = {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string'
+                }
+            }
+        };
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Foo: createShape('Foo', objectSchema, { interfaces: ['Bar'] }),
+                Bar: createShape('Bar', objectSchema)
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"Foo" cannot implement non-interface "Bar"',
+                path: ['shapes', 'Foo', 'interfaces', 0],
+                type: 'conflict'
+            }
+        ]);
+    });
+    const Node = {
+        name: 'Node',
+        title: 'Node',
+        id: 'Node',
+        type: 'interface',
+        schema: {
+            type: 'object',
+            properties: {
+                id: {
+                    '@tag': 'id',
+                    type: 'string'
+                }
+            },
+            required: ['id']
+        }
+    };
+    test('validateSchema - invalid implementation non object', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Node,
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['Node'],
+                    schema: {
+                        enum: ['lol', 'it', 'might', 'work']
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"Book" must have an object or extends schema to implement interfaces',
+                path: ['shapes', 'Book', 'schema'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - invalid implementation missing property', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Node,
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['Node'],
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            title: {
+                                type: 'string'
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"Book" is missing property "id" required by interface "Node"',
+                path: ['shapes', 'Book', 'schema', 'properties'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - invalid implementation non-matching property', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Node,
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['Node'],
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: 'string'
+                                // missing @tag
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"Book.id" must match "Node.id"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'id'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - invalid implementation non-matching property required', async () => {
+        const invalidSchema = createMockSchema('projectId', {
+            shapes: {
+                Node,
+                Book: {
+                    name: 'Book',
+                    title: 'Book',
+                    id: 'Book',
+                    interfaces: ['Node'],
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: 'string',
+                                '@tag': 'id'
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, schema, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(schema).toEqual(undefined);
+        expect(errors).toEqual([
+            {
+                message: '"Book.id" must be required to  match "Node.id"',
+                path: ['shapes', 'Book', 'schema', 'properties', 'id'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    const createMockRoleInput = () => ({
+        name: 'mockRole',
+        conditions: {
+            'ForAllValues:StringEquals': {
+                'claims:provider': 'mockService'
+            }
+        },
+        permissions: {
+            Version: '2012-10-17',
+            Statement: [
+                {
+                    Resource: ['ts:workflow-step:4a0614fc-9519-4dbe-976a-99622dc4fe37:*'],
+                    Effect: 'Allow',
+                    Action: ['workflow-step:*']
+                },
+                {
+                    Resource: ['ts:graphql:4a0614fc-9519-4dbe-976a-99622dc4fe37:Query.getAsset'],
+                    Effect: 'Allow',
+                    Action: ['graphql:execute']
+                }
+            ]
+        }
+    });
+    const createMockRoleImport = () => [createMockRoleInput()];
+    test('validateRoleInput - successfully validates a valid role input', async () => {
+        const mockRoleInput = createMockRoleInput();
+        const roleInput = validateRoleInput(mockRoleInput);
+        expect(roleInput).toEqual(mockRoleInput);
+    });
+    test('validateRoleInput - successfully validates a valid role input with additional properties', async () => {
+        const mockRoleInput = createMockRoleInput();
+        mockRoleInput.__updatedRegion = 'us-east-1';
+        mockRoleInput.__createdRegion = 'us-east-1';
+        const roleInput = validateRoleInput(mockRoleInput);
+        expect(roleInput).toEqual(mockRoleInput);
+    });
+    test('validateRoleInput - throw when an input is invalid', async () => {
+        const mockRoleInput = createMockRoleInput();
+        expect(() => validateRoleInput({ ...mockRoleInput, name: undefined })).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: RoleInput was invalid]');
+    });
+    test('validateRoleImport - successfully validates a valid role import', async () => {
+        const mockRoleImport = createMockRoleImport();
+        const roleImport = ensureValidRoleImport(mockRoleImport);
+        expect(roleImport).toEqual(mockRoleImport);
+    });
+    test('validateRoleImport - successfully validates a valid role import with additional properties', async () => {
+        const mockRoleImport = createMockRoleImport();
+        mockRoleImport.__updatedRegion = 'us-east-1';
+        mockRoleImport.__createdRegion = 'us-east-1';
+        const roleImport = ensureValidRoleImport(mockRoleImport);
+        expect(roleImport).toEqual(mockRoleImport);
+    });
+    test('validateRoleImport - throw when an import is invalid', async () => {
+        const mockRoleImport = createMockRoleImport();
+        mockRoleImport[0].name = undefined;
+        expect(() => ensureValidRoleImport(mockRoleImport)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: Roles were invalid]');
+    });
+    test('validateProjectSchemaImport - successfully validates a valid project schema import', () => {
+        const mockProjectSchema = shapeBooksSchemaLatest();
+        const projectSchema = ensureValidProjectSchemaImport(mockProjectSchema);
+        expect(projectSchema).toEqual(mockProjectSchema);
+    });
+    test('ensureValidProjectSchemaImport - validates a minimal import schema', () => {
+        const mockProjectSchema = omit(shapeBooksSchemaLatest(), [
+            'projectId',
+            'locales',
+            'defaultLocale',
+            'author'
+        ]);
+        const result = ensureValidProjectSchemaImport(mockProjectSchema);
+        expect(result).toBeDefined();
+    });
+    test('ensureValidProjectSchemaImport - throw when an import is invalid', async () => {
+        const mockProjectSchema = shapeBooksSchemaLatest();
+        // @ts-expect-error Intentionally invalid
+        mockProjectSchema.shapes = undefined;
+        expect(() => ensureValidProjectSchemaImport(mockProjectSchema)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: ProjectSchema could not be validated]');
+    });
+    test('ensureValidProjectSchemaImport - successfully validates a valid project schema import', () => {
+        const mockProjectSchema = shapeBooksSchemaLatest();
+        const projectSchema = ensureValidProjectSchemaImport(mockProjectSchema);
+        expect(projectSchema).toEqual(mockProjectSchema);
+    });
+    it('should validate with a maximal example filling in every optional field', async () => {
+        const mockSchema = createMockSchema('<project-id>', {
+            services: {
+                rick: createMockStoredServiceConfig('rick')
+            },
+            queries: {
+                Rick_characters: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        searchParams: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                },
+                                {
+                                    path: 'foo',
+                                    op: 'set',
+                                    value: 'FOO'
+                                },
+                                {
+                                    path: 'bar',
+                                    op: 'extend',
+                                    value: { foo: 'FOO' }
+                                },
+                                {
+                                    path: 'bar',
+                                    op: 'remove'
+                                },
+                                {
+                                    path: 'bar',
+                                    op: 'concat',
+                                    value: ['FOO']
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    style: 'form',
+                                    explode: true,
+                                    allowEmptyValue: true
+                                },
+                                paths: {
+                                    foo: {
+                                        style: 'deepObject',
+                                        explode: true,
+                                        allowReserved: true
+                                    },
+                                    bar: {
+                                        style: 'pipeDelimited',
+                                        explode: false,
+                                        skipEncoding: true
+                                    },
+                                    baz: {
+                                        style: 'spaceDelimited'
+                                    },
+                                    fuzz: {
+                                        style: 'none'
+                                    },
+                                    kermit: {
+                                        contentType: 'application/x-www-form-urlencoded'
+                                    },
+                                    frog: {
+                                        contentType: 'application/json'
+                                    }
+                                }
+                            }
+                        },
+                        path: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    style: 'label',
+                                    explode: true,
+                                    allowEmptyValue: true
+                                },
+                                paths: {
+                                    chunky: {
+                                        style: 'matrix',
+                                        explode: false,
+                                        allowReserved: true
+                                    },
+                                    monkey: {
+                                        style: 'label',
+                                        skipEncoding: true
+                                    },
+                                    cherry: {
+                                        style: 'none',
+                                        explode: true
+                                    },
+                                    kermit: {
+                                        contentType: 'application/x-www-form-urlencoded'
+                                    },
+                                    frog: {
+                                        contentType: 'application/json'
+                                    }
+                                },
+                                template: '/:foo'
+                            }
+                        },
+                        form: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    style: 'deepObject',
+                                    explode: true
+                                },
+                                paths: {
+                                    chunky: {
+                                        style: 'form',
+                                        explode: false
+                                    },
+                                    monkey: {
+                                        style: 'pipeDelimited'
+                                    },
+                                    cherry: {
+                                        style: 'spaceDelimited',
+                                        explode: true
+                                    },
+                                    kermit: {
+                                        contentType: 'application/x-www-form-urlencoded'
+                                    },
+                                    frog: {
+                                        contentType: 'application/json'
+                                    }
+                                }
+                            }
+                        },
+                        json: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                }
+                            ]
+                        },
+                        body: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                }
+                            ],
+                            serialize: {
+                                content: {
+                                    contentType: 'application/x-www-form-urlencoded'
+                                }
+                            }
+                        },
+                        headers: {
+                            ops: [
+                                {
+                                    path: 'x-user-id',
+                                    mapping: '$args'
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    style: 'simple',
+                                    explode: true
+                                },
+                                paths: {
+                                    'x-user-id': {
+                                        style: 'simple',
+                                        explode: false
+                                    },
+                                    'y-user-id': {
+                                        style: 'none'
+                                    }
+                                }
+                            }
+                        },
+                        args: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$args'
+                                }
+                            ]
+                        },
+                        results: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: '$finalStep.results'
+                                },
+                                {
+                                    path: '[*].firstName',
+                                    mapping: [
+                                        [
+                                            'jsonPath',
+                                            {
+                                                path: '$loop.item.name'
+                                            }
+                                        ],
+                                        [
+                                            'replace',
+                                            {
+                                                regexp: '[^\\s]+$',
+                                                replacement: ''
+                                            }
+                                        ],
+                                        ['trim', {}]
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, errors } = await validateSchema(validateContext, mockSchema);
+        expect(errors).toEqual(undefined);
+        expect(valid).toBe(true);
+    });
+    it('should validate with a minimal example where optional props are not present', async () => {
+        const mockSchema = createMockSchema('<project-id>', {
+            services: {
+                rick: createMockStoredServiceConfig('rick')
+            },
+            queries: {
+                Rick_characters: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        searchParams: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    op: 'remove'
+                                }
+                            ]
+                        },
+                        path: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    value: 'foo'
+                                }
+                            ],
+                            serialize: {
+                                template: '/:foo'
+                            }
+                        },
+                        form: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: 'bar'
+                                }
+                            ]
+                        },
+                        json: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    ops: [
+                                        {
+                                            path: '$',
+                                            value: 'nested'
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        body: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    op: 'remove'
+                                }
+                            ]
+                        },
+                        headers: {
+                            ops: [
+                                {
+                                    path: 'x-user-id',
+                                    value: 'userid'
+                                }
+                            ]
+                        },
+                        args: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    mapping: 'bar'
+                                }
+                            ]
+                        },
+                        results: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    ops: [
+                                        {
+                                            path: '$',
+                                            value: 'nested'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        });
+        const { valid, errors } = await validateSchema(validateContext, mockSchema);
+        expect(errors).toEqual(undefined);
+        expect(valid).toBe(true);
+    });
+    it('should fail to validate when required props are not present or have bad values', async () => {
+        const bogus = {
+            services: {
+                rick: createMockStoredServiceConfig('rick')
+            },
+            queries: {
+                Rick_characters: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        searchParams: {
+                            serialize: {
+                                defaults: {
+                                    explode: true,
+                                    allowEmptyValue: true
+                                },
+                                paths: {
+                                    fuzz: {}
+                                }
+                            }
+                        },
+                        pathParams: {},
+                        form: {
+                            ops: [
+                                {
+                                    op: 'nah'
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    contentType: 'application/nah'
+                                }
+                            }
+                        },
+                        json: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    nah: 'nope'
+                                }
+                            ]
+                        },
+                        headers: {
+                            ops: [
+                                {
+                                    path: 'x-user-id'
+                                }
+                            ],
+                            serialize: {
+                                defaults: {
+                                    style: 'form'
+                                }
+                            }
+                        },
+                        args: {
+                            ops: [
+                                {
+                                    path: '$'
+                                }
+                            ],
+                            serialize: {
+                                style: 'form'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        // @ts-expect-error
+        const mockSchema = createMockSchema('<project-id>', bogus);
+        const { valid, errors } = await validateSchema(validateContext, mockSchema);
+        expect(valid).toBe(false);
+        expect(errors).toBeDefined();
+    });
+    it('should fail to validate ops are confused', async () => {
+        const bogus = {
+            schemaVersion: '3.7.0',
+            services: {
+                rick: createMockStoredServiceConfig('rick')
+            },
+            queries: {
+                Rick_characters: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        searchParams: {
+                            ops: [
+                                {
+                                    path: '$',
+                                    value: 'foo',
+                                    mapping: '$args.foo'
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        };
+        // @ts-expect-error
+        const mockSchema = createMockSchema('<project-id>', bogus);
+        const { valid, errors } = await validateSchema(validateContext, mockSchema);
+        expect(valid).toBe(false);
+        expect(errors).toBeDefined();
+    });
+    const characterSchema = createMockSchema('<project-id>', {
+        services: {
+            rick: createMockStoredServiceConfig('rick')
+        },
+        shapes: {
+            Character: {
+                id: 'Character',
+                name: 'Character',
+                title: 'Character',
+                model: {
+                    type: 'single'
+                },
+                schema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        },
+        queries: {
+            getCharacter: {
+                shape: 'Character',
+                resolver: {
+                    name: 'shapedb:get',
+                    service: 'shapedb',
+                    shapeName: 'Character'
+                }
+            }
+        }
+    });
+    it('should validate with valid resolver config', async () => {
+        const schema = {
+            ...characterSchema,
+            queries: {
+                a: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        path: 'characters'
+                    }
+                },
+                b: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'graphql:query',
+                        service: 'rick',
+                        fieldName: 'characters'
+                    }
+                },
+                c: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'shapedb:find',
+                        service: 'shapedb',
+                        shapeName: 'Character'
+                    }
+                },
+                d: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'awsLambda:invoke',
+                        service: 'rick',
+                        functionName: 'my-lambda'
+                    }
+                },
+                e: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'util:wrap'
+                    }
+                },
+                f: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        path: {
+                            ops: [
+                                {
+                                    path: 'foo',
+                                    value: 'FOO'
+                                }
+                            ],
+                            serialize: {
+                                template: '/bar/{foo}'
+                            }
+                        }
+                    }
+                },
+                g: {
+                    shape: 'Character',
+                    resolver: {
+                        name: 'awsLambda:invoke',
+                        service: 'rick',
+                        functionName: {
+                            ops: [
+                                {
+                                    path: 'foo',
+                                    value: 'FOO'
+                                }
+                            ],
+                            serialize: {
+                                template: 'us-east-1:{foo}'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const { valid, errors } = await validateSchema(validateContext, schema);
+        expect(errors).toEqual(undefined);
+        expect(valid).toBe(true);
+    });
+    it('should fail to validate an invalid resolver.shapeName', async () => {
+        const invalidSchema = set(characterSchema, ['queries', 'getCharacter', 'resolver', 'shapeName'], 'bogus');
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(errors).toEqual([
+            {
+                type: 'notFound',
+                message: 'Invalid Model Shape "bogus"',
+                path: ['queries', 'getCharacter', 'resolver', 'shapeName']
+            }
+        ]);
+    });
+    it('should fail to validate resolvers without required props', async () => {
+        const schema = {
+            ...characterSchema,
+            queries: {
+                a: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'rest:get',
+                        service: 'rick',
+                        notwhatyouneed: ''
+                    }
+                }
+            }
+        };
+        const { valid, errors } = await validateSchema(validateContext, schema);
+        expect(valid).toBe(false);
+        expect(errors).toBeDefined();
+    });
+    it('should fail to validate resolvers without required props', async () => {
+        const schema = {
+            ...characterSchema,
+            queries: {
+                a: {
+                    shape: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'rick:Character'
+                        }
+                    },
+                    resolver: {
+                        name: 'graphql:query',
+                        service: 'rick'
+                    }
+                }
+            }
+        };
+        const { valid, errors } = await validateSchema(validateContext, schema);
+        expect(valid).toBe(false);
+        expect(errors).toBeDefined();
+    });
+    function mockSchemaWithCachedShapes(nestedCount = 1) {
+        const definition = {
+            type: 'array',
+            items: { type: 'string' },
+            '@indexed': { nested: true }
+        };
+        const properties = new Array(nestedCount).fill(definition).reduce((prev, propDef) => ({
+            ...prev,
+            [shortid()]: propDef
+        }), {});
+        const shapeName = 'ShapeA';
+        const shape = createShape(shapeName, {
+            type: 'object',
+            properties
+        }, {
+            loaders: {
+                list: {
+                    query: 'getList'
+                }
+            },
+            cache: {
+                enabled: true
+            }
+        });
+        const shapeBName = 'ShapeB';
+        const shapeB = createShape(shapeBName, {
+            extends: [
+                {
+                    type: 'object',
+                    properties
+                }
+            ]
+        }, {
+            loaders: {
+                list: {
+                    query: 'getList'
+                }
+            },
+            cache: { enabled: true }
+        });
+        return createMockSchema('<project-id>', {
+            shapes: {
+                [shapeName]: shape,
+                [shapeBName]: shapeB
+            },
+            queries: {
+                getList: {
+                    shape: 'PaginatedList<ShapeA>',
+                    resolver: {
+                        name: 'shapedb:list',
+                        service: 'shapedb',
+                        shapeName
+                    }
+                }
+            }
+        });
+    }
+    it('should validate with @indexed.nested set', async () => {
+        const { valid, errors } = await validateSchema(validateContext, mockSchemaWithCachedShapes());
+        expect(valid).toBe(true);
+        expect(errors).toEqual(undefined);
+    });
+    it('should fail to validate with more than 50 @indexed.nested values set', async () => {
+        const { valid, errors } = await validateSchema(validateContext, mockSchemaWithCachedShapes(51));
+        expect(valid).toBe(false);
+        expect(errors?.[0]).toMatchInlineSnapshot(`
+      {
+        "message": "102 nested indexes found",
+        "path": [
+          "shapes",
+        ],
+        "type": "tooMany",
+      }
+    `);
+    });
+    it('should fail to validate if @indexed is not on an array', async () => {
+        const schema = mockSchemaWithCachedShapes();
+        const shapePropertyName = Object.keys(schema.shapes.ShapeA.schema.properties)[0];
+        const invalidSchema = set(schema, `shapes.ShapeA.schema.properties.${shapePropertyName}.type`, 'string');
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(errors?.[0].message).toMatchInlineSnapshot(`"Nested indexes may only appear next to fields of type: "array""`);
+    });
+    it('should fail to validate if @indexed is not on an array inside an extends', async () => {
+        const schema = mockSchemaWithCachedShapes();
+        const shapePropertyName = Object.keys(schema.shapes.ShapeB.schema.extends[0].properties)[0];
+        const invalidSchema = set(schema, `shapes.ShapeB.schema.extends[0].properties.${shapePropertyName}.type`, 'string');
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toBe(false);
+        expect(errors?.[0].message).toMatchInlineSnapshot(`"Nested indexes may only appear next to fields of type: "array""`);
+    });
+    test('validateSchema - invalid tool in agent', async () => {
+        const invalidSchema = agentSchema();
+        invalidSchema['ai-experimental'].agents.findDogColor.states.ccc.execution.tools = [
+            { ref: 'local:Query.fake' }
+        ];
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toEqual(false);
+        expect(errors).toEqual([
+            {
+                message: 'Missing tool query "local:Query.fake"',
+                path: ['ai-experimental', 'agents', 'findDogColor', 'states', 'ccc', 'execution', 'tools', 0, 'ref', 'ref'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - duplicate state names', async () => {
+        const invalidSchema = agentSchema();
+        const { findDogColor } = invalidSchema['ai-experimental'].agents;
+        findDogColor.states.bbb.name = 'dupe';
+        findDogColor.states.ccc.name = 'dupe';
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toEqual(false);
+        expect(errors).toEqual([
+            {
+                message: 'Duplicate state name "dupe"',
+                path: ['ai-experimental', 'agents', 'findDogColor', 'states', 'ccc', 'name'],
+                type: 'conflict'
+            }
+        ]);
+    });
+    test('validateSchema - an agent mutation can be a tool call', async () => {
+        const invalidSchema = agentSchema();
+        const { chat } = invalidSchema['ai-experimental'].agents;
+        const exec = chat.states['3pjuyB47X'].execution;
+        assert(exec.type === 'chat', 'Expected chat execution');
+        exec.tools = [
+            {
+                ref: 'Mutation.findDogColor'
+            }
+        ];
+        const { valid } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toEqual(true);
+    });
+    test('validateSchema - guards entitlement fails with 0 guards', async () => {
+        const invalidSchema = agentSchema();
+        set(invalidSchema, ['ai-experimental', 'guards', 'abc123'], {
+            name: 'foo'
+        });
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toEqual(false);
+        expect(errors).toEqual([
+            {
+                message: 'Number of guards exceeds your entitled limit of 0',
+                path: ['ai-experimental', 'guards'],
+                type: 'entitlement'
+            }
+        ]);
+    });
+    test('validateSchema - guards entitlement succeeds with 1 guard', async () => {
+        const validSchema = agentSchema();
+        set(validSchema, ['ai-experimental', 'guards', 'abc123'], { name: 'foo' });
+        const context = {
+            ...validateContext,
+            entitlements: { ...validateContext.entitlements, guards: 1 }
+        };
+        const { valid } = await validateSchema(context, validSchema);
+        expect(valid).toEqual(true);
+    });
+    test('validateSchema - no guard for an agent guardId fails', async () => {
+        const invalidSchema = agentSchema();
+        set(invalidSchema, ['ai-experimental', 'agents', 'findDogColor', 'guards'], [{ guardId: 'abc123' }]);
+        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
+        expect(valid).toEqual(false);
+        expect(errors).toEqual([
+            {
+                message: `Invalid guardId "abc123"`,
+                path: ['ai-experimental', 'agents', 'findDogColor', 'guards', 0, 'guardId'],
+                type: 'notFound'
+            }
+        ]);
+    });
+    test('validateSchema - existing guard for an agent guardId succeeds', async () => {
+        const validSchema = agentSchema();
+        set(validSchema, ['ai-experimental', 'agents', 'findDogColor', 'guards'], [{ guardId: 'abc123' }]);
+        set(validSchema, ['ai-experimental', 'guards', 'abc123'], { name: 'foo' });
+        const context = {
+            ...validateContext,
+            entitlements: { ...validateContext.entitlements, guards: 1 }
+        };
+        const { valid } = await validateSchema(context, validSchema);
+        expect(valid).toEqual(true);
+    });
+});