@orion-js/graphql 3.12.0 → 3.13.1

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),
+            modelResolvers: (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/service/otherParams.d.ts

@@ -0,0 +1,7 @@
+import { ResolverMiddleware } from '@orion-js/resolvers';
+import { GlobalResolverPropertyDescriptor } from './global';
+import { ModelResolverPropertyDescriptor } from './model';
+export declare function getTargetMetadata(target: any, propertyKey: string, metadataKey: string): any;
+export declare const UseMiddleware: (metadata: ResolverMiddleware) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;
+export declare const ResolverParams: (metadata: any) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;
+export declare const ResolverReturns: (metadata: any) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;

package/lib/service/otherParams.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolverReturns = exports.ResolverParams = exports.UseMiddleware = exports.getTargetMetadata = void 0;
+function createRegisterResolverMetadata(metadataKey, isArray = false) {
+    return (metadata) => {
+        return (target, propertyKey, descriptor) => {
+            if (!descriptor.value)
+                throw new Error(`You must pass resolver function to ${propertyKey}`);
+            target[metadataKey] = target[metadataKey] || {};
+            if (isArray) {
+                target[metadataKey][propertyKey] = target[metadataKey][propertyKey] || [];
+                // push at the start of the array
+                target[metadataKey][propertyKey].unshift(metadata);
+            }
+            else {
+                target[metadataKey][propertyKey] = metadata;
+            }
+        };
+    };
+}
+function getTargetMetadata(target, propertyKey, metadataKey) {
+    const items = target[metadataKey] || {};
+    return items[propertyKey] || [];
+}
+exports.getTargetMetadata = getTargetMetadata;
+exports.UseMiddleware = createRegisterResolverMetadata('middlewares', true);
+exports.ResolverParams = createRegisterResolverMetadata('params');
+exports.ResolverReturns = createRegisterResolverMetadata('returns');

package/lib/service/subscription.d.ts

@@ -0,0 +1,6 @@
+import { OrionSubscription, OrionSubscriptionOptions } from '../types/subscription';
+export declare function Subscriptions(): ClassDecorator;
+export declare function Subscription<T = any, ReturnType = any>(options: OrionSubscriptionOptions): (object: any, propertyName: string, index?: number) => void;
+export declare function getServiceSubscriptions(target: any): {
+    [key: string]: OrionSubscription;
+};

package/lib/service/subscription.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceSubscriptions = exports.Subscription = exports.Subscriptions = void 0;
+const services_1 = require("@orion-js/services");
+const helpers_1 = require("@orion-js/helpers");
+const __1 = require("..");
+function Subscriptions() {
+    return (target) => {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+        target.prototype.serviceType = 'subscriptions';
+    };
+}
+exports.Subscriptions = Subscriptions;
+function Subscription(options) {
+    return (object, propertyName, index) => {
+        const sub = (0, __1.subscription)({
+            name: propertyName,
+            ...options,
+        });
+        object.subscriptions = object.subscriptions || {};
+        object.subscriptions[propertyName] = sub;
+        services_1.Container.registerHandler({
+            object,
+            propertyName,
+            index,
+            value: _containerInstance => {
+                if (!object.serviceType || object.serviceType !== 'subscriptions') {
+                    throw new Error('You must pass a class decorated with @Subscriptions if you want to use @Subscription');
+                }
+                return sub;
+            },
+        });
+    };
+}
+exports.Subscription = Subscription;
+function getServiceSubscriptions(target) {
+    if (!target.prototype) {
+        throw new helpers_1.UserError('You must pass a class to getSubscriptions');
+    }
+    return target.prototype.subscriptions || {};
+}
+exports.getServiceSubscriptions = getServiceSubscriptions;

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

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

package/lib/service/subscription.test.js

@@ -0,0 +1,55 @@
+"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 index_1 = require("./index");
+const services_1 = require("@orion-js/services");
+const typed_model_1 = require("@orion-js/typed-model");
+describe('Subscriptions classes', () => {
+    it('should get the subscriptions using services', async () => {
+        let Params = class Params {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Params.prototype, "name", void 0);
+        Params = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Params);
+        let User = class User {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], User.prototype, "name", void 0);
+        User = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], User);
+        let ExampleSubscriptionsService = class ExampleSubscriptionsService {
+        };
+        __decorate([
+            (0, index_1.Subscription)({
+                params: Params,
+                returns: User
+            }),
+            __metadata("design:type", Object)
+        ], ExampleSubscriptionsService.prototype, "onUserCreated", void 0);
+        ExampleSubscriptionsService = __decorate([
+            (0, index_1.Subscriptions)()
+        ], ExampleSubscriptionsService);
+        const subscriptions = (0, index_1.getServiceSubscriptions)(ExampleSubscriptionsService);
+        expect(subscriptions.onUserCreated).toBeDefined();
+        const instance = (0, services_1.getInstance)(ExampleSubscriptionsService);
+        expect(instance.onUserCreated.publish).toBeDefined();
+        expect(instance.onUserCreated.name).toBe('onUserCreated');
+        // await instance.onUserCreated.publish({name: 'test'}, {name: 'test'})
+    });
+});

package/lib/startGraphQL.d.ts

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

package/lib/startGraphQL.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const startGraphiQL_1 = __importDefault(require("./startGraphiQL"));
+const getApolloOptions_1 = __importDefault(require("./getApolloOptions"));
+const startWebsocket_1 = __importDefault(require("./startWebsocket"));
+const http_1 = require("@orion-js/http");
+const server_1 = require("@apollo/server");
+const express4_1 = require("@apollo/server/express4");
+const drainHttpServer_1 = require("@apollo/server/plugin/drainHttpServer");
+async function default_1(options) {
+    const apolloOptions = await (0, getApolloOptions_1.default)(options);
+    const app = options.app || (0, http_1.getApp)();
+    const httpServer = (0, http_1.getServer)();
+    if (options.useGraphiql) {
+        (0, startGraphiQL_1.default)(apolloOptions, options);
+    }
+    const subPlugins = (0, startWebsocket_1.default)(apolloOptions, options);
+    const drainPlugins = httpServer ? [(0, drainHttpServer_1.ApolloServerPluginDrainHttpServer)({ httpServer })] : [];
+    const server = new server_1.ApolloServer({
+        ...apolloOptions,
+        plugins: [...(apolloOptions.plugins || []), ...drainPlugins, ...subPlugins]
+    });
+    await server.start();
+    const middleware = (0, express4_1.expressMiddleware)(server, {
+        // @ts-expect-error
+        context: ({ req, res }) => req._viewer
+    });
+    (0, http_1.registerRoute)((0, http_1.route)({
+        app,
+        method: 'all',
+        path: '/graphql',
+        bodyParser: 'json',
+        async resolve(req, res, viewer) {
+            // @ts-expect-error
+            req._viewer = viewer;
+            return middleware(req, res, req.next);
+        }
+    }));
+}
+exports.default = default_1;

package/lib/startGraphQL.test.d.ts

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