th-169: Drivers table (#228)

* th-169: * driver flow added user to response

* th-169: * driver types

* th-169: * driver service added findPageOfDrivers

* th-169: * driver service added total and createdAt

* th-169: * driver types

* th-169: + driver table

* th-169: + driver table flow

* th-169: * driver entity

* th-169: * driver api types

* th-169: * drivers acrions added notification service

* th-169: * drivers routes and types

* th-169: * imports fixed props

* th-169: * driver actions fixed rejectWithValue

* th-169: * swagger documentation

* th-169: * driver slice

* th-169: * drivers slice renamed

* th-169: * driver table added queries and enmpty data message

* th-169: * table fixed message with loading

* th-169: * table added styles

* th-169: * driver table changed styles

* th-169: * driver service changed types

* th-169: * empty table message

* th-169: * driver actions refactored addDriver

* th-169: * useAppTable

* th-169: * table message

Author: AlexVlaso

.eslintrc.yml

@@ -124,6 +124,9 @@ rules:
   '@typescript-eslint/semi':
     - error
     - always
+  '@typescript-eslint/no-unused-vars':
+    - error
+    - ignoreRestSiblings: true
 
 overrides:
   - files:

backend/src/packages/business/business.controller.ts

@@ -25,13 +25,15 @@ import {
   type BusinessGetRequestParameters,
   type BusinessUpdateRequestDto,
   type BusinessUpdateRequestParameters,
+  type GetPaginatedPageQuery,
 } from './libs/types/types.js';
 import {
   businessAddRequestBody,
   businessDeleteParameters,
   businessGetParameters,
   businessUpdateParameters,
   businessUpdateRequestBody,
+  commonGetPageQuery,
 } from './libs/validation-schemas/validation-schemas.js';
 
 /**
@@ -354,9 +356,13 @@ class BusinessController extends Controller {
       path: BusinessApiPath.DRIVERS,
       method: 'GET',
       authStrategy: defaultStrategies,
+      validation: {
+        query: commonGetPageQuery,
+      },
       handler: (options) =>
         this.findAllDrivers(
           options as ApiHandlerOptions<{
+            query: GetPaginatedPageQuery;
             user: UserEntityObjectWithGroupT;
           }>,
         ),
@@ -744,18 +750,27 @@ class BusinessController extends Controller {
    *          content:
    *            application/json:
    *              schema:
-   *                type: array
-   *                items:
-   *                  $ref: '#/components/schemas/Driver'
+   *                type: object
+   *                properties:
+   *                    items:
+   *                      type: array
+   *                      items:
+   *                        $ref: '#/components/schemas/Driver'
+   *                    total:
+   *                      type: string
+   *                      example: 1
+   *
    */
 
   private async findAllDrivers(
     options: ApiHandlerOptions<{
+      query: GetPaginatedPageQuery;
       user: UserEntityObjectWithGroupT;
     }>,
   ): Promise<ApiHandlerResponse> {
     const drivers = await this.businessService.findAllDriversByBusinessId(
       options.user.id,
+      options.query,
     );
 
     return {

backend/src/packages/business/business.service.ts

@@ -19,6 +19,7 @@ import {
   type BusinessCreatePayload,
   type BusinessEntityT,
   type BusinessUpdateResponseDto,
+  type GetPaginatedPageQuery,
 } from './libs/types/types.js';
 
 class BusinessService implements IService {
@@ -170,6 +171,7 @@ class BusinessService implements IService {
 
   public async findAllDriversByBusinessId(
     ownerId: number,
+    query: GetPaginatedPageQuery,
   ): Promise<DriverGetAllResponseDto> {
     const business = await this.findByOwnerId(ownerId);
 
@@ -180,7 +182,10 @@ class BusinessService implements IService {
       });
     }
 
-    return await this.driverService.findAllByBusinessId(business.id);
+    return await this.driverService.findAllByBusinessId({
+      businessId: business.id,
+      query,
+    });
   }
 
   public async deleteDriver(

backend/src/packages/business/libs/types/types.ts

@@ -8,4 +8,5 @@ export {
   type BusinessUpdateRequestDto,
   type BusinessUpdateRequestParameters,
   type BusinessUpdateResponseDto,
+  type GetPaginatedPageQuery,
 } from 'shared/build/index.js';

backend/src/packages/business/libs/validation-schemas/validation-schemas.ts

@@ -4,4 +4,5 @@ export {
   businessGetParameters,
   businessUpdateParameters,
   businessUpdateRequestBody,
+  commonGetPageQuery,
 } from 'shared/build/index.js';

backend/src/packages/drivers/driver.entity.ts

@@ -1,6 +1,7 @@
 import { type IEntity } from '~/libs/interfaces/entity.interface.js';
 import { type NullableProperties } from '~/libs/types/types.js';
 
+import { type UserEntityT } from '../users/users.js';
 import { type DriverEntity as DriverEntityT } from './libs/types/types.js';
 
 class DriverEntity implements IEntity {
@@ -12,42 +13,57 @@ class DriverEntity implements IEntity {
 
   private businessId: DriverEntityT['businessId'];
 
+  private createdAt: DriverEntityT['createdAt'] | null;
+
+  private user?: UserEntityT;
+
   private constructor({
     id,
     driverLicenseNumber,
     userId,
     businessId,
-  }: NullableProperties<DriverEntityT, 'id'>) {
+    createdAt,
+    user,
+  }: NullableProperties<DriverEntityT, 'id' | 'createdAt'> & {
+    user?: UserEntityT;
+  }) {
     this.id = id;
     this.driverLicenseNumber = driverLicenseNumber;
     this.userId = userId;
     this.businessId = businessId;
+    this.createdAt = createdAt;
+    this.user = user;
   }
 
   public static initialize({
     id,
     driverLicenseNumber,
     userId,
     businessId,
-  }: DriverEntityT): DriverEntity {
+    createdAt,
+    user,
+  }: DriverEntityT & { user?: UserEntityT }): DriverEntity {
     return new DriverEntity({
       id,
       driverLicenseNumber,
       userId,
       businessId,
+      createdAt,
+      user,
     });
   }
 
   public static initializeNew({
     driverLicenseNumber,
     userId,
     businessId,
-  }: Omit<DriverEntityT, 'id'>): DriverEntity {
+  }: Omit<DriverEntityT, 'id' | 'createdAt'>): DriverEntity {
     return new DriverEntity({
       id: null,
       driverLicenseNumber,
       userId,
       businessId,
+      createdAt: null,
     });
   }
 
@@ -57,6 +73,7 @@ class DriverEntity implements IEntity {
       driverLicenseNumber: this.driverLicenseNumber,
       userId: this.userId,
       businessId: this.businessId,
+      createdAt: this.createdAt as string,
     };
   }
 
@@ -65,6 +82,18 @@ class DriverEntity implements IEntity {
       driverLicenseNumber: this.driverLicenseNumber,
       userId: this.userId,
       businessId: this.businessId,
+      createdAt: this.createdAt as string,
+    };
+  }
+
+  public toObjectWithUser(): DriverEntityT & { user: UserEntityT } {
+    return {
+      id: this.id as number,
+      driverLicenseNumber: this.driverLicenseNumber,
+      userId: this.userId,
+      businessId: this.businessId,
+      createdAt: this.createdAt as string,
+      user: this.user as UserEntityT,
     };
   }
 }

