@takeshape/schema 11.72.0 → 11.74.1

package/dist/services/__tests__/services.test.js

@@ -1,113 +0,0 @@
-import { beforeEach, describe, expect, it, test, vi } from 'vitest';
-import { createMockSchema, createMockServiceConfig } from "../../mocks.js";
-import { prepareServiceUpdate } from "../services.js";
-import { getResolverServices, isMissingAuth } from "../util.js";
-beforeEach(vi.clearAllMocks);
-describe('prepareServiceUpdate', () => {
-    const serviceKey = 'mock-service';
-    const encryptedAuthentication = 'encrypted-token';
-    const serviceConfig = createMockServiceConfig(serviceKey);
-    const storedServiceConfig = {
-        ...serviceConfig,
-        authentication: encryptedAuthentication
-    };
-    const { authentication } = serviceConfig;
-    const projectSchema = createMockSchema('mock-schema', {
-        services: {
-            [serviceKey]: storedServiceConfig
-        }
-    });
-    const encryptFn = vi.fn(() => encryptedAuthentication);
-    const decryptFn = vi.fn(() => authentication);
-    it('prepares an update', async () => {
-        const serviceUpdate = {
-            title: 'foo',
-            authenticationType: 'bearer',
-            authentication: {
-                token: 'updated'
-            }
-        };
-        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey);
-        expect(encryptFn).toHaveBeenCalledWith({
-            ...authentication,
-            token: 'updated'
-        });
-        expect(result).toEqual({ ...storedServiceConfig, title: 'foo' });
-    });
-    it('can proceed with a full object, and nothing stored', async () => {
-        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceConfig, 'random');
-        expect(encryptFn).toHaveBeenCalledWith(authentication);
-        expect(result).toEqual(storedServiceConfig);
-    });
-    it('clears the authentication property when a null sentinel is sent', async () => {
-        const serviceUpdate = {
-            authenticationType: 'bearer',
-            authentication: null
-        };
-        const result = prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey);
-        expect(encryptFn).toHaveBeenCalledTimes(0);
-        expect(result).toEqual({
-            ...storedServiceConfig,
-            authentication: undefined
-        });
-    });
-    it('throws a validation error on invalid authentication properties', async () => {
-        const serviceUpdate = {
-            title: 'foo',
-            authenticationType: 'bearer',
-            authentication: {
-                bogus: 'bogus-property'
-            }
-        };
-        expect(() => prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: ServiceConfig was invalid]');
-    });
-    it('throws a validation error when the envelopes authenticationType changes', async () => {
-        const serviceUpdate = {
-            title: 'foo',
-            authenticationType: 'basic'
-        };
-        expect(() => prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceUpdate, serviceKey)).toThrowErrorMatchingInlineSnapshot('[SchemaValidationError: ServiceConfig was invalid]');
-    });
-});
-describe('getResolverServices', () => {
-    test('works for basic resolvers', () => {
-        expect(getResolverServices({
-            name: 'graphql:query',
-            service: 'foo',
-            fieldName: 'foo'
-        })).toEqual(['foo']);
-    });
-    test('works for compose resolvers', () => {
-        expect(getResolverServices({
-            compose: [
-                {
-                    name: 'graphql:query',
-                    service: 'a',
-                    fieldName: 'a'
-                },
-                {
-                    name: 'graphql:query',
-                    service: 'b',
-                    fieldName: 'b'
-                },
-                {
-                    name: 'graphql:query',
-                    service: 'c',
-                    fieldName: 'c'
-                },
-                {
-                    name: 'graphql:query',
-                    service: 'a',
-                    fieldName: 'a'
-                }
-            ]
-        })).toEqual(['a', 'b', 'c']);
-    });
-});
-test('isMissingAuth', () => {
-    expect(isMissingAuth({ authenticationType: 'none' })).toBe(false);
-    expect(isMissingAuth({ authenticationType: 'basic' })).toBe(true);
-    expect(
-    // @ts-expect-error for the sake of testing js runtime usage
-    isMissingAuth({ authenticationType: 'oauth2Bearer', authentication: {} })).toBe(true);
-});

package/dist/template-shapes/__tests__/index.test.d.ts

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

