@hazeljs/graphql 0.2.0-beta.54 → 0.2.0-beta.56

package/dist/client/decorators.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=decorators.test.d.ts.map

package/dist/client/decorators.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.test.d.ts","sourceRoot":"","sources":["../../src/client/decorators.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/client/decorators.test.js

@@ -0,0 +1,102 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const decorators_1 = require("./decorators");
+describe('GraphQL client decorators', () => {
+    describe('GraphQLQuery', () => {
+        it('should apply without error', () => {
+            class TestClient {
+                getUsers() {
+                    return 'query { users { id } }';
+                }
+            }
+            __decorate([
+                (0, decorators_1.GraphQLQuery)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClient.prototype, "getUsers", null);
+            expect(new TestClient().getUsers()).toBe('query { users { id } }');
+        });
+        it('should support multiple methods', () => {
+            class TestClient {
+                one() {
+                    return 'query { one }';
+                }
+                two() {
+                    return 'query { two }';
+                }
+            }
+            __decorate([
+                (0, decorators_1.GraphQLQuery)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClient.prototype, "one", null);
+            __decorate([
+                (0, decorators_1.GraphQLQuery)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClient.prototype, "two", null);
+            const client = new TestClient();
+            expect(client.one()).toBe('query { one }');
+            expect(client.two()).toBe('query { two }');
+        });
+    });
+    describe('GraphQLMutation', () => {
+        it('should apply without error', () => {
+            class TestClient {
+                createUser() {
+                    return 'mutation { createUser { id } }';
+                }
+            }
+            __decorate([
+                (0, decorators_1.GraphQLMutation)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClient.prototype, "createUser", null);
+            expect(new TestClient().createUser()).toBe('mutation { createUser { id } }');
+        });
+    });
+    describe('GraphQLClientClass', () => {
+        it('should store url in metadata', () => {
+            let TestClient = class TestClient {
+            };
+            TestClient = __decorate([
+                (0, decorators_1.GraphQLClientClass)('http://localhost:3000/graphql')
+            ], TestClient);
+            const config = (0, decorators_1.getGraphQLClientConfig)(TestClient);
+            expect(config.url).toBe('http://localhost:3000/graphql');
+            expect(config.headers).toEqual({});
+        });
+        it('should store url and headers in metadata', () => {
+            let TestClient = class TestClient {
+            };
+            TestClient = __decorate([
+                (0, decorators_1.GraphQLClientClass)('http://api.example.com/gql', { Authorization: 'Bearer x' })
+            ], TestClient);
+            const config = (0, decorators_1.getGraphQLClientConfig)(TestClient);
+            expect(config.url).toBe('http://api.example.com/gql');
+            expect(config.headers).toEqual({ Authorization: 'Bearer x' });
+        });
+    });
+    describe('getGraphQLClientConfig', () => {
+        it('should return defaults for class without decorator', () => {
+            class Plain {
+            }
+            const config = (0, decorators_1.getGraphQLClientConfig)(Plain);
+            expect(config).toEqual({ url: '', headers: {} });
+        });
+    });
+});

package/dist/client/graphql.client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graphql.client.test.d.ts.map

package/dist/client/graphql.client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.client.test.d.ts","sourceRoot":"","sources":["../../src/client/graphql.client.test.ts"],"names":[],"mappings":""}

package/dist/client/graphql.client.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_client_1 = require("./graphql.client");
+describe('GraphQLClient', () => {
+    const mockFetch = jest.fn();
+    beforeEach(() => {
+        global.fetch = mockFetch;
+        mockFetch.mockReset();
+    });
+    it('should execute query', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: { hello: 'world' } }),
+        });
+        const client = new graphql_client_1.GraphQLClient({ url: 'http://localhost/graphql' });
+        const result = await client.query('{ hello }');
+        expect(result).toEqual({ hello: 'world' });
+        expect(mockFetch).toHaveBeenCalledWith('http://localhost/graphql', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({ query: '{ hello }', variables: undefined }),
+        }));
+    });
+    it('should execute query with variables', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: { user: { id: '1' } } }),
+        });
+        const client = new graphql_client_1.GraphQLClient({ url: 'http://localhost/graphql' });
+        await client.query('query($id: ID!) { user(id: $id) { id } }', { id: '1' });
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            body: JSON.stringify({
+                query: 'query($id: ID!) { user(id: $id) { id } }',
+                variables: { id: '1' },
+            }),
+        }));
+    });
+    it('should execute mutation', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: { createUser: { id: '1' } } }),
+        });
+        const client = new graphql_client_1.GraphQLClient({ url: 'http://localhost/graphql' });
+        const result = await client.mutate('mutation { createUser(name: "x") { id } }');
+        expect(result).toEqual({ createUser: { id: '1' } });
+    });
+    it('should pass custom headers', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: {} }),
+        });
+        const client = new graphql_client_1.GraphQLClient({
+            url: 'http://localhost/graphql',
+            headers: { Authorization: 'Bearer token' },
+        });
+        await client.query('{ x }');
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            headers: expect.objectContaining({
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer token',
+            }),
+        }));
+    });
+    it('should throw on HTTP error', async () => {
+        mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: 'Internal Error' });
+        const client = new graphql_client_1.GraphQLClient({ url: 'http://localhost/graphql' });
+        await expect(client.query('{ x }')).rejects.toThrow('GraphQL request failed: 500 Internal Error');
+    });
+    it('should throw on GraphQL errors', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                errors: [{ message: 'Invalid query' }, { message: 'Second error' }],
+            }),
+        });
+        const client = new graphql_client_1.GraphQLClient({ url: 'http://localhost/graphql' });
+        await expect(client.query('{ bad }')).rejects.toThrow('Invalid query; Second error');
+    });
+});

