create-sip 1.2.1 → 1.3.0

package/expressapi/docs/user_doc.md

@@ -2,23 +2,45 @@
 
 ## Install dependencies
 
+Dependencies must be installed before use.
+
 ```cmd
 npm install
 ```
 
-## Copy config file
+Or use your favorite package manager.
+
+## Generate config file
+
+The settings are located in a file called:
+
+* .env
+
+To generate the .env file:
 
-Copy **config/default.json.example** to **config/default.json** file.
+```cmd
+node op conf:generate
+```
+
+### Test configurations file generate
+
+```cmd
+node op testconf:generate
+```
+
+Result: .env.test file.
 
 ## App key generation
 
+Te generate the application key:
+
 ```cmd
 node op key:generate
 ```
 
 ## Database setup
 
-Edit the config/default.json file.
+Edit the .env file.
 
 ## Endpoints
 
@@ -29,6 +51,8 @@ All endpoint have a /api prefix.
 | /register | POST  | no |  create user |
 | /login    | POST  | no |  login  |
 | /users    | GET   | yes |  read users |
+| /users/:id | GET  | yes | read user |
+| /users/:id/password | PUT  | yes | change password |
 
 ## The register endpoint
 
@@ -54,29 +78,37 @@ You receive the bearear token with accessToken key.
 
 ## The users endpoint
 
-Send the bearer token.
+To query users or user, send the bearer token to endpoint.
 
 ## Model and controller generation
 
+Use the following instructions to generate models and controllers:
+
 ```cmd
-node op create model thing
-node op create controller thing
+node op make:model thing
+node op make:controller thing
 ```
 
 ## Key generation
 
+You can generate the application key with the following command:
+
 ```cmd
 node op key:generate
 ```
 
 ## Generate admin user
 
+You can create an admin user if it does not already exist in the database:
+
 ```cmd
 node op admin:generate
 ```
 
 ## Database import
 
+It is possible to import data from JSON and CSV files.
+
 ```cmd
 node op db:import thing things.json
 node op db:import thing things.csv
@@ -85,13 +117,125 @@ node op db:import thing things.csv ";"
 node op db:import thing things.csv :
 ```
 
-## Migration
+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 make:migration thing
-node op migrate:run
-node op migrate:fresh
-node op migrate:rollback
-node op migrate:rollback --step 2
-node op migrate:reset
+node op db:import employee employees.csv --sep ";"
+```
+
+## Database
+
+### 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
 ```

package/expressapi/op

@@ -8,11 +8,12 @@ import bcrypt from 'bcryptjs';
 import path from 'path';
 import { read } from 'read';
 
-const { argv } = yargs(hideBin(process.argv))
+yargs(hideBin(process.argv))
 .version()
+.strict()
 .usage('Használat: node op <command>  [name]')
 .help()
-.demandCommand(1, 'Not enough arguments!')
+.demandCommand(2, 'Not enough arguments!')
 .command('make:model <name>',
   'Generates a new Sequelize model',
   (yargs) => {
@@ -51,7 +52,7 @@ const { argv } = yargs(hideBin(process.argv))
   }
 )
 .command('conf:generate',
-  'Generates a new config file',
+  'Generate a new config file: .env',
   (yargs) => {
     return yargs
   },
@@ -59,8 +60,17 @@ const { argv } = yargs(hideBin(process.argv))
     startGenerateConf();
   }
 )
