@takeshape/schema 11.73.0 → 11.76.0

package/dist/__tests__/relationships.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/relationships.test.js

@@ -1,638 +0,0 @@
-import massiveSchemaJson from '@takeshape/schema/examples/latest/massive-schema.json';
-import postSchemaJson from '@takeshape/schema/examples/latest/post-schema.json';
-import shapeBooksSchemaJson from '@takeshape/schema/examples/latest/shape-books.json';
-import { deepClone } from '@takeshape/util';
-import { describe, expect, it, test } from 'vitest';
-import { createMockSchema, createMockSchemaWithDefaults } from "../mocks.js";
-import { addRelatedFields, findExistingRelationships, getRelationshipSchema } from "../relationships.js";
-import { applyDefaultsToSchema, createShape } from "../schema-util.js";
-const projectSchema = applyDefaultsToSchema(shapeBooksSchemaJson);
-describe('getRelationshipSchema', () => {
-    const projectSchema = createMockSchema('<project-id>', {
-        shapes: {
-            A: createShape('A', {
-                type: 'object',
-                properties: { a: { type: 'string' } }
-            }),
-            B: createShape('B', {
-                type: 'object',
-                properties: { b: { type: 'string' } }
-            })
-        }
-    });
-    const singleRelationship = {
-        shapeIds: ['ASSET'],
-        type: 'single'
-    };
-    const multipleRelationship = {
-        shapeIds: ['ASSET'],
-        type: 'multiple'
-    };
-    it('gets a schema when provided a single relationship', () => {
-        const schema = getRelationshipSchema(projectSchema, singleRelationship);
-        expect(schema).toEqual({
-            '@ref': 'local:Asset',
-            '@args': 'TSRelationshipArgs',
-            '@input': {
-                '@ref': 'local:TSRelationship'
-            },
-            '@resolver': {
-                name: 'shapedb:getRelated',
-                service: 'shapedb',
-                options: {
-                    nullable: true
-                }
-            }
-        });
-    });
-    it('gets an array schema when provided a multiple relationship', () => {
-        const schema = getRelationshipSchema(projectSchema, multipleRelationship);
-        expect(schema).toEqual({
-            type: 'array',
-            items: { '@ref': 'local:Asset' },
-            '@args': 'TSRelationshipArgs',
-            '@input': {
-                type: 'array',
-                items: {
-                    '@ref': 'local:TSRelationship'
-                }
-            },
-            '@resolver': {
-                name: 'shapedb:getRelated',
-                service: 'shapedb',
-                options: {
-                    nullable: true
-                }
-            }
-        });
-    });
-    it('gets uses oneOf when relationship has multiple shape ids', () => {
-        const multipleRelationship = {
-            shapeIds: ['A', 'B'],
-            type: 'multiple'
-        };
-        const schema = getRelationshipSchema(projectSchema, multipleRelationship);
-        expect(schema).toEqual({
-            type: 'array',
-            items: { oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }] },
-            '@args': 'TSRelationshipArgs',
-            '@input': {
-                type: 'array',
-                items: {
-                    '@ref': 'local:TSRelationship'
-                }
-            },
-            '@resolver': {
-                name: 'shapedb:getRelated',
-                service: 'shapedb',
-                options: {
-                    nullable: true
-                }
-            }
-        });
-    });
-    it('throws error for empty relationship', () => {
-        const empty = {
-            shapeIds: [],
-            type: 'single'
-        };
-        expect(() => getRelationshipSchema(projectSchema, empty)).toThrowErrorMatchingInlineSnapshot(`[Error: Invalid empty relationship {"shapeIds":[],"type":"single"}]`);
-    });
-});
-const massiveSchema = createMockSchemaWithDefaults(massiveSchemaJson.projectId, massiveSchemaJson);
-const postSchema = createMockSchemaWithDefaults(postSchemaJson.projectId, postSchemaJson);
-describe('findExistingRelationships', () => {
-    test('post', () => {
-        const schema = postSchema;
-        const actual = findExistingRelationships(schema, schema.shapes);
-        const expected = {
-            tagContentTypeId: [
-                {
-                    shapeId: 'postContentTypeId',
-                    path: ['tags'],
-                    relatedName: 'firstTags',
-                    hasBackreference: true,
-                    schema: {
-                        '@args': 'TSRelationshipArgs',
-                        '@backreference': {
-                            enabled: true,
-                            name: 'firstTags'
-                        },
-                        '@input': {
-                            items: {
-                                '@ref': 'local:TSRelationship'
-                            },
-                            type: 'array'
-                        },
-                        '@mapping': 'shapedb:Post.tagsId',
-                        '@resolver': {
-                            name: 'shapedb:getRelated',
-                            service: 'shapedb',
-                            options: {
-                                nullable: true
-                            }
-                        },
-                        items: {
-                            '@ref': 'local:Tag'
-                        },
-                        type: 'array'
-                    },
-                    shapeName: 'Post'
-                }
-            ]
-        };
-        expect(actual).toEqual(expected);
-    });
-    test('massive', () => {
-        const actual = findExistingRelationships(massiveSchema, massiveSchema.shapes);
-        expect(Object.keys(actual).length).toBe(15);
-    });
-    test('recursive ', () => {
-        const recursiveSchema = createMockSchemaWithDefaults('project-id', {
-            shapes: {
-                Node: {
-                    title: 'Node',
-                    name: 'Node',
-                    id: 'node-id',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            value: { type: 'number' },
-                            left: { '@ref': 'local:Node' },
-                            right: { '@ref': 'local:Node' }
-                        }
-                    }
-                },
-                Report: {
-                    title: 'Report',
-                    name: 'Report',
-                    id: 'report-id',
-                    model: {
-                        type: 'multiple'
-                    },
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            tree: {
-                                oneOf: [
-                                    {
-                                        '@ref': 'local:Node'
-                                    }
-                                ],
-                                '@input': {
-                                    '@ref': 'local:TSRelationship'
-                                },
-                                '@backreference': {
-                                    enabled: true,
-                                    name: 'firstTags'
-                                },
-                                '@resolver': {
-                                    name: 'shapedb:getRelated',
-                                    service: 'shapedb'
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        const actual = findExistingRelationships(recursiveSchema, recursiveSchema.shapes);
-        expect(actual).toEqual({
-            'node-id': [
-                {
-                    path: ['tree'],
-                    shapeId: 'report-id',
-                    relatedName: 'firstTags',
-                    hasBackreference: true,
-                    schema: {
-                        '@backreference': {
-                            enabled: true,
-                            name: 'firstTags'
-                        },
-                        '@input': {
-                            '@ref': 'local:TSRelationship'
-                        },
-                        '@resolver': {
-                            name: 'shapedb:getRelated',
-                            service: 'shapedb'
-                        },
-                        oneOf: [
-                            {
-                                '@ref': 'local:Node'
-                            }
-                        ]
-                    },
-                    shapeName: 'Report'
-                }
-            ]
-        });
-    });
-    test('nested in union ', () => {
-        const projectSchema = createMockSchema('project-id', {
-            shapes: {
-                Center: {
-                    title: 'Center',
-                    name: 'Center',
-                    id: 'Center',
-                    model: {
-                        type: 'multiple'
-                    },
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            info: {
-                                oneOf: [{ '@ref': 'local:BasicInfo' }, { '@ref': 'local:AdvancedInfo' }]
-                            }
-                        }
-                    }
-                },
-                BasicInfo: {
-                    title: 'BasicInfo',
-                    name: 'BasicInfo',
-                    id: 'BasicInfo',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            treatments: {
-                                type: 'array',
-                                items: {
-                                    oneOf: [
-                                        {
-                                            '@ref': 'local:Treatment'
-                                        }
-                                    ]
-                                },
-                                '@input': {
-                                    type: 'array',
-                                    items: {
-                                        '@ref': 'local:TSRelationship'
-                                    }
-                                },
-                                '@backreference': { enabled: true, name: 'basicInfoSet' },
-                                '@resolver': {
-                                    name: 'shapedb:getRelated',
-                                    service: 'shapedb'
-                                }
-                            }
-                        }
-                    }
-                },
-                AdvancedInfo: {
-                    title: 'AdvancedInfo',
-                    name: 'AdvancedInfo',
-                    id: 'AdvancedInfo',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            isExpensive: { type: 'boolean' }
-                        }
-                    }
-                },
-                Treatment: {
-                    title: 'Treatment',
-                    name: 'Treatment',
-                    id: 'Treatment',
-                    model: {
-                        type: 'multiple'
-                    },
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' }
-                        }
-                    }
-                }
-            }
-        });
-        const actual = findExistingRelationships(projectSchema, projectSchema.shapes);
-        expect(actual).toEqual({
-            Treatment: [
-                {
-                    relatedName: 'basicInfoSet',
-                    path: ['info', 'treatments'],
-                    shapeId: 'Center',
-                    hasBackreference: true,
-                    schema: {
-                        '@backreference': {
-                            enabled: true,
-                            name: 'basicInfoSet'
-                        },
-                        '@input': {
-                            items: {
-                                '@ref': 'local:TSRelationship'
-                            },
-                            type: 'array'
-                        },
-                        '@resolver': {
-                            name: 'shapedb:getRelated',
-                            service: 'shapedb'
-                        },
-                        items: {
-                            oneOf: [
-                                {
-                                    '@ref': 'local:Treatment'
-                                }
-                            ]
-                        },
-                        type: 'array'
-                    },
-                    shapeName: 'BasicInfo'
-                }
-            ]
-        });
-    });
-    test('shopify', () => {
-        const shapes = {
-            TSRelationship: {
-                id: 'TSRelationship',
-                name: 'TSRelationship',
-                title: 'Relationship',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        shapeId: {
-                            type: 'string'
-                        },
-                        id: { type: 'string' }
-                    },
-                    required: ['shapeId', 'id']
-                }
-            },
-            Post: {
-                name: 'Post',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        shopifyProduct: {
-                            $ref: '#/shapes/TSShopify_Product/schema',
-                            '@resolver': {
-                                name: 'graphql:query',
-                                argsMapping: {
-                                    id: [['jsonPath', { path: '$.productId' }]]
-                                },
-                                service: 'seans-store-takeshape',
-                                fieldName: 'product'
-                            }
-                        },
-                        rating: {
-                            type: 'integer',
-                            '@mapping': 'shapedb:self.ratingId'
-                        },
-                        productId: {
-                            type: 'string',
-                            '@tag': 'id'
-                        },
-                        title: {
-                            type: 'string',
-                            '@l10n': true,
-                            '@mapping': 'shapedb:self.titleId'
-                        },
-                        body: {
-                            type: 'string',
-                            '@l10n': true,
-                            '@mapping': 'shapedb:self.bodyId'
-                        },
-                        tags: {
-                            '@mapping': 'shapedb:self.tagsId',
-                            type: 'array',
-                            items: {
-                                oneOf: [
-                                    {
-                                        '@ref': 'local:Tag'
-                                    }
-                                ]
-                            },
-                            '@input': {
-                                items: {
-                                    '@ref': 'local:TSRelationship'
-                                }
-                            },
-                            '@backreference': {
-                                enabled: true,
-                                name: 'firstTags'
-                            },
-                            '@resolver': {
-                                name: 'shapedb:getRelated',
-                                service: 'shapedb'
-                            }
-                        }
-                    },
-                    required: ['title']
-                },
-                model: {
-                    type: 'multiple'
-                },
-                id: 'postContentTypeId',
-                title: 'Post'
-            },
-            Tag: {
-                name: 'Tag',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        name: {
-                            type: 'string',
-                            '@mapping': 'shapedb:self.nameId'
-                        }
-                    },
-                    required: ['name']
-                },
-                model: {
-                    type: 'taxonomy'
-                },
-                id: 'tagContentTypeId',
-                title: 'Tag'
-            }
-        };
-        const relationships = findExistingRelationships(massiveSchema, shapes);
-        expect(relationships).toEqual({
-            tagContentTypeId: [
-                {
-                    path: ['tags'],
-                    relatedName: 'firstTags',
-                    shapeId: 'postContentTypeId',
-                    hasBackreference: true,
-                    schema: {
-                        '@backreference': {
-                            enabled: true,
-                            name: 'firstTags'
-                        },
-                        '@input': {
-                            items: {
-                                '@ref': 'local:TSRelationship'
-                            }
-                        },
-                        '@mapping': 'shapedb:self.tagsId',
-                        '@resolver': {
-                            name: 'shapedb:getRelated',
-                            service: 'shapedb'
-                        },
-                        items: {
-                            oneOf: [
-                                {
-                                    '@ref': 'local:Tag'
-                                }
-                            ]
-                        },
-                        type: 'array'
-                    },
-                    shapeName: 'Post'
-                }
-            ]
-        });
-    });
-});
-describe('addRelatedFields', () => {
-    test('it works', () => {
-        const relationships = findExistingRelationships(projectSchema, projectSchema.shapes);
-        const actual = addRelatedFields(deepClone(projectSchema), relationships);
-        const { properties } = actual.shapes.Author.schema;
-        expect(properties.postSet).toEqual({
-            '@args': 'TSListArgs<local:Post>',
-            '@ref': 'PaginatedList<local:Post>',
-            '@resolver': {
-                args: {
-                    ops: [
-                        {
-                            path: '$',
-                            mapping: '$args'
-                        },
-                        {
-                            path: 'baseWhere._references.eq',
-                            mapping: '$source._id'
-                        },
-                        {
-                            path: 'baseWhere._shapeId.eq',
-                            value: projectSchema.shapes.Post.id
-                        }
-                    ]
-                },
-                name: 'shapedb:list',
-                service: 'shapedb'
-            }
-        });
-        expect(properties.authored).toEqual({
-            '@args': 'TSListArgs<local:Book>',
-            '@ref': 'PaginatedList<local:Book>',
-            '@resolver': {
-                args: {
-                    ops: [
-                        {
-                            path: '$',
-                            mapping: '$args'
-                        },
-                        {
-                            path: 'baseWhere.author._id.eq',
-                            mapping: '$source._id'
-                        },
-                        {
-                            path: 'baseWhere._shapeId.eq',
-                            value: projectSchema.shapes.Book.id
-                        }
-                    ]
-                },
-                name: 'shapedb:list',
-                service: 'shapedb'
-            }
-        });
-        expect(properties._references).toEqual({
-            '@args': 'TSListArgs<local:AuthorReference>',
-            '@ref': 'PaginatedList<local:AuthorReference>',
-            '@resolver': {
-                args: {
-                    ops: [
-                        {
-                            path: '$',
-                            mapping: '$args'
-                        },
-                        {
-                            path: 'baseWhere._references.eq',
-                            mapping: '$source._id'
-                        },
-                        {
-                            path: 'baseWhere._shapeId.in',
-                            value: [projectSchema.shapes.Asset.id, projectSchema.shapes.Post.id, projectSchema.shapes.Book.id]
-                        }
-                    ]
-                },
-                name: 'shapedb:list',
-                service: 'shapedb'
-            }
-        });
-        expect(actual.shapes.AuthorReference).toEqual({
-            id: 'AuthorReference',
-            name: 'AuthorReference',
-            title: 'AuthorReference',
-            schema: {
-                oneOf: [{ '@ref': 'local:Asset' }, { '@ref': 'local:Post' }, { '@ref': 'local:Book' }]
-            }
-        });
-    });
-    test('backreference not enabled, no reference', () => {
-        const mockSchema = deepClone(projectSchema);
-        // @ts-expect-error
-        mockSchema.shapes.Post.schema.properties.author['@backreference'].enabled = false;
-        const relationships = findExistingRelationships(mockSchema, mockSchema.shapes);
-        const actual = addRelatedFields(deepClone(projectSchema), relationships);
-        const { properties } = actual.shapes.Author.schema;
-        expect(properties.postSet).toBeUndefined();
-        expect(properties.authored).toEqual({
-            '@args': 'TSListArgs<local:Book>',
-            '@ref': 'PaginatedList<local:Book>',
-            '@resolver': {
-                args: {
-                    ops: [
-                        {
-                            path: '$',
-                            mapping: '$args'
-                        },
-                        {
-                            path: 'baseWhere.author._id.eq',
-                            mapping: '$source._id'
-                        },
-                        {
-                            path: 'baseWhere._shapeId.eq',
-                            value: projectSchema.shapes.Book.id
-                        }
-                    ]
-                },
-                name: 'shapedb:list',
-                service: 'shapedb'
-            }
-        });
-        expect(properties._references).toEqual({
-            '@args': 'TSListArgs<local:AuthorReference>',
-            '@ref': 'PaginatedList<local:AuthorReference>',
-            '@resolver': {
-                args: {
-                    ops: [
-                        {
-                            path: '$',
-                            mapping: '$args'
-                        },
-                        {
-                            path: 'baseWhere._references.eq',
-                            mapping: '$source._id'
-                        },
-                        {
-                            path: 'baseWhere._shapeId.in',
-                            value: [projectSchema.shapes.Asset.id, projectSchema.shapes.Book.id]
-                        }
-                    ]
-                },
-                name: 'shapedb:list',
-                service: 'shapedb'
-            }
-        });
-        expect(actual.shapes.AuthorReference).toEqual({
-            id: 'AuthorReference',
-            name: 'AuthorReference',
-            title: 'AuthorReference',
-            schema: {
-                oneOf: [{ '@ref': 'local:Asset' }, { '@ref': 'local:Book' }]
-            }
-        });
-    });
-});

package/dist/__tests__/schema-transform.test.d.ts

@@ -1 +0,0 @@
-export {};