@takeshape/schema 11.72.0 → 11.74.1

package/dist/__tests__/validate.test.js

@@ -1,1980 +0,0 @@
-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 rickAndMortyLayer from '@/examples/latest/layers/rick-and-morty-layer.json';
-import shopifyLayer from '@/examples/latest/layers/shopify-layer-2023-01.json';
-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);
-    });
-    test('validateSchema - invalid service in semantic chunker', async () => {
-        const invalidSchema = agentSchema();
-        invalidSchema.queries.semantic = {
-            shape: { type: 'array', items: { type: 'string' } },
-            args: {
-                type: 'object',
-                properties: { input: { type: 'string' } },
-                required: ['input']
-            },
-            resolver: {
-                name: 'util:chunk',
-                options: {
-                    type: 'semantic',
-                    serviceId: 'INVALID SERVICE OH NO',
-                    modelId: 'text-embedding-3-small'
-                }
-            }
-        };
-        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
-        expect(valid).toEqual(false);
-        expect(errors).toEqual([
-            {
-                message: 'Invalid service \"INVALID SERVICE OH NO\"',
-                path: ['queries', 'semantic', 'resolver', 'options', 'serviceId'],
-                type: 'notFound'
-            }
-        ]);
-    });
-    test('validateSchema - invalid expressions', async () => {
-        const invalidSchema = agentSchema();
-        const { bbb, ccc, ddd } = invalidSchema['ai-experimental'].agents.findDogColor.states;
-        bbb.variables[0].steps[0].expression = ')';
-        ccc.transition[0].condition = '(';
-        ddd.variables[0].steps[0].condition = 'foo';
-        const { valid, errors } = await validateSchema(validateContext, invalidSchema);
-        expect(valid).toEqual(false);
-        expect(errors).toEqual([
-            {
-                message: 'Unexpected ")" at character 0',
-                path: ['ai-experimental', 'agents', 'findDogColor', 'states', 'bbb', 'variables', 0, 'steps', 0, 'expression'],
-                type: 'conflict'
-            },
-            {
-                message: 'Unclosed ( at character 1',
-                path: ['ai-experimental', 'agents', 'findDogColor', 'states', 'ccc', 'transition', 0, 'expression'],
-                type: 'conflict'
-            },
-            {
-                message: 'Unknown variable "foo"',
-                path: ['ai-experimental', 'agents', 'findDogColor', 'states', 'ddd', 'variables', 0, 'steps', 0, 'condition'],
-                type: 'conflict'
-            }
-        ]);
-    });
-});