@comasoft/nestjs 0.0.97 → 0.1.2

package/dist/category/category.service.d.ts

@@ -0,0 +1,13 @@
+import { Repository } from 'typeorm';
+import { Category } from '../database/entities';
+import { CreateCategoryBaseDto, ResponseCategoriesBaseDto, ResponseCategoryBaseDto, UpdateCategoryBaseDto, UpdateCategorySortBaseDto } from './dto';
+export declare class CategoryService {
+    private readonly repository;
+    constructor(repository: Repository<Category>);
+    create(body: CreateCategoryBaseDto): Promise<ResponseCategoryBaseDto<string>>;
+    findAll(type: string): Promise<ResponseCategoriesBaseDto<string>>;
+    findOne(id: number): Promise<ResponseCategoryBaseDto<string>>;
+    update(id: number, body: UpdateCategoryBaseDto): Promise<ResponseCategoryBaseDto<string>>;
+    remove(id: number): Promise<void>;
+    updateSort(body: UpdateCategorySortBaseDto): Promise<void>;
+}

package/dist/category/category.service.js

@@ -0,0 +1,124 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const class_transformer_1 = require("class-transformer");
+const typeorm_2 = require("typeorm");
+const entities_1 = require("../database/entities");
+const error_codes_1 = require("../shared/error-codes");
+const dto_1 = require("./dto");
+let CategoryService = class CategoryService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    create(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { type, name, description, slug } = body;
+            const existCategory = yield this.repository.findOne({
+                where: { type, name },
+            });
+            if (existCategory) {
+                throw new common_1.ConflictException({
+                    message: 'Category name already exists',
+                    error_code: error_codes_1.ErrorCode.CATEGORY_NAME_ALREADY_EXISTS,
+                });
+            }
+            const next_sort = (yield this.repository.count({ where: { type } })) + 1;
+            const category = yield this.repository.save(Object.assign(Object.assign({}, body), { sort: next_sort }));
+            return (0, class_transformer_1.plainToClass)(dto_1.ResponseCategoryBaseDto, category);
+        });
+    }
+    findAll(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.repository.find({
+                where: { type },
+                order: { sort: 'ASC' },
+            });
+            return (0, class_transformer_1.plainToClass)(dto_1.ResponseCategoriesBaseDto, { items: res });
+        });
+    }
+    findOne(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.repository.findOne({ where: { id } });
+            if (!res)
+                throw new common_1.NotFoundException(`Category with ID ${id} not found`);
+            return (0, class_transformer_1.plainToClass)(dto_1.ResponseCategoryBaseDto, res);
+        });
+    }
+    update(id, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const category = yield this.repository.findOne({ where: { id } });
+            if (!category)
+                throw new common_1.NotFoundException(`Category with ID ${id} not found`);
+            const existCategory = yield this.repository.findOne({
+                where: { type: category.type, name: body.name, id: (0, typeorm_2.Not)(id) },
+            });
+            if (existCategory) {
+                throw new common_1.ConflictException({
+                    message: 'Category name already exists',
+                    error_code: error_codes_1.ErrorCode.CATEGORY_NAME_ALREADY_EXISTS,
+                });
+            }
+            yield this.repository.update(id, body);
+            const res = yield this.repository.findOne({ where: { id } });
+            return (0, class_transformer_1.plainToClass)(dto_1.ResponseCategoryBaseDto, res);
+        });
+    }
+    remove(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const category = yield this.repository.findOne({ where: { id } });
+            if (!category)
+                throw new common_1.NotFoundException(`Category with ID ${id} not found`);
+            yield this.repository.update(id, {
+                is_active: false,
+                deleted_at: new Date(),
+            });
+            return;
+        });
+    }
+    updateSort(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { items: _items, type } = body;
+            const items = yield this.repository.find({
+                where: { type },
+            });
+            if (items.length !== _items.length) {
+                throw new common_1.BadRequestException('Invalid items ids provided');
+            }
+            const updateItems = items.map((item) => {
+                var _a;
+                return Object.assign(Object.assign({}, item), { sort: ((_a = _items.find((i) => i.id === item.id)) === null || _a === void 0 ? void 0 : _a.sort) || item.sort });
+            });
+            yield this.repository.save(updateItems);
+            return;
+        });
+    }
+};
+exports.CategoryService = CategoryService;
+exports.CategoryService = CategoryService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.Category)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], CategoryService);

