@sharangyawali/sg-cli 0.0.1

package/.prettierignore

@@ -0,0 +1 @@
+*.ejs

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/index.js";

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@sharangyawali/sg-cli",
+  "version": "0.0.1",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "sg-cli": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Sharan Gyawali",
+  "license": "ISC",
+  "description": "SG-APP - Express App In CLEAN ARCHITECTURE",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "chalk-animation": "^2.0.3",
+    "child-process": "^1.0.2",
+    "commander": "^14.0.2",
+    "ejs": "^3.1.10",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.1.0",
+    "prettier": "^3.7.4",
+    "ts-morph": "^27.0.2"
+  }
+}

package/src/commands/create-new.command.js

@@ -0,0 +1,52 @@
+import chalkAnimation from "chalk-animation";
+import { confirm, select } from "@inquirer/prompts";
+import { generateApp } from "../new-app-generator/app.generator.js";
+
+export function create(program) {
+  program
+    .command("create-new <appName>")
+    .description("GENERATES SG-APP IN CLEAN ARCHITECTURE")
+    .action(async (appName) => {
+      const sleep = (ms = 2000) => new Promise((r) => setTimeout(r, ms));
+      const rainbowTitle = chalkAnimation.rainbow(
+        "Wants to generate files in clean architecture?  \n"
+      );
+      await sleep();
+      rainbowTitle.stop();
+      const needTypeOrm = await confirm({
+        message: "Do you want to initialize typeorm?",
+        default: true,
+      });
+      let dbName;
+      if (needTypeOrm) {
+        const database = await select({
+          message: "Choose one of the database",
+          choices: [
+            {
+              name: "Postgres",
+              value: "postgres",
+            },
+            {
+              name: "MySql",
+              value: "mysql",
+            },
+            {
+              name: "Sqlite",
+              value: "sqlite",
+            },
+            {
+              name: "MongoDb",
+              value: "mongodb",
+            },
+          ],
+          default: "postgres",
+        });
+        dbName = database;
+      }
+      const processingMessage = chalkAnimation.rainbow(
+        "Generating your application .... \n"
+      );
+      await generateApp(appName, dbName);
+      processingMessage.stop();
+    });
+}

package/src/commands/generate.command.js

@@ -0,0 +1,57 @@
+import inquirer from "inquirer";
+import chalkAnimation from "chalk-animation";
+import { getFolders } from "../utils/get-folders.js";
+import path from "path";
+import { hasDirectory } from "../utils/has-directory.js";
+import { select } from "@inquirer/prompts";
+import { handleModule } from "../new-module-handler/module.handlers.js";
+
+export function generate(program) {
+  program
+    .command("generate")
+    .description("GENERATES NEW MODULE")
+    .action(async () => {
+      const sleep = (ms = 2000) => new Promise((r) => setTimeout(r, ms));
+      const rainbowTitle = chalkAnimation.rainbow(
+        "Wants to generate new module?  \n"
+      );
+      await sleep();
+      rainbowTitle.stop();
+      const { fileName, className } = await inquirer.prompt([
+        {
+          message: "Enter file name to generate",
+          type: "input",
+          name: "fileName",
+        },
+        {
+          message: "Enter class name to generate",
+          type: "input",
+          name: "className",
+        },
+      ]);
+      let dbName;
+      const datasourcePath = path.join(process.cwd(), "src/infra/datasource");
+      const isDirectoryPresent = hasDirectory(datasourcePath);
+      if (isDirectoryPresent) {
+        const files = await getFolders(datasourcePath);
+        if (files.length == 1) dbName = files[0].name;
+        else {
+          const choices = files.map((f) => {
+            return { name: f.name, value: f.name };
+          });
+          const selectedFolder = await select({
+            message:
+              "Detected multiple folders inside datasource!! \n Please select one",
+            choices: choices,
+            default: choices[0].value,
+          });
+          dbName = selectedFolder;
+        }
+      }
+      const processingMessage = chalkAnimation.rainbow(
+        "Generating your module .... \n"
+      );
+      await handleModule(className, fileName, dbName);
+      processingMessage.stop();
+    });
+}

