@fiado/type-kit 1.0.4 → 1.0.5

package/src/account/dtos/AccountResponse.ts

@@ -0,0 +1,60 @@
+
+
+import { IsEnum, IsNumber, IsOptional, IsString, IsDateString } from 'class-validator';
+import { Provider } from '../../provider/enums/Provider';
+import { Country } from '../../country/enums/Country';
+import { AccountStatus } from '../enums/AccountStatus';
+import { TypeOfDirectoryId } from '../../directory/enums/TypeOfDirectoryId';
+
+
+export class AccountResponse {
+    @IsString()
+    id: string;
+
+    @IsOptional()
+    @IsString()
+    typeOfAccountId: string;
+
+    @IsOptional()
+    @IsString()
+    externalAccountId: string;
+
+    @IsOptional()
+    @IsString()
+    externalSubAccountId: string | null;
+
+    @IsEnum(Provider)
+    provider: Provider;
+
+    @IsString()
+    directoryId: string;
+
+    @IsEnum(TypeOfDirectoryId)
+    typeOfDirectoryId: TypeOfDirectoryId;
+
+    @IsNumber()
+    currentBalance: number;
+
+    @IsNumber()
+    balanceLock: number;
+
+    @IsEnum(Country)
+    countryId: Country;
+
+    @IsDateString()
+    createDate: string;
+
+    @IsDateString()
+    lastUpdateDate: string;
+
+    @IsOptional()
+    @IsString()
+    accountNumber: string
+
+    @IsOptional()
+    @IsString()
+    routingNumber: string;
+
+    @IsEnum(AccountStatus)
+    status: AccountStatus;
+}

package/src/account/dtos/CreateAccountRequest.ts

@@ -0,0 +1,45 @@
+import { IsEmail, IsEnum, IsString, ValidateNested, IsDateString, Matches, Length } from 'class-validator';
+import { AddressResponse } from "../../address/dtos/AddressResponse";
+import { Country } from "../../country/enums/Country";
+import { regexUuidV4 } from '../../helpers/constans/regex';
+import { TypeOfDirectoryId } from '../../directory/enums/TypeOfDirectoryId';
+import { IsPhoneNumberFiado } from '../../card/validations/IsPhoneNumberConstraint';
+
+export class CreateAccountRequest {
+
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'directoryId must be a valid UUID v4',
+        })
+    directoryId: string;
+
+    @IsEnum(TypeOfDirectoryId)
+    typeOfDirectoryId: string;
+
+    @IsString()
+    firstName: string;
+
+    @IsString()
+
+    lastName: string;
+
+    @IsPhoneNumberFiado()
+    phoneNumber: string;
+
+    @ValidateNested()
+    address: AddressResponse;
+
+    @IsEmail()
+    email: string;
+
+    @IsDateString()
+    dob: string;
+
+    @IsString()
+    @Length(1, 30)
+    documentNumber: string;
+
+    @IsEnum(Country)
+    countryId: Country;
+}

package/src/account/dtos/CreatePockeRequest.ts

@@ -0,0 +1,19 @@
+import { IsString, Matches } from "class-validator";
+import { regexUuidV4 } from "../../helpers/constans/regex";
+
+export class CreatePocketRequest {
+
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'beneficiaryDirectoryId must be a valid UUID v4',
+        })
+    beneficiaryDirectoryId?: string;
+
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'accountId must be a valid UUID v4',
+        })
+    accountId: string;
+}

package/src/account/enums/AccountStatus.ts

@@ -0,0 +1,7 @@
+
+
+export enum AccountStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    BLOCKED = "BLOCKED"
+}

package/src/address/dtos/AddressBase.ts