package/dist/template-shapes/__tests__/index.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import blogSchema from '@/examples/latest/blog-schema.json';
-import { isValidTemplate, resolveTemplate } from "../index.js";
-describe('resolveTemplate', () => {
-    test('success', () => {
-        expect(resolveTemplate(blogSchema, 'TSGetArgs', 'Post')).toEqual({
-            dependencies: {
-                PostTSGetArgs: {
-                    id: 'PostTSGetArgs',
-                    name: 'PostTSGetArgs',
-                    schema: {
-                        properties: {
-                            _id: { type: 'string' },
-                            enableLocaleFallback: { default: true, type: 'boolean' },
-                            locale: { type: 'string' }
-                        },
-                        required: ['_id'],
-                        type: 'object'
-                    },
-                    title: 'PostTSGetArgs'
-                }
-            },
-            shapeName: 'PostTSGetArgs'
-        });
-    });
-    test('invalid template', () => {
-        expect(() => resolveTemplate(blogSchema, 'TSGetRekt', 'Post')).toThrowError('Invalid shape template TSGetRekt');
-    });
-    test('invalid shape', () => {
-        expect(() => resolveTemplate(blogSchema, 'TSGetArgs', 'Nerd')).toThrowError('Unknown shape "Nerd" in template "TSGetArgs"');
-    });
-});
-describe('isValidTemplate', () => {
-    test('yes', () => {
-        expect(isValidTemplate('TSGetArgs')).toEqual(true);
-    });
-    test('no', () => {
-        expect(isValidTemplate('TSGetBreakfast')).toEqual(false);
-    });
-});

package/dist/template-shapes/__tests__/names.test.d.ts

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

package/dist/template-shapes/__tests__/names.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getOutputShapeName } from "../names.js";
-describe('getOutputShapeName', () => {
-    it('should remove "Input" suffix from the name', () => {
-        expect(getOutputShapeName('UserInput')).toBe('User');
-    });
-    it('should remove "PartialInput" suffix from the name', () => {
-        expect(getOutputShapeName('UserPartialInput')).toBe('User');
-    });
-    it('should not change the name if it does not have "Input" or "PartialInput" suffix', () => {
-        expect(getOutputShapeName('User')).toBe('User');
-    });
-    it('should not change the name if it has "Input" or "PartialInput" in the middle', () => {
-        expect(getOutputShapeName('InputUserPartial')).toBe('InputUserPartial');
-    });
-    it('should handle empty string', () => {
-        expect(getOutputShapeName('')).toBe('');
-    });
-});

package/dist/template-shapes/__tests__/templates.test.d.ts

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

package/dist/template-shapes/__tests__/templates.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createMockSchema } from "../../mocks.js";
-import { CreateArgs, DeleteArgs, DuplicateArgs, UpdateArgs } from "../templates.js";
-describe('getMutationArgs', () => {
-    const Mock = {
-        title: 'Mock',
-        name: 'Mock',
-        id: 'Mock',
-        schema: {
-            type: 'object',
-            properties: {
-                title: {
-                    type: 'string',
-                    '@input': {
-                        type: 'number'
-                    }
-                }
-            }
-        }
-    };
-    const projectSchema = createMockSchema('<project-id>', {
-        shapes: { Mock }
-    });
-    it('should substitute @input for the original field schema', () => {
-        const createResult = CreateArgs({ projectSchema }, Mock);
-        expect(createResult.dependencies.CreateMockInput.schema).toEqual({
-            type: 'object',
-            properties: {
-                title: {
-                    '@output': {
-                        type: 'string'
-                    },
-                    type: 'number'
-                }
-            }
-        });
-        const updateResult = UpdateArgs({ projectSchema }, Mock);
-        expect(updateResult.dependencies.UpdateMockInput.schema).toEqual({
-            type: 'object',
-            properties: {
-                _id: {
-                    type: 'string'
-                },
-                title: {
-                    '@output': {
-                        type: 'string'
-                    },
-                    type: 'number'
-                }
-            },
-            required: ['_id']
-        });
-        const duplicateResult = DuplicateArgs({ projectSchema }, Mock);
-        expect(duplicateResult.dependencies.DuplicateMockInput.schema).toEqual({
-            type: 'object',
-            properties: {
-                _id: {
-                    type: 'string'
-                },
-                title: {
-                    '@output': {
-                        type: 'string'
-                    },
-                    type: 'number'
-                }
-            },
-            required: ['_id']
-        });
-        const deleteResult = DeleteArgs({ projectSchema }, Mock);
-        expect(deleteResult.dependencies.DeleteMockInput.schema).toEqual({
-            type: 'object',
-            properties: {
-                _id: {
-                    type: 'string'
-                }
-            },
-            required: ['_id']
-        });
-    });
-});

