create-sip 0.9.0 → 0.10.1

package/create-sip.js

@@ -7,7 +7,8 @@ const {
   genNodejs,
   genWebEsbuildJs,
   genWebEsbuildTs,
-  genMockApi
+  genMockApi,
+  genExpressApi
 } = require('./manager');
 const prompts = require('prompts');
 
@@ -57,6 +58,15 @@ const questions = [
         title: 'MockAPI',
         description: 'API server with hai-server 0.0.4',
         value: 'mockapi'
+      },
+      { 
+        title: 'Express API',
+        description: 'Express API with simple Sequelize',
+        value: 'expressapi' 
+      },
+      { 
+        title: 'Cancel', 
+        value: 'cancel' 
       }
     ],
     initial: 0
@@ -100,5 +110,10 @@ const questions = [
     genMockApi(res.name);
     return;
   }
+  if(res.type === 'expressapi') {
+    console.log('Create a new Express API...');
+    genExpressApi(res.name);
+    return;
+  }
   
 })();

package/expressapi/README.md

@@ -0,0 +1,69 @@
+# exapi
+
+Exapi framework
+
+Express based REST API sablon
+
+## Install
+
+```cmd
+npm install
+```
+
+## Copy config file
+
+Copy **config/default.json.example** to **config/default.json** file.
+
+## APP KEY generation
+
+Run the genkey tools:
+
+```cmd
+node tools/genkey.js
+```
+
+## Database settings
+
+The database settings can be found at the following location:
+
+* config/default.json
+
+### Database dialect
+
+The default database is an in-memory database. Its contents are cleared after the server is restarted.
+
+One of:
+
+* sqlite
+* mariadb
+
+After installing the appropriate dependencies, it can be used:
+
+* mysql
+* postgres
+* mssql
+* db2
+* snowflake
+* oracle
+
+With the `sqlite` option, the database is stored in the `database.sqlite` file, or you can add :memory:, then the database is stored in memory.
+
+## Starting
+
+For development:
+
+```cmd
+npm run dev
+```
+
+Run productum:
+
+```cmd
+npm start
+```
+
+## Licence
+
+May be freely distributed under the MIT license.
+
+Copyright (c) 2023 Sallai András

package/expressapi/app/controllers/authcontroller.js

@@ -0,0 +1,103 @@
+const bcrypt = require('bcryptjs')
+const jwt = require('jsonwebtoken')
+const User = require('../models/user')
+const config = require('../../config/default.json')
+ 
+const AuthController = {
+    async register(req, res) {        
+        var clientError = false;
+        try {
+            if(!req.body.name ||
+                !req.body.email ||
+                !req.body.password ||
+                !req.body.password_confirmation) {
+                clientError = true
+                throw new Error('Error! Bad request data!')
+            }
+            if(req.body.password != req.body.password_confirmation) {
+                clientError = true
+                throw new Error('Error! The two password is not same!')
+            }
+            const user = await User.findOne({
+                where: { name: req.body.name }
+            })
+            if(user) {
+                clientError = true
+                throw new Error('Error! User already exists: ' + user.name)
+            }
+            AuthController.tryRegister(req, res)
+        } catch (error) {
+            if (clientError) {
+                res.status(400)
+            }else {
+                res.status(500)
+            }            
+            await res.json({
+                success: false,
+                message: 'Error! User creation failed!',
+                error: error.message
+            })            
+        }
+    },
+    async tryRegister(req, res) {
+        const user = {
+            name: req.body.name,
+            email: req.body.email,
+            password: bcrypt.hashSync(req.body.password)
+        }
+        await User.create(user)
+        .then( result => {
+            res.status(201)
+            res.json({
+                succes: true,
+                data: result
+            })
+        })
+    },
+    async login(req, res) {
+        
+        try {
+            if(!req.body.name || !req.body.password) {
+               res.status(400)
+               throw new Error('Error! Bad name or password!')
+            }
+            const user = await User.findOne({
+                where: { name: req.body.name }
+            })
+
+            if(!user) {
+                res.status(404)
+                throw new Error('Error! User not found!')
+            }
+            var passwordIsValid = await bcrypt.compare(
+                req.body.password,
+                user.dataValues.password
+            );
+            if(!passwordIsValid) {
+                res.status(401)
+                throw new Error('Error! Password is not valid!')
+            }
+            AuthController.tryLogin(req, res, user)
+
+        } catch (error) {
+            res.json({
+                success: false,
+                message: 'Error! The login is failed!',
+                error: error.message
+            })
+        }
+    },
+    async tryLogin(req, res, user) {
+        var token = jwt.sign({ id: user.id }, config.app.key, {
+            expiresIn: 86400 //24 óra
+        })
+        res.status(200).json({
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            accessToken: token
+        })            
+    }
+}
+ 
+module.exports = AuthController