@@ -0,0 +1,131 @@
+
+
+
+import { IsBoolean, IsEnum, IsNumber, IsOptional, IsString, Length, Matches, ValidateNested } from 'class-validator';
+import { TypeOfDirectoryId } from "../../directory/enums/TypeOfDirectoryId";
+import { AddressProvider } from "../enums/AddressProvider";
+import { AddressStatus } from "../enums/AddressStatus";
+import { Place } from "./Place";
+import { CountryId } from '../../country/enums/CountryId';
+import { regexIso8601, regexUuidV4 } from '../../helpers/constans/regex';
+
+export class AddressBase {
+
+    @IsOptional()
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'id must be a valid UUID v4',
+        })
+    id?: string;
+
+    @IsNumber()
+    @IsOptional()
+    distance?: number;
+
+    @IsEnum(TypeOfDirectoryId)
+    createdBy: TypeOfDirectoryId;
+
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'directoryId must be a valid UUID v4',
+        })
+    directoryId: string;
+
+    @IsBoolean()
+    isPrincipal: boolean;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 100)
+    tag?: string;
+
+    @IsString()
+    @Length(1, 100)
+    tenantId: string;
+
+    @IsString()
+    typeOfAddressId: string;
+
+    @IsEnum(TypeOfDirectoryId)
+    typeOfDirectoryId: TypeOfDirectoryId;
+
+    @IsEnum(AddressProvider)
+    provider: AddressProvider;
+
+    @ValidateNested()
+    place: Place;
+
+    @IsString()
+    @Matches(regexIso8601,
+        {
+            message: 'validFrom must be a valid ISO 8601 date string',
+        })
+    validFrom: string;
+
+    @IsOptional()
+    @IsString()
+    @Matches(regexIso8601,
+        {
+            message: 'validUntil must be a valid ISO 8601 date string',
+        })
+    validUntil?: string;
+
+    @IsEnum(AddressStatus)
+    addressStatus: AddressStatus;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 200)
+    additionalInformation?: string;
+
+    @IsBoolean()
+    helpNeeded: boolean;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 10)
+    internalNumber?: string;
+
+    @IsEnum(CountryId)
+    countryId: CountryId;
+
+    @IsString()
+    @Length(1, 100)
+    street?: string;
+
+    @IsString()
+    @Length(1, 10)
+    addressNumber?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    municipality?: string;
+
+    @IsOptional()
+    @IsString()
+    subMunicipality?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    neighborhood?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    subRegion?: string;
+
+    @IsString()
+    @Length(5, 10)
+    region?: string;
+
+    @IsString()
+    @Length(5, 10)
+    postalCode?: string;
+
+    @IsEnum(CountryId)
+    country: string;
+}

package/src/address/dtos/AddressResponse.ts

@@ -0,0 +1,41 @@
+
+
+
+import { IsOptional, IsString, Length, Matches } from 'class-validator';
+
+import { regexIso8601, regexUuidV4 } from '../../helpers/constans/regex';
+import { AddressBase } from './AddressBase';
+
+export class AddressResponse extends AddressBase {
+
+    @IsString()
+    @Matches(regexUuidV4,
+        {
+            message: 'id must be a valid UUID v4',
+        })
+    id: string
+
+    @IsOptional()
+    @IsString()
+    @Matches(regexIso8601,
+        {
+            message: 'createDate must be a valid ISO 8601 date string',
+        })
+    createDate: string;
+
+    @IsOptional()
+    @IsString()
+    @Matches(regexIso8601,
+        {
+            message: 'updateDate must be a valid ISO 8601 date string',
+        })
+    updateDate?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 100)
+    updatedBy?: string;
+}
+
+
+

package/src/address/dtos/CreateAddressRequest.ts

@@ -0,0 +1,7 @@
+import { AddressBase } from "./AddressBase";
+
+
+export class CreateAddressRequest extends AddressBase {
+
+
+}

package/src/address/dtos/Geometry.ts

@@ -0,0 +1,5 @@
+
+
+export type Geometry = {
+    point: [number, number];
+}

package/src/address/dtos/Place.ts

@@ -0,0 +1,84 @@
+import { IsArray, IsBoolean, IsEnum, IsOptional, IsString, Length, ValidateNested } from 'class-validator';
+import { Geometry } from "./Geometry";
+import { Timezone } from "./Timezone";
+import { Country } from '../../country/enums/Country';
+
+export class Place {
+    @ValidateNested()
+    geometry: Geometry;
+
+    @IsOptional()
+    @IsString()
+    addressNumber?: string;
+
+    @IsOptional()
+    @IsArray()
+    @IsString({ each: true })
+    categories?: string[];
+
+    @IsOptional()
+    @IsEnum(Country)
+    country?: string;
+
+    @IsBoolean()
+    interpolated: boolean;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 300)
+    label?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 60)
+    municipality?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    neighborhood?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(5, 10)
+    postalCode?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(5, 10)
+    region?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 100)
+    street?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    subMunicipality?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(2, 60)
+    subRegion?: string;
+
+    @IsOptional()
+    @IsArray()
+    @IsString({ each: true })
+    supplementalCategories?: string[];
+
+    @IsOptional()
+    @ValidateNested()
+    timezone?: Timezone;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 10)
+    unitNumber?: string;
+
+    @IsOptional()
+    @IsString()
+    @Length(1, 10)
+    unitType?: string;
+}

