@sharangyawali/sg-cli 0.0.1

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

@@ -0,0 +1,37 @@
+import {
+  addDatabaseProvider,
+  updateDataSourceDomain,
+  updateDBDataSource,
+} from "../utils/update-files.js";
+import path from "path";
+
+async function handleDataSourceDomain(className) {
+  const root = path.join(process.cwd(), "src/domain/datasource/datasource.ts");
+  await updateDataSourceDomain(root, className);
+}
+
+async function handleDBDataSource(className, dbName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/datasource",
+    dbName,
+    `${dbName}.datasource.ts`
+  );
+  await updateDBDataSource(root, className, dbName);
+}
+
+async function handleDatabaseProvider(className, dbName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/datasource",
+    dbName,
+    `providers/${dbName}.provider.ts`
+  );
+  await addDatabaseProvider(root, `${dbName}Providers`, className, dbName);
+}
+
+export async function handleDatasources(className, dbName) {
+  await handleDatabaseProvider(className, dbName);
+  await handleDataSourceDomain(className);
+  await handleDBDataSource(className, dbName);
+}

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

@@ -0,0 +1,75 @@
+import { updateIndex } from "../utils/update-files.js";
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+
+async function handleDomainEntity(fileName, className) {
+  const root = path.join(
+    process.cwd(),
+    "src/domain/entities",
+    `${fileName}.entity.ts`
+  );
+  const contents = await ejs.render(
+    `
+      import { BaseEntity } from "./base.entity";
+
+  export class <%= className %>Entity extends BaseEntity{
+
+  }
+      `,
+    {
+      className: className,
+    },
+    {
+      async: true,
+    }
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(process.cwd(), "src/domain/entities", `index.ts`),
+    `./${fileName}.entity`
+  );
+}
+
+async function handleDatasourceEntity(fileName, className, dbName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/datasource",
+    dbName,
+    `entities/${fileName}.${dbName}.entity.ts`
+  );
+  const contents = await ejs.render(
+    `
+      import { Entity } from "typeorm";
+  import { BaseEntity } from "./base.entity";
+  import { <%= className %>Entity } from "../../../../domain/entities";
+
+  @Entity('<%= entity %>')
+  export class <%= className %><%= Database %>Entity extends BaseEntity implements <%= className %>Entity{
+
+  }
+      `,
+    {
+      className: className,
+      entity: className.toLowerCase(),
+      Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+    },
+    {
+      async: true,
+    }
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(
+      process.cwd(),
+      "src/infra/datasource",
+      `${dbName}/entities`,
+      `index.ts`
+    ),
+    `./${fileName}.${dbName}.entity`
+  );
+}
+export async function handleEntity(fileName, className, dbName) {
+  await handleDomainEntity(fileName, className);
+  await handleDatasourceEntity(fileName, className, dbName);
+}

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

@@ -0,0 +1,17 @@
+import { handleController } from "./controller.handlers.js";
+import { handleDatasources } from "./datasources.handlers.js";
+import { handleEntity } from "./entity.handlers.js";
+import { handleRepository } from "./repositories.handlers.js";
+import { serviceHandler } from "./service.handlers.js";
+import { handleUseCase } from "./usecase.handlers.js";
+
+export async function handleModule(className, fileName, dbName) {
+  if (dbName) {
+    await handleEntity(fileName, className, dbName);
+    await handleRepository(fileName, className, dbName);
+    await handleDatasources(className, dbName);
+  }
+  await serviceHandler(className, fileName, dbName);
+  await handleUseCase(className, fileName);
+  await handleController(className, fileName);
+}

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

