Oauth

bs-config.json

@@ -0,0 +1,3 @@
+{
+  "port": 4200
+}

mock-server/accounts.ts

@@ -1,15 +1,17 @@
 import AccountsServer from '@accounts/server';
-import {MongoClient } from 'mongodb';
 import MongoAdapter from '@accounts/mongo';
 import * as faker from 'faker';
+import { getMongoClient } from './db';
 
-const MONGO_URL = 'mongodb://localhost:27017/rocketchatMock';
 
 const initUsers = () => {
-  const users = [{username: 'eitan', password: 'eitan'},{username: 'Eitan', password: 'Eitan'}, {username: 'tomer', password: 'tomer'}];
+  const users = [{ username: 'eitan', password: 'eitan' }, {
+    username: 'Eitan',
+    password: 'Eitan'
+  }, { username: 'tomer', password: 'tomer' }];
 
   users.map(async (userData) => {
-    const {username, password} = userData;
+    const { username, password } = userData;
     const user = await AccountsServer.findUserByUsername(username);
     if (!user) {
       AccountsServer.createUser({
@@ -27,10 +29,10 @@ const initUsers = () => {
 export const initAccounts = async () => {
   let mongoAdapter = null;
   try {
-    mongoAdapter = await MongoClient.connect(MONGO_URL).then(db => new MongoAdapter(db));
+    mongoAdapter = await getMongoClient().then(db => new MongoAdapter(db));
   }
   catch (e) {
-    console.log('Failed connecting to the mongoDb ', e);
+    console.error('Failed connecting to the mongoDb ', e);
     return;
   }
   AccountsServer.config({

mock-server/db.ts

@@ -0,0 +1,24 @@
+import { MongoClient } from 'mongodb';
+
+let mongoDB;
+
+const MONGO_URL = 'mongodb://localhost:27017/rocketchatMock';
+
+const initMongoClient = async () => {
+  try {
+    mongoDB = await MongoClient.connect(MONGO_URL);
+  }
+  catch (e) {
+    console.error('cannot connect to db', e);
+  }
+  return mongoDB;
+};
+
+
+export const getMongoClient = async () => {
+  if (!mongoDB) {
+    await initMongoClient();
+  }
+  return mongoDB;
+};
+

mock-server/index.ts

@@ -1,24 +1,55 @@
 import 'babel-polyfill';
 import * as express from 'express';
+import * as session from 'express-session';
+import * as Grant from 'grant-express';
 import * as bodyParser from 'body-parser';
 import * as cors from 'cors';
 import { graphiqlExpress, graphqlExpress } from 'graphql-server-express';
-import {createSchemeWithAccounts} from './schema';
+import { createSchemeWithAccounts } from './schema';
 import { JSAccountsContext } from '@accounts/graphql-api';
 import { SubscriptionServer } from 'subscriptions-transport-ws';
 import { execute, subscribe } from 'graphql';
 import { createServer } from 'http';
 import { initAccounts } from './accounts';
+import { initializeOAuthResolver } from './oauth/oauth-service';
+import { GRANT_PATH, grantConfig } from './oauth/grant-config';
+import AccountsServer from '@accounts/server';
 
 const PORT = 3000;
 const WS_GQL_PATH = '/subscriptions';
+const STATIC_SERVER = 'http://localhost:4200';
 
 async function main() {
   const app = express();
   app.use(cors());
 
-  const accountsServer = await initAccounts();
-  const schema = createSchemeWithAccounts(accountsServer);
+  await initAccounts();
+
+  app.use(session({
+    secret: 'grant',
+    resave: true,
+    saveUninitialized: true,
+  }));
+
+  app.use(bodyParser.urlencoded({ extended: true }));
+
+  const grant = new Grant(grantConfig);
+
+  app.use(GRANT_PATH, grant);
+
+  app.get(`${GRANT_PATH}/handle_facebook_callback`, function (req, res) {
+    const accessToken = req.query.access_token;
+    res.redirect(`${STATIC_SERVER}/login?service=facebook&access_token=${accessToken}`);
+  });
+
+  app.get(`${GRANT_PATH}/handle_google_callback`, function (req, res) {
+    const accessToken = req.query.access_token;
+    res.redirect(`${STATIC_SERVER}/login?service=google&access_token=${accessToken}`);
+  });
+
+  initializeOAuthResolver();
+
+  const schema = createSchemeWithAccounts(AccountsServer);
 
   app.use('/graphql', bodyParser.json(), graphqlExpress(request => ({
     schema,
@@ -49,4 +80,4 @@ async function main() {
   });
 }
 
-main().catch((e) => console.log('Failed to start mock server', e));
+main().catch((e) => console.error('Failed to start mock server', e));

mock-server/mocks.ts

@@ -1,15 +1,14 @@
 import * as faker from 'faker';
 import { pubsub } from './subscriptions';
 import { withFilter } from 'graphql-subscriptions';
+import { getOAuthResolver } from './oauth/oauth-service';
+import { authenticated } from '@accounts/graphql-api';
+import AccountsServer from '@accounts/server';
 
 export const CHAT_MESSAGE_SUBSCRIPTION_TOPIC = 'CHAT_MESSAGE_ADDED';
-
 const messages = new Map<string, any[]>();
+const oauthResolver = getOAuthResolver();
 const channels = [];
-const me = {
-  name: faker.name.firstName() + ' ' + faker.name.lastName(),
-  avatar: faker.image.avatar(),
-};
 
 const createMessage = (channelId) => {
   return {
@@ -45,19 +44,23 @@ for (let i = 0; i < 15; i++) {
 }
 
 export const mocks = {
-  User: () => ({
-    name: () => faker.name.firstName() + ' ' + faker.name.lastName(),
-    avatar: () => faker.image.avatar(),
-  }),
+  User: ({user}) => {
+    return {
+      name: () => user.profile.name,
+      avatar: () => user.profile.avatar,
+    };
+  },
   Channel: () => ({
     id: () => faker.random.uuid(),
     name: () => faker.random.word(),
     direct: () => faker.random.boolean(),
     unseenMessages: () => faker.random.boolean() ? faker.random.number(30) : 0,
   }),
   Query: () => ({
-    channelsByUser: () => channels.slice(0, faker.random.number({ min: 3, max: channels.length })),
-    messages: (root, { channelId, channelDetails, cursor, count }, context) => {
+    channelsByUser: () => {
+      return channels.slice(0, faker.random.number({ min: 3, max: channels.length }));
+    },
+    messages: authenticated(AccountsServer, (root, { channelId, channelDetails, cursor, count }, context) => {
       if (!channelId && !channelDetails) {
         console.error(`messages query must be called with channelId or channelDetails`);
         return null;
@@ -104,25 +107,25 @@ export const mocks = {
         console.error('cursor is invalid');
         return null;
       }
-    },
-    channelByName: (root, { name, isDirect }) => {
+    }),
+    channelByName: authenticated(AccountsServer, (root, { name, isDirect }) => {
       return channels.find((element) => element.name === name && element.direct === isDirect) || null;
-    },
+    }),
   }),
   Mutation: () => ({
-    sendMessage: (root, { channelId, content }, context) => {
+    sendMessage: authenticated(AccountsServer, (root, { channelId, content }, {user}) => {
       const messagesArray = messages.get(channelId);
       if (!messagesArray) {
-        console.log('channel not found');
+        console.error('channel not found');
         return null;
       }
       const newMessage = {
         id: faker.random.uuid(),
         content,
         creationTime: (new Date()).getTime().toString(),
         author: {
-          name: me.name,
-          avatar: me.avatar
+          name: user.profile.name,
+          avatar: user.profile.avatar
         },
         channel: {
           id: channelId,
@@ -132,6 +135,24 @@ export const mocks = {
       messagesArray.unshift(newMessage);
       pubsub.publish(CHAT_MESSAGE_SUBSCRIPTION_TOPIC, { chatMessageAdded: newMessage });
       return newMessage;
+    }),
+    loginWithServiceAccessToken: async (root, { service, accessToken }, context) => {
+      try {
+        const userData = await oauthResolver.getUserDataFromService(accessToken, service);
+        const accountsServer = AccountsServer;
+        const user = await oauthResolver.getUserFromServiceUserData(service, userData);
+        if (!user) {
+          return null;
+        }
+        const loginResult = await accountsServer.loginWithUser(user);
+        return {
+          refreshToken: loginResult.tokens.refreshToken,
+          accessToken: loginResult.tokens.accessToken,
+        };
+      }
+      catch (e) {
+        console.error('Failed to login with service', e);
+      }
     }
   }),
 };

mock-server/oauth/grant-config.ts

@@ -0,0 +1,22 @@
+export const GRANT_PATH = '/auth';
+
+export const grantConfig = {
+  server: {
+    protocol: 'http',
+    host: 'localhost:3000',
+    path: '/auth',
+    state: true,
+  },
+  facebook: {
+    key: '353692268378789',
+    secret: '30fa7be4ee732b4cc28c6d8acab54263',
+    callback: `${GRANT_PATH}/handle_facebook_callback`,
+    scope: [],
+  },
+  google: {
+    key: '822500959137-ktt8mfq95vlvq8ogcbu4gg3paear7174.apps.googleusercontent.com',
+    secret: 'PBMWy2O-739OyqTItjXP3Dzq',
+    callback: `${GRANT_PATH}/handle_google_callback`,
+    scope: ['openid email'],
+  },
+};

mock-server/oauth/oauth-resolver.ts

@@ -0,0 +1,45 @@
+import * as request from 'request';
+import { ServicesResolver } from '../types/types';
+
+export class OAuthResolver {
+  private servicesResolver: ServicesResolver = {};
+
+  setServicesResolver(resolver: ServicesResolver) {
+    Object.assign(this.servicesResolver, resolver);
+  }
+
+  getServiceUrl(service: string): string {
+    if (this.servicesResolver[service]) {
+      return this.servicesResolver[service].url;
+    }
+
+    return null;
+  };
+
+  async getUserFromServiceUserData(service: string, userData) {
+    if (this.servicesResolver[service]) {
+      return await this.servicesResolver[service].userResolver(userData);
+    }
+
+    return null;
+  };
+
+  getUserDataFromService(accessToken: string, service: string) {
+    return new Promise((resolve, reject) => {
+      let userData = null;
+      const requestUrl = this.getServiceUrl(service);
+      if (!requestUrl) {
+        reject('service is not defined');
+      }
+      request(`${requestUrl}${accessToken}`, (error, response, body) => {
+        if (!error && response.statusCode === 200) {
+          userData = JSON.parse(body);
+          resolve(userData);
+        }
+        else {
+          reject(error);
+        }
+      });
+    });
+  };
+}

mock-server/oauth/oauth-service.ts

@@ -0,0 +1,62 @@
+import { OAuthResolver } from './oauth-resolver';
+import AccountsServer from '@accounts/server';
+import { getMongoClient } from '../db';
+
+const oauthResolver: OAuthResolver = new OAuthResolver();
+
+export const getOAuthResolver = () => {
+  return oauthResolver;
+};
+
+export const findUserByOAuthId = async (service: string, id) => {
+  const mongoClient = await getMongoClient();
+  const dbCollection = await mongoClient.collection('users');
+  return await dbCollection.findOne({ [`profile.oauth.${service}`]: id });
+};
+
+export const addOAuthIdToUserProfile = async (user, service: string, serviceId) => {
+  AccountsServer.setProfile(user.id, Object.assign({}, user.profile,
+    {
+      oauth: {
+        ...user.profile.oauth,
+        [service]: serviceId
+      }
+    }));
+};
+
+export const initializeOAuthResolver = () => {
+  oauthResolver.setServicesResolver({
+    google: {
+      url: 'https://www.googleapis.com/plus/v1/people/me?access_token=',
+      userResolver: async (userData) => {
+        let user = await findUserByOAuthId('google', userData.id);
+        if (user) {
+          user.id = user._id;
+        }
+        else {
+          user = await AccountsServer.findUserByEmail(userData.emails[0].value);
+        }
+
+        if (user) {
+          await addOAuthIdToUserProfile(user, 'google', userData.id);
+        }
+        else {
+          const id = await AccountsServer.createUser({
+            username: userData.emails[0].value,
+            email: userData.emails[0].value,
+            profile: {
+              name: userData.name.givenName + ' ' + userData.name.familyName,
+              avatar: userData.image.url,
+              oauth: {
+                google: userData.id,
+              }
+            }
+          });
+          user = await AccountsServer.findUserById(id);
+        }
+
+        return user;
+      },
+    },
+  });
+};

mock-server/schema.ts

@@ -20,6 +20,7 @@ type Mutation {
     editMessage(messageId: MessageIdentifier!, content: String!): Message
     addReactionToMassage(messageId: MessageIdentifier!, icon: String!): Message
     updateUserSettings(userSettings: UserSettings): User
+    loginWithServiceAccessToken(service: String!, accessToken: String!): LoginResult
     #updateUserChannelSettings(channelId: String!,settings: ChannelSettings )
 }
 
@@ -64,6 +65,11 @@ type MessagesWithCursor {
   messagesArray: [Message]
 }
 
+type LoginResult {
+  accessToken: String
+  refreshToken: String
+}
+
 type Message {
     id: String
     author: User

mock-server/types/types.d.ts

@@ -1,4 +1,10 @@
 declare module 'graphql' {
   export function subscribe(): any;
+
   export function execute(): any;
 }
+
+export interface ServicesResolver {
+  [name: string]: { url: string, userResolver: (userData: any) => Promise<any> };
+}
+