flow fixes

Author: AntonPuko

src/lib/controllers/Controller.js

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

src/lib/controllers/UsersController.js

@@ -22,7 +22,7 @@ class UsersController extends Controller {
   @httpVerb('post')
   @route('/v1/users')
   @anonymous()
-  async createUser(userCredentials: UserCredentials): Promise<Object> {
+  async createUser(userCredentials: UserCredentials): Promise<*> {
     try {
       const isUserNameInUse =
         this._usersRepository.isUserNameInUse(userCredentials.username);
@@ -41,7 +41,7 @@ class UsersController extends Controller {
   @httpVerb('delete')
   @route('/v1/access_tokens/:token')
   @anonymous()
-  async deleteAccessToken(token: string): Promise<Object> {
+  async deleteAccessToken(token: string): Promise<*> {
     try {
       const { username, password } = basicAuthParser(this.request.get('authorization'));
       const user = await this._usersRepository.validateLogin(username, password);
@@ -57,7 +57,7 @@ class UsersController extends Controller {
   @httpVerb('get')
   @route('/v1/access_tokens')
   @anonymous()
-  async getAccessTokens(): Promise<Object> {
+  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

@@ -15,49 +15,49 @@ 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')
-  getAll(): Object {
+  async getAll(): Promise<*> {
     return this.ok(this._webhookRepository.getAll());
   }
 
   @httpVerb('get')
   @route('/v1/webhooks/:webhookId')
-  getById(webhookId: string): Object {
+  async getById(webhookId: string): Promise<*> {
     return this.ok(this._webhookRepository.getById(webhookId));
   }
 
   @httpVerb('post')
   @route('/v1/webhooks')
-  create(model: WebhookMutator): Object {
+  async create(model: WebhookMutator): Promise<*> {
     try {
-      const validateError = validateWebhookModel(model);
+      const validateError = validateWebhookMutator(model);
       if (validateError) {
         throw validateError;
       }
@@ -77,7 +77,7 @@ class WebhookController extends Controller {
 
   @httpVerb('delete')
   @route('/v1/webhooks/:webhookId')
-  deleteById(webhookId: string): Object {
+  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/repository/UsersFileRepository.js

@@ -41,7 +41,7 @@ class UsersFileRepository {
   getByUsername = (username: string): ?User =>
     this.getAll().find((user: User): boolean => user.username === username);
 
-  async validateLogin(username: string, password: string): User {
+  async validateLogin(username: string, password: string): Promise<User> {
     try {
       const user = this.getByUsername(username);
       if (!user) {
@@ -60,7 +60,7 @@ 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,
       ),

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(),
@@ -33,7 +33,6 @@ class WebhookFileRepository {
 
   getById = (id: string): Webhook =>
     this._fileManager.getFile(`${id}.json`);
-
 }
 
 export default WebhookFileRepository;

src/types.js

@@ -1,27 +1,17 @@
 // @flow
 
-export type Webhook = {
-  deviceID: string,
-  event: string,
-  errorResponseTopic: string,
+export type Webhook = WebhookMutator & {
+  created_at: Date,
   id: string,
-  json: {[key: string]: Object},
-  mydevices: boolean,
-  productIdOrSlug: ?string,
-  rejectUnauthorized: boolean,
-  requestType: RequestType,
-  responseTemplate: ?string,
-  responseTopic: string,
-  url: string,
 };
 
 export type WebhookMutator = {
   auth?: { Authorization: string },
-  deviceID?: boolean,
+  deviceID?: string,
   errorResponseTopic?: string,
   event: string,
   form?: { [key: string]: Object },
-  headers?:{ [key: string]: string },
+  headers?: { [key: string]: string },
   json?: { [key: string]: Object },
   mydevices?: boolean,
   noDefaults?: boolean,
@@ -69,6 +59,7 @@ export type User = {
   created_at: Date,
   id: string,
   passwordHash: string,
+  salt: string,
   username: string,
 };
 
@@ -77,16 +68,16 @@ export type UserCredentials = {
   password: string,
 };
 
-export type Repository<TModel> = {
-  create: (id: string, model: TModel) => TModel,
+export type Repository<TModel, TMutator> = {
+  create: (model: TMutator) => TModel,
   deleteById: (id: string) => void,
   getAll: () => Array<TModel>,
   getById: (id: string) => TModel,
   update: (id: string, model: TModel) => TModel,
 };
 
-export type UsersRepository = Repository<User> & {
-  deleteAccessToken: (accessToken: string) => void,
+export type UsersRepository = Repository<User, UserCredentials> & {
+  deleteAccessToken: (user: User, accessToken: string) => void,
   getByAccessToken: (accessToken: string) => User,
   getByUsername: (username: string) => ?User,
   isUserNameInUse: (username: string) => boolean,
@@ -112,6 +103,6 @@ export type Settings = {
   serverKeyFile: string,
   serverKeyPassEnvVar: ?string,
   serverKeyPassFile: ?string,
-  usersRepository: Repository<*>,
-  webhookRepository: Repository<*>,
+  usersRepository: Repository<*, *>,
+  webhookRepository: Repository<*, *>,
 };

test/WebhooksController.test.js

@@ -135,7 +135,7 @@ test.serial('should return webhook object by id', async t => {
   t.is(testWebhook.url, response.body.url);
 });
 
-test.serial('should deleteById webhook', async t => {
+test.serial('should delete webhook', async t => {
   const deleteResponse = await request(app)
     .delete(`/v1/webhooks/${testWebhook.id}`)
     .query({ access_token: userToken });