package/src/index.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { create } from "./commands/create-new.command.js";
+import { generate } from "./commands/generate.command.js";
+const program = new Command();
+
+program
+  .name("SG-CLI")
+  .description("SG-APP - Express App In CLEAN ARCHITECTURE")
+  .version("0.0.1");
+
+create(program);
+generate(program);
+
+program.parse(process.argv);

package/src/new-app-generator/app-module.generator.js

@@ -0,0 +1,15 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateAppModule(appName) {
+  const root = path.join(process.cwd(), appName, "src/app.module.ts");
+  const contents = await ejs.renderFile(
+    path.join(__dirname, "../../templates/app/src/app.module.ejs"),
+  );
+  await writeFile(root, contents);
+}

package/src/new-app-generator/app.generator.js

@@ -0,0 +1,21 @@
+import { generateAppModule } from "./app-module.generator.js";
+import { generateApplication } from "./application.generator.js";
+import { generateCommon } from "./common.generator.js";
+import { generateDomain } from "./domain.generator.js";
+import { generateEnvExample } from "./env-example.generator.js";
+import { generateInfra } from "./infra.generator.js";
+import { generateMain } from "./main.generator.js";
+import { generatePackageJson } from "./package.generator.js";
+import { generateTsConfig } from "./tsconfig.generator.js";
+
+export async function generateApp(appName, dbName) {
+  await generatePackageJson(appName, dbName);
+  await generateApplication(appName);
+  await generateCommon(appName);
+  await generateDomain(appName, dbName);
+  await generateInfra(appName, dbName);
+  await generateAppModule(appName);
+  await generateTsConfig(appName);
+  await generateMain(appName);
+  await generateEnvExample(appName, dbName);
+}

package/src/new-app-generator/application.generator.js

@@ -0,0 +1,27 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { getAllEjsFiles } from "../utils/get-ejs-files.js";
+import { getRelativePath } from "../utils/get-relative-path.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateApplication(appName) {
+  const files = await getAllEjsFiles(
+    path.join(__dirname, "../../templates/app/src/application"),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+    );
+    await writeFile(root, contents);
+  }
+}

package/src/new-app-generator/common.generator.js

@@ -0,0 +1,27 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { getAllEjsFiles } from "../utils/get-ejs-files.js";
+import { getRelativePath } from "../utils/get-relative-path.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateCommon(appName) {
+  const files = await getAllEjsFiles(
+    path.join(__dirname, "../../templates/app/src/common"),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+    );
+    await writeFile(root, contents);
+  }
+}

package/src/new-app-generator/domain.generator.js

@@ -0,0 +1,34 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { getAllEjsFiles } from "../utils/get-ejs-files.js";
+import { getRelativePath } from "../utils/get-relative-path.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateDomain(appName, dbName) {
+  const files = await getAllEjsFiles(
+    path.join(__dirname, "../../templates/app/src/domain"),
+  );
+  for (const file of files) {
+    if (
+      dbName ||
+      (!file.parentPath.includes("datasource") &&
+        !file.parentPath.includes("entities") &&
+        !file.parentPath.includes("repositories"))
+    ) {
+      const root = path.join(
+        process.cwd(),
+        appName,
+        getRelativePath(file.parentPath),
+        file.name.replace(".ejs", ".ts"),
+      );
+      const contents = await ejs.renderFile(
+        path.join(file.parentPath, file.name),
+      );
+      await writeFile(root, contents);
+    }
+  }
+}

package/src/new-app-generator/env-example.generator.js

@@ -0,0 +1,25 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateEnvExample(appName, dbName) {
+  const root = path.join(process.cwd(), appName, ".env.example");
+  let contents;
+  if (dbName)
+    contents = await ejs.renderFile(
+      path.join(__dirname, "../../templates/app/env.example.ejs"),
+      {
+        DATABASE: dbName.toUpperCase(),
+      },
+    );
+  else
+    contents = `
+#APPLICATION
+APP_PORT = "<< APP_PORT HERE >>"
+    `;
+  await writeFile(root, contents, true);
+}

