push

package-lock.json

       }
     },
     "rpclibrary": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.4.0.tgz",
-      "integrity": "sha512-JUU7+HymV2ZTI+NrIVOiIr5LGFoRsPq4k/ffdUonqIpd9fjOHBQ2/PFLVXx9z94+dKxdqN8/D9ZXPwU03ovZrg==",
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.4.1.tgz",
+      "integrity": "sha512-Tv9zOBVT8JFMZfTJgmnX9vvUvtALCDtj/cnlYw2SxsFnj1MuH9VgPniSfThUgdwZZknjFuYVfhLaYb9Yl+eRxQ==",
       "requires": {
         "bsock": "^0.1.9",
         "http": "0.0.0",

package.json

     "node-fetch": "^2.6.0",
     "path": "^0.12.7",
     "rimraf": "^3.0.0",
-    "rpclibrary": "^1.4.0",
+    "rpclibrary": "^1.4.1",
     "simple-git": "^1.124.0",
     "spawn-sync": "^2.0.0",
     "sqlite3": "^4.1.0",

src/backend/Admin/Admin.ts

 
         this.knex = Knex(conf)
     
-        await Promise.all(this.getTableDefinitions().map(async (def)=>{
-            const hasTable = await this.knex.schema.hasTable(def.name)
-            if(!hasTable){
-                await this.knex.schema.createTable(def.name, def.tableBuilder)
-            }
-        }))
+        await Promise.all(
+            this.getTableDefinitions()
+            //make unique by name
+            .filter((other, index, self) => index === self.findIndex(
+                (self) => self.name === other.name)
+            )
+            //create table if not exists
+            .map(async (def)=> {
+                const hasTable = await this.knex.schema.hasTable(def.name)
+                if(!hasTable)
+                    return await this.knex.schema.createTable(def.name, def.tableBuilder)
+            })
+        )
         
         return this.knex
     }

src/backend/Components/Item/ItemManager.ts

         const allItems = [...T1]
         const countCache = await this.countItems()
         if(countCache != allItems.length){
-            const items:Item[] = await Promise.all(allItems.map(async (i) => this.getItem(i)))
+            const items:Item[] = await Promise.all(allItems.map((i) => this.getItem(i)))
             try{
                 await this.admin
                 .knex('items')
                 .insert(items)
             }catch(e){
-                console.error(e)
+                console.info("Skipping item insertion")
             }
         }
     }

src/backend/Components/Login/LoginManager.ts

 import { RPCServer } from "rpclibrary";
