Merge pull request particle-iot#28 from AntonPuko/flowClean

clean flow, add WebhookMutator

Author: jlkalberer

src/lib/OAuthModel.js

@@ -1,24 +1,30 @@
 // @flow
 
-import type { Client, Repository, User } from '../types';
+import type {
+  Client,
+  TokenObject,
+  User,
+  UsersRepository,
+} from '../types';
 
 import ouathClients from '../oauthClients.json';
 
 class OauthModel {
-  _usersRepository: Repository<User>;
+  _usersRepository: UsersRepository;
 
-  constructor(usersRepository: Repository<User>) {
+  constructor(usersRepository: UsersRepository) {
     this._usersRepository = usersRepository;
   }
 
-  getAccessToken = (bearerToken: string) => {
+  getAccessToken = (bearerToken: string): ?Object => {
     const user = this._usersRepository.getByAccessToken(bearerToken);
     if (!user) {
-      return false;
+      return null;
     }
 
-    const userTokenObject = user.accessTokens.find((tokenObject) =>
-      tokenObject.accessToken === bearerToken,
+    const userTokenObject = user.accessTokens.find(
+      (tokenObject: TokenObject): boolean =>
+        tokenObject.accessToken === bearerToken,
     );
 
     return {
@@ -32,11 +38,11 @@ class OauthModel {
       client.clientId === clientId && client.clientSecret === clientSecret,
     );
 
-  getUser = async (username: string, password: string): User => {
-    return await this._usersRepository.validateLogin(username, password);
-  };
+  getUser = async (username: string, password: string): Promise<User> =>
+    await this._usersRepository.validateLogin(username, password);
+
 
-  saveToken = (tokenObject, client, user) => {
+  saveToken = (tokenObject: TokenObject, client: Client, user: User): Object => {
     this._usersRepository.saveAccessToken(user.id, tokenObject);
     return {
       accessToken: tokenObject.accessToken,

src/lib/controllers/Controller.js

@@ -1,15 +1,15 @@
+// @flow
+
+import type { HttpResult } from './types';
+
 export default class Controller {
-  bad(message) {
-    return {
-      data: {message},
-      status: 400,
-    };
-  }
+  bad = (message: string): HttpResult<*> => ({
+    data: { message },
+    status: 400,
+  });
 
-  ok(output) {
-    return {
-      data: output,
-      status: 200,
-    };
-  }
+  ok = <TType>(output?: TType): HttpResult<TType> => ({
+    data: output,
+    status: 200,
+  });
 }

src/lib/controllers/UsersController.js

@@ -1,6 +1,9 @@
 // @flow
 
-import type { Repository, User, UserCredentials } from '../../types';
+import type {
+  UserCredentials,
+  UsersRepository,
+} from '../../types';
 
 import basicAuthParser from 'basic-auth-parser';
 import Controller from './Controller';
@@ -9,17 +12,17 @@ import httpVerb from '../decorators/httpVerb';
 import route from '../decorators/route';
 
 class UsersController extends Controller {
-  _usersRepository: Repository<User>;
+  _usersRepository: UsersRepository;
 
-  constructor(usersRepository: Repository<User>) {
+  constructor(usersRepository: UsersRepository) {
     super();
     this._usersRepository = usersRepository;
   }
 
   @httpVerb('post')
   @route('/v1/users')
   @anonymous()
-  async createUser(userCredentials: UserCredentials) {
+  async createUser(userCredentials: UserCredentials): Promise<*> {
     try {
       const isUserNameInUse =
         this._usersRepository.isUserNameInUse(userCredentials.username);
@@ -38,7 +41,7 @@ class UsersController extends Controller {
   @httpVerb('delete')
   @route('/v1/access_tokens/:token')
   @anonymous()
-  async deleteAccessToken(token: string) {
+  async deleteAccessToken(token: string): Promise<*> {
     try {
       const { username, password } = basicAuthParser(this.request.get('authorization'));
       const user = await this._usersRepository.validateLogin(username, password);
@@ -54,7 +57,7 @@ class UsersController extends Controller {
   @httpVerb('get')
   @route('/v1/access_tokens')
   @anonymous()
-  async getAccessTokens() {
+  async getAccessTokens(): Promise<*> {
     try {
       const { username, password } = basicAuthParser(this.request.get('authorization'));
       const user = await this._usersRepository.validateLogin(username, password);

src/lib/controllers/WebhookController.js

@@ -1,59 +1,63 @@
 // @flow
 
-import type { Repository, Webhook, WebhookRequestType } from '../../types';
+import type {
+  Repository,
+  RequestType,
+  Webhook,
+  WebhookMutator,
+} from '../../types';
 
-import settings from '../../settings';
 import Controller from './Controller';
 import httpVerb from '../decorators/httpVerb';
 import route from '../decorators/route';
 
-const REQUEST_TYPES: Array<WebhookRequestType> = [
+const REQUEST_TYPES: Array<RequestType> = [
   'DELETE', 'GET', 'POST', 'PUT',
 ];
 
-const validateWebhookModel = (webhook: Webhook): ?Error => {
-  if (!webhook.event) {
+const validateWebhookMutator = (webhookMutator: WebhookMutator): ?Error => {
+  if (!webhookMutator.event) {
     return new Error('no event name provided');
   }
-  if (!webhook.url) {
+  if (!webhookMutator.url) {
     return new Error('no url provided');
   }
-  if (!webhook.requestType) {
+  if (!webhookMutator.requestType) {
     return new Error('no requestType provided');
   }
-  if (!REQUEST_TYPES.includes(webhook.requestType)) {
+  if (!REQUEST_TYPES.includes(webhookMutator.requestType)) {
     return new Error('wrong requestType');
   }
 
   return null;
 };
 
 class WebhookController extends Controller {
-  _webhookRepository: Repository<Webhook>;
+  _webhookRepository: Repository<Webhook, WebhookMutator>;
 
-  constructor(webhookRepository: Repository<Webhook>) {
+  constructor(webhookRepository: Repository<Webhook, WebhookMutator>) {
     super();
 
     this._webhookRepository = webhookRepository;
   }
 
   @httpVerb('get')
   @route('/v1/webhooks')
-  get() {
+  async getAll(): Promise<*> {
     return this.ok(this._webhookRepository.getAll());
   }
 
   @httpVerb('get')
   @route('/v1/webhooks/:webhookId')
-  getByWebhookId(webhookId: string) {
+  async getById(webhookId: string): Promise<*> {
     return this.ok(this._webhookRepository.getById(webhookId));
   }
 
   @httpVerb('post')
   @route('/v1/webhooks')
-  post(model: Webhook) {
+  async create(model: WebhookMutator): Promise<*> {
     try {
-      const validateError = validateWebhookModel(model);
+      const validateError = validateWebhookMutator(model);
       if (validateError) {
         throw validateError;
       }
@@ -73,8 +77,8 @@ class WebhookController extends Controller {
 
   @httpVerb('delete')
   @route('/v1/webhooks/:webhookId')
-  delete(webhookId: string) {
-    this._webhookRepository.delete(webhookId);
+  async deleteById(webhookId: string): Promise<*> {
+    this._webhookRepository.deleteById(webhookId);
     return this.ok();
   }
 }

src/lib/controllers/types.js

@@ -0,0 +1,10 @@
+// @flow
+
+
+export type HttpResult<TType> = {
+  data: ?TType,
+  status: number,
+} | {
+  data: ?string,
+  status: number,
+};

src/lib/decorators/types.js

@@ -1,3 +1,5 @@
+// @flow
+
 export type Decorator = (
   target: Object,
   name: string,
@@ -8,7 +10,7 @@ export type HttpVerb =
   'checkout' |
   'connect' |
   'copy' |
-  'delete' |
+  'deleteById' |
   'head' |
   'get' |
   'lock' |

src/lib/repository/UsersFileRepository.js

@@ -5,15 +5,14 @@ import type { TokenObject, User, UserCredentials } from '../../types';
 import { FileManager, uuid } from 'spark-protocol';
 import PasswordHasher from '../PasswordHasher';
 
-// todo change class methods style to arrow functions.
 class UsersFileRepository {
   _fileManager: FileManager;
 
   constructor(path: string) {
     this._fileManager = new FileManager(path);
   }
 
-  create = async (userCredentials: UserCredentials): User => {
+  create = async (userCredentials: UserCredentials): Promise<User> => {
     const { username, password } = userCredentials;
 
     const salt = await PasswordHasher.generateSalt();
@@ -33,19 +32,16 @@ class UsersFileRepository {
     return modelToSave;
   };
 
-  getAll(): Array<User> {
-    return this._fileManager.getAllData();
-  }
+  getAll = (): Array<User> =>
+    this._fileManager.getAllData();
 
-  getById(id: string): User {
-    return this._fileManager.getFile(id + '.json');
-  }
+  getById = (id: string): User =>
+    this._fileManager.getFile(`${id}.json`);
 
-  getByUsername(username: string) {
-    return this.getAll().find((user: User) => user.username === username);
-  }
+  getByUsername = (username: string): ?User =>
+    this.getAll().find((user: User): boolean => user.username === username);
 
-  async validateLogin(username: string, password: string) {
+  async validateLogin(username: string, password: string): Promise<User> {
     try {
       const user = this.getByUsername(username);
       if (!user) {
@@ -64,13 +60,13 @@ class UsersFileRepository {
   }
 
   getByAccessToken = (accessToken: string): ?User =>
-    this.getAll().find((user: User): User =>
+    this.getAll().find((user: User): boolean =>
       user.accessTokens.some((tokenObject: TokenObject): boolean =>
         tokenObject.accessToken === accessToken,
       ),
     );
 
-  deleteAccessToken(user: User, token: string) {
+  deleteAccessToken = (user: User, token: string) => {
     const userToSave = {
       ...user,
       accessTokens: user.accessTokens.filter(
@@ -80,18 +76,18 @@ class UsersFileRepository {
     };
 
     this._fileManager.writeFile(`${user.id}.json`, userToSave);
-  }
+  };
 
-  deleteById(id: string) {
+  deleteById = (id: string): void =>
     this._fileManager.deleteFile(`${id}.json`);
-  }
+
 
   isUserNameInUse = (username: string): boolean =>
     this.getAll().some((user: User): boolean =>
       user.username === username,
     );
 
-  saveAccessToken(userId: string, tokenObject: TokenObject) {
+  saveAccessToken = (userId: string, tokenObject: TokenObject) => {
     const user = this.getById(userId);
     const userToSave = {
       ...user,

src/lib/repository/WebhookFileRepository.js

@@ -1,6 +1,6 @@
 // @flow
 
-import type { Webhook } from '../../types';
+import type { Webhook, WebhookMutator } from '../../types';
 
 import { FileManager, uuid } from 'spark-protocol';
 
@@ -11,7 +11,7 @@ class WebhookFileRepository {
     this._fileManager = new FileManager(path);
   }
 
-  create = (model: Webhook): Webhook => {
+  create = (model: WebhookMutator): Webhook => {
     const modelToSave = {
       ...model,
       created_at: new Date(),
@@ -25,15 +25,14 @@ class WebhookFileRepository {
     return modelToSave;
   };
 
-  delete = (id: string): void =>
+  deleteById = (id: string): void =>
     this._fileManager.deleteFile(`${id}.json`);
 
   getAll = (): Array<Webhook> =>
     this._fileManager.getAllData();
 
   getById = (id: string): Webhook =>
     this._fileManager.getFile(`${id}.json`);
-
 }
 
 export default WebhookFileRepository;