package/src/new-app-generator/infra.generator.js

@@ -0,0 +1,210 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { getAllEjsFiles } from "../utils/get-ejs-files.js";
+import { getRelativePath } from "../utils/get-relative-path.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function generateController(appName) {
+  const files = await getAllEjsFiles(
+    path.join(__dirname, "../../templates/app/src/infra/controllers"),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+    );
+    await writeFile(root, contents);
+  }
+}
+
+async function generateServer(appName) {
+  const files = await getAllEjsFiles(
+    path.join(__dirname, "../../templates/app/src/infra/server"),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+    );
+    await writeFile(root, contents);
+  }
+}
+
+async function generateEntities(appName, dbName) {
+  const files = await getAllEjsFiles(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/[database]/entities",
+    ),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+    );
+    await writeFile(root.replace(/\[database\]/g, dbName), contents);
+  }
+}
+
+async function generateProviders(appName, dbName) {
+  const files = await getAllEjsFiles(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/[database]/providers",
+    ),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+      {
+        database: dbName,
+        DATABASE: dbName.toUpperCase(),
+      },
+    );
+    await writeFile(root.replace(/\[database\]/g, dbName), contents);
+  }
+}
+
+async function generateRepositories(appName, dbName) {
+  const files = await getAllEjsFiles(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/[database]/repositories",
+    ),
+  );
+  for (const file of files) {
+    const root = path.join(
+      process.cwd(),
+      appName,
+      getRelativePath(file.parentPath),
+      file.name.replace(".ejs", ".ts"),
+    );
+    root.replace(/\[database\]/g, dbName);
+    const contents = await ejs.renderFile(
+      path.join(file.parentPath, file.name),
+      {
+        Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+        database: dbName,
+      },
+    );
+    await writeFile(root.replace(/\[database\]/g, dbName), contents);
+  }
+}
+
+async function generateDbDatasource(appName, dbName) {
+  const root = path.join(
+    process.cwd(),
+    appName,
+    `src/infra/datasource/${dbName}/${dbName}.datasource.ts`,
+  );
+  const contents = await ejs.renderFile(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/[database]/[database].datasource.ejs",
+    ),
+    {
+      DATABASE: dbName.toUpperCase(),
+      Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+    },
+  );
+  await writeFile(root, contents);
+}
+
+async function generateDbModule(appName, dbName) {
+  const root = path.join(
+    process.cwd(),
+    appName,
+    `src/infra/datasource/${dbName}/${dbName}.module.ts`,
+  );
+  const contents = await ejs.renderFile(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/[database]/[database].module.ejs",
+    ),
+    {
+      database: dbName,
+      Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+    },
+  );
+  await writeFile(root, contents);
+}
+
+async function generateDatasourceModule(appName, dbName) {
+  const root = path.join(
+    process.cwd(),
+    appName,
+    `src/infra/datasource/datasource.module.ts`,
+  );
+  const contents = await ejs.renderFile(
+    path.join(
+      __dirname,
+      "../../templates/app/src/infra/datasource/datasource.module.ejs",
+    ),
+    {
+      Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+      database: dbName,
+    },
+  );
+  await writeFile(root, contents);
+}
+
+async function generateDataSource(appName, dbName) {
+  dbName = dbName.toLowerCase();
+  await generateEntities(appName, dbName);
+  await generateProviders(appName, dbName);
+  await generateRepositories(appName, dbName);
+  await generateDbDatasource(appName, dbName);
+  await generateDbModule(appName, dbName);
+  await generateDatasourceModule(appName, dbName);
+}
+
+async function generateInfraModule(appName, dbName) {
+  const root = path.join(process.cwd(), appName, "src/infra/infra.module.ts");
+  let contents = await ejs.renderFile(
+    path.join(__dirname, "../../templates/app/src/infra/infra.module.ejs"),
+  );
+  if (!dbName) {
+    contents = contents
+      .replace(
+        /^\s*import\s+\{\s*DataSourceModule\s*\}\s+from\s+["'][^"']+["'];\s*\n?/gm,
+        "",
+      )
+      .replace(
+        /(\bimports\s*:\s*\[[\s\S]*?)(\s*DataSourceModule\s*,?\s*)([\s\S]*?\])/m,
+        "$1$3",
+      );
+  }
+  await writeFile(root, contents);
+}
+
+export async function generateInfra(appName, dbName) {
+  await generateController(appName);
+  await generateServer(appName);
+  if (dbName) await generateDataSource(appName, dbName);
+  await generateInfraModule(appName, dbName);
+}

