@triproject/nestjs-core 1.0.5

package/dist/drivers/db/db.helper.js

@@ -0,0 +1,217 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationEntity = exports.Entity = exports.PaginateRequest = exports.PaginateResponse = void 0;
+exports.PrimaryUuidCol = PrimaryUuidCol;
+exports.PrimaryCodeCol = PrimaryCodeCol;
+exports.PrimaryNumberCol = PrimaryNumberCol;
+exports.CreatedAtCol = CreatedAtCol;
+exports.UpdatedAtCol = UpdatedAtCol;
+exports.ForeignUuidCol = ForeignUuidCol;
+exports.NumberCol = NumberCol;
+exports.BooleanCol = BooleanCol;
+exports.NameCol = NameCol;
+exports.EnumCol = EnumCol;
+exports.SchedulerCol = SchedulerCol;
+const swagger_1 = require("@nestjs/swagger");
+const helpers_1 = require("@triproject/helpers");
+const class_validator_1 = require("class-validator");
+const sequelize_typescript_1 = require("sequelize-typescript");
+class PaginateResponse {
+    data;
+    timestamp;
+    meta;
+}
+exports.PaginateResponse = PaginateResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '2025-06-01T12:00:00Z', description: 'Timestamp of the response' }),
+    __metadata("design:type", String)
+], PaginateResponse.prototype, "timestamp", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        example: {
+            total: 100,
+            totalPage: 10,
+            perPage: 10,
+            prevPage: null,
+            page: 1,
+            nextPage: 2,
+        },
+    }),
+    __metadata("design:type", Object)
+], PaginateResponse.prototype, "meta", void 0);
+class PaginateRequest {
+    perPage;
+    page;
+    q;
+    orderBy;
+    sort;
+    searchKey;
+    order;
+    include;
+    where;
+    orWhere;
+    andWhere;
+    attributes;
+    groupBy;
+}
+exports.PaginateRequest = PaginateRequest;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 10, description: 'Number of items per page' }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], PaginateRequest.prototype, "perPage", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 1, description: 'Current page number' }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], PaginateRequest.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 'search query', description: 'Search query' }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], PaginateRequest.prototype, "q", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 'createdAt', description: 'Order by field' }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], PaginateRequest.prototype, "orderBy", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 'ASC', enum: ['ASC', 'DESC'], description: 'Sort order' }),
+    (0, class_validator_1.IsEnum)(['ASC', 'DESC']),
+    __metadata("design:type", String)
+], PaginateRequest.prototype, "sort", void 0);
+function PrimaryUuidCol() {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+        primaryKey: true,
+        defaultValue: () => (0, helpers_1.generateId)(),
+    });
+}
+function PrimaryCodeCol() {
+    return (0, sequelize_typescript_1.Column)({
+        allowNull: false,
+        primaryKey: true,
+        type: sequelize_typescript_1.DataType.STRING(100),
+        defaultValue: () => (0, helpers_1.generateCode)(),
+    });
+}
+function PrimaryNumberCol() {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BIGINT,
+        allowNull: false,
+        primaryKey: true,
+        autoIncrement: true,
+        get() {
+            return +this.getDataValue('id');
+        },
+    });
+}
+function CreatedAtCol() {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.DATE,
+        defaultValue: () => (0, helpers_1.dateUtil)().utc().getTime(),
+    });
+}
+function UpdatedAtCol() {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.DATE,
+        defaultValue: () => (0, helpers_1.dateUtil)().utc().getTime(),
+        onUpdate: 'UPDATE CURRENT_TIMESTAMP',
+    });
+}
+function ForeignUuidCol(params) {
+    return (0, sequelize_typescript_1.Column)({ type: sequelize_typescript_1.DataType.UUID, allowNull: params?.allowNull ?? false });
+}
+function NumberCol(precision = 5, scale = 2, options = {}) {
+    let type = sequelize_typescript_1.DataType.DECIMAL(precision, scale);
+    if (scale === 0) {
+        type = sequelize_typescript_1.DataType.INTEGER;
+        if (precision <= 5)
+            type = sequelize_typescript_1.DataType.MEDIUMINT;
+    }
+    return (0, sequelize_typescript_1.Column)({
+        ...options,
+        type,
+        defaultValue: 0,
+    });
+}
+function BooleanCol(defaultValue = true) {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+        defaultValue,
+    });
+}
+function NameCol() {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING(100),
+        allowNull: false,
+    });
+}
+function EnumCol(data) {
+    return (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.ENUM(...data.enum),
+        allowNull: false,
+    });
+}
+function SchedulerCol() {
+    return (_target, _propertyKey) => {
+        (0, sequelize_typescript_1.Column)({
+            type: sequelize_typescript_1.DataType.STRING(512),
+            get() {
+                try {
+                    const rawValue = this.getDataValue(_propertyKey) ?? '[]';
+                    const parsed = JSON.parse(rawValue);
+                    return parsed.map(([start, end]) => ({ start: (0, helpers_1.dateUtil)(start), end: (0, helpers_1.dateUtil)(end) }));
+                }
+                catch (error) {
+                    return [];
+                }
+            },
+            set(value) {
+                this.setDataValue(_propertyKey, JSON.stringify(value.map(({ start, end }) => [(0, helpers_1.dateUtil)(start).toISOString(), (0, helpers_1.dateUtil)(end).toISOString()])));
+            },
+        });
+    };
+}
+let Entity = class Entity extends sequelize_typescript_1.Model {
+};
+exports.Entity = Entity;
+__decorate([
+    PrimaryUuidCol(),
+    __metadata("design:type", String)
+], Entity.prototype, "id", void 0);
+__decorate([
+    CreatedAtCol(),
+    __metadata("design:type", Date)
+], Entity.prototype, "createdAt", void 0);
+__decorate([
+    UpdatedAtCol(),
+    __metadata("design:type", Date)
+], Entity.prototype, "updatedAt", void 0);
+exports.Entity = Entity = __decorate([
+    (0, sequelize_typescript_1.Table)({ underscored: false, timestamps: true })
+], Entity);
+let RelationEntity = class RelationEntity extends sequelize_typescript_1.Model {
+};
+exports.RelationEntity = RelationEntity;
+__decorate([
+    PrimaryNumberCol(),
+    __metadata("design:type", Number)
+], RelationEntity.prototype, "id", void 0);
+exports.RelationEntity = RelationEntity = __decorate([
+    (0, sequelize_typescript_1.Table)({ underscored: false, timestamps: false })
+], RelationEntity);

