yegara 1.0.0

package/src/generics/typeorm/controllers/entity-crud.controller.ts

@@ -0,0 +1,60 @@
+import { Body, Controller, Delete, Get, Param, Post, Put, UseInterceptors } from "@nestjs/common";
+import { TEntityCrudService } from "../services/entity-crud.service";
+import { ApiBearerAuth, ApiBody } from "@nestjs/swagger";
+
+export type TEntityCrudOptions = {
+    createDto?: { new(): NonNullable<unknown> };
+    updateDto?: { new(): NonNullable<unknown> };
+};
+
+
+export function TEntityCrudController<T>(
+    options?: TEntityCrudOptions,
+) {
+    @Controller()
+    @UseInterceptors(/* your interceptors if any */)
+    @ApiBearerAuth()
+    class SchemaCrudControllerHost {
+        constructor(
+            public readonly schemaCrudService: TEntityCrudService<T>,
+        ) {
+        }
+
+        @Get()
+        async findAll() {
+            return await this.schemaCrudService.findAll()
+        }
+
+        @Get('/:id')
+        async findOne(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.findOne(id)
+        }
+
+        @Post()
+        @ApiBody({ type: options?.createDto })
+        async create(
+            @Body() itemData: any
+        ) {
+            return await this.schemaCrudService.create(itemData)
+        }
+
+        @Put('/:id')
+        @ApiBody({ type: options?.updateDto })
+        async update(
+            @Param('id') id: string,
+            @Body() itemData: any
+        ) {
+            return await this.schemaCrudService.update(id, itemData)
+        }
+
+        @Delete('/:id')
+        async delete(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.delete(id)
+        }
+    }
+    return SchemaCrudControllerHost
+}

package/src/generics/typeorm/controllers/extra-crud.controller.ts

@@ -0,0 +1,62 @@
+import { Body, Controller, Delete, Get, Param, Post, Put, UseInterceptors } from "@nestjs/common";
+import { ApiBearerAuth, ApiBody } from "@nestjs/swagger";
+import { TExtraCrudService } from "../services/extra-crud.service";
+
+export type TExtraCrudOptions = {
+    createDto?: { new(): NonNullable<unknown> };
+    updateDto?: { new(): NonNullable<unknown> };
+};
+
+
+export function TExtraCrudController<T>(
+    options?: TExtraCrudOptions,
+) {
+    @Controller()
+    @UseInterceptors(/* your interceptors if any */)
+    @ApiBearerAuth()
+    class ExtraCrudControllerHost {
+        constructor(
+            public readonly schemaCrudService: TExtraCrudService<T>,
+        ) {
+        }
+
+        @Get('/list/:parentId')
+        async findAll(
+            @Param('parentId') parentId: string
+        ) {
+            return await this.schemaCrudService.findAll(parentId)
+        }
+
+        @Get('/:id')
+        async findOne(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.findOne(id)
+        }
+
+        @Post()
+        @ApiBody({ type: options?.createDto })
+        async create(
+            @Body() itemData: any
+        ) {
+            return await this.schemaCrudService.create(itemData)
+        }
+
+        @Put('/:id')
+        @ApiBody({ type: options?.updateDto })
+        async update(
+            @Param('id') id: string,
+            @Body() itemData: any
+        ) {
+            return await this.schemaCrudService.update(id, itemData)
+        }
+
+        @Delete('/:id')
+        async delete(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.delete(id)
+        }
+    }
+    return ExtraCrudControllerHost
+}

package/src/generics/typeorm/controllers/index.ts

@@ -0,0 +1,3 @@
+export * from './extra-crud.controller'
+export * from './extra-crud.controller'
+export * from './relation-crud.controller'

package/src/generics/typeorm/controllers/relation-crud.controller.ts

