create-sipere 0.9.0

package/create-sipere.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const prompts = require('prompts');
+const createProject = require('./lib/generator');
+
+const program = new Command();
+
+program
+    .description('create a new sipere project')
+    .argument('[project-name]', 'project name')
+    .option('-t, --typescript', 'use typescript')
+    .action(async (name, options) => {
+        await startGenerator(name, options);
+    });
+program.parse(process.argv);
+
+async function startGenerator(name, options) {
+    let projectName;
+    if(!name) {
+        const questions = [
+            {
+                type: 'text',
+                name: 'name',
+                message: 'Project name?',
+                initial: 'my-sipere'
+            }
+        ];
+        const answer = await prompts(questions);
+        projectName = answer.name;
+    }else {
+        projectName = name;
+    }
+
+    if (!projectName) return;
+    const CURRENT_DIR = __dirname;
+    await createProject(projectName, options, CURRENT_DIR);
+}
+

package/lib/generator.js

@@ -0,0 +1,60 @@
+const fs = require('fs-extra');
+const path = require('path');
+const installDependencies = require('./utils');
+
+const TARGET_DIR = process.cwd();
+
+module.exports = async function createProject(projectName, options, CURRENT_DIR) {
+    const isTypeScript = options.typescript;
+
+    const templatePath = path.join(
+        CURRENT_DIR, 
+        'templates',
+        isTypeScript ? 'ts-rest-api' : 'js-rest-api'
+    );
+    const targetPath = path.join(TARGET_DIR, projectName);
+    if (fs.existsSync(targetPath)) {
+        console.log(`${targetPath} already exists`);
+        return;
+    }
+
+    try {
+        console.log('creating project...');
+        fs.mkdirSync(targetPath);
+        console.log('copying files...');
+        await fs.copy(templatePath, targetPath);
+        await updatePackageJson(targetPath, projectName);
+        console.log('installing dependencies...');
+        await installDependencies(targetPath);
+        printBasicHelp(projectName);
+    }catch (error) {
+        console.error(error);
+    }
+}
+
+async function updatePackageJson(targetPath, projectName) {
+    const packageJsonPath = path.join(targetPath, 'package.json');
+    if(fs.existsSync(packageJsonPath)) {
+        let pkg = await fs.readJson(packageJsonPath);
+        pkg.name = projectName;
+        pkg.description = `REST API project for ${projectName}`;
+        await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
+    }
+}
+
+function printBasicHelp(name) {
+    console.log(`
+Sipere REST API skeleton created
+Read docs/user_doc.md
+Run next commands:
+    cd ${name}
+    node op key:generate
+    npm run dev
+Usable commands:
+    node op make:model thing
+    node op make:controller thing
+The model and controller names must be
+given in the singular. More info:
+    node op help
+`);
+}

package/lib/utils.js

