@takeshape/schema 11.52.0 → 11.56.1

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

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

package/dist/__tests__/relationships.test.js

@@ -0,0 +1,638 @@
+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

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