@buunguyen3589/collections-module 1.0.0

package/dist/app/usecases/command/update-collection.usecase.d.ts

@@ -0,0 +1,15 @@
+import { IUseCase, UseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+import { CollectionRepository, UpdateCollectionInput } from '../../../domain';
+export type UpdateCollectionUseCaseInput = UpdateCollectionInput;
+export type UpdateCollectionUseCaseOutput = {
+    id: string;
+};
+export type IUpdateCollectionUseCase = IUseCase<UpdateCollectionUseCaseInput, UpdateCollectionUseCaseOutput, UseCaseContext>;
+export declare class CollectionUpdateUseCase<I extends UpdateCollectionUseCaseInput = UpdateCollectionUseCaseInput, O extends UpdateCollectionUseCaseOutput = UpdateCollectionUseCaseOutput, C extends UseCaseContext = UseCaseContext> extends UseCase<I, O, C> implements IUpdateCollectionUseCase {
+    protected readonly collectionRepository: CollectionRepository;
+    private readonly logger;
+    constructor(collectionRepository: CollectionRepository);
+    processing: (input: UpdateCollectionUseCaseInput) => Promise<{
+        id: string;
+    }>;
+}

package/dist/app/usecases/command/update-collection.usecase.js

@@ -0,0 +1,73 @@
+"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.CollectionUpdateUseCase = void 0;
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../../shared");
+const domain_1 = require("../../../domain");
+const zod_1 = require("zod");
+const UpdateCollectionUseCaseInputSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    ambassadorId: zod_1.z.string(),
+    collectionName: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    isFavorite: zod_1.z.boolean().default(false),
+});
+let CollectionUpdateUseCase = class CollectionUpdateUseCase extends aqua_ddd_1.UseCase {
+    constructor(collectionRepository) {
+        super();
+        this.collectionRepository = collectionRepository;
+        // send message to create post
+        this.processing = async (input) => {
+            if (!input) {
+                throw new common_1.RuntimeError('UPDATE_COLLECTION', shared_1.ERROR_CODES.BAD_REQUEST, 'Invalid payload');
+            }
+            const model = UpdateCollectionUseCaseInputSchema.parse(input);
+            // check if post already exists
+            const entity = await this.collectionRepository.findOne({
+                filter: {
+                    id: { $eq: model.id },
+                    ambassadorId: { $eq: model.ambassadorId },
+                },
+            }, {
+                tenantId: this.context.tenantId,
+            });
+            if (!entity?.id) {
+                throw new common_1.RuntimeError('UPDATE_COLLECTION', shared_1.ERROR_CODES.NOT_FOUND, 'Collection not found');
+            }
+            if (entity.collectionType !== domain_1.CollectionTypeEnum.OTHERS) {
+                throw new common_1.RuntimeError('DELETE_COLLECTION', shared_1.ERROR_CODES.NOT_FOUND, 'Cannot update default collections');
+            }
+            await entity.update(input);
+            await this.collectionRepository.update(entity, {
+                tenantId: this.context.tenantId,
+            });
+            return {
+                id: entity.id,
+            };
+        };
+        this.logger = new common_1.Logger(this.constructor.name);
+        this.setMethods(this.processing);
+    }
+};
+CollectionUpdateUseCase = __decorate([
+    (0, common_1.Provider)({
+        token: shared_1.COLLECTION_INJECT_TOKENS.USECASE.COLLECTION_UPDATE,
+        scope: common_1.Lifecycle.Transient,
+    }),
+    __param(0, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.REPOSITORY.COLLECTION)),
+    __metadata("design:paramtypes", [domain_1.CollectionRepository])
+], CollectionUpdateUseCase);
+exports.CollectionUpdateUseCase = CollectionUpdateUseCase;

package/dist/app/usecases/index.d.ts

@@ -0,0 +1,2 @@
+export * from './command';
+export * from './query';

package/dist/app/usecases/index.js

@@ -0,0 +1,18 @@
+"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("./command"), exports);
+__exportStar(require("./query"), exports);

package/dist/app/usecases/query/get-detail-collection.usecase.d.ts