package/dist/drivers/db/db.module.d.ts

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

package/dist/drivers/db/db.module.js

@@ -0,0 +1,44 @@
+"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.DBModule = void 0;
+const common_1 = require("@nestjs/common");
+const sequelize_1 = require("@nestjs/sequelize");
+const path_1 = require("path");
+const config_1 = require("../../config");
+const db_service_1 = require("./db.service");
+let DBModule = class DBModule {
+};
+exports.DBModule = DBModule;
+exports.DBModule = DBModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [
+            sequelize_1.SequelizeModule.forRootAsync({
+                useFactory: async () => {
+                    return {
+                        host: config_1.DB_HOST,
+                        port: config_1.DB_PORT,
+                        username: config_1.DB_USER,
+                        password: config_1.DB_PASSWORD,
+                        database: config_1.DB_NAME,
+                        dialect: config_1.DB_DIALECT,
+                        pool: { min: 2, max: config_1.DB_MAX_POOL_SIZE },
+                        models: [(0, path_1.resolve)(config_1.DB_ENTITIES_PATH)],
+                        define: { charset: 'utf8', underscored: false },
+                        synchronize: false,
+                        logging: false,
+                        dialectOptions: config_1.DB_SSL ? { ssl: { require: true, rejectUnauthorized: false } } : {},
+                    };
+                },
+            }),
+        ],
+        providers: [sequelize_1.SequelizeModule, db_service_1.DbService],
+        exports: [sequelize_1.SequelizeModule, db_service_1.DbService],
+    })
+], DBModule);

package/dist/drivers/db/db.service.d.ts

@@ -0,0 +1,10 @@
+import { OnModuleInit } from '@nestjs/common';
+import { Sequelize } from 'sequelize-typescript';
+export declare class DbService implements OnModuleInit {
+    private db;
+    private logger;
+    constructor(db: Sequelize);
+    onModuleInit(): Promise<void>;
+    authenticate(): Promise<void>;
+    checkConnection(): Promise<boolean>;
+}

package/dist/drivers/db/db.service.js

