set up querying and mutations and MySQL queries

Co-authored-by: Johnny <[email protected]>

Author: root

.gitignore

@@ -1,2 +1,4 @@
 node_modules
-package-lock.json
+package-lock.json
+nohup.out
+build

.vscode/settings.json

@@ -1 +1,4 @@
-123,125
+{
+    "extensions.ignoreRecommendations": true,
+    "files.autoSave": "off"
+}

build/index.js

@@ -0,0 +1,4 @@
+const ws = require("ws");
+
+var asdf = new ws("http://api.osn-reo.org:5000");
+

client.js

@@ -4,15 +4,22 @@
   "description": "API routing for mobile app",
   "main": "index.js",
   "dependencies": {
-    "@types/node": "^14.0.27",
-    "express": "^4.17.1",
-    "express-graphql": "^0.11.0",
+    "apollo-datasource": "^0.7.2",
+    "apollo-datasource-rest": "^0.9.3",
+    "apollo-server": "^2.16.1",
     "firebase-admin": "^9.0.0",
-    "graphql": "^15.3.0"
+    "google-auth-library": "^6.0.6",
+    "graphql": "^15.3.0",
+    "mysql": "^2.18.1",
+    "ws": "^7.3.1"
+  },
+  "devDependencies": {
+    "@types/graphql": "^14.5.0",
+    "@types/node": "^14.0.27"
   },
