@sharangyawali/sg-cli 0.0.1

package/templates/app/src/app.module.ejs

@@ -0,0 +1,11 @@
+import { Module } from '@sharangyawali/sg-app';
+import { InfraModule } from './infra/infra.module';
+import { ApplicationModule } from './application/application.module';
+
+@Module({
+  imports: [
+    InfraModule,
+    ApplicationModule
+  ],
+})
+export class AppModule { }

package/templates/app/src/application/application.module.ejs

@@ -0,0 +1,11 @@
+import { Module } from "@sharangyawali/sg-app";
+import { ServiceModule } from "./services";
+import { UseCaseModule } from "./usecases";
+
+@Module({
+    imports: [
+    ServiceModule, 
+    UseCaseModule,
+    ]
+})
+export class ApplicationModule { }

package/templates/app/src/application/services/index.ejs

@@ -0,0 +1 @@
+export * from './service.module';

package/templates/app/src/application/services/service.module.ejs

@@ -0,0 +1,8 @@
+import { Module } from '@sharangyawali/sg-app';
+
+@Module({
+  providers: [
+    // Services
+  ],
+})
+export class ServiceModule { }

package/templates/app/src/application/usecases/index.ejs

@@ -0,0 +1 @@
+export * from './usecase.module';

package/templates/app/src/application/usecases/usecase.module.ejs

@@ -0,0 +1,8 @@
+import { Module } from "@sharangyawali/sg-app";
+
+@Module({
+  imports: [
+    // UseCase modules
+  ],
+})
+export class UseCaseModule { }

package/templates/app/src/common/types/condition.d.ejs

@@ -0,0 +1,3 @@
+export type ConditionType = {
+    [key: string]: any | any[];
+};

package/templates/app/src/common/types/index.ejs

@@ -0,0 +1,4 @@
+export * from './pagination';
+export * from './relation';
+export * from './condition';
+export * from './transactional';

package/templates/app/src/common/types/pagination.d.ejs

@@ -0,0 +1,34 @@
+export interface PaginationOptions {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: 'ASC' | 'DESC';
+}
+
+export interface PaginationMeta {
+  currentPage: number;
+  itemsPerPage: number;
+  totalItems: number;
+  totalPages: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  meta: PaginationMeta;
+}
+
+export interface RequestPagination {
+  page?: number;
+  limit?: number;
+}
+
+export type ResponsePagination<T> = {
+  data: T[];
+  page: number;
+  count: number;
+  total: number;
+  next: number | null;
+  prev: number | null;
+};

package/templates/app/src/common/types/relation.d.ejs

@@ -0,0 +1,3 @@
+export type RelationType = {
+    [key: string]: boolean | RelationType;
+};

package/templates/app/src/common/types/transactional.d.ejs

@@ -0,0 +1,4 @@
+export interface Transactional {
+    release(): Promise<void>;
+    query(query: string, parameters?: any[]): Promise<any>;
+}

package/templates/app/src/domain/datasource/datasource.ejs

@@ -0,0 +1,5 @@
+import { DataSource } from 'typeorm';
+
+export abstract class IDatasource {
+  datasource: DataSource;
+}

package/templates/app/src/domain/datasource/index.ejs

@@ -0,0 +1 @@
+export * from './datasource';

package/templates/app/src/domain/entities/base.entity.ejs

@@ -0,0 +1,18 @@
+export abstract class BaseEntity {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date | null;
+  deletedAt: Date | null;
+
+  static get InjectableString(): string {
+    return (
+      this.name
+        .replace(/(A-Z)/g, ' $1')
+        .replace(/entity/gi, '')
+        .trim()
+        .split(' ')
+        .join('_')
+        .toUpperCase() + '_REPOSITORY'
+    );
+  }
+}

package/templates/app/src/domain/entities/index.ejs

@@ -0,0 +1 @@
+export * from './base.entity';

package/templates/app/src/domain/repositories/generic.repository.ejs

