@merkaly/api 0.2.5-8 → 0.3.2

package/dist/abstract.entity.d.ts

@@ -0,0 +1,10 @@
+import { Document } from 'mongoose';
+import type { SchemaOptions } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+export declare const $collection: SchemaOptions;
+export declare const $subdocument: SchemaOptions;
+export type MongoEntity<T extends AbstractEntity> = T | string;
+export declare abstract class AbstractEntity extends Document<string> {
+    createdAt: Date;
+    readonly updatedAt?: Date;
+    deletedAt?: Date;
+}

package/dist/abstract.entity.js

@@ -0,0 +1,45 @@
+"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.AbstractEntity = exports.$subdocument = exports.$collection = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+exports.$collection = {
+    timestamps: true,
+    toJSON: { getters: true, versionKey: false, virtuals: true },
+    toObject: { getters: true, versionKey: false, virtuals: true },
+    virtuals: true,
+};
+exports.$subdocument = {
+    _id: true,
+    toJSON: { getters: true, versionKey: false, virtuals: true },
+    toObject: { getters: true, versionKey: false, virtuals: true },
+    virtuals: true,
+};
+class AbstractEntity extends mongoose_2.Document {
+    createdAt;
+    updatedAt;
+    deletedAt;
+}
+exports.AbstractEntity = AbstractEntity;
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.Date }),
+    __metadata("design:type", Date)
+], AbstractEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.Date }),
+    __metadata("design:type", Date)
+], AbstractEntity.prototype, "updatedAt", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: null, type: mongoose_2.Schema.Types.Date }),
+    __metadata("design:type", Date)
+], AbstractEntity.prototype, "deletedAt", void 0);
+//# sourceMappingURL=abstract.entity.js.map

package/dist/abstract.repository.d.ts

@@ -0,0 +1,56 @@
+import { CacheService } from './';
+import { LoggerService } from './';
+import { MongoService } from './';
+import { AbstractEntity } from './';
+import { AbstractSchema } from './';
+import { AbstractValidator, ReadValidator, SearchValidator } from './';
+import type { Request } from 'express';
+import type { HydratedDocument, RootFilterQuery, Document, Model } from 'mongoose';
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+type SystemKeys = '_id' | 'createdAt' | 'updatedAt' | 'deletedAt' | keyof Document;
+export type CreateEntityArgs<T> = {
+    [K in keyof T as K extends SystemKeys ? never : T[K] extends Function ? never : Equal<{
+        [Q in K]: T[K];
+    }, {
+        -readonly [Q in K]: T[K];
+    }> extends true ? K : never]: T[K] extends AbstractEntity ? CreateEntityArgs<T[K]> : T[K];
+};
+type UpdateEntityArgs<T extends AbstractEntity> = Partial<CreateEntityArgs<T>>;
+interface ReadOptions {
+    cache?: boolean;
+}
+export declare abstract class AbstractRepository<E extends AbstractEntity = AbstractEntity> {
+    protected abstract readonly $schema: AbstractSchema<E>;
+    protected readonly $logger: LoggerService;
+    protected readonly $request: Request;
+    protected readonly $mongo: MongoService<E>;
+    readonly $cache: CacheService;
+    protected readonly $joins: Record<string, AbstractSchema<any>>;
+    constructor($request: Request, $mongo: MongoService<E>, $logger: LoggerService);
+    get $builder(): Model<E>;
+    get $user(): import("../../app.types").AppAuthUser;
+    set $identity(value: string);
+    get $identity(): string;
+    search(validator?: SearchValidator<E>): Promise<{
+        data: import("mongoose").IfAny<E, any, Document<unknown, {}, E, {}, {}> & (import("mongoose").Require_id<E> extends infer T ? T extends import("mongoose").Require_id<E> ? T extends {
+            __v?: infer U;
+        } ? T : T & {
+            __v: number;
+        } : never : never)>[];
+        limit: number;
+        pages: number;
+        total: number;
+    }>;
+    read(param: string | RootFilterQuery<E>, validator?: ReadValidator, options?: ReadOptions): Promise<HydratedDocument<E>>;
+    create(payload: CreateEntityArgs<E> | AbstractValidator, validator?: ReadValidator, doc?: Document<string, object, E>): Promise<import("mongoose").IfAny<E, any, Document<unknown, {}, E, {}, {}> & (import("mongoose").Require_id<E> extends infer T ? T extends import("mongoose").Require_id<E> ? T extends {
+        __v?: infer U;
+    } ? T : T & {
+        __v: number;
+    } : never : never)> | Document<string, object, E, Record<string, any>, {}>>;
+    update(_id: string, payload: UpdateEntityArgs<E> | AbstractValidator, validator?: ReadValidator): Promise<HydratedDocument<E>>;
+    delete(_id: string): Promise<void>;
+    private sanitizePaths;
+    private removeNonDeclaredSchemas;
+    private applyPopulate;
+}
+export {};

