Added findUser implementation

- added findUser to the graphql resolvers
- changed default limit to 20
- removed special worker logging
- added error handling for worker initialization

src/app.ts

@@ -82,11 +82,10 @@ class App {
         }
         this.app.use((req, res, next) => {
             logger.verbose(`${req.method} ${req.url}`);
-            process.send({cmd: "notifyRequest"});
             next();
         });
         this.app.use(routes.router);
-        // listen for graphql requrest
+        // listen for graphql requests
         this.app.use("/graphql",  graphqlHTTP((request, response) => {
             return {
                 // @ts-ignore all

src/graphql/resolvers.ts

@@ -7,6 +7,7 @@ import globals from "../lib/globals";
 import {InternalEvents} from "../lib/InternalEvents";
 import * as models from "../lib/models";
 import {is} from "../lib/regex";
+import {Op} from "sequelize";
 
 /**
  * Returns the resolvers for the graphql api.
@@ -15,6 +16,17 @@ import {is} from "../lib/regex";
  */
 export function resolver(req: any, res: any): any {
     return {
+        async findUser({first, offset, name, handle}:
+                           {first: number, offset: number, name: string, handle: string}) {
+            if (name) {
+                return models.User.findAll({where: {username: {[Op.like]: `%${name}%`}}, offset, limit: first});
+            } else if (handle) {
+                return models.User.findAll({where: {handle: {[Op.like]: `%${handle}%`}}, offset, limit: first});
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No search parameters provided.");
+            }
+        },
         async getSelf() {
             if (req.session.userId) {
                 return models.User.findByPk(req.session.userId);

src/graphql/schema.graphql

@@ -17,11 +17,8 @@ type Query {
     "returns the request object for its id"
     getRequest(requestId: ID!): Request
 
-    "find a post by the posted date or content"
-    findPost(first: Int, offset: Int, text: String!, postedDate: String): [Post]
-
     "find a user by user name or handle"
-    findUser(first: Int, offset: Int, name: String, handle: String): [User]
+    findUser(first: Int = 20, offset: Int = 0, name: String, handle: String): [User]
 
     "returns the post filtered by the sort type with pagination."
     getPosts(first: Int=20, offset: Int=0, sort: SortType = NEW): [Post]

src/index.ts

@@ -16,61 +16,19 @@ interface IClusterData {
 
 if (cluster.isMaster) {
     console.log(`[CLUSTER-M] Master ${process.pid} is running`);
-    const clusterData: IClusterData = {
-        reqCount: 0,
-        workerCount: () => Object.keys(cluster.workers).length,
-        // @ts-ignore
-        workerRes: {},
-    };
 
-    setInterval(() => {
-            clusterData.workerRes.M = {
-                cpu: process.cpuUsage(),
-                mem: process.memoryUsage(),
-            };
-    }, 1000);
-
-    const log = (msg: string) => {
-        process.stdout.write(" ".padEnd(100) + "\r");
-        process.stdout.write(msg);
-        process.stdout.write(
-            `W: ${clusterData.workerCount()},R: ${clusterData.reqCount},M: ${(() => {
-                let usageString = "";
-                for (const [key, value] of Object.entries(clusterData.workerRes)) {
-                    usageString += `${
-                        Math.round((value as IResourceUsage).mem.heapUsed / 100000) / 10}MB,`.padEnd(8);
-                }
-                return usageString;
-            })()}`.padEnd(99) + "\r");
-    };
     cluster.settings.silent = true;
 
-    cluster.on("exit", (worker, code, signal) => {
+    cluster.on("exit", (worker, code) => {
-        log(`[CLUSTER-M] Worker ${worker.process.pid} died!\n`);
+        console.error(`[CLUSTER-M] Worker ${worker.id} died! (code: ${code})`);
-        delete clusterData.workerRes[worker.id];
+        console.log("[CLUSTER-M] Starting new worker");
-        log("[CLUSTER-M] Starting new worker\n");
         cluster.fork();
     });
     cluster.on("online", (worker) => {
         worker.process.stdout.on("data", (data) => {
-            log(`[CLUSTER-${worker.id}] ${data}`);
+            process.stdout.write(`[CLUSTER-${worker.id}] ${data}`);
         });
     });
-    cluster.on("message", (worker, message) => {
-        switch (message.cmd) {
-            case "notifyRequest":
-                clusterData.reqCount++;
-                log("");
-                break;
-            case "notifyResources":
-                // @ts-ignore
-                clusterData.workerRes[worker.id] = message.data;
-                log("");
-                break;
-            default:
-                break;
-        }
-    });
 
     for (let i = 0; i < numCPUs; i++) {
         cluster.fork();
@@ -81,15 +39,15 @@ if (cluster.isMaster) {
      * async main function wrapper.
      */
     (async () => {
-        setInterval(() => {
+        try {
-            process.send({cmd: "notifyResources", data: {
-                cpu: process.cpuUsage(),
-                mem: process.memoryUsage(),
-            }});
-        }, 1000);
             const app = new App(cluster.worker.id);
             await app.init();
             app.start();
+        } catch (err) {
+            console.error(err.message);
+            console.error(err.stack);
+            process.exit(1);
+        }
     })();
 
     console.log(`[CLUSTER] Worker ${process.pid} started`);