@takeshape/schema 11.52.0 → 11.56.1

package/dist/unions.js

@@ -0,0 +1,77 @@
+import { BadDataError } from '@takeshape/errors';
+import { camelCase, isRecord } from '@takeshape/util';
+import omit from 'lodash/omit.js';
+import { getRef, refItemToNamespacedShapeName } from "./refs.js";
+import { getOutputShapeName } from "./template-shapes/names.js";
+import { isRefSchema } from "./types/utils.js";
+import { getShapeById } from "./util/shapes.js";
+export function enumerateOneOfKeys(projectSchema, oneOf) {
+    const result = [];
+    for (const child of oneOf) {
+        const refItem = getRef(projectSchema, child);
+        if (refItem) {
+            const shapeName = refItemToNamespacedShapeName(refItem);
+            if (projectSchema.shapes[shapeName]) {
+                const shapeId = projectSchema.shapes[shapeName].id;
+                result.push({
+                    propName: getOutputShapeName(camelCase(refItem.typeName)),
+                    propSchema: child,
+                    shapeName,
+                    shapeId
+                });
+            }
+        }
+    }
+    return result;
+}
+function getOneOf(schema) {
+    if (!schema.oneOf) {
+        throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
+    }
+    return schema.oneOf;
+}
+export function isUnionSchema(schema) {
+    return Boolean(schema.oneOf?.every(isRefSchema));
+}
+export function oneOfToObject(projectSchema, schema) {
+    const properties = {};
+    for (const { propName, propSchema: child } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
+        properties[propName] = child;
+    }
+    return { ...omit(schema, 'oneOf'), type: 'object', properties };
+}
+function formatKeys(keys) {
+    return keys.map((k) => `"${k}"`).join(', ');
+}
+export const createUnwrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
+    if (isRecord(obj)) {
+        const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
+        const objectKeys = Object.keys(obj);
+        if (objectKeys.length !== 1) {
+            const propNames = oneOfKeys.map((k) => k.propName);
+            throw new BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
+        }
+        for (const { propName, shapeId, propSchema } of oneOfKeys) {
+            const propValue = obj[propName];
+            if (isRecord(propValue)) {
+                const transformedPropValue = next(propValue, propSchema, name);
+                if (isRecord(transformedPropValue)) {
+                    return {
+                        ...transformedPropValue,
+                        _shapeId: shapeId
+                    };
+                }
+            }
+        }
+    }
+};
+export const createWrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
+    if (isRecord(obj) && typeof obj._shapeId === 'string') {
+        const shape = getShapeById(projectSchema, obj._shapeId);
+        if (shape) {
+            return {
+                [camelCase(shape.name)]: next(omit(obj, '_shapeId'), shape.schema, name)
+            };
+        }
+    }
+};

package/dist/util/__tests__/api-indexing.test.d.ts

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

package/dist/util/__tests__/api-indexing.test.js