package/dist/abstract.repository.js

@@ -0,0 +1,200 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRepository = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const class_validator_1 = require("class-validator");
+const cache_service_1 = require("../services/cache.service");
+const logger_service_1 = require("../services/logger.service");
+const entity_not_found_exception_1 = require("../exceptions/entity-not-found.exception");
+const mongo_service_1 = require("../services/mongo.service");
+const abstract_validator_1 = require("./abstract.validator");
+const $cache = new cache_service_1.CacheService();
+let AbstractRepository = class AbstractRepository {
+    $logger;
+    $request;
+    $mongo;
+    $cache = $cache;
+    $joins = {};
+    constructor($request, $mongo, $logger) {
+        this.$mongo = $mongo;
+        this.$request = $request;
+        this.$logger = $logger;
+        this.$cache.$request = $request;
+    }
+    get $builder() {
+        return this.$mongo.schema(this.$schema);
+    }
+    get $user() {
+        return this.$request?.user;
+    }
+    set $identity(value) {
+        this.$mongo.$identity = value;
+    }
+    get $identity() {
+        return this.$mongo.$identity;
+    }
+    async search(validator = new abstract_validator_1.SearchValidator()) {
+        const filters = { deletedAt: null, ...validator.filters };
+        const isUnlimited = validator.limit === -1 || validator.limit === Infinity;
+        const page = isUnlimited ? 1 : validator.page || 1;
+        const limit = isUnlimited ? 0 : validator.limit || 25;
+        const skip = isUnlimited ? 0 : (page - 1) * limit;
+        const defaultSort = { createdAt: 'desc' };
+        validator.sort = (0, class_validator_1.isNotEmptyObject)(validator.sort) ? validator.sort : defaultSort;
+        const baseQuery = this.$builder.find(filters).sort(validator.sort);
+        if (validator.join) {
+            this.applyPopulate(baseQuery, validator.join);
+        }
+        if (isUnlimited) {
+            const total = await this.$builder.countDocuments(filters).exec();
+            const data = await baseQuery.sort(validator.sort);
+            return {
+                data,
+                limit: total,
+                pages: 1,
+                total,
+            };
+        }
+        const query = baseQuery.skip(skip).limit(limit);
+        const [data, total] = await Promise.all([
+            query.sort(validator.sort),
+            this.$builder.countDocuments(filters).exec(),
+        ]);
+        return {
+            data,
+            limit,
+            pages: Math.ceil(total / limit),
+            total,
+        };
+    }
+    async read(param, validator = {}, options = {}) {
+        this.$cache.use(this.$identity);
+        if ((0, class_validator_1.isString)(param)) {
+            param = { _id: param };
+        }
+        const id = `${this.$schema.name}:${JSON.stringify(param)}`;
+        if ((options.cache === undefined || options.cache === true) && this.$cache.has(id)) {
+            const entity = this.$cache.get(id);
+            this.$logger.log({
+                group: this.$identity,
+                message: `Retrieved ${entity._id} from cache ${this.$schema.name}`,
+                type: 'repository',
+            });
+            return entity;
+        }
+        const query = this.$builder.findOne(param);
+        if (validator.join) {
+            this.applyPopulate(query, validator.join);
+        }
+        const entity = await query.exec();
+        if (!entity) {
+            this.$logger.warn({
+                group: this.$identity,
+                message: `Not found ${id} in collection ${this.$schema.name}`,
+                type: 'repository',
+            });
+            throw new entity_not_found_exception_1.EntityNotFoundException(param);
+        }
+        if (entity.deletedAt) {
+            this.$logger.warn({
+                group: this.$identity,
+                message: `Found but deleted ${entity._id} in collection ${this.$schema.name}`,
+                type: 'repository',
+            });
+            throw new common_1.GoneException();
+        }
+        this.$logger.log({
+            group: this.$identity,
+            message: `Retrieved ${entity._id} from collection ${this.$schema.name}`,
+            type: 'repository',
+        });
+        return this.$cache.set(id, entity);
+    }
+    async create(payload, validator = {}, doc) {
+        const entity = doc || new this.$builder();
+        Object.entries(payload)
+            .filter(([key, value]) => value !== undefined && key in entity)
+            .forEach(([key, value]) => (entity[key] = value));
+        if (validator.join) {
+            this.applyPopulate(entity, validator.join);
+        }
+        return entity.save();
+    }
+    async update(_id, payload, validator = {}) {
+        const entity = await this.read({ _id });
+        Object.entries(payload)
+            .filter(([key, value]) => key in entity && (0, class_validator_1.isNotEmpty)(value))
+            .forEach(([key, value]) => (entity[key] = value));
+        if (validator.join) {
+            this.applyPopulate(entity, validator.join);
+        }
+        return entity.save();
+    }
+    async delete(_id) {
+        await this.read({ _id });
+        await this.$builder.deleteOne({ _id });
+    }
+    sanitizePaths(options) {
+        return options.map((it) => {
+            if ((0, class_validator_1.isString)(it)) {
+                return { path: it, populate: [] };
+            }
+            if ((0, class_validator_1.isArray)(it.populate)) {
+                it.populate = this.sanitizePaths(it.populate);
+            }
+            return it;
+        });
+    }
+    removeNonDeclaredSchemas(options) {
+        const flatten = (item, parentPath = '') => {
+            const currentPath = parentPath ? `${parentPath}.${item.path}` : item.path;
+            if (!(currentPath in this.$joins)) {
+                return [];
+            }
+            const schema = this.$joins[currentPath];
+            const result = {
+                path: item.path,
+                model: schema?.name,
+            };
+            if (item.populate && Array.isArray(item.populate)) {
+                const nestedPopulate = item.populate
+                    .map((nestedItem) => flatten(nestedItem, currentPath))
+                    .filter((it) => !Array.isArray(it));
+                if (nestedPopulate.length > 0) {
+                    result.populate = nestedPopulate;
+                }
+            }
+            return result;
+        };
+        return options.map((it) => flatten(it)).filter((it) => !Array.isArray(it));
+    }
+    applyPopulate(query, options) {
+        if (!options)
+            return;
+        const sanitizedPaths = this.sanitizePaths(options);
+        const validatedPaths = this.removeNonDeclaredSchemas(sanitizedPaths);
+        query.populate(validatedPaths);
+    }
+};
+exports.AbstractRepository = AbstractRepository;
+exports.AbstractRepository = AbstractRepository = __decorate([
+    __param(0, (0, common_1.Inject)(core_1.REQUEST)),
+    __param(1, (0, common_1.Inject)()),
+    __param(2, (0, common_1.Inject)()),
+    __metadata("design:paramtypes", [Object, mongo_service_1.MongoService,
+        logger_service_1.LoggerService])
+], AbstractRepository);
+//# sourceMappingURL=abstract.repository.js.map