backend/src/packages/drivers/driver.repository.ts

@@ -1,4 +1,4 @@
-import { type SQL, and, eq, or } from 'drizzle-orm';
+import { type SQL, and, desc, eq, or, sql } from 'drizzle-orm';
 
 import { AppErrorMessage } from '~/libs/enums/enums.js';
 import { ApplicationError } from '~/libs/exceptions/exceptions.js';
@@ -9,6 +9,8 @@ import { type OperationResult } from '~/libs/types/types.js';
 
 import { DriverEntity } from './driver.entity.js';
 import { type DriverEntity as DriverEntityT } from './drivers.js';
+import { countOffsetByQuery } from './libs/helpers/helpers.js';
+import { type GetPaginatedPageQuery } from './libs/types/types.js';
 
 class DriverRepository implements IRepository {
   private db: Pick<IDatabase, 'driver'>;
@@ -24,8 +26,8 @@ class DriverRepository implements IRepository {
     this.driverSchema = driverSchema;
   }
 
-  public find(
-    partial: Partial<DriverEntityT>,
+  public async find(
+    partial: Partial<Omit<DriverEntityT, 'user'>>,
   ): ReturnType<IRepository<DriverEntityT>['find']> {
     const queries = Object.entries(partial).map(([key, value]) =>
       eq(
@@ -36,22 +38,41 @@ class DriverRepository implements IRepository {
 
     const finalQuery = queries.length === 1 ? queries[0] : and(...queries);
 
-    return this.db
+    const drivers = await this.db
       .driver()
-      .query.drivers.findMany({ where: finalQuery })
+      .query.drivers.findMany({ where: finalQuery, with: { user: true } })
       .execute();
+
+    return drivers.map(({ createdAt, updatedAt, ...pureDriver }) =>
+      DriverEntity.initialize({
+        ...pureDriver,
+        createdAt: createdAt.toISOString(),
+      }).toObject(),
+    );
   }
 
   public async findAllByBusinessId(
     businessId: number,
+    query: GetPaginatedPageQuery,
   ): Promise<DriverEntity[]> {
+    const offset = countOffsetByQuery(query);
     const drivers = await this.db
       .driver()
-      .select()
-      .from(this.driverSchema)
-      .where(eq(this.driverSchema.businessId, businessId));
+      .query.drivers.findMany({
+        limit: query.size,
+        offset,
+        where: eq(this.driverSchema.businessId, businessId),
+        with: { user: true },
+        orderBy: [desc(this.driverSchema.createdAt)],
+      })
+      .execute();
 
-    return drivers.map((it) => DriverEntity.initialize(it));
+    return drivers.map(({ createdAt, ...pureDriver }) =>
+      DriverEntity.initialize({
+        ...pureDriver,
+        createdAt: createdAt.toISOString(),
+      }),
+    );
   }
 
   public async checkExists({
@@ -76,7 +97,7 @@ class DriverRepository implements IRepository {
       });
     }
 
-    const [driver]: DriverEntityT[] = await this.db
+    const [driver] = await this.db
       .driver()
       .select()
       .from(this.driverSchema)
@@ -90,14 +111,17 @@ class DriverRepository implements IRepository {
   public async create(entity: DriverEntity): Promise<DriverEntity> {
     const { driverLicenseNumber, userId, businessId } = entity.toNewObject();
 
-    const [item] = await this.db
+    const [{ createdAt, ...pureDriver }] = await this.db
       .driver()
       .insert(this.driverSchema)
       .values({ driverLicenseNumber, userId, businessId })
       .returning()
       .execute();
 
-    return DriverEntity.initialize(item);
+    return DriverEntity.initialize({
+      ...pureDriver,
+      createdAt: createdAt.toISOString(),
+    });
   }
 
   public async update({
@@ -107,15 +131,18 @@ class DriverRepository implements IRepository {
     id: number;
     payload: Partial<Pick<DriverEntityT, 'driverLicenseNumber'>>;
   }): Promise<DriverEntity> {
-    const [item] = await this.db
+    const [{ createdAt, ...pureDriver }] = await this.db
       .driver()
       .update(this.driverSchema)
       .set(payload)
       .where(eq(this.driverSchema.id, id))
       .returning()
       .execute();
 
-    return DriverEntity.initialize(item);
+    return DriverEntity.initialize({
+      ...pureDriver,
+      createdAt: createdAt.toISOString(),
+    });
   }
 
   public async delete(id: number): Promise<boolean> {
@@ -128,6 +155,16 @@ class DriverRepository implements IRepository {
 
     return Boolean(item);
   }
+
+  public async getTotal(id: number): Promise<number> {
+    const [driver] = await this.db
+      .driver()
+      .select({ count: sql<number>`count(*)` })
+      .from(this.driverSchema)
+      .where(eq(this.driverSchema.businessId, id));
+
+    return driver.count;
+  }
 }
 
 export { DriverRepository };

backend/src/packages/drivers/driver.service.ts

@@ -9,15 +9,17 @@ import { UserGroupKey } from '../auth/libs/enums/enums.js';
 import { DriverEntity } from '../drivers/driver.entity.js';
 import { type DriverRepository } from '../drivers/driver.repository.js';
 import {
-  type DriverAddPayload,
+  type DriverAddPayloadWithBusinessId,
   type DriverAddResponseWithGroup,
   type DriverCreateUpdateResponseDto,
   type DriverEntity as DriverEntityT,
   type DriverGetAllResponseDto,
+  type DriverGetDriversPayloadWithBusinessId,
   type DriverUpdatePayload,
 } from '../drivers/libs/types/types.js';
 import { type GroupService } from '../groups/group.service.js';
 import { type UserService } from '../users/user.service.js';
+import { convertToDriverUser } from './libs/helpers/helpers.js';
 
 class DriverService implements IService {
   private driverRepository: DriverRepository;
@@ -79,20 +81,26 @@ class DriverService implements IService {
     return driver ? DriverEntity.initialize(driver).toObject() : null;
   }
 
-  public async findAllByBusinessId(
-    businessId: number,
-  ): Promise<DriverGetAllResponseDto> {
-    const items = await this.driverRepository.findAllByBusinessId(businessId);
+  public async findAllByBusinessId({
+    businessId,
+    query,
+  }: DriverGetDriversPayloadWithBusinessId): Promise<DriverGetAllResponseDto> {
+    const items = await this.driverRepository.findAllByBusinessId(
+      businessId,
+      query,
+    );
+    const total = await this.driverRepository.getTotal(businessId);
 
     return {
-      items: items.map((it) => it.toObject()),
+      items: items.map((item) => convertToDriverUser(item)),
+      total,
     };
   }
 
   public async create({
     payload,
     businessId,
-  }: DriverAddPayload): Promise<DriverAddResponseWithGroup> {
+  }: DriverAddPayloadWithBusinessId): Promise<DriverAddResponseWithGroup> {
     const { password, email, lastName, firstName, phone, driverLicenseNumber } =
       payload;