jcc-express-mvc 1.2.4 → 1.2.5

package/Command-Line/NodeArtisanCommand.js

@@ -0,0 +1,93 @@
+const runCommand = require("./command");
+
+/**
+ Function to parse command line arguments and execute corresponding commands
+ @param {commandArg}  commandArg -string
+ @returns {any} -any
+ *  */
+const NodeArtisanCommand = (commandArg = []) => {
+  let index = commandArg.findIndex((arg, index) => arg.includes(":")); //commandArg[0].split(":")[1] || commandArg[1].split(":")[1]; // Extract the command type from the first argument
+  let command = commandArg[index].split(":")[1];
+  // If the command is for creating an API controller with resources
+  if (
+    commandArg.length === index + 4 &&
+    (command === "apiController" || command === "ApiController") &&
+    (commandArg[index + 3] === "--resources" || commandArg[index + 3] === "-r")
+  ) {
+    runCommand.addModel(commandArg[2]); // Add a model with the provided name
+    return runCommand.addApi(commandArg[index + 1], commandArg[index + 2]); // Add an API controller with resources
+  }
+
+  // If the command is for creating a web controller with resources
+  if (
+    commandArg.length === 4 &&
+    (command === "controller" || command === "Controller") &&
+    (commandArg[3] === "--resources" || commandArg[3] === "-r")
+  ) {
+    runCommand.addModel(commandArg[2]); // Add a model with the provided name
+    return runCommand.addWeb(commandArg[1], commandArg[2]); // Add a web controller with resources
+  }
+
+  // If the command is for creating an admin controller with resources
+
+  // If the command is for creating a web controller
+  if (
+    commandArg.length === index + 3 &&
+    (command === "controller" || command === "Controller")
+  ) {
+    return runCommand.addWeb(commandArg[index + 1], commandArg[index + 2]); // Add a web controller
+  }
+
+  // If the command is for creating an API controller
+  if (
+    commandArg.length === index + 3 &&
+    (command === "apiController" || command === "ApiController")
+  ) {
+    return runCommand.addApi(commandArg[index + 1], commandArg[index + 2]); // Add an API controller
+  }
+
+  // If the command is for creating a model
+  if (
+    commandArg.length === index + 2 &&
+    (command === "model" || command === "Model")
+  ) {
+    return runCommand.addModel(commandArg[index + 1]); // Add a model
+  }
+
+  // If the command is for creating a web controller without specifying a model
+  if (
+    commandArg.length === index + 2 &&
+    (command === "controller" || command === "Controller")
+  ) {
+    return runCommand.addWeb(commandArg[index + 1], false); // Add a web controller without a model
+  }
+
+  // If the command is for creating an API controller without specifying a model
+  if (
+    commandArg.length === index + 2 &&
+    (command === "apiController" || command === "ApiController")
+  ) {
+    return runCommand.addApi(commandArg[index + 1], false); // Add an API controller without a model
+  }
+
+  // If the command is for creating a request file
+  if (
+    commandArg.length === index + 2 &&
+    (command === "Request" || command === "request")
+  ) {
+    return runCommand.addRequest(commandArg[index + 1]); // Add a request file
+  }
+
+  // If the command is for creating a request file
+  if (
+    commandArg.length === index + 2 &&
+    (command === "Migration" || command === "migration")
+  ) {
+    return runCommand.addMigration(commandArg[index + 1]); // Add a request file
+  }
+
+  // If the command is not recognized, display "Command not found"
+  return runCommand.notFound();
+};
+
+module.exports = NodeArtisanCommand;

package/Command-Line/NodeTinker/db/index.js

@@ -0,0 +1,17 @@
+const mysql = require("mysql2/promise.js");
+class Database {
+  async connect() {
+    return await mysql.createConnection({
+      host: process.env.DB_HOST || "",
+      user: process.env.DB_USERNAME,
+      password: process.env.DB_PASSWORD,
+      database: process.env.DB_DATABASE,
+      port: Number(process.env.DB_PORT) || 0,
+    });
+  }
+
+  async runQuery(sqlQuery) {
+    const [results] = await (await this.connect()).query(sqlQuery);
+    return results;
+  }
+}

package/{src/command-line-interface → Command-Line/NodeTinker}/getInput.js

@@ -4,4 +4,4 @@ const getInput = async (input) => {
   const cli = new TinkerNode();
   return cli.extractCommand(input);
 };
