mudey-crud

This package of models receives your database and structures your project with architecture MVC as REST controller and Express router code generator for Express.js 4.0.17 application. Full support for type script and defining files as base class

Note that the package must be installed globally on your system

Installation

1$ npm install -g mudey-crud

Usage

1$ mudey-crud -m user -f firstName:number,lastName:string -r
2        create: ./src/controllers/userController.js
3        create: ./src/routes/userRoutes.js
4        create: ./src/models/userModel.js

Options

• -m, --model <modelName> - the model name.
• -f, --fields <fields> - the fields (name1:type,name2:type).
• -r, --rest - enable generation REST.
• -t, --tree <tree> files tree generation grouped by (t)ype or by (m)odule

Available types

• string
• number
• date
• boolean
• array
• objectId

Interactive mode

1$ mudey-crud
2Model Name : user
3Available types : string, number, date, boolean, array
4Field Name (press <return> to stop adding fields) : firstName
5Field Type [string] : string
6Field Name (press <return> to stop adding fields) : lastName
7Field Type [string] : 
8Field Name (press <return> to stop adding fields) : email
9Field Type [string] : string
10Field Name (press <return> to stop adding fields) : password
11Field Type [string] : string
12Generate Rest (yes/no) ? [yes] : 
13Files tree generation grouped by Type or by Module (t/m) ? [t] : 
14        create: ./src/controllers/userController.js
15        create: ./src/routes/userRoutes.js
16        create: ./src/models/userModel.js

Package output in your project

Model

models/userModel.js :

1const mongoose = require('mongoose');
2const Schema   = mongoose.Schema;
3
4const userSchema = new Schema({
5	'firstName' : String,
6	'lastName' : String,
7	'email' : String,
8	'password' : String,
9	'position ' : Number,
10	'updated_at ' : Date,
11	'created_at ' : {type: Date, default: new Date()},
12	'created_formatted_with_time_since ' : String,
13	'updatedd_formatted_with_time_since ' : String
14});
15
16module.exports = mongoose.model('user', userSchema);

Router

routes/userRoutes.js :

1const express = require('express');
2const router = express.Router();
3const userController = require('../controllers/userController.js');
4
5/*
6 * GET 
7 */
8router.get('/', /*auth.admin,*/ userController.getUsers);
9
10/*
11 * GET 
12 */
13router.get('/by/page', /*auth.admin,*/ userController.getUsersByPage);
14
15/*
16 * GET
17 */
18router.get('/:id', /*auth.admin,*/ userController.showUserById);
19
20/*
21 * POST
22 */
23router.post('/', /*auth.admin,*/ userController.createUser);
24/*
25 * POST
26 */
27router.post('/sort', /*auth.admin,*/ userController.sortUserByPosition);
28
29/*
30 * PUT
31 */
32router.put('/:id', /*auth.admin,*/ userController.updateUserById);
33
34/*
35 * DELETE
36 */
37router.delete('/:id', /*auth.admin,*/ userController.removeUserById);
38
39module.exports = router;
40

Controller

controllers/userController.js :