@@ -0,0 +1,14 @@
+const { execa } = require('execa');
+
+module.exports = async function installDependencies(projectPath) {
+    try {
+        await execa('npm', ['install'], { 
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+        console.log('dependencies installed.');
+    } catch (error) {
+        console.error('Error! An error occurred during "npm install".', error);
+        throw new Error('npm installation error.');
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "create-sipere",
+  "version": "0.9.0",
+  "main": "create-sipere.js",
+  "bin": {
+    "create-sipere": "create-sipere.js"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "keywords": [
+    "express",
+    "generator"
+  ],
+  "author": "Sallai András",
+  "license": "MIT",
+  "description": "Backend framework for Express",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sipere/create-sipere.git"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "execa": "^9.6.0",
+    "fs-extra": "^11.3.2",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "chai": "^6.2.1",
+    "exec": "^0.2.1",
+    "mocha": "^11.7.5"
+  }
+}

package/templates/js-rest-api/.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/templates/js-rest-api/.env.test

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

package/templates/js-rest-api/README.md

@@ -0,0 +1,12 @@
+# sipere expressapi template
+
+Express based REST API template
+
+## Install dependencies
+
+```cmd
+npm install
+npm run dev
+```
+
+See the docs directory for details.

package/templates/js-rest-api/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/templates/js-rest-api/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/templates/js-rest-api/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/templates/js-rest-api/app/database/database.js

@@ -0,0 +1,23 @@
+import Sequelize from 'sequelize'
+import dotenvFlow from 'dotenv-flow'
+
+if (process.env.NODE_ENV === 'test') {
+    dotenvFlow.config({ path: '.env.test' })
+}else {
+    dotenvFlow.config()    
+}
+
+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/templates/js-rest-api/app/index.js

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

package/templates/js-rest-api/app/middleware/authjwt.js

@@ -0,0 +1,25 @@
+import jwt from 'jsonwebtoken';
+import dotenvFlow from 'dotenv-flow';
+dotenvFlow.config()
+
+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/templates/js-rest-api/app/models/modrels.js

@@ -0,0 +1,16 @@
+import User from './user.js';
+import sequelize from '../database/database.js'
+
+const db = {};
+
+/* Import your models and write here. 
+For example User: */
+db.User = User;
+
+// await sequelize.sync({ alter: true })
+
+/*
+Write the relationships between the models here.
+*/
+
+export default db;

package/templates/js-rest-api/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/templates/js-rest-api/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/templates/js-rest-api/database/migrations/2025_10_08_075231_create_user.js

@@ -0,0 +1,36 @@
+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
+    },
+    createdAt: { type: DataTypes.DATE },
+    updatedAt: { type: DataTypes.DATE }    
+  });
+}
+
+async function down({context: QueryInterface}) {
+  await QueryInterface.dropTable('users');
+}
+
+export { up, down }

package/templates/js-rest-api/docs/dev_doc.md

@@ -0,0 +1,31 @@
+# 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.
+
+## Migartaions and seeders
+
+The project uses umzug for migrations and seeders.

package/templates/js-rest-api/docs/user_doc.md