-  "devDependencies": {},
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node build/server.js"
   },
   "repository": {
     "type": "git",

mysql_sample_db/mysqlsampledatabase.sql

@@ -0,0 +1,48 @@
+import { rootCertificates } from "tls";
+
+export {};
+
+
+module.exports = {
+    UserInterface: {
+        __resolveType(user, context, info){
+            if(user.isAvailable){
+                return 'Tutor'
+            }
+            else return 'Student'
+        }
+    },
+    
+    Query:{
+        hello: ()=>{
+            return "Hello World!";
+        },
+        getUserById: (_, { id }, { dataSources })=> dataSources.db.getUserById(id),
+        getMessageById: (_, { id })=>{
+            var messages = {
+                1:{
+                    "id": 1,
+                    "author": {
+                        "id": 1,
+                        "displayName": "johney"
+                    },
+                    "content":"hello world",
+                    "timestamp": "8/11/2020"
+                },
+                2:{
+                    "id": 1,
+                    "author": {
+                        "id": 2,
+                        "displayName": "bort"
+                    },
+                    "content":"hello world",
+                    "timestamp": "8/11/2020"
+                }
+            }
+            return messages[id];
+        }
+    },
+    Mutation:{
+        addUser: (_, {displayName }, { dataSources })=> dataSources.db.addUser(displayName)
+    }
+}

mysql_sample_db/sample_db.zip

@@ -0,0 +1,58 @@
+export {};
+const { gql } = require("apollo-server");
+
+const typeDefs = gql`
+    interface UserInterface{
+        id: Int!
+        displayName: String!
+    }
+
+    type User{
+        id: Int!
+        displayName: String!
+    }
+
+    type Tutor implements UserInterface{
+        id: Int!
+        displayName: String!
+        tutoredSubjects: [String!]!
+        isAvailable: Boolean!
+    }
+
+    type Student implements UserInterface{
+        id: Int!
+        displayName: String!
+    }
+
+    type Message{
+        id: Int!
+        author: UserInterface!
+        content: String!
+        timestamp: String!
+    }
+
+    type Channel{
+        id: ID!
+        users: [UserInterface!]!
+        messages: [Message!]!
+    }
+
+    type RequestTutorReturn{
+        requestId: ID!
+        assignedTutor: Tutor!
+    }
+
+    type Query{
+        requestTutor(reqBy: ID!, subject: String!, timestamp: String!): RequestTutorReturn
+        getUserById(id: Int!): UserInterface
+        getMessageById(id: Int!): Message
+        hello: String
+    }
+
+    type Mutation{
+        deleteMessageById(id: ID!): Int!
+        addUser(displayName: String!): UserInterface
+    }
+`;
+
+module.exports = typeDefs;

package.json

@@ -0,0 +1,63 @@
+export {};
+const { ApolloServer } = require("apollo-server");
+const mysql = require('mysql');
+const typeDefs = require("./schema");
+const resolvers = require("./resolvers");
+const SQLSource = require("./sql_datasource");
+const fs = require("fs");
+const ws = require("ws");
+const socket_server_port = 5000;
+//const dbSource = require('./db')
+
+//websocket server stuff
+
+
+
+//apollo graph ql stuff
+var db = createStore();
+
+const server = new ApolloServer({
+    typeDefs,
+    resolvers,
+    dataSources: ()=>({
+        "db": new SQLSource(db)
+    }),
+    context: ({req})=>{
+        if(req.headers.authorization != "bread123") throw new Error("Unauthorized");
+    }
+});
+
+function createStore(){
+    var db = mysql.createConnection({
+        host: 'localhost',
+        user: 'root',
+        password: 'bread123',
+        database: 'test_db',
+        insecureAuth: true,
+        multipleStatements: true
+    })
+    db.connect(function(err){
+        if(err) throw err;
+        console.log('Connected Successfully')
+    });
+    fs.readdir("./stored_procedures/", (err, files)=>{
+        if(err) throw err;
+        files.forEach(file => {
+            fs.readFile('./stored_procedures/'+file, 'utf-8', async function(err, contents){
+                if(err) throw err;
+                new Promise((resolve, reject)=>{
+                    db.query(contents), function(err, res, fields){
+                        if(err) reject(err);
+                        resolve();
+                    }
+                })
+            })
+        });
+    })
+    return db;
+}
+
+
+server.listen({port: 80}).then(({ url }: any)=>{
+    console.log(`Server started on ${url}`);
+});

src/index.ts

@@ -0,0 +1,47 @@
+import { exception } from "console";
+
+export {};
+const { DataSource } = require("apollo-datasource");
+const mysql = require('mysql');
+
+class SQLSource extends DataSource {
+    constructor(db){
+        super();
+        this.store = db;
+        this.connected = [];
+        console.log('done');
+    }
+    initialize (config){
+        this.context = config.context;
+    }
+    async getUserById(id){
+        try{
+            var queryReturn = await this.query("select * from users where id = " + id);
+            return queryReturn[0];
+        }catch(err){
+            //if promise rejects;
+        }
+        
+    }
+
+    async addUser(displayName){
+        var queryReturn = await this.query(`call insert_user("?")`, [ displayName ]);
+        console.log(queryReturn);
+        return queryReturn[0][0];
+    }
+    
+    query(selector, params=[]){
+        return new Promise((resolve, reject)=>{
+            this.store.query(selector, params, function(err, res, fields){
+                if(err) reject(err);
+                resolve(res);
+            });
+        });
+    }
+
+    addConnectedWs(ws: WebSocket){
+        this.connected.push(ws);
+    }
+}
+
+module.exports = SQLSource;

src/resolvers.ts

@@ -0,0 +1,25 @@
+
+export {};
+const ws = require("ws");
+const socket_server_port = 5000;
+
+const wss= new ws.Server({
+    "port": socket_server_port
+});
+
+var connected = {
+    //id: websocket connection
+};
+wss.on("connection", (ws: WebSocket, req: Request)=>{
+    var id = req.body.id;
+    connected[id] = ws;
+    console.log("websocket connected");
+});
+
+function sendMessage(id, message){
+    connected[id].sendMessage(message);
+}
+
+module.exports = {
+    
+};

src/schema.ts

@@ -0,0 +1,4 @@
+create table if not exists users(
+    id int auto_increment primary key,
+    displayName VARCHAR(255) not null
+);

src/server.ts

@@ -0,0 +1,6 @@
+drop procedure if exists insert_user;
+create procedure insert_user(in p_displayName varchar(255))
+begin
+    insert into users (displayName) values (p_displayName);
+    select * from users where id = last_insert_id();
+end