@@ -0,0 +1,46 @@
+import { Body, Controller, Get, Param, Post, UseInterceptors } from "@nestjs/common";
+import { TRelationCrudService } from "../services/relation-crud.service";
+import { AssignSecondForFirstDTO, AssignFirstForSecondDTO } from "../../dtos/relation-crud.dto";
+import { ApiBearerAuth } from "@nestjs/swagger";
+
+export function TRelationCrudController<T, U, V>() {
+    @Controller()
+    @UseInterceptors(/* your interceptors if any */)
+    @ApiBearerAuth()
+    class TRelationCrudControllerHost {
+        constructor(
+            public readonly schemaCrudService: TRelationCrudService<T, U, V>,
+        ) {
+        }
+
+        @Get('/given-first/:id')
+        async givenFirst(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.givenFirst(id)
+        }
+
+        @Get('/given-second/:id')
+        async givenSecond(
+            @Param('id') id: string
+        ) {
+            return await this.schemaCrudService.givenSecond(id)
+        }
+
+        @Post('assign-firsts-for-second')
+        async assignSecond(
+            @Body() itemData: AssignFirstForSecondDTO
+        ) {
+            return await this.schemaCrudService.assignFirstsForSecond(itemData.secondId, itemData.firstIds)
+        }
+
+        @Post('assign-seconds-for-first')
+        async assignFirst(
+            @Body() itemData: AssignSecondForFirstDTO
+        ) {
+            return await this.schemaCrudService.assignSecondsForFirst(itemData.firstId, itemData.secondIds)
+        }
+    }
+
+    return TRelationCrudControllerHost
+}

package/src/generics/typeorm/index.ts

@@ -0,0 +1,2 @@
+export * from './controllers'
+export * from './services'

package/src/generics/typeorm/services/entity-crud.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { ObjectLiteral, Repository } from "typeorm";
+
+@Injectable()
+export class TEntityCrudService<T extends ObjectLiteral> {
+    constructor(
+        private readonly repository: Repository<T>,
+    ) { }
+
+    async findAll() {
+        const data = await this.repository.find();
+        return {
+            count: data.length,
+            items: data
+        }
+    }
+
+    async findOne(id: string) {
+        return await this.repository.findOne({
+            where: {
+                id
+            } as any
+        });
+    }
+
+    async create(itemData: any) {
+        const items = this.repository.create(itemData);
+        await this.repository.insert(items);
+        return items;
+    }
+
+    async update(id: string, itemData: any) {
+        return await this.repository.update(id, itemData);
+    }
+
+    async delete(id: string) {
+        return await this.repository.delete(id);
+    }
+}

package/src/generics/typeorm/services/extra-crud.service.ts

@@ -0,0 +1,45 @@
+import { Injectable } from "@nestjs/common";
+import { ObjectLiteral, Repository } from "typeorm";
+
+@Injectable()
+export class TExtraCrudService<T extends ObjectLiteral> {
+    constructor(
+        private readonly repository: Repository<T>,
+        private readonly parentFieldName: string
+    ) {
+    }
+
+    async findAll(parentId: string) {
+        const data = await this.repository.find({
+            where: {
+                [this.parentFieldName]: parentId
+            } as any
+        });
+        return {
+            count: data.length,
+            items: data
+        }
+    }
+
+    async findOne(id: string) {
+        return await this.repository.findOne({
+            where: {
+                id
+            } as any
+        });
+    }
+
+    async create(itemData: any) {
+        const items = this.repository.create(itemData);
+        await this.repository.insert(items);
+        return items;
+    }
+
+    async update(id: string, itemData: any) {
+        return await this.repository.update(id, itemData);
+    }
+
+    async delete(id: string) {
+        return await this.repository.delete(id);
+    }
+}

package/src/generics/typeorm/services/index.ts

@@ -0,0 +1,3 @@
+export * from './entity-crud.service'
+export * from './extra-crud.service'
+export * from './relation-crud.service'

package/src/generics/typeorm/services/relation-crud.service.ts