package/dist/decorators/field.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=field.decorator.test.d.ts.map

package/dist/decorators/field.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/field.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/field.decorator.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const field_decorator_1 = require("./field.decorator");
+describe('Field decorator', () => {
+    it('should add metadata for property with default name', () => {
+        class User {
+        }
+        __decorate([
+            (0, field_decorator_1.Field)(),
+            __metadata("design:type", String)
+        ], User.prototype, "id", void 0);
+        const meta = (0, field_decorator_1.getFieldMetadata)(User.prototype);
+        expect(meta).toHaveLength(1);
+        expect(meta[0].name).toBe('id');
+    });
+    it('should add metadata with custom name as string', () => {
+        class User {
+        }
+        __decorate([
+            (0, field_decorator_1.Field)('userId'),
+            __metadata("design:type", String)
+        ], User.prototype, "id", void 0);
+        const meta = (0, field_decorator_1.getFieldMetadata)(User.prototype);
+        expect(meta[0].name).toBe('userId');
+    });
+    it('should add metadata with options object', () => {
+        class User {
+        }
+        __decorate([
+            (0, field_decorator_1.Field)({ name: 'fullName', description: 'Full name' }),
+            __metadata("design:type", String)
+        ], User.prototype, "name", void 0);
+        const meta = (0, field_decorator_1.getFieldMetadata)(User.prototype);
+        expect(meta[0]).toMatchObject({ name: 'fullName', description: 'Full name' });
+    });
+    it('should add metadata for multiple fields', () => {
+        class User {
+        }
+        __decorate([
+            (0, field_decorator_1.Field)(),
+            __metadata("design:type", String)
+        ], User.prototype, "id", void 0);
+        __decorate([
+            (0, field_decorator_1.Field)(),
+            __metadata("design:type", String)
+        ], User.prototype, "name", void 0);
+        const meta = (0, field_decorator_1.getFieldMetadata)(User.prototype);
+        expect(meta).toHaveLength(2);
+        expect(meta.map((m) => m.name)).toEqual(['id', 'name']);
+    });
+    it('should return empty array for class without @Field', () => {
+        class Plain {
+        }
+        const meta = (0, field_decorator_1.getFieldMetadata)(Plain.prototype);
+        expect(meta).toEqual([]);
+    });
+});

package/dist/decorators/object-type.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=object-type.decorator.test.d.ts.map

package/dist/decorators/object-type.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-type.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/object-type.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/object-type.decorator.test.js

