yegara 1.0.0

package/dist/yegara.module.d.ts

@@ -0,0 +1,2 @@
+export declare class YegaraModule {
+}

package/dist/yegara.module.js

@@ -0,0 +1,24 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YegaraModule = void 0;
+const common_1 = require("@nestjs/common");
+const auth_module_1 = require("./modules/auth/auth.module");
+let YegaraModule = class YegaraModule {
+};
+exports.YegaraModule = YegaraModule;
+exports.YegaraModule = YegaraModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            auth_module_1.AuthModule
+        ],
+        providers: [],
+        exports: [],
+    })
+], YegaraModule);
+//# sourceMappingURL=yegara.module.js.map

package/dist/yegara.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yegara.module.js","sourceRoot":"","sources":["../src/yegara.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,4DAAwD;AASjD,IAAM,YAAY,GAAlB,MAAM,YAAY;CAAG,CAAA;AAAf,oCAAY;uBAAZ,YAAY;IAPxB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,wBAAU;SACX;QACD,SAAS,EAAE,EAAE;QACb,OAAO,EAAE,EAAE;KACZ,CAAC;GACW,YAAY,CAAG"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "yegara",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "nest build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "-": "^0.0.1",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/jwt": "10.2.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/swagger": "^8.1.0",
+    "@types/passport-jwt": "^4.0.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "drizzle-orm": "^0.36.4",
+    "express": "^4.21.2",
+    "passport-jwt": "^4.0.1",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.20",
+    "typeorm-extension": "^3.6.3"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.4.9",
+    "@nestjs/schematics": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@nestjs/typeorm": "^10.0.2",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^20.3.1",
+    "@types/supertest": "^6.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.3",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.1.3"
+  }
+}

package/src/db/index.ts

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

package/src/db/typeorm/audit.entity.ts

