@takeshape/schema 11.52.0 → 11.56.1

package/dist/__tests__/schema-util.test.js

@@ -0,0 +1,1731 @@
+import massiveSchemaJson from '@/examples/latest/massive-schema.json';
+import postSchemaJson from '@/examples/latest/post-schema.json';
+import shopifySchema202207 from '@/examples/latest/shopify-product-2022-07.json';
+import shopifyStoreJson from '@/examples/latest/shopify-store-with-widget.json';
+import stripeStarterResolvedJson from '@/examples/latest/stripe-starter-resolved.json';
+import shopifyLayer202301 from '@/examples/source/layers/shopify-layer-2023-01.json';
+import { deepClone } from '@takeshape/util';
+import cloneDeep from 'lodash/cloneDeep.js';
+import get from 'lodash/get.js';
+import keyBy from 'lodash/keyBy.js';
+import pick from 'lodash/pick.js';
+import pickBy from 'lodash/pickBy.js';
+import { describe, expect, it, test, vi } from 'vitest';
+import { createMockSchema } from "../mocks.js";
+import { dereferenceObjectSchema } from "../refs.js";
+import { BuiltInPropertiesProfile, applyBuiltinPropertiesToShape, applyDefaultsToSchema, createSchemaPropertyAccessor, createSchemaPropertyList, emptySchema, ensureMutationByShape, ensureQueryByShape, filterGraphQLServiceMap, getAllNamespaceShapes, getAllRefs, getAllRefsInShapes, getArgsShapeSchema, getBuiltInPropertyNames, getBuiltinsUsed, getDefaultMutationName, getModelBuiltInProperties, getNamespacedShapeNameList, getQueriesShape, getRelevantShapes, getServiceIdFieldName, getShapeByRef, getShapeDependencies, getShapesById, isBuiltInPropertyName, isBuiltinMutation, isBuiltinQuery, isBuiltinShape, isBuiltinType, pathBetween, projectSchemaToJSONSchema, schemaMatchesShapeName, shapeHasArrayPropOfShape, shapeToPropertySchema, visitSchemaProperties } from "../schema-util.js";
+import { getServiceInfo } from "../services/services.js";
+import { isModelShape, isObjectSchema } from "../types/index.js";
+import { getShapeById } from "../util/shapes.js";
+import { CURRENT_SCHEMA_VERSION } from "../versions.js";
+import { defaultWorkflow } from "../workflows.js";
+const stripeStarterResolved = stripeStarterResolvedJson;
+const massiveSchema = applyDefaultsToSchema(massiveSchemaJson);
+const shopifyStoreSchema = applyDefaultsToSchema(shopifyStoreJson);
+const petStoreSchema = applyDefaultsToSchema({
+    ...emptySchema('project-id'),
+    shapes: {
+        Cat: {
+            id: '-Mogf-9_z',
+            name: 'Cat',
+            title: 'Cat',
+            schema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        minLength: 1,
+                        description: '',
+                        title: 'Name',
+                        '@mapping': 'shapedb:Cat.yyBAR4pc9'
+                    },
+                    lives: {
+                        type: 'integer',
+                        minimum: 0,
+                        '@l10n': false,
+                        description: '',
+                        title: 'Lives',
+                        '@mapping': 'shapedb:Cat.xfIXJz_ye'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        Dog: {
+            id: 'xGTklNn3G',
+            name: 'Dog',
+            title: 'Dog',
+            schema: {
+                type: 'object',
+                properties: {
+                    _shapeId: {
+                        type: 'string'
+                    },
+                    name: {
+                        type: 'string',
+                        minLength: 1,
+                        description: '',
+                        title: 'Name',
+                        '@mapping': 'shapedb:Dog.kcQs1FxBF'
+                    },
+                    isBestFriend: {
+                        type: 'boolean',
+                        default: false,
+                        '@l10n': false,
+                        description: '',
+                        title: 'Is Best Friend',
+                        '@mapping': 'shapedb:Dog.uhNHuLVds'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        Homepage: {
+            id: 'AXb0RTnjB',
+            name: 'Homepage',
+            title: 'Homepage',
+            workflow: 'default',
+            model: { type: 'single' },
+            schema: {
+                type: 'object',
+                properties: {
+                    pets: {
+                        type: 'array',
+                        items: { oneOf: [{ '@ref': 'local:Dog' }, { '@ref': 'local:Cat' }] }
+                    }
+                }
+            }
+        }
+    },
+    workflows: {},
+    forms: {}
+});
+function getPostSchema() {
+    return deepClone(postSchemaJson);
+}
+describe('isBuiltinShape', () => {
+    test('it works', () => {
+        expect(isBuiltinShape('TSRelationship')).toBe(true);
+        expect(isBuiltinShape('Post')).toBe(false);
+    });
+});
+describe('isBuiltinType', () => {
+    test('it works', () => {
+        expect(isBuiltinType(shopifyStoreSchema, {
+            $ref: '#/shapes/TSRelationship/schema'
+        })).toBe(true);
+        expect(isBuiltinType(shopifyStoreSchema, { type: 'string' })).toBe(false);
+    });
+});
+describe('isBuiltinQuery', () => {
+    test('it works', () => {
+        expect(isBuiltinQuery('getAsset')).toBe(true);
+        expect(isBuiltinQuery('getDog')).toBe(false);
+    });
+});
+describe('isBuiltinMutation', () => {
+    test('it works', () => {
+        expect(isBuiltinMutation('updateAsset')).toBe(true);
+        expect(isBuiltinMutation('updateDog')).toBe(false);
+    });
+});
+describe('getShapeById', () => {
+    test('it works', () => {
+        const postSchema = getPostSchema();
+        const shape = postSchema.shapes.Post;
+        const shapeId = shape.id;
+        expect(getShapeById(postSchema, shapeId)).toEqual(shape);
+    });
+});
+describe('getShapeByRef', () => {
+    test('it works', () => {
+        const postSchema = getPostSchema();
+        const shape = postSchema.shapes.Post;
+        expect(getShapeByRef(postSchema, 'local:Post')).toEqual(shape);
+    });
+});
+describe('applyBuiltInPropertiesToShape', () => {
+    test('model shape props applied', () => {
+        const projectSchema = getPostSchema();
+        const shape = projectSchema.shapes.Post;
+        expect(applyBuiltinPropertiesToShape(projectSchema, shape)).toMatchObject({
+            ...shape,
+            schema: {
+                ...shape.schema,
+                properties: {
+                    ...dereferenceObjectSchema(projectSchema, shape.schema).properties,
+                    ...getModelBuiltInProperties(projectSchema, shape),
+                    _status: {
+                        type: 'string',
+                        title: 'Status',
+                        '@workflow': 'default'
+                    }
+                }
+            }
+        });
+    });
+    test('cached shape props applied', () => {
+        const projectSchema = {
+            ...shopifyLayer202301,
+            services: {
+                shopify: {
+                    id: 'shopify',
+                    provider: 'shopify',
+                    title: 'Shopify',
+                    namespace: 'Shopify',
+                    serviceType: 'graphql',
+                    authenticationType: 'custom',
+                    options: {
+                        shop: 'andrews-takeshape-store',
+                        endpoint: 'https://andrews-takeshape-store.myshopify.com/admin/api/2023-01/graphql.json'
+                    },
+                    authentication: 'secret'
+                }
+            }
+        };
+        // Enable cache
+        const shape = cloneDeep(shopifyLayer202301.shapes.Shopify_Product);
+        shape.cache = { enabled: true };
+        shape.loaders = { list: { query: 'shopify:Query.products' } };
+        const schema = applyBuiltinPropertiesToShape(projectSchema, shape).schema;
+        expect(pickBy(schema.properties, (_, key) => key.startsWith('_'))).toEqual({
+            _id: {
+                '@mapping': 'shopify:Product.id',
+                title: 'Id',
+                type: 'string'
+            },
+            _shapeId: {
+                enum: ['Shopify_Product'],
+                title: 'Shape Id',
+                type: 'string'
+            }
+        });
+    });
+    test('cached shape props applied preserves custom mapping', () => {
+        const shape = {
+            name: 'Salsify_Product',
+            id: 'Salsify_Product',
+            title: 'Salsify_Product',
+            cache: { enabled: true },
+            loaders: { list: { query: 'shopify:Query.products' } },
+            schema: {
+                properties: {
+                    id: {
+                        type: 'string',
+                        '@mapping': 'salsify:Product.salsify%3Aid'
+                    }
+                },
+                type: 'object'
+            }
+        };
+        const projectSchema = createMockSchema('project-id', {
+            shapes: {
+                Salisify_Product: shape
+            },
+            services: {
+                salsify: {
+                    id: 'salsify',
+                    provider: 'salsify',
+                    title: 'Salsify',
+                    namespace: 'Salsify',
+                    serviceType: 'rest',
+                    authenticationType: 'bearer',
+                    options: {
+                        organizationId: 'organization-id',
+                        channelId: 'channel-id',
+                        endpoint: 'https://app.salsify.com/api/orgs/organization-id'
+                    },
+                    authentication: 'secret'
+                }
+            }
+        });
+        const schema = applyBuiltinPropertiesToShape(projectSchema, shape).schema;
+        expect(pickBy(schema.properties, (_, key) => key.startsWith('_'))).toEqual({
+            _id: {
+                '@mapping': 'salsify:Product.salsify%3Aid',
+                title: 'Id',
+                type: 'string'
+            },
+            _shapeId: {
+                enum: ['Salsify_Product'],
+                title: 'Shape Id',
+                type: 'string'
+            }
+        });
+    });
+    test('shape with extends schema', () => {
+        const projectSchema = getPostSchema();
+        const shape = {
+            ...projectSchema.shapes.Post,
+            schema: {
+                extends: [
+                    {
+                        type: 'object',
+                        properties: {
+                            a: { type: 'string' }
+                        }
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            b: { type: 'string' }
+                        }
+                    }
+                ]
+            }
+        };
+        projectSchema.shapes.Post = shape;
+        expect(applyBuiltinPropertiesToShape(projectSchema, shape)).toEqual({
+            id: 'postContentTypeId',
+            name: 'Post',
+            title: 'Post',
+            model: {
+                type: 'multiple'
+            },
+            schema: {
+                type: 'object',
+                properties: expect.objectContaining({
+                    _id: {
+                        title: 'Id',
+                        type: 'string'
+                    },
+                    a: {
+                        type: 'string'
+                    },
+                    b: {
+                        type: 'string'
+                    }
+                })
+            }
+        });
+    });
+});
+describe('getBuiltInPropertyNames', () => {
+    test('default / model properties', () => {
+        expect(getBuiltInPropertyNames()).toMatchInlineSnapshot(`
+          Set {
+            "_id",
+            "_shapeId",
+            "_version",
+            "_shapeName",
+            "_createdAt",
+            "_createdBy",
+            "_updatedAt",
+            "_updatedBy",
+            "_schemaVersion",
+            "_enabled",
+            "_enabledAt",
+            "_status",
+          }
+      `);
+    });
+    test('cached properties', () => {
+        expect(getBuiltInPropertyNames(BuiltInPropertiesProfile.Cached)).toMatchInlineSnapshot(`
+          Set {
+            "_id",
+            "_shapeId",
+          }
+      `);
+    });
+});
+describe('isModelShape', () => {
+    test('TS source', () => {
+        const postSchema = getPostSchema();
+        const shape = postSchema.shapes.Post;
+        expect(isModelShape(shape)).toEqual(true);
+    });
+    test('foreign source', () => {
+        const shape = {
+            id: 'foreign-shape',
+            name: 'Foreign',
+            title: 'Foreign',
+            schema: {
+                type: 'object',
+                properties: {
+                    price: {
+                        type: 'string',
+                        '@mapping': 'my-store:product.price'
+                    }
+                }
+            }
+        };
+        expect(isModelShape(shape)).toBe(false);
+    });
+});
+describe('getBuiltinsUsed', () => {
+    test('post', () => {
+        expect(Object.keys(getBuiltinsUsed(getPostSchema()))).toEqual([
+            'Asset',
+            'TSRelationship',
+            'TSStaticSite',
+            'TSStaticSiteEnvironmentVariables',
+            'TSStaticSiteTriggers',
+            'TSUser',
+            'TSRelationshipArgs'
+        ]);
+    });
+    test('massive', () => {
+        expect(Object.keys(getBuiltinsUsed(massiveSchema))).toEqual([
+            'Asset',
+            'TSRelationship',
+            'TSStaticSite',
+            'TSStaticSiteEnvironmentVariables',
+            'TSStaticSiteTriggers',
+            'TSUser',
+            'TSRelationshipArgs',
+            'TSColorHsl',
+            'TSColorHsv',
+            'TSColorRgb',
+            'TSColor'
+        ]);
+    });
+});
+describe('applyDefaultsToSchema', () => {
+    test('it works', () => {
+        const postSchema = getPostSchema();
+        const projectSchema = getPostSchema();
+        const result = applyDefaultsToSchema(projectSchema);
+        expect(result.workflows).toMatchObject({ default: defaultWorkflow });
+        expect(dereferenceObjectSchema(projectSchema, result.shapes.Post.schema).properties).toEqual(expect.objectContaining(getModelBuiltInProperties(postSchema, result.shapes.Post)));
+    });
+});
+describe('applyDefaultsToSchema', () => {
+    test('merge built-in', () => {
+        const postSchema = getPostSchema();
+        const postSchemaWithAsset = {
+            ...postSchema,
+            schemaVersion: CURRENT_SCHEMA_VERSION,
+            shapes: {
+                Asset: {
+                    id: 'ASSET',
+                    name: 'Asset',
+                    title: 'Asset',
+                    model: {
+                        type: 'multiple'
+                    },
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            // With only filename and path this schema has removed some built-in fields
+                            filename: {
+                                type: 'string',
+                                title: 'Filename',
+                                '@l10n': false,
+                                minLength: 1,
+                                '@mapping': 'shapedb:Asset.H1oYQOM9'
+                            },
+                            path: {
+                                type: 'string',
+                                title: 'Path',
+                                '@l10n': false,
+                                minLength: 1,
+                                '@mapping': 'shapedb:Asset.Hk6FQuz5'
+                            },
+                            // Override property type
+                            description: {
+                                type: 'object',
+                                title: 'Description',
+                                '@tag': 'draftjs',
+                                '@mapping': 'shapedb:Asset.B1Zsra3fx'
+                            },
+                            // New custom field
+                            tag: {
+                                '@mapping': 'shapedb:Asset.tagsId',
+                                type: 'array',
+                                items: {
+                                    oneOf: [
+                                        {
+                                            '@ref': 'local:Tag'
+                                        }
+                                    ]
+                                },
+                                '@input': {
+                                    type: 'array',
+                                    items: {
+                                        '@ref': 'local:TSRelationship'
+                                    }
+                                },
+                                '@backreference': {
+                                    enabled: true,
+                                    name: 'firstTags'
+                                }
+                            }
+                        },
+                        required: ['filename', 'path', 'tags']
+                    }
+                }
+            },
+            forms: {
+                Asset: {
+                    default: {
+                        order: ['filename', 'path', 'tags'],
+                        properties: {
+                            filename: {
+                                widget: 'singleLineText'
+                            },
+                            path: {
+                                widget: 'singleLineText'
+                            },
+                            tags: {
+                                widget: 'relationship'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const result = applyDefaultsToSchema(postSchemaWithAsset);
+        const assetShape = {
+            id: 'ASSET',
+            name: 'Asset',
+            title: 'Asset',
+            model: {
+                type: 'multiple'
+            },
+            schema: {
+                type: 'object',
+                properties: {
+                    filename: {
+                        type: 'string',
+                        title: 'Filename',
+                        '@l10n': false,
+                        minLength: 1,
+                        '@mapping': 'shapedb:Asset.H1oYQOM9'
+                    },
+                    path: {
+                        type: 'string',
+                        title: 'Path',
+                        '@l10n': false,
+                        minLength: 1,
+                        '@mapping': 'shapedb:Asset.Hk6FQuz5'
+                    },
+                    description: {
+                        type: 'string',
+                        title: 'Description',
+                        '@mapping': 'shapedb:Asset.B1Zsra3fx',
+                        '@l10n': true
+                    },
+                    tag: {
+                        '@mapping': 'shapedb:Asset.tagsId',
+                        type: 'array',
+                        items: {
+                            oneOf: [
+                                {
+                                    '@ref': 'local:Tag'
+                                }
+                            ]
+                        },
+                        '@input': {
+                            type: 'array',
+                            items: {
+                                '@ref': 'local:TSRelationship'
+                            }
+                        },
+                        '@backreference': {
+                            enabled: true,
+                            name: 'firstTags'
+                        }
+                    },
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        '@mapping': 'shapedb:Asset.By5tQOMc',
+                        '@l10n': true
+                    },
+                    caption: {
+                        type: 'object',
+                        title: 'Caption',
+                        '@mapping': 'shapedb:Asset.SyWVsd98x',
+                        '@tag': 'draftjs',
+                        '@l10n': true
+                    },
+                    credit: {
+                        type: 'object',
+                        title: 'Credit',
+                        '@mapping': 'shapedb:Asset.Skn_i_5Ll',
+                        '@tag': 'draftjs',
+                        '@l10n': true
+                    },
+                    mimeType: {
+                        type: 'string',
+                        title: 'MIME type',
+                        '@l10n': false,
+                        '@mapping': 'shapedb:Asset.SyCYX_Gq'
+                    },
+                    sourceUrl: {
+                        type: 'string',
+                        title: 'Source URL',
+                        '@l10n': false,
+                        '@mapping': 'shapedb:Asset.SJXSidnXE'
+                    },
+                    uploadStatus: {
+                        type: 'string',
+                        title: 'Upload status',
+                        '@l10n': false,
+                        '@mapping': 'shapedb:Asset.ByeAYXdG9'
+                    }
+                }
+            }
+        };
+        expect(result.shapes.Asset).toEqual(applyBuiltinPropertiesToShape(postSchemaWithAsset, {
+            ...assetShape,
+            schema: {
+                ...assetShape.schema,
+                properties: {
+                    ...assetShape.schema.properties,
+                    ...getModelBuiltInProperties(postSchemaWithAsset, assetShape)
+                },
+                required: ['filename', 'path', 'tags']
+            }
+        }));
+        expect(result.forms?.Asset).toEqual({
+            default: {
+                order: [
+                    'filename',
+                    'path',
+                    'tags',
+                    'title',
+                    'description',
+                    'caption',
+                    'credit',
+                    'mimeType',
+                    'sourceUrl',
+                    'uploadStatus'
+                ],
+                properties: {
+                    filename: {
+                        widget: 'singleLineText'
+                    },
+                    path: {
+                        widget: 'singleLineText'
+                    },
+                    tags: {
+                        widget: 'relationship'
+                    },
+                    title: {
+                        widget: 'singleLineText'
+                    },
+                    description: {
+                        widget: 'paragraphText'
+                    },
+                    caption: {
+                        widget: 'wysiwygSingleLineText'
+                    },
+                    credit: {
+                        widget: 'wysiwygSingleLineText'
+                    },
+                    mimeType: {
+                        widget: 'singleLineText'
+                    },
+                    sourceUrl: {
+                        widget: 'singleLineText'
+                    },
+                    uploadStatus: {
+                        widget: 'singleLineText'
+                    }
+                }
+            }
+        });
+    });
+});
+describe('shapeToPropertySchema', () => {
+    test('it works', () => {
+        const propertySchema = shapeToPropertySchema(massiveSchema, massiveSchema.shapes.AboutPage);
+        expect(propertySchema).toMatchSnapshot();
+    });
+    test('workflow validation', () => {
+        const projectSchema = applyDefaultsToSchema(getPostSchema());
+        const propertySchema = shapeToPropertySchema(projectSchema, projectSchema.shapes.Post);
+        const objectSchema = dereferenceObjectSchema(projectSchema, projectSchema.shapes.Post.schema);
+        expect(objectSchema.properties._status.oneOf).toBeUndefined();
+        expect(propertySchema.properties?._status.oneOf).toEqual([
+            {
+                enum: ['r1uCfi4ZL', 'disabled'],
+                title: 'Disabled'
+            },
+            {
+                enum: ['rkhRGs4WL', 'enabled'],
+                title: 'Enabled'
+            }
+        ]);
+    });
+    test('oneOf discriminator ', () => {
+        const propertySchema = shapeToPropertySchema(petStoreSchema, petStoreSchema.shapes.Homepage);
+        expect(propertySchema).toEqual({
+            type: 'object',
+            title: 'Homepage',
+            properties: {
+                pets: {
+                    type: 'array',
+                    items: {
+                        discriminator: {
+                            propertyName: '_shapeId'
+                        },
+                        oneOf: [
+                            {
+                                $ref: '#/definitions/Dog'
+                            },
+                            {
+                                $ref: '#/definitions/Cat'
+                            }
+                        ],
+                        required: ['_shapeId']
+                    }
+                },
+                _id: {
+                    title: 'Id',
+                    type: 'string'
+                },
+                _version: {
+                    title: 'Version',
+                    type: 'integer'
+                },
+                _shapeId: {
+                    enum: ['AXb0RTnjB'],
+                    title: 'Shape Id',
+                    type: 'string'
+                },
+                _shapeName: {
+                    title: 'Shape Name',
+                    type: 'string'
+                },
+                _createdAt: {
+                    title: 'Created',
+                    type: 'string',
+                    format: 'date-time'
+                },
+                _createdBy: {
+                    title: 'Created By',
+                    $ref: '#/definitions/TSUser',
+                    '@input': {
+                        type: 'string'
+                    },
+                    '@resolver': {
+                        name: 'takeshape:getUser',
+                        service: 'takeshape'
+                    }
+                },
+                _updatedAt: {
+                    title: 'Updated',
+                    type: 'string',
+                    format: 'date-time'
+                },
+                _updatedBy: {
+                    title: 'Updated By',
+                    $ref: '#/definitions/TSUser',
+                    '@input': {
+                        type: 'string'
+                    },
+                    '@resolver': {
+                        name: 'takeshape:getUser',
+                        service: 'takeshape'
+                    }
+                },
+                _schemaVersion: {
+                    title: 'Schema Version',
+                    type: 'number'
+                },
+                _enabled: {
+                    title: 'Enabled',
+                    type: 'boolean',
+                    '@deprecationReason': 'Use _status instead'
+                },
+                _enabledAt: {
+                    title: 'Enabled Date',
+                    type: 'string',
+                    format: 'date-time',
+                    '@deprecationReason': 'Use a custom date field instead'
+                },
+                _status: {
+                    type: 'string',
+                    title: 'Status',
+                    '@workflow': 'default',
+                    oneOf: [
+                        {
+                            enum: ['r1uCfi4ZL', 'disabled'],
+                            title: 'Disabled'
+                        },
+                        {
+                            enum: ['rkhRGs4WL', 'enabled'],
+                            title: 'Enabled'
+                        }
+                    ]
+                }
+            },
+            definitions: {
+                Dog: {
+                    title: 'Dog',
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            minLength: 1,
+                            description: '',
+                            title: 'Name',
+                            '@mapping': 'shapedb:Dog.kcQs1FxBF'
+                        },
+                        isBestFriend: {
+                            type: 'boolean',
+                            default: false,
+                            '@l10n': false,
+                            description: '',
+                            title: 'Is Best Friend',
+                            '@mapping': 'shapedb:Dog.uhNHuLVds'
+                        },
+                        _shapeId: {
+                            type: 'string',
+                            enum: ['xGTklNn3G']
+                        }
+                    },
+                    required: ['name']
+                },
+                Cat: {
+                    title: 'Cat',
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            minLength: 1,
+                            description: '',
+                            title: 'Name',
+                            '@mapping': 'shapedb:Cat.yyBAR4pc9'
+                        },
+                        lives: {
+                            type: 'integer',
+                            minimum: 0,
+                            '@l10n': false,
+                            description: '',
+                            title: 'Lives',
+                            '@mapping': 'shapedb:Cat.xfIXJz_ye'
+                        },
+                        _shapeId: {
+                            type: 'string',
+                            enum: ['-Mogf-9_z']
+                        }
+                    },
+                    required: ['name']
+                },
+                TSUser: {
+                    type: 'object',
+                    title: 'TSUser',
+                    properties: {
+                        _shapeId: {
+                            enum: ['TSUser'],
+                            type: 'string'
+                        },
+                        avatarPath: {
+                            type: 'string'
+                        },
+                        email: {
+                            type: 'string'
+                        },
+                        fullName: {
+                            type: 'string'
+                        },
+                        id: {
+                            type: 'string'
+                        }
+                    },
+                    required: ['id', 'email', 'fullName']
+                }
+            }
+        });
+    });
+    test('enum shape ', () => {
+        const schema = getPostSchema();
+        schema.shapes.EnumHaver = {
+            id: 'EnumHaver',
+            title: 'EnumHaver',
+            name: 'EnumHaver',
+            description: 'EnumHaver',
+            schema: {
+                type: 'object',
+                properties: {
+                    value: {
+                        '@mapping': 'gregs-takeshape-store:EnumHaver.value',
+                        '@ref': 'self:EnumValue',
+                        description: 'My value'
+                    }
+                }
+            }
+        };
+        schema.shapes.EnumValue = {
+            id: 'EnumValue',
+            title: 'EnumValue',
+            name: 'EnumValue',
+            description: 'EnumValue',
+            schema: {
+                enum: ['RED', 'BLUE', 'PURPLE']
+            }
+        };
+        const propertySchema = shapeToPropertySchema(schema, schema.shapes.EnumHaver);
+        expect(propertySchema).toEqual({
+            type: 'object',
+            title: 'EnumHaver',
+            definitions: {
+                EnumValue: {
+                    enum: ['RED', 'BLUE', 'PURPLE']
+                }
+            },
+            properties: {
+                value: {
+                    $ref: '#/definitions/EnumValue',
+                    '@mapping': 'gregs-takeshape-store:EnumHaver.value',
+                    description: 'My value'
+                }
+            }
+        });
+    });
+});
+describe('projectSchemaToJSONSchema', () => {
+    test('it works', () => {
+        const { definitions } = projectSchemaToJSONSchema(petStoreSchema);
+        expect(Object.keys(definitions).sort()).toEqual(Object.keys(petStoreSchema.shapes).sort());
+    });
+    test('oneOf shape', () => {
+        const projectSchema = {
+            ...petStoreSchema,
+            shapes: {
+                ...petStoreSchema.shapes,
+                Homepage: {
+                    id: 'AXb0RTnjB',
+                    name: 'Homepage',
+                    title: 'Homepage',
+                    workflow: 'default',
+                    model: { type: 'single' },
+                    schema: {
+                        oneOf: [{ '@ref': 'local:Dog' }, { '@ref': 'local:Cat' }]
+                    }
+                }
+            }
+        };
+        const jsonSchema = projectSchemaToJSONSchema(projectSchema);
+        expect(jsonSchema.definitions.Homepage).toMatchInlineSnapshot(`
+    {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Dog",
+        },
+        {
+          "$ref": "#/definitions/Cat",
+        },
+      ],
+    }
+  `);
+    });
+});
+describe('getShapeDependencies', () => {
+    test('it works', () => {
+        const actual = getShapeDependencies(massiveSchema, massiveSchema.shapes.AboutPage);
+        expect(actual.sort()).toEqual([
+            'AboutPagePartnerGroups',
+            'AboutPageStaff',
+            'Asset',
+            'Field',
+            'Institution',
+            'InstitutionSocial',
+            'Partner',
+            'Person',
+            'TSUser',
+            'Tag'
+        ]);
+    });
+    test('oneOf', () => {
+        const actual = getShapeDependencies(petStoreSchema, petStoreSchema.shapes.Homepage);
+        expect(actual.sort()).toEqual(['Cat', 'Dog', 'TSUser']);
+    });
+});
+describe('getRelevantShapes', () => {
+    test('it works', () => {
+        const actual = getRelevantShapes(massiveSchema, {
+            shapeNames: ['AboutPage']
+        });
+        expect(actual).toEqual(pick(massiveSchema.shapes, [
+            'AboutPage',
+            'AboutPagePartnerGroups',
+            'AboutPageStaff',
+            'Asset',
+            'Field',
+            'Institution',
+            'InstitutionSocial',
+            'Partner',
+            'Person',
+            'TSUser',
+            'Tag'
+        ]));
+    });
+    test('includeDependencies: false', () => {
+        const actual = getRelevantShapes(massiveSchema, {
+            shapeNames: ['AboutPage'],
+            includeDependencies: false
+        });
+        expect(actual).toEqual(pick(massiveSchema.shapes, ['AboutPage']));
+    });
+    test('byId', () => {
+        const actual = getRelevantShapes(massiveSchema, {
+            shapeNames: ['AboutPage'],
+            byId: true
+        });
+        const shapesById = keyBy(massiveSchema.shapes, 'id');
+        expect(actual).toEqual(pick(shapesById, [
+            'ASSET',
+            'B1qlk4qjf',
+            'HkxZBVcoG',
+            'ByJqVEcjG',
+            'HJKRv2oKe',
+            'SyUu3bgTe',
+            'r1a9-NCYx',
+            'rkfMnju1-',
+            'rkzZb6QWE',
+            'ryuQTWgTl',
+            'TSUser'
+        ]));
+    });
+    test('empty', () => {
+        const actual = getRelevantShapes(massiveSchema, {});
+        expect(actual).toEqual({});
+    });
+});
+describe('getServiceInfo', () => {
+    test('success, no generator version in schema', () => {
+        const schema = cloneDeep(shopifyStoreSchema);
+        schema.shapes.Product.schema.properties.gregsTakeshapeStore['@tag'] = undefined;
+        expect(getServiceInfo(schema, schema.shapes.Product)).toEqual({
+            shopify: [
+                {
+                    service: 'gregs-takeshape-store',
+                    fieldName: 'gregsTakeshapeStore',
+                    path: [],
+                    generators: {}
+                }
+            ]
+        });
+    });
+    test('success, existing generator version in schema', () => {
+        const schema = cloneDeep(shopifyStoreSchema);
+        schema.shapes.Product.schema.properties.gregsTakeshapeStore['@tag'] =
+            'pattern:service-object:1';
+        expect(getServiceInfo(schema, schema.shapes.Product)).toEqual({
+            shopify: [
+                {
+                    service: 'gregs-takeshape-store',
+                    fieldName: 'gregsTakeshapeStore',
+                    path: [],
+                    generators: {
+                        'pattern:service-object': {
+                            currentVersion: '1',
+                            idFieldName: 'gregsTakeshapeStoreId',
+                            serviceObjectType: 'product',
+                            version: '1'
+                        }
+                    }
+                }
+            ]
+        });
+    });
+    test('none found', () => {
+        expect(getServiceInfo(massiveSchema, massiveSchema.shapes.Article)).toEqual({});
+    });
+    test('multiple fields found', () => {
+        const projectSchema = deepClone(shopifyStoreSchema);
+        const shapeSchema = dereferenceObjectSchema(projectSchema, projectSchema.shapes.Product.schema);
+        shapeSchema.properties = {
+            ...shapeSchema.properties,
+            andrewsTakeshapeStore: shapeSchema.properties.gregsTakeshapeStore,
+            andrewsTakeshapeStoreId: shapeSchema.properties.gregsTakeshapeStoreId
+        };
+        expect(getServiceInfo(projectSchema, projectSchema.shapes.Product)).toEqual({
+            shopify: [
+                {
+                    fieldName: 'gregsTakeshapeStore',
+                    generators: {
+                        'pattern:service-object': {
+                            currentVersion: '1',
+                            idFieldName: 'gregsTakeshapeStoreId',
+                            serviceObjectType: 'product',
+                            version: '1'
+                        }
+                    },
+                    path: [],
+                    service: 'gregs-takeshape-store'
+                },
+                {
+                    fieldName: 'andrewsTakeshapeStore',
+                    generators: {
+                        'pattern:service-object': {
+                            currentVersion: '1',
+                            idFieldName: 'andrewsTakeshapeStoreId',
+                            serviceObjectType: 'product',
+                            version: '1'
+                        }
+                    },
+                    path: [],
+                    service: 'gregs-takeshape-store'
+                }
+            ]
+        });
+    });
+    test('dedupes two way reference', () => {
+        const projectSchema = deepClone(shopifyStoreSchema);
+        projectSchema.shapes.Shopify_Product.schema.properties.takeshapeProduct = {
+            '@ref': 'local:Product',
+            '@resolver': {
+                name: 'shapedb:find',
+                service: 'shapedb',
+                shapeName: 'Product',
+                argsMapping: {
+                    'where.shopifyProductId.eq': [['get', { path: 'source.id' }]]
+                }
+            }
+        };
+        expect(getServiceInfo(projectSchema, projectSchema.shapes.Product)).toEqual({
+            shopify: [
+                {
+                    fieldName: 'gregsTakeshapeStore',
+                    generators: {
+                        'pattern:service-object': {
+                            currentVersion: '1',
+                            idFieldName: 'gregsTakeshapeStoreId',
+                            serviceObjectType: 'product',
+                            version: '1'
+                        }
+                    },
+                    path: [],
+                    service: 'gregs-takeshape-store'
+                }
+            ]
+        });
+    });
+    test('stripe starter - inline object with oneOf', () => {
+        const projectSchema = deepClone(stripeStarterResolved);
+        expect(getServiceInfo(projectSchema, projectSchema.shapes.Profile)).toEqual({
+            stripe: [
+                {
+                    fieldName: 'stripeCustomer',
+                    generators: {},
+                    path: [],
+                    service: 'stripe'
+                }
+            ]
+        });
+    });
+    test('penny - does not follow oneOf relationship', () => {
+        const projectSchema = createMockSchema('project-id', {
+            shapes: {
+                Navigation: {
+                    id: 'Go7s7M7Ij',
+                    name: 'Navigation',
+                    title: 'Navigation',
+                    workflow: 'default',
+                    model: { type: 'single' },
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            message: {
+                                type: 'object',
+                                '@tag': 'draftjs',
+                                description: '',
+                                title: 'Message',
+                                '@mapping': 'shapedb:Navigation.PL-G7Y5Vx'
+                            },
+                            sections: {
+                                title: 'Sections',
+                                description: '',
+                                items: { '@ref': 'local:NavigationSections' },
+                                type: 'array',
+                                '@mapping': 'shapedb:Navigation.yDgLbdGqy'
+                            }
+                        }
+                    }
+                },
+                NavigationSections: {
+                    id: 'yDgLbdGqy',
+                    name: 'NavigationSections',
+                    title: 'Navigation Sections',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                minLength: 1,
+                                type: 'string',
+                                description: '',
+                                title: 'Name',
+                                '@mapping': 'shapedb:NavigationSections.epnGSC2k1'
+                            },
+                            link: {
+                                description: '',
+                                '@args': 'TSRelationshipArgs',
+                                '@resolver': {
+                                    name: 'shapedb:getRelated',
+                                    service: 'shapedb',
+                                    options: { nullable: true }
+                                },
+                                oneOf: [{ '@ref': 'local:Product' }],
+                                '@input': { '@ref': 'local:TSRelationship' },
+                                title: 'Link',
+                                '@backreference': { enabled: false },
+                                '@mapping': 'shapedb:NavigationSections.u2cRNa3wf'
+                            }
+                        },
+                        required: ['name']
+                    }
+                },
+                Product: {
+                    id: 'oseWW7gAF',
+                    name: 'Product',
+                    title: 'Product',
+                    workflow: 'default',
+                    model: { type: 'multiple' },
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Initialized with title from shopify',
+                                title: 'Name',
+                                '@mapping': 'shapedb:Product.O17SLDB3vK'
+                            },
+                            shopifyProductId: {
+                                type: 'string',
+                                '@mapping': 'shapedb:Product.shopifyProductId',
+                                title: 'shopify product',
+                                minLength: 1,
+                                pattern: '(^gid://shopify/Product/\\d+$)'
+                            },
+                            shopifyProduct: {
+                                '@ref': 'shopify:Product',
+                                '@resolver': {
+                                    name: 'graphql:query',
+                                    service: 'shopify',
+                                    fieldName: 'product',
+                                    args: {
+                                        ops: [{ path: 'id', mapping: '$source.shopifyProductId' }]
+                                    }
+                                },
+                                '@tag': 'pattern:service-object:1'
+                            }
+                        }
+                    }
+                }
+            },
+            services: {
+                shopify: {
+                    id: 'shopify',
+                    title: 'Shopify',
+                    provider: 'shopify',
+                    serviceType: 'graphql',
+                    authenticationType: 'none'
+                }
+            }
+        });
+        expect(getServiceInfo(projectSchema, projectSchema.shapes.Navigation)).toEqual({});
+    });
+});
+describe('getServiceIdFieldName', () => {
+    test('it works', () => {
+        expect(getServiceIdFieldName('dog')).toBe('dogId');
+    });
+});
+describe('getNamespacedShapeNameList', () => {
+    test('it works', () => {
+        const schema = {
+            ...emptySchema('project-id'),
+            services: {
+                'my-example': {
+                    title: 'My Example',
+                    id: 'my-example',
+                    provider: 'graphql',
+                    namespace: 'Example',
+                    serviceType: 'graphql',
+                    authenticationType: 'oauth2Bearer',
+                    authentication: 'supasecret',
+                    options: {
+                        endpoint: 'https://example.com'
+                    }
+                }
+            },
+            queries: {
+                getFoo: {
+                    shape: 'Example_Foo',
+                    resolver: {
+                        name: 'graphql:query',
+                        service: 'my-example',
+                        fieldName: 'foo'
+                    }
+                }
+            },
+            shapes: {
+                Taco: {
+                    id: 'taco-id',
+                    name: 'Taco',
+                    title: 'Taco',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            getBar: {
+                                $ref: '#/shapes/Example_Bar/schema'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const expected = new Set(['Example_Foo', 'Example_Bar']);
+        const actual = getNamespacedShapeNameList(schema);
+        expect(actual).toEqual(expected);
+    });
+    // Test instance where a shape in the schema has the same name as a
+    // shape derived from a remote type should exclude the conflicting shape name
+    test('with collision', () => {
+        const schema = deepClone(shopifyStoreSchema);
+        schema.shapes = {
+            MyShape: {
+                id: 'taco-id',
+                name: 'Taco',
+                title: 'Taco',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        getBar: {
+                            '@ref': 'gregs-takeshape-store:Egg'
+                        }
+                    }
+                }
+            }
+        };
+        const expected = new Set(['Shopify_Egg']);
+        const actual = getNamespacedShapeNameList(schema);
+        expect(actual).toEqual(expected);
+    });
+    // Test instance where a shape in the schema has the same name as a
+    // shape derived from a remote type should exclude the conflicting shape name
+    test('with @ref in item array', () => {
+        const schema = deepClone(shopifyStoreSchema);
+        const shapeWithItems = {
+            id: 'ShapeWithItems',
+            name: 'ShapeWithItems',
+            title: 'ShapeWithItems',
+            schema: {
+                type: 'object',
+                properties: {
+                    variants: {
+                        type: 'array',
+                        items: {
+                            '@ref': 'gregs-takeshape-store:Egg'
+                        }
+                    }
+                }
+            }
+        };
+        schema.shapes = {
+            ...schema.shapes,
+            ShapeWithItems: shapeWithItems
+        };
+        const expected = new Set(['Shopify_Egg']);
+        const actual = getNamespacedShapeNameList(schema);
+        expect(actual).toEqual(expected);
+    });
+});
+describe('filterGraphQLServiceMap', () => {
+    test('returns only GraphQL services', () => {
+        const service = Object.values(shopifyStoreSchema.services)[0];
+        const serviceConfig = service;
+        const serviceConfigNoGraphQL = deepClone(serviceConfig);
+        serviceConfigNoGraphQL.serviceType = 'rest';
+        const serviceMap = new Map();
+        serviceMap.set('graphql:my-service', serviceConfig);
+        serviceMap.set('nographql:my-service', serviceConfigNoGraphQL);
+        const expected = new Map();
+        expected.set('graphql:my-service', serviceConfig);
+        const actual = filterGraphQLServiceMap(serviceMap);
+        expect(actual).toEqual(expected);
+    });
+});
+describe('pathBetween', () => {
+    test('it works', () => {
+        expect(pathBetween(massiveSchema.shapes.Report, massiveSchema.shapes.TSColor, massiveSchema)).toEqual([
+            'primaryColor'
+        ]);
+    });
+    test('oneOf array', () => {
+        expect(pathBetween(petStoreSchema.shapes.Homepage, petStoreSchema.shapes.Dog, petStoreSchema)).toEqual(['pets']);
+    });
+    test('we need to go deeper', () => {
+        expect(pathBetween(massiveSchema.shapes.ResourceNavigation, massiveSchema.shapes.ResourceNavigationSectionsSubsections, massiveSchema)).toEqual(['sections', 'subsections']);
+    });
+    test('throws when it reaches depth limit', () => {
+        expect(() => pathBetween(massiveSchema.shapes.ResourceNavigation, massiveSchema.shapes.ResourceNavigationSectionsSubsections, massiveSchema, 1)).toThrow('No path between ResourceNavigation and ResourceNavigationSectionsSubsections');
+    });
+    test('no path', () => {
+        expect(() => pathBetween(massiveSchema.shapes.AboutPage, massiveSchema.shapes.Report, massiveSchema)).toThrow('No path between AboutPage and Report');
+    });
+    test('repeater', () => {
+        expect(pathBetween(massiveSchema.shapes.ResourceNavigation, massiveSchema.shapes.ResourceNavigationExternalResources, massiveSchema)).toEqual(['externalResources']);
+    });
+});
+describe('emptySchema', () => {
+    test('correct project id', () => {
+        const projectId = 'myProjectId';
+        expect(emptySchema(projectId).projectId).toEqual(projectId);
+    });
+    test('creates schema', () => {
+        expect(emptySchema('myProjectId').schemaVersion).toMatch('3');
+    });
+});
+describe('getShapesById', () => {
+    test('it works', () => {
+        const product = {
+            name: 'Product',
+            id: 'abc'
+        };
+        const productInput = {
+            name: 'ProductInput',
+            id: 'xyz'
+        };
+        const schema = {
+            shapes: {
+                Product: product,
+                ProductInput: productInput
+            }
+        };
+        const expected = {
+            abc: product,
+            xyz: productInput
+        };
+        const actual = getShapesById(schema);
+        expect(actual).toEqual(expected);
+    });
+});
+describe('getArgsShapeSchema', () => {
+    test('it works', () => {
+        const productShape = {
+            schema: {
+                type: 'object'
+            }
+        };
+        const createProductArgs = {
+            type: 'object'
+        };
+        const schema = {
+            shapes: {
+                Product: productShape
+            },
+            queries: {
+                getProduct: {
+                    args: 'Product'
+                }
+            },
+            mutations: {
+                createProduct: {
+                    args: createProductArgs
+                }
+            }
+        };
+        const actualGetProductResult = getArgsShapeSchema(schema, schema.queries.getProduct);
+        expect(productShape.schema).toEqual(actualGetProductResult);
+        const actualCreateProductResult = getArgsShapeSchema(schema, schema.mutations.createProduct);
+        expect(createProductArgs).toEqual(actualCreateProductResult);
+    });
+});
+describe('schema property utilities', () => {
+    const productShape = {
+        schema: {
+            type: 'object',
+            properties: {
+                a: {
+                    type: 'string',
+                    '@mapping': 'shapedb:Product.a'
+                },
+                b: {
+                    type: 'string'
+                },
+                c: {
+                    type: 'number'
+                }
+            }
+        }
+    };
+    const sourceShape = cloneDeep(productShape);
+    const targetShapeWithRef = {
+        schema: {
+            '@ref': 'local:SourceShape'
+        }
+    };
+    const targetShapeWithAllOf = {
+        schema: {
+            allOf: [
+                {
+                    '@ref': 'local:SourceShape'
+                }
+            ]
+        }
+    };
+    const schema = {
+        shapes: {
+            Product: productShape,
+            SourceShape: sourceShape,
+            TargetShapeWithRef: targetShapeWithRef,
+            TargetShapeWithAllOf: targetShapeWithAllOf
+        }
+    };
+    it('returns property lists from simple shapes', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyList.getNodes()).toEqual(Object.entries(productShape.schema.properties));
+        expect(schemaPropertyList.getObject()).toEqual(productShape.schema.properties);
+        expect(schemaPropertyList.getNames()).toEqual(Object.keys(productShape.schema.properties));
+        expect(schemaPropertyList.getValues()).toEqual(Object.values(productShape.schema.properties));
+    });
+    it('returns property lists from shapes using ref', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.TargetShapeWithRef.schema);
+        expect(schemaPropertyList.getNodes()).toEqual(Object.entries(sourceShape.schema.properties));
+    });
+    it('returns property lists from shapes using allOf', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.TargetShapeWithAllOf.schema);
+        expect(schemaPropertyList.getNodes()).toEqual(Object.entries(sourceShape.schema.properties));
+    });
+    it('filters property lists', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyList.filterBy(([k]) => k === 'a').getNodes()).toEqual([
+            ['a', productShape.schema.properties.a]
+        ]);
+    });
+    it('orders property lists', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyList.orderBy([([k]) => k], ['desc']).getNames()).toEqual(['c', 'b', 'a']);
+    });
+    it('allows callbacks to be called forEach property', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        const forEachResults = ['c', 'b', 'a'];
+        // biome-ignore lint/complexity/noForEach: Types from orderBy don't line up
+        schemaPropertyList.orderBy([([k]) => k], ['desc']).forEach(([k]) => {
+            expect(k).toBe(forEachResults[0]);
+            forEachResults.shift();
+        });
+    });
+    it('allows property lists to be assigned to variables', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        const ordered = schemaPropertyList.orderBy([([k]) => k], ['desc']);
+        expect(ordered.getNames()).toEqual(['c', 'b', 'a']);
+    });
+    it('allows property lists to be sorted with a user-supplied comparator', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyList
+            .sortWith(([nameA], [nameB]) => {
+            if (nameA < nameB) {
+                return 1;
+            }
+            if (nameA > nameB) {
+                return -1;
+            }
+            // Names must be equal
+            return 0;
+        })
+            .getNodes()).toEqual([
+            ['c', productShape.schema.properties.c],
+            ['b', productShape.schema.properties.b],
+            ['a', productShape.schema.properties.a]
+        ]);
+    });
+    it('allows property lists to be sorted by an array of property names', () => {
+        const schemaPropertyList = createSchemaPropertyList(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyList.sortByNamesWithList(['c', 'a']).getNodes()).toEqual([
+            ['c', productShape.schema.properties.c],
+            ['a', productShape.schema.properties.a]
+        ]);
+    });
+    it('allows properties to accessed in simple shapes', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyAccessor.getValue('a')).toEqual(productShape.schema.properties.a);
+    });
+    it('allows properties to accessed in shapes using ref', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.TargetShapeWithRef.schema);
+        expect(schemaPropertyAccessor.getValue('a')).toEqual(sourceShape.schema.properties.a);
+    });
+    it('allows properties to accessed in shapes using allOf', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.TargetShapeWithAllOf.schema);
+        expect(schemaPropertyAccessor.getValue('a')).toEqual(sourceShape.schema.properties.a);
+    });
+    it('allows property values to be found in shapes', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyAccessor.findValue(([, value]) => value.type === 'number')).toEqual(sourceShape.schema.properties.c);
+    });
+    it('allows property names to be found in shapes', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyAccessor.findName(([, value]) => value.type === 'number')).toEqual('c');
+    });
+    it('allows property keys from @mapping to be generated for properties', () => {
+        const schemaPropertyAccessor = createSchemaPropertyAccessor(schema, schema.shapes.Product.schema);
+        expect(schemaPropertyAccessor.getKey('a')).toEqual('a');
+    });
+    it('can find query by shape and resolver', () => {
+        expect(ensureQueryByShape(getPostSchema(), 'Post', 'shapedb:get')).toEqual('getPost');
+    });
+    it('can find mutation by shape and resolver', () => {
+        expect(ensureMutationByShape(getPostSchema(), 'Post', 'shapedb:update')).toEqual('updatePost');
+    });
+    it('throws error if cannot find query by shape and resolver', () => {
+        expect(() => {
+            ensureQueryByShape(getPostSchema(), 'Egg', 'shapedb:get');
+        }).toThrowError('Failed to find a "shapedb:get" query for shape "Egg"');
+    });
+    it('can get default mutation by name', () => {
+        expect(getDefaultMutationName('Asset', 'shapedb:create')).toBe('createAsset');
+    });
+});
+describe('getAllNamespaceShapes', () => {
+    test('shopify schema snapshot', () => {
+        expect(getAllNamespaceShapes(shopifyStoreSchema)).toMatchSnapshot();
+    });
+});
+describe('getAllRefs', () => {
+    test('shopify schema snapshot', () => {
+        expect(getAllRefs(shopifyStoreSchema)).toMatchSnapshot();
+    });
+    test('predicate', () => {
+        expect(getAllRefs(shopifyStoreSchema, (ref) => !ref.isForeign)).toMatchSnapshot();
+    });
+});
+describe('getQueriesShape', () => {
+    test('shopify schema', () => {
+        const shape = getQueriesShape(shopifySchema202207, 'query');
+        expect(isObjectSchema(shape.schema)).toBe(true);
+        const objectSchema = shape.schema;
+        expect(Object.keys(objectSchema.properties).sort()).toEqual(Object.keys(shopifySchema202207.queries).sort());
+        expect(objectSchema.properties.Shopify_products).toEqual({
+            '@args': expect.objectContaining({
+                type: 'object'
+            }),
+            '@mapping': 'shopify:Query.products',
+            '@ref': 'shopify:ProductConnection',
+            '@resolver': {
+                fieldName: 'products',
+                name: 'graphql:query',
+                service: 'shopify'
+            }
+        });
+    });
+});
+describe('schemaMatchesShapeName', () => {
+    const ref = { '@ref': 'local:Post' };
+    test('yes', () => {
+        expect(schemaMatchesShapeName(postSchemaJson, ref, 'Post')).toEqual(true);
+    });
+    test('no', () => {
+        expect(schemaMatchesShapeName(postSchemaJson, ref, 'Potato')).toEqual(false);
+    });
+});
+describe('shapeHasArrayPropOfShape', () => {
+    test('yes', () => {
+        expect(shapeHasArrayPropOfShape(postSchemaJson, postSchemaJson.shapes.Post, 'Tag')).toEqual(true);
+    });
+    test('no', () => {
+        expect(shapeHasArrayPropOfShape(postSchemaJson, postSchemaJson.shapes.Post, 'Onion')).toEqual(false);
+    });
+});
+describe('getAllRefsInShapes', () => {
+    test('finds interfaces that are refs', () => {
+        expect(getAllRefsInShapes({
+            shapes: {
+                Dog: {
+                    id: 'Dog',
+                    name: 'Dog',
+                    title: 'Dog',
+                    schema: { type: 'object' },
+                    interfaces: ['Animal', 'shopify:Friend']
+                }
+            }
+        })).toEqual([
+            {
+                isForeign: false,
+                path: ['shapes', 'Dog', 'interfaces', 0],
+                serviceKey: 'local',
+                typeName: 'Animal',
+                isValidService: true
+            },
+            {
+                isForeign: false,
+                path: ['shapes', 'Dog', 'interfaces', 1],
+                serviceKey: 'shopify',
+                typeName: 'Friend',
+                isValidService: false
+            }
+        ]);
+    });
+});
+describe('isBuiltInPropertyName', () => {
+    test('not a builtin', () => {
+        expect(isBuiltInPropertyName('name')).toEqual(false);
+    });
+    test('universal builtin property model profile', () => {
+        expect(isBuiltInPropertyName('_id')).toEqual(true);
+    });
+    test('model property model profile', () => {
+        expect(isBuiltInPropertyName('_updatedBy')).toEqual(true);
+    });
+    test('universal builtin property none profile', () => {
+        expect(isBuiltInPropertyName('_id', BuiltInPropertiesProfile.None)).toEqual(true);
+    });
+    test('model property none profile', () => {
+        expect(isBuiltInPropertyName('_updatedBy', BuiltInPropertiesProfile.None)).toEqual(false);
+    });
+});
+describe('visitSchemaProperties', () => {
+    const schema = {
+        required: ['data'],
+        type: 'object',
+        properties: {
+            data: {
+                type: 'array',
+                items: {
+                    allOf: [
+                        {
+                            '@ref': 'klayvio:ObjectResource'
+                        },
+                        {
+                            type: 'object',
+                            properties: {
+                                relationships: {
+                                    '@ref': 'klayvio:GetSegmentListResponseCollectionCompoundDocumentDataRelationships'
+                                }
+                            }
+                        }
+                    ]
+                }
+            },
+            links: {
+                '@ref': 'klayvio:CollectionLinks'
+            },
+            included: {
+                type: 'array',
+                items: {
+                    '@ref': 'klayvio:TagResponseObjectResource'
+                }
+            }
+        }
+    };
+    const expectVisited = (callback, path) => {
+        const item = get(schema, path);
+        expect(callback).toHaveBeenCalledWith(item, path);
+    };
+    test('works', () => {
+        const callback = vi.fn();
+        visitSchemaProperties(schema, [], callback);
+        expect(callback).toHaveBeenCalledTimes(8);
+        expectVisited(callback, ['properties', 'data']);
+        expectVisited(callback, ['properties', 'data', 'items']);
+        expectVisited(callback, ['properties', 'data', 'items', 'allOf', '0']);
+        expectVisited(callback, ['properties', 'data', 'items', 'allOf', '1']);
+        expectVisited(callback, ['properties', 'data', 'items', 'allOf', '1', 'properties', 'relationships']);
+        expectVisited(callback, ['properties', 'links']);
+        expectVisited(callback, ['properties', 'included']);
+        expectVisited(callback, ['properties', 'included', 'items']);
+    });
+    test('cancels iteration correctly', () => {
+        const callback = vi.fn((prop) => prop.type !== 'array');
+        visitSchemaProperties(schema, [], callback);
+        expect(callback).toHaveBeenCalledTimes(3);
+        expectVisited(callback, ['properties', 'data']);
+        expectVisited(callback, ['properties', 'links']);
+        expectVisited(callback, ['properties', 'included']);
+    });
+});