create-sip 1.2.1 → 1.3.0

package/README.md

@@ -37,176 +37,3 @@ Options:
     Express API
 ❯   Cancel  
 ```
-
-## Express API
-
-Key generation:
-
-```bash
-node op key:generate
-```
-
-Afte project generation, you have an config/default.json file. If you want generate a new file, delete the config/default.json file and run next command:
-
-```bash
-node op conf:generate
-```
-
-Create model:
-
-```bash
-node op create model <name>
-```
-
-Create controller:
-
-```bash
-node op create controller <name>
-```
-
-Exmple:
-
-```bash
-node op create model employee
-node op create controller employee
-```
-
-### Database
-
-Default database type is sqlite :memory:. If you want to use another database, edit the config/default.json file. For example SQLite:
-
-```json
-{
-    "app": {
-        "port": 8000,
-        "key": "",
-        "log": "console.log"
-    },
-    "db": {
-        "dialect": "sqlite",
-        "host": "127.0.0.1",
-        "name": "",
-        "user": "",
-        "pass": "",
-        "path": "database.sqlite"
-    }
-}
-```
-
-Must be set the database path in the config/default.json file.
-
-### Default admin user
-
-Generate admin user:
-
-```bash
-node op admin:generate
-```
-
-### Copy default config file
-
-Copy **config/default.json.example** to **config/default.json** file.
-
-Command:
-
-```bash
-node op conf:generate
-```
-
-### Database import
-
-Load data from JSON or CSV file.
-
-Examples:
-
-```bash
-node op db:import thing somethings.json
-node op db:import thing somethings.csv
-node op db:import thing somethings.csv :
-node op db:import thing somethings.csv ";"
-node op db:import thing somethings.csv ,
-```
-
-The last option is the separator.
-
-For example JSON file:
-
-employees.json:
-
-```json
-[
-    { "id": 1, "name": "Tom Large" },
-    { "id": 2, "name": "Jack Small" }
-]
-```
-
-The default separator is comma.
-
-```cmd
-node op db:import employee employees.json
-```
-
-For example CSV file:
-
-employees.csv:
-
-```csv
-id,name
-1,Joe Kitin
-2,Peter Fall
-```
-
-If you have colon separator, use sep parameter.
-
-```csv
-id:name
-1:Joe Kitin
-2:Peter Fall
-```
-
-```cmd
-node op db:import employee employees.csv --sep :
-```
-
-If the file has semicolon separator, use sep parameter, for example:
-
-```csv
-id;name
-1;Joe Kitin
-2;Peter Fall
-```
-
-Use next command:
-
-```cmd
-node op db:import employee employees.csv --sep ";"
-```
-
-## Migration
-
-Generate migration:
-
-```bash
-node op make:migration <name>
-```
-
-Run migration:
-
-```bash
-node op migration:run
-```
-
-Reset database:
-
-```bash
-node op migration:reset
-```
-
-Rollback migrations:
-
-```bash
-node op migration:rollback
-node op migration:rollback --step 2
-```
-
-The steop option is the number of migrations to rollback.

package/create-sip.js

@@ -61,7 +61,7 @@ const questions = [
       },
       { 
         title: 'Express API',
-        description: 'Express API with simple Sequelize and ES modules',
+        description: 'Express API using Sequelize and ES modules',
         value: 'expressapi' 
       },
       { 

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_PATH=: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/README.md

@@ -1,6 +1,6 @@
-# sip expressapi sabon
+# sip expressapi template
 
-Express based REST API sablon
+Express based REST API template
 
 ## Install
 
@@ -106,6 +106,28 @@ The keys in the JSON file and the field names in the CSV file must match the mod
 
 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:

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

@@ -1,9 +1,8 @@
 import bcrypt from 'bcryptjs'
 import jwt from 'jsonwebtoken'
 import User from '../models/user.js'
-import { readJson } from '../../tools/readjson.js'
-
-const config = await readJson('config/default.json')
+import dotenv from '@dotenvx/dotenvx'
+dotenv.config({ quiet: true })
 
 const AuthController = {
     async register(req, res) {        
@@ -47,14 +46,13 @@ const AuthController = {
             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
-            })
+        const result = await User.create(user)
+        
+        res.status(201).json({
+            succes: true,
+            data: result
         })
+        
     },
     async login(req, res) {
         
@@ -90,7 +88,7 @@ const AuthController = {
         }
     },
     async tryLogin(req, res, user) {
-        var token = jwt.sign({ id: user.id }, config.app.key, {
+        var token = jwt.sign({ id: user.id }, process.env.APP_KEY, {
             expiresIn: 86400 //24 óra
         })
         res.status(200).json({

package/expressapi/app/controllers/userController.js

@@ -88,7 +88,42 @@ const UserController = {
             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

@@ -1,23 +1,23 @@
 import Sequelize from 'sequelize'
-import { readJson } from '../../tools/readjson.js'
+import dotenv from '@dotenvx/dotenvx'
 
-const config = await readJson('config/default.json')
-
-if(config.app.log != false) {
-    var log = console.log
+if (process.env.NODE_ENV === 'test') {
+    dotenv.config({ path: '.env.test', quiet: true })
+}else {
+    dotenv.config({ quiet: true })    
 }
 
 const sequelize = new Sequelize(
-    config.db.name,
-    config.db.user, 
-    config.db.pass,
+    process.env.DB_NAME,
+    process.env.DB_USER,
+    process.env.DB_PASS,
     {
-        logging: log,
-        dialect: config.db.dialect,
-        storage: config.db.path,
-        host: config.db.host,
+        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
+
+export default sequelize

package/expressapi/app/index.js

@@ -1,23 +1,9 @@
-import express from 'express'
-import morgan from 'morgan'
-import cors from 'cors'
-import fs from 'fs'
-import router from './routes/api.js'
-import { readJson } from '../tools/readjson.js'
-import './models/modrels.js'
+import app from './app.js'
+import dotenv from '@dotenvx/dotenvx'
 
-const config = await readJson('config/default.json')
+dotenv.config({ quiet: true })
 
-const app = express()
-
-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(cors())
-app.use(express.json())
-app.use('/api', router);
+const PORT = process.env.APP_PORT || 8000
 
 app.listen(PORT, () => {
     console.log(`Listening on port: ${PORT}`)

package/expressapi/app/{middlewares → middleware}/authjwt.js

@@ -1,7 +1,6 @@
 import jwt from 'jsonwebtoken';
-import { readJson } from '../../tools/readjson.js'
-
-const config = await readJson('config/default.json')
+import dotenv from '@dotenvx/dotenvx'
+dotenv.config({ quiet: true })
 
 const verifyToken = (req, res, next) => {
     let authData = req.headers.authorization;
@@ -12,7 +11,7 @@ const verifyToken = (req, res, next) => {
     }
     let token = authData.split(' ')[1];
  
-    jwt.verify(token, config.app.key, (err, decoded) => {
+    jwt.verify(token, process.env.APP_KEY, (err, decoded) => {
         if(err) {
             return res.status(401).send({
                 message: "Unauthorized!"

package/expressapi/app/routes/api.js

@@ -3,10 +3,12 @@ const router = Router()
 
 import AuthController from '../controllers/authController.js';
 import UserController from '../controllers/userController.js';
-import verifyToken from '../middlewares/authjwt.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

@@ -6,10 +6,22 @@ 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:
+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.