@@ -0,0 +1,129 @@
+import shopifySchemaJson from '@/examples/latest/shopify-product-2023-04.json';
+import { describe, expect, test } from 'vitest';
+import { getListQueryIndexConfigs, serviceHasIndexedShapes } from "../api-indexing.js";
+function mockShopifySchemaWithIndexing(shape) {
+    return {
+        ...shopifySchema,
+        shapes: {
+            ...shopifySchema.shapes,
+            Shopify_Product: {
+                ...shopifySchema.shapes.Shopify_Product,
+                ...shape
+            }
+        }
+    };
+}
+const shopifySchema = shopifySchemaJson;
+const baseShape = shopifySchema.shapes.Shopify_Product;
+describe('serviceHasIndexedShapes', () => {
+    test('returns true when the service has indexed shapes', () => {
+        const schema = mockShopifySchemaWithIndexing({
+            loaders: {
+                list: {
+                    query: 'shopify:Query.products'
+                }
+            },
+            cache: {
+                enabled: true
+            }
+        });
+        expect(serviceHasIndexedShapes(schema, 'shopify')).toBe(true);
+    });
+    test('returns false when the schema has no indexed shapes', () => {
+        expect(serviceHasIndexedShapes(shopifySchema, 'shopify')).toBe(false);
+    });
+    test('returns false when no indexed shapes have a list query', () => {
+        const schema = mockShopifySchemaWithIndexing({
+            cache: {
+                enabled: true
+            }
+        });
+        expect(serviceHasIndexedShapes(schema, 'shopify')).toBe(false);
+    });
+});
+describe('getListQueryIndexConfig', () => {
+    test('handles shape not configured', () => {
+        expect(getListQueryIndexConfigs({ shapes: {} }, 'Shopify_Product')).toBe(undefined);
+    });
+    test('handles list query not configured', () => {
+        expect(getListQueryIndexConfigs({
+            shapes: {
+                Shopify_Product: baseShape
+            }
+        }, 'Shopify_Product')).toBe(undefined);
+    });
+    test('combines common config and adds shapeName', () => {
+        expect(getListQueryIndexConfigs({
+            shapes: {
+                Shopify_Product: {
+                    ...baseShape,
+                    cache: {
+                        enabled: true,
+                        fragment: {
+                            maxDepth: 1
+                        }
+                    },
+                    loaders: {
+                        list: {
+                            query: 'shopify:Query.products'
+                        }
+                    }
+                }
+            }
+        }, 'Shopify_Product')).toEqual([
+            {
+                shapeName: 'Shopify_Product',
+                idField: 'id',
+                query: 'shopify:Query.products',
+                maxDepth: 1
+            }
+        ]);
+    });
+    test('flattens args', () => {
+        expect(getListQueryIndexConfigs({
+            shapes: {
+                Shopify_Product: {
+                    ...baseShape,
+                    cache: {
+                        enabled: true,
+                        fragment: {
+                            maxDepth: 1
+                        }
+                    },
+                    loaders: {
+                        list: {
+                            query: 'shopify:Query.products',
+                            args: [
+                                {
+                                    query: 'tag: foo'
+                                },
+                                {
+                                    query: 'tag: bar'
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        }, 'Shopify_Product')).toEqual([
+            {
+                shapeName: 'Shopify_Product',
+                idField: 'id',
+                query: 'shopify:Query.products',
+                maxDepth: 1,
+                args: {
+                    query: 'tag: foo'
+                }
+            },
+            {
+                shapeName: 'Shopify_Product',
+                idField: 'id',
+                query: 'shopify:Query.products',
+                maxDepth: 1,
+                args: {
+                    query: 'tag: bar'
+                }
+            }
+        ]);
+    });
+});

package/dist/util/__tests__/detect-cycles.test.d.ts

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

package/dist/util/__tests__/detect-cycles.test.js

@@ -0,0 +1,193 @@
+import shopifySchemaJson from '@/examples/latest/shopify-store-with-widget.json';
+import { expect, test } from 'vitest';
+import { createMockSchema } from "../../mocks.js";
+import { hasCycle } from "../detect-cycles.js";
+const shopifySchema = shopifySchemaJson;
+const cycle = {
+    ...createMockSchema('project-schema'),
+    shapes: {
+        A: {
+            id: 'A',
+            name: 'A',
+            title: 'A',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    left: {
+                        '@ref': 'local:B'
+                    },
+                    right: {
+                        '@ref': 'local:C'
+                    }
+                }
+            }
+        },
+        B: {
+            id: 'B',
+            name: 'B',
+            title: 'B',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    left: {
+                        '@ref': 'local:C'
+                    }
+                }
+            }
+        },
+        C: {
+            id: 'C',
+            name: 'C',
+            title: 'C',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    right: {
+                        '@ref': 'local:A'
+                    }
+                }
+            }
+        },
+        D: {
+            id: 'D',
+            name: 'D',
+            title: 'D',
+            schema: {
+                type: 'object',
+                properties: {
+                    left: {
+                        oneOf: [
+                            {
+                                '@ref': 'local:E'
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        E: {
+            id: 'E',
+            name: 'E',
+            title: 'E',
+            schema: {
+                type: 'object',
+                properties: {
+                    right: {
+                        oneOf: [
+                            {
+                                '@ref': 'local:D'
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    }
+};
+const noCycle = {
+    ...createMockSchema('project-schema'),
+    shapes: {
+        A: {
+            id: 'A',
+            name: 'A',
+            title: 'A',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    left: {
+                        '@ref': 'local:C'
+                    },
+                    right: {
+                        '@ref': 'local:B'
+                    }
+                }
+            }
+        },
+        B: {
+            id: 'B',
+            name: 'B',
+            title: 'B',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    left: {
+                        '@ref': 'local:C'
+                    }
+                }
+            }
+        },
+        C: {
+            id: 'C',
+            name: 'C',
+            title: 'C',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' }
+                }
+            }
+        },
+        D: {
+            id: 'D',
+            name: 'D',
+            title: 'D',
+            schema: {
+                type: 'object',
+                properties: {
+                    left: {
+                        '@ref': 'local:Missing'
+                    }
+                }
+            }
+        }
+    }
+};
+test('hasCycle - true', () => {
+    const schemaA = cycle.shapes.A.schema;
+    expect(hasCycle(cycle, schemaA)).toBe(true);
+    expect(hasCycle(cycle, schemaA.properties.left)).toBe(true);
+    expect(hasCycle(cycle, schemaA.properties.right)).toBe(true);
+    const schemaB = cycle.shapes.B.schema;
+    expect(hasCycle(cycle, schemaB)).toBe(true);
+    expect(hasCycle(cycle, schemaB.properties.left)).toBe(true);
+    const schemaC = cycle.shapes.C.schema;
+    expect(hasCycle(cycle, schemaC)).toBe(true);
+    expect(hasCycle(cycle, schemaC.properties.right)).toBe(true);
+    const schemaD = cycle.shapes.D.schema;
+    expect(hasCycle(cycle, schemaD)).toBe(true);
+    expect(hasCycle(cycle, schemaD.properties.left)).toBe(true);
+    const schemaE = cycle.shapes.E.schema;
+    expect(hasCycle(cycle, schemaE)).toBe(true);
+    expect(hasCycle(cycle, schemaE.properties.right)).toBe(true);
+});
+test('hasCycle - false', () => {
+    const schemaA = noCycle.shapes.A.schema;
+    expect(hasCycle(noCycle, schemaA)).toBe(false);
+    expect(hasCycle(noCycle, schemaA.properties.left)).toBe(false);
+    expect(hasCycle(noCycle, schemaA.properties.right)).toBe(false);
+    const schemaB = noCycle.shapes.B.schema;
+    expect(hasCycle(noCycle, schemaB)).toBe(false);
+    expect(hasCycle(noCycle, schemaB.properties.left)).toBe(false);
+    const schemaC = noCycle.shapes.C.schema;
+    expect(hasCycle(noCycle, schemaC)).toBe(false);
+    expect(hasCycle(noCycle, schemaC.properties.title)).toBe(false);
+    const schemaD = noCycle.shapes.D.schema;
+    expect(hasCycle(noCycle, schemaD)).toBe(false);
+    expect(hasCycle(noCycle, schemaD.properties.left)).toBe(false);
+});
+test('hasCycle - shopify schema', () => {
+    const { Product, Shopify_Product } = shopifySchema.shapes;
+    expect(hasCycle(shopifySchema, Product.schema)).toBe(true);
+    expect(hasCycle(shopifySchema, Shopify_Product.schema)).toBe(true);
+});
+test('hasCycle - predicate', () => {
+    const schemaA = cycle.shapes.A.schema;
+    expect(hasCycle(cycle, schemaA, (projectSchema, propSchema, shapeName, propName) => {
+        return !(shapeName === 'C' && propName === 'right');
+    })).toBe(false);
+});

package/dist/util/__tests__/find-shape-at-path.test.d.ts

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

package/dist/util/__tests__/find-shape-at-path.test.js

@@ -0,0 +1,41 @@
+import shopifySchema from '@/examples/latest/pruned-shopify-product-schema.json';
+import shapeBooksSchemaJson from '@/examples/latest/shape-books.json';
+import { describe, expect, test } from 'vitest';
+import { flattenTemplates } from "../../flatten-templates.js";
+import { applyDefaultsToSchema } from "../../schema-util.js";
+import { findSchemaAtPath, findShapeAtPath } from "../find-shape-at-path.js";
+const shapeBooksSchema = flattenTemplates(applyDefaultsToSchema(shapeBooksSchemaJson));
+describe('findSchemaAtPath', () => {
+    test('found - shopify', () => {
+        expect(findSchemaAtPath(shopifySchema, shopifySchema.shapes.Shopify_ProductConnection.schema, [
+            'edges',
+            'node',
+            'collections',
+            'edges',
+            'node'
+        ])).toMatchObject({ '@ref': 'shopify:takeshape-io-shop:Collection' });
+    });
+    test('found - shape books', () => {
+        expect(findSchemaAtPath(shapeBooksSchema, shapeBooksSchema.shapes.BookPaginatedList.schema, ['items'])).toMatchObject({ items: { '@ref': 'local:Book' } });
+    });
+    test('not found', () => {
+        expect(findSchemaAtPath(shopifySchema, shopifySchema.shapes.Shopify_ProductConnection, ['edges', 'node', 'bogus'])).toBe(undefined);
+    });
+});
+describe('findShapeAtPath', () => {
+    test('found - shopify', () => {
+        expect(findShapeAtPath(shopifySchema, shopifySchema.shapes.Shopify_ProductConnection.schema, [
+            'edges',
+            'node',
+            'collections',
+            'edges',
+            'node'
+        ])).toEqual(shopifySchema.shapes.Shopify_Collection);
+    });
+    test('found - shape books', () => {
+        expect(findShapeAtPath(shapeBooksSchema, shapeBooksSchema.shapes.BookPaginatedList.schema, ['items'])).toEqual(shapeBooksSchema.shapes.Book);
+    });
+    test('not found', () => {
+        expect(findShapeAtPath(shopifySchema, shopifySchema.shapes.Shopify_ProductConnection, ['edges', 'node', 'bogus'])).toBe(undefined);
+    });
+});

package/dist/util/__tests__/form-config.test.d.ts

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

package/dist/util/__tests__/form-config.test.js

@@ -0,0 +1,196 @@
+import { expect, test } from 'vitest';
+import { createMockSchema } from "../../mocks.js";
+import { normalizeForms } from "../form-config.js";
+const projectSchema = createMockSchema('project-id', {
+    shapes: {
+        PostSeoMetaTags: {
+            id: 'PostSeoMetaTags',
+            name: 'PostSeoMetaTags',
+            title: 'PostSeoMetaTags',
+            schema: {
+                type: 'object',
+                properties: {
+                    viewport: {
+                        minLength: 0,
+                        type: 'string',
+                        title: 'Viewport',
+                        '@mapping': 'shapedb:AObjectObject.hwoob0l_q'
+                    }
+                }
+            }
+        },
+        PostSeo: {
+            id: 'PostSeo',
+            name: 'PostSeo',
+            title: 'Post Seo',
+            schema: {
+                type: 'object',
+                properties: {
+                    documentTitle: {
+                        minLength: 0,
+                        type: 'string',
+                        title: 'Document Title',
+                        '@mapping': 'shapedb:PostSeo.hwZvb0l_q'
+                    },
+                    favicon: {
+                        '@args': 'TSRelationshipArgs',
+                        '@resolver': {
+                            name: 'shapedb:getRelated',
+                            service: 'shapedb'
+                        },
+                        '@ref': 'local:Asset',
+                        '@input': { '@ref': 'local:TSRelationship' },
+                        title: 'Favicon',
+                        '@backreference': { enabled: true },
+                        '@mapping': 'shapedb:PostSeo.8PWcKmdvb'
+                    },
+                    metaTags: {
+                        title: 'Meta Tags',
+                        '@ref': 'local:PostSeoMetaTags',
+                        '@mapping': 'shapedb:PostSeo.rSZsienVNw'
+                    }
+                }
+            }
+        },
+        PostSlider: {
+            id: 'PostSlider',
+            name: 'PostSlider',
+            title: 'Post Slider',
+            schema: {
+                type: 'object',
+                properties: {
+                    image: {
+                        title: 'Image',
+                        '@mapping': 'shapedb:ProjectImagesSlider.ryus8FF64',
+                        '@backreference': {
+                            enabled: true
+                        },
+                        '@ref': 'local:Asset',
+                        '@input': {
+                            '@ref': 'local:TSRelationship'
+                        },
+                        '@args': 'TSRelationshipArgs',
+                        '@resolver': {
+                            name: 'shapedb:getRelated',
+                            service: 'shapedb',
+                            options: {
+                                nullable: true
+                            }
+                        }
+                    }
+                },
+                required: ['list']
+            }
+        },
+        Post: {
+            id: 'Post',
+            name: 'Post',
+            title: 'Post',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: {
+                        minLength: 1,
+                        type: 'string',
+                        title: 'title',
+                        '@mapping': 'shapedb:Post.7M3-Zj6IT'
+                    },
+                    body: {
+                        minLength: 1,
+                        type: 'string',
+                        '@tag': 'mdx',
+                        title: 'Block Canvas MDX',
+                        '@mapping': 'shapedb:Post.cgPEfNcFq'
+                    },
+                    slider: {
+                        title: 'Slider',
+                        items: {
+                            '@ref': 'local:PostSlider'
+                        },
+                        minItems: 1,
+                        type: 'array',
+                        '@mapping': 'shapedb:ProjectImages.r1-jLYtT4'
+                    },
+                    seo: {
+                        title: 'Seo',
+                        '@ref': 'local:PostSeo',
+                        '@mapping': 'shapedb:Post.rSZscwVNw'
+                    }
+                },
+                required: ['title', 'body']
+            }
+        }
+    },
+    workflows: {},
+    forms: {
+        Post: {
+            default: {
+                properties: {
+                    title: { widget: 'singleLineText' },
+                    body: { widget: 'wysiwygTextMdx' },
+                    slider: {
+                        widget: 'repeater',
+                        properties: {
+                            image: {
+                                widget: 'image'
+                            }
+                        },
+                        order: ['list']
+                    },
+                    seo: {
+                        widget: 'object',
+                        properties: {
+                            documentTitle: { widget: 'singleLineText' },
+                            favicon: { widget: 'relationship' },
+                            metaTags: {
+                                widget: 'object',
+                                properties: {
+                                    viewport: { widget: 'singleLineText' }
+                                },
+                                order: ['viewport']
+                            }
+                        },
+                        order: ['documentTitle', 'favicon', 'metaTags']
+                    }
+                },
+                order: ['title', 'body', 'seo']
+            }
+        }
+    }
+});
+const expected = {
+    Post: projectSchema.forms?.Post,
+    PostSlider: {
+        default: {
+            order: ['list'],
+            properties: {
+                image: {
+                    widget: 'image'
+                }
+            },
+            widget: 'repeater'
+        }
+    },
+    PostSeo: {
+        default: {
+            widget: 'object',
+            properties: {
+                documentTitle: { widget: 'singleLineText' },
+                favicon: { widget: 'relationship' }
+            },
+            order: ['documentTitle', 'favicon', 'metaTags']
+        }
+    },
+    PostSeoMetaTags: {
+        default: {
+            widget: 'object',
+            properties: {
+                viewport: { widget: 'singleLineText' }
+            },
+            order: ['viewport']
+        }
+    }
+};
+test('normalizeForms', () => {
+    expect(normalizeForms(projectSchema)).toEqual(expected);
+});

package/dist/util/__tests__/get-return-shape.test.d.ts

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

package/dist/util/__tests__/get-return-shape.test.js

@@ -0,0 +1,27 @@
+import shopifySchema from '@/examples/latest/pruned-shopify-product-schema.json';
+import { describe, expect, test } from 'vitest';
+import { getReturnShape } from "../get-return-shape.js";
+describe('getReturnShape', () => {
+    test('query', () => {
+        expect(getReturnShape(shopifySchema, shopifySchema.queries.Shopify_products)).toEqual(shopifySchema.shapes.Shopify_ProductConnection);
+        // again from cache
+        expect(getReturnShape(shopifySchema, shopifySchema.queries.Shopify_products)).toEqual(shopifySchema.shapes.Shopify_ProductConnection);
+    });
+    test('property', () => {
+        const { collections } = shopifySchema.shapes.Shopify_Product.schema.properties;
+        expect(getReturnShape(shopifySchema, collections)).toEqual(shopifySchema.shapes.Shopify_CollectionConnection);
+        // again from cache
+        expect(getReturnShape(shopifySchema, collections)).toEqual(shopifySchema.shapes.Shopify_CollectionConnection);
+    });
+    test('none found', () => {
+        const query = {
+            shape: 'Bogus',
+            resolver: {
+                name: 'util:noop'
+            }
+        };
+        expect(getReturnShape(shopifySchema, query)).toEqual(undefined);
+        // again from cache
+        expect(getReturnShape(shopifySchema, query)).toEqual(undefined);
+    });
+});

package/dist/util/__tests__/has-args.test.d.ts

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