@orion-js/graphql 3.12.0 → 3.13.1

package/lib/resolversSchemas/params.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolvers_1 = require("@orion-js/resolvers");
+const helpers_1 = require("@orion-js/helpers");
+const ResolverParamsInfo_1 = __importDefault(require("./ResolverParamsInfo"));
+const resolversStore_1 = require("../buildSchema/getResolvers/resolversStore");
+exports.default = (0, resolvers_1.resolver)({
+    params: {
+        name: {
+            type: 'ID'
+        },
+        mutation: {
+            type: Boolean
+        }
+    },
+    returns: ResolverParamsInfo_1.default,
+    mutation: false,
+    resolve: async function ({ mutation, name }, viewer) {
+        const resolver = resolversStore_1.resolversStore[name];
+        if (!resolver) {
+            throw new helpers_1.UserError('notFound', `${mutation ? 'Mutation' : 'Query'} named "${name}" not found`);
+        }
+        if (!!resolver.mutation !== !!mutation) {
+            throw new helpers_1.UserError('incorrectType', `"${name}" is ${mutation ? 'not' : ''} a mutation`);
+        }
+        return { resolver, name };
+    }
+});

package/lib/resolversSchemas/params.test.d.ts

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

package/lib/resolversSchemas/params.test.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const params_1 = __importDefault(require("./params"));
+const resolversStore_1 = require("../buildSchema/getResolvers/resolversStore");
+const resolvers_1 = require("@orion-js/resolvers");
+const models_1 = require("@orion-js/models");
+describe('Get params tests', () => {
+    it('Should return the correct information for a resolver that returns a string array', async () => {
+        resolversStore_1.resolversStore.aResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [String],
+            async resolve() {
+                return ['a', 'b'];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'aResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('aResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual(undefined);
+        expect(basicResultQuery).toEqual('');
+    });
+    it('Should return the correct information for a resolver that returns a string', async () => {
+        resolversStore_1.resolversStore.aaResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [String],
+            async resolve() {
+                return 'a';
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'aaResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('aaResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual(undefined);
+        expect(basicResultQuery).toEqual('');
+    });
+    it('Should return the correct information for a resolver that returns a array of a model', async () => {
+        const model = (0, models_1.createModel)({
+            name: 'Item',
+            schema: {
+                name: {
+                    type: String
+                }
+            }
+        });
+        resolversStore_1.resolversStore.bResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [model],
+            async resolve() {
+                return [{ name: 'Nico' }];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'bResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('bResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual('Item');
+        expect(basicResultQuery).toEqual('{ name }');
+    });
+    it('Should return the correct information for a resolver that returns a model', async () => {
+        const model2 = (0, models_1.createModel)({
+            name: 'Item2',
+            schema: {
+                name: {
+                    type: String
+                }
+            }
+        });
+        resolversStore_1.resolversStore.cResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: model2,
+            async resolve() {
+                return [{ name: 'Nico' }];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'cResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('cResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual('Item2');
+        expect(basicResultQuery).toEqual('{ name }');
+    });
+});

package/lib/resolversSchemas/serializeSchema.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '@orion-js/schema';
+export default function serializeSchema(params: any): Promise<Schema>;

package/lib/resolversSchemas/serializeSchema.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getField_1 = __importDefault(require("./getField"));
+async function serializeSchema(params) {
+    if (!params)
+        return;
+    if (typeof params === 'function' && params.getModel && params.__schemaId) {
+        params = params.getModel().getCleanSchema(); // typed model
+    }
+    if (Object.keys(params).length === 0)
+        return;
+    const fields = {};
+    for (const key of Object.keys(params)) {
+        const field = params[key];
+        fields[key] = await (0, getField_1.default)(field);
+    }
+    return fields;
+}
+exports.default = serializeSchema;

package/lib/resolversSchemas/serializeSchema.test.d.ts

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

package/lib/resolversSchemas/serializeSchema.test.js

@@ -0,0 +1,56 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typed_model_1 = require("@orion-js/typed-model");
+const serializeSchema_1 = __importDefault(require("./serializeSchema"));
+it('should create a JSON of the schema', async () => {
+    const schema = {
+        name: {
+            type: String
+        }
+    };
+    const result = await (0, serializeSchema_1.default)(schema);
+    expect(result).toEqual({ name: { type: 'string', __graphQLType: 'String' } });
+});
+it('should pass field options', async () => {
+    const schema = {
+        name: {
+            type: [String],
+            label: '1234'
+        }
+    };
+    const result = await (0, serializeSchema_1.default)(schema);
+    expect(result.name).toEqual({
+        type: ['string'],
+        label: '1234',
+        __graphQLType: '[String]'
+    });
+});
+it('should serialize a typed model', async () => {
+    let Point = class Point {
+    };
+    __decorate([
+        (0, typed_model_1.Prop)({ label: 'Name' }),
+        __metadata("design:type", String)
+    ], Point.prototype, "name", void 0);
+    Point = __decorate([
+        (0, typed_model_1.TypedModel)()
+    ], Point);
+    const result = await (0, serializeSchema_1.default)(Point);
+    expect(result.name).toEqual({
+        type: 'string',
+        label: 'Name',
+        __graphQLType: 'String'
+    });
+});

package/lib/service/global.d.ts

@@ -0,0 +1,10 @@
+import { GlobalResolverResolve, ResolverOptions, Resolver } from '@orion-js/resolvers';
+export declare function Resolvers(): ClassDecorator;
+export interface GlobalResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: GlobalResolverResolve;
+}
+export declare function Query(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
+export declare function Mutation(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
+export declare function getServiceResolvers(target: any): {
+    [key: string]: Resolver<GlobalResolverResolve>;
+};

package/lib/service/global.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceResolvers = exports.Mutation = exports.Query = exports.Resolvers = void 0;
+const services_1 = require("@orion-js/services");
+const resolvers_1 = require("@orion-js/resolvers");
+const helpers_1 = require("@orion-js/helpers");
+const otherParams_1 = require("./otherParams");
+function Resolvers() {
+    return (target) => {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Resolvers = Resolvers;
+function Query(options) {
+    return (target, propertyKey, descriptor) => {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.resolvers = target.resolvers || {};
+        target.resolvers[propertyKey] = (0, resolvers_1.resolver)({
+            resolverId: propertyKey,
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
+            ...options,
+            resolve: async (params, viewer, info) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer, info);
+            },
+        });
+    };
+}
+exports.Query = Query;
+function Mutation(options) {
+    return (target, propertyKey, descriptor) => {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.resolvers = target.resolvers || {};
+        target.resolvers[propertyKey] = (0, resolvers_1.resolver)({
+            resolverId: propertyKey,
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
+            ...options,
+            mutation: true,
+            resolve: async (params, viewer, info) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer, info);
+            },
+        });
+    };
+}
+exports.Mutation = Mutation;
+function getServiceResolvers(target) {
+    if (!target.prototype) {
+        throw new helpers_1.UserError('You must pass a class to getResolvers');
+    }
+    return target.prototype.resolvers || {};
+}
+exports.getServiceResolvers = getServiceResolvers;

package/lib/service/index.d.ts

@@ -0,0 +1,4 @@
+export * from './global';
+export * from './model';
+export * from './subscription';
+export * from './otherParams';

package/lib/service/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./global"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./subscription"), exports);
+__exportStar(require("./otherParams"), exports);

package/lib/service/index.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/service/index.test.js

@@ -0,0 +1,63 @@
+"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 services_1 = require("@orion-js/services");
+const index_1 = require("./index");
+describe('Resolvers with service injection', () => {
+    it('should allow to pass a service as resolve', async () => {
+        let ExampleRepo = class ExampleRepo {
+            getLastName() {
+                return 'Lopez';
+            }
+        };
+        ExampleRepo = __decorate([
+            (0, services_1.Service)()
+        ], ExampleRepo);
+        let ExampleResolverService = class ExampleResolverService {
+            async sayHi(params) {
+                return this.addAge(`My name is ${params.name} ${this.repo.getLastName()}`);
+            }
+            async setName() {
+                this.repo.getLastName();
+            }
+            async addAge(params) {
+                return `${params} and I'm 100 years old`;
+            }
+        };
+        __decorate([
+            (0, services_1.Inject)(),
+            __metadata("design:type", ExampleRepo)
+        ], ExampleResolverService.prototype, "repo", void 0);
+        __decorate([
+            (0, index_1.Query)({
+                params: { name: { type: 'string' } },
+                returns: String,
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "sayHi", null);
+        __decorate([
+            (0, index_1.Mutation)({ returns: String }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "setName", null);
+        ExampleResolverService = __decorate([
+            (0, index_1.Resolvers)()
+        ], ExampleResolverService);
+        const resolvers = (0, index_1.getServiceResolvers)(ExampleResolverService);
+        expect(resolvers.sayHi).toBeDefined();
+        const result = await resolvers.sayHi.execute({ params: { name: 'Orion' } });
+        expect(result).toBe(`My name is Orion Lopez and I'm 100 years old`);
+    });
+});

package/lib/service/middlewares.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/service/middlewares.test.js

@@ -0,0 +1,125 @@
+"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 services_1 = require("@orion-js/services");
+const index_1 = require("./index");
+const otherParams_1 = require("./otherParams");
+const resolvers_1 = require("@orion-js/resolvers");
+const typed_model_1 = require("@orion-js/typed-model");
+describe('Resolvers with service injection and middlewares', () => {
+    it('should allow to pass resolver middlewares with decorators', async () => {
+        expect.assertions(3);
+        let ExampleRepo = class ExampleRepo {
+            getLastName() {
+                return 'Lopez';
+            }
+        };
+        ExampleRepo = __decorate([
+            (0, services_1.Service)()
+        ], ExampleRepo);
+        const exampleMiddleware = (0, resolvers_1.createResolverMiddleware)(async (executeOptions, next) => {
+            const result = await next();
+            expect(result).toBe('intercepted2');
+            return 'intercepted';
+        });
+        const CheckRoles = (rolesToCheck) => {
+            return (0, otherParams_1.UseMiddleware)(async (executeOptions, next) => {
+                // check roles here
+                await next();
+                return 'intercepted2';
+            });
+        };
+        let ExampleResolverService = class ExampleResolverService {
+            async sayHi(params) {
+                return 'text';
+            }
+        };
+        __decorate([
+            (0, index_1.Query)(),
+            (0, otherParams_1.ResolverParams)({ name: { type: 'string' } }),
+            (0, otherParams_1.ResolverReturns)(String),
+            (0, otherParams_1.UseMiddleware)(exampleMiddleware),
+            CheckRoles(['admin']),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "sayHi", null);
+        ExampleResolverService = __decorate([
+            (0, index_1.Resolvers)()
+        ], ExampleResolverService);
+        const resolvers = (0, index_1.getServiceResolvers)(ExampleResolverService);
+        expect(resolvers.sayHi).toBeDefined();
+        const result = await resolvers.sayHi.execute({ params: { name: 'Orion' } });
+        expect(result).toBe(`intercepted`);
+    });
+    it('show also work with model resolvers', async () => {
+        let Person = class Person {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Person.prototype, "name", void 0);
+        Person = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Person);
+        const NiceToMeetYou = (0, otherParams_1.UseMiddleware)(async (executeOptions, next) => {
+            const result = await next();
+            return `${result}, nice to meet you`;
+        });
+        let PersonResolvers = class PersonResolvers {
+            async getAge(person) {
+                return `hello ${person.name}`;
+            }
+        };
+        __decorate([
+            (0, index_1.ModelResolver)(),
+            (0, otherParams_1.ResolverReturns)(String),
+            NiceToMeetYou,
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Person]),
+            __metadata("design:returntype", Promise)
+        ], PersonResolvers.prototype, "getAge", null);
+        PersonResolvers = __decorate([
+            (0, index_1.ModelResolvers)(Person)
+        ], PersonResolvers);
+        const data = (0, index_1.getServiceModelResolvers)(PersonResolvers);
+        const item = { name: 'Orion' };
+        const result = await data.Person.getAge.execute({ parent: item });
+        expect(result).toBe(`hello Orion, nice to meet you`);
+    });
+    it('should pass the mutation name in the middleware', async () => {
+        let mutationName = '';
+        const exampleMiddleware = (0, resolvers_1.createResolverMiddleware)(async (executeOptions, next) => {
+            mutationName = executeOptions.options.resolverId;
+            await next();
+        });
+        let ExampleResolverService = class ExampleResolverService {
+            async sayHi(params) {
+                return 'text';
+            }
+        };
+        __decorate([
+            (0, index_1.Query)(),
+            (0, otherParams_1.ResolverReturns)(String),
+            (0, otherParams_1.UseMiddleware)(exampleMiddleware),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "sayHi", null);
+        ExampleResolverService = __decorate([
+            (0, index_1.Resolvers)()
+        ], ExampleResolverService);
+        const resolvers = (0, index_1.getServiceResolvers)(ExampleResolverService);
+        await resolvers.sayHi.execute({ params: {} });
+        expect(mutationName).toBe('sayHi');
+    });
+});

package/lib/service/model.d.ts

@@ -0,0 +1,14 @@
+import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, ModelResolver as ModelResolverType } from '@orion-js/resolvers';
+export interface ModelResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: ModelResolverResolve;
+}
+export declare function ModelResolver(options?: Omit<ResolverOptions<any>, 'resolve' | 'middlewares'>): (target: any, propertyKey: string, descriptor: ModelResolverPropertyDescriptor) => void;
+export interface ModelResolversOptions {
+    modelName?: string;
+}
+export declare function ModelResolvers(typedSchema: any, options?: ModelResolversOptions): ClassDecorator;
+export declare function getServiceModelResolvers(target: any): {
+    [key: string]: {
+        [key: string]: ModelResolverType<GlobalResolverResolve>;
+    };
+};

package/lib/service/model.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceModelResolvers = exports.ModelResolvers = exports.ModelResolver = void 0;
+const services_1 = require("@orion-js/services");
+const resolvers_1 = require("@orion-js/resolvers");
+const helpers_1 = require("@orion-js/helpers");
+const otherParams_1 = require("./otherParams");
+function ModelResolver(options) {
+    return (target, propertyKey, descriptor) => {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.resolvers = target.resolvers || {};
+        target.resolvers[propertyKey] = (0, resolvers_1.modelResolver)({
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
+            ...options,
+            resolve: async (item, params, viewer, info) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](item, params, viewer, info);
+            },
+        });
+    };
+}
+exports.ModelResolver = ModelResolver;
+function ModelResolvers(typedSchema, options = {}) {
+    return (target) => {
+        (0, services_1.Service)()(target);
+        target.prototype.modelName = options.modelName || typedSchema.name;
+        if (!target.prototype.modelName) {
+            throw new Error('The specified model has no name or is not a model');
+        }
+        target.prototype.typedSchema = typedSchema;
+        target.prototype.service = target;
+        // @ts-expect-error this is a trick to make it work in resolvers without having to call getModelForClass
+        target.getModel = () => getModelForClass(target);
+    };
+}
+exports.ModelResolvers = ModelResolvers;
+function getServiceModelResolvers(target) {
+    if (!target.prototype) {
+        throw new helpers_1.UserError('You must pass a class to getResolvers');
+    }
+    return {
+        [target.prototype.modelName]: target.prototype.resolvers || {},
+    };
+}
+exports.getServiceModelResolvers = getServiceModelResolvers;

package/lib/service/model.test.d.ts

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