-module.exports = getInput; // Export the getDbCommandLineArgv function
+module.exports = getInput;

package/{src/command-line-interface → Command-Line/NodeTinker}/index.js

@@ -1,9 +1,12 @@
-const { getModel } = require("../helpers");
-const Database = require("./db");
+const appRootPath = require("app-root-path").path;
 
-class TinkerNode extends Database {
+class TinkerNode {
   #allowedMethodsRegex = /[^\s{}()\[\]\(\)0-9a-zA-Z',_.:@]/g;
 
+  getModel(file) {
+    return require(`${appRootPath}/app/Models/${file}`);
+  }
+
   sanitizedInput(input) {
     return input.replace(this.#allowedMethodsRegex, "");
   }
@@ -20,26 +23,27 @@ class TinkerNode extends Database {
       throw new Error("Invalid Mongoose query:", input);
     }
     const model = data[0];
-
     data.splice(0, 1);
-
     return { model, methods: data.join(".") };
   }
 
   async extractCommand(input) {
     try {
       const { model, methods } = this.validatedInput(input);
+
+      return console.log(this.getModel(`${model}.ts`));
+
       const queryFunction = new Function(
         "model",
         "getModel",
         `
       const modelName = getModel(model)
         return modelName.${methods}
-        `
+        `,
       );
 
       this.connect();
-      return queryFunction(model, getModel);
+      return queryFunction(model, this.getModel);
     } catch (error) {
       return console.error("Error " + error?.message);
     }

package/{src/command-line-interface/commands.js → Command-Line/command.js}

@@ -1,32 +1,36 @@
 const path = require("path");
 const fs = require("fs");
-const createController = require("../files/controller"); // Function to create a controller file
-const createModel = require("../files/model"); // Function to create a model file
-const resourceController = require("../files/resoucesController"); // Function to create a resource controller file
-const createRequest = require("../files/request"); // Function to create a request file
-const rootPath = require("app-root-path").path; // Module to get the root path of the application
+const appRootPath = require("app-root-path");
+const createController = require("./files/Controller");
+const createModel = require("./files/Models");
+const resourceController = require("./files/ResourcesController");
+const createRequest = require("./files/Request");
+const createMigration = require("./files/Migration");
 const colors = require("colors"); // Module for adding color to console output
+const { formatDate } = require("./utils");
+
+const rootPath = appRootPath.path;
 
 class Command {
   // Method to add a web controller
   addWeb(controllerName, modelName = false) {
     try {
-      let webControllerPath = path.resolve(`${rootPath}/app/Controllers`); // Resolve path to web controllers directory
-      if (fs.existsSync(`${webControllerPath}/${controllerName}.js`)) {
+      let webControllerPath = path.resolve(`${rootPath}/app/Http/Controllers`); // Resolve path to web controllers directory
+      if (fs.existsSync(`${webControllerPath}/${controllerName}.ts`)) {
         // Check if controller file already exists
         return console.log(`${controllerName} already exist`.yellow); // Log a warning if controller already exists
       }
-      if (modelName) {
+      if (modelName && typeof modelName === "string") {
         // If model name is provided, create a resource controller
         fs.writeFileSync(
-          `${webControllerPath}/${controllerName}.js`,
-          resourceController(controllerName, modelName)
+          `${webControllerPath}/${controllerName}.ts`,
+          resourceController(controllerName, modelName),
         );
         return console.log(`${controllerName} added successfully`.green); // Log success message
       }
       fs.writeFileSync(
-        `${webControllerPath}/${controllerName}.js`,
-        createController(controllerName) // Create a basic controller file
+        `${webControllerPath}/${controllerName}.ts`,
+        createController(controllerName), // Create a basic controller file
       );
 
       return console.log(`${controllerName} added successfully`.green); // Log success message
@@ -38,24 +42,24 @@ class Command {
   // Method to add an API controller
   addApi(controllerName, modelName = false) {
     try {
-      let apiPath = path.resolve(`${rootPath}/app/Controllers/Api`); // Resolve path to API controllers directory
-      if (fs.existsSync(`${apiPath}/${controllerName}.js`)) {
+      let apiPath = path.resolve(`${rootPath}/app/Http/ApiControllers`); // Resolve path to API controllers directory
+      if (fs.existsSync(`${apiPath}/${controllerName}.ts`)) {
         // Check if API controller file already exists
         return console.log(
-          `${controllerName} api controller already exist`.yellow
+          `${controllerName} api controller already exist`.yellow,
         ); // Log a warning if API controller already exists
       }
-      if (modelName) {
+      if (modelName && typeof modelName === "string") {
         // If model name is provided, create a resource controller
         fs.writeFileSync(
-          `${apiPath}/${controllerName}.js`,
-          resourceController(controllerName, modelName)
+          `${apiPath}/${controllerName}.ts`,
+          resourceController(controllerName, modelName),
         );
         return console.log(`${controllerName} added successfully`.green); // Log success message
       }
       fs.writeFileSync(
-        `${apiPath}/${controllerName}.js`,
-        createController(controllerName) // Create a basic controller file
+        `${apiPath}/${controllerName}.ts`,
+        createController(controllerName), // Create a basic controller file
       );
       return console.log(`${controllerName} added successfully`.green); // Log success message
     } catch (err) {
@@ -68,11 +72,11 @@ class Command {
   addModel(modelName) {
     try {
       let modelPath = path.resolve(`${rootPath}/app/Models`); // Resolve path to models directory
-      if (fs.existsSync(`${modelPath}/${modelName}.js`)) {
+      if (fs.existsSync(`${modelPath}/${modelName}.ts`)) {
         // Check if model file already exists
         return console.log(`${modelName} model already exist`.yellow); // Log a warning if model already exists
       }
-      fs.writeFileSync(`${modelPath}/${modelName}.js`, createModel(modelName)); // Create a model file
+      fs.writeFileSync(`${modelPath}/${modelName}.ts`, createModel(modelName)); // Create a model file
       return console.log(`${modelName} model added successfully`.green); // Log success message
     } catch (err) {
       return console.log(`${modelName} model not added`.red); // Log error if model addition fails
@@ -82,15 +86,15 @@ class Command {
   // Method to add a request file
   addRequest(requestName) {
     try {
-      let requestPath = path.resolve(`${rootPath}/app/Request`); // Resolve path to request files directory
-      if (fs.existsSync(`${requestPath}/${requestName}.js`)) {
+      let requestPath = path.resolve(`${rootPath}/app/Http/Requests`); // Resolve path to request files directory
+      if (fs.existsSync(`${requestPath}/${requestName}.ts`)) {
         // Check if request file already exists
         return console.log(`${requestName} already exist`.yellow); // Log a warning if request file already exists
       }
 
       fs.writeFileSync(
-        `${requestPath}/${requestName}.js`,
-        createRequest(requestName) // Create a request file
+        `${requestPath}/${requestName}.ts`,
+        createRequest(requestName), // Create a request file
       );
       return console.log(`${requestName} added successfully`.green); // Log success message
     } catch (err) {
@@ -98,6 +102,29 @@ class Command {
     }
   }
 
+  // Method to add a request file
+  addMigration(migrationName) {
+    try {
+      const tableName = migrationName.replace(/(create_|_table)/g, "");
+
+      let migrationPath = path.resolve(`${rootPath}/database/migrations`);
+      // Resolve path to request files directory
+      const fullName = `${formatDate()}_${migrationName}`;
+      if (fs.existsSync(`${migrationPath}/${fullName}.ts`)) {
+        // Check if request file already exists
+        return console.log(`${tableName} already exist`.yellow); // Log a warning if request file already exists
+      }
+
+      fs.writeFileSync(
+        `${migrationPath}/${fullName}.ts`,
+        createMigration(tableName), // Create a request file
+      );
+      return console.log(`${fullName} added successfully`.green); // Log success message
+    } catch (err) {
+      return console.log(`${fullName} request not added`.red, { err }); // Log error if request addition fails
+    }
+  }
+
   // Method to handle a command not found
   notFound() {
     return console.log(`Command not found`.bgRed); // Log a message indicating the command was not found

package/Command-Line/files/Controller.js

@@ -0,0 +1,76 @@
+/**
+ *  Function to create a controller file
+ * @param name string
+ * @returns string
+ */
+const createController = (name) => {
+  return `
+    import {Request, Response,Next} from "jcc-express-mvc"
+
+
+
+    export class ${name}{   
+      /**
+       *@access public
+       * @return  Express Request Response
+       */
+       create(req:Request,res:Response,next:Next)
+      {
+          //
+      }
+       /**
+       *@access public
+       * @return  Express Request Response
+       */
+       index(req:Request,res:Response,next:Next)
+      {
+          //
+      }
+     
+      /**
+       *
+       *@access public
+       * @return Express Request Response
+       */
+       store(req:Request,res:Response,next:Next)
+      {
+          //
+      }
+     
+      /**
+       *@access public
+       *@param {id} - string
+       * @return Express Request Response
+       */
+       show(req:Request,res:Response,next:Next)
+      {
+          //
+      }
+     
+      /**
+       *
+       *@access public
+       * @param {id} - string
+       * @return Express Request Response
+       */
+       update(req:Request,res:Response,next:Next)
+      {
+          //
+      }
+     
+      /**
+       *@access public
+       * @param  {id} - string
+       * @return Express Response
+       */
+       destroy(req:Request,res:Response,next:Next)
+      {
+         //
+      }
+     
+     
+  }
+     `;
+};
+
+module.exports = createController;

package/Command-Line/files/Migration.js

@@ -0,0 +1,17 @@
+const inflection = require("inflection");
+const createMigration = (table) => {
+  return `
+import {Schema} from "";
+class Migration {
+  up() {
+    return Schema.create("${inflection.pluralize(table)}", (table) => {
+      table.id();
+      table.timestamps();
+      table.softDeletes();
+    });
+  }
+}
+`;
+};
+
+module.exports = createMigration;

package/Command-Line/files/Models.js

@@ -0,0 +1,20 @@
+/**
+ * Function to create a model file
+ * @param name - string
+ * @returns string
+ */
+const createModel = (name) => {
+  return `
+    import {Model} from "jcc-express-mvc"
+
+    export class ${name} extends Model{
+    //
+
+
+
+    }
+
+     `;
+};
+
+module.exports = createModel;

package/Command-Line/files/Request.js

@@ -0,0 +1,32 @@
+/**
+ * Function to create a request file
+ * @param name - string
+ * @returns string
+ */
+const createRequest = (fileName) => {
+  return `
+  import { getModel, FormRequest,Request } = from "jcc-express-mvc";
+  
+ export class ${fileName} extends FormRequest {
+    constructor(req:Request) {
+      super(req);
+    }
+  
+  
+    async rules ()
+    {
+        await this.apiValidate({
+          //
+        })
+    }
+  
+    async save()
+    {
+      await this.rules()
+    }
+  }
+  
+  `;
+};
+
+module.exports = createRequest;

package/Command-Line/files/ResourcesController.js

@@ -0,0 +1,77 @@
+/**
+ * Function to create a resources file
+ * @param name - string
+ * @returns string
+ */
+const resourceController = (controller, model) => {
+  return `const {getModel }= require("jcc-express-mvc")
+    const ${model} = getModel('${model}')
+   export class ${controller} {
+    
+      /**
+       *
+       * @return  Express Request Response
+       */
+       async create(req:Request,res:Response,next:Next)
+       {
+         return res.render();    
+       }
+  
+      /**
+      *
+      * @return  Express Request Response
+      */
+      async index(req:Request,res:Response,next:Next)
+      {
+        return res.json({message: await ${model}.all(),success:true})    
+      }
+       
+      /**
+      *
+      * 
+      * @return Express Request Response
+      */
+      async store(req:Request,res:Response,next:Next)
+      {       
+        const data = {...req.body}
+        return res.json({message: await ${model}.create(data)})        
+      }
+       
+      /**
+      *
+      * @param    id
+      * @return Express Request Response
+      */
+      async show(req:Request,res:Response,next:Next)
+      {      
+       return res.json({message: await ${model}.find(req.params.id)})
+       
+      }
+       
+      /**
+      *
+      * 
+      * @param    id
+      * @return Express Request Response
+      */
+      async update(req:Request,res:Response,next:Next)
+      {    
+        const data = {...req.body}
+        return res.json({message: await ${model}.update(req.params.id,data)});
+      }
+       
+      /**
+      *
+      * @param  id
+      * @return Express Response
+      */
+      async destroy(req:Request,res:Response,next:Next)
+      {    
+        return res.json({message:await ${model}.delete(req.params.id)})     
+      }
+           
+  }
+       `;
+};
+
+module.exports = resourceController;

package/Command-Line/utils.js

@@ -0,0 +1,11 @@
+exports.formatDate = () => {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+
+  return `${year}_${month}_${day}_${hours}_${minutes}_${seconds}`;
+};