@hazeljs/graphql 0.2.0-alpha.1

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.d.ts

@@ -0,0 +1,23 @@
+import 'reflect-metadata';
+import type { FieldMetadata } from '../graphql.types';
+export declare const FIELD_METADATA_KEY: unique symbol;
+/**
+ * Marks a property or method as a GraphQL field
+ *
+ * @example
+ * ```typescript
+ * @ObjectType()
+ * class User {
+ *   @Field()
+ *   id: string;
+ *
+ *   @Field()
+ *   fullName(): string {
+ *     return `${this.firstName} ${this.lastName}`;
+ *   }
+ * }
+ * ```
+ */
+export declare function Field(nameOrOptions?: string | Partial<FieldMetadata>): PropertyDecorator & MethodDecorator;
+export declare function getFieldMetadata(target: object): FieldMetadata[];
+//# sourceMappingURL=field.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/field.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,eAAO,MAAM,kBAAkB,eAA0B,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CACnB,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,GAC9C,iBAAiB,GAAG,eAAe,CAUrC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAEhE"}

package/dist/decorators/field.decorator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIELD_METADATA_KEY = void 0;
+exports.Field = Field;
+exports.getFieldMetadata = getFieldMetadata;
+require("reflect-metadata");
+exports.FIELD_METADATA_KEY = Symbol('graphql:field');
+/**
+ * Marks a property or method as a GraphQL field
+ *
+ * @example
+ * ```typescript
+ * @ObjectType()
+ * class User {
+ *   @Field()
+ *   id: string;
+ *
+ *   @Field()
+ *   fullName(): string {
+ *     return `${this.firstName} ${this.lastName}`;
+ *   }
+ * }
+ * ```
+ */
+function Field(nameOrOptions) {
+    return (target, propertyKey, _descriptor) => {
+        const meta = typeof nameOrOptions === 'string'
+            ? { name: nameOrOptions, type: undefined }
+            : { name: String(propertyKey), type: undefined, ...nameOrOptions };
+        const existing = Reflect.getMetadata(exports.FIELD_METADATA_KEY, target) || [];
+        existing.push({ ...meta, name: meta.name || String(propertyKey) });
+        Reflect.defineMetadata(exports.FIELD_METADATA_KEY, existing, target);
+    };
+}
+function getFieldMetadata(target) {
+    return Reflect.getMetadata(exports.FIELD_METADATA_KEY, target) || [];
+}

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.d.ts

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import type { ObjectTypeMetadata } from '../graphql.types';
+export declare const OBJECT_TYPE_METADATA_KEY: unique symbol;
+/**
+ * Marks a class as a GraphQL object type
+ *
+ * @example
+ * ```typescript
+ * @ObjectType()
+ * class User {
+ *   @Field()
+ *   id: string;
+ *
+ *   @Field()
+ *   name: string;
+ * }
+ * ```
+ */
+export declare function ObjectType(nameOrOptions?: string | ObjectTypeMetadata): ClassDecorator;
+export declare function getObjectTypeMetadata(target: object): ObjectTypeMetadata | undefined;
+//# sourceMappingURL=object-type.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object-type.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/object-type.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,eAAO,MAAM,wBAAwB,eAAgC,CAAC;AAEtE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,kBAAkB,GAAG,cAAc,CAQtF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAIpF"}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_TYPE_METADATA_KEY = void 0;
+exports.ObjectType = ObjectType;
+exports.getObjectTypeMetadata = getObjectTypeMetadata;
+require("reflect-metadata");
+exports.OBJECT_TYPE_METADATA_KEY = Symbol('graphql:object-type');
+/**
+ * Marks a class as a GraphQL object type
+ *
+ * @example
+ * ```typescript
+ * @ObjectType()
+ * class User {
+ *   @Field()
+ *   id: string;
+ *
+ *   @Field()
+ *   name: string;
+ * }
+ * ```
+ */
+function ObjectType(nameOrOptions) {
+    return (target) => {
+        const meta = typeof nameOrOptions === 'string'
+            ? { name: nameOrOptions }
+            : (nameOrOptions ?? { name: target.name });
+        Reflect.defineMetadata(exports.OBJECT_TYPE_METADATA_KEY, meta, target);
+    };
+}
+function getObjectTypeMetadata(target) {
+    const ctor = typeof target === 'function' ? target : target.constructor;
+    return Reflect.getMetadata(exports.OBJECT_TYPE_METADATA_KEY, ctor ?? target);
+}

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.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import type { QueryMetadata, MutationMetadata, ArgMetadata } from '../graphql.types';
+export declare const QUERY_METADATA_KEY: unique symbol;
+export declare const MUTATION_METADATA_KEY: unique symbol;
+export declare const ARG_METADATA_KEY: unique symbol;
+/**
+ * Marks a method as a GraphQL Query
+ */
+export declare function Query(nameOrOptions?: string | Partial<QueryMetadata>): MethodDecorator;
+/**
+ * Marks a method as a GraphQL Mutation
+ */
+export declare function Mutation(nameOrOptions?: string | Partial<MutationMetadata>): MethodDecorator;
+/**
+ * Marks a parameter as a GraphQL argument
+ */
+export declare function Arg(nameOrOptions: string | Partial<ArgMetadata>, type?: unknown): ParameterDecorator;
+export declare function getQueryMetadata(target: object): Array<QueryMetadata & {
+    method: string;
+}>;
+export declare function getMutationMetadata(target: object): Array<MutationMetadata & {
+    method: string;
+}>;
+export declare function getArgMetadata(target: object, propertyKey: string | symbol): ArgMetadata[];
+//# sourceMappingURL=query-mutation.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-mutation.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/query-mutation.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAErF,eAAO,MAAM,kBAAkB,eAA0B,CAAC;AAC1D,eAAO,MAAM,qBAAqB,eAA6B,CAAC;AAChE,eAAO,MAAM,gBAAgB,eAAwB,CAAC;AAEtD;;GAEG;AACH,wBAAgB,KAAK,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,eAAe,CAUtF;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,eAAe,CAU5F;AAED;;GAEG;AACH,wBAAgB,GAAG,CACjB,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,EAC5C,IAAI,CAAC,EAAE,OAAO,GACb,kBAAkB,CAWpB;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAE1F;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,gBAAgB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhG;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,EAAE,CAE1F"}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARG_METADATA_KEY = exports.MUTATION_METADATA_KEY = exports.QUERY_METADATA_KEY = void 0;
+exports.Query = Query;
+exports.Mutation = Mutation;
+exports.Arg = Arg;
+exports.getQueryMetadata = getQueryMetadata;
+exports.getMutationMetadata = getMutationMetadata;
+exports.getArgMetadata = getArgMetadata;
+require("reflect-metadata");
+exports.QUERY_METADATA_KEY = Symbol('graphql:query');
+exports.MUTATION_METADATA_KEY = Symbol('graphql:mutation');
+exports.ARG_METADATA_KEY = Symbol('graphql:arg');
+/**
+ * Marks a method as a GraphQL Query
+ */
+function Query(nameOrOptions) {
+    return (target, propertyKey, _descriptor) => {
+        const meta = typeof nameOrOptions === 'string'
+            ? { name: nameOrOptions }
+            : { name: String(propertyKey), ...nameOrOptions };
+        const existing = Reflect.getMetadata(exports.QUERY_METADATA_KEY, target.constructor) || [];
+        existing.push({ ...meta, name: meta.name || String(propertyKey), method: String(propertyKey) });
+        Reflect.defineMetadata(exports.QUERY_METADATA_KEY, existing, target.constructor);
+    };
+}
+/**
+ * Marks a method as a GraphQL Mutation
+ */
+function Mutation(nameOrOptions) {
+    return (target, propertyKey, _descriptor) => {
+        const meta = typeof nameOrOptions === 'string'
+            ? { name: nameOrOptions }
+            : { name: String(propertyKey), ...nameOrOptions };
+        const existing = Reflect.getMetadata(exports.MUTATION_METADATA_KEY, target.constructor) || [];
+        existing.push({ ...meta, name: meta.name || String(propertyKey), method: String(propertyKey) });
+        Reflect.defineMetadata(exports.MUTATION_METADATA_KEY, existing, target.constructor);
+    };
+}
+/**
+ * Marks a parameter as a GraphQL argument
+ */
+function Arg(nameOrOptions, type) {
+    return (target, propertyKey, parameterIndex) => {
+        const meta = typeof nameOrOptions === 'string'
+            ? { name: nameOrOptions, type }
+            : { name: nameOrOptions.name, type: nameOrOptions.type, ...nameOrOptions };
+        const key = propertyKey ?? '';
+        const existing = Reflect.getMetadata(exports.ARG_METADATA_KEY, target, key) || [];
+        existing[parameterIndex] = meta;
+        Reflect.defineMetadata(exports.ARG_METADATA_KEY, existing, target, key);
+    };
+}
+function getQueryMetadata(target) {
+    return Reflect.getMetadata(exports.QUERY_METADATA_KEY, target) || [];
+}
+function getMutationMetadata(target) {
+    return Reflect.getMetadata(exports.MUTATION_METADATA_KEY, target) || [];
+}
+function getArgMetadata(target, propertyKey) {
+    return Reflect.getMetadata(exports.ARG_METADATA_KEY, target, propertyKey) || [];
+}

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.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import type { ResolverMetadata } from '../graphql.types';
+export declare const RESOLVER_METADATA_KEY: unique symbol;
+/**
+ * Marks a class as a GraphQL resolver (contains @Query and @Mutation handlers)
+ *
+ * @example
+ * ```typescript
+ * @Resolver()
+ * class UserResolver {
+ *   @Query()
+ *   user(@Arg('id') id: string) {
+ *     return { id, name: 'John' };
+ *   }
+ *
+ *   @Mutation()
+ *   createUser(@Arg('name') name: string) {
+ *     return { id: '1', name };
+ *   }
+ * }
+ * ```
+ */
+export declare function Resolver(name?: string): ClassDecorator;
+export declare function getResolverMetadata(target: object): ResolverMetadata | undefined;
+//# sourceMappingURL=resolver.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/resolver.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,eAAO,MAAM,qBAAqB,eAA6B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,cAAc,CAKtD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEhF"}