package/dist/abstract.validator.d.ts

@@ -0,0 +1,22 @@
+import { AbstractEntity } from './';
+import type { FilterQuery, PopulateOptions, SortOrder } from 'mongoose';
+export declare abstract class AbstractValidator {
+}
+type JoinPopulateOptions = string | PopulateOptions | Array<string | PopulateOptions>;
+export declare function transformJoinsIntoPopulate(value: JoinPopulateOptions): PopulateOptions[];
+export type KeyOfType<T, V> = keyof {
+    [P in keyof T as T[P] extends V ? P : string]: any;
+};
+export declare class ReadValidator<E = AbstractEntity> extends AbstractValidator {
+    join?: PopulateOptions[];
+}
+export declare class SearchValidator<E = AbstractEntity> {
+    limit?: number;
+    page?: number;
+    sort?: {
+        [key: string]: SortOrder;
+    };
+    filters?: FilterQuery<E>;
+    join?: PopulateOptions[];
+}
+export {};

package/dist/abstract.validator.js

@@ -0,0 +1,98 @@
+"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.SearchValidator = exports.ReadValidator = exports.AbstractValidator = void 0;
+exports.transformJoinsIntoPopulate = transformJoinsIntoPopulate;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+class AbstractValidator {
+}
+exports.AbstractValidator = AbstractValidator;
+function transformJoinsIntoPopulate(value) {
+    function transform(value) {
+        if ((0, class_validator_1.isString)(value)) {
+            try {
+                const parsed = JSON.parse(value);
+                return transform(parsed);
+            }
+            catch {
+                return [{ path: value }];
+            }
+        }
+        if ((0, class_validator_1.isArray)(value)) {
+            return value.flatMap(transform);
+        }
+        if (typeof value === 'object' && value !== null && 'path' in value) {
+            const result = { path: value.path };
+            if (value.populate) {
+                result.populate = transform(value.populate);
+            }
+            return [result];
+        }
+        return [];
+    }
+    return transform(value);
+}
+class ReadValidator extends AbstractValidator {
+    join = [];
+}
+exports.ReadValidator = ReadValidator;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => transformJoinsIntoPopulate(value)),
+    __metadata("design:type", Array)
+], ReadValidator.prototype, "join", void 0);
+class SearchValidator {
+    limit = 10;
+    page = 1;
+    sort = {};
+    filters = {};
+    join = [];
+}
+exports.SearchValidator = SearchValidator;
+__decorate([
+    (0, class_transformer_1.Transform)(({ value }) => (value ? Number(value) : 10)),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], SearchValidator.prototype, "limit", void 0);
+__decorate([
+    (0, class_transformer_1.Transform)(({ value }) => (value ? Number(value) : 1)),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], SearchValidator.prototype, "page", void 0);
+__decorate([
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if ((0, class_validator_1.isObject)(value)) {
+            return value;
+        }
+        return value && JSON.parse(value);
+    }),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], SearchValidator.prototype, "sort", void 0);
+__decorate([
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if ((0, class_validator_1.isObject)(value)) {
+            return value;
+        }
+        return value && JSON.parse(value);
+    }),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], SearchValidator.prototype, "filters", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => transformJoinsIntoPopulate(value)),
+    __metadata("design:type", Array)
+], SearchValidator.prototype, "join", void 0);
+//# sourceMappingURL=abstract.validator.js.map