@@ -0,0 +1,45 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const object_type_decorator_1 = require("./object-type.decorator");
+describe('ObjectType decorator', () => {
+    it('should add metadata with class name when no options', () => {
+        let User = class User {
+        };
+        User = __decorate([
+            (0, object_type_decorator_1.ObjectType)()
+        ], User);
+        const meta = (0, object_type_decorator_1.getObjectTypeMetadata)(User);
+        expect(meta).toEqual({ name: 'User' });
+    });
+    it('should add metadata with custom name as string', () => {
+        let User = class User {
+        };
+        User = __decorate([
+            (0, object_type_decorator_1.ObjectType)('CustomUser')
+        ], User);
+        const meta = (0, object_type_decorator_1.getObjectTypeMetadata)(User);
+        expect(meta).toEqual({ name: 'CustomUser' });
+    });
+    it('should add metadata with options object', () => {
+        let Person = class Person {
+        };
+        Person = __decorate([
+            (0, object_type_decorator_1.ObjectType)({ name: 'Person', description: 'A person type' })
+        ], Person);
+        const meta = (0, object_type_decorator_1.getObjectTypeMetadata)(Person);
+        expect(meta).toEqual({ name: 'Person', description: 'A person type' });
+    });
+    it('should return undefined for class without decorator', () => {
+        class Plain {
+        }
+        const meta = (0, object_type_decorator_1.getObjectTypeMetadata)(Plain.prototype);
+        expect(meta).toBeUndefined();
+    });
+});

package/dist/decorators/query-mutation.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=query-mutation.decorator.test.d.ts.map

package/dist/decorators/query-mutation.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-mutation.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/query-mutation.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/query-mutation.decorator.test.js

