finish rest client

Author: Dahkenangnon

.gitignore

@@ -73,3 +73,6 @@ build/
 !**/ios/**/default.pbxuser
 !**/ios/**/default.perspectivev3
 !/packages/flutter_tools/test/data/dart_dependencies_test/**/.packages
+
+# sembast db
+flutter_feathersjs.db

LICENSE

@@ -1,6 +1,6 @@
 # The MIT License (MIT)
 
-Copyright (c) 2019 Justin Y. Dah-kenangnon <dah.kenangnon@gmail.com>
+Copyright (c) 2019 Justin Dah-kenangnon <dah.kenangnon@gmail.com>
 
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,3 +1,19 @@
-# feathersjs
+# flutter_feathersjs
 
-Under dev, please don't use it now.
+Communicate with you feathers js server from flutter.
+
+## THIS IS UNDER DEV, DON'T USE IT AT THIS MOMENT IN PROD
+
+## TODO
+
+- [x] Write auth for  rest
+- [x] Write reAuth for rest
+- [x] Write rest client method (feathers js service methods)
+- [ ] Handle formData on rest
+
+- [ ] Write auth for  socket
+- [ ] Write reAuth for socket
+- [ ] Write socket client method (feathers js service methods)
+- [ ] Handle formData on socket
+- [ ] Write an unique flutter_feathersjs plugin which won't mater if you calling service via rest or sock
+- [ ] Write doc

lib/feathersjs.dart

@@ -0,0 +1,42 @@
+library flutter_feathersjs;
+
+import 'package:flutter_feathersjs/src/rest_client.dart';
+import 'package:flutter_feathersjs/src/socketio_client.dart';
+import 'package:meta/meta.dart';
+
+class FlutterFeathersjs {
+  /////////////////////////////////////////////////////////////////////
+  RestClient rest;
+  SocketioClient scketio;
+
+  ////////////////////////////////////////////////////////////////////////
+
+//Using singleton
+  static final FlutterFeathersjs _flutterFeathersjs =
+      FlutterFeathersjs._internal();
+  factory FlutterFeathersjs() {
+    return _flutterFeathersjs;
+  }
+  FlutterFeathersjs._internal();
+
+  //intialize both rest and scoketio client, base url and headers.
+  config({@required String baseUrl, Map<String, dynamic> extraHeaders}) async {
+    rest = new RestClient(baseUrl: baseUrl, extraHeaders: extraHeaders);
+
+    //Auth only by rest, so we must call auth or reAuth from rest before use scketio
+    var oldToken = await this.rest.utils.getRestAccessToken();
+    Map<String, dynamic> scketIOExtraHeaders = {
+      "Authorization": "Bearer $oldToken"
+    };
+    scketio =
+        new SocketioClient(baseUrl: baseUrl, extraHeaders: scketIOExtraHeaders);
+  }
+
+  /// Authenticate client
+  Future<dynamic> authenticate(
+      {@required String email,
+      @required String password,
+      String client = "rest"}) async {
+    return await rest.authenticate(email: email, password: password);
+  }
+}

lib/flutter_feathersjs.dart

@@ -0,0 +1,5 @@
+abstract class FlutterFeathersjsEvents {}
+
+class Connected extends FlutterFeathersjsEvents {}
+
+class Disconnected extends FlutterFeathersjsEvents {}

lib/src/event.dart

@@ -1,3 +1,7 @@
 //Base classe for both rest and socketio
 
-class FeathersJsClient {}
+import './utils.dart';
+
+class FlutterFeathersjs {
+  Utils utils = new Utils();
+}

lib/src/featherjs_client_base.dart

@@ -1,35 +1,149 @@
 import 'dart:async';
 
 import 'package:dio/dio.dart';
-import 'package:feathersjs/src/featherjs_client_base.dart';
+import 'package:flutter_feathersjs/src/featherjs_client_base.dart';
 import 'package:meta/meta.dart';
 
