Change semi rule to enforce semicolons

Signed-off-by: trivernis <trivernis@protonmail.com>

.eslintrc.json

@@ -24,8 +24,9 @@
         "max-classes-per-file": 0,
         "no-var-requires": 0,
         "array-type": 0,
-        "semi": 1,
-        "semi-style": ["error", "last"]
+        "semi": ["error", "always"],
+        "semi-style": ["error", "last"],
+        "no-extra-semi": "off"
       }
 
 }

src/datasources/db/cargobikeAPI.ts

@@ -1,14 +1,14 @@
-import { DataSource } from 'apollo-datasource'
-import { getConnection, Connection } from 'typeorm'
-import { CargoBike } from '../../model/CargoBike'
+import { DataSource } from 'apollo-datasource';
+import { getConnection, Connection } from 'typeorm';
+import { CargoBike } from '../../model/CargoBike';
 /**
  * extended datasource to feed resolvers with data about cargoBikes
  */
 export class CargoBikeAPI extends DataSource {
     connection : Connection
     constructor () {
-        super()
-        this.connection = getConnection()
+        super();
+        this.connection = getConnection();
     }
 
     /**
@@ -18,15 +18,15 @@ export class CargoBikeAPI extends DataSource {
         return {
             id,
             name: token
-        }
+        };
     }
 
     async updateBike ({ id, token, name }:{id:any, token: string, name: string }) {
-        const bike = new CargoBike()
-        bike.id = id
-        bike.description = token
-        bike.name = name
-        await this.connection.manager.save(bike)
+        const bike = new CargoBike();
+        bike.id = id;
+        bike.description = token;
+        bike.name = name;
+        await this.connection.manager.save(bike);
         return {
             success: true,
             message: token,
@@ -34,6 +34,6 @@ export class CargoBikeAPI extends DataSource {
                 id,
                 name
             }
-        }
+        };
     }
 }

src/datasources/userserver/message.ts

@@ -1,43 +1,43 @@
-import { encode, decode } from 'messagepack'
-import { Method } from './method'
-import { crc32 } from 'crc'
+import { encode, decode } from 'messagepack';
+import { Method } from './method';
+import { crc32 } from 'crc';
 
 export class RPCMessage<T> {
     private readonly method: Method
     readonly data: T
 
     constructor (method: Method, data: any) {
-        this.method = method
-        this.data = data
+        this.method = method;
+        this.data = data;
     }
 
     static fromBuffer<T> (raw: Buffer): RPCMessage<T> {
-        const length = raw.readUInt32BE()
+        const length = raw.readUInt32BE();
         if (raw.length !== length) {
-            throw new Error('Invalid Buffer length')
+            throw new Error('Invalid Buffer length');
         }
-        const crcNum = raw.readUInt32BE(length - 4)
+        const crcNum = raw.readUInt32BE(length - 4);
 
         if (crc32(raw.slice(0, length - 4)) !== crcNum) {
-            throw new Error('Validation check failed')
+            throw new Error('Validation check failed');
         }
-        const method = raw.readUInt32BE(4)
-        const msgData = decode(raw.slice(8, length))
+        const method = raw.readUInt32BE(4);
+        const msgData = decode(raw.slice(8, length));
 
-        return new RPCMessage(method, msgData)
+        return new RPCMessage(method, msgData);
     }
 
     public toBuffer (): Buffer {
-        const msgData = encode(this.data)
-        const length = msgData.length + 12
-        const buffer = Buffer.alloc(length - 4)
-        buffer.writeUInt32BE(length)
-        buffer.writeUInt32BE(this.method, 4)
-        buffer.fill(msgData, 8)
-        const crcNum = crc32(buffer)
-        const resultBuffer = Buffer.alloc(length, buffer)
-        resultBuffer.writeUInt32BE(crcNum, length - 4)
+        const msgData = encode(this.data);
+        const length = msgData.length + 12;
+        const buffer = Buffer.alloc(length - 4);
+        buffer.writeUInt32BE(length);
+        buffer.writeUInt32BE(this.method, 4);
+        buffer.fill(msgData, 8);
+        const crcNum = crc32(buffer);
+        const resultBuffer = Buffer.alloc(length, buffer);
+        resultBuffer.writeUInt32BE(crcNum, length - 4);
 
-        return resultBuffer
+        return resultBuffer;
     }
 }

src/datasources/userserver/permission.ts

@@ -14,4 +14,4 @@ export const requiredPermissions = [
         name: Permission.WriteBike,
         description: 'Allows the modification of bike information'
     }
-]
+];

src/datasources/userserver/userserviceAPI.ts

@@ -1,16 +1,16 @@
-import { DataSource } from 'apollo-datasource'
-import { Socket } from 'net'
-import { PromiseSocket } from 'promise-socket'
-import { RPCMessage } from './message'
-import { Method } from './method'
+import { DataSource } from 'apollo-datasource';
+import { Socket } from 'net';
+import { PromiseSocket } from 'promise-socket';
+import { RPCMessage } from './message';
+import { Method } from './method';
 import {
     CreateRoleResponse,
     GetInfoResponse,
     GetRolesPermissionsResponse,
     GetRolesResponse,
     ValidateTokenResponse
-} from './responses'
-import { Permission, requiredPermissions } from './permission'
+} from './responses';
+import { Permission, requiredPermissions } from './permission';
 
 /**
  * fetches datafrom user server, especially validates user tokens
@@ -20,13 +20,13 @@ export class UserServerAPI extends DataSource {
     host: string
 
     constructor (address: string) {
-        super()
-        const parts = address.split(':')
-        this.host = parts[0]
+        super();
+        const parts = address.split(':');
+        this.host = parts[0];
         if (parts.length === 2) {
-            this.port = Number(parts[1])
+            this.port = Number(parts[1]);
         } else {
-            this.port = 5000
+            this.port = 5000;
         }
     }
 
@@ -34,16 +34,16 @@ export class UserServerAPI extends DataSource {
      * Returns the information about all available rpc methods
      */
     async getInfo (): Promise<GetInfoResponse> {
-        const response = await this.send<GetInfoResponse>(new RPCMessage(Method.Info, null))
+        const response = await this.send<GetInfoResponse>(new RPCMessage(Method.Info, null));
 
-        return response.data
+        return response.data;
     }
 
     /**
      * Creates required API permissions
      */
     async createDefinedPermissions () {
-        await this.send<any>(new RPCMessage(Method.CreatePermissions, { permissions: requiredPermissions }))
+        await this.send<any>(new RPCMessage(Method.CreatePermissions, { permissions: requiredPermissions }));
     }
 
     /**
@@ -57,20 +57,20 @@ export class UserServerAPI extends DataSource {
             name,
             description,
             permissions: permissionIDs
-        }))
+        }));
 
-        return response.data
+        return response.data;
     }
 
     /**
      * validates user token
      */
     async validateToken (token:string): Promise<boolean> {
-        const response = await this.send<ValidateTokenResponse>(new RPCMessage(Method.ValidateToken, { token }))
+        const response = await this.send<ValidateTokenResponse>(new RPCMessage(Method.ValidateToken, { token }));
         if (response) {
-            return response.data[0]
+            return response.data[0];
         } else {
-            return false
+            return false;
         }
     }
 
@@ -79,8 +79,8 @@ export class UserServerAPI extends DataSource {
      * @param token
      */
     async getUserRoles (token: String): Promise<GetRolesResponse> {
-        const response = await this.send<any>(new RPCMessage(Method.GetRoles, { token }))
-        return response.data
+        const response = await this.send<any>(new RPCMessage(Method.GetRoles, { token }));
+        return response.data;
     }
 
     /**
@@ -88,27 +88,27 @@ export class UserServerAPI extends DataSource {
      * @param token
      */
     async getUserPermissions (token: String): Promise<string[]> {
-        const roles = await this.getUserRoles(token)
-        const roleIds = roles.map(role => role[0])
-        const permissionsResponse = await this.send<GetRolesPermissionsResponse>(new RPCMessage(Method.GetRolePermissions, { roles: roleIds }))
-        const permissions: string[] = []
+        const roles = await this.getUserRoles(token);
+        const roleIds = roles.map(role => role[0]);
+        const permissionsResponse = await this.send<GetRolesPermissionsResponse>(new RPCMessage(Method.GetRolePermissions, { roles: roleIds }));
+        const permissions: string[] = [];
 
         for (const id of roleIds) {
-            permissions.push(...permissionsResponse.data[id].map(entry => entry[1]))
+            permissions.push(...permissionsResponse.data[id].map(entry => entry[1]));
         }
 
-        return permissions
+        return permissions;
     }
 
     /**
      * Connects to the socket and returns the client
      */
     async getSocket (): Promise<PromiseSocket<Socket>> {
-        const socket = new Socket()
-        const promiseSocket = new PromiseSocket(socket)
-        await promiseSocket.connect(this.port, this.host)
+        const socket = new Socket();
+        const promiseSocket = new PromiseSocket(socket);
+        await promiseSocket.connect(this.port, this.host);
 
-        return promiseSocket
+        return promiseSocket;
     }
 
     /**
@@ -116,12 +116,12 @@ export class UserServerAPI extends DataSource {
      * @param message
      */
     async send<T> (message: RPCMessage<any>): Promise<RPCMessage<T>> {
-        const socket = await this.getSocket()
-        await socket.writeAll(message.toBuffer())
-        const response = await socket.readAll() as Buffer
+        const socket = await this.getSocket();
+        await socket.writeAll(message.toBuffer());
+        const response = await socket.readAll() as Buffer;
 
         if (response?.length > 0) {
-            return RPCMessage.fromBuffer<T>(response)
+            return RPCMessage.fromBuffer<T>(response);
         }
     }
 }

src/index.ts

@@ -1,14 +1,14 @@
-import { ApolloServer } from 'apollo-server-express'
-import bikeresolver from './resolvers/cargobikeResolver'
-import { CargoBikeAPI } from './datasources/db/cargobikeAPI'
-import typeDefs from './schema/type-defs'
-import 'reflect-metadata'
-import { createConnection } from 'typeorm'
-import { UserServerAPI } from './datasources/userserver/userserviceAPI'
-import express from 'express'
-import { requiredPermissions } from './datasources/userserver/permission'
+import { ApolloServer } from 'apollo-server-express';
+import bikeresolver from './resolvers/cargobikeResolver';
+import { CargoBikeAPI } from './datasources/db/cargobikeAPI';
+import typeDefs from './schema/type-defs';
+import 'reflect-metadata';
+import { createConnection } from 'typeorm';
+import { UserServerAPI } from './datasources/userserver/userserviceAPI';
+import express from 'express';
+import { requiredPermissions } from './datasources/userserver/permission';
 
-require('dotenv').config()
+require('dotenv').config();
 
 /**
  * Function that is called to authenticate a user by using the user rpc server
@@ -18,30 +18,30 @@ require('dotenv').config()
  */
 async function authenticate (req: any, res: any, next: any) {
     if (process.env.NODE_ENV === 'develop') {
-        req.permissions = requiredPermissions.map((e) => e.name)
-        next()
+        req.permissions = requiredPermissions.map((e) => e.name);
+        next();
     } else {
-        const token = req.headers.authorization?.replace('Bearer ', '')
+        const token = req.headers.authorization?.replace('Bearer ', '');
         if (token) {
             if (await userAPI.validateToken(token)) {
-                req.permissions = await userAPI.getUserPermissions(token)
-                next()
+                req.permissions = await userAPI.getUserPermissions(token);
+                next();
             } else {
-                res.status(401)
-                res.send('Unauthorized')
+                res.status(401);
+                res.send('Unauthorized');
             }
         } else {
-            res.status(401)
-            res.send('Unauthorized')
+            res.status(401);
+            res.send('Unauthorized');
         }
     }
 }
 
 createConnection().then(async () => {
-    console.log('connected to db')
-}).catch(error => console.log(error))
+    console.log('connected to db');
+}).catch(error => console.log(error));
 