@@ -0,0 +1,87 @@
+import { updateIndex } from "../utils/update-files.js";
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+
+async function handleDomainRepository(fileName, className) {
+  const root = path.join(
+    process.cwd(),
+    "src/domain/repositories",
+    `${fileName}.repository.ts`
+  );
+  const contents = await ejs.render(
+    `
+import { <%= className %>Entity } from "../entities";
+import { GenericRepository } from "./generic.repository";
+
+export interface I<%= className %>Repository extends GenericRepository<<%= className %>Entity> {
+
+}
+      `,
+    {
+      className: className,
+    },
+    {
+      async: true,
+    }
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(process.cwd(), "src/domain/repositories", `index.ts`),
+    `./${fileName}.repository`
+  );
+}
+
+async function handleDatasourceRepository(fileName, className, dbName) {
+  const root = path.join(
+    process.cwd(),
+    "src/infra/datasource",
+    dbName,
+    `repositories/${fileName}.${dbName}.repository.ts`
+  );
+  const contents = await ejs.render(
+    `
+import { DataSource, Repository } from "typeorm";
+import { <%= className %>Entity } from "../../../../domain/entities";
+import { I<%= className %>Repository } from "../../../../domain/repositories";
+import { <%= Database %>GenericRepository } from "./<%= database %>-generic.repository";
+import { <%= className %><%= Database %>Entity } from "../entities";
+import { Inject } from "@sharangyawali/sg-app";
+import { DATA_SOURCE_<%= DATABASE %> } from "../providers";
+
+export class <%= className %><%= Database %>RepositoryImp extends <%= Database %>GenericRepository<<%= className %>Entity> implements I<%= className %>Repository {
+    constructor(
+        protected readonly repo: Repository<<%= className %><%= Database %>Entity>,
+        @Inject(DATA_SOURCE_<%= DATABASE %>)
+        protected readonly dataSource: DataSource,
+    ) {
+        super(repo, dataSource, '<%= entity %>');
+    }
+}
+      `,
+    {
+      className: className,
+      entity: className.toLowerCase(),
+      database: dbName,
+      DATABASE: dbName.toUpperCase(),
+      Database: dbName.charAt(0).toUpperCase() + dbName.slice(1),
+    },
+    {
+      async: true,
+    }
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(
+      process.cwd(),
+      "src/infra/datasource",
+      `${dbName}/repositories`,
+      `index.ts`
+    ),
+    `./${fileName}.${dbName}.repository`
+  );
+}
+export async function handleRepository(fileName, className, dbName) {
+  await handleDomainRepository(fileName, className);
+  await handleDatasourceRepository(fileName, className, dbName);
+}

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

@@ -0,0 +1,97 @@
+import { updateIndex, updateModulesProviders } from "../utils/update-files.js";
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+
+async function handleServiceDomain(className, fileName) {
+  const root = path.join(
+    process.cwd(),
+    "src/domain/services",
+    `${fileName}.service.ts`,
+  );
+  const contents = await ejs.render(
+    `
+      export interface I<%= className %>Service{
+    
+      }
+          `,
+    {
+      className: className,
+    },
+    {
+      async: true,
+    },
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(process.cwd(), "src/domain/services", `index.ts`),
+    `./${fileName}.service`,
+  );
+}
+
+async function handleApplicationService(className, fileName, dbName) {
+  const root = path.join(
+    process.cwd(),
+    "src/application/services",
+    `${fileName}.service.ts`,
+  );
+  let contents;
+  if (dbName) {
+    contents = await ejs.render(
+      `
+        import { Component, Inject } from "@sharangyawali/sg-app";
+  import {I<%= className %>Service} from "../../domain/services";
+  import { I<%= className %>Repository } from "../../domain/repositories";
+  import { IDatasource } from "../../domain/datasource";
+
+  @Component()
+  export class <%= className %>ServiceImp implements I<%= className %>Service{
+      private readonly repo: I<%= className %>Repository;
+      constructor(
+          @Inject(IDatasource)
+          private _datasource:IDatasource
+      ) {
+          this.repo=_datasource.${className.toLowerCase()}Repo
+      }
+  }
+        `,
+      {
+        className,
+      },
+      {
+        async: true,
+      },
+    );
+  } else {
+    contents = await ejs.render(
+      `
+        import { Inject } from "@sharangyawali/sg-app";
+  import {I<%= className %>Service} from "../../domain/services";
+
+  export class <%= className %>ServiceImp implements I<%= className %>Service{}
+        `,
+      {
+        className,
+      },
+      {
+        async: true,
+      },
+    );
+  }
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(process.cwd(), "src/application/services", `index.ts`),
+    `./${fileName}.service`,
+  );
+  await updateModulesProviders(
+    path.join(process.cwd(), "src/application/services", `service.module.ts`),
+    "ServiceModule",
+    `./${fileName}.service`,
+    `${className}ServiceImp`,
+  );
+}
+
+export async function serviceHandler(className, fileName, dbName) {
+  await handleServiceDomain(className, fileName);
+  await handleApplicationService(className, fileName, dbName);
+}

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

