@orion-js/graphql 3.2.5 → 3.2.7

package/lib/buildSchema/getMutation.d.ts

@@ -1,5 +1,3 @@
 import { GraphQLObjectType } from 'graphql';
-export default function ({ resolvers, ...options }: {
-    [x: string]: any;
-    resolvers: any;
-}): Promise<GraphQLObjectType<any, any>>;
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<GraphQLObjectType<any, any>>;

package/lib/buildSchema/getMutation.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_1 = require("graphql");
 const getResolvers_1 = __importDefault(require("./getResolvers"));
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
-async function default_1({ resolvers, ...options }) {
-    const fields = await (0, getResolvers_1.default)({ resolvers, mutation: true, options });
+async function default_1(options) {
+    const fields = await (0, getResolvers_1.default)(options, true);
     if ((0, isEmpty_1.default)(fields))
         return null;
     return new graphql_1.GraphQLObjectType({

package/lib/buildSchema/getQuery.d.ts

@@ -1,5 +1,3 @@
 import { GraphQLObjectType } from 'graphql';
-export default function ({ resolvers, ...options }: {
-    [x: string]: any;
-    resolvers: any;
-}): Promise<GraphQLObjectType<any, any>>;
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<GraphQLObjectType<any, any>>;

package/lib/buildSchema/getQuery.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_1 = require("graphql");
 const getResolvers_1 = __importDefault(require("./getResolvers"));
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
-async function default_1({ resolvers, ...options }) {
-    const fields = await (0, getResolvers_1.default)({ resolvers, mutation: false, options });
+async function default_1(options) {
+    const fields = await (0, getResolvers_1.default)(options, false);
     if ((0, isEmpty_1.default)(fields))
         return null;
     return new graphql_1.GraphQLObjectType({

package/lib/buildSchema/getResolvers/index.d.ts

@@ -1,6 +1,3 @@
 import { GraphQLFieldConfig } from 'graphql';
-export default function ({ resolvers, mutation, options }: {
-    resolvers: any;
-    mutation: any;
-    options: any;
-}): Promise<import("graphql/jsutils/ObjMap").ObjMap<GraphQLFieldConfig<any, any, any>>>;
+import { StartGraphQLOptions } from '../../types/startGraphQL';
+export default function (options: StartGraphQLOptions, mutation: boolean): Promise<import("graphql/jsutils/ObjMap").ObjMap<GraphQLFieldConfig<any, any, any>>>;

package/lib/buildSchema/getResolvers/index.js

@@ -7,7 +7,8 @@ const getType_1 = __importDefault(require("../getType"));
 const getArgs_1 = __importDefault(require("../getArgs"));
 const errorHandler_1 = __importDefault(require("../../errorHandler"));
 const resolversStore_1 = require("./resolversStore");
-async function default_1({ resolvers, mutation, options }) {
+async function default_1(options, mutation) {
+    const { resolvers } = options;
     const filteredResolvers = Object.keys(resolvers)
         .map(key => {
         return {

package/lib/buildSchema/getResolvers/index.test.js

@@ -52,8 +52,8 @@ describe('Test get resolvers schema', () => {
         });
         const resolvers = { globalResolver };
         const mutation = false;
-        const options = {};
-        const schema = await (0, index_1.default)({ resolvers, mutation, options });
+        const options = { resolvers };
+        const schema = await (0, index_1.default)(options, mutation);
         expect(schema.globalResolver.type.toString()).toEqual('TestModel');
         expect(schema.globalResolver.args).toHaveProperty('userId');
         expect(await schema.globalResolver.resolve(null, { userId: '1' })).toEqual({

package/lib/buildSchema/getSubscription.d.ts

@@ -1,5 +1,3 @@
 import { GraphQLObjectType } from 'graphql';
-export default function ({ subscriptions, ...options }: {
-    [x: string]: any;
-    subscriptions: any;
-}): Promise<GraphQLObjectType<any, any>>;
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<GraphQLObjectType>;

package/lib/buildSchema/getSubscription.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_1 = require("graphql");
 const getSubscriptions_1 = __importDefault(require("./getSubscriptions"));
-async function default_1({ subscriptions, ...options }) {
-    if (!subscriptions)
+async function default_1(options) {
+    if (!options.subscriptions)
         return null;
-    const fields = await (0, getSubscriptions_1.default)({ subscriptions, options });
+    const fields = await (0, getSubscriptions_1.default)(options);
     return new graphql_1.GraphQLObjectType({
         name: 'Subscription',
         fields

package/lib/buildSchema/getSubscriptions/index.d.ts

@@ -1,4 +1,2 @@
-export default function ({ subscriptions, options }: {
-    subscriptions: any;
-    options: any;
-}): Promise<{}>;
+import { StartGraphQLOptions } from '../../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<{}>;

package/lib/buildSchema/getSubscriptions/index.js

@@ -5,7 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const getType_1 = __importDefault(require("../getType"));
 const getArgs_1 = __importDefault(require("../getArgs"));
-async function default_1({ subscriptions, options }) {
+async function default_1(options) {
+    const { subscriptions } = options;
     const fields = {};
     for (const key of Object.keys(subscriptions)) {
         const subscription = subscriptions[key];

package/lib/buildSchema/getSubscriptions/index.test.js

@@ -24,7 +24,7 @@ describe('Test get subscriptions schema', () => {
             __metadata("design:type", String)
         ], TestParams.prototype, "userId", void 0);
         TestParams = __decorate([
-            (0, typed_model_1.TypedModel)()
+            (0, typed_model_1.TypedSchema)()
         ], TestParams);
         let TestModel = class TestModel {
         };
@@ -37,15 +37,15 @@ describe('Test get subscriptions schema', () => {
             __metadata("design:type", Number)
         ], TestModel.prototype, "age", void 0);
         TestModel = __decorate([
-            (0, typed_model_1.TypedModel)()
+            (0, typed_model_1.TypedSchema)()
         ], TestModel);
         const modelSub = (0, __1.subscription)({
             params: TestParams,
             returns: TestModel
         });
         const subscriptions = { modelSub };
-        const options = {};
-        const schema = await (0, index_1.default)({ subscriptions, options });
+        const options = { subscriptions, resolvers: {} };
+        const schema = await (0, index_1.default)(options);
         expect(schema.modelSub.type.toString()).toEqual('TestModel');
         expect(schema.modelSub.args).toHaveProperty('userId');
     });

package/lib/buildSchema/getType/index.d.ts

@@ -1 +1,2 @@
-export default function getGraphQLType(type: any, options: any): any;
+import { StartGraphQLOptions } from '../../types/startGraphQL';
+export default function getGraphQLType(type: any, options: StartGraphQLOptions): any;

package/lib/buildSchema/getType/index.js

@@ -11,6 +11,7 @@ const getScalar_1 = __importDefault(require("./getScalar"));
 const getTypeAsResolver_1 = __importDefault(require("./getTypeAsResolver"));
 const getStaticFields_1 = require("../../resolversSchemas/getStaticFields");
 const getDynamicFields_1 = require("../../resolversSchemas/getDynamicFields");
+const getModelLoadedResolvers_1 = require("../../resolversSchemas/getModelLoadedResolvers");
 function getGraphQLType(type, options) {
     if (!type) {
         throw new Error('Type is undefined');
@@ -63,6 +64,14 @@ function getGraphQLType(type, options) {
                         throw new Error(`Error getting resolver type for resolver "${resolver.key}": ${error.message}`);
                     }
                 }
+                for (const resolver of (0, getModelLoadedResolvers_1.getModelLoadedResolvers)(model, options)) {
+                    try {
+                        fields[resolver.key] = (0, getTypeAsResolver_1.default)({ resolver, getGraphQLType, options, model });
+                    }
+                    catch (error) {
+                        throw new Error(`Error getting resolver type for resolver "${resolver.key}": ${error.message}`);
+                    }
+                }
                 return fields;
             }
         });

package/lib/buildSchema/index.d.ts

@@ -1,2 +1,3 @@
 import { GraphQLSchema } from 'graphql';
-export default function (options: any): Promise<GraphQLSchema>;
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export default function (options: StartGraphQLOptions): Promise<GraphQLSchema>;

package/lib/resolversSchemas/getModelLoadedResolvers.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '@orion-js/models';
+import { StartGraphQLOptions } from '../types/startGraphQL';
+export declare function getModelLoadedResolvers(model: Model, options: StartGraphQLOptions): any[];

package/lib/resolversSchemas/getModelLoadedResolvers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelLoadedResolvers = void 0;
+function getModelLoadedResolvers(model, options) {
+    if (!options.modelsResolvers)
+        return [];
+    const resolvers = options.modelsResolvers[model.name];
+    if (!resolvers)
+        return [];
+    const keys = Object.keys(resolvers);
+    return keys
+        .map(key => {
+        const resolver = resolvers[key];
+        return {
+            ...resolver,
+            key
+        };
+    })
+        .filter(resolver => !resolver.private);
+}
+exports.getModelLoadedResolvers = getModelLoadedResolvers;

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,51 @@
+"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");
+function Resolvers() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Resolvers = Resolvers;
+function Query(options) {
+    return function (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)({
+            ...options,
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.Query = Query;
+function Mutation(options) {
+    return function (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)({
+            ...options,
+            mutation: true,
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+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

@@ -1,18 +1,2 @@
-import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, Resolver, ModelResolver } from '@orion-js/resolvers';
-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>;
-};
-export interface ModelResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
-    value?: ModelResolverResolve;
-}
-export declare function ModelResolver(options: Omit<ResolverOptions<any>, 'resolve'>): (target: any, propertyKey: string, descriptor: ModelResolverPropertyDescriptor) => void;
-export declare function getServiceModelResolvers(target: any): {
-    [key: string]: ModelResolver<GlobalResolverResolve>;
-};
-export declare function Resolvers(): ClassDecorator;
-export declare function Model(typedSchema: any): ClassDecorator;
+export * from './global';
+export * from './model';

package/lib/service/index.js

@@ -1,83 +1,14 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
-exports.Model = exports.Resolvers = exports.getServiceModelResolvers = exports.ModelResolver = exports.getServiceResolvers = exports.Mutation = exports.Query = void 0;
-const services_1 = require("@orion-js/services");
-const resolvers_1 = require("@orion-js/resolvers");
-const helpers_1 = require("@orion-js/helpers");
-function Query(options) {
-    return function (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)({
-            ...options,
-            resolve: async (params, viewer) => {
-                const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](params, viewer);
-            }
-        });
-    };
-}
-exports.Query = Query;
-function Mutation(options) {
-    return function (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)({
-            ...options,
-            mutation: true,
-            resolve: async (params, viewer) => {
-                const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](params, viewer);
-            }
-        });
-    };
-}
-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;
-function ModelResolver(options) {
-    return function (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)({
-            ...options,
-            resolve: async (item, params, viewer) => {
-                const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](item, params, viewer);
-            }
-        });
-    };
-}
-exports.ModelResolver = ModelResolver;
-function getServiceModelResolvers(target) {
-    if (!target.prototype) {
-        throw new helpers_1.UserError('You must pass a class to getResolvers');
-    }
-    return target.prototype.resolvers || {};
-}
-exports.getServiceModelResolvers = getServiceModelResolvers;
-function Resolvers() {
-    return function (target) {
-        (0, services_1.Service)()(target);
-        target.prototype.service = target;
-    };
-}
-exports.Resolvers = Resolvers;
-function Model(typedSchema) {
-    return function (target) {
-        (0, services_1.Service)()(target);
-        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.Model = Model;
+__exportStar(require("./global"), exports);
+__exportStar(require("./model"), exports);

package/lib/service/index.test.js

@@ -11,8 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const services_1 = require("@orion-js/services");
-const typed_model_1 = require("@orion-js/typed-model");
-const _1 = require(".");
+const index_1 = require("./index");
 describe('Resolvers with service injection', () => {
     it('should allow to pass a service as resolve', async () => {
         let ExampleRepo = class ExampleRepo {
@@ -39,7 +38,7 @@ describe('Resolvers with service injection', () => {
             __metadata("design:type", ExampleRepo)
         ], ExampleResolverService.prototype, "repo", void 0);
         __decorate([
-            (0, _1.Query)({
+            (0, index_1.Query)({
                 params: { name: { type: 'string' } },
                 returns: String
             }),
@@ -48,58 +47,17 @@ describe('Resolvers with service injection', () => {
             __metadata("design:returntype", Promise)
         ], ExampleResolverService.prototype, "sayHi", null);
         __decorate([
-            (0, _1.Mutation)({ returns: String }),
+            (0, index_1.Mutation)({ returns: String }),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", []),
             __metadata("design:returntype", Promise)
         ], ExampleResolverService.prototype, "setName", null);
         ExampleResolverService = __decorate([
-            (0, _1.Resolvers)()
+            (0, index_1.Resolvers)()
         ], ExampleResolverService);
-        const resolvers = (0, _1.getServiceResolvers)(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`);
     });
-    it('show allow to pass a service with resolvers to typed model', async () => {
-        let AgeRepo = class AgeRepo {
-            getAge(name) {
-                return `${name} is 100 years old`;
-            }
-        };
-        AgeRepo = __decorate([
-            (0, services_1.Service)()
-        ], AgeRepo);
-        let PersonSchema = class PersonSchema {
-        };
-        __decorate([
-            (0, typed_model_1.Prop)(),
-            __metadata("design:type", String)
-        ], PersonSchema.prototype, "name", void 0);
-        PersonSchema = __decorate([
-            (0, typed_model_1.TypedSchema)()
-        ], PersonSchema);
-        let PersonModel = class PersonModel {
-            async getAge(person) {
-                const result = this.repo.getAge(person.name);
-                return result;
-            }
-        };
-        __decorate([
-            (0, services_1.Inject)(),
-            __metadata("design:type", AgeRepo)
-        ], PersonModel.prototype, "repo", void 0);
-        __decorate([
-            (0, _1.ModelResolver)({ returns: String }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [PersonSchema]),
-            __metadata("design:returntype", Promise)
-        ], PersonModel.prototype, "getAge", null);
-        PersonModel = __decorate([
-            (0, _1.Model)(PersonSchema)
-        ], PersonModel);
-        const model = (0, typed_model_1.getModelForClass)(PersonModel);
-        const item = model.initItem({ name: 'Orion' });
-        expect(await item.getAge()).toBe(`Orion is 100 years old`);
-    });
 });

package/lib/service/model.d.ts

@@ -0,0 +1,14 @@
+import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, ModelResolver } from '@orion-js/resolvers';
+export interface ModelResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: ModelResolverResolve;
+}
+export declare function ModelResolver(options: Omit<ResolverOptions<any>, 'resolve'>): (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]: ModelResolver<GlobalResolverResolve>;
+    };
+};

package/lib/service/model.js

@@ -0,0 +1,44 @@
+"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");
+function ModelResolver(options) {
+    return function (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)({
+            ...options,
+            resolve: async (item, params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](item, params, viewer);
+            }
+        });
+    };
+}
+exports.ModelResolver = ModelResolver;
+function ModelResolvers(typedSchema, options = {}) {
+    return function (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 {};

package/lib/service/model.test.js

@@ -0,0 +1,126 @@
+"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 services_1 = require("@orion-js/services");
+const typed_model_1 = require("@orion-js/typed-model");
+const model_1 = require("./model");
+const http_1 = require("@orion-js/http");
+const supertest_1 = __importDefault(require("supertest"));
+const startGraphQL_1 = __importDefault(require("../startGraphQL"));
+const cleanResolvers_1 = require("../cleanResolvers");
+const global_1 = require("./global");
+describe('Service with graphql models', () => {
+    beforeEach(() => {
+        (0, cleanResolvers_1.cleanResolvers)();
+    });
+    it('show allow to pass a service with resolvers to typed model', async () => {
+        let AgeRepo = class AgeRepo {
+            getAge(name) {
+                return `${name} is 100 years old`;
+            }
+        };
+        AgeRepo = __decorate([
+            (0, services_1.Service)()
+        ], AgeRepo);
+        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);
+        let PersonResolvers = class PersonResolvers {
+            async getAge(person) {
+                const result = this.repo.getAge(person.name);
+                return result;
+            }
+        };
+        __decorate([
+            (0, services_1.Inject)(),
+            __metadata("design:type", AgeRepo)
+        ], PersonResolvers.prototype, "repo", void 0);
+        __decorate([
+            (0, model_1.ModelResolver)({ returns: String }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Person]),
+            __metadata("design:returntype", Promise)
+        ], PersonResolvers.prototype, "getAge", null);
+        PersonResolvers = __decorate([
+            (0, model_1.ModelResolvers)(Person)
+        ], PersonResolvers);
+        const data = (0, model_1.getServiceModelResolvers)(PersonResolvers);
+        const item = { name: 'Orion' };
+        const result = await data.Person.getAge.execute({ parent: item });
+        expect(result).toBe(`Orion is 100 years old`);
+    });
+    it('should startGraphQL and make a request', 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);
+        let PersonResolvers = class PersonResolvers {
+            async sayHi(person) {
+                return `My name is ${person.name}`;
+            }
+        };
+        __decorate([
+            (0, model_1.ModelResolver)({ returns: String }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Person]),
+            __metadata("design:returntype", Promise)
+        ], PersonResolvers.prototype, "sayHi", null);
+        PersonResolvers = __decorate([
+            (0, model_1.ModelResolvers)(Person)
+        ], PersonResolvers);
+        let GlobalResolvers = class GlobalResolvers {
+            async person() {
+                return { name: 'Orion' };
+            }
+        };
+        __decorate([
+            (0, global_1.Query)({ returns: Person }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], GlobalResolvers.prototype, "person", null);
+        GlobalResolvers = __decorate([
+            (0, global_1.Resolvers)()
+        ], GlobalResolvers);
+        const app = (0, http_1.express)();
+        await (0, startGraphQL_1.default)({
+            resolvers: (0, global_1.getServiceResolvers)(GlobalResolvers),
+            modelsResolvers: (0, model_1.getServiceModelResolvers)(PersonResolvers),
+            app
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            operationName: 'testOperation',
+            query: `query testOperation {
+        person {
+          sayHi
+        }
+      }`
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.body.data).toEqual({ person: { sayHi: 'My name is Orion' } });
+    });
+});

package/lib/startGraphQL.test.js

@@ -116,7 +116,7 @@ describe('Test GraphQL Server', () => {
             __metadata("design:type", String)
         ], Params.prototype, "userId", void 0);
         Params = __decorate([
-            (0, typed_model_1.TypedModel)()
+            (0, typed_model_1.TypedSchema)()
         ], Params);
         let User = class User {
         };
@@ -129,7 +129,7 @@ describe('Test GraphQL Server', () => {
             __metadata("design:type", Number)
         ], User.prototype, "age", void 0);
         User = __decorate([
-            (0, typed_model_1.TypedModel)()
+            (0, typed_model_1.TypedSchema)()
         ], User);
         const resolve = async ({ userId }) => {
             if (userId !== '1')

package/lib/startWebsocket.test.js

@@ -73,7 +73,7 @@ const getStartServerOptions = async () => {
         __metadata("design:type", String)
     ], TestParams.prototype, "userId", void 0);
     TestParams = __decorate([
-        (0, typed_model_1.TypedModel)()
+        (0, typed_model_1.TypedSchema)()
     ], TestParams);
     let TestModel = class TestModel {
     };
@@ -86,7 +86,7 @@ const getStartServerOptions = async () => {
         __metadata("design:type", Number)
     ], TestModel.prototype, "age", void 0);
     TestModel = __decorate([
-        (0, typed_model_1.TypedModel)()
+        (0, typed_model_1.TypedSchema)()
     ], TestModel);
     const modelSub = (0, _1.subscription)({
         params: (0, typed_model_1.getModelForClass)(TestParams),
@@ -104,7 +104,7 @@ const getStartServerOptions = async () => {
         resolvers,
         subscriptions
     });
-    return { apolloOptions, subscriptions };
+    return { apolloOptions, resolvers, subscriptions };
 };
 const gqClient = async () => {
     // To make the point clear that we are not opening any ports here we use a randomized string that will not produce a correct port number.

package/lib/types/startGraphQL.d.ts

@@ -1,14 +1,21 @@
-import { GlobalResolversMap } from '@orion-js/models';
+import { GlobalResolversMap, ModelResolversMap } from '@orion-js/models';
 import { express } from '@orion-js/http';
 import { SubscriptionMap } from './subscription';
 import { GraphQLOptions } from 'apollo-server-core';
 export declare type ExecuteGraphQLCache = (req: express.Request, res: express.Response, viewer: object, executeQuery: () => Promise<string>) => Promise<string>;
+export interface ModelsResolversMap {
+    [key: string]: ModelResolversMap;
+}
 declare type SchemaOmits = 'schema' | 'schemaHash' | 'context' | 'useGraphiql';
 export interface StartGraphQLOptions extends Omit<GraphQLOptions, SchemaOmits> {
     /**
      * A map with all the global resolvers
      */
     resolvers: GlobalResolversMap;
+    /**
+     * A map with all the models resolvers. You must only add the models that you want to extend with resolvers.
+     */
+    modelsResolvers?: ModelsResolversMap;
     /**
      * A Map with all global subscriptions
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/graphql",
-  "version": "3.2.5",
+  "version": "3.2.7",
   "main": "lib/index.js",
   "author": "nicolaslopezj",
   "license": "MIT",
@@ -45,5 +45,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9bc5afdfb013bd197709cddec5f17e1da49fdc94"
+  "gitHead": "e46b899b76158da8ec8fedc6e9e39fdd728835d2"
 }