@@ -0,0 +1,49 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var DbService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbService = void 0;
+const common_1 = require("@nestjs/common");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const app_logger_1 = require("../../drivers/logger/app.logger");
+let DbService = DbService_1 = class DbService {
+    db;
+    logger = new app_logger_1.AppLogger(DbService_1.name);
+    constructor(db) {
+        this.db = db;
+    }
+    async onModuleInit() {
+        await this.authenticate();
+    }
+    async authenticate() {
+        await this.db
+            .authenticate({ retry: { max: 1 } })
+            .then(() => this.logger.log('Database connection has been established successfully.'))
+            .catch((err) => {
+            this.logger.error('Unable to connect to the database:', err);
+            throw err;
+        });
+    }
+    async checkConnection() {
+        return await this.db
+            .authenticate({ retry: { max: 1 } })
+            .then(() => true)
+            .catch((err) => {
+            this.logger.error('Database connection failed', err);
+            return false;
+        });
+    }
+};
+exports.DbService = DbService;
+exports.DbService = DbService = DbService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [sequelize_typescript_1.Sequelize])
+], DbService);

package/dist/drivers/db/index.d.ts

@@ -0,0 +1,5 @@
+export * from './db.helper';
+export * from './db.module';
+export * from './db.service';
+export * from './migration';
+export * from './repository';

package/dist/drivers/db/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./db.helper"), exports);
+__exportStar(require("./db.module"), exports);
+__exportStar(require("./db.service"), exports);
+__exportStar(require("./migration"), exports);
+__exportStar(require("./repository"), exports);

package/dist/drivers/db/migration.d.ts

@@ -0,0 +1,42 @@
+import { QueryInterface, QueryInterfaceIndexOptions, StringDataType } from 'sequelize';
+import { SequelizeOptions } from 'sequelize-typescript';
+type Index = {
+    queryInterface: QueryInterface;
+    tableName: string;
+    columns: string[];
+    options?: QueryInterfaceIndexOptions;
+};
+export declare const defaultCols: () => {
+    id: {
+        type: StringDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        defaultValue: () => string;
+    };
+    createdAt: {
+        type: import("sequelize").DateDataTypeConstructor;
+        defaultValue: import("sequelize/types/utils").Fn;
+    };
+    updatedAt: {
+        type: import("sequelize").DateDataTypeConstructor;
+        defaultValue: import("sequelize/types/utils").Fn;
+    };
+};
+export declare const relationCols: (...args: string[]) => {
+    id: {
+        type: import("sequelize").BigIntDataTypeConstructor;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+    };
+};
+export declare const addIndexes: (params: Index) => Promise<void>;
+export declare const deleteIndexes: (params: Index) => Promise<void>;
+export declare const addUniqueIndexes: (params: Index) => Promise<void>;
+export declare const deleteUniqueIndexes: (params: Index) => Promise<void>;
+export declare const migrationConfig: {
+    development: SequelizeOptions;
+    staging: SequelizeOptions;
+    test: {};
+    production: SequelizeOptions;
+};
+export {};

package/dist/drivers/db/migration.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrationConfig = exports.deleteUniqueIndexes = exports.addUniqueIndexes = exports.deleteIndexes = exports.addIndexes = exports.relationCols = exports.defaultCols = void 0;
+const helpers_1 = require("@triproject/helpers");
+const sequelize_1 = require("sequelize");
+const config_1 = require("../../config");
+const defaultCols = () => ({
+    id: { type: (0, sequelize_1.STRING)(32), primaryKey: true, autoIncrement: false, defaultValue: () => (0, helpers_1.generateId)() },
+    createdAt: { type: sequelize_1.DATE, defaultValue: (0, sequelize_1.fn)('now') },
+    updatedAt: { type: sequelize_1.DATE, defaultValue: (0, sequelize_1.fn)('now') },
+});
+exports.defaultCols = defaultCols;
+const relationCols = (...args) => ({
+    id: { type: sequelize_1.BIGINT, primaryKey: true, autoIncrement: true },
+    ...args.reduce((acc, curr) => {
+        acc[curr] = { type: (0, sequelize_1.STRING)(32), allowNull: false };
+        return acc;
+    }, {}),
+});
+exports.relationCols = relationCols;
+const index = (tableName, column) => {
+    return [tableName, (0, helpers_1.md5)(Array.isArray(column) ? column.sort().join('_') : column).substring(0, 8), 'idx'].join('_');
+};
+const addIndexes = async (params) => {
+    const { tableName, columns, options = {}, queryInterface } = params;
+    for (const col of columns) {
+        await queryInterface.addIndex(tableName, [col], { name: index(tableName, col), ...options });
+    }
+};
+exports.addIndexes = addIndexes;
+const deleteIndexes = async (params) => {
+    const { tableName, columns, queryInterface } = params;
+    for (const col of columns) {
+        await queryInterface.removeIndex(tableName, index(tableName, col));
+    }
+};
+exports.deleteIndexes = deleteIndexes;
+const addUniqueIndexes = async (params) => {
+    const { tableName, columns, options = {}, queryInterface } = params;
+    queryInterface.addIndex(tableName, columns, {
+        unique: true,
+        name: index(tableName, columns),
+        ...options,
+    });
+};
+exports.addUniqueIndexes = addUniqueIndexes;
+const deleteUniqueIndexes = async (params) => {
+    const { tableName, columns, queryInterface } = params;
+    await queryInterface.removeIndex(tableName, index(tableName, columns));
+};
+exports.deleteUniqueIndexes = deleteUniqueIndexes;
+const dialect = config_1.DB_DIALECT ?? 'postgres';
+const common = {
+    host: config_1.DB_HOST ?? '127.0.0.1',
+    port: +(config_1.DB_PORT ?? 5432),
+    username: config_1.DB_USER ?? 'postgres',
+    database: config_1.DB_NAME ?? 'app_db',
+    password: config_1.DB_PASSWORD ?? '',
+    dialect,
+    logging: false,
+    pool: {
+        max: config_1.DB_MAX_POOL_SIZE ?? 10,
+        min: config_1.DB_POOL_MIN ?? 0,
+        acquire: config_1.DB_POOL_ACQUIRE ?? 30000,
+        idle: config_1.DB_POOL_IDLE ?? 10000,
+    },
+    dialectOptions: config_1.DB_SSL
+        ? {
+            ssl: {
+                require: true,
+                rejectUnauthorized: true,
+            },
+        }
+        : {},
+};
+exports.migrationConfig = {
+    development: common,
+    staging: common,
+    test: {},
+    production: common,
+};

