systemlynx 1.1.0 → 1.3.0

package/API.md

@@ -73,10 +73,10 @@ Welcome to the docs! Following is a list of the objects used and created when de
 
 ## App
 
-**App** combinds the both functionalites of SystemLynx Service and Client into one object, while also providing a module interface and lifecycle events. Access the App instance by deconcatanating from the object return when loading SystemLynx `require("sht-tasks")`.
+**App** combinds the both functionalites of SystemLynx Service and Client into one object, while also providing a module interface and lifecycle events. Access the App instance by deconcatanating from the object return when loading SystemLynx `require("systemlynx")`.
 
 ```javascript
-const { App } = require("sht-tasks");
+const { App } = require("systemlynx");
 ```
 
 ## App.ServerModule(name, constructor [,reserved_methods])
@@ -108,10 +108,10 @@ Use **App.ServerModule(name, constructor)** function to create or pass an object
 
 Service is a SystemLynx abstraction used to server objects that can be loaded by a SystemLynx Client using the `Client.loadService(url)` method.
 
-Call require("sht-tasks") and de-concatenate from the object it returns.
+Call require("systemlynx") and de-concatenate from the object it returns.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 ```
 
 The Service object has the following methods:
@@ -127,7 +127,7 @@ The Service object has the following methods:
   Use the `Service.ServerModule(name, constructor, [,options])` method to register an object to be hosted by a _SystemLynx Service_. This will allows you to load an instance of that object onto a client application, and call any methods on that object remotely.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 
 const Users = {};
 

package/README.md

@@ -5,14 +5,14 @@ SystemLynx is a framework for developing modular web APIs. It's a wrapper on top
 SystemLynx comes with the following objects that are used for web API development:
 
 ```javascript
-const { App, Service, Client, LoadBalancer } = require("sht-tasks");
+const { App, Service, Client, LoadBalancer } = require("systemlynx");
 ```
 
-Call `require("sht-tasks")` and de-concatenate from the object it returns. The main abstractions used for client-to-server interactions are the following:
+Call `require("systemlynx")` and de-concatenate from the object it returns. The main abstractions used for client-to-server interactions are the following:
 
 - **Service** - Used to create and host objects that can be loaded and used by a SystemLynx Client.
-- **Client** - Used in a client application to load a _Service_, which contains all the objects added to the _Service_.
-- **App** - Provides a modular interface and lifecycle methods for asynchronously creating and loading _Services_.
+- **Client** - Used in a client application to load a **Service**, which contains all the objects added to the **Service**.
+- **App** - Provides a modular interface and lifecycle methods for asynchronously creating and loading **Services**.
 
 Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/tasksjs2.0/API.md#tasksjs-api-documentation) here.
 
@@ -22,16 +22,16 @@ Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/ta
 
 ## Service.ServerModule(name, constructor [,options])
 
-Use the `Service.ServerModule(name, constructor/object)` method to register an object to be hosted by a _SystemLynx Service_. This will allows you to load an instance of that object onto a client application, and call any methods on that object remotely.
+Use the `Service.ServerModule(name, constructor/object)` method to register an object to be hosted by a **SystemLynx Service**. This will allows you to load an instance of that object onto a client application, and call any methods on that object remotely.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 
 const Users = {};
 
-Users.add = function (data, callback) {
+Users.add = function (data) {
   console.log(data);
-  callback(null, { message: "You have successfully called the Users.add method" });
+  return { message: "You have successfully called the Users.add method" };
 };
 
 Service.ServerModule("Users", Users);
@@ -39,17 +39,17 @@ Service.ServerModule("Users", Users);
 
 In the code above we assigned an object to the variable `Users` and gave it an add method. The `Service.ServerModule(name, constructor/object)` function takes the name assigned to the object as the first argument and the object itself as the second argument.
 
-Alternatively, you can use a constructor function instead of an object as the second argument. In the example below we create another _ServerModule_ called
-"Orders".
+Alternatively, you can use a constructor function instead of an object as the second argument. In the example below we create another **ServerModule** called
+"Orders". This time we use a constructor function as the second argument of the to **ServerModule** function. The `this` value is the initial instance of the **ServerModule** object. Every method added to the `this` value will be accessible when the object is loaded by a **SystemLynx Client**. Note: **ServerModule** methods can be synchronous or asynchronous functions.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 
 const Users = {};
 
-Users.add = function (data, callback) {
+Users.add = function (data) {
   console.log(data);
-  callback(null, { message: "You have successfully called the Users.add method" });
+  return { message: "You have successfully called the Users.add method" };
 };
 
 Service.ServerModule("Users", Users);
@@ -57,27 +57,25 @@ Service.ServerModule("Users", Users);
 Service.ServerModule("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2, callback) {
+  Orders.find = async function (arg1, arg2) {
     console.log(data);
-    callback(null, { message: "You have successfully called the Orders.find method" });
+    return { message: "You have successfully called the Orders.find method" };
   };
 });
 ```
 
