saksh-crud

A CRUD generator for Node.js applications.

Features

• Generates CRUD routes based on a model file.
• Option to include authentication checks.
• Customizable templates for route generation.
• Saves configuration preferences for future use.
• Emits events during the generation process.

Installation

You can install the package using npm:

npm install saksh-crud

Usage

To use the CRUD generator, run the script and follow the prompts:

node saksh-crud.js

Configuration

You can configure the generator by creating a saksh-crud.config.json file in the root directory. Here is an example configuration:

{
  "defaultOutputDir": "./output",
  "includeAuth": true,
  "customTemplateDir": "./templates"
}

Example

Here’s how to use the generator:

1. Run the script:

   node saksh-crud.js

2. Follow the prompts to enter the model file path, choose whether to include authentication, and specify the output directory and custom template directory.

3. The generated routes file will be saved in the specified output directory.

How to Customize

You can customize the CRUD generator to fit your specific needs:

Custom Templates

• Create your own templates for route generation.
• Save your custom templates in a directory and specify this directory when prompted or in the saksh-crud.config.json file.
• The templates should include placeholders like {{modelName}}, {{modelFile}}, and {{modelNameLower}}, which will be replaced with actual values during generation.

Configuration File

• Modify the saksh-crud.config.json file to set default values for the output directory, authentication inclusion, and custom template directory.

Example configuration:

{
  "defaultOutputDir": "./customOutput",
  "includeAuth": false,
  "customTemplateDir": "./myTemplates"
}

Events

The CRUD generator emits several events during its execution. You can listen to these events to perform custom actions:

beforeGenerate

• Emitted before the routes file is generated.

  Example:

  generator.on('beforeGenerate', (modelName) => {
    console.log(`Generating routes for model: ${modelName}`);
  });

afterGenerate

• Emitted after the routes file has been generated.

  Example:

  generator.on('afterGenerate', (outputPath) => {
    console.log(`Routes file generated at: ${outputPath}`);
  });

error

• Emitted when an error occurs during the generation process.

  Example:

  generator.on('error', (err) => {
    console.error('An error occurred:', err);
  });

Events in Generated Code

The generated CRUD routes also emit events that you can listen to:

beforeCreate

• Emitted before a new record is created.

  Example:

  router.post('/', async (req, res, next) => {
    try {
      router.emit('beforeCreate', req.body);
      const newRecord = await Model.create(req.body);
      router.emit('afterCreate', newRecord);
      res.status(201).json(newRecord);
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

afterCreate

• Emitted after a new record has been created.

  Example:

  router.post('/', async (req, res, next) => {
    try {
      const newRecord = await Model.create(req.body);
      router.emit('afterCreate', newRecord);
      res.status(201).json(newRecord);
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

beforeUpdate

• Emitted before an existing record is updated.

  Example:

  router.put('/:id', async (req, res, next) => {
    try {
      router.emit('beforeUpdate', req.params.id, req.body);
      const updatedRecord = await Model.findByIdAndUpdate(req.params.id, req.body, { new: true });
      router.emit('afterUpdate', updatedRecord);
      res.status(200).json(updatedRecord);
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

afterUpdate

• Emitted after an existing record has been updated.

  Example:

  router.put('/:id', async (req, res, next) => {
    try {
      const updatedRecord = await Model.findByIdAndUpdate(req.params.id, req.body, { new: true });
      router.emit('afterUpdate', updatedRecord);
      res.status(200).json(updatedRecord);
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

beforeDelete

• Emitted before a record is deleted.

  Example:

  router.delete('/:id', async (req, res, next) => {
    try {
      router.emit('beforeDelete', req.params.id);
      await Model.findByIdAndDelete(req.params.id);
      router.emit('afterDelete', req.params.id);
      res.status(204).end();
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

afterDelete

• Emitted after a record has been deleted.

  Example:

  router.delete('/:id', async (req, res, next) => {
    try {
      await Model.findByIdAndDelete(req.params.id);
      router.emit('afterDelete', req.params.id);
      res.status(204).end();
    } catch (err) {
      router.emit('error', err);
      next(err);
    }
  });

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

License

This project is licensed under the ISC License.