@takeshape/schema 11.52.0 → 11.56.1

package/dist/__tests__/content-schema-transform.test.js

@@ -0,0 +1,522 @@
+import shapeBooksJson from '@/examples/latest/shape-books.json';
+import { describe, expect, test } from 'vitest';
+import { getContentTransform, getPropertyInfo } from "../content-schema-transform.js";
+import { createInputSchema } from "../create-input-schema.js";
+import { createMockSchema } from "../mocks.js";
+import { dereferenceObjectSchema } from "../refs.js";
+import { toName } from "../schema-transform.js";
+import { applyDefaultsToSchema } from "../schema-util.js";
+const shapeBooksSchema = createInputSchema(applyDefaultsToSchema(shapeBooksJson), {
+    isUpdate: true
+});
+const identityTransform = {
+    filter: () => true,
+    process: (x) => x
+};
+const petStoreSchema = createMockSchema('project-id', {
+    shapes: {
+        Dog: {
+            id: 'SH7HPWJfn',
+            name: 'Dog',
+            title: 'Dog',
+            schema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        minLength: 1,
+                        description: '',
+                        title: 'Name',
+                        '@mapping': 'shapedb:Dog.Bu4jsC6I4'
+                    },
+                    isBestFriend: {
+                        type: 'boolean',
+                        default: false,
+                        '@l10n': false,
+                        description: '',
+                        title: 'Is Best Friend',
+                        '@mapping': 'shapedb:Dog.SfsCYX0o5'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        Cat: {
+            id: 'j2VnVXELF',
+            name: 'Cat',
+            title: 'Cat',
+            schema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        minLength: 1,
+                        description: '',
+                        title: 'Name',
+                        '@mapping': 'shapedb:Cat.0zU9ToscC'
+                    },
+                    lives: {
+                        '@l10n': false,
+                        minimum: 0,
+                        type: 'integer',
+                        description: '',
+                        title: 'Lives',
+                        '@mapping': 'shapedb:Cat.lnQIlRKUy'
+                    }
+                },
+                required: ['name', 'lives']
+            }
+        },
+        Store: {
+            id: 'W15z-c33Q',
+            name: 'Store',
+            title: 'Store',
+            workflow: 'default',
+            model: { type: 'multiple' },
+            schema: {
+                type: 'object',
+                properties: {
+                    pets: {
+                        '@mapping': 'shapedb:Store.OmG666',
+                        type: 'array',
+                        items: { oneOf: [{ '@ref': 'local:Dog' }, { '@ref': 'local:Cat' }] }
+                    }
+                }
+            }
+        }
+    }
+});
+describe('getContentTransform', () => {
+    test('it works', () => {
+        const transforms = {
+            string: [identityTransform]
+        };
+        const transform = getContentTransform({
+            transforms,
+            projectSchema: shapeBooksSchema,
+            keyTransform: toName,
+            passThrough: false
+        });
+        const content = {
+            _updatedBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            BJfmu0OIZ: 'Homepage',
+            _createdBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            _status: 'rkhRGs4WL',
+            r1xPx1OUW: {
+                shapeId: 'r166qcP8Z',
+                id: 'e1bc4031-783e-40e6-9881-d25d744ea6b3'
+            },
+            _createdAt: '2020-08-10T22:06:44.699Z',
+            _schemaVersion: 1,
+            _id: '64224dec8b5214586b9fd8aedd979ee7',
+            _shapeId: 'H1TFgJdIb',
+            _version: 1,
+            _updatedAt: '2020-08-10T22:06:44.699Z',
+            ry4VnCD8W: {
+                'H1vBnAv8-': {
+                    shapeId: 'ASSET',
+                    id: 'dff44109-3fcd-43cf-8503-f266f8d5ca3e'
+                },
+                SJ1Xo0v8b: {
+                    shapeId: 'rJoobhv8W',
+                    id: 'ff34e345-21a2-4a0d-946a-12be856effba'
+                }
+            }
+        };
+        const transformed = transform(shapeBooksSchema.shapes.Homepage.schema, content);
+        expect(transformed).toEqual({
+            _createdAt: '2020-08-10T22:06:44.699Z',
+            _createdBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            _id: '64224dec8b5214586b9fd8aedd979ee7',
+            _shapeId: 'H1TFgJdIb',
+            _status: 'rkhRGs4WL',
+            _updatedAt: '2020-08-10T22:06:44.699Z',
+            _updatedBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            featuredBook: {
+                id: 'e1bc4031-783e-40e6-9881-d25d744ea6b3',
+                shapeId: 'r166qcP8Z'
+            },
+            hero: {
+                featuredPost: {
+                    id: 'ff34e345-21a2-4a0d-946a-12be856effba',
+                    shapeId: 'rJoobhv8W'
+                },
+                image: {
+                    id: 'dff44109-3fcd-43cf-8503-f266f8d5ca3e',
+                    shapeId: 'ASSET'
+                }
+            },
+            title: 'Homepage'
+        });
+    });
+    test('localized fields', () => {
+        const transforms = {
+            string: [identityTransform]
+        };
+        const transform = getContentTransform({
+            transforms,
+            projectSchema: {
+                ...shapeBooksSchema,
+                locales: [shapeBooksSchema.defaultLocale, 'fr-fr']
+            },
+            keyTransform: toName,
+            passThrough: false
+        });
+        const content = {
+            _updatedBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            _createdBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            _status: 'rkhRGs4WL',
+            r1xPx1OUW: {
+                shapeId: 'r166qcP8Z',
+                id: 'e1bc4031-783e-40e6-9881-d25d744ea6b3'
+            },
+            'r1xPx1OUW:fr-fr': {
+                shapeId: 'r166qcP8Z',
+                id: 'bf9b8b71-cf82-436a-90e2-8c1433533a2a"'
+            },
+            _createdAt: '2020-08-10T22:06:44.699Z',
+            _schemaVersion: 1,
+            _id: '64224dec8b5214586b9fd8aedd979ee7',
+            _shapeId: 'H1TFgJdIb',
+            _version: 1,
+            _updatedAt: '2020-08-10T22:06:44.699Z'
+        };
+        const transformed = transform(shapeBooksSchema.shapes.Homepage.schema, content);
+        expect(transformed).toEqual({
+            _createdAt: '2020-08-10T22:06:44.699Z',
+            _createdBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            _id: '64224dec8b5214586b9fd8aedd979ee7',
+            _shapeId: 'H1TFgJdIb',
+            _status: 'rkhRGs4WL',
+            _updatedAt: '2020-08-10T22:06:44.699Z',
+            _updatedBy: '1b499b01-bba7-4bc5-8ef5-08895a1d1322',
+            featuredBook: {
+                id: 'e1bc4031-783e-40e6-9881-d25d744ea6b3',
+                shapeId: 'r166qcP8Z'
+            },
+            'featuredBook:fr-fr': {
+                id: 'bf9b8b71-cf82-436a-90e2-8c1433533a2a"',
+                shapeId: 'r166qcP8Z'
+            }
+        });
+    });
+    test('allowNullObjects option', () => {
+        const projectSchema = {
+            ...createMockSchema('projectId'),
+            shapes: {
+                RocketPort: {
+                    name: 'RocketPort',
+                    title: 'RocketPort',
+                    id: 'RocketPort',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            lat: {
+                                type: 'number'
+                            },
+                            lon: {
+                                type: 'number'
+                            }
+                        }
+                    }
+                },
+                Species: {
+                    name: 'Species',
+                    title: 'Species',
+                    id: 'Species',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            hair: {
+                                type: 'string'
+                            },
+                            head: {
+                                type: 'string'
+                            }
+                        },
+                        required: ['hair', 'head']
+                    }
+                },
+                Planet: {
+                    name: 'Planet',
+                    title: 'Planet',
+                    id: 'Planet',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            species: { '@ref': 'shapedb:Species' },
+                            atmosphere: { type: 'string' },
+                            landStyle: { type: 'string' },
+                            rocketPorts: {
+                                type: 'array',
+                                items: { '@ref': 'shapedb:RocketPort' }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const transforms = {
+            string: [identityTransform],
+            number: [identityTransform]
+        };
+        const transformAllowNull = getContentTransform({
+            transforms,
+            projectSchema,
+            keyTransform: toName,
+            passThrough: false,
+            allowNullObjects: true
+        });
+        const transformNoNull = getContentTransform({
+            transforms,
+            projectSchema,
+            keyTransform: toName,
+            passThrough: false,
+            allowNullObjects: false
+        });
+        const content = {
+            species: null,
+            atmosphere: 'foggy',
+            landStyle: null,
+            rocketPorts: [null, { lat: 5, lon: 5 }]
+        };
+        const transformedAllowNull = transformAllowNull(projectSchema.shapes.Planet.schema, content);
+        expect(transformedAllowNull).toEqual({
+            species: null,
+            atmosphere: 'foggy',
+            landStyle: null,
+            rocketPorts: [null, { lat: 5, lon: 5 }]
+        });
+        const transformedNoNull = transformNoNull(projectSchema.shapes.Planet.schema, content);
+        expect(transformedNoNull).toEqual({
+            atmosphere: 'foggy',
+            landStyle: null,
+            rocketPorts: [undefined, { lat: 5, lon: 5 }]
+        });
+    });
+    test('recursive', () => {
+        const projectSchema = {
+            ...createMockSchema('projectId'),
+            shapes: {
+                Node: {
+                    name: 'Node',
+                    title: 'Node',
+                    id: 'node-id',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'number' },
+                            left: { $ref: '#/shapes/Node/schema' },
+                            right: { $ref: '#/shapes/Node/schema' }
+                        },
+                        required: ['value']
+                    }
+                }
+            }
+        };
+        const data = {
+            value: 50,
+            left: {
+                value: 25,
+                left: {
+                    value: 10
+                },
+                right: {
+                    value: 45
+                }
+            },
+            right: {
+                value: 75
+            }
+        };
+        const getAccumulator = () => {
+            let total = 0;
+            return {
+                accumulate(value) {
+                    if (typeof value === 'number') {
+                        total += value;
+                    }
+                },
+                getResults() {
+                    return total;
+                }
+            };
+        };
+        const totaler = getAccumulator();
+        const contentTransform = getContentTransform({
+            projectSchema,
+            accumulators: [totaler]
+        });
+        const notTransformed = contentTransform(projectSchema.shapes.Node.schema, data);
+        expect(notTransformed).toEqual(data);
+        expect(totaler.getResults()).toEqual(205);
+    });
+    test('oneOf', () => {
+        const data = {
+            OmG666: [
+                {
+                    Bu4jsC6I4: 'fido',
+                    SfsCYX0o5: true,
+                    _shapeId: 'SH7HPWJfn'
+                },
+                {
+                    '0zU9ToscC': 'fido',
+                    lnQIlRKUy: 666,
+                    _shapeId: 'j2VnVXELF'
+                }
+            ]
+        };
+        const contentTransform = getContentTransform({
+            projectSchema: petStoreSchema,
+            keyTransform: toName,
+            passThrough: true
+        });
+        const transformed = contentTransform(petStoreSchema.shapes.Store.schema, data);
+        expect(transformed).toEqual({
+            pets: [
+                {
+                    _shapeId: 'SH7HPWJfn',
+                    isBestFriend: true,
+                    name: 'fido'
+                },
+                {
+                    _shapeId: 'j2VnVXELF',
+                    lives: 666,
+                    name: 'fido'
+                }
+            ]
+        });
+    });
+});
+describe('getPropertyInfo', () => {
+    test('it works', () => {
+        const { schema } = shapeBooksSchema.shapes.Post;
+        const context = {
+            projectSchema: shapeBooksSchema,
+            transforms: {
+                string: [identityTransform]
+            }
+        };
+        const info = getPropertyInfo(context, schema, 'title');
+        expect(info).toEqual([
+            {
+                schema: dereferenceObjectSchema(shapeBooksSchema, shapeBooksSchema.shapes.Post.schema).properties.title,
+                key: 'BkJDGhw8W',
+                isRequired: false
+            }
+        ]);
+    });
+    test('array', () => {
+        const { schema } = shapeBooksSchema.shapes.Post;
+        const context = {
+            projectSchema: shapeBooksSchema,
+            transforms: {
+                string: [identityTransform]
+            }
+        };
+        const info = getPropertyInfo(context, schema, 'tags');
+        expect(info).toEqual([
+            {
+                schema: dereferenceObjectSchema(shapeBooksSchema, shapeBooksSchema.shapes.Post.schema).properties.tags,
+                key: 'Hkb57EkOQ',
+                isRequired: false
+            }
+        ]);
+    });
+    const millSchema = applyDefaultsToSchema({
+        ...createMockSchema('project-id'),
+        shapes: {
+            Sidebar: {
+                id: 'rJuZjRtJS',
+                name: 'Sidebar',
+                title: 'Main - Sidebar',
+                model: {
+                    type: 'multiple'
+                },
+                workflow: 'default',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        jurisdictions: {
+                            title: 'Jurisdictions',
+                            items: {
+                                $ref: '#/shapes/SidebarJurisdictions/schema'
+                            },
+                            type: 'array',
+                            '@mapping': 'shapedb:Sidebar.c81MqK71H'
+                        }
+                    },
+                    required: ['usedFor']
+                }
+            },
+            SidebarJurisdictions: {
+                id: 'c81MqK71H',
+                name: 'SidebarJurisdictions',
+                title: 'Main - Sidebar Jurisdictions',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        value: {
+                            minLength: 1,
+                            type: 'string',
+                            title: 'Value',
+                            '@mapping': 'shapedb:SidebarJurisdictions.FMYr9BGAG'
+                        }
+                    },
+                    required: ['value']
+                }
+            }
+        }
+    });
+    test('mill example', () => {
+        const { schema } = millSchema.shapes.Sidebar;
+        const context = {
+            projectSchema: millSchema,
+            transforms: {
+                string: [identityTransform]
+            }
+        };
+        const info = getPropertyInfo(context, schema, 'jurisdictions.value');
+        expect(info).toEqual([
+            {
+                schema: dereferenceObjectSchema(millSchema, millSchema.shapes.SidebarJurisdictions.schema).properties.value,
+                key: 'c81MqK71H.FMYr9BGAG',
+                isRequired: true
+            }
+        ]);
+    });
+    test('oneOf', () => {
+        const { schema } = petStoreSchema.shapes.Store;
+        const context = {
+            projectSchema: petStoreSchema,
+            transforms: {
+                string: [identityTransform]
+            }
+        };
+        const info = getPropertyInfo(context, schema, 'pets.name');
+        expect(info).toEqual([
+            {
+                key: 'OmG666.Bu4jsC6I4',
+                schema: {
+                    '@mapping': 'shapedb:Dog.Bu4jsC6I4',
+                    description: '',
+                    minLength: 1,
+                    title: 'Name',
+                    type: 'string'
+                },
+                isRequired: true
+            },
+            {
+                key: 'OmG666.0zU9ToscC',
+                schema: {
+                    '@mapping': 'shapedb:Cat.0zU9ToscC',
+                    description: '',
+                    minLength: 1,
+                    title: 'Name',
+                    type: 'string'
+                },
+                isRequired: true
+            }
+        ]);
+    });
+});