package/expressapi/app/controllers/usercontroller.js

@@ -0,0 +1,27 @@
+const User = require('../models/user')
+ 
+
+
+const UserController = {
+    async index(req, res) {
+        try {
+            UserController.tryIndex(req, res)
+        }catch(error) {
+            res.status(500)
+            res.json({
+                success: false,
+                message: 'Error! The query is failed!'
+            })
+        }
+    },
+    async tryIndex(req, res) {
+        const users = await User.findAll()
+        res.status(200)
+        res.json({
+            success: true,
+            data: users
+        })
+    }
+}
+
+module.exports = UserController

package/expressapi/app/database/database.js

@@ -0,0 +1,22 @@
+const Sequelize = require('sequelize')
+const config = require('../../config/default.json')
+
+if(config.app.log != false) {
+    var log = console.log
+}
+
+console.log(typeof console.log)
+const sequelize = new Sequelize(
+    config.db.name,
+    config.db.user, 
+    config.db.pass,
+    {
+        logging: log,
+        dialect: config.db.dialect,
+        storage: config.db.path,
+        host: config.db.host,
+        dialectOptions: {}
+    }
+)
+ 
+module.exports = sequelize

package/expressapi/app/index.js

@@ -0,0 +1,19 @@
+const express = require('express')
+const morgan = require('morgan')
+const app = express()
+const fs = require('fs')
+const router = require('./routes/api')
+const config = require('../config/default.json')
+
+const PORT = config.app.port || 8000
+
+const logfile = 'access.log'
+var accessLogStream = fs.createWriteStream(logfile, { flags: 'a' })
+app.use(morgan('dev', { stream: accessLogStream }))
+
+app.use(express.json())
+app.use('/api', router);
+
+app.listen(PORT, () => {
+    console.log(`Listening on port: ${PORT}`)
+})

package/expressapi/app/middleware/authjwt.js

@@ -0,0 +1,22 @@
+const jwt = require("jsonwebtoken");
+const config = require('../../config/default.json')
+ 
+exports.verifyToken = (req, res, next) => {
+    let authData = req.headers.authorization;
+    if(!authData) {
+        return res.status(403).send({
+            message: 'No token provided!'
+        })
+    }
+    let token = authData.split(' ')[1];
+ 
+    jwt.verify(token, config.app.key, (err, decoded) => {
+        if(err) {
+            return res.status(401).send({
+                message: "Unauthorized!"
+            })
+        }
+        req.userId = decoded.id;
+        next()
+    })
+};

package/expressapi/app/models/user.js

@@ -0,0 +1,19 @@
+const { DataTypes } = require('sequelize')
+const sequelize = require('../database/database')
+ 
+const User = sequelize.define('User', {
+    id: { 
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+    },
+    name: { type: DataTypes.STRING,  allowNull: false  },
+    email: { type: DataTypes.STRING,  allowNull: true  },
+    password: { type: DataTypes.STRING , allowNull: false }
+})
+
+
+sequelize.sync({
+    force: false
+})
+module.exports = User

package/expressapi/app/routes/api.js

@@ -0,0 +1,12 @@
+const Router = require('express')
+const router = Router()
+
+const AuthController = require('../controllers/authcontroller')
+const UserController = require('../controllers/usercontroller')
+const { verifyToken } = require('../middleware/authjwt')
+ 
+router.post('/register', AuthController.register)
+router.post('/login', AuthController.login)
+router.get('/users', [verifyToken], UserController.index)
+ 
+module.exports = router

package/expressapi/config/default.json.example

@@ -0,0 +1,15 @@
+{
+    "app": {
+        "port": 8000,
+        "key": "",
+        "log": "console.log"
+    },
+    "db": {
+        "dialect": "sqlite",
+        "host": "127.0.0.1",
+        "name": "",
+        "user": "",
+        "pass": "",
+        "path": ":memory:"
+    }
+}

package/expressapi/docs/dev_doc.md

@@ -0,0 +1,15 @@
+# expressapi
+
+## API KEY
+
+The app key generated with generate-api-key package.
+
+## Testing
+
+Set in config/default.json file, the db.dialect to sqlite. Set db.path to :memory:
+
+Start the application:
+
+```cmd
+npm run dev
+```

package/expressapi/docs/user_doc.md