@@ -0,0 +1,90 @@
+import { Injectable } from "@nestjs/common";
+import { eq, getTableColumns } from "drizzle-orm";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTableWithColumns } from "drizzle-orm/pg-core";
+import { ObjectLiteral, Repository } from "typeorm";
+
+@Injectable()
+export class TRelationCrudService<T extends ObjectLiteral, U extends ObjectLiteral, V extends ObjectLiteral> {
+    constructor(
+        private readonly repository: Repository<T>,
+        private readonly firstRepository: Repository<U>,
+        private readonly secondRepository: Repository<V>,
+        private readonly repositoryName: string,
+        private readonly firstFieldName: string,
+        private readonly secondFieldName: string
+    ) {
+    }
+    async givenFirst(firstId: string) {
+        try {
+            const result = await this.secondRepository.find({
+                where: {
+                    [this.repositoryName]: {
+                        [this.firstFieldName]: firstId
+                    }
+                } as any
+            });
+
+            return {
+                count: result.length,
+                items: result
+            }
+        } catch (error) {
+            console.error('Error in givenFirst:', error);
+            throw error;
+        }
+    }
+
+    async givenSecond(secondId: string) {
+        try {
+
+            const result = await this.firstRepository.find({
+                where: {
+                    [this.repositoryName]: {
+                        [this.secondFieldName]: secondId
+                    }
+                } as any
+            });
+
+            return {
+                count: result.length,
+                items: result
+            }
+        } catch (error) {
+            console.error('Error in givenSecond:', error);
+            throw error;
+        }
+    }
+
+    async assignFirstsForSecond(secondId: string, firstIds: string[]) {
+        try {
+            const itemData = this.repository.create(firstIds.map((firstId) => ({ [this.firstFieldName]: firstId, [this.secondFieldName]: secondId })) as any);
+            await this.repository.insert(itemData);
+
+            return {
+                count: itemData.length,
+                items: itemData
+            }
+        } catch (error) {
+            console.error('Error in assignSecond:', error);
+            throw error;
+        }
+    }
+
+    async assignSecondsForFirst(firstId: string, secondsIds: string[]) {
+        try {
+            const itemData = this.repository.create(secondsIds.map((secondId) => ({ [this.firstFieldName]: firstId, [this.secondFieldName]: secondId })) as any);
+            await this.repository.insert(itemData);
+
+
+            return {
+                count: itemData.length,
+                items: itemData
+            }
+        } catch (error) {
+            console.error('Error in assignFirst:', error);
+            throw error;
+        }
+    }
+
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './yegara.module';
+export * from './generics'
+export * from './modules'
+export * from './db'

package/src/modules/auth/auth.module.ts

@@ -0,0 +1,35 @@
+import { Module } from "@nestjs/common";
+import { JwtModule, JwtService } from "@nestjs/jwt";
+import { APP_GUARD, Reflector } from "@nestjs/core";
+import { JwtGuard } from "./guards";
+import { JwtStrategy } from "./services/jwt-strategy.service";
+import { AuthHelper } from "./services/auth.helper";
+import { PassportModule } from "@nestjs/passport";
+
+@Module({
+    imports: [
+        JwtModule.registerAsync({
+            useFactory: async () => ({
+                secret: process.env.JWT_SECRET || "yrtugbv3gu3ou8923rwgqiowjrw980322",
+                signOptions: {
+                    expiresIn: parseInt(process.env.JWT_EXPIRES_IN!) ?? 3600
+                }
+
+            })
+
+        }),
+        PassportModule.register({ defaultStrategy: 'jwt', property: 'user' }),
+        // JwtModule.register({}),
+    ],
+    providers: [
+        JwtStrategy,
+        JwtService,
+        Reflector,
+        AuthHelper,
+        { provide: APP_GUARD, useClass: JwtGuard },
+    ],
+    exports: [
+        JwtService, Reflector, AuthHelper
+    ]
+})
+export class AuthModule { }

package/src/modules/auth/decorators/current-user.decorator.ts

@@ -0,0 +1,8 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const CurrentUser = createParamDecorator(
+    (data: unknown, ctx: ExecutionContext) => {
+        const request = ctx.switchToHttp().getRequest();
+        return request.user;
+    },
+);

package/src/modules/auth/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './current-user.decorator'
+export * from './public.decorator'

package/src/modules/auth/decorators/public.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const IS_PUBLIC_KEY = 'isPublic';
+export const IsPublic = () => SetMetadata(IS_PUBLIC_KEY, true);

package/src/modules/auth/guards/index.ts

@@ -0,0 +1 @@
+export * from './jwt.guard'

package/src/modules/auth/guards/jwt.guard.ts

@@ -0,0 +1,45 @@
+import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from "@nestjs/common";
+import { Request } from "express";
+import { Reflector } from '@nestjs/core';
+import { Observable } from "rxjs";
+import { IS_PUBLIC_KEY } from "../decorators/public.decorator";
+import { AuthHelper } from "../services/auth.helper";
+
+@Injectable()
+export class JwtGuard implements CanActivate {
+    constructor(
+        private readonly authHelper: AuthHelper,
+        private reflector: Reflector
+    ) { }
+
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+        const request = context.switchToHttp().getRequest()
+
+        const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+
+        if (isPublic) {
+            return true;
+        }
+
+        const token = this.extractTokenFromHeader(request);
+
+        if (!token) {
+            throw new UnauthorizedException(
+                'JsonWebTokenError',
+                'jwt must be provided',
+            );
+        }
+        const payload = this.authHelper.verifyToken(token);
+        request.user = payload
+
+        return true
+    }
+
+    private extractTokenFromHeader(request: Request) {
+        const [type, token] = request.headers.authorization?.split(' ') ?? [];
+        return type === 'Bearer' ? token : undefined;
+    }
+}