-In the _ServerModule_ constructor function above, the `this` value is the initial instance of the _ServerModule_ object. Every method added to the `this` value will be accessible when the object is loaded by a _SystemLynx Client_. Notice that the method we created, `Orders.find = function(arg1, arg2, callback)...`, has 3 parameters including a callback function as the last argument. By defualt all _ServerModule_ methods will recieve a callback function as its last argument. Use the first parameter of the callback function to respond with an error, and the second parameter to send a success response. Note: _ServerModule_ methods can be configured to work with synchronous return values instead of asynchronous callbacks (read more about Service configuration [here](https://github.com/Odion100/SystemLynx/blob/tasksjs2.0/API.md#apploadserviceurl)).
-
 ## Service.startService(options)
 
-Before we can access the objects hosted by this _Service_ from a client application, we need to call the `Service.startService(options)` function. This will start an **ExpressJS** Server and a **Socket.io** WebSocket Server, and set up routing for the _Service_. In the example below we added the `Service.startService(options)` function at the bottom, but the order does not matter.
+Before we can access the objects hosted by this **Service** from a client application, we need to call the `Service.startService(options)` function. This will start an **ExpressJS** Server and a **Socket.io** WebSocket Server, and set up routing for the **Service**. In the example below we added the `Service.startService(options)` function at the bottom, but the order does not matter.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 
 const Users = {};
 
-Users.add = function (data, callback) {
+Users.add = function (data) {
   console.log(data);
-  callback(null, { message: "You have successfully called the Users.add method" });
+  return { message: "You have successfully called the Users.add method" };
 };
 
 Service.ServerModule("Users", Users);
@@ -85,9 +83,9 @@ Service.ServerModule("Users", Users);
 Service.ServerModule("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2, callback) {
+  Orders.find = function (arg1, arg2) {
     console.log(data);
-    callback(null, { message: "You have successfully called the Orders.find method" });
+    return { message: "You have successfully called the Orders.find method" };
   };
 });
 
@@ -98,29 +96,28 @@ Now lets see how these objects can be loaded into a client application.
 
 ## Client.loadService(url, [options])
 
-The `Client.loadService(url)` function can be used to load a SystemLynx _Service_. This method requires the url (string) of the _Service_ you want to load as the first argument, and will return a promise that will resolve into an object that containing all the modules hosted by that service. See below. **NOTE: You must be within an async function in order to use the `await` keyword when returning a promise.**
+The `Client.loadService(url)` function can be used to load a SystemLynx **Service**. This method requires the url (string) of the **Service** you want to load as the first argument, and will return a promise that will resolve into an object that containing all the modules hosted by that service. See below. **NOTE: You must be within an async function in order to use the `await` keyword when returning a promise.**
 
 ```javascript
-const { Client } = require("sht-tasks");
+const { Client } = require("systemlynx");
 
 const { Users, Orders } = await Client.loadService("http://localhost:4400/test/service");
 
 console.log(Users, Orders);
 ```
 
-Now that we've loaded the _Service_ that we created in the previous example, and have a handle on the _Users_ and _Orders_ objects hosted by the _Service_, we can now call any method on those objects. In the example below, we demonstrate that when a methods for the ServerModule objects is called from the client, it can optionally take a callback as the last argument or, if a callback is not used, it will return a promise. With the `Users.add(data, callback)` method we used a callback, but with the `Orders.find(arg1, arg2, callback)` method we left out the callback function and used the `await` keyword to return a promise.
+Now that we've loaded the **Service** that we created in the previous example, and have a handle on the **Users** and **Orders** objects hosted by the **Service**, we can now call any method on those objects in the same way we would remotely. In the example below, noticed that both the `User.add` and `Orders.find` methods will return a promise.
 
 ```javascript
-const { Client } = require("sht-tasks");
+const { Client } = require("systemlynx");
 
 const { Users, Orders } = await Client.loadService("http://localhost:4400/test/service");
 
 console.log(Users, Orders);
 
-Users.add({ message: "Users.add Test" }, function (err, results) {
-  if (err) console.log(err);
-  else console.log(results);
-});
+const results = await Users.add({ message: "Users.add Test" });
+
+console.log(results);
 
 const response = await Orders.find("hello", "world");
 
@@ -129,19 +126,18 @@ console.log(response);
 
 ## Sending and Receiving Websocket Events
 
-We can also receive WebSocket events emitted from the remote objects we've loaded using the `Client.loadService(url)` function. In the example below we're using the `Users.on(event_name, callback)` method to listen for events coming from the "Users" _ServerModule_.
+We can also receive WebSocket events emitted from the remote objects we've loaded using the `Client.loadService(url)` function. In the example below we're using the `Users.on(event_name, callback)` method to listen for events coming from the "Users" **ServerModule**.
 
 ```javascript
-const { Client } = require("sht-tasks");
+const { Client } = require("systemlynx");
 
 const { Users, Orders } = await Client.loadService("http://localhost:4400/test/service");
 
 console.log(Users, Orders);
 
-Users.add({ message: "Users.add Test" }, function (err, results) {
-  if (err) console.log(err);
-  else console.log(results);
-});
+const results = await Users.add({ message: "Users.add Test" });
+
+console.log(results);
 
 Users.on("new_user", function (event) {
   console.log(event);
@@ -152,17 +148,17 @@ const response = await Orders.find("hello", "world");
 console.log(response);
 ```
 
-Now let's go to our server application and call the `Users.emit(event_name, data)` method to emit a websocket event that can be received by its corresponding Clients. Below, notice that we've added `Users.emit("new_user", { message:"new_user event test" })` at the end of the `Users.add` method, so the `new_user` event will be emitted every time this method is called.
+Now let's go to our server application and call the `this.emit(event_name, data)` method to emit a websocket event that can be received by its corresponding Clients. Below, notice that we've added `this.emit("new_user", { message:"new_user event test" })` at the end of the `Users.add` method, so the `new_user` event will be emitted every time this method is called. The `this` value of a **ServerModule** method will always be scoped to the **ServerModule** itself.
 
 ```javascript
-const { Service } = require("sht-tasks");
+const { Service } = require("systemlynx");
 
 const Users = {};
 
-Users.add = function (data, callback) {
+Users.add = function (data) {
   console.log(data);
-  callback(null, { message: "You have successfully called the Users.add method" });
-  Users.emit("new_user", { message: "new_user event test" });
+  return { message: "You have successfully called the Users.add method" };
+  this.emit("new_user", { message: "new_user event test" });
 };
 
 Service.ServerModule("Users", Users);
@@ -170,9 +166,9 @@ Service.ServerModule("Users", Users);
 Service.ServerModule("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2, callback) {
+  Orders.find = function (arg1, arg2) {
     console.log(data);
-    callback(null, { message: "You have successfully called the Orders.find method" });
+    return { message: "You have successfully called the Orders.find method" };
   };
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systemlynx",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/systemlynx/App/components/loadModules.js

@@ -10,5 +10,5 @@ module.exports = async function loadModules(system) {
     system.Service.ServerModule(name, __constructor)
   );
   if (system.routing) await system.Service.startService(system.routing);
-  system.App.emit("init_complete", system);
+  system.App.emit("ready", system);
 };

package/systemlynx/App/tests/App.test.js

@@ -45,7 +45,7 @@ describe("App: Loading Services", () => {
     await new Promise((resolve) => {
       const App = AppFactory();
       App.loadService("test", `http://localhost:${port}/${route}`).on(
-        "init_complete",
+        "ready",
         (system) => {
           expect(system.Services[0]).to.be.an("object");
 
@@ -151,7 +151,7 @@ describe("App: Loading Services", () => {
             .that.respondsTo("resetConnection");
           resolve();
         })
-        .on("init_complete", resolve);
+        .on("ready", resolve);
     });
   });
 });
@@ -189,7 +189,7 @@ describe("App SystemObjects: Initializing Modules,  ServerModules and configurat
     const url = `http://localhost:${port}/${route}`;
 
     await new Promise((resolve) =>
-      App.startService({ route, port }).on("init_complete", resolve)
+      App.startService({ route, port }).on("ready", resolve)
     );
     const connData = await HttpClient.request({ url });
 
@@ -223,7 +223,7 @@ describe("App SystemObjects: Initializing Modules,  ServerModules and configurat
           this.test = () => {};
           this.test2 = () => {};
         })
-        .on("init_complete", resolve)
+        .on("ready", resolve)
     );
 
     const connData = await HttpClient.request({ url });
@@ -253,7 +253,7 @@ describe("App SystemObjects: Initializing Modules,  ServerModules and configurat
     ]);
   });
 
-  it('should be able to use App.on("init_complete", callback) fire a callback when App initialization is complete', async () => {
+  it('should be able to use App.on("ready", callback) fire a callback when App initialization is complete', async () => {
     const App = AppFactory();
 
     App.ServerModule("mod", function () {
@@ -265,7 +265,7 @@ describe("App SystemObjects: Initializing Modules,  ServerModules and configurat
     });
 
     await new Promise((resolve) =>
-      App.on("init_complete", (system) => {
+      App.on("ready", (system) => {
         expect(system)
           .to.be.an("object")
           .that.has.all.keys(
@@ -303,7 +303,7 @@ describe("App SystemObjects: Initializing Modules,  ServerModules and configurat
       });
 
     await new Promise((resolve) =>
-      App.on("init_complete", ({ configurations }) => {
+      App.on("ready", ({ configurations }) => {
         expect(configurations)
           .to.be.an("object")
           .that.has.all.keys("module", "__constructor")
@@ -349,6 +349,6 @@ describe("SystemObjects", () => {
         this.configPassed = true;
         next();
       });
-    return new Promise((resolve) => App.on("init_complete", () => resolve()));
+    return new Promise((resolve) => App.on("ready", () => resolve()));
   });
 });

package/systemlynx/ServerManager/ServerManager.js

@@ -16,10 +16,7 @@ module.exports = function SystemLynxServerManager() {
     useREST: false,
     useService: true,
     staticRouting: false,
-    validateArgs: true,
     middleware: [],
-    useCallbacks: true,
-    useReturnValues: false,
   };
   const server = SystemLynxServer();
   const router = SystemLynxRouter(server, () => serverConfigurations);