create-sip 1.3.2 → 1.3.4

package/expressapi/.env

@@ -0,0 +1,10 @@
+APP_PORT=8000
+APP_KEY=75ce1d709b165b03f6806dcec02b9f97
+APP_LOG=false
+
+DB_DIALECT=sqlite
+DB_HOST=127.0.0.1
+DB_NAME=
+DB_USER=
+DB_PASS=
+DB_STORAGE=database.sqlite

package/expressapi/.env.example

@@ -0,0 +1,10 @@
+APP_PORT=8000
+APP_KEY=
+APP_LOG=console.log
+
+DB_DIALECT=sqlite
+DB_HOST=127.0.0.1
+DB_NAME=
+DB_USER=
+DB_PASS=
+DB_STORAGE=:memory:

package/expressapi/.env.test

@@ -0,0 +1,7 @@
+
+APP_PORT=8000
+APP_KEY=my_secret_key
+APP_LOG=false
+
+DB_DIALECT=sqlite
+DB_STORAGE=:memory:

package/expressapi/.gitignore

@@ -0,0 +1,4 @@
+/node_modules
+/access.log
+/.env
+database.sqlite

package/expressapi/README.md

@@ -0,0 +1,179 @@
+# sip expressapi template
+
+Express based REST API template
+
+## Install
+
+```cmd
+npm install
+```
+
+## Copy config file
+
+Copy **config/default.json.example** to **config/default.json** file.
+
+## APP KEY generation
+
+Run the genkey:
+
+```cmd
+node op key:generate
+```
+
+## 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 usual path setting is `database.sqlite`. The default storage is :memory:, where data is stored in memory only.
+
+## Starting
+
+For development:
+
+```cmd
+npm run dev
+```
+
+Run productum:
+
+```cmd
+npm start
+```
+
+## Model and controller creation
+
+You can generate a model and controller with the following commands:
+
+```bash
+node op make:model something
+node op make:controller something
+```
+
+The name after the model and controller statements must be given in the singular. Controller generation automatically appends the "Controller" suffix.
+
+## Admin user
+
+The admin user can be created with the following command:
+
+```bash
+node op admin:generate
+```
+
+The command will prompt for the password.
+
+## Config generation
+
+The next command generates the default config file:
+
+```bash
+node op conf:generate
+```
+
+## Database import
+
+The database can be seeded with the following command:
+
+```bash
+node op db:import <model_name> <file_path>
+```
+
+The model name must be given in the singular and lowercase. The file extension must be:
+
+* .json
+* .csv
+
+The keys in the JSON file and the field names in the CSV file must match the model fields.
+
+If the CSV file contains quotation marks, they are automatically removed.
+
+## Database synchronization
+
+Models and database tables can be synchronized, but this can be dangerous.
+
+Database synchronization can be set up in the app/models/modrels.js file. Default values are:
+
+```js
+{ alter: true }
+```
+
+This preserves the data and existing structure.
+
+Possible values:
+
+```js
+{ force: true }
+```
+
+The latter deletes the contents of the database table!
+
+If the value is false, there is no synchronization in either case.
+
+## Migration
+
+Generate a migration:
+
+```bash
+node op make/migration thing
+```
+
+Run all migration:
+
+```bash
+node op migration:run
+```
+
+Run a migration:
+
+```bash
+node op migration:run <migration_name>
+```
+
+Rollback a migration:
+
+```bash
+node op migration:rollback
+```
+
+Rollback two migrations:
+
+```bash
+node op migration:rollback 2
+```
+
+Reset the database:
+
+```bash
+node op migration:reset
+```
+
+Reset the database and run all migrations:
+
+```bash
+node op migration:fresh
+```
+
+## Licence
+
+May be freely distributed under the MIT license.
+
+Copyright (c) 2023 Sallai András

package/expressapi/app/app.js

@@ -0,0 +1,17 @@
+import express from 'express'
+import morgan from 'morgan'
+import cors from 'cors'
+import fs from 'fs'
+import router from './routes/api.js'
+import './models/modrels.js'
+
+const app = express()
+
+const logfile = 'access.log'
+var accessLogStream = fs.createWriteStream(logfile, { flags: 'a' })
+app.use(morgan('dev', { stream: accessLogStream }))
+app.use(cors())
+app.use(express.json())
+app.use('/api', router);
+
+export default app

package/expressapi/app/controllers/authController.js

@@ -0,0 +1,103 @@
+import bcrypt from 'bcryptjs'
+import jwt from 'jsonwebtoken'
+import User from '../models/user.js'
+import dotenv from '@dotenvx/dotenvx'
+dotenv.config({ quiet: true })
+
+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)
+        }
+        const result = await User.create(user)
+        
+        res.status(201).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 }, process.env.APP_KEY, {
+            expiresIn: 86400 //24 óra
+        })
+        res.status(200).json({
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            accessToken: token
+        })            
+    }
+}
+ 
+export default AuthController

package/expressapi/app/controllers/userController.js

