yaml-admin-api 0.0.3

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "yaml-admin-api",
+  "version": "0.0.3",
+  "description": "YAML Admin API package",
+  "type": "commonjs",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "bcryptjs": "^3.0.2",
+    "jsonwebtoken": "^9.0.2",
+    "mongodb": "^6.18.0",
+    "request": "^2.88.2",
+    "yaml": "^2.8.1"
+  }
+}

package/src/crud/api-generator.js

@@ -0,0 +1,118 @@
+const isAuthenticated = (jwt_secret) => {
+    return async (req, res, next) => {
+        const token = req.headers['x-access-token'] || req.query.token || req.cookies.token;
+        if (token == null)
+            res.json({ r: false, err: { code: 666 }, msg: '로그인 필요' });
+        else {
+            jwt.verify(token, jwt_secret, (err, decoded) => {
+                if (err) {
+                    res.json({ r: false, err: { code: 666 }, msg: '로그인 필요' });
+                    return;
+                }
+                req.user = decoded;
+                delete req.user.password;
+                next();
+            })
+        }
+    }
+} 
+
+const generateList = async ({app, db, name, entity, jwt_secret}) => {
+    //list
+    app.get(`/${name}`, isAuthenticated(jwt_secret), async function (req, res) {
+        var s = {};
+        var _sort = req.query._sort;
+        var _order = req.query._order;
+        if (_sort != null)
+            s[_sort] = (_order == 'ASC' ? 1 : -1);
+
+        var _end = req.query._end;
+        var _start = req.query._start;
+        var l = _end - _start;
+
+        //검색 파라미터
+        var f = {};
+        var id = req.query.id;
+        if (id) {
+            if (Array.isArray(id))
+                f['id'] = { $in: id.map(m => parseInt(m)) };
+            else
+                f['id'] = parseInt(id);
+        }
+
+        // ${
+        //     entity.property.filter(f=>f.search && f.type != 'divider').map(m=>{
+        //         if(m.type == 'bool') {
+        //             return `
+        //             if (req.query.${m.name})
+        //                 f['${m.name}'] = req.query.${m.name} == 'true'
+        //             `
+        //         } else if(m.type == 'text') {
+        //             return `
+        //             if (req.query.${m.name})
+        //                 f['${m.name}'] = { $regex: ".*" + req.query.${m.name} + ".*" }
+        //             `    
+        //         } else if(m.type == 'reference') {
+        //             //reference의 키는 integer인지 string인지 모른다. 그리고 member_no같이 string으로 취급되어야할 integer도 있다
+        //             return `
+        //             if (req.query.${m.name})
+        //                 f['${m.name}'] = isNaN(Number(req.query.${m.name}))|| parseInt(req.query.${m.name}) > 1569340492095?req.query.${m.name}:parseInt(req.query.${m.name})
+        //             `    
+        //         } else if(m.type == 'date') {
+        //             return `
+        //             if (req.query.date) {
+        //                 if(req.query.date.replace(/-/g, '').length == 8) {
+        //                     //해당 날짜의 시작Date와 끝Date로 검색
+        //                     f['date'] = {
+        //                         $gte: moment(req.query.date).startOf('day').toDate(),
+        //                         $lte: moment(req.query.date).endOf('day').toDate()
+        //                     }
+        //                 }
+        //             }
+        //             `
+        //         } else {
+        //             return `
+        //             if (req.query.${m.name})
+        //                 f['${m.name}'] = req.query.${m.name}
+        //             `    
+        //         } 
+
+        //     }).join('\n')
+        // }
+
+        var name = req.query.name;
+        if (name == null && req.query.q)
+            name = req.query.q;
+        if (name != null)
+            f['name'] = { $regex: ".*" + name + ".*" };
+        f.remove = { $ne: true }
+
+        //Custom f list Start
+
+        //Custom f list End
+
+        var count = await db.collection('${name}').find(f).project({ _id: false }).sort(s).count();
+        let list = await db.collection('${name}').find(f).project({ _id: false }).sort(s).skip(parseInt(_start)).limit(l).toArray()
+        console.log('entity', entity)
+        list.map(m => {
+            m.id = entity.key
+        })
+        //Custom list Start
+
+        //Custom list End
+        await addInfo(db, list)
+        res.header('X-Total-Count', count);
+        res.json(list);
+    });
+}
+
+const generateEntityApi = async ({app, db, name, entity, jwt_secret}) => {
+    const { fields } = entity;
+    console.log('generateEntityApi', name)
+
+    await generateList({app, db, name, entity, jwt_secret})
+}
+
+module.exports = {
+    generateEntityApi
+}

package/src/crud/login-api-generator.js

@@ -0,0 +1,10 @@
+const member = require('../member/member.js');
+
+const generateLoginApi = async(app, db, yml) => {
+    console.log('generateLoginApi', yml.login["jwt-secret"])
+    await member(app, db, yml)
+}
+
+module.exports = {
+    generateLoginApi
+}

package/src/index.js

@@ -0,0 +1,3 @@
+const registerRoutes = require('./yml-admin-api.js');
+
+module.exports = { registerRoutes };

package/src/login/auth.js