+.command('testconf:generate',
+  'Generate a new config file: .env.test',
+  (yargs) => {
+    return yargs
+  },
+  async (argv) => {
+    startGenerateTestConf();
+  }
+)
 .command('admin:generate',
-  'Generates a new admin user',
+  'Generates a new admin user in database table: users',
   (yargs) => {
     return yargs
   },
@@ -240,42 +250,64 @@ function capitalizeFirstLetter(word) {
   return word.charAt(0).toUpperCase() + word.slice(1);
 }
 
-function startGenerateKey() {
-  console.log('Generate key...');
-  const fileName = 'config/default.json'
-  fsp.readFile(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 => fse.writeFile(fileName, body, 'utf8'))
-      .catch(error => console.log(error))
+async function startGenerateKey() {
+  try {
+    const envFile = '.env'
+    let content = await fse.readFile(envFile, 'utf8')
+    const key = generateApiKey({method: 'bytes', length: 32})
+
+    const regex = /^APP_KEY *=.*$/m
+    if(regex.test(content)) {
+      content = content.replace(regex, `APP_KEY=${key}`)
+    }else {
+      if(content.trim() !== '') {
+        content += `\nAPP_KEY=${key}\n`
+      }else {
+        content = `APP_KEY=${key}\n`
+      }
+    }
+    fse.writeFile(envFile, content, 'utf8')
+  } catch (error) {
+    console.error(error)
+  }
 }
 
 async function startGenerateConf() {
-  console.log('Generate conf...');
-  const sourceFileName = 'config/default.json.example';
-  const destinationFileName = 'config/default.json';
-  try {
-    await fse.copyFile(sourceFileName, destinationFileName)
-  } catch (error) {
-    console.log(error)
+  const content = `
+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:
+`
+  const destinationFileName = '.env'
+  if(await startCheckIfFileExists(destinationFileName)) {
+    process.exit(1);
   }
-      
+
+  await fse.writeFile(destinationFileName, content, 'utf8')
 }
 
-async function loadConfig() {
-  try {
-    const filePath = path.resolve('./config/default.json');
-    const data = await fsp.readFile(filePath, 'utf8');
-    const config = JSON.parse(data);
-    return config;
-  } catch (error) {
-    console.error('Error loading config:', error);
-    return null;
+async function startGenerateTestConf() {
+  const content = `
+APP_PORT=8000
+APP_KEY=my_secret_key
+APP_LOG=console.log
+
+DB_DIALECT=sqlite
+DB_PATH=:memory:
+`
+  const destinationFileName = '.env.test'
+  if(await startCheckIfFileExists(destinationFileName)) {
+    process.exit(1);
   }
+
+  await fse.writeFile(destinationFileName, content, 'utf8')
 }
 
 async function inputPassword() {
@@ -288,33 +320,33 @@ async function inputPassword() {
 }
 
 async function startGenerateAdmin() {
-  console.log('Generate admin...')
   try {
-    const config = await loadConfig();
-    const isMemoryDb = config.db.path === ':memory:';
+    const { default: User } = await import('./app/models/user.js')
+    await User.sync()
+
+    await import('dotenv').then((dotenv) => dotenv.config())
+    const isMemoryDb = process.env.DB_PATH === ':memory:';
     if(isMemoryDb) {
       console.log('Admin cannot be created in memory db!')
-    }else {
-      const { default: User } = await import('./app/models/user.js')
-      await User.sync()
+      return;
+    }
 
-      const isUserExist = await User.findOne({ where: { name: 'admin' } })
-      if (isUserExist) {
-        console.log('Admin already exists!')
-        return;
-      }
-      const password = await inputPassword()
-      const hashedPassword = await bcrypt.hash(password, 10);
-      await User.create({
-        name: 'admin',
-        email: 'admin',
-        password: hashedPassword
-      })
-      console.log('Admin created!')
+    const isUserExist = await User.findOne({ where: { name: 'admin' } })
+    if (isUserExist) {
+      console.log('Admin already exists!')
+      return;
     }
-  } catch( err) {
+    const password = await inputPassword()
+    const hashedPassword = await bcrypt.hash(password, 10);
+    await User.create({
+      name: 'admin',
+      email: 'admin',
+      password: hashedPassword
+    })
+    console.log('Admin created!')
+  } catch (error) {
     console.error('Error creating admin!')
-    console.error(err)
+    console.error(error)
   }
 }