package/dist/account/address/address.entity.d.ts

@@ -0,0 +1,7 @@
+import { AccountUserEntity } from '../user';
+import { AddressEntity } from '../..';
+import type { MongoEntity } from '../..';
+export declare class AccountAddressEntity extends AddressEntity {
+    user: MongoEntity<AccountUserEntity>;
+    name: string;
+}

package/dist/account/address/address.entity.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.AccountAddressEntity = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const user_schema_1 = require("../schemas/user.schema");
+const abstract_entity_1 = require("../../../infrastructure/abstracts/abstract.entity");
+const address_entity_1 = require("../../../infrastructure/entities/address.entity");
+let AccountAddressEntity = class AccountAddressEntity extends address_entity_1.AddressEntity {
+    user;
+    name;
+};
+exports.AccountAddressEntity = AccountAddressEntity;
+__decorate([
+    (0, mongoose_1.Prop)({ ref: user_schema_1.AccountUserSchema.name, required: true, type: mongoose_2.Schema.Types.String }),
+    __metadata("design:type", Object)
+], AccountAddressEntity.prototype, "user", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: true, trim: true }),
+    __metadata("design:type", String)
+], AccountAddressEntity.prototype, "name", void 0);
+exports.AccountAddressEntity = AccountAddressEntity = __decorate([
+    (0, mongoose_1.Schema)(abstract_entity_1.$collection)
+], AccountAddressEntity);
+//# sourceMappingURL=address.entity.js.map

package/dist/account/address/address.validator.d.ts

@@ -0,0 +1,17 @@
+import { AccountAddressEntity } from './';
+import { AbstractValidator, ReadValidator, SearchValidator } from '../..';
+export declare class SearchAddressValidator extends SearchValidator<AccountAddressEntity> {
+}
+export declare class ReadAddressValidator extends ReadValidator<AccountAddressEntity> {
+}
+export declare class CreateAddressValidator extends AbstractValidator {
+    street: string;
+    name: string;
+    complement: string;
+    country: string;
+    code: string;
+    longitude: number;
+    latitude: number;
+}
+export declare class UpdateAddressValidator extends CreateAddressValidator {
+}

package/dist/account/address/address.validator.js