@@ -0,0 +1,176 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const query_mutation_decorator_1 = require("./query-mutation.decorator");
+describe('Query decorator', () => {
+    it('should add metadata with method name as default', () => {
+        class TestResolver {
+            hello() {
+                return 'hi';
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "hello", null);
+        const meta = (0, query_mutation_decorator_1.getQueryMetadata)(TestResolver);
+        expect(meta).toHaveLength(1);
+        expect(meta[0].name).toBe('hello');
+        expect(meta[0].method).toBe('hello');
+    });
+    it('should add metadata with custom name', () => {
+        class TestResolver {
+            hello() {
+                return 'hi';
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)('getHello'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "hello", null);
+        const meta = (0, query_mutation_decorator_1.getQueryMetadata)(TestResolver);
+        expect(meta[0].name).toBe('getHello');
+        expect(meta[0].method).toBe('hello');
+    });
+    it('should support multiple queries', () => {
+        class TestResolver {
+            one() { }
+            two() { }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "one", null);
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "two", null);
+        const meta = (0, query_mutation_decorator_1.getQueryMetadata)(TestResolver);
+        expect(meta).toHaveLength(2);
+        expect(meta.map((m) => m.name)).toEqual(['one', 'two']);
+    });
+});
+describe('Mutation decorator', () => {
+    it('should add metadata with method name as default', () => {
+        class TestResolver {
+            createUser() {
+                return { id: '1' };
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Mutation)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "createUser", null);
+        const meta = (0, query_mutation_decorator_1.getMutationMetadata)(TestResolver);
+        expect(meta).toHaveLength(1);
+        expect(meta[0].name).toBe('createUser');
+        expect(meta[0].method).toBe('createUser');
+    });
+    it('should add metadata with custom name', () => {
+        class TestResolver {
+            createUser() {
+                return {};
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Mutation)('addUser'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "createUser", null);
+        const meta = (0, query_mutation_decorator_1.getMutationMetadata)(TestResolver);
+        expect(meta[0].name).toBe('addUser');
+    });
+});
+describe('Arg decorator', () => {
+    it('should add metadata for parameter with string name', () => {
+        class TestResolver {
+            user(_id) {
+                return {};
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __param(0, (0, query_mutation_decorator_1.Arg)('id')),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "user", null);
+        const meta = (0, query_mutation_decorator_1.getArgMetadata)(TestResolver.prototype, 'user');
+        expect(meta).toHaveLength(1);
+        expect(meta[0]?.name).toBe('id');
+    });
+    it('should add metadata with type', () => {
+        class TestResolver {
+            item(_id) {
+                return {};
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __param(0, (0, query_mutation_decorator_1.Arg)('id', String)),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "item", null);
+        const meta = (0, query_mutation_decorator_1.getArgMetadata)(TestResolver.prototype, 'item');
+        expect(meta[0]?.name).toBe('id');
+        expect(meta[0]?.type).toBe(String);
+    });
+    it('should add metadata for multiple args in order', () => {
+        class TestResolver {
+            create(_a, _b) {
+                return {};
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Mutation)(),
+            __param(0, (0, query_mutation_decorator_1.Arg)('a')),
+            __param(1, (0, query_mutation_decorator_1.Arg)('b')),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String, Number]),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "create", null);
+        const meta = (0, query_mutation_decorator_1.getArgMetadata)(TestResolver.prototype, 'create');
+        expect(meta).toHaveLength(2);
+        expect(meta[0]?.name).toBe('a');
+        expect(meta[1]?.name).toBe('b');
+    });
+    it('should return empty array when no args', () => {
+        class TestResolver {
+            hello() {
+                return 'hi';
+            }
+        }
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestResolver.prototype, "hello", null);
+        const meta = (0, query_mutation_decorator_1.getArgMetadata)(TestResolver.prototype, 'hello');
+        expect(meta).toEqual([]);
+    });
+});

package/dist/decorators/resolver.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=resolver.decorator.test.d.ts.map

package/dist/decorators/resolver.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/resolver.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/resolver.decorator.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const resolver_decorator_1 = require("./resolver.decorator");
+describe('Resolver decorator', () => {
+    it('should add empty metadata when no name', () => {
+        let UserResolver = class UserResolver {
+        };
+        UserResolver = __decorate([
+            (0, resolver_decorator_1.Resolver)()
+        ], UserResolver);
+        const meta = (0, resolver_decorator_1.getResolverMetadata)(UserResolver);
+        expect(meta).toEqual({});
+    });
+    it('should add metadata with custom name', () => {
+        let UserResolver = class UserResolver {
+        };
+        UserResolver = __decorate([
+            (0, resolver_decorator_1.Resolver)('User')
+        ], UserResolver);
+        const meta = (0, resolver_decorator_1.getResolverMetadata)(UserResolver);
+        expect(meta).toEqual({ name: 'User' });
+    });
+    it('should return undefined for class without decorator', () => {
+        class Plain {
+        }
+        const meta = (0, resolver_decorator_1.getResolverMetadata)(Plain);
+        expect(meta).toBeUndefined();
+    });
+});

package/dist/graphql.module.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=graphql.module.test.d.ts.map

package/dist/graphql.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.module.test.d.ts","sourceRoot":"","sources":["../src/graphql.module.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/graphql.module.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const core_2 = require("@hazeljs/core");
+const graphql_module_1 = require("./graphql.module");
+const graphql_server_1 = require("./graphql.server");
+const query_mutation_decorator_1 = require("./decorators/query-mutation.decorator");
+const resolver_decorator_1 = require("./decorators/resolver.decorator");
+const core_3 = require("@hazeljs/core");
+let TestResolver = class TestResolver {
+    hello() {
+        return 'world';
+    }
+};
+__decorate([
+    (0, query_mutation_decorator_1.Query)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResolver.prototype, "hello", null);
+TestResolver = __decorate([
+    (0, resolver_decorator_1.Resolver)()
+], TestResolver);
+let TestModule = class TestModule {
+};
+TestModule = __decorate([
+    (0, core_3.HazelModule)({
+        imports: [
+            graphql_module_1.GraphQLModule.forRoot({
+                path: '/graphql',
+                resolvers: [TestResolver],
+            }),
+        ],
+    })
+], TestModule);
+describe('GraphQLModule', () => {
+    let container;
+    const originalGetInstance = core_1.Container.getInstance;
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        core_1.Container.getInstance = jest.fn(() => container);
+    });
+    afterEach(() => {
+        core_1.Container.getInstance = originalGetInstance;
+    });
+    describe('forRoot', () => {
+        it('should return module config with providers and exports', () => {
+            expect(TestModule).toBeDefined();
+            const config = graphql_module_1.GraphQLModule.forRoot({
+                path: '/graphql',
+                resolvers: [TestResolver],
+            });
+            expect(config.module).toBe(graphql_module_1.GraphQLModule);
+            expect(config.providers).toHaveLength(2);
+            expect(config.providers[0]).toMatchObject({ provide: graphql_server_1.GraphQLServer });
+            expect(config.providers[0].useFactory).toBeDefined();
+            expect(config.exports).toContain(graphql_server_1.GraphQLServer);
+            expect(config.global).toBe(true);
+        });
+        it('should create GraphQLServer via factory', () => {
+            const mockApp = { addEarlyHandler: jest.fn() };
+            container.register(core_2.HazelApp, mockApp);
+            container.register(TestResolver, new TestResolver());
+            const config = graphql_module_1.GraphQLModule.forRoot({
+                path: '/api/gql',
+                resolvers: [TestResolver],
+            });
+            const factory = config.providers[0].useFactory;
+            const server = factory();
+            expect(server).toBeInstanceOf(graphql_server_1.GraphQLServer);
+            expect(server.getPath()).toBe('/api/gql');
+            expect(mockApp.addEarlyHandler).toHaveBeenCalledWith('/api/gql', expect.any(Function));
+        });
+    });
+});

