@webresto/graphql 1.3.7 → 1.4.0

package/src/resolvers/userLocation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// const userAuth = sails.config.restographql.authService;
+const jwt_1 = require("../../lib/jwt");
+const adapters_1 = require("@webresto/core/adapters");
+let captchaAdapter = adapters_1.Captcha.getAdapter();
+const graphqlHelper_1 = require("../../lib/graphqlHelper");
+graphqlHelper_1.default.addType(`#graphql    
+  input InputLocation {
+    street: String
+    streetId: String
+    home: String!
+    name: String
+    city: String
+    housing: String
+    isDefault: Boolean
+    index: String
+    entrance: String
+    floor: String
+    apartment: String
+    doorphone: String
+    comment: String
+    customFields: Json
+  } 
+  `);
+exports.default = {
+    Mutation: {
+        // Authentication required
+        locationCreate: {
+            def: `#graphql
+      locationCreate(
+        location: InputLocation!
+      ): Boolean`,
+            fn: async (parent, payload, context) => {
+                const auth = await jwt_1.JWTAuth.verify(context.connectionParams.authorization);
+                if (!payload.location.streetId && !payload.location.street)
+                    throw 'streetId or street are required';
+                const userLocation = {
+                    ...payload.location,
+                    ...{ street: payload.location.streetId }
+                };
+                await UserLocation.create({ ...userLocation, user: auth.userId }).fetch();
+                return true;
+            }
+        },
+        // Authentication required
+        locationSetIsDefault: {
+            def: `#graphql
+      locationSetIsDefault(
+        locationId: String!
+      ): Boolean`,
+            fn: async (parent, payload, context) => {
+                const auth = await jwt_1.JWTAuth.verify(context.connectionParams.authorization);
+                const user = (await UserLocation.findOne({ id: payload.locationId })).user;
+                if (user !== auth.userId)
+                    throw `User location not found`;
+                await UserLocation.update({ id: payload.locationId }, { isDefault: true }).fetch();
+                return true;
+            }
+        },
+        // Authentication required
+        locationDelete: {
+            def: `#graphql
+      locationDelete(
+        locationId: String!
+      ): Boolean`,
+            fn: async (parent, payload, context) => {
+                const auth = await jwt_1.JWTAuth.verify(context.connectionParams.authorization);
+                await UserLocation.destroy({ id: payload.locationId }).fetch();
+                return true;
+            }
+        }
+    }
+};

package/src/resolvers/userLocation.ts

@@ -0,0 +1,125 @@
+// const userAuth = sails.config.restographql.authService;
+import { JWTAuth } from "../../lib/jwt";
+import { Phone } from "@webresto/core/models/User";
+import User from "@webresto/core/models/User";
+import { Captcha } from "@webresto/core/adapters";
+import { ResolvedCaptcha } from "@webresto/core/adapters/captcha/CaptchaAdapter";
+import { Message, Action, Response } from "../../types/primitives";
+let captchaAdapter = Captcha.getAdapter();
+
+import graphqlHelper from "../../lib/graphqlHelper";
+
+// define UserResponse
+interface UserResponse extends Response {
+  user: User | undefined;
+}
+
+
+interface InputLocation {
+  street: string
+  streetId: string
+  home: string
+  name?: string
+  city?: string
+  housing?: string
+  isDefault?: boolean
+  index?: string
+  entrance?: string
+  floor?: string
+  apartment?: string
+  doorphone?: string
+  comment?: string
+  customData?: {
+    [key: string]: string | boolean | number;
+  }
+}
+
+graphqlHelper.addType(`#graphql    
+  input InputLocation {
+    street: String
+    streetId: String
+    home: String!
+    name: String
+    city: String
+    housing: String
+    isDefault: Boolean
+    index: String
+    entrance: String
+    floor: String
+    apartment: String
+    doorphone: String
+    comment: String
+    customFields: Json
+  } 
+  `);
+
+export default {
+  Mutation: {
+    // Authentication required
+    locationCreate: {
+      def: `#graphql
+      locationCreate(
+        location: InputLocation!
+      ): Boolean`,
+      fn: async (
+        parent: any,
+        payload: { location: InputLocation },
+        context: { connectionParams: { authorization: string } }
+      ): Promise<boolean> => {
+        const auth = await JWTAuth.verify(
+          context.connectionParams.authorization
+        );
+        
+        if (!payload.location.streetId && !payload.location.street) throw 'streetId or street are required'
+
+        const userLocation = {
+          ...payload.location,
+          ...{street: payload.location.streetId}
+        }
+        await UserLocation.create({...userLocation, user: auth.userId}).fetch()
+        return true
+      }
+    },
+    // Authentication required
+    locationSetIsDefault: {
+      def: `#graphql
+      locationSetIsDefault(
+        locationId: String!
+      ): Boolean`,
+      fn: async (
+        parent: any,
+        payload: { locationId: string },
+        context: { connectionParams: { authorization: string } }
+      ): Promise<boolean> => {
+        const auth = await JWTAuth.verify(
+          context.connectionParams.authorization
+        );
+
+        const user = (await UserLocation.findOne({id: payload.locationId})).user as string
+        if (user !== auth.userId) throw `User location not found`
+
+        await UserLocation.update({id: payload.locationId}, {isDefault: true}).fetch()
+        return true
+      }
+    },
+    // Authentication required
+    locationDelete: {
+      def: `#graphql
+      locationDelete(
+        locationId: String!
+      ): Boolean`,
+      fn: async (
+        parent: any,
+        payload: { locationId: string },
+        context: { connectionParams: { authorization: string } }
+      ): Promise<boolean> => {
+        const auth = await JWTAuth.verify(
+          context.connectionParams.authorization
+        );
+        
+        await UserLocation.destroy({id: payload.locationId}).fetch()
+        return true
+      }
+    }
+  }
+};