@@ -0,0 +1,67 @@
+"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.UpdateAddressValidator = exports.CreateAddressValidator = exports.ReadAddressValidator = exports.SearchAddressValidator = void 0;
+const class_validator_1 = require("class-validator");
+const abstract_validator_1 = require("../../../infrastructure/abstracts/abstract.validator");
+class SearchAddressValidator extends abstract_validator_1.SearchValidator {
+}
+exports.SearchAddressValidator = SearchAddressValidator;
+class ReadAddressValidator extends abstract_validator_1.ReadValidator {
+}
+exports.ReadAddressValidator = ReadAddressValidator;
+class CreateAddressValidator extends abstract_validator_1.AbstractValidator {
+    street;
+    name;
+    complement;
+    country;
+    code;
+    longitude;
+    latitude;
+}
+exports.CreateAddressValidator = CreateAddressValidator;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], CreateAddressValidator.prototype, "street", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], CreateAddressValidator.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], CreateAddressValidator.prototype, "complement", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Length)(2, 2),
+    __metadata("design:type", String)
+], CreateAddressValidator.prototype, "country", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], CreateAddressValidator.prototype, "code", void 0);
+__decorate([
+    (0, class_validator_1.IsLongitude)(),
+    __metadata("design:type", Number)
+], CreateAddressValidator.prototype, "longitude", void 0);
+__decorate([
+    (0, class_validator_1.IsLatitude)(),
+    __metadata("design:type", Number)
+], CreateAddressValidator.prototype, "latitude", void 0);
+class UpdateAddressValidator extends CreateAddressValidator {
+}
+exports.UpdateAddressValidator = UpdateAddressValidator;
+//# sourceMappingURL=address.validator.js.map

package/dist/account/address/index.d.ts

@@ -0,0 +1,2 @@
+export * from './address.entity';
+export * from './address.validator';

package/dist/account/address/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var address_entity_1 = require("./address.entity");
+Object.keys(address_entity_1).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, { enumerable: true, get: function () { return address_entity_1[key]; } });
+});
+var address_validator_1 = require("./address.validator");
+Object.keys(address_validator_1).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, { enumerable: true, get: function () { return address_validator_1[key]; } });
+});

package/dist/account/cart/cart.entity.d.ts

@@ -0,0 +1,8 @@
+import { AccountUserEntity } from '../user';
+import { SaleItemEntity } from '../../order/sale/item';
+import { AbstractEntity } from '../..';
+import type { MongoEntity } from '../..';
+export declare class AccountCartEntity extends AbstractEntity {
+    user: MongoEntity<AccountUserEntity>;
+    items: SaleItemEntity[];
+}

package/dist/account/cart/cart.entity.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.AccountCartEntity = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const user_schema_1 = require("../schemas/user.schema");
+const item_schema_1 = require("../../order/sale/schemas/item.schema");
+const abstract_entity_1 = require("../../../infrastructure/abstracts/abstract.entity");
+let AccountCartEntity = class AccountCartEntity extends abstract_entity_1.AbstractEntity {
+    user;
+    items = [];
+};
+exports.AccountCartEntity = AccountCartEntity;
+__decorate([
+    (0, mongoose_1.Prop)({ ref: user_schema_1.AccountUserSchema.name, required: true, type: mongoose_2.Schema.Types.String }),
+    __metadata("design:type", Object)
+], AccountCartEntity.prototype, "user", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: () => [], type: [item_schema_1.SaleItemSchema.schema] }),
+    __metadata("design:type", Array)
+], AccountCartEntity.prototype, "items", void 0);
+exports.AccountCartEntity = AccountCartEntity = __decorate([
+    (0, mongoose_1.Schema)(abstract_entity_1.$collection)
+], AccountCartEntity);
+//# sourceMappingURL=cart.entity.js.map

package/dist/account/cart/cart.validator.d.ts

@@ -0,0 +1,13 @@
+import { AccountCartEntity } from './';
+import { AbstractValidator, ReadValidator, SearchValidator } from '../..';
+export declare class SearchCartValidator extends SearchValidator<AccountCartEntity> {
+}
+export declare class ReadCartValidator extends ReadValidator<AccountCartEntity> {
+}
+export declare class CreateCartValidator extends AbstractValidator {
+    userId: string;
+    productId: string;
+    quantity: number;
+}
+export declare class UpdateCartValidator extends CreateCartValidator {
+}