@@ -0,0 +1,36 @@
+import { IUseCase, PaginationInput, SortInput, UseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+import type { ShopifyProduct, UGCPost, AmbassadorDto, IProductService, IUgcManagementService, IGetAmbassadorByIdUseCase, IPostProductDao } from '../../../shared';
+import { CollectionDto } from '../../../domain';
+import { CollectionDao, PostCollectionDao, ProductCollectionDao } from '../../../infra';
+type GetDetailCollectionUseCaseInput = PaginationInput & {
+    id: string;
+    needLinkedProduct?: boolean;
+};
+type GetDetailCollectionUseCaseOutput = {
+    collection: Partial<CollectionDto>;
+    totalCount: number;
+    posts: UGCPost[];
+    products: ShopifyProduct[];
+};
+export type IGetDetailCollectionUseCase = IUseCase<GetDetailCollectionUseCaseInput, GetDetailCollectionUseCaseOutput, UseCaseContext>;
+export declare class CollectionDetailUseCase<I extends GetDetailCollectionUseCaseInput = GetDetailCollectionUseCaseInput, O extends GetDetailCollectionUseCaseOutput = GetDetailCollectionUseCaseOutput, C extends UseCaseContext = UseCaseContext> extends UseCase<I, O, C> implements IGetDetailCollectionUseCase {
+    protected readonly collectionDao: CollectionDao;
+    protected readonly productCollectionDao: ProductCollectionDao;
+    protected readonly postCollectionDao: PostCollectionDao;
+    protected readonly ugcManagementService: IUgcManagementService;
+    protected readonly productService: IProductService;
+    protected readonly getAbsByIdUsecase: IGetAmbassadorByIdUseCase;
+    protected readonly postProductDao: IPostProductDao;
+    private readonly logger;
+    constructor(collectionDao: CollectionDao, productCollectionDao: ProductCollectionDao, postCollectionDao: PostCollectionDao, ugcManagementService: IUgcManagementService, productService: IProductService, getAbsByIdUsecase: IGetAmbassadorByIdUseCase, postProductDao: IPostProductDao);
+    processing: (input: GetDetailCollectionUseCaseInput) => Promise<GetDetailCollectionUseCaseOutput>;
+    handleGetPosts(collectionId: string, ambassador: Partial<AmbassadorDto>, limit?: number, offset?: number, sort?: SortInput, getAll?: boolean, needLinkedProduct?: boolean): Promise<{
+        posts: UGCPost[];
+        totalPostCount: number;
+    }>;
+    handleGetProducts(collectionId: string, ambassador: Partial<AmbassadorDto>, limit?: number, offset?: number, sort?: SortInput, getAll?: boolean): Promise<{
+        products: ShopifyProduct[];
+        totalProductCount: number;
+    }>;
+}
+export {};

package/dist/app/usecases/query/get-detail-collection.usecase.js

@@ -0,0 +1,216 @@
+"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.CollectionDetailUseCase = void 0;
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../../shared");
+const domain_1 = require("../../../domain");
+const infra_1 = require("../../../infra");
+let CollectionDetailUseCase = class CollectionDetailUseCase extends aqua_ddd_1.UseCase {
+    constructor(collectionDao, productCollectionDao, postCollectionDao, ugcManagementService, productService, getAbsByIdUsecase, postProductDao) {
+        super();
+        this.collectionDao = collectionDao;
+        this.productCollectionDao = productCollectionDao;
+        this.postCollectionDao = postCollectionDao;
+        this.ugcManagementService = ugcManagementService;
+        this.productService = productService;
+        this.getAbsByIdUsecase = getAbsByIdUsecase;
+        this.postProductDao = postProductDao;
+        this.processing = async (input) => {
+            try {
+                const getAll = true;
+                const { id, limit, offset, sort, needLinkedProduct = false } = input;
+                const collection = await this.collectionDao.findOne({ filter: { id: { $eq: id } } });
+                if (!collection) {
+                    throw new common_1.RuntimeError(this.constructor.name, shared_1.ERROR_CODES.NOT_FOUND, 'Collection not found');
+                }
+                const absId = collection?.ambassadorId || '';
+                const ambassador = await this.getAbsByIdUsecase.exec({ id: absId });
+                if (!ambassador)
+                    throw new common_1.RuntimeError('GET_DETAIL_COLLECTION', shared_1.ERROR_CODES.NOT_FOUND, 'Ambassador not found');
+                const response = {
+                    collection: collection,
+                    totalCount: 0,
+                    posts: [],
+                    products: [],
+                };
+                if (collection.collectionType === domain_1.CollectionTypeEnum.ALL) {
+                    const [allPosts, allProducts] = await Promise.all([
+                        this.handleGetPosts(id, ambassador, limit, offset, sort, getAll, false),
+                        this.handleGetProducts(id, ambassador, limit, offset, sort, getAll),
+                    ]);
+                    response.posts = allPosts.posts;
+                    response.products = allProducts.products;
+                    response.totalCount = Number(allPosts.totalPostCount + allProducts.totalProductCount);
+                }
+                else if (collection.collectionType === domain_1.CollectionTypeEnum.POSTS) {
+                    const allPosts = await this.handleGetPosts(id, ambassador, limit, offset, sort, getAll, needLinkedProduct);
+                    response.posts = allPosts.posts;
+                    response.totalCount = allPosts.totalPostCount;
+                }
+                else {
+                    const [posts, products] = await Promise.all([
+                        this.handleGetPosts(id, ambassador, limit, offset, sort),
+                        this.handleGetProducts(id, ambassador, limit, offset, sort),
+                    ]);
+                    response.posts = posts.posts;
+                    response.products = products.products;
+                    response.totalCount = Number(posts.totalPostCount + products.totalProductCount);
+                }
+                return response;
+            }
+            catch (error) {
+                throw new common_1.RuntimeError('GET_DETAIL_COLLECTION', shared_1.ERROR_CODES.BAD_REQUEST, error);
+            }
+        };
+        this.logger = new common_1.Logger(this.constructor.name);
+        this.setMethods(this.processing);
+    }
+    async handleGetPosts(collectionId, ambassador, limit = 30, offset = 0, sort, getAll = false, needLinkedProduct = true) {
+        const emptyResponse = {
+            posts: [],
+            totalPostCount: 0,
+        };
+        try {
+            const postsLinkedProducts = await this.postCollectionDao.findPostsLinkedProduct(collectionId);
+            const collectionPostsConfig = await this.postCollectionDao.find({
+                filter: { ambassadorId: { $eq: ambassador?.id ?? '' } },
+            });
+            let postIds = postsLinkedProducts.flatMap((p) => typeof p.postId === 'string' ? [p.postId] : []);
+            if (!getAll && !postIds.length) {
+                return emptyResponse;
+            }
+            const absSocialUsername = ambassador.ambassadorMetric?.map((metric) => metric.socialUsername || '');
+            let listPostResponse;
+            try {
+                listPostResponse = getAll
+                    ? await this.ugcManagementService.getApprovedPosts({
+                        absUsernames: absSocialUsername,
+                        paginationInput: { limit, offset, sort },
+                    })
+                    : await this.ugcManagementService.getApprovedPosts({
+                        ids: postIds,
+                        paginationInput: { limit, offset, sort },
+                    });
+            }
+            catch (error) {
+                this.logger.error('Get Posts', error);
+                return emptyResponse;
+            }
+            const configMap = Object.fromEntries(collectionPostsConfig.map((cfg) => [cfg.postId, cfg]));
+            let filteredPosts = listPostResponse.items;
+            postIds = filteredPosts.map((item) => item.id);
+            const postHasProduct = await this.postProductDao.find({
+                filter: {
+                    postId: { $in: postIds },
+                },
+            });
+            const postHasProductMap = {};
+            postHasProduct.forEach((item) => {
+                if (item.postId)
+                    postHasProductMap[item.postId] = true;
+            });
+            // need filter only post has product
+            if (needLinkedProduct) {
+                filteredPosts = filteredPosts.filter((post) => !!postHasProductMap[post.id]);
+            }
+            const posts = filteredPosts.map((post) => {
+                return {
+                    ...post,
+                    hidden: configMap[post.id]?.hidden ?? false,
+                    collectionId: configMap[post.id]?.collectionId || '',
+                    hasProduct: !!postHasProductMap[post.id],
+                };
+            });
+            return {
+                posts: posts,
+                totalPostCount: Number(posts.length),
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async handleGetProducts(collectionId, ambassador, limit = 30, offset = 0, sort, getAll = false) {
+        try {
+            const emptyResponse = {
+                products: [],
+                totalProductCount: 0,
+            };
+            const filter = getAll
+                ? { ambassadorId: { $eq: ambassador.id } }
+                : { collectionId: { $eq: collectionId } };
+            const collectionProducts = await this.productCollectionDao.find({
+                filter: filter,
+                sort,
+            });
+            const productIds = collectionProducts.flatMap((p) => typeof p.productId === 'string' ? [p.productId] : []);
+            if (productIds.length == 0)
+                return emptyResponse;
+            const { items, totalCount } = await this.productService.getProducts({
+                limit,
+                offset,
+            }, productIds);
+            const discountValue = ambassador.ambassadorDiscountValue;
+            const discountType = ambassador.ambassadorDiscountValueType;
+            const collectionProductMap = new Map(collectionProducts.map((p) => [p.productId, p]));
+            const products = items.map((product) => {
+                const maxValue = Number(product.productMaxPrice) ?? 0;
+                const discount = discountValue ?? 0;
+                let minValue = Number(product.productMinPrice) ?? 0;
+                if (discountType === shared_1.DiscountValueType.PERCENTAGE) {
+                    minValue = maxValue - (maxValue * discount) / 100;
+                }
+                else {
+                    minValue = maxValue - discount;
+                }
+                if (minValue < 0)
+                    minValue = 0;
+                const collectionProduct = collectionProductMap.get(product.id);
+                return {
+                    productId: product.id,
+                    ...product,
+                    productMinPrice: minValue,
+                    productMaxPrice: maxValue,
+                    id: collectionProduct?.id ?? '',
+                };
+            });
+            return {
+                products: products,
+                totalProductCount: Number(totalCount),
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+};
+CollectionDetailUseCase = __decorate([
+    (0, common_1.Provider)({
+        token: shared_1.COLLECTION_INJECT_TOKENS.USECASE.COLLECTION_GET_DETAIL,
+        scope: common_1.Lifecycle.Transient,
+    }),
+    __param(0, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.COLLECTION)),
+    __param(1, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.PRODUCT_COLLECTION)),
+    __param(2, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.POST_COLLECTION)),
+    __param(3, (0, common_1.Inject)(shared_1.COMPONENT_INJECT_TOKENS.SERVICE.UGC_MANAGEMENT_SERVICE)),
+    __param(4, (0, common_1.Inject)(shared_1.COMPONENT_INJECT_TOKENS.SERVICE.PRODUCT_SERVICE)),
+    __param(5, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.USECASE.GET_AMBASSADOR_BY_ID)),
+    __param(6, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.POST_PRODUCT)),
+    __metadata("design:paramtypes", [infra_1.CollectionDao,
+        infra_1.ProductCollectionDao,
+        infra_1.PostCollectionDao, Object, Object, Object, Object])
+], CollectionDetailUseCase);
+exports.CollectionDetailUseCase = CollectionDetailUseCase;

package/dist/app/usecases/query/get-list-collection.usecase.d.ts

@@ -0,0 +1,23 @@
+import { IUseCase, PaginationInput, UseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+import { CollectionDto } from '../../../domain';
+import { CollectionDao } from '../../../infra';
+import { IGetDetailCollectionUseCase } from './get-detail-collection.usecase';
+type GetListCollectionUseCaseInput = PaginationInput<CollectionDto> & {
+    ambassadorId?: string;
+};
+type GetListCollectionUseCaseOutput = {
+    totalCount: number;
+    items: Partial<CollectionDto>[];
+};
+export type IGetListCollectionUseCase = IUseCase<GetListCollectionUseCaseInput, GetListCollectionUseCaseOutput, UseCaseContext>;
+export declare class CollectionListUseCase<I extends GetListCollectionUseCaseInput = GetListCollectionUseCaseInput, O extends GetListCollectionUseCaseOutput = GetListCollectionUseCaseOutput, C extends UseCaseContext = UseCaseContext> extends UseCase<I, O, C> implements IGetListCollectionUseCase {
+    protected readonly collectionDao: CollectionDao;
+    protected readonly getDetailCollectionUsecase: IGetDetailCollectionUseCase;
+    constructor(collectionDao: CollectionDao, getDetailCollectionUsecase: IGetDetailCollectionUseCase);
+    processing: (input: GetListCollectionUseCaseInput) => Promise<{
+        totalCount: number;
+        items: Partial<CollectionDto>[];
+    }>;
+    sortCollections(collections: Partial<CollectionDto>[]): Partial<CollectionDto>[];
+}
+export {};

package/dist/app/usecases/query/get-list-collection.usecase.js

@@ -0,0 +1,96 @@
+"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.CollectionListUseCase = void 0;
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../../shared");
+const domain_1 = require("../../../domain");
+const infra_1 = require("../../../infra");
+let CollectionListUseCase = class CollectionListUseCase extends aqua_ddd_1.UseCase {
+    constructor(collectionDao, getDetailCollectionUsecase) {
+        super();
+        this.collectionDao = collectionDao;
+        this.getDetailCollectionUsecase = getDetailCollectionUsecase;
+        this.processing = async (input) => {
+            const { ambassadorId } = input;
+            const [totalCount, items] = await Promise.all([
+                this.collectionDao.count(input, {
+                    tenantId: this.context.tenantId,
+                }),
+                this.collectionDao.find(input, {
+                    tenantId: this.context.tenantId,
+                }),
+            ]);
+            if (!!ambassadorId) {
+                return {
+                    totalCount,
+                    items: this.sortCollections(items),
+                };
+            }
+            const postCollection = items.find((col) => col.collectionType === domain_1.CollectionTypeEnum.POSTS);
+            if (!postCollection?.id) {
+                return {
+                    totalCount,
+                    items: this.sortCollections(items),
+                };
+            }
+            const collectionPosts = await this.getDetailCollectionUsecase.exec({
+                id: postCollection?.id,
+                needLinkedProduct: true,
+            });
+            const filteredItems = collectionPosts.posts.length === 0
+                ? items.filter((col) => col.id !== collectionPosts.collection.id)
+                : items;
+            return {
+                totalCount,
+                items: this.sortCollections(filteredItems),
+            };
+        };
+        this.setMethods(this.processing);
+    }
+    sortCollections(collections) {
+        const order = {
+            [domain_1.CollectionTypeEnum.ALL]: 0,
+            [domain_1.CollectionTypeEnum.POSTS]: 1,
+            [domain_1.CollectionTypeEnum.OTHERS]: 2,
+        };
+        return collections.sort((a, b) => {
+            const aType = a.collectionType ?? domain_1.CollectionTypeEnum.OTHERS;
+            const bType = b.collectionType ?? domain_1.CollectionTypeEnum.OTHERS;
+            const aOrder = order[aType] ?? 2;
+            const bOrder = order[bType] ?? 2;
+            if (aOrder !== bOrder) {
+                return aOrder - bOrder;
+            }
+            // Ưu tiên isFavorite === true
+            if (a.isFavorite !== b.isFavorite) {
+                return b.isFavorite ? 1 : -1;
+            }
+            const aDate = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+            const bDate = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+            return bDate - aDate;
+        });
+    }
+};
+CollectionListUseCase = __decorate([
+    (0, common_1.Provider)({
+        token: shared_1.COLLECTION_INJECT_TOKENS.USECASE.COLLECTION_GET_LIST,
+        scope: common_1.Lifecycle.Transient,
+    }),
+    __param(0, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.COLLECTION)),
+    __param(1, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.USECASE.COLLECTION_GET_DETAIL)),
+    __metadata("design:paramtypes", [infra_1.CollectionDao, Object])
+], CollectionListUseCase);
+exports.CollectionListUseCase = CollectionListUseCase;

package/dist/app/usecases/query/get-products-by-collections-internal.usecase.d.ts

@@ -0,0 +1,19 @@
+import { IUseCase, PaginationInput, UseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+import { CollectionDao, ProductCollectionDao } from '../../../infra';
+import { ProductCollectionDto } from '../../../domain';
+type GetProductsByCollectionInternalUseCaseInput = PaginationInput<ProductCollectionDto>;
+type GetProductsByCollectionInternalUseCaseOutput = {
+    totalCount: number;
+    items: Partial<ProductCollectionDto>[];
+};
+export type IGetProductsByCollectionInternalUseCase = IUseCase<GetProductsByCollectionInternalUseCaseInput, GetProductsByCollectionInternalUseCaseOutput, UseCaseContext>;
+export declare class GetProductsByCollectionInternalUseCase<I extends GetProductsByCollectionInternalUseCaseInput = GetProductsByCollectionInternalUseCaseInput, O extends GetProductsByCollectionInternalUseCaseOutput = GetProductsByCollectionInternalUseCaseOutput, C extends UseCaseContext = UseCaseContext> extends UseCase<I, O, C> implements IGetProductsByCollectionInternalUseCase {
+    protected readonly productCollectionDao: ProductCollectionDao;
+    protected readonly collectionDao: CollectionDao;
+    constructor(productCollectionDao: ProductCollectionDao, collectionDao: CollectionDao);
+    processing: (input: GetProductsByCollectionInternalUseCaseInput) => Promise<{
+        totalCount: number;
+        items: ProductCollectionDto[];
+    }>;
+}
+export {};

package/dist/app/usecases/query/get-products-by-collections-internal.usecase.js

@@ -0,0 +1,65 @@
+"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.GetProductsByCollectionInternalUseCase = void 0;
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../../shared");
+const infra_1 = require("../../../infra");
+const domain_1 = require("../../../domain");
+let GetProductsByCollectionInternalUseCase = class GetProductsByCollectionInternalUseCase extends aqua_ddd_1.UseCase {
+    constructor(productCollectionDao, collectionDao) {
+        super();
+        this.productCollectionDao = productCollectionDao;
+        this.collectionDao = collectionDao;
+        this.processing = async (input) => {
+            const { filter } = input;
+            const { collectionId: filterCollectionId } = filter || {};
+            if (filterCollectionId) {
+                const filterGetCollections = { id: filterCollectionId };
+                const collections = await this.collectionDao.find({
+                    filter: filterGetCollections,
+                });
+                const existedAll = collections.find((col) => col.collectionType === domain_1.CollectionTypeEnum.ALL);
+                if (existedAll) {
+                    input.filter = { ambassadorId: { $eq: existedAll.ambassadorId } };
+                }
+            }
+            const [totalCount, items] = await Promise.all([
+                this.productCollectionDao.count(input, {
+                    tenantId: this.context.tenantId,
+                }),
+                this.productCollectionDao.find(input, {
+                    tenantId: this.context.tenantId,
+                }),
+            ]);
+            return {
+                totalCount: Number(totalCount),
+                items: items,
+            };
+        };
+        this.setMethods(this.processing);
+    }
+};
+GetProductsByCollectionInternalUseCase = __decorate([
+    (0, common_1.Provider)({
+        token: shared_1.COLLECTION_INJECT_TOKENS.USECASE.GET_PRODUCTS_BY_COLLECTIONS_INTERNAL,
+        scope: common_1.Lifecycle.Transient,
+    }),
+    __param(0, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.PRODUCT_COLLECTION)),
+    __param(1, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.COLLECTION)),
+    __metadata("design:paramtypes", [infra_1.ProductCollectionDao,
+        infra_1.CollectionDao])
+], GetProductsByCollectionInternalUseCase);
+exports.GetProductsByCollectionInternalUseCase = GetProductsByCollectionInternalUseCase;

