refactor: global namespace + admin pages UI

server/graph/resolvers/authentication.js

@@ -0,0 +1,45 @@
+const _ = require('lodash')
+const fs = require('fs-extra')
+const path = require('path')
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    async authentication() { return {} }
+  },
+  Mutation: {
+    async authentication() { return {} }
+  },
+  AuthenticationQuery: {
+    providers(obj, args, context, info) {
+      switch (args.mode) {
+        case 'active':
+          let strategies = _.chain(WIKI.auth.strategies).map(str => {
+            return {
+              key: str.key,
+              title: str.title,
+              useForm: str.useForm
+            }
+          }).sortBy(['title']).value()
+          let localStrategy = _.remove(strategies, str => str.key === 'local')
+          return _.concat(localStrategy, strategies)
+        case 'all':
+
+          break
+        default:
+          return null
+      }
+    }
+  },
+  AuthenticationProvider: {
+    icon (ap, args) {
+      return fs.readFileAsync(path.join(WIKI.ROOTPATH, `assets/svg/auth-icon-${ap.key}.svg`), 'utf8').catch(err => {
+        if (err.code === 'ENOENT') {
+          return null
+        }
+        throw err
+      })
+    }
+  }
+}

server/graph/resolvers/comment.js

@@ -0,0 +1,42 @@
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    comments(obj, args, context, info) {
+      return WIKI.db.Comment.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    createComment(obj, args) {
+      return WIKI.db.Comment.create({
+        content: args.content,
+        author: args.userId,
+        document: args.documentId
+      })
+    },
+    deleteComment(obj, args) {
+      return WIKI.db.Comment.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    modifyComment(obj, args) {
+      return WIKI.db.Comment.update({
+        content: args.content
+      }, {
+        where: { id: args.id }
+      })
+    }
+  },
+  Comment: {
+    author(cm) {
+      return cm.getAuthor()
+    },
+    document(cm) {
+      return cm.getDocument()
+    }
+  }
+}

server/graph/resolvers/document.js

@@ -0,0 +1,46 @@
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    documents(obj, args, context, info) {
+      return WIKI.db.Document.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    createDocument(obj, args) {
+      return WIKI.db.Document.create(args)
+    },
+    deleteDocument(obj, args) {
+      return WIKI.db.Document.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    modifyDocument(obj, args) {
+      return WIKI.db.Document.update({
+        title: args.title,
+        subtitle: args.subtitle
+      }, {
+        where: { id: args.id }
+      })
+    },
+    moveDocument(obj, args) {
+      return WIKI.db.Document.update({
+        path: args.path
+      }, {
+        where: { id: args.id }
+      })
+    }
+  },
+  Document: {
+    comments(doc) {
+      return doc.getComments()
+    },
+    tags(doc) {
+      return doc.getTags()
+    }
+  }
+}

server/graph/resolvers/file.js