package/dist/drivers/db/repository.d.ts

@@ -0,0 +1,41 @@
+import { AggregateOptions, Attributes, BulkCreateOptions, CreateOptions, CreationAttributes, DestroyOptions, FindAndCountOptions, FindOptions, ModelStatic, UpdateOptions, UpsertOptions, WhereOptions } from 'sequelize';
+import { Model, Sequelize } from 'sequelize-typescript';
+import { AppLogger } from '../logger';
+import { PaginateRequest, PaginateResponse } from './db.helper';
+export declare class Repository<M extends Model<M, Partial<M>>> {
+    protected logger: AppLogger;
+    protected Model: ModelStatic<M>;
+    protected db: Sequelize;
+    private excludeParamsFromFilter;
+    private get attributes();
+    private get attributesTypes();
+    private getTrueKey;
+    private parsedBetweenData;
+    private mapFilter;
+    private _getOptions;
+    protected findForPublic<P extends {
+        label: string;
+        value: string | number;
+    }>(params: PaginateRequest<M>, mapInto: (data: M) => P): Promise<P[]>;
+    protected paginate<P>(params: PaginateRequest<M>, mapInto?: (data: M) => P): Promise<PaginateResponse<P | M>>;
+    protected export(params: PaginateRequest<M>): Promise<M[]>;
+    protected export(params: PaginateRequest<M>, mapInto?: (data: M) => string[]): Promise<string[][]>;
+    protected updateOrCreate(values: CreationAttributes<M>, whereOptions: WhereOptions<M>, options?: CreateOptions<M> | UpdateOptions<M>): Promise<M>;
+    protected findAll(options?: FindOptions<M>): Promise<M[]>;
+    protected findAndCountAll(options: FindAndCountOptions<M>): Promise<{
+        rows: M[];
+        count: number;
+    }>;
+    protected findOne(options: FindOptions<M>): Promise<M | null>;
+    protected create(values: CreationAttributes<M>, options?: CreateOptions<M>): Promise<M>;
+    protected update(entity: M | string, values: Partial<M>, options?: Partial<UpdateOptions<M>>): Promise<M>;
+    protected upsert(values: CreationAttributes<M>, options?: Partial<UpsertOptions<Attributes<M>>>): Promise<[M, boolean | null]>;
+    protected bulkUpdate(values: Partial<M>, options: UpdateOptions<M>): Promise<[number]>;
+    protected bulkCreate(values: ReadonlyArray<CreationAttributes<M>>, options?: BulkCreateOptions<M>): Promise<M[]>;
+    protected destroy(options: DestroyOptions<M>): Promise<number>;
+    protected sum(field: keyof Attributes<M>, options?: AggregateOptions<M>): Promise<number>;
+    protected sumField(params: PaginateRequest<M>, field: keyof Attributes<M>): Promise<number>;
+    protected sumCol(params: PaginateRequest<M>, fieldToSum: string, expectedField: string): Promise<number>;
+    protected count(options: FindOptions<M>): Promise<number>;
+    protected filteredFindAll(params: PaginateRequest<M>): Promise<M[]>;
+}