@@ -0,0 +1,57 @@
+# User documentation
+
+## Install dependencies
+
+```cmd
+pnpm install
+```
+
+## Copy config file
+
+Copy **config/default.json.example** to **config/default.json** file.
+
+## App key generation
+
+```cmd
+node tools/genkey.js
+```
+
+## Database setup
+
+Edit the config/default.json file.
+
+## Endpoints
+
+All endpoint have a /api prefix.
+
+| Endpoint | Method | Auth | Description |
+|-|-|-|-|
+| /register | POST  | no |  create user |
+| /login    | POST  | no |  login  |
+| /users    | GET   | yes |  read users |
+
+## The register endpoint
+
+```json
+{
+    "name": "joe",
+    "email": "joe@green.lan",
+    "password": "secret",
+    "password_confirmation": "secret"
+}
+```
+
+## The login endpoint
+
+```json
+{
+    "name": "joe",
+    "password": "secret"
+}
+```
+
+You receive the bearear token with accessToken key.
+
+## The users endpoint
+
+Send the bearer token.

package/expressapi/nodemon.json

@@ -0,0 +1,4 @@
+{
+  "watch": ["app/index.js", "app"],
+  "ext": "js"
+}

package/expressapi/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "expressapi",
+  "version": "1.0.1",
+  "description": "Express API with simple Sequelize",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha",
+    "dev": "nodemon app",
+    "start": "node app"
+  },
+  "keywords": [
+    "express",
+    "api"
+  ],
+  "author": "Sallai András",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "express": "^4.18.2",
+    "generate-api-key": "^1.0.2",
+    "jsonwebtoken": "^9.0.0",
+    "mariadb": "^3.1.2",
+    "morgan": "^1.10.0",
+    "replace": "^1.2.2",
+    "sequelize": "^6.32.0",
+    "sqlite3": "^5.1.6"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.22",
+    "supertest": "^6.3.3"
+  }
+}

package/expressapi/test/test.js

@@ -0,0 +1,43 @@
+const supertest = require('supertest')
+
+describe('GET /api/users', () => {
+
+    const host = 'http://localhost:8000/api' 
+    const restype= 'application/json; charset=utf-8'
+    var token = null
+
+    it('post /register ', function(done) {
+      supertest(host)
+        .post('/register')
+        .set('Accept', 'application/json')
+        .send({
+            name: 'mari',
+            email: 'mari@zold.lan',
+            password: 'titok',
+            password_confirmation: 'titok'
+        })
+        .expect('Content-Type', restype)
+        .expect(201, done)
+    })
+    it('post /login ', (done) => {
+      supertest(host)
+        .post('/login')
+        .set('Accept', 'application/json')
+        .send({
+            name: 'mari',
+            password: 'titok'
+        })
+        .expect('Content-Type', restype)
+        .expect(200, done)
+        .expect(res => {
+          token = res.body.accessToken
+        })
+    })
+    it('get /users ', function(done) {
+      supertest(host)
+        .get('/users')
+        .set('Accept', 'application/json')
+        .set('Authorization', 'Bearer ' + token)
+        .expect(200, done)
+    })
+  })

package/expressapi/tools/genkey.js

@@ -0,0 +1,19 @@
+const fs = require('fs').promises
+const path = require('path')
+const fileName = '../config/default.json'
+const { generateApiKey } = require('generate-api-key')
+
+function generateKey(size = 32, format = 'base64') {
+    const buffer = crypto.randomBytes(size);
+    return buffer.toString(format);
+}
+
+fs.readFile(path.join(__dirname, fileName))
+    .then(body => JSON.parse(body))
+    .then(json => {
+        json.app.key = generateApiKey({method: 'bytes', length: 32})
+        return json
+    })
+    .then(json => JSON.stringify(json, null, 4))
+    .then(body => fs.writeFile(path.join(__dirname, fileName), body, 'utf8'))
+    .catch(error => console.log(error))

package/manager.js

@@ -57,6 +57,13 @@ const genMockApi = (target) => {
   console.log('npm start');
 }
 
+const genExpressApi = (target) => {
+  copyDir(`${dir}/expressapi`, target);
+  updatePackageName(`${target}/package.json`, target);
+  console.log('ExpressJS REST API sablon created');
+  console.log('Read docs/user_doc.md');
+}
+
 const updatePackageName = (filePath, newName) => {
   const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
   if (content.name) {
@@ -87,5 +94,6 @@ module.exports = {
   genNodejs,
   genWebEsbuildJs,
   genWebEsbuildTs,
-  genMockApi
+  genMockApi,
+  genExpressApi
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-sip",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "main": "index.js",
   "bin": {
     "create-sip": "create-sip.js"