@takeshape/schema 11.52.0 → 11.55.0

package/dist/__tests__/refs.test.js

@@ -0,0 +1,752 @@
+import shapeBooksSchema from '@/examples/latest/shape-books.json';
+import shopifyStoreJson from '@/examples/latest/shopify-store-with-widget.json';
+import valvolineSchema from '@/examples/latest/valvoline-ai-demo.json';
+import { describe, expect, it, test } from 'vitest';
+import { createMockSchema, createMockSchemaWithDefaults } from "../mocks.js";
+import { $refToAtRef, anyRefToShapeSchemaPath, createGetNamespace, createTemplateShapeName, dereferenceSchema, getAllPropertyRefs, getOneOfRefs, getRefShapeName, hasRef, hasRefProperty, hasResolvableRef, normalizeLocalRefString, normalizeRefExpression, normalizeRefs, parsePropertyRef, parseReturnShape, parseTemplateShape, propertyRefItemToArgsPath, propertyRefItemToResolverPath, propertyRefToArgs, propertyRefToShapeRef, refExpressionToRefItem, refExpressionToShape, refSchemaToPath, returnShapeToSchema, serializePropertyRef, untemplate } from "../refs.js";
+import { createShape } from "../schema-util.js";
+const schema = shopifyStoreJson.shapes.Product.schema;
+test('getRefShapeName', () => {
+    const expected = 'Shopify_Product';
+    const actual = getRefShapeName(shopifyStoreJson, schema.properties.gregsTakeshapeStore);
+    expect(actual).toEqual(expected);
+});
+test('anyRefToShapeSchemaPath', () => {
+    const expected = ['shapes', 'Shopify_Product', 'schema'];
+    const actual = anyRefToShapeSchemaPath(shopifyStoreJson, schema.properties.gregsTakeshapeStore);
+    expect(actual).toEqual(expected);
+});
+test('hasRefProperty', () => {
+    const expected = true;
+    const actual = hasRefProperty(schema.properties.gregsTakeshapeStore);
+    expect(actual).toEqual(expected);
+});
+describe('hasRef', () => {
+    const mockFieldSchema = {
+        type: 'object',
+        properties: {
+            mock: {
+                type: 'string'
+            }
+        }
+    };
+    it('is true with @ref', () => {
+        const schema = {
+            '@ref': 'local:Fake'
+        };
+        const schemaHasRef = hasRef(schema);
+        expect(schemaHasRef).toEqual(true);
+    });
+    it('is true with $ref', () => {
+        const schema = {
+            $ref: '#/shapes/Fake/schema'
+        };
+        const schemaHasRef = hasRef(schema);
+        expect(schemaHasRef).toEqual(true);
+    });
+    it('is true with nested schemas (mixed)', () => {
+        const allOfSchema = {
+            allOf: [
+                {
+                    '@ref': 'local:Fake'
+                },
+                mockFieldSchema
+            ]
+        };
+        const allOfSchemaHasRef = hasRef(allOfSchema);
+        expect(allOfSchemaHasRef).toEqual(true);
+        const oneOfSchema = {
+            oneOf: [
+                {
+                    '@ref': 'local:Fake'
+                },
+                mockFieldSchema
+            ]
+        };
+        const oneOfSchemaHasRef = hasRef(oneOfSchema);
+        expect(oneOfSchemaHasRef).toEqual(true);
+    });
+    it('is false when there are none', () => {
+        const oneOfSchema = {
+            oneOf: [mockFieldSchema]
+        };
+        const oneOfSchemaHasRef = hasRef(oneOfSchema);
+        expect(oneOfSchemaHasRef).toEqual(false);
+    });
+});
+describe('hasResolvableRef', () => {
+    const mockProjectSchema = createMockSchemaWithDefaults('mock-project-id');
+    const mockFieldSchema = {
+        type: 'object',
+        properties: {
+            mock: {
+                type: 'string'
+            }
+        }
+    };
+    it('is true with @ref', () => {
+        const schema = {
+            '@ref': 'local:Asset'
+        };
+        const schemaHasRef = hasResolvableRef(mockProjectSchema, schema);
+        expect(schemaHasRef).toEqual(true);
+    });
+    it('is true with $ref', () => {
+        const schema = {
+            $ref: '#/shapes/Asset/schema'
+        };
+        const schemaHasRef = hasResolvableRef(mockProjectSchema, schema);
+        expect(schemaHasRef).toEqual(true);
+    });
+    it('is true with nested schemas (mixed) ', () => {
+        const allOfSchema = {
+            allOf: [
+                {
+                    '@ref': 'local:Asset'
+                },
+                mockFieldSchema
+            ]
+        };
+        const allOfSchemaHasRef = hasResolvableRef(mockProjectSchema, allOfSchema);
+        expect(allOfSchemaHasRef).toEqual(true);
+        const oneOfSchema = {
+            oneOf: [
+                {
+                    '@ref': 'local:Asset'
+                },
+                mockFieldSchema
+            ]
+        };
+        const oneOfSchemaHasRef = hasResolvableRef(mockProjectSchema, oneOfSchema);
+        expect(oneOfSchemaHasRef).toEqual(true);
+    });
+    it('is false when there are none', () => {
+        const schema = {
+            oneOf: [
+                {
+                    '@ref': 'remote:Shape'
+                },
+                mockFieldSchema
+            ]
+        };
+        const hasRef = hasResolvableRef(mockProjectSchema, schema);
+        expect(hasRef).toEqual(false);
+    });
+});
+describe('$refToAtRef', () => {
+    it('works', () => {
+        const atRef = $refToAtRef('#/shapes/Shopify_Product/schema', 'my-service', 'Shopify');
+        expect(atRef).toEqual('my-service:Product');
+    });
+    it('works with local ref', () => {
+        const atRef = $refToAtRef('#/shapes/Product/schema', 'local');
+        expect(atRef).toEqual('local:Product');
+    });
+});
+describe('refSchemaToPath', () => {
+    it('works', () => {
+        expect(refSchemaToPath(shopifyStoreJson, { '@ref': 'local:Product' })).toEqual(['shapes', 'Product']);
+    });
+});
+describe('refExpressionToRefItem', () => {
+    it('template and at ref', () => {
+        expect(refExpressionToRefItem(shopifyStoreJson, 'CreateArgs<gregs-takeshape-store:Product>')).toEqual({
+            isForeign: true,
+            serviceKey: 'gregs-takeshape-store',
+            serviceNamespace: 'Shopify',
+            template: 'CreateArgs',
+            typeName: 'Product',
+            isValidService: true
+        });
+    });
+    it('service namespace', () => {
+        expect(refExpressionToRefItem(shopifyStoreJson, 'Shopify_Product')).toEqual({
+            isForeign: true,
+            serviceKey: 'gregs-takeshape-store',
+            serviceNamespace: 'Shopify',
+            typeName: 'Product',
+            isValidService: true
+        });
+    });
+    it('@ref', () => {
+        expect(refExpressionToRefItem(shopifyStoreJson, 'gregs-takeshape-store:Product')).toEqual({
+            isForeign: true,
+            serviceKey: 'gregs-takeshape-store',
+            serviceNamespace: 'Shopify',
+            typeName: 'Product',
+            isValidService: true
+        });
+    });
+});
+test('refExpressionToShape', () => {
+    expect(refExpressionToShape(shopifyStoreJson, 'CreateArgs<Product>')).toEqual(shopifyStoreJson.shapes.Product);
+});
+describe('parseTemplateShape', () => {
+    test('no template', () => {
+        expect(parseTemplateShape('Post')).toEqual({
+            shapeName: 'Post',
+            template: undefined
+        });
+    });
+    test('with template', () => {
+        expect(parseTemplateShape('CreateArgs<Product>')).toEqual({
+            shapeName: 'Product',
+            template: 'CreateArgs'
+        });
+    });
+    test('service namespace', () => {
+        expect(parseTemplateShape('Shopify_Post')).toEqual({
+            shapeName: 'Shopify_Post',
+            template: undefined
+        });
+    });
+});
+describe('parseReturnShape', () => {
+    test('string', () => {
+        expect(parseReturnShape(shapeBooksSchema, 'Post')).toEqual({
+            shapeName: 'Post',
+            template: undefined,
+            isArray: false,
+            ref: {
+                isForeign: false,
+                serviceKey: 'local',
+                typeName: 'Post',
+                isValidService: true
+            }
+        });
+    });
+    test('ref string', () => {
+        expect(parseReturnShape(shapeBooksSchema, 'local:Post')).toEqual({
+            shapeName: 'Post',
+            template: undefined,
+            isArray: false,
+            ref: {
+                isForeign: false,
+                serviceKey: 'local',
+                typeName: 'Post',
+                isValidService: true
+            }
+        });
+    });
+    test('ref string with template', () => {
+        expect(parseReturnShape(shopifyStoreJson, 'PaginatedList<shopify:Post>')).toEqual({
+            isArray: false,
+            ref: {
+                isForeign: false,
+                serviceKey: 'shopify',
+                template: 'PaginatedList',
+                typeName: 'Post',
+                isValidService: false
+            },
+            shapeName: 'Post',
+            template: 'PaginatedList'
+        });
+    });
+    test('array schema', () => {
+        expect(parseReturnShape(shapeBooksSchema, {
+            type: 'array',
+            items: { '@ref': 'local:Post' }
+        })).toEqual({
+            shapeName: 'Post',
+            template: undefined,
+            isArray: true,
+            ref: {
+                isForeign: false,
+                serviceKey: 'local',
+                typeName: 'Post',
+                isValidService: true
+            }
+        });
+    });
+    test('array schema scalar', () => {
+        expect(parseReturnShape(shapeBooksSchema, {
+            type: 'array',
+            items: { type: 'string' }
+        })).toEqual({
+            shapeName: 'string',
+            template: undefined,
+            isArray: true
+        });
+    });
+});
+describe('returnShapeToSchema', () => {
+    test('string', () => {
+        const schema = returnShapeToSchema(shapeBooksSchema, 'Post');
+        expect(schema).toEqual({ '@ref': 'local:Post' });
+    });
+    test('string scalar', () => {
+        const schema = returnShapeToSchema(shapeBooksSchema, 'string');
+        expect(schema).toEqual({ type: 'string' });
+    });
+    test('string open object', () => {
+        const schema = returnShapeToSchema(shapeBooksSchema, 'object');
+        expect(schema).toEqual({ type: 'object' });
+    });
+    test('array schema scalar', () => {
+        const returnShape = {
+            type: 'array',
+            items: { type: 'string' }
+        };
+        expect(returnShapeToSchema(shapeBooksSchema, returnShape)).toEqual(returnShape);
+    });
+    test('array schema ref', () => {
+        const returnShape = {
+            type: 'array',
+            items: { '@ref': 'local:Post' }
+        };
+        expect(returnShapeToSchema(shapeBooksSchema, returnShape)).toEqual(returnShape);
+    });
+});
+test('parseTemplateShape - PaginatedList<Post>', () => {
+    expect(parseTemplateShape('PaginatedList<Post>')).toEqual({
+        shapeName: 'Post',
+        template: 'PaginatedList'
+    });
+});
+test('createTemplateShapeName', () => {
+    expect(createTemplateShapeName('PaginatedList', 'Post')).toEqual('PaginatedList<Post>');
+});
+test('untemplate -- shape name', () => {
+    expect(untemplate('Post')).toEqual('Post');
+});
+test('untemplate -- template', () => {
+    expect(untemplate('PaginatedList<Post>')).toEqual('Post');
+});
+test('dereferenceSchema - extends', () => {
+    const shapes = {
+        A: createShape('A', {
+            extends: [
+                { '@ref': 'local:B' },
+                { '@ref': 'local:C' },
+                { '@ref': 'local:D' },
+                {
+                    type: 'object',
+                    properties: {
+                        a: { type: 'string' }
+                    },
+                    required: ['a']
+                }
+            ]
+        }),
+        B: createShape('B', {
+            type: 'object',
+            properties: {
+                b: { type: 'string' }
+            },
+            required: ['b']
+        }),
+        C: createShape('C', {
+            type: 'object',
+            properties: {
+                c: { type: 'string' },
+                b: { type: 'number' }
+            },
+            required: ['c']
+        }),
+        D: createShape('D', {
+            extends: [
+                { '@ref': 'local:D' },
+                {
+                    type: 'object',
+                    properties: {
+                        z: { type: 'string' }
+                    }
+                }
+            ]
+        })
+    };
+    expect(dereferenceSchema({ shapes, services: {} }, shapes.A.schema)).toEqual({
+        type: 'object',
+        properties: {
+            a: { type: 'string' },
+            b: { type: 'number' },
+            c: { type: 'string' },
+            z: { type: 'string' }
+        },
+        required: ['b', 'c', 'a']
+    });
+});
+test('dereferenceSchema - should ignore loops when path is specified', () => {
+    const objectSchema = {
+        properties: {
+            foo: {
+                type: 'string'
+            }
+        },
+        type: 'object'
+    };
+    const shapes = {
+        A: createShape('A', {
+            extends: [{ '@ref': 'local:A' }, objectSchema]
+        })
+    };
+    expect(dereferenceSchema({ shapes, services: {} }, shapes.A.schema, ['shapes', 'A'])).toEqual(objectSchema);
+});
+describe('createGetNamespace', () => {
+    const services = {
+        shopify: {
+            id: 'shopify',
+            title: 'Shopify',
+            namespace: 'Shopify',
+            provider: 'graphql',
+            serviceType: 'graphql',
+            authenticationType: 'none'
+        }
+    };
+    const getNamespace = createGetNamespace({ services });
+    test('service found', () => {
+        expect(getNamespace('shopify')).toEqual('Shopify');
+    });
+    test('service not found', () => {
+        expect(getNamespace('local')).toEqual(undefined);
+    });
+});
+describe('parsePropertyRef', () => {
+    test('explicit service id', () => {
+        expect(parsePropertyRef('local:Query.foo')).toEqual({
+            serviceId: 'local',
+            shapeName: 'Query',
+            propertyName: 'foo'
+        });
+    });
+    test('handles legacy service id', () => {
+        expect(parsePropertyRef('shopify:my-shop:Query.products')).toEqual({
+            serviceId: 'shopify:my-shop',
+            shapeName: 'Query',
+            propertyName: 'products'
+        });
+    });
+    test('assumes local', () => {
+        expect(parsePropertyRef('Query.foo')).toEqual({
+            serviceId: 'local',
+            shapeName: 'Query',
+            propertyName: 'foo'
+        });
+    });
+    test('assumes Query', () => {
+        expect(parsePropertyRef('foo')).toEqual({
+            serviceId: 'local',
+            shapeName: 'Query',
+            propertyName: 'foo'
+        });
+    });
+    test('assumes Query with service id', () => {
+        expect(parsePropertyRef('shopify:products')).toEqual({
+            serviceId: 'shopify',
+            shapeName: 'Query',
+            propertyName: 'products'
+        });
+    });
+    test('handles invalid', () => {
+        expect(parsePropertyRef('takeshape:Query.foo.bar')).toEqual(undefined);
+    });
+});
+describe('propertyRefItemToResolverPath', () => {
+    test('remote', () => {
+        expect(serializePropertyRef({
+            serviceId: 'shopify',
+            shapeName: 'Query',
+            propertyName: 'products'
+        })).toBe('shopify:Query.products');
+    });
+    test('local', () => {
+        expect(serializePropertyRef({
+            serviceId: 'local',
+            shapeName: 'Query',
+            propertyName: 'getProductList'
+        })).toBe('Query.getProductList');
+    });
+});
+describe('propertyRefItemToResolverPath', () => {
+    test('query', () => {
+        expect(propertyRefItemToResolverPath(() => 'Shopify', {
+            serviceId: 'shopify',
+            propertyName: 'products',
+            shapeName: 'Query'
+        })).toEqual(['queries', 'Shopify_products', 'resolver']);
+    });
+    test('local query', () => {
+        expect(propertyRefItemToResolverPath(() => undefined, {
+            serviceId: 'local',
+            propertyName: 'products',
+            shapeName: 'Query'
+        })).toEqual(['queries', 'products', 'resolver']);
+    });
+    test('mutation', () => {
+        expect(propertyRefItemToResolverPath(() => 'Shopify', {
+            serviceId: 'shopify',
+            propertyName: 'createProduct',
+            shapeName: 'Mutation'
+        })).toEqual(['mutations', 'Shopify_createProduct', 'resolver']);
+    });
+    test('local mutation', () => {
+        expect(propertyRefItemToResolverPath(() => undefined, {
+            serviceId: 'local',
+            propertyName: 'createProduct',
+            shapeName: 'Mutation'
+        })).toEqual(['mutations', 'createProduct', 'resolver']);
+    });
+    test('shape', () => {
+        expect(propertyRefItemToResolverPath(() => 'Shopify', {
+            serviceId: 'shopify',
+            propertyName: 'variants',
+            shapeName: 'Product'
+        })).toEqual(['shapes', 'Shopify_Product', 'schema', 'properties', 'variants', '@resolver']);
+    });
+    test('local shape', () => {
+        expect(propertyRefItemToResolverPath(() => undefined, {
+            serviceId: 'local',
+            propertyName: 'products',
+            shapeName: 'MyNamespace'
+        })).toEqual(['shapes', 'MyNamespace', 'schema', 'properties', 'products', '@resolver']);
+    });
+});
+describe('propertyRefItemToArgsPath', () => {
+    test('query', () => {
+        expect(propertyRefItemToArgsPath(() => 'Shopify', {
+            serviceId: 'shopify',
+            propertyName: 'products',
+            shapeName: 'Query'
+        })).toEqual(['queries', 'Shopify_products', 'args']);
+    });
+    test('shape', () => {
+        expect(propertyRefItemToArgsPath(() => 'Shopify', {
+            serviceId: 'shopify',
+            propertyName: 'variants',
+            shapeName: 'Product'
+        })).toEqual(['shapes', 'Shopify_Product', 'schema', 'properties', 'variants', '@args']);
+    });
+});
+describe('propertyRefToArgs', () => {
+    test('found', () => {
+        const args = propertyRefToArgs(shapeBooksSchema, 'Query.getBook');
+        expect(args).toBe('TSGetArgs<Book>');
+    });
+    test('not found', () => {
+        const args = propertyRefToArgs(shapeBooksSchema, 'Query.bogus');
+        expect(args).toBe(undefined);
+    });
+});
+describe('shapeNameToRef', () => {
+    test('service', () => {
+        expect(normalizeRefExpression(shopifyStoreJson, 'Shopify_Product')).toEqual('gregs-takeshape-store:Product');
+    });
+    test('local', () => {
+        expect(normalizeRefExpression(shapeBooksSchema, 'Book')).toEqual('local:Book');
+    });
+    test('missing namespace', () => {
+        expect(normalizeRefExpression(shapeBooksSchema, 'Shopify_Product')).toEqual('local:Shopify_Product');
+    });
+    test('multiple _', () => {
+        expect(normalizeRefExpression(shapeBooksSchema, 'Foo_Bar_Baz')).toEqual('local:Foo_Bar_Baz');
+    });
+});
+describe('normalizeLocalRefString', () => {
+    test('local', () => {
+        expect(normalizeLocalRefString('local:Foo')).toEqual('Foo');
+    });
+    test('non-local', () => {
+        expect(normalizeLocalRefString('shopify:Product')).toEqual('shopify:Product');
+    });
+});
+describe('getAllPropertyRefs', () => {
+    test('returns empty array when no refs found', () => {
+        expect(getAllPropertyRefs(shopifyStoreJson)).toEqual([]);
+    });
+    test('only looks at resolver.to', () => {
+        const projectSchema = createMockSchema('projectId', {
+            shapes: {
+                Foo: createShape('Foo', {
+                    type: 'object',
+                    properties: {
+                        character: {
+                            '@ref': 'rick:Character',
+                            '@resolver': {
+                                name: 'delegate',
+                                to: 'rick:Query.character'
+                            }
+                        }
+                    }
+                }),
+                Bar: createShape('Bar', {
+                    type: 'object',
+                    properties: {
+                        to: { type: 'string' }
+                    }
+                })
+            },
+            forms: {
+                Bar: {
+                    default: {
+                        to: 'oops'
+                    }
+                }
+            }
+        });
+        expect(getAllPropertyRefs(projectSchema)).toEqual([
+            {
+                propertyName: 'character',
+                serviceId: 'rick',
+                shapeName: 'Query'
+            }
+        ]);
+    });
+    test('tool query refs', () => {
+        expect(getAllPropertyRefs(valvolineSchema)).toEqual([
+            {
+                propertyName: 'getMakes',
+                serviceId: 'local',
+                shapeName: 'Query'
+            },
+            {
+                propertyName: 'getModels',
+                serviceId: 'local',
+                shapeName: 'Query'
+            },
+            {
+                propertyName: 'getEngines',
+                serviceId: 'local',
+                shapeName: 'Query'
+            },
+            {
+                propertyName: 'listProducts',
+                serviceId: 'local',
+                shapeName: 'Query'
+            },
+            {
+                propertyName: 'getPart',
+                serviceId: 'local',
+                shapeName: 'Query'
+            }
+        ]);
+    });
+});
+describe('propertyRefToShapeRef', () => {
+    it('works', () => {
+        expect(propertyRefToShapeRef('shopify:Product.id')).toBe('shopify:Product');
+        expect(propertyRefToShapeRef('getProductList')).toBe('local:Query');
+    });
+    it('throws for invalid property refs', () => {
+        expect(() => propertyRefToShapeRef('foo.bar.baz')).toThrowErrorMatchingInlineSnapshot(`[Error: Invalid property ref "foo.bar.baz]`);
+    });
+});
+describe('normalizeRefs', () => {
+    test('$ref to user defined shape', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            $ref: '#/definitions/Book'
+        })).toEqual({ '@ref': 'local:Book' });
+    });
+    test('$ref to built in color shape', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            $ref: '#/definitions/TSColor'
+        })).toEqual({ '@ref': 'local:TSColor' });
+    });
+    test('repeater', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            type: 'array',
+            items: {
+                '@ref': 'local:Book'
+            }
+        })).toEqual({
+            items: {
+                '@ref': 'local:Book'
+            },
+            type: 'array'
+        });
+    });
+    test('$ref in items', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            type: 'array',
+            items: {
+                $ref: '#/shapes/Book/schema'
+            }
+        })).toEqual({
+            type: 'array',
+            items: {
+                '@ref': 'local:Book'
+            }
+        });
+    });
+    test('$ref in oneOf', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            oneOf: [{ $ref: '#/shapes/Book/schema' }, { $ref: '#/shapes/Post/schema' }]
+        })).toEqual({
+            oneOf: [{ '@ref': 'local:Book' }, { '@ref': 'local:Post' }]
+        });
+    });
+    test('$ref in oneOf array', () => {
+        expect(normalizeRefs(shapeBooksSchema, {
+            type: 'array',
+            items: {
+                oneOf: [{ $ref: '#/shapes/Book/schema' }, { $ref: '#/shapes/Post/schema' }]
+            }
+        })).toEqual({
+            type: 'array',
+            items: {
+                oneOf: [{ '@ref': 'local:Book' }, { '@ref': 'local:Post' }]
+            }
+        });
+    });
+});
+describe('getOneOfRefs', () => {
+    test('oneOf', () => {
+        expect(getOneOfRefs({}, {
+            oneOf: [
+                {
+                    '@ref': 'local:Dog'
+                },
+                {
+                    '@ref': 'local:Cat'
+                }
+            ]
+        })).toEqual([
+            {
+                isForeign: false,
+                isInterfaceRef: false,
+                isValidService: true,
+                path: ['@ref'],
+                serviceKey: 'local',
+                typeName: 'Dog'
+            },
+            {
+                isForeign: false,
+                isInterfaceRef: false,
+                isValidService: true,
+                path: ['@ref'],
+                serviceKey: 'local',
+                typeName: 'Cat'
+            }
+        ]);
+    });
+    test('items with oneOf', () => {
+        expect(getOneOfRefs({}, {
+            items: {
+                oneOf: [
+                    {
+                        '@ref': 'local:Dog'
+                    },
+                    {
+                        '@ref': 'local:Cat'
+                    }
+                ]
+            }
+        })).toEqual([
+            {
+                isForeign: false,
+                isInterfaceRef: false,
+                isValidService: true,
+                path: ['items', '@ref'],
+                serviceKey: 'local',
+                typeName: 'Dog'
+            },
+            {
+                isForeign: false,
+                isInterfaceRef: false,
+                isValidService: true,
+                path: ['items', '@ref'],
+                serviceKey: 'local',
+                typeName: 'Cat'
+            }
+        ]);
+    });
+});