package/dist/app/usecases/query/get-products-by-collections.usecase.d.ts

@@ -0,0 +1,44 @@
+import { IUseCase, PaginationInput, UseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+import type { ShopifyProduct, IProductService, IPostProductDao, IGetAmbassadorByIdUseCase } from '../../../shared';
+import { CollectionDao, ProductCollectionDao } from '../../../infra';
+type GetProductsByCollectionUseCaseInput = PaginationInput & {
+    ambassadorId: string;
+};
+type GetProductsByCollectionUseCaseOutput = {
+    totalCount: number;
+    items: Partial<ShopifyProduct>[];
+};
+export type IGetProductsByCollectionUseCase = IUseCase<GetProductsByCollectionUseCaseInput, GetProductsByCollectionUseCaseOutput, UseCaseContext>;
+export declare class GetProductsByCollectionUseCase<I extends GetProductsByCollectionUseCaseInput = GetProductsByCollectionUseCaseInput, O extends GetProductsByCollectionUseCaseOutput = GetProductsByCollectionUseCaseOutput, C extends UseCaseContext = UseCaseContext> extends UseCase<I, O, C> implements IGetProductsByCollectionUseCase {
+    protected readonly collectionDao: CollectionDao;
+    protected readonly productCollectionDao: ProductCollectionDao;
+    protected readonly postProductDao: IPostProductDao;
+    protected readonly productService: IProductService;
+    protected readonly getAbsByIdUsecase: IGetAmbassadorByIdUseCase;
+    constructor(collectionDao: CollectionDao, productCollectionDao: ProductCollectionDao, postProductDao: IPostProductDao, productService: IProductService, getAbsByIdUsecase: IGetAmbassadorByIdUseCase);
+    processing: (input: GetProductsByCollectionUseCaseInput) => Promise<{
+        totalCount: number;
+        items: {
+            productMinPrice: number;
+            productMaxPrice: number;
+            id: string;
+            productId: string;
+            productName: string;
+            productShopifyId: string;
+            productUrl: string;
+            productDescription: string;
+            productImage: string;
+            productMedia: {
+                node: {
+                    url: string;
+                };
+            }[];
+            productStatus: string;
+            createdAt: string;
+            updatedAt: string;
+            collectionId?: string | undefined;
+            collectionName: string;
+        }[];
+    }>;
+}
+export {};