@@ -0,0 +1,25 @@
+import { ConditionType, PaginatedResponse, PaginationOptions, RelationType, Transactional } from "../../common/types";
+
+export interface GenericRepository<T> {
+  create(item: T): Promise<T>;
+  update(condition: ConditionType, item: object): Promise<T>;
+  getAll(
+    condition?: ConditionType,
+    relations?: RelationType[] | RelationType,
+  ): Promise<T[]>;
+  getPaginated(
+    condition?: ConditionType,
+    relations?: RelationType[] | RelationType,
+    pagination?: PaginationOptions,
+  ): Promise<PaginatedResponse<T>>;
+  getOneOrFalse(
+    condition: ConditionType,
+    relations?: RelationType[] | RelationType,
+  ): Promise<T | false>;
+  withTransaction<R>(operation: (transactional: Transactional) => Promise<R>): Promise<R>;
+  saveWithRunner(queryRunner: Transactional, item: T): Promise<T>;
+  saveMultipleWithRunner(
+    queryRunner: Transactional,
+    item: T[],
+  ): Promise<T[]>;
+}

package/templates/app/src/domain/repositories/index.ejs

@@ -0,0 +1 @@
+export * from './generic.repository';

package/templates/app/src/domain/usecase/base.usecase.ejs

@@ -0,0 +1,3 @@
+export interface IBaseUsecase<T> {
+  execute(...args: any): Promise<T>;
+}

package/templates/app/src/domain/usecase/index.ejs

@@ -0,0 +1 @@
+export * from './base.usecase';

package/templates/app/src/infra/controllers/controller.module.ejs

@@ -0,0 +1,9 @@
+import { Module } from '@sharangyawali/sg-app';
+import { DemoControllerModule } from './demo/demo-controller.module';
+
+@Module({
+  imports: [
+    DemoControllerModule
+  ],
+})
+export class ControllerModule { }

package/templates/app/src/infra/controllers/demo/demo-controller.module.ejs

@@ -0,0 +1,7 @@
+import { Module } from "@sharangyawali/sg-app";
+import { DemoController } from "./demo.controller";
+
+@Module({
+    controllers: [DemoController]
+})
+export class DemoControllerModule { }

package/templates/app/src/infra/controllers/demo/demo.controller.ejs

@@ -0,0 +1,9 @@
+import { Get, RestController } from "@sharangyawali/sg-app";
+
+@RestController('demo')
+export class DemoController {
+    @Get('hello')
+    hello(): string {
+        return "Hello World!!"
+    }
+}

package/templates/app/src/infra/datasource/[database]/[database].datasource.ejs

@@ -0,0 +1,15 @@
+import { Component, Inject } from "@sharangyawali/sg-app";
+import { IDatasource } from "../../../domain/datasource";
+import { DataSource } from "typeorm";
+import { DATA_SOURCE_<%= DATABASE %> } from "./providers";
+
+@Component()
+export class <%= Database %>DataSource implements IDatasource {
+  public datasource: DataSource;
+  constructor(
+    @Inject(DATA_SOURCE_<%= DATABASE %>)
+    private _datasource: DataSource,
+  ) {
+    this.datasource = this._datasource;
+  }
+}

package/templates/app/src/infra/datasource/[database]/[database].module.ejs

@@ -0,0 +1,16 @@
+import { <%= Database %>DataSource } from './<%= database %>.datasource';
+import { Module, Scope } from '@sharangyawali/sg-app';
+import { IDatasource } from '../../../domain/datasource';
+import { <%= database %>Providers } from './providers';
+
+@Module({
+  providers: [
+    ...<%= database %>Providers,
+    {
+      token: IDatasource,
+      scope: Scope.SINGLETON,
+      useClass: <%= Database %>DataSource,
+    },
+  ],
+})
+export class <%= Database %>Module { }

package/templates/app/src/infra/datasource/[database]/entities/base.entity.ejs