-import { TableDefiniton, AnyRPCExporter, User, RPCPermission, _Rank, Token, Auth } from "../../Types/Types";
+import { TableDefiniton, AnyRPCExporter, User, RPCPermission, _Rank, Token, Auth, FrontcraftFeatureIfc, Rank } from "../../Types/Types";
 import { FrontworkAdmin } from "../../Admin/Admin";
 import { PrivilegedRPCExporter } from "../../Types/PrivilegedRPCExporter";
 import { FrontworkComponent } from "../../Types/FrontworkComponent";
             },{
                 name: 'rpcpermissions',
                 tableBuilder: (table) => {
-                    table.string("rpcName").primary().notNullable()
+                    table.string("name").primary().notNullable()
                     table.boolean("ADMIN").defaultTo(true).notNullable()
                     _Rank.forEach(r => table.boolean(r).defaultTo(false).notNullable())
                 }
 
     async initialize(){
         await Promise.all( 
-            [this, ...this.exporters].flatMap(exp => exp.exportRPCFeatures().map(async (rpc) => {
+            [this, ...this.exporters].flatMap(exp => exp.exportRPCFeatures().map(async (feature) => {
             try{
-                await this.admin.knex.insert({ rpcname: rpc.name }).into('rpcpermissions')
+                await this.admin.knex.insert({ name: feature.name }).into('rpcpermissions')
             }catch(e){}
         })))
 
         return await this.admin.knex.select('*').from('rpcpermissions')
     }
 
+    getPermission = async (feature: keyof FrontcraftFeatureIfc, rank:Rank) : Promise<boolean> => {
+        const perm : RPCPermission[] = await this.admin.knex
+            .select(rank)
+            .from('rpcpermissions')
+            .where('name', '=', feature)
+
+        if(perm.length === 0) return false
+        return perm[0][rank]
+    }
+
     getRPCForUser = async (user:User): Promise<AnyRPCExporter[]> => {
-        return [...this.exportRPCFeatures(), ...this.exporters.flatMap((exp) => exp.exportRPCFeatures())]
+        return [
+            ...this.exportRPCFeatures(), 
+            ...this.exporters.flatMap((exp) => exp.exportRPCFeatures())
+        ].filter(async (feature) => await this.getPermission(<keyof FrontcraftFeatureIfc> feature.name, user.rank))
     }
 
     createUser = async(user:User): Promise<User> => {

src/backend/Types/Types.ts

         getSingups: (raid:Raid) => Promise<Signup[]>
         sign: (user:User, raid:Raid, attending:boolean) => Promise<any>
     }
+}
+
+export type SomeOf<T> = {
+    [K in keyof T]? : T[K]
 }

src/frontend/package-lock.json

       "integrity": "sha512-ZYzRkETgBrdEGzL5JSKimvjI2CX7ioyZCkX2BpcfyjqI+079W0wHAyj5W4rIZMcDSOHgLZtgz1IdDi/vU77KEQ=="
     },
     "rpclibrary": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.4.0.tgz",
-      "integrity": "sha512-JUU7+HymV2ZTI+NrIVOiIr5LGFoRsPq4k/ffdUonqIpd9fjOHBQ2/PFLVXx9z94+dKxdqN8/D9ZXPwU03ovZrg==",
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.4.2.tgz",
+      "integrity": "sha512-IFigD+65a9MM+1AgEH5nurUzCyMg9hawqtnOA67/PtTGP5GsnWxaFESKl03k8L/PQ8ptZkWcub/63bfxkrwyMw==",
       "requires": {
         "bsock": "^0.1.9",
         "http": "0.0.0",

src/frontend/package.json

     "normalize.css": "6.0.0",
     "pace-js": "1.0.2",
     "roboto-fontface": "0.8.0",
-    "rpclibrary": "^1.4.0",
+    "rpclibrary": "^1.4.2",
     "rxjs": "6.5.2",
     "rxjs-compat": "6.3.0",
     "socicon": "3.0.5",

src/frontend/src/app/app.component.ts

 
   ngOnInit(): void {
     this.analytics.trackPageViews();
+    this.loginSvc.getFeature('createUser').then( (f) => {
+     
+    })
     window['s'] = this.loginSvc
   }
 }

src/frontend/src/app/frontcraft/login-api.ts

 import { Injectable } from "@angular/core";
 import {RPCSocket} from 'rpclibrary/js/src/Frontend'
 
-import { Token, Auth, User, _Rank, _Class, FrontcraftFeatureIfc, LoginManagerIfc, } from '../../../../backend/Types/Types'
+import { Token, Auth, User, _Class, FrontcraftFeatureIfc, LoginManagerIfc, SomeOf, } from '../../../../backend/Types/Types'
 import { CookieService } from 'ngx-cookie-service';
 
 @Injectable()
 export class LoginApiService{
     private socket:RPCSocket & LoginManagerIfc;
     private auth:Auth
-    private privSocket: RPCSocket & FrontcraftFeatureIfc
+    private privSocket: RPCSocket & SomeOf<FrontcraftFeatureIfc>
 
     constructor(
         private cookieSvc : CookieService
 
     getUnprivilegedSocket = () : RPCSocket & LoginManagerIfc => this.socket
 
-    private getPrivilegedSocket = async (auth:Auth) : Promise<RPCSocket & FrontcraftFeatureIfc> => {
+    private getPrivilegedSocket = async (auth:Auth) : Promise<RPCSocket & SomeOf<FrontcraftFeatureIfc>> => {
         if(this.privSocket) return this.privSocket
+        if(auth.user.rank === 'Guest'){
+            return await RPCSocket.makeSocket<SomeOf<FrontcraftFeatureIfc>>(
+                20001,
+                window.location.hostname
+            )
+        }
         try{
-            const sock: RPCSocket & FrontcraftFeatureIfc = await new RPCSocket(auth.port, window.location.hostname).connect(auth.token.value)
+            const sock = await RPCSocket.makeSocket<SomeOf<FrontcraftFeatureIfc>>(
+                auth.port, 
+                window.location.hostname, 
+                auth.token.value
+            )
+
             //login success
             this.auth = auth
             this.privSocket = sock
             //login failed
             throw new Error('login failed')
         }
-    } 
+    }
+
+    getFeature = async <K extends keyof FrontcraftFeatureIfc>(feature : K) : Promise<void | FrontcraftFeatureIfc[K]> => {
+        const sock = await this.getPrivilegedSocket(this.auth)
+        if(sock[feature]) return <FrontcraftFeatureIfc[K]> sock[feature]
+    }
 
     getCurrentUser = () : User => this.auth 
                                 ? this.auth.user 
                                     rank: 'Guest'
                                 }
 
-    authenticate = async (token : Token | string) : Promise<RPCSocket & FrontcraftFeatureIfc> => {
+    authenticate = async (token : Token | string) : Promise<RPCSocket & SomeOf<FrontcraftFeatureIfc>> => {
         const auth = await this.socket.Authenticator.authenticate(token)
         return await this.getPrivilegedSocket(auth)
     }
 
-    login = async (username, password) => {
+    login = async (username: string, password: string) => {
         const buf = str2arraybuf(password)
         const pwHash = await crypto.subtle.digest('SHA-256', buf);
         const token = await this.socket.Authenticator.login(username, buf2hex(pwHash))
     }
 
     initialize = async () : Promise<RPCSocket> => {
-        const sock : RPCSocket & LoginManagerIfc = await new RPCSocket(20000, window.location.hostname).connect()
+        const sock = await RPCSocket.makeSocket<LoginManagerIfc>(20000, window.location.hostname)
         this.socket = sock
 
         const cookie = this.getCookie()
         if(cookie) {
-            return await this.authenticate(cookie)
+            try{
+                return await this.authenticate(cookie)
+            }catch(e){
+                this.logout()
+            }
         }
 
         return sock
     return Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('');
 }
 
-
-export function initializeLoginSvc(svc: LoginApiService): () => Promise<RPCSocket> {
+//angular depenency manager requires this
+export function initializeLoginSvc(svc: LoginApiService): () => Promise<any> {
     return svc.initialize
 }