@orion-js/typed-model 3.2.1 → 3.2.2

package/lib/decorators/index.d.ts

@@ -1,3 +1,4 @@
 export * from './typedModel';
+export * from './typedSchema';
 export * from './prop';
 export * from './resolver';

package/lib/decorators/index.js

@@ -11,5 +11,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./typedModel"), exports);
+__exportStar(require("./typedSchema"), exports);
 __exportStar(require("./prop"), exports);
 __exportStar(require("./resolver"), exports);

package/lib/decorators/resolver.d.ts

@@ -1,2 +1,5 @@
 import { ModelResolver, ModelResolverResolve } from '@orion-js/resolvers';
+/**
+ * @deprecated Please use a @TypedSchema and a @Model a @ModelResolver instead
+ */
 export declare function ResolverProp(options: ModelResolver<ModelResolverResolve>): PropertyDecorator;

package/lib/decorators/resolver.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolverProp = void 0;
 const metadataStorage_1 = require("../storage/metadataStorage");
+/**
+ * @deprecated Please use a @TypedSchema and a @Model a @ModelResolver instead
+ */
 function ResolverProp(options) {
     return (classDef, propertyKey) => {
         metadataStorage_1.MetadataStorage.addResolverMetadata({ target: classDef.constructor, propertyKey, options });

package/lib/decorators/typedModel.d.ts

@@ -1,2 +1,5 @@
 import { TypedModelOptions } from '../storage/metadataStorage';
+/**
+ * @deprecated Please use @TypedSchema instead
+ */
 export declare function TypedModel(options?: TypedModelOptions): ClassDecorator;

package/lib/decorators/typedModel.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedModel = void 0;
 const __1 = require("..");
 const metadataStorage_1 = require("../storage/metadataStorage");
+/**
+ * @deprecated Please use @TypedSchema instead
+ */
 function TypedModel(options = {}) {
     return target => {
         metadataStorage_1.MetadataStorage.addSchemaMetadata({ target, options });

package/lib/decorators/typedSchema.d.ts

@@ -0,0 +1,2 @@
+import { TypedModelOptions } from '../storage/metadataStorage';
+export declare function TypedSchema(options?: TypedModelOptions): ClassDecorator;

package/lib/decorators/typedSchema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedSchema = void 0;
+const __1 = require("..");
+const metadataStorage_1 = require("../storage/metadataStorage");
+function TypedSchema(options = {}) {
+    return target => {
+        metadataStorage_1.MetadataStorage.addSchemaMetadata({ target, options });
+        // @ts-expect-error this is a trick to make it work in resolvers without having to call getModelForClass
+        target.getModel = () => (0, __1.getModelForClass)(target);
+    };
+}
+exports.TypedSchema = TypedSchema;

package/lib/factories/getModelForClass.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModelForClass = void 0;
 /* eslint-disable @typescript-eslint/ban-types */
 const models_1 = require("@orion-js/models");
+const __1 = require("..");
 const metadataStorage_1 = require("../storage/metadataStorage");
 const processSchemaForProp_1 = require("./helpers/processSchemaForProp");
 const modelCache = new Map();
@@ -13,6 +14,11 @@ function processModelSchemaForProp(prop) {
     return (0, processSchemaForProp_1.processSchemaForProp)(prop);
 }
 function getModelForClass(target) {
+    let modelResolvers = null;
+    if (target.prototype.typedModel) {
+        modelResolvers = (0, __1.getServiceModelResolvers)(target);
+        target = target.prototype.typedModel;
+    }
     const schemaId = target.__schemaId;
     if (modelCache.has(schemaId)) {
         return modelCache.get(schemaId);
@@ -37,7 +43,10 @@ function getModelForClass(target) {
     const model = (0, models_1.createModel)({
         name: target.name,
         schema,
-        resolvers: resolverMap
+        resolvers: {
+            ...resolverMap,
+            ...modelResolvers
+        }
     });
     modelCache.set(schemaId, model);
     return model;

package/lib/index.d.ts

@@ -1,3 +1,3 @@
 export * from './decorators';
 export * from './factories';
-export * from './resolvers';
+export * from './services';

package/lib/index.js

@@ -12,4 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./factories"), exports);
-__exportStar(require("./resolvers"), exports);
+__exportStar(require("./services"), exports);

package/lib/services/echoes.d.ts

@@ -0,0 +1,10 @@
+import { Echo as EchoType, EchoConfig } from '@orion-js/echoes';
+export declare function Echoes(): ClassDecorator;
+export interface EchoesPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: EchoConfig['resolve'];
+}
+export declare function EchoRequest(options?: Omit<EchoConfig, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: EchoesPropertyDescriptor) => void;
+export declare function EchoEvent(options?: Omit<EchoConfig, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: EchoesPropertyDescriptor) => void;
+export declare function getServiceEchoes(target: any): {
+    [key: string]: EchoType;
+};

package/lib/services/echoes.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceEchoes = exports.EchoEvent = exports.EchoRequest = exports.Echoes = void 0;
+const services_1 = require("@orion-js/services");
+const echoes_1 = require("@orion-js/echoes");
+function Echoes() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Echoes = Echoes;
+function EchoRequest(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, echoes_1.echo)({
+            ...options,
+            type: 'request',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.EchoRequest = EchoRequest;
+function EchoEvent(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, echoes_1.echo)({
+            ...options,
+            type: 'event',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.EchoEvent = EchoEvent;
+function getServiceEchoes(target) {
+    if (!target.prototype) {
+        throw new Error('You must pass a class to getServiceRoutes');
+    }
+    return target.prototype.echoes || {};
+}
+exports.getServiceEchoes = getServiceEchoes;

package/lib/services/echoes.test.d.ts

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

package/lib/services/echoes.test.js

@@ -0,0 +1,50 @@
+"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 });
+const echoes_1 = require("./echoes");
+describe('Echoes with service injections', () => {
+    it('Should define a echoes map using services', async () => {
+        let ExampleEchoesService = class ExampleEchoesService {
+            async echo() {
+                return 1;
+            }
+            async echoEvent() {
+                return 2;
+            }
+        };
+        __decorate([
+            (0, echoes_1.EchoRequest)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleEchoesService.prototype, "echo", null);
+        __decorate([
+            (0, echoes_1.EchoEvent)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleEchoesService.prototype, "echoEvent", null);
+        ExampleEchoesService = __decorate([
+            (0, echoes_1.Echoes)()
+        ], ExampleEchoesService);
+        const echoes = (0, echoes_1.getServiceEchoes)(ExampleEchoesService);
+        expect(echoes).toMatchObject({
+            echo: {
+                type: 'request',
+                onRequest: expect.any(Function)
+            },
+            echoEvent: {
+                type: 'event',
+                resolve: expect.any(Function)
+            }
+        });
+    });
+});

package/lib/services/http.d.ts

@@ -0,0 +1,9 @@
+import { OrionRouteOptions, Route as RouteType } from '@orion-js/http';
+export declare function Routes(): ClassDecorator;
+export interface RoutesPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: OrionRouteOptions['resolve'];
+}
+export declare function Route(options: Omit<OrionRouteOptions, 'resolve'>): (target: any, propertyKey: string, descriptor: RoutesPropertyDescriptor) => void;
+export declare function getServiceRoutes(target: any): {
+    [key: string]: RouteType;
+};

package/lib/services/http.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceRoutes = exports.Route = exports.Routes = void 0;
+const services_1 = require("@orion-js/services");
+const http_1 = require("@orion-js/http");
+function Routes() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Routes = Routes;
+function Route(options) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.routes = target.routes || {};
+        target.routes[propertyKey] = (0, http_1.route)({
+            ...options,
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.Route = Route;
+function getServiceRoutes(target) {
+    if (!target.prototype) {
+        throw new Error('You must pass a class to getServiceRoutes');
+    }
+    return target.prototype.routes || {};
+}
+exports.getServiceRoutes = getServiceRoutes;

package/lib/services/http.test.d.ts

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

package/lib/services/http.test.js

@@ -0,0 +1,40 @@
+"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 });
+const http_1 = require("./http");
+describe('Routes with service injections', () => {
+    it('Should define a routes map using services', async () => {
+        let RoutesService = class RoutesService {
+            async route1() {
+                return {
+                    statusCode: 200,
+                    body: 'route1'
+                };
+            }
+        };
+        __decorate([
+            (0, http_1.Route)({ method: 'get', path: '/route1' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], RoutesService.prototype, "route1", null);
+        RoutesService = __decorate([
+            (0, http_1.Routes)()
+        ], RoutesService);
+        const routes = (0, http_1.getServiceRoutes)(RoutesService);
+        expect(routes).toMatchObject({
+            route1: {
+                method: 'get',
+                path: '/route1'
+            }
+        });
+    });
+});

package/lib/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './resolvers';
+export * from './echoes';
+export * from './http';
+export * from './jobs';

package/lib/services/index.js

@@ -0,0 +1,16 @@
+"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 });
+__exportStar(require("./resolvers"), exports);
+__exportStar(require("./echoes"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./jobs"), exports);

package/lib/services/jobs.d.ts

@@ -0,0 +1,9 @@
+import { JobDefinition } from '@orion-js/dogs';
+export declare function Jobs(): ClassDecorator;
+export interface JobsPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: JobDefinition['resolve'];
+}
+export declare function Job(options: Omit<JobDefinition, 'resolve'>): (target: any, propertyKey: string, descriptor: JobsPropertyDescriptor) => void;
+export declare function getServiceJobs(target: any): {
+    [key: string]: JobDefinition;
+};

package/lib/services/jobs.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceJobs = exports.Job = exports.Jobs = void 0;
+const services_1 = require("@orion-js/services");
+const dogs_1 = require("@orion-js/dogs");
+function Jobs() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Jobs = Jobs;
+function Job(options) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, dogs_1.defineJob)({
+            ...options,
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.Job = Job;
+function getServiceJobs(target) {
+    if (!target.prototype) {
+        throw new Error('You must pass a class to getServiceRoutes');
+    }
+    return target.prototype.echoes || {};
+}
+exports.getServiceJobs = getServiceJobs;

package/lib/services/jobs.test.d.ts

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

package/lib/services/jobs.test.js

@@ -0,0 +1,37 @@
+"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 });
+const jobs_1 = require("./jobs");
+describe('Jobs (dogs) with service injections', () => {
+    it('Should define a jobs map using services', async () => {
+        let ExampleJobsService = class ExampleJobsService {
+            async job1() {
+                return {};
+            }
+        };
+        __decorate([
+            (0, jobs_1.Job)({ type: 'event' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleJobsService.prototype, "job1", null);
+        ExampleJobsService = __decorate([
+            (0, jobs_1.Jobs)()
+        ], ExampleJobsService);
+        const jobs = (0, jobs_1.getServiceJobs)(ExampleJobsService);
+        expect(jobs).toMatchObject({
+            job1: {
+                type: 'event',
+                resolve: expect.any(Function)
+            }
+        });
+    });
+});

package/lib/services/resolvers.d.ts

@@ -0,0 +1,18 @@
+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(typedModel: any): ClassDecorator;

package/lib/{resolvers/index.js → services/resolvers.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServiceModelResolvers = exports.CreateModelResolver = exports.getServiceResolvers = exports.CreateResolver = void 0;
+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 CreateResolver(options) {
+function Query(options) {
     return function (target, propertyKey, descriptor) {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
@@ -12,13 +12,29 @@ function CreateResolver(options) {
         target.resolvers[propertyKey] = (0, resolvers_1.resolver)({
             ...options,
             resolve: async (params, viewer) => {
-                const instance = (0, services_1.getInstance)(options.thisService);
+                const instance = (0, services_1.getInstance)(target.service);
                 return await instance[propertyKey](params, viewer);
             }
         });
     };
 }
-exports.CreateResolver = CreateResolver;
+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');
@@ -26,7 +42,7 @@ function getServiceResolvers(target) {
     return target.prototype.resolvers || {};
 }
 exports.getServiceResolvers = getServiceResolvers;
-function CreateModelResolver(options) {
+function ModelResolver(options) {
     return function (target, propertyKey, descriptor) {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
@@ -34,13 +50,13 @@ function CreateModelResolver(options) {
         target.resolvers[propertyKey] = (0, resolvers_1.modelResolver)({
             ...options,
             resolve: async (item, params, viewer) => {
-                const instance = (0, services_1.getInstance)(options.thisService);
+                const instance = (0, services_1.getInstance)(target.service);
                 return await instance[propertyKey](item, params, viewer);
             }
         });
     };
 }
-exports.CreateModelResolver = CreateModelResolver;
+exports.ModelResolver = ModelResolver;
 function getServiceModelResolvers(target) {
     if (!target.prototype) {
         throw new helpers_1.UserError('You must pass a class to getResolvers');
@@ -48,3 +64,20 @@ function getServiceModelResolvers(target) {
     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(typedModel) {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.typedModel = typedModel;
+        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;

package/lib/{resolvers/index.test.js → services/resolvers.test.js}

@@ -13,10 +13,9 @@ require("reflect-metadata");
 const services_1 = require("@orion-js/services");
 const __1 = require("..");
 const factories_1 = require("../factories");
-const _1 = require(".");
+const resolvers_1 = require("./resolvers");
 describe('Resolvers with service injection', () => {
     it('should allow to pass a service as resolve', async () => {
-        var ExampleResolverService_1;
         let ExampleRepo = class ExampleRepo {
             getLastName() {
                 return 'Lopez';
@@ -25,10 +24,13 @@ describe('Resolvers with service injection', () => {
         ExampleRepo = __decorate([
             (0, services_1.Service)()
         ], ExampleRepo);
-        let ExampleResolverService = ExampleResolverService_1 = class ExampleResolverService {
+        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`;
             }
@@ -38,8 +40,7 @@ describe('Resolvers with service injection', () => {
             __metadata("design:type", ExampleRepo)
         ], ExampleResolverService.prototype, "repo", void 0);
         __decorate([
-            (0, _1.CreateResolver)({
-                thisService: ExampleResolverService_1,
+            (0, resolvers_1.Query)({
                 params: { name: { type: 'string' } },
                 returns: String
             }),
@@ -47,16 +48,21 @@ describe('Resolvers with service injection', () => {
             __metadata("design:paramtypes", [Object]),
             __metadata("design:returntype", Promise)
         ], ExampleResolverService.prototype, "sayHi", null);
-        ExampleResolverService = ExampleResolverService_1 = __decorate([
-            (0, services_1.Service)()
+        __decorate([
+            (0, resolvers_1.Mutation)({ returns: String }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "setName", null);
+        ExampleResolverService = __decorate([
+            (0, resolvers_1.Resolvers)()
         ], ExampleResolverService);
-        const resolvers = (0, _1.getServiceResolvers)(ExampleResolverService);
+        const resolvers = (0, resolvers_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 () => {
-        var PersonResolvers_1;
         let AgeRepo = class AgeRepo {
             getAge(name) {
                 return `${name} is 100 years old`;
@@ -65,7 +71,16 @@ describe('Resolvers with service injection', () => {
         AgeRepo = __decorate([
             (0, services_1.Service)()
         ], AgeRepo);
-        let PersonResolvers = PersonResolvers_1 = class PersonResolvers {
+        let PersonSchema = class PersonSchema {
+        };
+        __decorate([
+            (0, __1.Prop)(),
+            __metadata("design:type", String)
+        ], PersonSchema.prototype, "name", void 0);
+        PersonSchema = __decorate([
+            (0, __1.TypedSchema)()
+        ], PersonSchema);
+        let PersonModel = class PersonModel {
             async getAge(person) {
                 const result = this.repo.getAge(person.name);
                 return result;
@@ -74,29 +89,17 @@ describe('Resolvers with service injection', () => {
         __decorate([
             (0, services_1.Inject)(),
             __metadata("design:type", AgeRepo)
-        ], PersonResolvers.prototype, "repo", void 0);
+        ], PersonModel.prototype, "repo", void 0);
         __decorate([
-            (0, _1.CreateModelResolver)({
-                thisService: PersonResolvers_1,
-                returns: String
-            }),
+            (0, resolvers_1.ModelResolver)({ returns: String }),
             __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object]),
+            __metadata("design:paramtypes", [PersonSchema]),
             __metadata("design:returntype", Promise)
-        ], PersonResolvers.prototype, "getAge", null);
-        PersonResolvers = PersonResolvers_1 = __decorate([
-            (0, services_1.Service)()
-        ], PersonResolvers);
-        let Person = class Person {
-        };
-        __decorate([
-            (0, __1.Prop)(),
-            __metadata("design:type", String)
-        ], Person.prototype, "name", void 0);
-        Person = __decorate([
-            (0, __1.TypedModel)({ resolversService: PersonResolvers })
-        ], Person);
-        const model = (0, factories_1.getModelForClass)(Person);
+        ], PersonModel.prototype, "getAge", null);
+        PersonModel = __decorate([
+            (0, resolvers_1.Model)(PersonSchema)
+        ], PersonModel);
+        const model = (0, factories_1.getModelForClass)(PersonModel);
         const item = model.initItem({ name: 'Orion' });
         expect(await item.getAge()).toBe(`Orion is 100 years old`);
     });

package/lib/storage/metadataStorage.d.ts

@@ -4,9 +4,7 @@ import { ModelResolver, ModelResolverResolve } from '@orion-js/resolvers';
 export declare type PropertiesMap = {
     [key: string]: PropOptions;
 };
-export interface TypedModelOptions {
-    resolversService?: any;
-}
+export declare type TypedModelOptions = Record<string, never>;
 export declare class MetadataStorageHandler {
     private schemas;
     private getSchema;

package/lib/storage/metadataStorage.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataStorage = exports.MetadataStorageHandler = void 0;
 const errors_1 = require("../errors");
 const helpers_1 = require("@orion-js/helpers");
-const resolvers_1 = require("../resolvers");
 class MetadataStorageHandler {
     constructor() {
         this.schemas = new Map();
@@ -25,12 +24,6 @@ class MetadataStorageHandler {
     }
     addSchemaMetadata({ target, options }) {
         const schema = this.getSchema(target);
-        if (options.resolversService) {
-            const resolversService = (0, resolvers_1.getServiceModelResolvers)(options.resolversService);
-            Object.entries(resolversService).forEach(([key, resolver]) => {
-                schema.resolvers[key] = resolver;
-            });
-        }
         schema.options = options;
     }
     addPropMetadata({ target, propertyKey, options }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/typed-model",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,7 +17,10 @@
     "test": "jest --config jest.config.js"
   },
   "dependencies": {
+    "@orion-js/dogs": "^3.2.2",
+    "@orion-js/echoes": "^3.2.2",
     "@orion-js/helpers": "^3.2.0",
+    "@orion-js/http": "^3.2.0",
     "@orion-js/models": "^3.2.0",
     "@orion-js/resolvers": "^3.2.0",
     "@orion-js/schema": "^3.2.0",
@@ -34,11 +37,12 @@
     "eslint": "8.2.0",
     "eslint-plugin-import": "2.25.3",
     "jest": "27.3.1",
+    "kafkajs": "^1.16.0",
     "ts-jest": "27.0.7",
     "typescript": "^4.4.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "582bfdbd33b30a1259cc2c35f46111992aeeff81"
+  "gitHead": "95d6f776514b789bb1c267ee9fbe3b4eaa4c961d"
 }

package/lib/resolvers/index.d.ts

@@ -1,19 +0,0 @@
-import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, Resolver, ModelResolver } from '@orion-js/resolvers';
-export interface GlobalResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
-    value?: GlobalResolverResolve;
-}
-export declare function CreateResolver(options: Omit<ResolverOptions<any>, 'resolve'> & {
-    thisService: any;
-}): (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 CreateModelResolver(options: Omit<ResolverOptions<any>, 'resolve'> & {
-    thisService: any;
-}): (target: any, propertyKey: string, descriptor: ModelResolverPropertyDescriptor) => void;
-export declare function getServiceModelResolvers(target: any): {
-    [key: string]: ModelResolver<GlobalResolverResolve>;
-};