package/dist/graphql.server.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=graphql.server.test.d.ts.map

package/dist/graphql.server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.server.test.d.ts","sourceRoot":"","sources":["../src/graphql.server.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/graphql.server.test.js

@@ -0,0 +1,79 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const core_2 = require("@hazeljs/core");
+const graphql_server_1 = require("./graphql.server");
+const query_mutation_decorator_1 = require("./decorators/query-mutation.decorator");
+const resolver_decorator_1 = require("./decorators/resolver.decorator");
+jest.mock('graphql-http/lib/use/http', () => ({
+    createHandler: jest.fn().mockReturnValue(jest.fn()),
+}));
+let TestResolver = class TestResolver {
+    hello() {
+        return 'world';
+    }
+};
+__decorate([
+    (0, query_mutation_decorator_1.Query)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResolver.prototype, "hello", null);
+TestResolver = __decorate([
+    (0, core_2.Injectable)(),
+    (0, resolver_decorator_1.Resolver)()
+], TestResolver);
+describe('GraphQLServer', () => {
+    let container;
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        container.register(TestResolver, new TestResolver());
+    });
+    describe('configure', () => {
+        it('should set default path to /graphql', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            expect(server.getPath()).toBe('/graphql');
+        });
+        it('should set custom path', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            server.configure({ path: '/api/gql' });
+            expect(server.getPath()).toBe('/api/gql');
+        });
+    });
+    describe('getHandler', () => {
+        it('should build and return handler on first call', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            const handler = server.getHandler();
+            expect(handler).toBeDefined();
+            expect(typeof handler).toBe('function');
+        });
+        it('should return same handler on subsequent calls', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            const h1 = server.getHandler();
+            const h2 = server.getHandler();
+            expect(h1).toBe(h2);
+        });
+    });
+    describe('getSchema', () => {
+        it('should return null before build', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            expect(server.getSchema()).toBeNull();
+        });
+        it('should return schema after getHandler', () => {
+            const server = new graphql_server_1.GraphQLServer([TestResolver], container);
+            server.getHandler();
+            expect(server.getSchema()).toBeDefined();
+            expect(server.getSchema()?.getQueryType()).toBeDefined();
+        });
+    });
+});

package/dist/schema-builder.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=schema-builder.test.d.ts.map