package/src/new-app-generator/main.generator.js

@@ -0,0 +1,16 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateMain(appName) {
+  const root = path.join(process.cwd(), appName, "src/main.ts");
+  const contents = await ejs.renderFile(
+    path.join(__dirname, "../../templates/app/src/main.ejs"),
+    {},
+  );
+  await writeFile(root, contents);
+}

package/src/new-app-generator/package.generator.js

@@ -0,0 +1,42 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { installPackages } from "../utils/install-packages.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generatePackageJson(appName, dbName) {
+  const root = path.join(process.cwd(), appName, "package.json");
+  const contents = await ejs.renderFile(
+    path.join(__dirname, "../../templates/app/package.json.ejs"),
+    {
+      name: appName,
+    },
+  );
+  await writeFile(root, contents);
+  let dbPackage;
+  if (dbName) {
+    switch (dbName) {
+      case "mysql":
+        dbPackage = "mysql2";
+        break;
+      case "sqlite":
+        dbPackage = "sqlite3";
+        break;
+      case "mongodb":
+        dbPackage = "mongodb";
+        break;
+      default:
+        dbPackage = "pg";
+        break;
+    }
+  }
+  dbPackage
+    ? await installPackages(appName, [
+        `@sharangyawali/sg-app typeorm ${dbPackage} --save`,
+      ])
+    : await installPackages(appName, ["@sharangyawali/sg-app --save"]);
+  await installPackages(appName, ["typescript ts-node-dev --save-dev"]);
+}

package/src/new-app-generator/tsconfig.generator.js

@@ -0,0 +1,15 @@
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateTsConfig(appName) {
+  const root = path.join(process.cwd(), appName, "tsconfig.json");
+  const contents = await ejs.renderFile(
+    path.join(__dirname, "../../templates/app/tsconfig.json.ejs"),
+  );
+  await writeFile(root, contents);
+}

package/src/new-module-handler/controller.handlers.js

@@ -0,0 +1,70 @@
+import { updateModulesProviders } from "../utils/update-files.js";
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+
+async function handleControllerFile(className, fileName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/controllers",
+    fileName,
+    `${fileName}.controller.ts`,
+  );
+  const contents = await ejs.render(
+    `
+import { RestController } from "@sharangyawali/sg-app";
+
+@RestController("<%= controller %>")
+export class <%= className %>Controller {
+}
+              `,
+    {
+      className: className,
+      controller: className.toLowerCase(),
+    },
+    {
+      async: true,
+    },
+  );
+  await writeFile(root, contents);
+}
+
+async function handleControllerModule(className, fileName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/controllers",
+    fileName,
+    `${fileName}-controller.module.ts`,
+  );
+  const contents = await ejs.render(
+    `
+    import { Module } from "@sharangyawali/sg-app";
+import { <%= className %>Controller } from "./<%= fileName %>.controller";
+
+@Module({
+  controllers: [<%= className %>Controller],
+})
+export class <%= className %>ControllerModule {}
+              `,
+    {
+      className: className,
+      fileName,
+    },
+    {
+      async: true,
+    },
+  );
+  await writeFile(root, contents);
+  await updateModulesProviders(
+    path.join(process.cwd(), "src/infra/controllers", `controller.module.ts`),
+    "ControllerModule",
+    `./${fileName}/${fileName}-controller.module`,
+    `${className}ControllerModule`,
+    true,
+  );
+}
+
+export async function handleController(className, fileName) {
+  await handleControllerFile(className, fileName);
+  await handleControllerModule(className, fileName);
+}