package/src/resolvers/userOTPrequest.d.ts

@@ -0,0 +1,21 @@
+import { ResolvedCaptcha } from "@webresto/core/adapters/captcha/CaptchaAdapter";
+import { Message, Action } from "../../types/primitives";
+type OTPResponse = {
+    id: Number;
+    nextOTPSeconds: Number;
+    message: Message;
+    action?: Action;
+};
+type OTPPayload = {
+    login: string;
+    captcha: ResolvedCaptcha;
+};
+declare const _default: {
+    Mutation: {
+        OTPRequest: {
+            def: string;
+            fn: (parent: any, payload: OTPPayload, context: any) => Promise<OTPResponse>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/userOTPrequest.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// const userAuth = sails.config.restographql.authService;
+const adapters_1 = require("@webresto/core/adapters");
+const adapters_2 = require("@webresto/core/adapters");
+let captchaAdapter = adapters_1.Captcha.getAdapter();
+let OTPAdapter = adapters_2.OTP.getAdapter();
+const graphqlHelper_1 = require("../../lib/graphqlHelper");
+graphqlHelper_1.default.addType(`#graphql    
+  type OTPResponse {
+    id: String
+    nextOTPAfterSeconds: Int
+    message: Message
+    action: Action
+  }
+  `);
+exports.default = {
+    Mutation: {
+        OTPRequest: {
+            def: `#graphql
+      OTPRequest(
+
+        "Phone login is 'phone.code+phone.number' for phone only digits"
+        login: String!,
+
+        "Solved captcha for label 'otpRequest:%login%'"
+        captcha: Captcha!
+
+        ): OTPResponse`,
+            fn: async (parent, payload, context) => {
+                console.log(!(await captchaAdapter).check(payload.captcha, `otprequest:${payload.login}`));
+                if (!(await captchaAdapter).check(payload.captcha, `otprequest:${payload.login}`)) {
+                    throw `bad captcha`;
+                }
+                let otp = await (await OTPAdapter).get(payload.login);
+                let message = {
+                    deviceId: null,
+                    title: context.i18n.__("Success"),
+                    type: "info",
+                    message: context.i18n.__("OTP sended")
+                };
+                // Here should be Emmiter for midificate Action And Message
+                let action = {
+                    deviceId: null,
+                    type: "",
+                    data: {}
+                };
+                return {
+                    id: otp.id,
+                    nextOTPSeconds: 300,
+                    message: message,
+                    action: action
+                };
+            },
+        }
+    }
+};

package/src/resolvers/userOTPrequest.ts

@@ -0,0 +1,75 @@
+// const userAuth = sails.config.restographql.authService;
+import { Captcha } from "@webresto/core/adapters";
+import { OTP } from "@webresto/core/adapters"
+import { ResolvedCaptcha } from "@webresto/core/adapters/captcha/CaptchaAdapter"
+import { Message, Action, Response } from "../../types/primitives";
+let captchaAdapter = Captcha.getAdapter();
+let OTPAdapter = OTP.getAdapter();
+
+import graphqlHelper from "../../lib/graphqlHelper";
+
+type OTPResponse = {
+  id: Number
+  nextOTPSeconds: Number
+  message: Message
+  action?: Action
+}
+
+graphqlHelper.addType(`#graphql    
+  type OTPResponse {
+    id: String
+    nextOTPAfterSeconds: Int
+    message: Message
+    action: Action
+  }
+  `)
+
+type OTPPayload = { 
+  login: string
+  captcha: ResolvedCaptcha
+}
+
+export default {
+  Mutation: {
+    OTPRequest: {
+      def: `#graphql
+      OTPRequest(
+
+        "Phone login is 'phone.code+phone.number' for phone only digits"
+        login: String!,
+
+        "Solved captcha for label 'otpRequest:%login%'"
+        captcha: Captcha!
+
+        ): OTPResponse`,
+      fn: async (parent: any, payload: OTPPayload, context: any): Promise<OTPResponse> => {
+        console.log(!(await captchaAdapter).check(payload.captcha, `otprequest:${payload.login}`))
+        if (!(await captchaAdapter).check(payload.captcha, `otprequest:${payload.login}`)) { 
+          throw `bad captcha`
+        }
+        let otp = await (await OTPAdapter).get(payload.login);
+        let message: Message = {
+          deviceId: null,
+          title: context.i18n.__("Success"),
+          type: "info",
+          message: context.i18n.__("OTP sended")
+        } 
+
+        // Here should be Emmiter for midificate Action And Message
+        let action: Action = {
+          deviceId: null,
+          type: "",
+          data: {}
+        }
+
+
+        return {
+          id: otp.id,
+          nextOTPSeconds: 300,
+          message: message,
+          action: action
+        };
+      },
+    }
+  }
+};

package/test/e2e_helper.js

@@ -0,0 +1,157 @@
+"use strict";
+//
+// E2E Test Setup
+// e2e_helpers.js
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGQL = exports.createSubscription = exports.TestApolloClient = void 0;
+const utilities_1 = require("@apollo/client/utilities");
+const ws_1 = require("@apollo/client/link/ws");
+const cross_fetch_1 = require("cross-fetch");
+const ws = require("ws");
+const axios_1 = require("axios");
+const client_1 = require("@apollo/client");
+const host = "127.0.0.1";
+const port = process.env.PORT === undefined ? "42772" : process.env.PORT;
+/**
+ * Our test apollo client <3
+ *
+ * @export
+ * @class TestApolloClient
+ * @extends {ApolloClient<any>}
+ */
+class TestApolloClient extends client_1.ApolloClient {
+    wsLink;
+    constructor(serverInfo) {
+        const { host } = serverInfo;
+        const wsLink = new ws_1.WebSocketLink({
+            // @TODO: Update WS url
+            uri: `ws://${host}:${port}/graphql`,
+            webSocketImpl: ws,
+            options: {
+                reconnect: false,
+                connectionParams: {
+                    Authorization: "Bearer dummy",
+                },
+            },
+        });
+        const httpLink = new client_1.HttpLink({
+            // @TODO: update HTTP url
+            uri: `http://${host}:${port}/graphql`,
+            fetch: cross_fetch_1.default,
+        });
+        const splitLink = (0, client_1.split)(({ query }) => {
+            const definition = (0, utilities_1.getMainDefinition)(query);
+            return (definition.kind === "OperationDefinition" &&
+                definition.operation === "subscription");
+        }, wsLink, httpLink);
+        super({
+            link: splitLink,
+            cache: new client_1.InMemoryCache(),
+        });
+        this.wsLink = wsLink;
+    }
+    stop() {
+        super.stop();
+        //
+        // This is important, or else your test session will never close.
+        // Also the reason it inherits from ApolloClient instead of just creating it
+        // That way we can sneak in that WS closing
+        //
+        this.wsLink.subscriptionClient.close();
+    }
+}
+exports.TestApolloClient = TestApolloClient;
+/**
+ * Helper to create a subscription with a bunch of handy methods
+ *
+ * @export
+ * @param {SubscriptionTestParams} params
+ * @returns
+ */
+function createSubscription(params) {
+    const results = [];
+    let error;
+    let observer = params.client
+        .subscribe({
+        errorPolicy: "all",
+        query: params.query,
+        variables: params.variables || {},
+    })
+        .subscribe({
+        next(data) {
+            results.push(data);
+        },
+        error: (err) => {
+            error = err;
+        },
+    });
+    return {
+        results,
+        observer,
+        disconnect() {
+            observer.unsubscribe();
+        },
+        wait(ms = 100) {
+            return new Promise((done) => {
+                setTimeout(() => {
+                    done(null);
+                }, ms);
+            });
+        },
+        waitForResults(opts = {}) {
+            return new Promise((done, fail) => {
+                let step = 50;
+                let sum = 0;
+                let timeout = opts.timeout ?? 3000;
+                let len = opts.len ?? 1;
+                const interval = setInterval(() => {
+                    if (!error && results.length >= len) {
+                        clearInterval(interval);
+                        return done(results);
+                    }
+                    if (error || sum >= timeout) {
+                        error =
+                            error ||
+                                new Error(`Timeout: subscription did not receive the expected results after ${timeout}ms`);
+                        clearInterval(interval);
+                        return fail(error);
+                    }
+                    sum += step;
+                }, step);
+            });
+        },
+        get triggerCount() {
+            return results.length;
+        },
+        get error() {
+            return error;
+        },
+    };
+}
+exports.createSubscription = createSubscription;
+async function runGQL(query, headersOrToken, variables) {
+    return new Promise((resolve, reject) => {
+        let headers = headersOrToken;
+        // Except stringToken
+        if (typeof headersOrToken === "string") {
+            headers = {
+                Authorization: `${headersOrToken}`,
+            };
+        }
+        axios_1.default
+            .post(`http://${host}:${port}/graphql`, { query, variables }, { headers })
+            .then((response) => {
+            if (response.data.errors) {
+                console.log(response.data.errors);
+                return resolve(response.data);
+            }
+            return resolve(response.data);
+        })
+            .catch((error) => {
+            console.log(error.response.data.errors);
+            return resolve(error.response.data);
+        });
+    });
+}
+exports.runGQL = runGQL;