@takeshape/schema 11.73.0 → 11.76.0

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

@@ -1,522 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import shapeBooksJson from '@/examples/latest/shape-books.json';
-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

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

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

@@ -1,184 +0,0 @@
-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);
-});