package/dist/template-shapes/__tests__/where.test.d.ts

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

package/dist/template-shapes/__tests__/where.test.js

@@ -1,218 +0,0 @@
-import { DEFAULT_ENTITLEMENTS } from '@takeshape/util';
-import { expect, test } from 'vitest';
-import massiveSchemaJson from '@/examples/latest/massive-schema.json';
-import millSchemaJson from '@/examples/latest/mill-components-schema.json';
-import { createMockSchema } from "../../mocks.js";
-import { isEqualRelationship } from "../../relationships.js";
-import { applyDefaultsToSchema } from "../../schema-util.js";
-import { isModelShape } from "../../types/index.js";
-import { validateSchema } from "../../validate/validate.js";
-import { getWhereShape } from "../where.js";
-const massiveSchema = applyDefaultsToSchema(massiveSchemaJson);
-const millSchema = applyDefaultsToSchema(millSchemaJson);
-async function validateShapes(shapes) {
-    return (await validateSchema({
-        entitlements: DEFAULT_ENTITLEMENTS
-    }, createMockSchema('project-id', { shapes }))).errors;
-}
-test('getWhereShape - massive', async () => {
-    const { shapeName, dependencies } = getWhereShape(massiveSchema, Object.values(massiveSchema.shapes).filter(isModelShape));
-    expect(await validateShapes(dependencies)).toEqual(undefined);
-    expect(shapeName).toBe('TSWhereInput');
-    expect(dependencies).toMatchSnapshot();
-});
-test('getWhereShape - mill', async () => {
-    const { shapeName, dependencies } = getWhereShape(millSchema, Object.values(millSchema.shapes).filter(isModelShape));
-    expect(await validateShapes(dependencies)).toEqual(undefined);
-    expect(shapeName).toBe('TSWhereInput');
-    expect(dependencies).toMatchSnapshot();
-});
-test('getWhereShape - recursive', async () => {
-    const schema = createMockSchema('project-id', {
-        shapes: {
-            Node: {
-                name: 'Node',
-                title: 'Node',
-                id: 'node-id',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        foreign: { '@ref': 'stripe:Customer' },
-                        left: { '@ref': 'local:Node' },
-                        right: { '@ref': 'local:Node' },
-                        value: { type: 'number' }
-                    }
-                }
-            },
-            Stripe_Customer: {
-                name: 'Stripe_Customer',
-                title: 'Stripe_Customer',
-                id: 'Stripe_Customer',
-                schema: {
-                    type: 'object',
-                    properties: {}
-                }
-            }
-        },
-        services: {
-            stripe: {
-                id: 'stripe',
-                title: 'Stripe',
-                namespace: 'Stripe',
-                provider: 'openapi',
-                serviceType: 'openapi',
-                authenticationType: 'none'
-            }
-        }
-    });
-    const { shapeName, dependencies } = getWhereShape(schema, [schema.shapes.Node]);
-    expect(await validateShapes(dependencies)).toEqual(undefined);
-    expect(shapeName).toBe('TSWhereNodeInput');
-    expect(dependencies).toMatchInlineSnapshot(`
-    {
-      "TSWhereNode": {
-        "id": "TSWhereNode",
-        "name": "TSWhereNode",
-        "schema": {
-          "properties": {
-            "left": {
-              "@ref": "local:TSWhereNode",
-            },
-            "right": {
-              "@ref": "local:TSWhereNode",
-            },
-            "value": {
-              "@ref": "local:TSWhereNumber",
-            },
-          },
-          "type": "object",
-        },
-        "title": "TSWhereNode",
-      },
-      "TSWhereNodeInput": {
-        "id": "TSWhereNodeInput",
-        "name": "TSWhereNodeInput",
-        "schema": {
-          "properties": {
-            "AND": {
-              "items": {
-                "@ref": "local:TSWhereNodeInput",
-              },
-              "type": "array",
-            },
-            "NOT": {
-              "@ref": "local:TSWhereNodeInput",
-            },
-            "OR": {
-              "items": {
-                "@ref": "local:TSWhereNodeInput",
-              },
-              "type": "array",
-            },
-            "left": {
-              "@ref": "local:TSWhereNode",
-            },
-            "right": {
-              "@ref": "local:TSWhereNode",
-            },
-            "value": {
-              "@ref": "local:TSWhereNumber",
-            },
-          },
-          "type": "object",
-        },
-        "title": "TSWhereNodeInput",
-      },
-      "TSWhereNumber": {
-        "id": "TSWhereNumber",
-        "name": "TSWhereNumber",
-        "schema": {
-          "properties": {
-            "eq": {
-              "description": "Exact match",
-              "type": "number",
-            },
-            "gt": {
-              "description": "Greater than",
-              "type": "number",
-            },
-            "gte": {
-              "description": "Greater than or equal",
-              "type": "number",
-            },
-            "in": {
-              "description": "Array of possible exact match values.",
-              "items": {
-                "type": "number",
-              },
-              "type": "array",
-            },
-            "lt": {
-              "description": "Less than",
-              "type": "number",
-            },
-            "lte": {
-              "description": "Less than or equal",
-              "type": "number",
-            },
-          },
-          "type": "object",
-        },
-        "title": "TSWhereNumber",
-      },
-    }
-  `);
-});
-test('isEqualRelationship - non-relationship', () => {
-    expect(isEqualRelationship({ type: 'string' }, { type: 'number' })).toBe(true);
-});
-test('isEqualRelationship - relationship to non-relationship', () => {
-    const a = {
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb'
-        },
-        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
-    };
-    const b = {
-        type: 'string'
-    };
-    expect(isEqualRelationship(a, b)).toBe(false);
-    expect(isEqualRelationship(b, a)).toBe(false);
-});
-test('isEqualRelationship - relationships', () => {
-    const a = {
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb'
-        },
-        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
-    };
-    const b = {
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb'
-        },
-        oneOf: [{ '@ref': 'local:C' }, { '@ref': 'local:A' }, { '@ref': 'local:B' }]
-    };
-    expect(isEqualRelationship(a, b)).toBe(true);
-    expect(isEqualRelationship(b, a)).toBe(true);
-});
-test('isEqualRelationship - relationships', () => {
-    const a = {
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb'
-        },
-        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
-    };
-    const b = {
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb'
-        },
-        oneOf: [{ '@ref': 'local:C' }]
-    };
-    expect(isEqualRelationship(a, b)).toBe(false);
-    expect(isEqualRelationship(b, a)).toBe(false);
-});

