Add products and sales management modules with database schema and validation

- Introduced `ProductsModule` to manage product data, including read and write controllers.
- Created database migrations for the `products`, `sales_requests`, `sales_orders`, `sales_invoices`, and related tables, including constraints and unique indexes.
- Implemented validation for product fields such as code, name, unit, and brand with corresponding utility functions.
- Developed service and repository layers for handling product and sales data operations.
- Added unit tests for the products and sales services, repositories, and controllers to ensure functionality and correctness.
- Updated application module to include the new `ProductsModule` and related sales modules for better organization.
This commit is contained in:
shancheas
2026-08-25 09:54:16 +07:00
parent ddbe8a9ef8
commit 34d4f2c120
82 changed files with 12609 additions and 2 deletions
@@ -0,0 +1,421 @@
import {
ConflictException,
Inject,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { and, asc, count, eq, ilike, inArray, or, SQL } from 'drizzle-orm';
import { DateTime } from '../../../common/value-objects/date-time/date-time';
import { Decimal } from '../../../common/value-objects/decimal/decimal';
import { Status } from '../../../common/value-objects/status/status';
import { DRIZZLE, type DrizzleDB } from '../../../database/database.module';
import {
salesRequestImages,
salesRequestProducts,
salesRequests,
type SalesRequestImageRow,
type SalesRequestProductRow,
type SalesRequestRow,
} from '../../../database/sales-requests-table';
import { DocumentCodeService } from '../shared/document-code.service';
import { DOCUMENT_PREFIXES } from '../shared/document-prefixes';
import { SALES_REQUEST_STATUSES } from '../shared/sales-fields';
import type {
CreateSalesRequestInput,
ListSalesRequestsFilters,
SalesRequest,
SalesRequestImageInput,
SalesRequestLineInput,
UpdateSalesRequestInput,
} from './sales-request';
type QueryExecutor = Pick<DrizzleDB, 'select' | 'insert' | 'delete'>;
@Injectable()
export class SalesRequestsRepository {
constructor(
@Inject(DRIZZLE) private readonly db: DrizzleDB,
private readonly documentCodeService: DocumentCodeService,
) {}
async list(
filters: ListSalesRequestsFilters,
): Promise<{ data: SalesRequest[]; total: number }> {
const where = this.buildListWhere(filters);
const totalRows = await this.db
.select({ total: count() })
.from(salesRequests)
.where(where);
const rows = await this.db
.select()
.from(salesRequests)
.where(where)
.orderBy(asc(salesRequests.code))
.limit(filters.limit)
.offset(filters.offset);
return {
data: rows.map((row) => this.toDomain(row, [], [])),
total: Number(totalRows[0]?.total ?? 0),
};
}
async findById(id: string): Promise<SalesRequest | null> {
const rows: SalesRequestRow[] = await this.db
.select()
.from(salesRequests)
.where(eq(salesRequests.id, id))
.limit(1);
const row = rows[0];
if (!row) {
return null;
}
const products = await this.selectProducts(this.db, id);
const images = await this.selectImages(this.db, id);
return this.toDomain(row, products, images);
}
async create(input: CreateSalesRequestInput): Promise<SalesRequest> {
const now = DateTime.fromUnixMs(Date.now());
const status =
input.status ?? Status.create('draft', SALES_REQUEST_STATUSES);
try {
return await this.db.transaction(async (tx) => {
const code =
input.code ??
(await this.documentCodeService.nextCode(
DOCUMENT_PREFIXES.salesRequest,
input.date,
tx,
));
const inserted = await tx
.insert(salesRequests)
.values(this.toInsertValues(input, code, status, now, input.userId))
.returning();
const row = inserted[0];
await this.replaceProducts(tx, row.id, input.products);
await this.replaceImages(tx, row.id, input.images ?? []);
const products = await this.selectProducts(tx, row.id);
const images = await this.selectImages(tx, row.id);
return this.toDomain(row, products, images);
});
} catch (error) {
this.rethrowConstraintViolation(error);
}
}
async createMany(inputs: CreateSalesRequestInput[]): Promise<number> {
if (inputs.length === 0) {
return 0;
}
for (const input of inputs) {
await this.create(input);
}
return inputs.length;
}
async update(
id: string,
input: UpdateSalesRequestInput,
): Promise<SalesRequest> {
const existing = await this.findById(id);
if (!existing) {
throw new NotFoundException('Sales request not found');
}
const now = DateTime.fromUnixMs(Date.now());
try {
return await this.db.transaction(async (tx) => {
const updated = await tx
.update(salesRequests)
.set({
code: input.code ?? existing.code,
date: input.date?.value ?? existing.date.value,
salesPersonId: input.salesPersonId ?? existing.salesPersonId,
branchId: input.branchId ?? existing.branchId,
divisionId: input.divisionId ?? existing.divisionId,
customerId: input.customerId ?? existing.customerId,
address: input.address ?? existing.address,
latitude:
input.latitude !== undefined ? input.latitude : existing.latitude,
longitude:
input.longitude !== undefined
? input.longitude
: existing.longitude,
notes: input.notes !== undefined ? input.notes : existing.notes,
updatedAt: now.value,
updatedBy: input.userId,
})
.where(eq(salesRequests.id, id))
.returning();
const row = updated[0];
if (!row) {
throw new NotFoundException('Sales request not found');
}
if (input.products !== undefined) {
await this.replaceProducts(tx, id, input.products);
}
if (input.images !== undefined) {
await this.replaceImages(tx, id, input.images);
}
const products = await this.selectProducts(tx, id);
const images = await this.selectImages(tx, id);
return this.toDomain(row, products, images);
});
} catch (error) {
this.rethrowConstraintViolation(error);
}
}
async updateStatus(
id: string,
status: Status,
userId: string,
): Promise<SalesRequest> {
const now = DateTime.fromUnixMs(Date.now());
const updated = await this.db
.update(salesRequests)
.set({
status: status.value,
updatedAt: now.value,
updatedBy: userId,
})
.where(eq(salesRequests.id, id))
.returning();
const row = updated[0];
if (!row) {
throw new NotFoundException('Sales request not found');
}
const products = await this.selectProducts(this.db, id);
const images = await this.selectImages(this.db, id);
return this.toDomain(row, products, images);
}
async bulkUpdateStatus(
ids: string[],
status: Status,
userId: string,
): Promise<number> {
if (ids.length === 0) {
return 0;
}
const now = DateTime.fromUnixMs(Date.now());
const rows = await this.db
.update(salesRequests)
.set({
status: status.value,
updatedAt: now.value,
updatedBy: userId,
})
.where(inArray(salesRequests.id, ids))
.returning({ id: salesRequests.id });
return rows.length;
}
async delete(id: string): Promise<void> {
const deleted = await this.db
.delete(salesRequests)
.where(eq(salesRequests.id, id))
.returning({ id: salesRequests.id });
if (deleted.length === 0) {
throw new NotFoundException('Sales request not found');
}
}
async bulkDelete(ids: string[]): Promise<number> {
if (ids.length === 0) {
return 0;
}
const deleted = await this.db
.delete(salesRequests)
.where(inArray(salesRequests.id, ids))
.returning({ id: salesRequests.id });
return deleted.length;
}
private async selectProducts(
executor: QueryExecutor,
salesRequestId: string,
): Promise<SalesRequestProductRow[]> {
return executor
.select()
.from(salesRequestProducts)
.where(eq(salesRequestProducts.salesRequestId, salesRequestId));
}
private async selectImages(
executor: QueryExecutor,
salesRequestId: string,
): Promise<SalesRequestImageRow[]> {
return executor
.select()
.from(salesRequestImages)
.where(eq(salesRequestImages.salesRequestId, salesRequestId));
}
private async replaceProducts(
executor: QueryExecutor,
salesRequestId: string,
products: readonly SalesRequestLineInput[],
): Promise<void> {
await executor
.delete(salesRequestProducts)
.where(eq(salesRequestProducts.salesRequestId, salesRequestId));
if (products.length === 0) {
return;
}
await executor.insert(salesRequestProducts).values(
products.map((line) => ({
salesRequestId,
productId: line.productId,
quantity: line.quantity.value,
price: line.price.value,
})),
);
}
private async replaceImages(
executor: QueryExecutor,
salesRequestId: string,
images: readonly SalesRequestImageInput[],
): Promise<void> {
await executor
.delete(salesRequestImages)
.where(eq(salesRequestImages.salesRequestId, salesRequestId));
if (images.length === 0) {
return;
}
await executor.insert(salesRequestImages).values(
images.map((image) => ({
salesRequestId,
url: image.url,
description: image.description ?? null,
})),
);
}
private buildListWhere(filters: ListSalesRequestsFilters): SQL | undefined {
const parts: SQL[] = [];
if (filters.code) {
parts.push(ilike(salesRequests.code, `%${filters.code}%`));
}
if (filters.status) {
parts.push(eq(salesRequests.status, filters.status));
}
if (filters.customerId) {
parts.push(eq(salesRequests.customerId, filters.customerId));
}
if (filters.salesPersonId) {
parts.push(eq(salesRequests.salesPersonId, filters.salesPersonId));
}
if (filters.branchId) {
parts.push(eq(salesRequests.branchId, filters.branchId));
}
if (filters.divisionId) {
parts.push(eq(salesRequests.divisionId, filters.divisionId));
}
if (filters.search) {
const search = or(
ilike(salesRequests.code, `%${filters.search}%`),
ilike(salesRequests.address, `%${filters.search}%`),
ilike(salesRequests.notes, `%${filters.search}%`),
);
if (search) {
parts.push(search);
}
}
if (parts.length === 0) {
return undefined;
}
return parts.length === 1 ? parts[0] : and(...parts);
}
private toInsertValues(
input: CreateSalesRequestInput,
code: string,
status: Status,
now: DateTime,
userId: string,
) {
return {
code,
date: input.date.value,
salesPersonId: input.salesPersonId,
branchId: input.branchId,
divisionId: input.divisionId,
customerId: input.customerId,
address: input.address,
latitude: input.latitude ?? null,
longitude: input.longitude ?? null,
notes: input.notes ?? null,
status: status.value,
createdAt: now.value,
updatedAt: now.value,
createdBy: userId,
updatedBy: userId,
};
}
private toDomain(
row: SalesRequestRow,
productRows: SalesRequestProductRow[],
imageRows: SalesRequestImageRow[],
): SalesRequest {
return {
id: row.id,
code: row.code,
date: DateTime.fromUnixMs(row.date),
salesPersonId: row.salesPersonId,
branchId: row.branchId,
divisionId: row.divisionId,
customerId: row.customerId,
address: row.address,
latitude: row.latitude,
longitude: row.longitude,
notes: row.notes,
products: productRows.map((line) => ({
id: line.id,
productId: line.productId,
quantity: Decimal.create(line.quantity),
price: Decimal.create(line.price),
})),
images: imageRows.map((image) => ({
id: image.id,
url: image.url,
description: image.description,
})),
status: Status.create(row.status, SALES_REQUEST_STATUSES),
createdAt: DateTime.fromUnixMs(row.createdAt),
updatedAt: DateTime.fromUnixMs(row.updatedAt),
createdBy: row.createdBy,
updatedBy: row.updatedBy,
};
}
private rethrowConstraintViolation(error: unknown): never {
if (error instanceof NotFoundException) {
throw error;
}
const err = this.unwrapDbError(error);
if (err.code === '23505') {
throw new ConflictException('Sales request code already exists');
}
if (err.code === '23503') {
throw new ConflictException('Related record was not found');
}
throw error;
}
private unwrapDbError(error: unknown): { code?: string } {
let current: unknown = error;
for (let i = 0; i < 5; i++) {
if (!current || typeof current !== 'object') {
break;
}
const obj = current as { code?: string; cause?: unknown };
if (obj.code === '23505' || obj.code === '23503') {
return { code: obj.code };
}
current = obj.cause;
}
return error as { code?: string };
}
}