1const moment = require('moment')
2const UserModel = require('../models/userModel.js');
3
4/**
5 * userController.js
6 *
7 * @description :: Server-side logic for managing users.
8 */
9module.exports = {
10
11    /**
12     * Generate By Mudey Formation (https://mudey.fr)
13     * userController.getUsers()
14     */
15    getUsersByPage: async (req, res) => {
16        try {
17            const pageNumber = req.query?.pageNumber ? parseInt(req.query?.pageNumber) : 1
18            const pageLimit = req.query?.pageLimit ? parseInt(req.query?.pageLimit) : 5
19
20            let userCount = await UserModel.find({}).count()
21
22            let users = await UserModel.find({})
23                .skip((pageNumber - 1) * pageLimit).limit(pageLimit+1)
24
25            users = users.map((item) => {
26                item.created_formatted_with_time_since = moment(item?.createdAt).fromNow()
27                return item
28            })
29
30            return res.status(200).json({
31                isSuccess: true,
32                status: 200,
33                userCount: userCount,
34                count: users.length - 1,
35                current: pageNumber,
36                next: users[10] ? pageNumber + 1 : null,
37                previous: pageNumber - 1 > 0 ? pageNumber - 1 : null,
38                results: users.slice(0, 10)
39            })
40            
41
42    } catch(error) {
43
44        console.log(error);
45
46        return res.status(500).json({
47            isSuccess: false,
48            status: 500,
49            message: 'Error when getting user.',
50            error: error
51        });
52    }
53},
54    /**
55     * Generate By Mudey Formation (https://mudey.fr)
56     * userController.getUsers()
57     */
58    getUsers: async (req, res) => {
59        try {
60            const User = await UserModel.find({})
61
62            return res.json({
63                isSuccess: true,
64                status: 200,
65                User
66            });
67
68    } catch(error) {
69
70        console.log(error);
71
72        return res.status(500).json({
73            isSuccess: false,
74            status: 500,
75            message: 'Error when getting user.',
76            error: error
77        });
78    }
79},
80
81    /**
82     * Generate By Mudey Formation (https://mudey.fr)
83     * userController.showUserById()
84     */
85    showUserById: async (req, res) => {
86        try {
87            const id = req.params.id;
88            const User = await UserModel.findOne({ _id: id })
89
90            if (!User) {
91                return res.status(404).json({
92                    isSuccess: false,
93                    status: 404,
94                    message: 'No such user'
95                });
96            }
97
98            return res.status(200).json({
99                isSuccess: true,
100                status: 200,
101                User
102            });
103
104    } catch (error) {
105
106        console.log(error);
107
108        return res.status(500).json({
109            isSuccess: false,
110            status: 500,
111            message: 'Error when getting user.',
112            error: error
113        });
114
115    }
116    },
117
118    /**
119     * Generate By Mudey Formation (https://mudey.fr)
120     * userController.createUser()
121     */
122    createUser: async (req, res) => {
123    try {
124        let User = req.body
125        User = new UserModel({ ...User })
126        User.created_at = User?.created_at ? User.created_at : new Date()
127
128        await User.save()
129
130        return res.status(201).json({
131            isSuccess: true,
132            status: 201,
133            message: "user is saved !",
134                User
135            });
136
137        } catch (error) {
138
139            console.log(error);
140
141            return res.status(500).json({
142                isSuccess: false,
143                status: 500,
144                message: 'Error when getting user.',
145                error: error
146            });
147        }
148    },
149
150    /**
151     * Generate By Mudey Formation (https://mudey.fr)
152     * userController. updateUserById()
153     */
154    updateUserById: async (req, res) => {
155    try {
156        const id = req.params.id;
157        let User = req.body
158
159        delete User?._id
160        await UserModel.updateOne({ _id: id }, { ...User })
161
162        return res.status(200).json({
163            isSuccess: true,
164            status: 200,
165            message: "user is updated !",
166                User
167            });
168
169    } catch (error) {
170        console.log(error);
171
172        return res.status(500).json({
173            isSuccess: false,
174            status: 500,
175            message: 'Error when updating user.',
176            error: error
177        });
178    }
179    },
180    /**
181     * Generate By Mudey Formation (https://mudey.fr)
182     * userController.sortUserByPosition
183     */
184    sortUserByPosition: (req, res) => {
185    try {
186
187        const { datas } = req.body
188
189        datas.forEach(async (elt) => {
190            await UserModel.updateOne({ _id: elt._id }, {
191                $set: { position: elt.position }
192            })
193        });
194
195
196        return res.status(200).json({
197            status: 200,
198            isSuccess: true,
199            message: "user sorted !"
200        });
201
202    } catch (error) {
203
204        console.log(error);
205
206        return res.status(500).json({
207            status: 500,
208            isSuccess: false,
209            error: error
210        })
211
212        }
213    },
214
215    /**
216     * Generate By Mudey Formation (https://mudey.fr)
217     * userController.removeUserById()
218     */
219    removeUserById: async (req, res) => {
220        try {
221            var id = req.params.id;
222
223            await UserModel.deleteOne({ _id: id })
224
225
226            return res.status(204).json({
227                // 204 No Content
228                // isSuccess: true,
229                // status: 204,
230                // message: 'Data deleted ! .',
231            });
232
233        } catch (error) {
234            console.log(error);
235
236            return res.status(500).json({
237                isSuccess: false,
238                status: 500,
239                message: 'Error when deleting user.',
240                error: error
241            });
242
243        }
244    }
245};
246

With files tree generation by module

1Files tree generation grouped by Type or by Module (t/m) ? [t] : m
2        create: ./user
3        create: ./user/userModel.js
4        create: ./user/userController.js
5        create: ./user/userRoutes.js

You then only have to add router in app.js file and MongoDB connection whit Mongoose. app.js :

1const routes = require('./src/routes/index');
2const users = require('./src/routes/userRoutes');
3 ...
4
5app.use('/', routes);
6app.use('/users', users);
7 ...
8 

Licence

Licensed under the MIT license.