@nestjs/apollo 13.3.0 → 13.4.1

package/dist/tests/tests/e2e/generated-definitions.spec.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const graphql_1 = require("@nestjs/graphql");
+const testing_1 = require("@nestjs/testing");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const util = tslib_1.__importStar(require("util"));
+const app_module_1 = require("../code-first/app.module");
+const readFile = util.promisify(fs.readFile);
+const generatedDefinitions = (fileName) => path.join(__dirname, '..', 'generated-definitions', fileName);
+describe('Generated Definitions', () => {
+    let app;
+    let graphqlFactory;
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            imports: [app_module_1.ApplicationModule],
+        }).compile();
+        app = module.createNestApplication();
+        await app.init();
+        graphqlFactory = app.get(graphql_1.GraphQLFactory);
+    });
+    it('should generate interface definitions for types', async () => {
+        const typeDefs = await readFile(generatedDefinitions('simple-type.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('simple-type.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('simple-type.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate properties referencing other interfaces', async () => {
+        const typeDefs = await readFile(generatedDefinitions('interface-property.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('interface-property.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('interface-property.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate array properties with correct optionality', async () => {
+        const typeDefs = await readFile(generatedDefinitions('array-property.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('array-property.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('array-property.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate queries', async () => {
+        const typeDefs = await readFile(generatedDefinitions('query.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('query.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('query.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate queries with methods as fields (skipResolverArgs: true)', async () => {
+        const typeDefs = await readFile(generatedDefinitions('query.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('query-skip-args.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                skipResolverArgs: true,
+            },
+        });
+        expect(await readFile(generatedDefinitions('query-skip-args.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate mutations', async () => {
+        const typeDefs = await readFile(generatedDefinitions('mutation.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('mutation.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('mutation.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate enums', async () => {
+        const typeDefs = await readFile(generatedDefinitions('enum.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('enum.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('enum.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate enums as types', async () => {
+        const typeDefs = await readFile(generatedDefinitions('enum-as-type.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('enum-as-type.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                enumsAsTypes: true,
+            },
+        });
+        expect(await readFile(generatedDefinitions('enum-as-type.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate custom scalars', async () => {
+        const typeDefs = await readFile(generatedDefinitions('custom-scalar.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('custom-scalar.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+            },
+        });
+        expect(await readFile(generatedDefinitions('custom-scalar.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate custom scalars with a default type', async () => {
+        const typeDefs = await readFile(generatedDefinitions('custom-scalar.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('custom-scalar-default-type.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                defaultScalarType: 'unknown',
+            },
+        });
+        expect(await readFile(generatedDefinitions('custom-scalar-default-type.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate custom scalars with a type mapping', async () => {
+        const typeDefs = await readFile(generatedDefinitions('custom-scalar-type-mapping.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('custom-scalar-type-mapping.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                customScalarTypeMapping: {
+                    List: 'string[]',
+                    Point: '[number, number]',
+                    DateTime: Date,
+                },
+            },
+        });
+        expect(await readFile(generatedDefinitions('custom-scalar-type-mapping.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should prepend a custom header', async () => {
+        const typeDefs = await readFile(generatedDefinitions('custom-header.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('custom-header.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                additionalHeader: '/* Put anything here you like */',
+            },
+        });
+        expect(await readFile(generatedDefinitions('custom-header.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate for a federated graph', async () => {
+        const outputFile = generatedDefinitions('federation.test-definitions.ts');
+        const factory = new graphql_1.GraphQLFederationDefinitionsFactory();
+        await factory.generate({
+            typePaths: [generatedDefinitions('federation.graphql')],
+            path: outputFile,
+            outputAs: 'class',
+        });
+        expect(await readFile(generatedDefinitions('federation.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate for a federated graph with typeDef', async () => {
+        const outputFile = generatedDefinitions('federation-typedef.test-definitions.ts');
+        const factory = new graphql_1.GraphQLFederationDefinitionsFactory();
+        await factory.generate({
+            typePaths: [generatedDefinitions('federation-typedef.graphql')],
+            typeDefs: `enum Animal {
+        DOG
+        CAT
+      }`,
+            path: outputFile,
+            outputAs: 'class',
+        });
+        expect(await readFile(generatedDefinitions('federation-typedef.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should generate with __typename field for each object type', async () => {
+        const typeDefs = await readFile(generatedDefinitions('typename.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('typename.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                emitTypenameField: true,
+            },
+        });
+        expect(await readFile(generatedDefinitions('typename.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it('should generate for a federated graph with partial query definition', async () => {
+        const outputFile = generatedDefinitions('federation-partial-query.test-definitions.ts');
+        const factory = new graphql_1.GraphQLFederationDefinitionsFactory();
+        await factory.generate({
+            typePaths: [generatedDefinitions('federation-partial-query.graphql')],
+            path: outputFile,
+            outputAs: 'interface',
+        });
+        expect(await readFile(generatedDefinitions('federation-partial-query.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+    it('should apply typeName function to transform type names', async () => {
+        const typeDefs = await readFile(generatedDefinitions('type-name.graphql'), 'utf8');
+        const outputFile = generatedDefinitions('type-name.test-definitions.ts');
+        await graphqlFactory.generateDefinitions(typeDefs, {
+            definitions: {
+                path: outputFile,
+                typeName: (name) => `${name}Schema`,
+            },
+        });
+        expect(await readFile(generatedDefinitions('type-name.fixture.ts'), 'utf8')).toBe(await readFile(outputFile, 'utf8'));
+    });
+});

package/dist/tests/tests/e2e/global-prefix-fastify.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=global-prefix-fastify.spec.d.ts.map

package/dist/tests/tests/e2e/global-prefix-fastify.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-prefix-fastify.spec.d.ts","sourceRoot":"","sources":["../../../../tests/e2e/global-prefix-fastify.spec.ts"],"names":[],"mappings":""}

package/dist/tests/tests/e2e/global-prefix-fastify.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const platform_fastify_1 = require("@nestjs/platform-fastify");
+const testing_1 = require("@nestjs/testing");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const global_prefix_module_1 = require("../graphql/global-prefix.module");
+describe('GraphQL Fastify (global prefix)', () => {
+    let app;
+    describe('Global prefix with starting slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication(new platform_fastify_1.FastifyAdapter());
+            app.setGlobalPrefix('/api/v1');
+            await app.init();
+            await app.getHttpAdapter().getInstance().ready();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix without starting slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication();
+            app.setGlobalPrefix('api/v1');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix with ending slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication();
+            app.setGlobalPrefix('/api/v1/');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+});

package/dist/tests/tests/e2e/global-prefix.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=global-prefix.spec.d.ts.map

package/dist/tests/tests/e2e/global-prefix.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-prefix.spec.d.ts","sourceRoot":"","sources":["../../../../tests/e2e/global-prefix.spec.ts"],"names":[],"mappings":""}

package/dist/tests/tests/e2e/global-prefix.spec.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@nestjs/core");
+const platform_express_1 = require("@nestjs/platform-express");
+const testing_1 = require("@nestjs/testing");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const global_prefix_async_options_class_module_1 = require("../graphql/global-prefix-async-options-class.module");
+const global_prefix_async_options_module_1 = require("../graphql/global-prefix-async-options.module");
+const global_prefix_module_1 = require("../graphql/global-prefix.module");
+describe('GraphQL (global prefix)', () => {
+    let app;
+    describe('Global prefix with starting slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication(new platform_express_1.ExpressAdapter(), {
+                abortOnError: false,
+            });
+            app.setGlobalPrefix('/api/v1');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix without starting slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication(new platform_express_1.ExpressAdapter(), {
+                abortOnError: false,
+            });
+            app.setGlobalPrefix('api/v1');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix with ending slash', () => {
+        beforeEach(async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [global_prefix_module_1.GlobalPrefixModule],
+            }).compile();
+            app = module.createNestApplication(new platform_express_1.ExpressAdapter(), {
+                abortOnError: false,
+            });
+            app.setGlobalPrefix('/api/v1/');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix (async configuration)', () => {
+        beforeEach(async () => {
+            app = await core_1.NestFactory.create(global_prefix_async_options_module_1.GlobalPrefixAsyncOptionsModule, {
+                logger: false,
+                abortOnError: false,
+            });
+            app.setGlobalPrefix('/api/v1/');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+    describe('Global prefix (async class)', () => {
+        beforeEach(async () => {
+            app = await core_1.NestFactory.create(global_prefix_async_options_class_module_1.GlobalPrefixAsyncOptionsClassModule, {
+                logger: false,
+                abortOnError: false,
+            });
+            app.setGlobalPrefix('/api/v1/');
+            await app.init();
+        });
+        it('should return query result', () => {
+            return (0, supertest_1.default)(app.getHttpServer())
+                .post('/api/v1/graphql')
+                .send({
+                operationName: null,
+                variables: {},
+                query: `
+          {
+            getCats {
+              id,
+              color,
+              weight
+            }
+          }`,
+            })
+                .expect(200, {
+                data: {
+                    getCats: [
+                        {
+                            id: 1,
+                            color: 'black',
+                            weight: 5,
+                        },
+                    ],
+                },
+            });
+        });
+        afterEach(async () => {
+            await app.close();
+        });
+    });
+});

package/dist/tests/tests/e2e/graphiql-playground.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graphiql-playground.spec.d.ts.map

package/dist/tests/tests/e2e/graphiql-playground.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphiql-playground.spec.d.ts","sourceRoot":"","sources":["../../../../tests/e2e/graphiql-playground.spec.ts"],"names":[],"mappings":""}