-class RestClient extends FeathersJsClient {
-  /////////////////////////////////////////////////////////////////////
+/// Feathers Js rest client
+class RestClient extends FlutterFeathersjs {
+  ///Dio as http client
   Dio dio;
-  ////////////////////////////////////////////////////////////////////////
 
   RestClient({@required String baseUrl, Map<String, dynamic> extraHeaders}) {
     //Setup Http client
     dio = Dio(BaseOptions(
       baseUrl: baseUrl,
       headers: extraHeaders,
     ));
+
+    dio.interceptors
+        .add(InterceptorsWrapper(onRequest: (RequestOptions options) async {
+      // Do something before request is sent
+      //Adding stored token early with sembast
+      var oldToken = await this.utils.getRestAccessToken();
+      dio.options.headers["Authorization"] = "Bearer $oldToken";
+      return options; //continue
+      // If you want to resolve the request with some custom data，
+      // you can return a `Response` object or return `dio.resolve(data)`.
+      // If you want to reject the request with a error message,
+      // you can return a `DioError` object or return `dio.reject(errMsg)`
+    }, onResponse: (Response response) async {
+      // Do something with response data
+      return response; // continue
+    }, onError: (DioError e) async {
+      // Do something with response error
+
+      if (e.response != null) {
+        // print(e.response.data);
+        // print(e.response.headers);
+        // print(e.response.request);
+        //Only send the error message from feathers js server not for Dio
+        return e.response.data; //continue
+      } else {
+        // Something happened in setting up or sending the request that triggered an Error
+        // print(e.request);
+        // print(e.message);
+        //By returning null, it means that error is from client
+        return null;
+      }
+    }));
+  }
+
+  Future<dynamic> reAuthenticate({String serviceName = "users"}) async {
+    //AsyncTask manager
+    Completer asyncTask = Completer<dynamic>();
+    Map<String, dynamic> authResponse = {
+      "error": true,
+      "error_zone": "UNKNOWN",
+      "message": "An error occured"
+    };
+
+    //Getting the early sotored rest access token and send the request by using it
+    var oldToken = await this.utils.getRestAccessToken();
+
+    //If an oldToken exist really
+    if (oldToken != null) {
+      dio.options.headers["Authorization"] = "Bearer $oldToken";
+      var response =
+          await find(serviceName: "$serviceName", query: {"\$limit": 1});
+
+      if (response.statusCode == 401) {
+        print("jwt expired or jwt malformed");
+        authResponse["error"] = true;
+        authResponse["message"] = "jwt expired";
+        authResponse["error_zone"] = "JWT_EXPIRED_ERROR";
+      } else if (response.statusCode == 200) {
+        print("Jwt still validated");
+        authResponse["error"] = false;
+        authResponse["message"] = "Jwt still validated";
+        authResponse["error_zone"] = "NO_ERROR";
+      } else {
+        print("Unknown error");
+        authResponse["error"] = true;
+        authResponse["message"] = "Unknown error";
+        authResponse["error_zone"] = "UNKNOWN_ERROR";
+      }
+    } else {
+      print("No old token found. Must reAuth user");
+      authResponse["error"] = true;
+      authResponse["message"] = "No old token found. Must reAuth user";
+      authResponse["error_zone"] = "JWT_NOT_FOUND";
+    }
+    asyncTask.complete(authResponse);
+    return asyncTask.future;
   }
 
-  Future<bool> authenticate(
+  Future<dynamic> authenticate(
       {strategy = "local", String email, String password}) async {
-    Completer asyncTask = Completer<bool>();
+    Completer asyncTask = Completer<dynamic>();
+
+    Map<String, dynamic> authResponse = {
+      "error": true,
+      "error_zone": "UNKNOWN",
+      "message": "An error occured"
+    };
+
     try {
       //Making http request to get auth token
       var response = await dio.post("/authentication",
           data: {"strategy": strategy, "email": email, "password": password});
-      var token = response.data['accessToken'];
-      dio.options.headers["Authorization"] = "Bearer $token";
-      asyncTask.complete(true);
+      //Check is auth is successfully before storing token
+      if (response.data["code"] != null && response.data["code"] == 401) {
+        //This is useful to display to end user why auth failed
+        //With 401: it will be either Invalid credentials or strategy error
+        if (response.data["message"] == "Invalid login") {
+          authResponse["error_zone"] = "INVALID_CREDENTIALS";
+        } else {
+          authResponse["error_zone"] = "INVALID_STRATEGY";
+        }
+        authResponse["error"] = true;
+        authResponse["message"] = response.data["message"];
+      } else if (response.data['accessToken'] != null) {
+        authResponse["error"] = false;
+        authResponse["message"] = response.data["user"];
+        authResponse["error_zone"] = "NO_ERROR";
+
+        //Store the authenticated user
+        await this
+            .utils
+            .setAuthenticatedFeathersUser(user: response.data['user']);
+        //Storing the token
+        await this
+            .utils
+            .setRestAccessToken(token: response.data['accessToken']);
+      } else {
+        //Unknown error
+        authResponse["error"] = true;
+        authResponse["message"] = "Unknown error occured";
+      }
     } catch (e) {
-      asyncTask.complete(false);
+      //Error caught by Dio
+      authResponse["error"] = true;
+      authResponse["message"] = e;
+      authResponse["error_zone"] = "DIO_ERROR";
     }
+    //Send response
+    asyncTask.complete(authResponse);
     return asyncTask.future;
   }