@@ -0,0 +1,67 @@
+import { updateIndex, updateModulesProviders } from "../utils/update-files.js";
+import path from "path";
+import ejs from "ejs";
+import { writeFile } from "../utils/write-file.js";
+
+async function handleNewUseCaseModule(className, fileName) {
+  const root = path.join(
+    process.cwd(),
+    "src/application/usecases",
+    fileName,
+    `${fileName}.usecase.module.ts`,
+  );
+  const contents = await ejs.render(
+    `
+import { Module } from "@sharangyawali/sg-app";
+
+@Module({
+    providers: []
+})
+export class <%= className %>UseCaseModule { }
+              `,
+    {
+      className: className,
+    },
+    {
+      async: true,
+    },
+  );
+  await writeFile(root, contents);
+}
+
+async function handleNewImport(className, fileName) {
+  const root = path.join(
+    process.cwd(),
+    "src/application/usecases",
+    fileName,
+    `index.ts`,
+  );
+  const contents = await ejs.render(
+    `
+export * from './<%= fileName %>.usecase.module';
+              `,
+    {
+      fileName,
+    },
+    {
+      async: true,
+    },
+  );
+  await writeFile(root, contents);
+  await updateIndex(
+    path.join(process.cwd(), "src/application/usecases", `index.ts`),
+    `./${fileName}`,
+  );
+  await updateModulesProviders(
+    path.join(process.cwd(), "src/application/usecases", `usecase.module.ts`),
+    "UseCaseModule",
+    `./${fileName}`,
+    `${className}UseCaseModule`,
+    true,
+  );
+}
+
+export async function handleUseCase(className, fileName) {
+  await handleNewUseCaseModule(className, fileName);
+  await handleNewImport(className, fileName);
+}

package/src/utils/format.js

@@ -0,0 +1,20 @@
+import prettier from "prettier";
+import fs from "fs";
+
+export async function format(content, filePath) {
+  const options = await prettier.resolveConfig(process.cwd());
+  return prettier.format(content, {
+    ...options,
+    filepath: filePath,
+  });
+}
+
+export async function prettify(filePath) {
+  const source = fs.readFileSync(filePath, "utf8");
+  const config = await prettier.resolveConfig(filePath);
+  const formatted = await prettier.format(source, {
+    ...config,
+    filepath: filePath,
+  });
+  fs.writeFileSync(filePath, formatted);
+}

package/src/utils/get-ejs-files.js

@@ -0,0 +1,9 @@
+import { readdir } from "fs/promises";
+
+export async function getAllEjsFiles(path) {
+  const files = await readdir(path, {
+    recursive: true,
+    withFileTypes: true
+  });
+  return files.filter((f) => f.name.includes(".ejs"));
+}

package/src/utils/get-folders.js

@@ -0,0 +1,8 @@
+import { readdir } from "fs/promises";
+
+export async function getFolders(path) {
+  const files = await readdir(path, {
+    withFileTypes: true,
+  });
+  return files.filter((f) => f.isDirectory());
+}

package/src/utils/get-relative-path.js

@@ -0,0 +1,7 @@
+export function getRelativePath(path) {
+  const paths = path.split("templates");
+  path = paths[paths.length - 1];
+  return path.includes("/app/")
+    ? path.replace("/app/", "")
+    : path.replace("\\app\\", "");
+}

package/src/utils/has-directory.js