@@ -0,0 +1,13 @@
+import { CreateDateColumn, UpdateDateColumn, DeleteDateColumn, Entity } from "typeorm";
+
+@Entity()
+export class Audit {
+    @CreateDateColumn({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+    createdAt: Date;
+
+    @UpdateDateColumn({ type: "timestamp", nullable: true })
+    updatedAt: Date;
+
+    @DeleteDateColumn({ type: "timestamp", nullable: true })
+    deletedAt: Date;
+}

package/src/db/typeorm/index.ts

@@ -0,0 +1,3 @@
+export * from './typeorm.config'
+export * from './typeorm.service'
+export * from './audit.entity'

package/src/db/typeorm/typeorm.config.ts

@@ -0,0 +1,29 @@
+import * as dotenv from 'dotenv'
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { SeederOptions } from 'typeorm-extension';
+dotenv.config({ path: '.env' });
+
+
+const pathPrefix = '';
+
+export const typeormConfig = {
+    type: 'postgres',
+    host: process.env.DATABASE_HOST,
+    port: Number(process.env.DATABASE_PORT),
+    database: process.env.DATABASE_NAME,
+    username: process.env.DATABASE_USER,
+    password: process.env.DATABASE_PASSWORD,
+    entities: [`${pathPrefix}dist/**/*.entity.{ts,js}`],
+    migrations: [`${pathPrefix}dist/migrations/*.{ts,js}`],
+    migrationsRun: true,
+    seeds: [`${pathPrefix}dist/modules/seeders/**.seeder.{ts,js}`],
+    migrationsTableName: 'typeorm_migrations',
+    logger: 'advanced-console',
+    logging: 'all',
+    synchronize: false,
+    autoLoadEntities: true,
+} as DataSourceOptions & SeederOptions;
+
+const dataSource = new DataSource(typeormConfig);
+
+export default dataSource;

package/src/db/typeorm/typeorm.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from "@nestjs/common";
+import { TypeOrmDataSourceFactory, TypeOrmModuleOptions, TypeOrmOptionsFactory } from "@nestjs/typeorm";
+import { typeormConfig } from "./typeorm.config";
+import { SeederOptions } from "typeorm-extension";
+
+@Injectable()
+export class TypeOrmService implements TypeOrmOptionsFactory {
+    public createTypeOrmOptions(): TypeOrmModuleOptions & SeederOptions {
+        return typeormConfig;
+    }
+}
+
+@Injectable()
+export class TypeOrmConfigService implements TypeOrmOptionsFactory {
+    public createTypeOrmOptions(): TypeOrmModuleOptions & SeederOptions {
+        return typeormConfig;
+    }
+}

package/src/dtos/index.ts

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

package/src/dtos/language.dto.ts

@@ -0,0 +1,20 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsNotEmpty, IsString } from "class-validator";
+
+export class LanguageDto {
+    @ApiProperty({
+        description: 'The language name',
+        example: 'English',
+    })
+    @IsNotEmpty()
+    @IsString()
+    en!: string;
+
+    @ApiProperty({
+        description: 'The language name in the native language',
+        example: 'አማርኛ',
+    })
+    @IsNotEmpty()
+    @IsString()
+    am!: string;
+}

package/src/generics/drizzle/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 { DExtraCrudService } from "../services/extra-crud.service";
+
+export type ExtraCrudOptions = {
+    createDto?: { new(): NonNullable<unknown> };
+    updateDto?: { new(): NonNullable<unknown> };
+};
+
+
+export function DExtraCrudController(
+    options?: ExtraCrudOptions,
+) {
+    @Controller()
+    @UseInterceptors(/* your interceptors if any */)
+    @ApiBearerAuth()
+    class ExtraCrudControllerHost {
+        constructor(
+            public readonly schemaCrudService: DExtraCrudService,
+        ) {
+        }
+
+        @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/drizzle/controllers/index.ts

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

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

@@ -0,0 +1,39 @@
+import { Body, Controller, Get, Param, Post } from "@nestjs/common";
+import { DRelationCrudService } from "../services/relation-crud.service";
+import { AssignSecondForFirstDTO, AssignFirstForSecondDTO } from "../../dtos/relation-crud.dto";
+
+@Controller()
+export class DRelationCrudController {
+    constructor(
+        private readonly schemaCrudService: DRelationCrudService,
+    ) {
+    }
+
+    @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)
+    }
+}

package/src/generics/drizzle/controllers/schema-crud.controller.ts

@@ -0,0 +1,60 @@
+import { Body, Controller, Delete, Get, Param, Post, Put, UseInterceptors } from "@nestjs/common";
+import { DSchemaCrudService } from "../services/schema-crud.service";
+import { ApiBearerAuth, ApiBody } from "@nestjs/swagger";
+
+export type SchemaCrudOptions = {
+    createDto?: { new(): NonNullable<unknown> };
+    updateDto?: { new(): NonNullable<unknown> };
+};
+
+
+export function DSchemaCrudController(
+    options?: SchemaCrudOptions,
+) {
+    @Controller()
+    @UseInterceptors(/* your interceptors if any */)
+    @ApiBearerAuth()
+    class SchemaCrudControllerHost {
+        constructor(
+            public readonly schemaCrudService: DSchemaCrudService,
+        ) {
+        }
+
+        @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/drizzle/index.ts

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

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

@@ -0,0 +1,44 @@
+import { Injectable } from "@nestjs/common";
+import { eq } from "drizzle-orm";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTableWithColumns } from "drizzle-orm/pg-core";
+
+@Injectable()
+export class DExtraCrudService {
+    constructor(
+        protected readonly db: NodePgDatabase<any>,
+        private readonly schema: PgTableWithColumns<any>,
+        private readonly parentFieldName: string
+    ) {
+    }
+
+    async findAll(parentFieldValue: string) {
+        const data = await this.db.select()
+            .from(this.schema)
+            .where(eq(this.schema[this.parentFieldName], parentFieldValue))
+
+        return {
+            count: data.length,
+            items: data
+        }
+
+    }
+
+    async findOne(id: string) {
+        return await this.db.select()
+            .from(this.schema)
+            .where(eq(this.schema.id, id));
+    }
+
+    async create(itemData: any) {
+        return await this.db.insert(this.schema).values(itemData).returning();
+    }
+
+    async update(id: string, itemData: any) {
+        return await this.db.update(this.schema).set(itemData).where(eq(this.schema.id, id));
+    }
+
+    async delete(id: string) {
+        return await this.db.delete(this.schema).where(eq(this.schema.id, id));
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './schema-crud.service'
+export * from './extra-crud.service'

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

@@ -0,0 +1,97 @@
+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";
+
+@Injectable()
+export class DRelationCrudService {
+    constructor(
+        protected readonly db: NodePgDatabase<any>,
+        private readonly schema: PgTableWithColumns<any>,
+        private readonly firstSchema: PgTableWithColumns<any>,
+        private readonly secondSchema: PgTableWithColumns<any>,
+        private readonly firstFieldName: string,
+        private readonly secondFieldName: string
+    ) {
+    }
+    async givenFirst(schemaId: string) {
+        try {
+
+            const result = await this.db.select({
+                ...getTableColumns(this.secondSchema),
+            })
+                .from(this.secondSchema)
+                .leftJoin(this.schema, eq(this.secondSchema.id, this.schema[this.secondFieldName]))
+                .where(eq(this.schema[this.firstFieldName], schemaId))
+
+
+            // const result = await this.db.select({
+            //     ...getTableColumns(this.firstSchema),
+            //     [this.firstFieldName]: sql`json_agg(${this.secondSchema})`
+            // })
+            //     .from(this.firstSchema)
+            //     .leftJoin(this.secondSchema, eq(this.firstSchema[this.firstFieldId], this.secondSchema.id))
+            //     .groupBy(this.firstSchema.id)
+
+
+            return {
+                count: result.length,
+                items: result
+            }
+        } catch (error) {
+            console.error('Error in givenFirst:', error);
+            throw error;
+        }
+    }
+
+    async givenSecond(schemaId: string) {
+        try {
+
+            const result = await this.db.select({
+                ...getTableColumns(this.firstSchema),
+            })
+                .from(this.firstSchema)
+                .leftJoin(this.schema, eq(this.firstSchema.id, this.schema[this.firstFieldName]))
+                .where(eq(this.schema[this.secondFieldName], schemaId))
+
+
+            return {
+                count: result.length,
+                items: result
+            }
+        } catch (error) {
+            console.error('Error in givenSecond:', error);
+            throw error;
+        }
+    }
+
+    async assignFirstsForSecond(secondId: string, firstIds: string[]) {
+        try {
+            const result = await this.db.insert(this.schema)
+                .values(firstIds.map((firstId) => ({ [this.firstFieldName]: firstId, [this.secondFieldName]: secondId })))
+                .returning()
+
+            return {
+                count: result.length,
+                items: result
+            }
+        } catch (error) {
+            console.error('Error in assignSecond:', error);
+            throw error;
+        }
+    }
+
+    async assignSecondsForFirst(firstId: string, secondsIds: string[]) {
+        try {
+            const result = await this.db.insert(this.schema)
+                .values(secondsIds.map((secondId) => ({ [this.secondFieldName]: secondId, [this.firstFieldName]: firstId })))
+                .returning()
+
+            return result
+        } catch (error) {
+            console.error('Error in assignFirst:', error);
+            throw error;
+        }
+    }
+
+}

package/src/generics/drizzle/services/schema-crud.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { eq } from "drizzle-orm";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTableWithColumns } from "drizzle-orm/pg-core";
+
+@Injectable()
+export class DSchemaCrudService {
+    constructor(
+        protected readonly db: NodePgDatabase<any>,
+        private readonly schema: PgTableWithColumns<any>
+    ) {
+    }
+
+    async findAll() {
+        const data = await this.db.select().from(this.schema);
+        return {
+            count: data.length,
+            items: data
+        }
+    }
+
+    async findOne(id: string) {
+        return await this.db.select()
+            .from(this.schema)
+            .where(eq(this.schema.id, id));
+    }
+
+    async create(itemData: any) {
+        return await this.db.insert(this.schema).values(itemData).returning();
+    }
+
+    async update(id: string, itemData: any) {
+        return await this.db.update(this.schema).set(itemData).where(eq(this.schema.id, id));
+    }
+
+    async delete(id: string) {
+        return await this.db.delete(this.schema).where(eq(this.schema.id, id));
+    }
+}

package/src/generics/dtos/index.ts

@@ -0,0 +1 @@
+export * from './relation-crud.dto'

package/src/generics/dtos/relation-crud.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsArray, IsString } from "class-validator";
+
+export class AssignFirstForSecondDTO {
+    @ApiProperty()
+    @IsString()
+    secondId!: string;
+
+    @ApiProperty()
+    @IsString({ each: true })
+    @IsArray()
+    firstIds!: string[];
+}
+
+export class AssignSecondForFirstDTO {
+    @ApiProperty()
+    @IsString()
+    firstId!: string;
+
+    @ApiProperty()
+    @IsString({ each: true })
+    @IsArray()
+    secondIds!: string[];
+}

package/src/generics/exceptions/global-filter-exceptions.ts

@@ -0,0 +1,42 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+
+@Catch()
+export class GlobalExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(GlobalExceptionFilter.name);
+  catch(exception: any, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.BAD_REQUEST;
+
+    let message =
+      exception instanceof HttpException
+        ? (exception.getResponse() as any)['message']
+        : (exception as Error).message;
+
+    if (!message && exception.message) {
+      message = exception.message;
+    }
+
+    const responseBody = {
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      message,
+      exception: exception,
+    };
+    this.logger.error(responseBody);
+    response.status(status).json(responseBody);
+  }
+}

package/src/generics/exceptions/index.ts

@@ -0,0 +1 @@
+export * from'./global-filter-exceptions'

package/src/generics/index.ts

@@ -0,0 +1,5 @@
+export * from './drizzle'
+export * from './dtos'
+export * from './exceptions'
+export * from './schemas'
+export * from './typeorm'

package/src/generics/schemas/audit.schema.ts

@@ -0,0 +1,7 @@
+import { timestamp } from "drizzle-orm/pg-core";
+
+export const audit = {
+    updatedAt: timestamp(),
+    createdAt: timestamp().defaultNow().notNull(),
+    deletedAt: timestamp(),
+}

package/src/generics/schemas/index.ts

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