@@ -0,0 +1,51 @@
+
+/* global WIKI */
+
+const gql = require('graphql')
+
+module.exports = {
+  Query: {
+    files(obj, args, context, info) {
+      return WIKI.db.File.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    uploadFile(obj, args) {
+      // todo
+      return WIKI.db.File.create(args)
+    },
+    deleteFile(obj, args) {
+      return WIKI.db.File.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    renameFile(obj, args) {
+      return WIKI.db.File.update({
+        filename: args.filename
+      }, {
+        where: { id: args.id }
+      })
+    },
+    moveFile(obj, args) {
+      return WIKI.db.File.findById(args.fileId).then(fl => {
+        if (!fl) {
+          throw new gql.GraphQLError('Invalid File ID')
+        }
+        return WIKI.db.Folder.findById(args.folderId).then(fld => {
+          if (!fld) {
+            throw new gql.GraphQLError('Invalid Folder ID')
+          }
+          return fl.setFolder(fld)
+        })
+      })
+    }
+  },
+  File: {
+    folder(fl) {
+      return fl.getFolder()
+    }
+  }
+}

server/graph/resolvers/folder.js

@@ -0,0 +1,35 @@
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    folders(obj, args, context, info) {
+      return WIKI.db.Folder.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    createFolder(obj, args) {
+      return WIKI.db.Folder.create(args)
+    },
+    deleteGroup(obj, args) {
+      return WIKI.db.Folder.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    renameFolder(obj, args) {
+      return WIKI.db.Folder.update({
+        name: args.name
+      }, {
+        where: { id: args.id }
+      })
+    }
+  },
+  Folder: {
+    files(grp) {
+      return grp.getFiles()
+    }
+  }
+}

server/graph/resolvers/group.js

@@ -0,0 +1,63 @@
+
+/* global WIKI */
+
+const gql = require('graphql')
+
+module.exports = {
+  Query: {
+    groups(obj, args, context, info) {
+      return WIKI.db.Group.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    assignUserToGroup(obj, args) {
+      return WIKI.db.Group.findById(args.groupId).then(grp => {
+        if (!grp) {
+          throw new gql.GraphQLError('Invalid Group ID')
+        }
+        return WIKI.db.User.findById(args.userId).then(usr => {
+          if (!usr) {
+            throw new gql.GraphQLError('Invalid User ID')
+          }
+          return grp.addUser(usr)
+        })
+      })
+    },
+    createGroup(obj, args) {
+      return WIKI.db.Group.create(args)
+    },
+    deleteGroup(obj, args) {
+      return WIKI.db.Group.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    removeUserFromGroup(obj, args) {
+      return WIKI.db.Group.findById(args.groupId).then(grp => {
+        if (!grp) {
+          throw new gql.GraphQLError('Invalid Group ID')
+        }
+        return WIKI.db.User.findById(args.userId).then(usr => {
+          if (!usr) {
+            throw new gql.GraphQLError('Invalid User ID')
+          }
+          return grp.removeUser(usr)
+        })
+      })
+    },
+    renameGroup(obj, args) {
+      return WIKI.db.Group.update({
+        name: args.name
+      }, {
+        where: { id: args.id }
+      })
+    }
+  },
+  Group: {
+    users(grp) {
+      return grp.getUsers()
+    }
+  }
+}

server/graph/resolvers/right.js

@@ -0,0 +1,53 @@
+
+/* global WIKI */
+
+const gql = require('graphql')
+
+module.exports = {
+  Query: {
+    rights(obj, args, context, info) {
+      return WIKI.db.Right.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    addRightToGroup(obj, args) {
+      return WIKI.db.Group.findById(args.groupId).then(grp => {
+        if (!grp) {
+          throw new gql.GraphQLError('Invalid Group ID')
+        }
+        return WIKI.db.Right.create({
+          path: args.path,
+          role: args.role,
+          exact: args.exact,
+          allow: args.allow,
+          group: grp
+        })
+      })
+    },
+    removeRightFromGroup(obj, args) {
+      return WIKI.db.Right.destroy({
+        where: {
+          id: args.rightId
+        },
+        limit: 1
+      })
+    },
+    modifyRight(obj, args) {
+      return WIKI.db.Right.update({
+        path: args.path,
+        role: args.role,
+        exact: args.exact,
+        allow: args.allow
+      }, {
+        where: {
+          id: args.id
+        }
+      })
+    }
+  },
+  Right: {
+    group(rt) {
+      return rt.getGroup()
+    }
+  }
+}

server/graph/resolvers/setting.js

@@ -0,0 +1,24 @@
+
+/* global WIKI */
+
+const _ = require('lodash')
+
+module.exports = {
+  Query: {
+    settings(obj, args, context, info) {
+      return WIKI.db.Setting.findAll({ where: args, raw: true }).then(entries => {
+        return _.map(entries, entry => {
+          entry.config = JSON.stringify(entry.config)
+          return entry
+        })
+      })
+    }
+  },
+  Mutation: {
+    setConfigEntry(obj, args) {
+      return WIKI.db.Setting.update({
+        value: args.value
+      }, { where: { key: args.key } })
+    }
+  }
+}

server/graph/resolvers/tag.js

@@ -0,0 +1,63 @@
+
+/* global WIKI */
+
+const gql = require('graphql')
+
+module.exports = {
+  Query: {
+    tags(obj, args, context, info) {
+      return WIKI.db.Tag.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    assignTagToDocument(obj, args) {
+      return WIKI.db.Tag.findById(args.tagId).then(tag => {
+        if (!tag) {
+          throw new gql.GraphQLError('Invalid Tag ID')
+        }
+        return WIKI.db.Document.findById(args.documentId).then(doc => {
+          if (!doc) {
+            throw new gql.GraphQLError('Invalid Document ID')
+          }
+          return tag.addDocument(doc)
+        })
+      })
+    },
+    createTag(obj, args) {
+      return WIKI.db.Tag.create(args)
+    },
+    deleteTag(obj, args) {
+      return WIKI.db.Tag.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    removeTagFromDocument(obj, args) {
+      return WIKI.db.Tag.findById(args.tagId).then(tag => {
+        if (!tag) {
+          throw new gql.GraphQLError('Invalid Tag ID')
+        }
+        return WIKI.db.Document.findById(args.documentId).then(doc => {
+          if (!doc) {
+            throw new gql.GraphQLError('Invalid Document ID')
+          }
+          return tag.removeDocument(doc)
+        })
+      })
+    },
+    renameTag(obj, args) {
+      return WIKI.db.Group.update({
+        key: args.key
+      }, {
+        where: { id: args.id }
+      })
+    }
+  },
+  Tag: {
+    documents(tag) {
+      return tag.getDocuments()
+    }
+  }
+}

server/graph/resolvers/translation.js

@@ -0,0 +1,12 @@
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    translations (obj, args, context, info) {
+      return WIKI.lang.getByNamespace(args.locale, args.namespace)
+    }
+  },
+  Mutation: {},
+  Translation: {}
+}

server/graph/resolvers/user.js

@@ -0,0 +1,61 @@
+
+/* global WIKI */
+
+module.exports = {
+  Query: {
+    users(obj, args, context, info) {
+      return WIKI.db.User.findAll({ where: args })
+    }
+  },
+  Mutation: {
+    createUser(obj, args) {
+      return WIKI.db.User.create(args)
+    },
+    deleteUser(obj, args) {
+      return WIKI.db.User.destroy({
+        where: {
+          id: args.id
+        },
+        limit: 1
+      })
+    },
+    login(obj, args, context) {
+      return WIKI.db.User.login(args, context).catch(err => {
+        return {
+          succeeded: false,
+          message: err.message
+        }
+      })
+    },
+    loginTFA(obj, args, context) {
+      return WIKI.db.User.loginTFA(args, context).catch(err => {
+        return {
+          succeeded: false,
+          message: err.message
+        }
+      })
+    },
+    modifyUser(obj, args) {
+      return WIKI.db.User.update({
+        email: args.email,
+        name: args.name,
+        provider: args.provider,
+        providerId: args.providerId,
+        role: args.role
+      }, {
+        where: { id: args.id }
+      })
+    },
+    resetUserPassword(obj, args) {
+      return false
+    },
+    setUserPassword(obj, args) {
+      return false
+    }
+  },
+  User: {
+    groups(usr) {
+      return usr.getGroups()
+    }
+  }
+}