package/src/address/dtos/{AddressShippingDto.ts → Shipping.ts}

@@ -1,7 +1,7 @@
 import { IsString, Length, IsOptional } from 'class-validator';
 import { CountryId } from '../../country/enums/CountryId';
 
-export class ShippingAddressDto {
+export class Shipping {
   @IsString()
   @Length(2, 60)
   municipality: string;

package/src/address/dtos/Timezone.ts

@@ -0,0 +1,6 @@
+
+
+export type Timezone = {
+    name: string;
+    offset: string;
+}

package/src/address/enums/AddressProvider.ts

@@ -0,0 +1,10 @@
+
+/**
+ * AddressProvider enum
+ * @description AddressProvider enum is used to define the address provider
+ * @enum {string} AddressProvider
+ */
+export enum AddressProvider {
+    AWS = "AWS",
+    MANUAL = "MANUAL"
+}

package/src/address/enums/AddressStatus.ts

@@ -0,0 +1,10 @@
+
+/**
+ * AddressProvider Status
+ * @description AddressProvider Status is used to define the address provider status
+ * @enum {string} AddressStatus
+ */
+export enum AddressStatus {
+    VISIBLE = "VISIBLE",
+    NOT_VISIBLE = "NOT_VISIBLE"
+}

package/src/address/index.ts

@@ -1 +1 @@
-export * from './dtos/AddressShippingDto';
+export * from './dtos/Shipping';

package/src/card/dtos/{CardActivateRequestDto.ts → CardActivateRequest.ts}

@@ -2,7 +2,7 @@ import { IsEnum, IsString, Matches } from 'class-validator';
 import { CountryId } from '../../country/enums/CountryId';
 
 
-export class CardActivateRequestDto {
+export class CardActivateRequest {
   @IsEnum(CountryId)
   countryId: number;
 

package/src/card/dtos/{CardApplicationRequestDto.ts → CardApplicationRequest.ts}

@@ -4,9 +4,9 @@ import { IsEnum, IsNotEmpty, ValidateNested } from 'class-validator';
 import { Type } from 'class-transformer';
 import { CountryId } from '../../country/enums/CountryId';
 import { CardType } from '../enums/CardType';
-import { ShippingAddressDto } from '../../address/dtos/AddressShippingDto';
+import { Shipping } from '../../address/dtos/Shipping';
 
-export class CardApplicationRequestDto {
+export class CardApplicationRequest {
   @IsEnum(CountryId)
   countryId: number;
 
@@ -15,6 +15,6 @@ export class CardApplicationRequestDto {
 
   @IsNotEmpty()
   @ValidateNested()
-  @Type(() => ShippingAddressDto)
-  address: ShippingAddressDto;
+  @Type(() => Shipping)
+  address: Shipping;
 }

package/src/card/dtos/{CardUpdateRequestDto.ts → CardUpdateRequest.ts}

@@ -5,7 +5,7 @@ import { IsValueValid } from "../validations/CardUpdateKeyConstraint";
 
 
 
-export class CardUpdateRequestDto {
+export class CardUpdateRequest {
 
     @IsEnum(UpdateKey)
     type: UpdateKey;

package/src/card/dtos/{CreateCardRequestDto.ts → CreateCardRequest.ts}

@@ -1,14 +1,14 @@
 import { IsString, IsOptional, IsEnum, ValidateNested, IsNumber, Min, Max, Length, Matches } from 'class-validator';
 import { Type } from 'class-transformer';
 import { CountryId } from '../../country/enums/CountryId';
-import { ShippingAddressDto } from '../../address/dtos/AddressShippingDto';
 import { CardType } from '../enums/CardType';
 import { Brand } from '../enums/Brand';
 import { OwnershipType } from '../enums/OwnershipType';
 import { Status } from '../enums/Status';
 import { regexIso8601, regexUuidV4 } from '../../helpers/constans/regex';
+import { Shipping } from '../../address';
 
-export class CreateCardRequestDto {
+export class CreateCardRequest {
 
   @IsOptional()
   @IsString()
@@ -136,6 +136,6 @@ export class CreateCardRequestDto {
 
   @IsOptional()
   @ValidateNested()
-  @Type(() => ShippingAddressDto)
-  shippedAddress?: ShippingAddressDto;
+  @Type(() => Shipping)
+  shippedAddress?: Shipping;
 }

package/src/card/validations/CardUpdateKeyConstraint.ts

@@ -1,5 +1,5 @@
 import { ValidationArguments, ValidationOptions, ValidatorConstraint, registerDecorator } from "class-validator";
-import { CardUpdateRequestDto } from "../dtos/CardUpdateRequestDto";
+import { CardUpdateRequest } from "../dtos/CardUpdateRequest";
 import { Status } from "../enums/Status";
 import { UpdateKey } from "../enums/UpdateKey";
 
@@ -9,7 +9,7 @@ export class CardUpdateKeyConstraint {
 
     public static validateUpdateKey(value: string | Status, arg: ValidationArguments) {
 
-        const cardUpdateRequest = arg.object as CardUpdateRequestDto;
+        const cardUpdateRequest = arg.object as CardUpdateRequest;
 
         // Validar si el valor es uno de los status válidos
         if (cardUpdateRequest.type === UpdateKey.CHANGE_STATUS) {
@@ -37,10 +37,8 @@ export class CardUpdateKeyConstraint {
     }
 
     defaultMessage(args: ValidationArguments) {
-        // Se4 puede usar args para personalizar aún más el mensaje de error basado en el valor o las propiedades.
-        return "El valor no es adecuado para el tipo de actualización.";
+        return "The value is not valid for the update type.";
     }
-
 }
 
 export function IsValueValid(validationOptions?: ValidationOptions) {

package/src/card/validations/IsPhoneNumberConstraint.ts

@@ -0,0 +1,26 @@
+import { ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments, registerDecorator, ValidationOptions } from 'class-validator';
+import { regexPhoneNumber } from '../../helpers/constans/regex';
+
+@ValidatorConstraint({ async: true })
+export class IsPhoneNumberConstraint implements ValidatorConstraintInterface {
+    validate(phoneNumber: string, args: ValidationArguments) {
+        return regexPhoneNumber.test(phoneNumber);
+    }
+
+    defaultMessage(args: ValidationArguments) {
+        return "The phone number is not valid. The expected format is +############.";
+    }
+}
+
+// Decorador que usaremos en nuestras clases DTO
+export function IsPhoneNumberFiado(validationOptions?: ValidationOptions) {
+    return function (object: Object, propertyName: string) {
+        registerDecorator({
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            constraints: [],
+            validator: IsPhoneNumberConstraint,
+        });
+    };
+}

package/src/country/enums/Country.ts

@@ -0,0 +1,6 @@
+
+
+export enum Country {
+    MEX = "MEX",
+    USA = "USA"
+}

package/src/country/enums/CountryId.ts

@@ -1,3 +1,6 @@
+
+//*
+
 export enum CountryId {
     MEX = "484",
     USA = "840"

package/src/directory/enums/TypeOfDirectoryId.ts

@@ -0,0 +1,7 @@
+
+
+export enum TypeOfDirectoryId {
+    USER = "USER",
+    BACKOFFICE = "BACKOFFICE",
+    AGENT = "AGENT"
+}

package/src/helpers/constans/regex.ts

@@ -4,6 +4,8 @@
 export const regexUuidV4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 // Expresión regular para validar fecha ISO 8601
 export const regexIso8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+// Expresión regular para validar un número de teléfono
+export const regexPhoneNumber = /^\+\d{12}$/;
 
 
 

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from './card/dtos/CardActivateRequestDto';
-export * from './card/dtos/CardApplicationRequestDto';
-export * from './card/dtos/CreateCardRequestDto';
-export * from './card/dtos/CardUpdateRequestDto';
+export * from './card/dtos/CardActivateRequest';
+export * from './card/dtos/CardApplicationRequest';
+export * from './card/dtos/CreateCardRequest';
+export * from './card/dtos/CardUpdateRequest';