first

index.js

@@ -0,0 +1,351 @@
+const ObjectID    = require("mongodb").ObjectID;
+const jwt         = require('jsonwebtoken')
+const jwtSecret   = 'CbymrfGfnB'
+const expressJwt  = require('express-jwt');
+
+const anonResolvers = ['login', 'createUser'];
+
+
+;(async () => {
+    const {Savable, slice} = await require('./models.js')('cb')
+
+    class User extends Savable {
+        static get relations(){
+            return {
+                events: "users"
+            }
+        }
+    }
+    Savable.addClass(User)
+
+
+    const express = require('express');
+    const express_graphql = require('express-graphql');
+    const { buildSchema } = require('graphql');
+
+
+    const schema = buildSchema(`
+        type Query {
+            login(login: String!, password: String!): String
+
+            events: [Event]
+            event(eventId: String!): Event
+
+            eventMoneysByEvent(eventId: String!): [EventMoney]
+            eventMoneys: [EventMoney]
+        }
+        type Mutation {
+            createUser(login: String!, password: String!): User
+            changePassword(password: String!): User
+
+            createEvent(name: String!, total: Float!):Event
+            changeEvent(eventId:String!, name: String!, total: Float!):Event
+
+            createEventMoney(eventId: String!, amount: Float):EventMoney
+        }
+
+        type User {
+             _id: String
+             login: String
+             nick : String
+             moneyEvents: [EventMoney]
+        }
+
+        type Event {
+            _id: String
+            name: String
+            moneyEvents: [EventMoney]
+            owner: String,
+            total: Float,
+            usersSum: Float,
+            moneyDiff: Float,
+            avg: Float
+        }
+
+        type EventMoney {
+            _id: String
+            user: User
+            event: Event
+            amount: Float
+            owner: String
+            avgDiff: Float
+        }
+    `);
+
+
+
+    var app = express();
+    app.use(express.static('public'));
+
+    const rootResolvers = {
+        createUser:async function ({login, password}){
+            let user =  await Savable.m.User.findOne({login, password})
+            if (user)
+                return null;
+            user = await (new User({login, password})).save()
+
+            user.___owner = user._id.toString()
+            user.___permissions = {
+                read: ["owner", "user"]
+            }
+
+            return await user.save()
+        },
+
+        login: async function({login, password}){
+            const user =  await Savable.m.User.findOne({login, password})
+            if (!user)
+                return null;
+
+            const token = jwt.sign({ sub: {id: user._id, login}}, jwtSecret); //подписывам токен нашим ключем
+            return token
+        },
+
+        changePassword:async function ({password}, {jwt: {id}, models: {SlicedSavable, User}} ){
+            id = new ObjectID(id)
+
+            const user =  await SlicedSavable.m.User.findOne({_id: id})
+            if (!user)
+                return null;
+            user.password = password;
+            return await user.save()
+        },
+
+        async createEvent({name, total}, {jwt: {id}, models: {Event}}){
+            return await (new Event({name, total})).save()
+        },
+
+        async changeEvent({eventId, name, total}, {jwt: {id}, models: {SlicedSavable}}){
+            const event = await SlicedSavable.m.Event.findOne({_id: ObjectID(eventId)})
+            if (!event)
+                return null;
+
+            event.name  = name
+            event.total = total
+            return await event.save()
+        },
+
+        async events({}, {jwt: {id}, models: {SlicedSavable}}){
+            let events = []
+            for (let event of SlicedSavable.m.Event.find({})){
+                event = await event
+                //const {_id, name, owner, moneyEvents, usersSum, moneyDiff, total} = event
+                //event = {_id, name, owner, moneyEvents, usersSum: await event.usersSum,  total}
+                //console.log(event)
+                events.push(event)
+            }
+
+            return events;
+        },
+
+        async event({eventId}, {jwt: {id}, models: {SlicedSavable}}){
+            return await SlicedSavable.m.Event.findOne({_id: ObjectID(eventId)});
+        },
+
+
+        async createEventMoney({eventId, amount}, {jwt: {id}, models: {SlicedSavable, EventMoney}}){
+            let eventMoney = await SlicedSavable.m.EventMoney.findOne({"user._id": ObjectID(id), "event._id": ObjectID(eventId)})
+            if (eventMoney){
+                eventMoney.amount = amount;
+                return await eventMoney.save()
+            }
+
+            const event = await SlicedSavable.m.Event.findOne({_id: ObjectID(eventId)})
+            if (!event)
+                return null;
+
+            const me = await SlicedSavable.m.User.findOne({_id: ObjectID(id)})
+            if (!me)
+                return null;
+
+            return await (new EventMoney({user: me, event, amount})).save()
+        },
+
+
+        async eventMoneysByEvent({eventId}, {jwt: {id}, models: {SlicedSavable}}){
+            const event =  await SlicedSavable.m.Event.findOne({_id: ObjectID(eventId)});
+            if (!event)
+                return null
+
+            const moneys = [];
+
+            for (let money of event.moneyEvents){
+                try {
+                    await money
+                    console.log(money)
+                }
+                catch (e){
+                    console.log('skip no access user' ,e)
+                }
+                moneys.push(money)
+                console.log('in loop')
+            }
+            //for (let money of event.moneyEvents){
+                //moneys.push(await money)
+            //}
+
+            console.log('after loop')
+
+            return moneys;
+        },
+
+
+        async eventMoneys({}, {jwt: {id}, models: {SlicedSavable}}){
+            const me =  await SlicedSavable.m.User.findOne({_id: ObjectID(id)});
+            if (!me)
+                return null
+
+            const moneys = [];
+
+            for (let money of me.moneyEvents){
+                moneys.push(await money)
+            }
+
+            return moneys;
+        },
+
+    }
+
+/*
+mutation createUser($login:String!, $password:String!){
+  createUser(login:$login, password:$password){
+    _id, login    
+  }  
+}
+
+query login($login:String!, $password:String!){
+  login(login:$login, password:$password){
+    _id, login
+  }
+}
+ */
+
+
+    function getModels(id){
+        const SlicedSavable = slice([id, 'user'])
+
+        class User extends SlicedSavable {
+            constructor(...params){
+                super(...params)
+                
+                if (this.moneyEvents instanceof Array)
+                    return
+
+                if (this.moneyEvents instanceof SlicedSavable)
+                    this.moneyEvents = [this.moneyEvents];
+
+                this.moneyEvents = [];
+            }
+
+            static get relations(){
+                return {
+                    moneyEvents: "user"
+                }
+            }
+        }
+        SlicedSavable.addClass(User)
+
+        class Event extends SlicedSavable {
+            constructor(...params){
+                super(...params)
+
+                if (this.moneyEvents instanceof Array)
+                    return
+
+                if (this.moneyEvents instanceof SlicedSavable)
+                    this.moneyEvents = [this.moneyEvents];
+
+                this.moneyEvents = [];
+            }
+
+            get owner(){
+                return this.___owner
+            }
+
+            get usersSum(){
+                return (async  () => {
+                    var result = 0;
+                    for (let money of this.moneyEvents){
+                        result += (await money).amount
+                        console.log('MONEY SUM', money.amount, money._id)
+                    }
+                    return result;
+                })()
+            }
+
+
+            get moneyDiff(){
+                return (async  () => {
+                    return (await this.usersSum) - (this.total || 0);
+                })()
+            }
+
+            get avg(){
+                return this.total/((this.moneyEvents && this.moneyEvents.length) || 1)
+            }
+
+
+            static get relations(){
+                return {
+                    moneyEvents: "event"
+                }
+            }
+        }
+        SlicedSavable.addClass(Event)
+
+        class EventMoney extends SlicedSavable {
+            get owner(){
+                return this.___owner
+            }
+
+            get avgDiff(){
+                return (async () =>  this.amount - (await this.event).avg)()
+            }
+
+            static get relations(){
+                return {
+                    user: "moneyEvents",
+                    event: "moneyEvents"
+                }
+            }
+        }
+        SlicedSavable.addClass(EventMoney)
+
+        return {
+            SlicedSavable, User, Event, EventMoney
+        }
+    }
+
+
+
+    app.use('/graphql', express_graphql(async (req, res, gql) => { 
+        if (gql.operationName === null || anonResolvers.includes(gql.operationName))
+            return {
+                schema: schema,
+                rootValue: rootResolvers,
+                graphiql: true, 
+            }
+        
+        const authorization = req.headers.authorization 
+        if (authorization && authorization.startsWith('Bearer ')){
+            console.log('token provided')
+            const token = authorization.substr("Bearer ".length)
+            const decoded = jwt.verify(token, jwtSecret)
+            if (decoded){
+                console.log('token verified', decoded)
+
+                let slicedModels  = getModels(decoded.sub.id)
+
+                return {
+                    schema: schema,
+                    rootValue: rootResolvers,
+                    graphiql: true, 
+                    context: {jwt: decoded.sub,
+                              models: slicedModels}
+                }
+            }
+        }
+    }))
+
+    app.listen(4000, () => console.log('Express GraphQL Server Now Running On localhost:4000/graphql'));
+})()

models.js

@@ -0,0 +1,22 @@
+const MongoClient = require("mongodb").MongoClient;
+const ObjectID    = require("mongodb").ObjectID;
+const mm          = require('mm')
+
+module.exports = async (dbName, dsn="mongodb://localhost:27017/") => {
+    if (!dbName)
+        throw new ReferenceError(`db name does not provided`)
+
+    const mongoClient = new MongoClient(dsn, { useNewUrlParser: true });
+    const client      = await mongoClient.connect()
+    const db          = client.db(dbName)
+    const Savable     = mm(db).Savable
+    const sliceSavable = mm(db).sliceSavable 
+
+    return {
+        Savable, 
+
+        slice(...params){
+            return sliceSavable(...params)
+        }
+    }
+}

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cooperative-blue",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.17.1",
+    "express-graphql": "^0.9.0",
+    "express-jwt": "^5.3.1",
+    "graphql": "^14.4.2",
+    "jsonwebtoken": "^8.5.1",
+    "mm": "git+ssh://git@gitlab.a-level.com.ua:gitgod/mm.git"
+  }
+}