package/dist/category/dto/create-category.dto.d.ts

@@ -0,0 +1,7 @@
+export declare class CreateCategoryBaseDto<T = string> {
+    type: T;
+    name: string;
+    description?: string;
+    slug?: string;
+    is_active: boolean;
+}

package/dist/category/dto/create-category.dto.js

@@ -0,0 +1,34 @@
+"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.CreateCategoryBaseDto = void 0;
+const class_validator_1 = require("class-validator");
+class CreateCategoryBaseDto {
+}
+exports.CreateCategoryBaseDto = CreateCategoryBaseDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateCategoryBaseDto.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], CreateCategoryBaseDto.prototype, "description", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], CreateCategoryBaseDto.prototype, "slug", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], CreateCategoryBaseDto.prototype, "is_active", void 0);

package/dist/category/dto/delete-category.dto.d.ts

@@ -0,0 +1,3 @@
+export declare class DeleteCategoryBaseDto<T = string> {
+    type: T;
+}

package/dist/category/dto/delete-category.dto.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteCategoryBaseDto = void 0;
+class DeleteCategoryBaseDto {
+}
+exports.DeleteCategoryBaseDto = DeleteCategoryBaseDto;

package/dist/category/dto/index.d.ts

@@ -0,0 +1,5 @@
+export * from './create-category.dto';
+export * from './delete-category.dto';
+export * from './response-categories.dto';
+export * from './update-category-sort.dto';
+export * from './update-category.dto';

package/dist/category/dto/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("./create-category.dto"), exports);
+__exportStar(require("./delete-category.dto"), exports);
+__exportStar(require("./response-categories.dto"), exports);
+__exportStar(require("./update-category-sort.dto"), exports);
+__exportStar(require("./update-category.dto"), exports);

package/dist/category/dto/response-categories.dto.d.ts

@@ -0,0 +1,12 @@
+export declare class ResponseCategoryBaseDto<T = string> {
+    id: number;
+    type: T;
+    name: string;
+    description?: string;
+    slug?: string;
+    sort: number;
+    is_active: boolean;
+}
+export declare class ResponseCategoriesBaseDto<T = string> {
+    items: ResponseCategoryBaseDto<T>[];
+}

package/dist/category/dto/response-categories.dto.js

@@ -0,0 +1,52 @@
+"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.ResponseCategoriesBaseDto = exports.ResponseCategoryBaseDto = void 0;
+const class_transformer_1 = require("class-transformer");
+class ResponseCategoryBaseDto {
+}
+exports.ResponseCategoryBaseDto = ResponseCategoryBaseDto;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], ResponseCategoryBaseDto.prototype, "id", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Object)
+], ResponseCategoryBaseDto.prototype, "type", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], ResponseCategoryBaseDto.prototype, "name", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], ResponseCategoryBaseDto.prototype, "description", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], ResponseCategoryBaseDto.prototype, "slug", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Number)
+], ResponseCategoryBaseDto.prototype, "sort", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", Boolean)
+], ResponseCategoryBaseDto.prototype, "is_active", void 0);
+class ResponseCategoriesBaseDto {
+}
+exports.ResponseCategoriesBaseDto = ResponseCategoriesBaseDto;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_transformer_1.Type)(() => ResponseCategoryBaseDto),
+    __metadata("design:type", Array)
+], ResponseCategoriesBaseDto.prototype, "items", void 0);

package/dist/category/dto/update-category-sort.dto.d.ts

@@ -0,0 +1,9 @@
+declare class SortDto {
+    id: number;
+    sort: number;
+}
+export declare class UpdateCategorySortBaseDto<T = string> {
+    type: T;
+    items: SortDto[];
+}
+export {};

package/dist/category/dto/update-category-sort.dto.js