-const userAPI = new UserServerAPI(process.env.RPC_HOST)
+const userAPI = new UserServerAPI(process.env.RPC_HOST);
 
 const server = new ApolloServer({
     resolvers: [bikeresolver],
@@ -51,18 +51,18 @@ const server = new ApolloServer({
         userAPI
     }),
     context: (req: any) => {
-        return req
+        return req;
     }
-})
+});
 
-const app = express()
+const app = express();
 
-app.post('/graphql', authenticate)
-app.get(/\/graphql?&.*query=/, authenticate)
-server.applyMiddleware({ app })
+app.post('/graphql', authenticate);
+app.get(/\/graphql?&.*query=/, authenticate);
+server.applyMiddleware({ app });
 
-console.log(__dirname)
+console.log(__dirname);
 app.listen(4000, async () => {
-    console.log('Server listening on port 4000')
-    await userAPI.createDefinedPermissions()
-})
+    console.log('Server listening on port 4000');
+    await userAPI.createDefinedPermissions();
+});

src/model/CargoBike.ts

@@ -1,4 +1,4 @@
-import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm'
+import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity()
 export class CargoBike {

src/resolvers/cargobikeResolver.ts

@@ -1,23 +1,23 @@
-import { Permission } from '../datasources/userserver/permission'
-import { GraphQLError } from 'graphql'
+import { Permission } from '../datasources/userserver/permission';
+import { GraphQLError } from 'graphql';
 
 export default {
     Query: {
         CargobikeById: (_: any, { id, token }:{id: any, token: string}, { dataSources, req }:{dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadBike)) {
-                return dataSources.cargoBikeAPI.findCargoBikeById({ id, token })
+                return dataSources.cargoBikeAPI.findCargoBikeById({ id, token });
             } else {
-                throw new GraphQLError('Insufficient Permissions')
+                throw new GraphQLError('Insufficient Permissions');
             }
         }
     },
     Mutation: {
         addBike: (_: any, { id, token, name }:{id: any, token: string, name:string}, { dataSources, req }:{dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.WriteBike)) {
-                return dataSources.cargoBikeAPI.updateBike({ id, token, name })
+                return dataSources.cargoBikeAPI.updateBike({ id, token, name });
             } else {
-                throw new GraphQLError('Insufficient Permissions')
-            }
+                throw new GraphQLError('Insufficient Permissions');
             }
         }
     }
+};

src/schema/type-defs.ts

@@ -1,4 +1,4 @@
-import { gql } from 'apollo-server'
+import { gql } from 'apollo-server';
 
 export default gql`
 
@@ -355,4 +355,4 @@ type Mutation {
     cargoBike(token:String!,cargoBike: CargoBikeInput): UpdateBikeResponse!
 }
 
-`
+`;