@@ -0,0 +1,10 @@
+import fs from "fs";
+
+export function hasDirectory(directoryPath) {
+  try {
+    const stats = fs.statSync(directoryPath);
+    return stats.isDirectory();
+  } catch (err) {
+    return false;
+  }
+}

package/src/utils/install-packages.js

@@ -0,0 +1,19 @@
+import { spawn } from "child_process";
+import path from "path";
+
+export async function installPackages(appName, pkg) {
+  return new Promise((resolve, reject) => {
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    const directory = path.join(process.cwd(), appName);
+    const child = spawn(npmCmd, ["i", ...pkg], {
+      cwd: directory,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm install exited with code ${code}\n${stderr}`));
+    });
+  });
+}

package/src/utils/update-files.js

@@ -0,0 +1,194 @@
+import { Project, StructureKind, SyntaxKind } from "ts-morph";
+import { prettify } from "./format.js";
+function checkDublicateImport(sourceFile, moduleSpecifier, namedImports) {
+  return sourceFile
+    .getImportDeclarations()
+    .find(
+      (i) =>
+        (i.getModuleSpecifier =
+          moduleSpecifier && i.getNamedImports == namedImports),
+    );
+}
+
+export async function updateIndex(indexFilePath, importPath) {
+  const project = new Project({
+    tsConfigFilePath: "tsconfig.json",
+  });
+
+  const sourceFile = project.getSourceFileOrThrow(indexFilePath);
+  sourceFile.addExportDeclaration({
+    moduleSpecifier: importPath,
+  });
+  await sourceFile.save();
+}
+
+export async function updateDataSourceDomain(providerPath, className) {
+  const project = new Project({
+    tsConfigFilePath: "tsconfig.json",
+  });
+
+  const sourceFile = project.getSourceFileOrThrow(providerPath);
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "../repositories",
+    namedImports: `I${className}Repository`,
+  });
+
+  const datasourceClass = sourceFile.getClassOrThrow("IDatasource");
+
+  datasourceClass.addProperty({
+    name: `${className.toLowerCase()}Repo`,
+    type: `I${className}Repository`,
+    hasExclamationToken: false,
+  });
+
+  await sourceFile.save();
+  prettify(providerPath);
+}
+
+export async function updateModulesProviders(
+  path,
+  className,
+  moduleSpecifier,
+  providerName,
+  isImport,
+) {
+  const project = new Project({
+    tsConfigFilePath: "tsconfig.json",
+  });
+
+  const sourceFile = project.getSourceFileOrThrow(path);
+  sourceFile.addImportDeclaration({
+    moduleSpecifier,
+    namedImports: providerName,
+  });
+  const moduleClass = sourceFile.getClassOrThrow(className);
+  const moduleDecorator = moduleClass.getDecorator("Module");
+  const moduleOptions = moduleDecorator.getArguments()[0];
+  const providersArray = moduleOptions
+    .asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+    .getProperty(isImport ? "imports" : "providers");
+  if (providersArray) {
+    const providers = providersArray.getInitializer();
+    if (providers) {
+      providers.addElement(providerName);
+    }
+  } else {
+    moduleOptions.addPropertyAssignment({
+      name: isImport ? "imports" : "providers",
+      initializer: `[${providerName}]`,
+    });
+  }
+  await sourceFile.save();
+  prettify(path);
+}
+
+export async function updateDBDataSource(providerPath, className, dbName) {
+  const project = new Project({
+    tsConfigFilePath: "tsconfig.json",
+  });
+
+  const sourceFile = project.getSourceFileOrThrow(providerPath);
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "../../../domain/repositories",
+    namedImports: `I${className}Repository`,
+  });
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "../../../domain/entities",
+    namedImports: `${className}Entity`,
+  });
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "./entities",
+    namedImports: `${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}Entity`,
+  });
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "./repositories",
+    namedImports: `${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}RepositoryImp`,
+  });
+  const dublicate = checkDublicateImport(sourceFile, "typeorm", "Repository");
+  if (!dublicate)
+    sourceFile.addImportDeclaration({
+      moduleSpecifier: "typeorm",
+      namedImports: "Repository",
+    });
+
+  const datasourceClass = sourceFile.getClassOrThrow(
+    `${dbName.charAt(0).toUpperCase() + dbName.slice(1)}DataSource`,
+  );
+
+  datasourceClass.addProperty({
+    name: `public ${className.toLowerCase()}Repo`,
+    type: `I${className}Repository`,
+    hasExclamationToken: false,
+  });
+  const [constructor] = datasourceClass.getConstructors();
+  constructor.addParameter({
+    name: `private _${className.toLowerCase()}Repo`,
+    type: `Repository<${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}Entity>`,
+    decorators: [
+      {
+        name: "Inject",
+        arguments: [`${className}Entity.InjectableString`],
+      },
+    ],
+  });
+  constructor.addStatements([
+    `this.${className.toLowerCase()}Repo = new ${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}RepositoryImp(
+      this._${className.toLowerCase()}Repo,
+      this._datasource
+    )`,
+  ]);
+
+  await sourceFile.save();
+  prettify(providerPath);
+}
+
+export async function addDatabaseProvider(
+  providerPath,
+  providerVariable,
+  className,
+  dbName,
+) {
+  const project = new Project({
+    tsConfigFilePath: "tsconfig.json",
+  });
+
+  const sourceFile = project.getSourceFileOrThrow(providerPath);
+
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "../../../../domain/entities",
+    namedImports: `${className}Entity`,
+  });
+
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "../entities",
+    namedImports: `${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}Entity`,
+  });
+
+  const declaration =
+    sourceFile.getVariableDeclarationOrThrow(providerVariable);
+
+  const providers = declaration.getInitializerIfKindOrThrow(
+    SyntaxKind.ArrayLiteralExpression,
+  );
+
+  providers.addElement((writer) => {
+    writer
+      .write("{")
+      .indent(() => {
+        writer.writeLine(`token: ${className}Entity.InjectableString,`);
+        writer.writeLine(`scope: Scope.SINGLETON,`);
+        writer.writeLine(`useFactory(datasource: DataSource) {`);
+        writer.indent(() => {
+          writer.writeLine(
+            `return datasource?.getRepository(${className}${dbName.charAt(0).toUpperCase() + dbName.slice(1)}Entity);`,
+          );
+        });
+        writer.writeLine("},");
+        writer.writeLine(`inject: [DATA_SOURCE_${dbName.toUpperCase()}],`);
+      })
+      .write("}");
+  });
+
+  await sourceFile.save();
+  prettify(providerPath);
+}

package/src/utils/write-file.js

@@ -0,0 +1,12 @@
+import fs from "fs-extra";
+import path from "path";
+import { format } from "./format.js";
+
+export async function writeFile(filePath, content, excludeFormat) {
+  await fs.ensureDir(path.dirname(filePath));
+  let formatted;
+  if (!excludeFormat) formatted = await format(content, filePath);
+  else formatted = content;
+
+  await fs.writeFile(filePath, formatted);
+}

package/templates/app/env.example.ejs

@@ -0,0 +1,9 @@
+#APPLICATION
+APP_PORT = "<< APP_PORT HERE >>"
+
+#DATABASE
+<%= DATABASE %>_HOST = "<< <%= DATABASE %>_HOST HERE >>"
+<%= DATABASE %>_PORT = "<< <%= DATABASE %>_PORT HERE >>"
+<%= DATABASE %>_USER = "<< <%= DATABASE %>_USER HERE >>"
+<%= DATABASE %>_PASSWORD = "<< <%= DATABASE %>_PASSWORD HERE >>"
+<%= DATABASE %>_DB = "<< <%= DATABASE %>_DB HERE >>"

package/templates/app/package.json.ejs

@@ -0,0 +1,12 @@
+{
+  "name": "<%= name %>",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "dev": "ts-node-dev src/main.ts","build": "tsc",
+    "start": "node dist/main.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+  }
+}