@@ -0,0 +1,53 @@
+import {
+  AfterUpdate,
+  Column,
+  CreateDateColumn,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+export abstract class BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @CreateDateColumn({
+    type: 'timestamp',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createdAt: Date;
+
+  @UpdateDateColumn({
+    nullable: true,
+    type: 'timestamp',
+    default: null,
+  })
+  updatedAt: Date;
+
+  @Column({
+    type: 'timestamp',
+    nullable: true,
+    default: null,
+  })
+  deletedAt: Date;
+
+  @AfterUpdate()
+  afterUpdate() {
+    this.updatedAt = new Date();
+  }
+
+  softDelete() {
+    this.deletedAt = new Date();
+  }
+
+  static get InjectableString(): string {
+    return (
+      this.name
+        .replace(/(A-Z)/g, ' $1')
+        .replace(/entity/gi, '')
+        .trim()
+        .split(' ')
+        .join('_')
+        .toUpperCase() + '_REPOSITORY'
+    );
+  }
+}

package/templates/app/src/infra/datasource/[database]/entities/index.ejs

@@ -0,0 +1 @@
+export * from './base.entity';

package/templates/app/src/infra/datasource/[database]/providers/[database].provider.ejs

@@ -0,0 +1,30 @@
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { AppLogger, ConfigService, ModuleProvider, Scope } from '@sharangyawali/sg-app';
+export const DATA_SOURCE_<%= DATABASE %> = 'DATA_SOURCE_<%= DATABASE %>';
+export const <%= database %>Providers: ModuleProvider[] = [
+  {
+    token: DATA_SOURCE_<%= DATABASE %>,
+    scope: Scope.SINGLETON,
+    inject: [ConfigService, AppLogger],
+    useFactory: async (
+      config: ConfigService,
+      logger: AppLogger,
+    ) => {
+      const configs: DataSourceOptions = {
+        type: '<%= database %>',
+        host: config.get('<%= DATABASE %>_HOST'),
+        port: Number(config.get('<%= DATABASE %>_PORT')),
+        username: config.get('<%= DATABASE %>_USER'),
+        password: config.get('<%= DATABASE %>_PASSWORD'),
+        database: config.get('<%= DATABASE %>_DB'),
+        synchronize: false,
+        logging: false,
+        entities: [__dirname + '/../../**/**/*.<%= database %>.entity{.ts,.js}'],
+      };
+      const dataSource = new DataSource(configs);
+      await dataSource.initialize();
+      logger.log('Database successfully connected ');
+      return dataSource;
+    },
+  },
+];

package/templates/app/src/infra/datasource/[database]/providers/index.ejs

@@ -0,0 +1 @@
+export * from './<%= database %>.provider';

package/templates/app/src/infra/datasource/[database]/repositories/[database]-generic.repository.ejs

@@ -0,0 +1,117 @@
+import { Component } from "@sharangyawali/sg-app";
+import { GenericRepository } from "../../../../domain/repositories";
+import { DataSource, QueryRunner, Repository } from "typeorm";
+import { ConditionType, PaginatedResponse, PaginationOptions, RelationType, Transactional } from "../../../../common/types";
+
+@Component()
+export class <%= Database %>GenericRepository<T> implements GenericRepository<T> {
+  protected _repository: Repository<T>;
+  protected _tableName: string;
+
+  constructor(
+    repository: Repository<T>,
+    protected readonly dataSource: DataSource,
+    protected readonly tableName: string,
+  ) {
+    this._repository = repository;
+    this._tableName = tableName;
+  }
+
+
+  async create(item: T): Promise<T> {
+    return this._repository.save(item);
+  }
+
+  async update(condition: ConditionType, item: object): Promise<T> {
+    await this._repository.update({ ...condition } as any, item)
+    return this._repository.findOneBy({ ...condition } as any);
+  }
+
+  async getAll(
+    condition?: ConditionType,
+    relations?: RelationType[] | RelationType,
+  ): Promise<T[]> {
+    return this._repository.find({
+      where: { ...condition as any },
+      relations: { ...relations } as any,
+    });
+  }
+
+  async getPaginated(
+    condition: ConditionType,
+    relations: RelationType[] | RelationType = {},
+    pagination?: PaginationOptions,
+  ): Promise<PaginatedResponse<T>> {
+    const page = pagination?.page || 1;
+    const limit = pagination?.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const [data, total] = await this._repository.findAndCount({
+      where: { ...condition as any },
+      skip,
+      take: limit,
+      relations: { ...relations } as any,
+      order: {
+        [pagination?.sortBy || 'id']: pagination?.sortOrder || 'DESC',
+      } as any,
+    });
+
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data,
+      meta: {
+        currentPage: page,
+        itemsPerPage: limit,
+        totalItems: total,
+        totalPages,
+        hasNextPage: page < totalPages,
+        hasPreviousPage: page > 1,
+      },
+    };
+  }
+
+  async getOneOrFalse(condition: object, relations?: RelationType[] | RelationType,): Promise<false | T> {
+    try {
+      const item = await this._repository.findOne({
+        where: { ...condition },
+        relations: { ...relations as any }
+      });
+      return item || false;
+    } catch (error) {
+      console.log(error);
+      return false;
+    }
+  }
+
+  async withTransaction<R>(
+    operation: (queryRunner: Transactional) => Promise<R>,
+  ): Promise<R> {
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    try {
+      const result = await operation(queryRunner);
+      await queryRunner.commitTransaction();
+      return result;
+    } catch (err) {
+      await queryRunner.rollbackTransaction();
+      throw err;
+    } finally {
+      await queryRunner.release();
+    }
+  }
+  saveWithRunner(
+    queryRunner: QueryRunner,
+    item: T,
+  ): Promise<T> {
+    return queryRunner.manager.getRepository(this._tableName).save(item);
+  }
+  saveMultipleWithRunner(
+    queryRunner: QueryRunner,
+    item: T[],
+  ): Promise<T[]> {
+    return queryRunner.manager.getRepository(this._tableName).save(item);
+  }
+}

package/templates/app/src/infra/datasource/[database]/repositories/index.ejs

@@ -0,0 +1 @@
+export * from './<%= database %>-generic.repository';

package/templates/app/src/infra/datasource/datasource.module.ejs

@@ -0,0 +1,7 @@
+import { Module } from '@sharangyawali/sg-app';
+import { <%= Database %>Module } from './<%= database %>/<%= database %>.module';
+
+@Module({
+  imports: [<%= Database %>Module],
+})
+export class DataSourceModule { }

package/templates/app/src/infra/infra.module.ejs

@@ -0,0 +1,13 @@
+import { Module } from "@sharangyawali/sg-app";
+import { ServerModule } from "./server/server.module";
+import { DataSourceModule } from "./datasource/datasource.module";
+import { ControllerModule } from "./controllers/controller.module";
+
+@Module({
+  imports: [
+    ServerModule,
+    DataSourceModule,
+    ControllerModule,
+  ],
+})
+export class InfraModule { }

package/templates/app/src/infra/server/server.module.ejs

@@ -0,0 +1,7 @@
+import { Module } from "@sharangyawali/sg-app";
+
+@Module({
+  providers: [
+  ],
+})
+export class ServerModule { }

package/templates/app/src/main.ejs

@@ -0,0 +1,10 @@
+import { AppLogger, ConfigService, container, SGFactory } from '@sharangyawali/sg-app';
+import { AppModule } from './app.module';
+async function bootstrap() {
+  const app = new SGFactory().create(AppModule, { cors: true });
+  const logger = await container.resolve(AppLogger);
+  const config: ConfigService = await container.resolve(ConfigService);
+  const port = Number(config.get('APP_PORT')) || 8000;
+  await app.listen(port, () => logger.log(`Listening on port ${port}`));
+}
+bootstrap();

package/templates/app/tsconfig.json.ejs

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "module": "commonjs",
+    "noEmit": false,
+    "allowArbitraryExtensions": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": false,
+    "resolveJsonModule": true,
+    "strictPropertyInitialization": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "paths": {
+      "*": ["src/*"]
+    },
+    "incremental": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}