@@ -0,0 +1,129 @@
+import bcrypt from 'bcryptjs'
+import User from '../models/user.js'
+
+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
+        })
+    },
+    async show(req, res) {
+        try {
+            await UserController.tryShow(req, res)
+        }catch(error) {
+            res.status(500)
+            res.json({
+                success: false,
+                message: 'Error! The query is failed!'
+            })
+        }
+    },
+    async tryShow(req, res) {
+        const user = await User.findByPk(req.params.id)
+        res.status(200)
+        res.json({
+            success: true,
+            data: user
+        })
+    },
+    async create(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)
+            }            
+            await UserController.tryCreate(req, res)
+        }catch(error) {
+            if (clientError) {
+                res.status(400)
+            }else {
+                res.status(500)
+            }
+            res.json({
+                success: false,
+                message: 'Error! The query is failed!',
+                error: error.message
+            })
+        }
+    },
+    async tryCreate(req, res) {
+        const newUser = {
+            name: req.body.name,
+            email: req.body.email,
+            password: bcrypt.hashSync(req.body.password)
+        }        
+        const userData = await User.create(newUser)
+        res.status(201)
+        res.json({
+            success: true,
+            data: userData
+        })
+    },
+    async updatePassword(req, res) {
+        var clientError = false;
+        try {
+            if(!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!')
+            }
+            await UserController.tryUpdatePassword(req, res)
+        }catch(error) {
+            if (clientError) {
+                res.status(400)
+            }else {
+                res.status(500)
+            }
+            res.json({
+                success: false,
+                message: 'Error! The query is failed!',
+                error: error.message
+            })
+        }
+    },
+    async tryUpdatePassword(req, res) {
+        const user = await User.findByPk(req.params.id)
+        user.password = bcrypt.hashSync(req.body.password)
+        await user.save()
+        res.status(200)
+        res.json({
+            success: true,
+            data: user
+        })
+    }
+}
+
+export default UserController

package/expressapi/app/database/database.js

@@ -0,0 +1,23 @@
+import Sequelize from 'sequelize'
+import dotenv from '@dotenvx/dotenvx'
+
+if (process.env.NODE_ENV === 'test') {
+    dotenv.config({ path: '.env.test', quiet: true })
+}else {
+    dotenv.config({ quiet: true })    
+}
+
+const sequelize = new Sequelize(
+    process.env.DB_NAME,
+    process.env.DB_USER,
+    process.env.DB_PASS,
+    {
+        dialect: process.env.DB_DIALECT,
+        storage: process.env.DB_STORAGE,
+        host: process.env.DB_HOST,
+        logging: process.env.APP_LOG === 'true' ? console.log : false,
+        dialectOptions: {}
+    }
+)
+
+export default sequelize

package/expressapi/app/index.js

@@ -0,0 +1,10 @@
+import app from './app.js'
+import dotenv from '@dotenvx/dotenvx'
+
+dotenv.config({ quiet: true })
+
+const PORT = process.env.APP_PORT || 8000
+
+app.listen(PORT, () => {
+    console.log(`Listening on port: ${PORT}`)
+})

package/expressapi/app/middleware/authjwt.js

@@ -0,0 +1,25 @@
+import jwt from 'jsonwebtoken';
+import dotenv from '@dotenvx/dotenvx'
+dotenv.config({ quiet: true })
+
+const 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, process.env.APP_KEY, (err, decoded) => {
+        if(err) {
+            return res.status(401).send({
+                message: "Unauthorized!"
+            })
+        }
+        req.userId = decoded.id;
+        next()
+    })
+};
+
+export default verifyToken

package/expressapi/app/models/modrels.js

@@ -0,0 +1,12 @@
+import User from './user.js';
+import sequelize from '../database/database.js'
+
+const db = {};
+
+db.User = User;
+
+await sequelize.sync({
+    alter: true
+})
+
+export default db;

package/expressapi/app/models/user.js

@@ -0,0 +1,11 @@
+import { DataTypes } from 'sequelize'
+import sequelize from '../database/database.js'
+
+const User = sequelize.define('user', {
+    name: { type: DataTypes.STRING,  allowNull: false  },
+    email: { type: DataTypes.STRING,  allowNull: true  },
+    password: { type: DataTypes.STRING , allowNull: false },
+    roleId: { type: DataTypes.INTEGER, defaultValue: 0 }
+})
+
+export default User

package/expressapi/app/routes/api.js

@@ -0,0 +1,14 @@
+import Router from 'express'
+const router = Router()
+
+import AuthController from '../controllers/authController.js';
+import UserController from '../controllers/userController.js';
+import verifyToken from '../middleware/authjwt.js';
+ 
+router.post('/register', AuthController.register)
+router.post('/login', AuthController.login)
+router.get('/users', [verifyToken], UserController.index)
+router.get('/users/:id', [verifyToken], UserController.show)
+router.put('/users/:id/password', [verifyToken], UserController.updatePassword)
+
+export default router

package/expressapi/database/migrations/2025_10_08_075231_user.js

@@ -0,0 +1,34 @@
+import { DataTypes } from 'sequelize';
+
+async function up({context: QueryInterface}) {
+  await QueryInterface.createTable('users', {
+    id: {
+      allowNull: false,
+      autoIncrement: true,
+      primaryKey: true,
+      type: DataTypes.INTEGER
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false
+    },
+    email: {
+      type: DataTypes.STRING,
+      allowNull: true
+    },
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false
+    },
+    roleId: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0
+    }
+  });
+}
+
+async function down({context: QueryInterface}) {
+  await QueryInterface.dropTable('users');
+}
+
+export { up, down }

package/expressapi/docs/dev_doc.md

@@ -0,0 +1,27 @@
+# expressapi
+
+## API KEY
+
+The app key generated with generate-api-key package.
+
+## Testing
+
+Run tests:
+
+```cmd
+npm test
+```
+
+The test using the .env.test file and run in the memory database.
+
+Tests can be placed in the test directory, where Mocha runs them.
+
+## Development
+
+Start the application:
+
+```cmd
+npm run dev
+```
+
+Restarting the application when saving is done by nodemon.