package/dist/schema-builder.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-builder.test.d.ts","sourceRoot":"","sources":["../src/schema-builder.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/schema-builder.test.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const core_2 = require("@hazeljs/core");
+const schema_builder_1 = require("./schema-builder");
+const resolver_decorator_1 = require("./decorators/resolver.decorator");
+const query_mutation_decorator_1 = require("./decorators/query-mutation.decorator");
+let TestResolver = class TestResolver {
+    hello() {
+        return 'world';
+    }
+    user(id) {
+        return JSON.stringify({ id, name: `User ${id}` });
+    }
+    createUser(name) {
+        return JSON.stringify({ id: '1', name });
+    }
+};
+__decorate([
+    (0, query_mutation_decorator_1.Query)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResolver.prototype, "hello", null);
+__decorate([
+    (0, query_mutation_decorator_1.Query)(),
+    __param(0, (0, query_mutation_decorator_1.Arg)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestResolver.prototype, "user", null);
+__decorate([
+    (0, query_mutation_decorator_1.Mutation)(),
+    __param(0, (0, query_mutation_decorator_1.Arg)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], TestResolver.prototype, "createUser", null);
+TestResolver = __decorate([
+    (0, core_2.Injectable)(),
+    (0, resolver_decorator_1.Resolver)()
+], TestResolver);
+describe('SchemaBuilder', () => {
+    let container;
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        container.register(TestResolver, new TestResolver());
+    });
+    it('should build schema with queries', () => {
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([TestResolver], container);
+        expect(schema.getQueryType()).toBeDefined();
+        expect(schema.getQueryType()?.getFields().hello).toBeDefined();
+        expect(schema.getQueryType()?.getFields().user).toBeDefined();
+    });
+    it('should build schema with mutations', () => {
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([TestResolver], container);
+        expect(schema.getMutationType()).toBeDefined();
+        expect(schema.getMutationType()?.getFields().createUser).toBeDefined();
+    });
+    it('should execute query resolvers', async () => {
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([TestResolver], container);
+        const { graphql } = await Promise.resolve().then(() => __importStar(require('graphql')));
+        const result = await graphql({ schema, source: '{ hello }' });
+        expect(result.data).toEqual({ hello: 'world' });
+    });
+    it('should execute query with args', async () => {
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([TestResolver], container);
+        const { graphql } = await Promise.resolve().then(() => __importStar(require('graphql')));
+        const result = await graphql({ schema, source: '{ user(id: "42") }' });
+        expect(result.errors).toBeUndefined();
+        expect(result.data?.user).toBeDefined();
+        expect(JSON.parse(result.data.user)).toMatchObject({ id: '42', name: 'User 42' });
+    });
+    it('should execute mutation', async () => {
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([TestResolver], container);
+        const { graphql } = await Promise.resolve().then(() => __importStar(require('graphql')));
+        const result = await graphql({
+            schema,
+            source: 'mutation { createUser(name: "Alice") }',
+        });
+        expect(result.errors).toBeUndefined();
+        expect(result.data?.createUser).toBeDefined();
+        expect(JSON.parse(result.data.createUser)).toMatchObject({ id: '1', name: 'Alice' });
+    });
+    it('should handle resolver with missing method', async () => {
+        let IncompleteResolver = class IncompleteResolver {
+            hello() {
+                return 'ok';
+            }
+        };
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], IncompleteResolver.prototype, "hello", null);
+        IncompleteResolver = __decorate([
+            (0, core_2.Injectable)(),
+            (0, resolver_decorator_1.Resolver)()
+        ], IncompleteResolver);
+        const instance = new (class {
+        })();
+        container.register(IncompleteResolver, instance);
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([IncompleteResolver], container);
+        const { graphql } = await Promise.resolve().then(() => __importStar(require('graphql')));
+        const result = await graphql({ schema, source: '{ hello }' });
+        expect(result.data?.hello).toBeNull();
+    });
+    it('should build mutation type only when mutations exist', () => {
+        let QueryOnlyResolver = class QueryOnlyResolver {
+            only() {
+                return 'ok';
+            }
+        };
+        __decorate([
+            (0, query_mutation_decorator_1.Query)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], QueryOnlyResolver.prototype, "only", null);
+        QueryOnlyResolver = __decorate([
+            (0, core_2.Injectable)(),
+            (0, resolver_decorator_1.Resolver)()
+        ], QueryOnlyResolver);
+        container.register(QueryOnlyResolver, new QueryOnlyResolver());
+        const builder = new schema_builder_1.SchemaBuilder();
+        const schema = builder.buildSchema([QueryOnlyResolver], container);
+        expect(schema.getMutationType()).toBeUndefined();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/graphql",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.56",
   "description": "GraphQL server and client for HazelJS - decorator-based schema and typed client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,5 +52,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "c2737e90974458a8438eee623726f0a453b66b8b"
 }