package/dist/__tests__/create-input-schema.test.d.ts

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

package/dist/__tests__/create-input-schema.test.js

@@ -0,0 +1,184 @@
+import { expect, test, vi } from 'vitest';
+import { createInputSchema } from "../create-input-schema.js";
+test('rewriteSchema', () => {
+    const schema = {
+        type: 'object',
+        properties: {
+            title: { type: 'string' },
+            live: {
+                type: 'boolean',
+                default: false
+            },
+            rating: {
+                type: 'string',
+                '@mapping': 'foo.bar',
+                '@input': {
+                    type: 'number'
+                }
+            }
+        },
+        required: ['title']
+    };
+    const jsonParse = JSON.parse;
+    JSON.parse = vi.fn().mockImplementation((text, reviver) => {
+        return jsonParse(text, reviver);
+    });
+    expect(createInputSchema(schema, { isUpdate: true })).toEqual({
+        type: 'object',
+        properties: {
+            title: { type: 'string' },
+            live: { type: 'boolean' },
+            rating: {
+                type: 'number',
+                '@output': {
+                    type: 'string'
+                },
+                '@mapping': 'foo.bar'
+            }
+        }
+    });
+});
+test('rewriteSchema - removes @resolver', () => {
+    const schema = {
+        type: 'object',
+        properties: {
+            greeting: {
+                '@l10n': true,
+                minLength: 1,
+                type: 'string',
+                title: 'Greeting',
+                '@mapping': 'shapedb:Homie.Ulpa_mHb3'
+            },
+            splash: {
+                '@l10n': true,
+                '@args': 'TSRelationshipArgs',
+                '@resolver': {
+                    name: 'shapedb:getRelated',
+                    service: 'shapedb',
+                    options: { nullable: true }
+                },
+                '@ref': 'local:Asset',
+                '@input': { '@ref': 'local:TSRelationship' },
+                title: 'Splash',
+                '@mapping': 'shapedb:Homie.0KGSDRXTC'
+            },
+            _references: {
+                '@args': 'AuthorReferenceTSListArgs',
+                '@ref': 'AuthorReferencePaginatedList',
+                '@resolver': {
+                    args: {
+                        ops: [
+                            {
+                                path: '$',
+                                mapping: '$args'
+                            },
+                            {
+                                path: 'baseWhere._references.eq',
+                                mapping: '$source._id'
+                            },
+                            {
+                                path: 'baseWhere._shapeId.in',
+                                value: ['asset-id', 'post-id', 'book-id']
+                            }
+                        ]
+                    },
+                    name: 'shapedb:list',
+                    service: 'shapedb'
+                }
+            }
+        },
+        required: ['greeting', 'splash']
+    };
+    expect(createInputSchema(schema)).toEqual({
+        properties: {
+            greeting: {
+                '@l10n': true,
+                '@mapping': 'shapedb:Homie.Ulpa_mHb3',
+                minLength: 1,
+                title: 'Greeting',
+                type: 'string'
+            },
+            splash: {
+                '@l10n': true,
+                '@mapping': 'shapedb:Homie.0KGSDRXTC',
+                '@output': {
+                    '@args': 'TSRelationshipArgs',
+                    '@ref': 'local:Asset',
+                    '@resolver': {
+                        name: 'shapedb:getRelated',
+                        options: {
+                            nullable: true
+                        },
+                        service: 'shapedb'
+                    }
+                },
+                '@ref': 'local:TSRelationship',
+                title: 'Splash'
+            }
+        },
+        required: ['greeting', 'splash'],
+        type: 'object'
+    });
+});
+test('rewriteSchema - l10n', () => {
+    const schema = {
+        type: 'object',
+        properties: {
+            greeting: {
+                '@l10n': true,
+                minLength: 1,
+                type: 'string',
+                title: 'Greeting',
+                '@mapping': 'shapedb:Homie.Ulpa_mHb3'
+            },
+            splash: {
+                '@l10n': true,
+                '@args': 'TSRelationshipArgs',
+                '@resolver': {
+                    name: 'shapedb:getRelated',
+                    service: 'shapedb',
+                    options: { nullable: true }
+                },
+                '@ref': 'local:Asset',
+                '@input': { '@ref': 'local:TSRelationship' },
+                title: 'Splash',
+                '@mapping': 'shapedb:Homie.0KGSDRXTC'
+            }
+        },
+        required: ['greeting', 'splash']
+    };
+    expect(createInputSchema(schema)).toEqual({
+        properties: {
+            greeting: {
+                '@l10n': true,
+                '@mapping': 'shapedb:Homie.Ulpa_mHb3',
+                minLength: 1,
+                title: 'Greeting',
+                type: 'string'
+            },
+            splash: {
+                '@l10n': true,
+                '@mapping': 'shapedb:Homie.0KGSDRXTC',
+                '@output': {
+                    '@args': 'TSRelationshipArgs',
+                    '@ref': 'local:Asset',
+                    '@resolver': {
+                        name: 'shapedb:getRelated',
+                        options: {
+                            nullable: true
+                        },
+                        service: 'shapedb'
+                    }
+                },
+                '@ref': 'local:TSRelationship',
+                title: 'Splash'
+            }
+        },
+        required: ['greeting', 'splash'],
+        type: 'object'
+    });
+});
+test('rewriteSchema - handles nulls', () => {
+    const bogus = { foo: null };
+    expect(createInputSchema(bogus)).toEqual(bogus);
+});