package/dist/types/__tests__/utils.test.d.ts

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

package/dist/types/__tests__/utils.test.js

@@ -1,159 +0,0 @@
-import { describe, expect, it, test } from 'vitest';
-import { isAwsLambdaResolver, isBasicResolver, isComposeResolver, isGraphQLServiceConfig, isGraphqlResolver, isParameterOp, isParameterOpMapping, isParameterOpNested, isParameterOpOp, isParameterOpValue, isRestResolver, isReturnShapeArraySchema, isShapedbResolver, isTakeshapeResolver, isUtilResolver } from "../utils.js";
-test('isGenericGraphQLServiceConfig', () => {
-    expect(isGraphQLServiceConfig({})).toBe(false);
-    const restServiceConfig = {
-        provider: 'rest',
-        id: 'service-id',
-        title: 'REST Service',
-        serviceType: 'rest',
-        authenticationType: 'none',
-        options: {
-            endpoint: 'https://api.example.com/graphql'
-        }
-    };
-    expect(isGraphQLServiceConfig(restServiceConfig)).toBe(false);
-    const genericServiceConfig = {
-        provider: 'rest',
-        id: 'service-id',
-        title: 'REST Service',
-        serviceType: 'rest',
-        authenticationType: 'none'
-    };
-    expect(isGraphQLServiceConfig(genericServiceConfig)).toBe(false);
-    const graphqlServiceConfig = {
-        provider: 'graphql',
-        id: 'service-id',
-        title: 'GraphQL Service',
-        serviceType: 'graphql',
-        authenticationType: 'none',
-        options: {
-            endpoint: 'https://api.example.com/graphql'
-        }
-    };
-    expect(isGraphQLServiceConfig(graphqlServiceConfig)).toBe(true);
-});
-test('isParameterOp type guards', () => {
-    expect(isParameterOp({ path: 'foo', op: 'set' })).toBe(true);
-    expect(isParameterOp({ path: 'foo', mapping: 'foo' })).toBe(true);
-    expect(isParameterOpNested({ path: 'foo', ops: [] })).toBe(true);
-    expect(isParameterOpMapping({ path: 'foo', mapping: 'foo' })).toBe(true);
-    expect(isParameterOpValue({ path: 'foo', value: 'foo' })).toBe(true);
-    expect(isParameterOpOp({ path: 'foo', op: 'set' })).toBe(true);
-    expect(isParameterOpOp({ path: 'foo', op: 'set', value: 'foo' })).toBe(false);
-});
-describe('resolver type utils', () => {
-    it('should validate a valid basic resolver', () => {
-        const resolverConfig = {
-            name: 'shapedb:create',
-            service: 'foo'
-        };
-        expect(isBasicResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an incomplete basic resolver', () => {
-        expect(isBasicResolver({
-            service: 'foo'
-        })).toBe(false);
-    });
-    it('should validate a valid compose resolver', () => {
-        const resolverConfig = {
-            compose: [
-                {
-                    name: 'shapedb:create',
-                    service: 'foo'
-                }
-            ]
-        };
-        expect(isComposeResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an incomplete compose resolver', () => {
-        expect(isComposeResolver({
-            compose: [
-                {
-                    name: 'shapedb:create'
-                },
-                {}
-            ]
-        })).toBe(false);
-        expect(isComposeResolver({
-            compose: []
-        })).toBe(false);
-    });
-    it('should validate a valid takeshape resolver name', () => {
-        const resolverConfig = {
-            name: 'takeshape:getUser'
-        };
-        expect(isTakeshapeResolver(resolverConfig)).toBe(true);
-    });
-    it('should validate a valid shapedb resolver name', () => {
-        const resolverConfig = {
-            name: 'shapedb:create'
-        };
-        expect(isShapedbResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an invalid takeshape resolver name', () => {
-        const resolverConfig = {
-            name: 'shapedb:wrong'
-        };
-        expect(isTakeshapeResolver(resolverConfig)).toBe(false);
-    });
-    it('should validate a valid rest resolver name', () => {
-        const resolverConfig = {
-            name: 'rest:post'
-        };
-        expect(isRestResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an invalid rest resolver name', () => {
-        const resolverConfig = {
-            name: 'rest:wrong'
-        };
-        expect(isRestResolver(resolverConfig)).toBe(false);
-    });
-    it('should validate a valid graphql resolver name', () => {
-        const resolverConfig = {
-            name: 'graphql:query'
-        };
-        expect(isGraphqlResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an invalid graphql resolver name', () => {
-        const resolverConfig = {
-            name: 'graphql:wrong'
-        };
-        expect(isGraphqlResolver(resolverConfig)).toBe(false);
-    });
-    it('should validate a valid aws lambda resolver name', () => {
-        const resolverConfig = {
-            name: 'awsLambda:invoke'
-        };
-        expect(isAwsLambdaResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an invalid aws lambda resolver name', () => {
-        const resolverConfig = {
-            name: 'awsLambda:wrong'
-        };
-        expect(isAwsLambdaResolver(resolverConfig)).toBe(false);
-    });
-    it('should validate a valid util resolver name', () => {
-        const resolverConfig = {
-            name: 'util:wrap'
-        };
-        expect(isUtilResolver(resolverConfig)).toBe(true);
-    });
-    it('should reject an invalid util resolver name', () => {
-        const resolverConfig = {
-            name: 'util:wrong'
-        };
-        expect(isUtilResolver(resolverConfig)).toBe(false);
-    });
-});
-describe('isReturnShapeArraySchema', () => {
-    test('no', () => {
-        expect(isReturnShapeArraySchema('Product')).toEqual(false);
-    });
-    test('yes', () => {
-        expect(isReturnShapeArraySchema({
-            type: 'array',
-            items: { '@ref': 'shopify:Product' }
-        })).toEqual(true);
-    });
-});

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

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