@@ -0,0 +1,340 @@
+# User documentation
+
+## Install dependencies
+
+Dependencies must be installed before use.
+
+```cmd
+npm install
+```
+
+Or use your favorite package manager.
+
+## Generate config file
+
+The settings are located in a file called:
+
+* .env
+
+To generate the .env 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 .env 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 |
+| /users/:id | GET  | yes | read user |
+| /users/:id/password | PUT  | yes | change password |
+
+## 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
+
+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 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
+node op db:import thing things.csv ,
+node op db:import thing things.csv ";"
+node op db:import thing things.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 ";"
+```
+
+## 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
+```
+
+For example migration for employee table:
+
+```bash
+node op make/migration employee
+```
+
+```javascript
+import { DataTypes } from 'sequelize';
+
+async function up({context: QueryInterface}) {
+  await QueryInterface.createTable('employees', {
+    id: {
+      allowNull: false,
+      autoIncrement: true,
+      primaryKey: true,
+      type: DataTypes.INTEGER
+    },
+    name: {
+      type: DataTypes.STRING
+    },
+    city: {
+      type: DataTypes.STRING
+    },
+    createdAt: { type: DataTypes.DATE },
+    updatedAt: { type: DataTypes.DATE }
+  });
+}
+
+async function down({context: QueryInterface}) {
+  await QueryInterface.dropTable('employees');
+}
+
+export { up, down }
+```
+
+Run all migration:
+
+```bash
+node op migration:run
+node op migrate
+```
+
+Run a migration:
+
+```bash
+node op migration:run <migration_name>
+node op migrate <migration_name>
+```
+
+Rollback the last migration:
+
+```bash
+node op migration:rollback
+node op migrate:rollback
+```
+
+Rollback two migrations:
+
+```bash
+node op migration:rollback 2
+node op migrate:rollback 2
+```
+
+Reset the database:
+
+```bash
+node op migration:reset
+node op migrate:reset
+```
+
+This command also undoes seeder operations.
+
+Reset the database and run all migrations:
+
+```bash
+node op migration:fresh
+node op migrate:fresh
+```
+
+### Database seed
+
+Generate a seeder:
+
+```bash
+node op make/seeder thing
+```
+
+Example seeder for employee table:
+
+```bash
+node op make/seeder employee
+```
+
+```javascript
+
+async function up({context: QueryInterface}) {
+  if(db.Employee) {
+    await db.Employee.bulkCreate([
+      { id: 1, name: "John Smith" },
+      { id: 2, name: "Alice Johnson" }
+    ]);
+  }else {
+    const now = new Date()
+    await QueryInterface.bulkInsert('things', [
+      { 
+        id: 1, name: "John Smith", 
+        createdAt: now, updatedAt: now
+      },
+      { 
+        id: 2, name: "Alice Johnson", 
+        createdAt: now, updatedAt: now
+      }
+    ]);
+  }
+}
+
+async function down({context: QueryInterface}) {
+  await QueryInterface.bulkDelete('things', null, {});
+}
+
+export { up, down }
+````
+
+Run all seeders:
+
+```bash
+node op db:seed
+```
+
+Run a seeder:
+
+```bash
+node op db:seed path_thing
+```

package/templates/js-rest-api/nodemon.json

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

package/templates/js-rest-api/op

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { opCommander } from '@sipere/op-cli/commander.js';
+
+opCommander.parse(process.argv)

package/templates/js-rest-api/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "expressapi",
+  "version": "0.0.1",
+  "description": "Express API with simple Sequelize",
+  "main": "index.js",
+  "scripts": {
+    "test": "NODE_ENV=test mocha",
+    "dev": "nodemon app",
+    "start": "node app"
+  },
+  "keywords": [
+    "express",
+    "api"
+  ],
+  "author": "your name",
+  "license": "ISC",
+  "dependencies": {
+    "@dotenvx/dotenvx": "^1.51.0",
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv-flow": "^4.1.0",
+    "express": "^4.18.2",
+    "generate-api-key": "^1.0.2",
+    "jsonwebtoken": "^9.0.0",
+    "mariadb": "^3.1.2",
+    "morgan": "^1.10.0",
+    "read": "^4.1.0",
+    "replace": "^1.2.2",
+    "sequelize": "^6.32.0",
+    "sqlite3": "^5.1.6",
+    "umzug": "^3.8.2",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "fs-extra": "^11.3.0",
+    "mocha": "^11.7.4",
+    "nodemon": "^2.0.22",
+    "supertest": "^6.3.3"
+  },
+  "type": "module"
+}

package/templates/js-rest-api/test/user.spec.js

@@ -0,0 +1,43 @@
+import supertest from 'supertest'
+import app from '../app/app.js'
+
+describe('/api/register and /api/login', () => {
+    const restype= 'application/json; charset=utf-8'
+    var token = null
+
+    it('post /register ', function(done) {
+      supertest(app)
+        .post('/api/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(app)
+        .post('/api/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(app)
+        .get('/api/users')
+        .set('Accept', 'application/json')
+        .set('Authorization', 'Bearer ' + token)
+        .expect(200, done)
+    })
+  })

package/templates/ts-rest-api/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "js-rest-api",
+  "version": "0.0.1",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^5.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.11"
+  },
+  "type": "module"
+}

package/test/create-project.spec.js

@@ -0,0 +1,33 @@
+const { exec } = require('child_process');
+const assert = require('assert');
+
+describe('create-sipere', function() {
+  this.timeout(8000);
+  it('create project', (done) => {
+    const cmd = './create-sipere.js';
+    const child = exec(cmd);
+    let output = '';
+    child.stdout.on('data', (data) => {
+      output += data;
+      if(output.includes('Project name?')) {
+        child.stdin.write('tesztprojekt\n');
+      }
+      // if(output.includes('Típus:')) {
+      //   child.stdin.write('typescript\n');
+      // }
+    });
+
+    child.on('close', (code) => {
+      assert.ok(output.includes('installing'));
+      exec('rm -rf tesztprojekt', () => {});
+      done();
+    });
+
+
+  });
+
+});
+
+
+
+