@@ -0,0 +1,33 @@
+"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.UpdateCategorySortBaseDto = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+class SortDto {
+}
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], SortDto.prototype, "id", void 0);
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], SortDto.prototype, "sort", void 0);
+class UpdateCategorySortBaseDto {
+}
+exports.UpdateCategorySortBaseDto = UpdateCategorySortBaseDto;
+__decorate([
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => SortDto),
+    __metadata("design:type", Array)
+], UpdateCategorySortBaseDto.prototype, "items", void 0);

package/dist/category/dto/update-category.dto.d.ts

@@ -0,0 +1,6 @@
+import { CreateCategoryBaseDto } from './create-category.dto';
+declare const UpdateCategoryBaseDto_base: import("@nestjs/common").Type<Partial<Omit<CreateCategoryBaseDto<unknown>, "type">>>;
+export declare class UpdateCategoryBaseDto extends UpdateCategoryBaseDto_base {
+    static readonly keys: string[];
+}
+export {};

package/dist/category/dto/update-category.dto.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCategoryBaseDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const create_category_dto_1 = require("./create-category.dto");
+class UpdateCategoryBaseDto extends (0, swagger_1.PartialType)((0, swagger_1.OmitType)(create_category_dto_1.CreateCategoryBaseDto, ['type'])) {
+}
+exports.UpdateCategoryBaseDto = UpdateCategoryBaseDto;
+UpdateCategoryBaseDto.keys = ['name', 'description', 'slug', 'is_active'];

package/dist/category/index.d.ts

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

package/dist/category/index.js

@@ -0,0 +1,19 @@
+"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("./category.module"), exports);
+__exportStar(require("./category.service"), exports);
+__exportStar(require("./dto"), exports);

package/dist/comment/comment.module.d.ts

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

package/dist/comment/comment.module.js

@@ -0,0 +1,23 @@
+"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.CommentModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const entities_1 = require("../database/entities");
+const comment_service_1 = require("./comment.service");
+let CommentModule = class CommentModule {
+};
+exports.CommentModule = CommentModule;
+exports.CommentModule = CommentModule = __decorate([
+    (0, common_1.Module)({
+        imports: [typeorm_1.TypeOrmModule.forFeature([entities_1.Comment])],
+        providers: [comment_service_1.CommentService],
+        exports: [comment_service_1.CommentService],
+    })
+], CommentModule);

package/dist/comment/comment.service.d.ts

@@ -0,0 +1,33 @@
+import { DataSource, EntityManager, Repository, SelectQueryBuilder } from 'typeorm';
+import { Comment } from '../database/entities';
+import { CustomParamsDto } from '../dto';
+import { CreateCommentBaseDto, ResponseCommentBaseDto, ResponseCommentsBaseDto, UpdateCommentBaseDto } from './dto';
+export declare class CommentService<T = any> {
+    protected readonly repository: Repository<Comment>;
+    protected readonly dataSource: DataSource;
+    constructor(repository: Repository<Comment>, dataSource: DataSource);
+    protected resolveTargetId(target: T, target_id?: number, target_uid?: string): Promise<number>;
+    protected updateTargetCommentCount(manager: EntityManager, target: T, target_id: number, increment: number): Promise<void>;
+    protected calculateTreeStructure(target: T, target_id: number, parent_id?: number): Promise<{
+        group_id: number;
+        depth: number;
+        sort: any;
+    }>;
+    create(user_id: number, _body: CreateCommentBaseDto<T>): Promise<ResponseCommentBaseDto<any>>;
+    paginateRaw<T>(queryBuilder: SelectQueryBuilder<T>, options: {
+        page: number;
+        limit: number;
+    }, mapFn: (raw: any) => T): Promise<{
+        items: T[];
+        pagination: {
+            page: number;
+            limit: number;
+            count: number;
+            count_total: number;
+            count_page: number;
+        };
+    }>;
+    findAll(c_params: CustomParamsDto, target?: T, target_id?: number, target_uid?: string): Promise<ResponseCommentsBaseDto<any>>;
+    update(user_id: number, id: number, body: UpdateCommentBaseDto): Promise<void>;
+    remove(user_id: number, id: number): Promise<void>;
+}