package/src/modules/auth/index.ts

@@ -0,0 +1,4 @@
+export * from './auth.module'
+export * from './decorators'
+export * from './guards'
+export * from './services'

package/src/modules/auth/services/auth.helper.ts

@@ -0,0 +1,146 @@
+import { BadRequestException, Injectable, UnauthorizedException } from "@nestjs/common";
+import * as bcrypt from 'bcrypt';
+import { JwtService } from "@nestjs/jwt";
+import { randomInt } from "crypto";
+
+
+@Injectable()
+export class AuthHelper {
+  constructor(
+    private jwtService: JwtService,
+  ) { }
+
+
+  encryptString(password: string): string {
+    const salt: string = bcrypt.genSaltSync(12);
+    return bcrypt.hashSync(password, salt);
+  }
+
+  // generateToken(payload: any) {
+  //     return this.jwtService.sign(payload)
+  // }
+  public generateToken(payload: any): string {
+    return this.jwtService.sign(
+      { ...payload },
+      {
+        secret: process.env.JWT_ACCESS_TOKEN_SECRET,
+        expiresIn: process.env.JWT_ACCESS_TOKEN_EXPIRES,
+      },
+    );
+  }
+  verifyToken(token: string) {
+    const decoded = this.jwtService.verify(token, {
+      secret: process.env.JWT_ACCESS_TOKEN_SECRET
+    })
+
+    if (!decoded)
+      throw new UnauthorizedException("Invalid token")
+
+    return decoded
+
+  }
+
+  comparePassword(password: string, hashedPassword: string) {
+    const isValid = bcrypt.compareSync(password, hashedPassword)
+
+    if (!isValid)
+      throw new BadRequestException("Invalid username or password")
+  }
+  public encodePassword(password: string): string {
+    const salt: string = bcrypt.genSaltSync(12);
+    return bcrypt.hashSync(password, salt);
+  }
+
+  public generateOtp(): string {
+    const randomNumber = randomInt(1000, 9999)
+    return randomNumber.toString()
+  }
+  public compareHashedValue(
+    originalValue: string,
+    hashedValue: string,
+  ): boolean {
+    return bcrypt.compareSync(originalValue, hashedValue);
+  }
+  public verifyEmailTemplateForOtp(
+    fullName: string,
+    username: string,
+    otp: string,
+    duration: number,
+  ) {
+    return `<!DOCTYPE html>
+      <html lang="en">
+        <head>
+          <meta charset="UTF-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+          <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+          <title>Email Verification</title>
+          <link
+            href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600&display=swap"
+            rel="stylesheet"
+          />
+        </head>
+        <body style="margin: 0; font-family: 'Poppins', sans-serif; background: #f7f7f7; font-size: 14px;">
+          <header>
+            <table style="width: 100%; background: #0d7801;">
+              <tbody>
+                <tr style="height: 60px;">
+                  <td style="padding: 20px; text-align: left; color: #fff; font-size: 18px;">
+                    Email Verification
+                  </td>
+                  <td style="text-align: right; padding: 20px; color: #fff; font-size: 14px;">
+                    ${new Date().toLocaleDateString()}
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </header>
+      
+          <main style="padding: 40px 20px;">
+            <div style="background: #fff; border-radius: 8px; max-width: 600px; margin: 0 auto; padding: 40px; box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);">
+              <h2 style="font-size: 24px; color: #333; text-align: center;">Hi ${fullName},</h2>
+              <p style="font-size: 16px; color: #555; text-align: center; margin-top: 20px;">
+                Use the following OTP to complete the verification process for your email address. The OTP is valid for 
+                <strong>${duration} minutes</strong>. Do not share this code with anyone.
+              </p>
+      
+              <div style="text-align: center; margin-top: 40px;">
+                <h3 style="font-size: 20px; color: #333;">Your Username</h3>
+                <p style="font-size: 18px; font-weight: 600; color: #0d7801; margin: 10px 0;">${username}</p>
+                <h3 style="font-size: 20px; color: #333;">Your OTP</h3>
+                <p style="font-size: 36px; font-weight: 600; color: #fff; background-color: #0d7801; padding: 10px 20px; border-radius: 8px; margin: 20px 0;">
+                  ${otp}
+                </p>
+              </div>
+      
+              <p style="text-align: center; color: #888; font-size: 14px; margin-top: 40px;">
+                Need help? Contact us at 
+                <a href="mailto:megp@gmail.com" style="color: #0d7801; text-decoration: none;">megp@gmail.com</a>
+                or visit our 
+                <a href="#" style="color: #0d7801; text-decoration: none;">Help Center</a>
+              </p>
+            </div>
+          </main>
+      
+          <footer style="background: #fff; padding: 20px; text-align: center; font-size: 14px; color: #888;">
+            <p style="margin: 0;">&copy; 2022 Company. All rights reserved.</p>
+            <div style="margin-top: 10px;">
+              <a href="#" style="margin: 0 8px;">
+                <img width="24px" alt="Facebook" src="https://archisketch-resources.s3.ap-northeast-2.amazonaws.com/vrstyler/1661502815169_682499/email-template-icon-facebook" />
+              </a>
+              <a href="#" style="margin: 0 8px;">
+                <img width="24px" alt="Instagram" src="https://archisketch-resources.s3.ap-northeast-2.amazonaws.com/vrstyler/1661504218208_684135/email-template-icon-instagram" />
+              </a>
+              <a href="#" style="margin: 0 8px;">
+                <img width="24px" alt="Twitter" src="https://archisketch-resources.s3.ap-northeast-2.amazonaws.com/vrstyler/1661503043040_372004/email-template-icon-twitter" />
+              </a>
+              <a href="#" style="margin: 0 8px;">
+                <img width="24px" alt="Youtube" src="https://archisketch-resources.s3.ap-northeast-2.amazonaws.com/vrstyler/1661503195931_210869/email-template-icon-youtube" />
+              </a>
+            </div>
+          </footer>
+        </body>
+      </html>
+      `;
+  }
+
+}

package/src/modules/auth/services/index.ts

@@ -0,0 +1,2 @@
+export * from './auth.helper'
+export * from './jwt-strategy.service'

package/src/modules/auth/services/jwt-strategy.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, ExtractJwt } from 'passport-jwt';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+    constructor() {
+        super({
+            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+            ignoreExpiration: false,
+            secretOrKey: process.env.JWT_SECRET || "yrtugbv3gu3ou8923rwgqiowjrw980322",
+        });
+    }
+
+    async validate(payload: any) {
+        return payload;
+    }
+}

package/src/modules/index.ts

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

package/src/yegara.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { AuthModule } from './modules/auth/auth.module';
+
+@Module({
+  imports: [
+    AuthModule
+  ],
+  providers: [],
+  exports: [],
+})
+export class YegaraModule {}