@@ -0,0 +1,86 @@
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+
+const withConfig = (config) => {
+  const { db, jwt_secret } = config;
+
+  const comparePassword = function (plainPass, hashword, callback) {
+    bcrypt.compare(plainPass, hashword, function (err, isPasswordMatch) {
+      return err == null ?
+        callback(null, isPasswordMatch) :
+        callback(err);
+    });
+  };
+
+  const authenticateSuccess = function (req, res, user, next) {
+    jwt.sign(
+      user,
+      jwt_secret,
+      {
+        expiresIn: '1000d',
+        subject: 'userInfo'
+      }, (err, token) => {
+        if (err) res.json({ r: false, msg: '알 수 없는 이유로 토큰 생성에 실패하였습니다.' });
+
+        req.token = token;
+        delete user.password;
+        req.user = user;
+        next();
+      }
+    );
+  };
+
+  const isAuthenticated = function (req, res, next) {
+    const token = req.headers['x-access-token'] || req.query.token || req.cookies.token;
+
+    if (token == null)
+      res.json({ r: false, err: { code: 666 }, msg: '로그인 필요' });
+    else
+      jwt.verify(token, jwt_secret, (err, decoded) => {
+        if (err) {
+          res.json({ r: false, err: { code: 666 }, msg: '로그인 필요' });
+          return;
+        }
+        req.user = decoded;
+        next();
+      })
+  };
+
+  const authenticate = async (req, res, next) => {
+    const email = req.query.email || req.body.email;
+    const password = req.query.pass || req.body.pass;
+    const type = req.query.type || req.body.type || "email";
+    if (email === 'admin' && password === '5756') {
+      authenticateSuccess(req, res,
+        { id: '1111111', email: 'admin', name: 'admin', type: 'email' },
+        next);
+    }
+    else {
+      var memberProjection = { projection: { _id: false, name: true, email: true, password: true, super: true, id: true } };
+      if (type === 'email') {
+        memberProjection['password'] = true;
+        let member = await db.collection('admin').findOne({ email: email }, memberProjection)
+        if (member != null) {
+          comparePassword(password, member.password, async function (err, isPasswordMatch) {
+            if (isPasswordMatch) {
+              authenticateSuccess(req, res, member, next);
+              await db.collection('admin').updateOne({ email: email }, { $set: { login_date: new Date() } }, { upsert: false })
+            } else
+              res.json({ r: false, msg: '비밀번호가 일치하지 않습니다.' });
+          });
+        }
+        else
+          res.json({ r: false, msg: '존재하지 않는 사용자입니다.' });
+      }
+    }
+  };
+
+  return {
+    isAuthenticated,
+    authenticate,
+  }
+}
+
+module.exports = {
+  withConfig,
+}

package/src/member/member.js

@@ -0,0 +1,32 @@
+const {withConfig} = require('../login/auth.js');
+
+module.exports = async function (app, db, yml, delegate) {
+    const auth = withConfig({ db, jwt_secret: yml.login["jwt-secret"] });
+
+    app.get('/member/login',
+        auth.authenticate,
+        function (req, res) {
+            res.json({ r: true, token: req.token, member: req.user });
+        }
+    );
+
+    app.get('/member/islogin',
+        auth.isAuthenticated,
+        async function (req, res) {
+            res.json({ r: true, member: req.user });
+        }
+    );
+
+    app.post('/member/login',
+        auth.authenticate,
+        function (req, res) {
+            res.json({ r: true, token: req.token, member: req.user });
+        }
+    );
+
+    app.get('/member/logout', async (req, res) => {
+        req.logout();
+        res.json({ r: true });
+    });
+
+};

package/src/yml-admin-api.js

@@ -0,0 +1,57 @@
+const { MongoClient } = require('mongodb');
+const fs = require('fs').promises;
+const yaml = require('yaml');
+const { generateEntityApi } = require('./crud/api-generator');
+const { generateLoginApi } = require('./crud/login-api-generator');
+
+async function registerRoutes(app, options = {}) {
+  const { yamlPath, yamlString } = options;
+  let yml;
+  if(yamlPath) {
+    yml = await readYml(yamlPath);
+  } else if(yamlString) {
+    yml = yaml.parse(yamlString);
+  } else {
+    let yamlString = await fs.readFile('./admin.yml', 'utf8');
+    if(!yamlString) {
+      throw new Error('admin.yml is not found. yamlPath or yamlString is required.')
+    }
+    yamlString = yamlString.replace('${JWT_SECRET}', process.env.JWT_SECRET);
+    yamlString = yamlString.replace('${MONGODB_URL}', process.env.MONGODB_URL);
+    yml = yaml.parse(yamlString);
+  }
+
+  const {database, entity} = yml;
+  let db = null;
+  if(database) {
+    const {mongodb} = database;
+    if(mongodb) {
+      const {uri} = mongodb;
+      db = await MongoClient.connect(uri, {}).then(client => client.db())
+      console.log('db connected')
+    }
+  }
+  const jwt_secret = yml.login["jwt-secret"]
+  app.set('jwt-secret', jwt_secret);
+
+  await generateLoginApi(app, db, yml)
+  entity && Object.keys(entity).forEach(async (entityName) => {
+    await generateEntityApi({
+      app, db, 
+      name:entityName, 
+      entity:entity[entityName], 
+      jwt_secret
+    })
+  })
+}
+
+async function readYml(path) {
+  let yml = await fs.readFile(path, 'utf8');
+  yml = yml.replace('${JWT_SECRET}', process.env.JWT_SECRET);
+  yml = yml.replace('${MONGODB_URL}', process.env.MONGODB_URL);
+    
+  return yaml.parse(yml);
+
+}
+
+module.exports = registerRoutes;