@buunguyen3589/collections-module 1.0.0

package/dist/domain/repositories/collection.repository.js

@@ -0,0 +1,93 @@
+"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.CollectionRepository = 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");
+let CollectionRepository = class CollectionRepository extends aqua_ddd_1.BaseRepository {
+    constructor(db, collectionDao, collectionMapper) {
+        super({ db });
+        this.db = db;
+        this.collectionDao = collectionDao;
+        this.collectionMapper = collectionMapper;
+    }
+    async create(entity, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dto = await this.collectionMapper.fromEntityToDto(entity);
+            await this.collectionDao.create(dto, { ...options, trx });
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async createList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dtos = await this.collectionMapper.fromEntitiesToDtos(entities);
+            await this.collectionDao.createList(dtos, { ...options, trx });
+        }, options);
+        entities.forEach((entity) => entity.dispatchDomainEvents);
+        return entities;
+    }
+    async update(entity, options) {
+        await this.withTransaction(async (trx) => {
+            const dto = await this.collectionMapper.fromEntityToDto(entity);
+            await this.collectionDao.updateById(dto.id, dto, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async updateList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dtos = await this.collectionMapper.fromEntitiesToDtos(entities);
+            await this.collectionDao.updateList(dtos, { ...options, trx });
+        }, options);
+        entities.forEach((entity) => entity.dispatchDomainEvents);
+        return entities;
+    }
+    async delete(entity, options) {
+        await this.withTransaction(async (trx) => {
+            await this.collectionDao.deleteById(entity.id, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async deleteList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            entities.forEach((entity) => entity.dispatchDomainEvents());
+            await this.collectionDao.deleteList(entities.map((entity) => entity.id), { ...options, trx });
+        }, options);
+        return entities;
+    }
+    async find(input, options) {
+        const dtos = await this.collectionDao.find(input, options);
+        const entities = await this.collectionMapper.fromDtosToEntities(dtos);
+        return entities;
+    }
+    async findOne(input, options) {
+        const dto = await this.collectionDao.findOne(input, options);
+        const entity = dto ? await this.collectionMapper.fromDtoToEntity(dto) : dto;
+        return entity;
+    }
+};
+CollectionRepository = __decorate([
+    (0, common_1.Repository)({ token: shared_1.COLLECTION_INJECT_TOKENS.REPOSITORY.COLLECTION, scope: common_1.Lifecycle.Singleton }),
+    __param(0, (0, common_1.DataSource)()),
+    __param(1, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.COLLECTION)),
+    __param(2, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.MAPPER.COLLECTION)),
+    __metadata("design:paramtypes", [Object, infra_1.CollectionDao, Object])
+], CollectionRepository);
+exports.CollectionRepository = CollectionRepository;

package/dist/domain/repositories/index.d.ts

@@ -0,0 +1,3 @@
+export * from './collection.repository';
+export * from './product-collection.repository';
+export * from './post-collection.repository';

package/dist/domain/repositories/index.js

@@ -0,0 +1,19 @@
+"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("./collection.repository"), exports);
+__exportStar(require("./product-collection.repository"), exports);
+__exportStar(require("./post-collection.repository"), exports);

package/dist/domain/repositories/post-collection.repository.d.ts

@@ -0,0 +1,21 @@
+import { BaseRepository, IDatabase, IRepository, QueryInput, QueryInputFindOne, RepositoryOptions } from '@cbidigital/aqua-ddd';
+import { Optional } from '@heronjs/common';
+import { IPostCollection } from '../entities';
+import { PostCollectionDao } from '../../infra';
+import { PostCollectionMapper } from '../mappers';
+export interface IPostCollectionRepository extends IRepository<IPostCollection, RepositoryOptions> {
+}
+export declare class PostCollectionRepository extends BaseRepository<IPostCollection> implements IPostCollectionRepository {
+    protected readonly db: IDatabase;
+    protected readonly postCollectionDao: PostCollectionDao;
+    protected readonly postCollectionMapper: PostCollectionMapper;
+    constructor(db: IDatabase, postCollectionDao: PostCollectionDao, postCollectionMapper: PostCollectionMapper);
+    create(entity: IPostCollection, options?: RepositoryOptions): Promise<IPostCollection>;
+    update(entity: IPostCollection, options?: RepositoryOptions): Promise<IPostCollection>;
+    upsert(entity: IPostCollection, options?: RepositoryOptions): Promise<IPostCollection>;
+    upsertList(entities: IPostCollection[], options?: RepositoryOptions): Promise<IPostCollection[]>;
+    delete(entity: IPostCollection, options?: RepositoryOptions): Promise<IPostCollection>;
+    find(input: QueryInput, options?: RepositoryOptions): Promise<IPostCollection[]>;
+    findOne(input: QueryInputFindOne, options?: RepositoryOptions): Promise<Optional<IPostCollection>>;
+    deleteList(entities: IPostCollection[], options?: RepositoryOptions): Promise<IPostCollection[]>;
+}

package/dist/domain/repositories/post-collection.repository.js

@@ -0,0 +1,107 @@
+"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.PostCollectionRepository = 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 mappers_1 = require("../mappers");
+let PostCollectionRepository = class PostCollectionRepository extends aqua_ddd_1.BaseRepository {
+    constructor(db, postCollectionDao, postCollectionMapper) {
+        super({ db });
+        this.db = db;
+        this.postCollectionDao = postCollectionDao;
+        this.postCollectionMapper = postCollectionMapper;
+    }
+    async create(entity, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dto = await this.postCollectionMapper.fromEntityToDto(entity);
+            await this.postCollectionDao.create(dto, { ...options, trx });
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async update(entity, options) {
+        await this.withTransaction(async (trx) => {
+            const dto = await this.postCollectionMapper.fromEntityToDto(entity);
+            await this.postCollectionDao.updateById(dto.id, dto, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async upsert(entity, options) {
+        try {
+            await this.withTransaction(async (trx) => {
+                const dto = await this.postCollectionMapper.fromEntityToDto(entity);
+                await this.postCollectionDao.upsert(dto, { ...options, trx });
+                return entity;
+            }, options);
+            entity.dispatchDomainEvents();
+            return entity;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async upsertList(entities, options) {
+        try {
+            await this.withTransaction(async (trx) => {
+                const dto = await this.postCollectionMapper.fromEntitiesToDtos(entities);
+                await this.postCollectionDao.upsertList(dto, { ...options, trx });
+                return entities;
+            }, options);
+            entities.forEach((entity) => entity.dispatchDomainEvents());
+            return entities;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async delete(entity, options) {
+        await this.withTransaction(async (trx) => {
+            await this.postCollectionDao.deleteById(entity.id, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async find(input, options) {
+        const dtos = await this.postCollectionDao.find(input, options);
+        const entities = await this.postCollectionMapper.fromDtosToEntities(dtos);
+        return entities;
+    }
+    async findOne(input, options) {
+        const dto = await this.postCollectionDao.findOne(input, options);
+        const entity = dto ? await this.postCollectionMapper.fromDtoToEntity(dto) : dto;
+        return entity;
+    }
+    async deleteList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            entities.forEach((entity) => entity.dispatchDomainEvents());
+            await this.postCollectionDao.deleteList(entities.map((entity) => entity.id), { ...options, trx });
+        }, options);
+        return entities;
+    }
+};
+PostCollectionRepository = __decorate([
+    (0, common_1.Repository)({ token: shared_1.COLLECTION_INJECT_TOKENS.REPOSITORY.POST_COLLECTION, scope: common_1.Lifecycle.Singleton }),
+    __param(0, (0, common_1.DataSource)()),
+    __param(1, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.DAO.POST_COLLECTION)),
+    __param(2, (0, common_1.Inject)(shared_1.COLLECTION_INJECT_TOKENS.MAPPER.POST_COLLECTION)),
+    __metadata("design:paramtypes", [Object, infra_1.PostCollectionDao,
+        mappers_1.PostCollectionMapper])
+], PostCollectionRepository);
+exports.PostCollectionRepository = PostCollectionRepository;

package/dist/domain/repositories/product-collection.repository.d.ts

@@ -0,0 +1,21 @@
+import { BaseRepository, IDatabase, IRepository, QueryInput, QueryInputFindOne, RepositoryOptions } from '@cbidigital/aqua-ddd';
+import { Optional } from '@heronjs/common';
+import { ProductCollectionDao } from '../../infra';
+import { IProductCollection } from '../entities';
+import { IProductCollectionMapper } from '../mappers';
+export interface IProductCollectionRepository extends IRepository<IProductCollection, RepositoryOptions> {
+}
+export declare class ProductCollectionRepository extends BaseRepository<IProductCollection> implements IProductCollectionRepository {
+    protected readonly db: IDatabase;
+    protected readonly productCollectionDao: ProductCollectionDao;
+    protected readonly productCollectionMapper: IProductCollectionMapper;
+    constructor(db: IDatabase, productCollectionDao: ProductCollectionDao, productCollectionMapper: IProductCollectionMapper);
+    create(entity: IProductCollection, options?: RepositoryOptions): Promise<IProductCollection>;
+    createList(entities: IProductCollection[], options?: RepositoryOptions): Promise<IProductCollection[]>;
+    update(entity: IProductCollection, options?: RepositoryOptions): Promise<IProductCollection>;
+    updateList(entities: IProductCollection[], options?: RepositoryOptions): Promise<IProductCollection[]>;
+    delete(entity: IProductCollection, options?: RepositoryOptions): Promise<IProductCollection>;
+    deleteList(entities: IProductCollection[], options?: RepositoryOptions): Promise<IProductCollection[]>;
+    find(input: QueryInput, options?: RepositoryOptions): Promise<IProductCollection[]>;
+    findOne(input: QueryInputFindOne, options?: RepositoryOptions): Promise<Optional<IProductCollection>>;
+}

package/dist/domain/repositories/product-collection.repository.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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCollectionRepository = 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");
+let ProductCollectionRepository = class ProductCollectionRepository extends aqua_ddd_1.BaseRepository {
+    constructor(db, productCollectionDao, productCollectionMapper) {
+        super({ db });
+        this.db = db;
+        this.productCollectionDao = productCollectionDao;
+        this.productCollectionMapper = productCollectionMapper;
+    }
+    async create(entity, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dto = await this.productCollectionMapper.fromEntityToDto(entity);
+            await this.productCollectionDao.create(dto, { ...options, trx });
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async createList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dtos = await this.productCollectionMapper.fromEntitiesToDtos(entities);
+            await this.productCollectionDao.createList(dtos, { ...options, trx });
+        }, options);
+        entities.forEach((entity) => entity.dispatchDomainEvents());
+        return entities;
+    }
+    async update(entity, options) {
+        await this.withTransaction(async (trx) => {
+            const dto = await this.productCollectionMapper.fromEntityToDto(entity);
+            await this.productCollectionDao.updateById(dto.id, dto, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async updateList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            const dtos = await this.productCollectionMapper.fromEntitiesToDtos(entities);
+            await this.productCollectionDao.updateList(dtos, { ...options, trx });
+        }, options);
+        entities.forEach((entity) => entity.dispatchDomainEvents);
+        return entities;
+    }
+    async delete(entity, options) {
+        await this.withTransaction(async (trx) => {
+            await this.productCollectionDao.deleteById(entity.id, { ...options, trx });
+            return entity;
+        }, options);
+        entity.dispatchDomainEvents();
+        return entity;
+    }
+    async deleteList(entities, options) {
+        await this.db.withTransaction(async (trx) => {
+            entities.forEach((entity) => entity.dispatchDomainEvents());
+            await this.productCollectionDao.deleteList(entities.map((entity) => entity.id), { ...options, trx });
+        }, options);
+        return entities;
+    }
+    async find(input, options) {
+        const dtos = await this.productCollectionDao.find(input, options);
+        const entities = await this.productCollectionMapper.fromDtosToEntities(dtos);
+        return entities;
+    }
+    async findOne(input, options) {
+        const dto = await this.productCollectionDao.findOne(input, options);
+        const entity = dto
+            ? await this.productCollectionMapper.fromDtoToEntity(dto)
+            : dto;
+        return entity;
+    }
+};
+ProductCollectionRepository = __decorate([
+    (0, common_1.Repository)({
+        token: shared_1.COLLECTION_INJECT_TOKENS.REPOSITORY.PRODUCT_COLLECTION,
+        scope: common_1.Lifecycle.Singleton,
+    }),
+    __param(0, (0, common_1.DataSource)()),
+    __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.MAPPER.PRODUCT_COLLECTION)),
+    __metadata("design:paramtypes", [Object, infra_1.ProductCollectionDao, Object])
+], ProductCollectionRepository);
+exports.ProductCollectionRepository = ProductCollectionRepository;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './presentation';
+export * from './collection.module';
+export * from './infra';
+export * from './domain';
+export * from './app';

package/dist/index.js

@@ -0,0 +1,23 @@
+"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("./presentation"), exports);
+__exportStar(require("./collection.module"), exports);
+__exportStar(require("./infra"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./app"), exports);
+// Note: shared folder is not exported at the top level to avoid conflicts
+// When using the module as npm package, import from './shared' directly if needed

package/dist/infra/daos/collection.dao.d.ts

@@ -0,0 +1,7 @@
+import { BaseDao, IBaseDao, IDatabase } from '@cbidigital/aqua-ddd';
+import { CollectionDto } from '../../domain';
+import { CollectionRecord } from '../records';
+export type ICollectionDao = IBaseDao<CollectionDto, CollectionRecord>;
+export declare class CollectionDao extends BaseDao<CollectionDto, CollectionRecord> implements ICollectionDao {
+    constructor(db: IDatabase);
+}

package/dist/infra/daos/collection.dao.js

@@ -0,0 +1,36 @@
+"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.CollectionDao = void 0;
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../shared");
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const mappers_1 = require("../mappers");
+const query_configs_1 = require("../query-configs");
+let CollectionDao = class CollectionDao extends aqua_ddd_1.BaseDao {
+    constructor(db) {
+        super({
+            db,
+            tableName: shared_1.COLLECTION_TABLE_NAMES.COLLECTION,
+            recordMapper: new mappers_1.CollectionRecordMapper(),
+            queryConfig: query_configs_1.CollectionQueryConfig,
+        });
+    }
+};
+CollectionDao = __decorate([
+    (0, common_1.Dao)({ token: shared_1.COLLECTION_INJECT_TOKENS.DAO.COLLECTION, scope: common_1.Lifecycle.Singleton }),
+    __param(0, (0, common_1.DataSource)()),
+    __metadata("design:paramtypes", [Object])
+], CollectionDao);
+exports.CollectionDao = CollectionDao;

package/dist/infra/daos/index.d.ts

@@ -0,0 +1,3 @@
+export * from './collection.dao';
+export * from './product-collection.dao';
+export * from './post-collection.dao';

package/dist/infra/daos/index.js

@@ -0,0 +1,19 @@
+"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("./collection.dao"), exports);
+__exportStar(require("./product-collection.dao"), exports);
+__exportStar(require("./post-collection.dao"), exports);

package/dist/infra/daos/post-collection.dao.d.ts

@@ -0,0 +1,10 @@
+import { BaseDao, IBaseDao, IDatabase, RepositoryOptions } from '@cbidigital/aqua-ddd';
+import { PostCollectionDto } from '../../domain';
+import { PostCollectionRecord } from '../records';
+export type IPostCollectionDao = IBaseDao<PostCollectionDto, PostCollectionRecord>;
+export declare class PostCollectionDao extends BaseDao<PostCollectionDto, PostCollectionRecord> implements IPostCollectionDao {
+    private readonly postCollectionRecordMapper;
+    constructor(db: IDatabase);
+    upsert(dto: Partial<PostCollectionDto>, options?: RepositoryOptions): Promise<Partial<PostCollectionDto>>;
+    findPostsLinkedProduct(collectionId: string, options?: RepositoryOptions): Promise<PostCollectionDto[]>;
+}

package/dist/infra/daos/post-collection.dao.js

@@ -0,0 +1,70 @@
+"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.PostCollectionDao = void 0;
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../shared");
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const mappers_1 = require("../mappers");
+const query_configs_1 = require("../query-configs");
+let PostCollectionDao = class PostCollectionDao extends aqua_ddd_1.BaseDao {
+    constructor(db) {
+        super({
+            db,
+            tableName: shared_1.COLLECTION_TABLE_NAMES.POST_COLLECTION,
+            recordMapper: new mappers_1.PostCollectionRecordMapper(),
+            queryConfig: query_configs_1.PostCollectionQueryConfig,
+        });
+        this.postCollectionRecordMapper = new mappers_1.PostCollectionRecordMapper();
+    }
+    async upsert(dto, options = {}) {
+        return this.db.withTransaction(async (trx, client) => {
+            const record = this.postCollectionRecordMapper.fromDtoToRecord(dto);
+            const query = client
+                .from(this.tableName)
+                .insert(record)
+                .onConflict(['ambassador_id', 'collection_id', 'post_id'])
+                .merge();
+            if (trx)
+                query.transacting(trx);
+            await query;
+            return dto;
+        }, options);
+    }
+    async findPostsLinkedProduct(collectionId, options = {}) {
+        const tenantId = options?.tenantId;
+        const client = this.db.getClient(tenantId);
+        const query = client
+            .select([
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION}.post_id`,
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION}.hidden`,
+        ])
+            .from({ [shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION]: this.tableName })
+            .join({ [shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_PRODUCT]: shared_1.COLLECTION_TABLE_NAMES.POST_PRODUCT }, `${[shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION]}.post_id`, `${[shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_PRODUCT]}.post_id`)
+            .where(`${shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION}.collection_id`, collectionId)
+            .groupBy([
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION}.post_id`,
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.POST_COLLECTION}.hidden`,
+        ]);
+        const records = await query;
+        const dtos = this.postCollectionRecordMapper.fromRecordsToDtos(records);
+        return dtos;
+    }
+};
+PostCollectionDao = __decorate([
+    (0, common_1.Dao)({ token: shared_1.COLLECTION_INJECT_TOKENS.DAO.POST_COLLECTION, scope: common_1.Lifecycle.Singleton }),
+    __param(0, (0, common_1.DataSource)()),
+    __metadata("design:paramtypes", [Object])
+], PostCollectionDao);
+exports.PostCollectionDao = PostCollectionDao;

package/dist/infra/daos/product-collection.dao.d.ts

@@ -0,0 +1,9 @@
+import { BaseDao, IBaseDao, IDatabase, QueryInput, RepositoryOptions } from '@cbidigital/aqua-ddd';
+import { ProductCollectionDto } from '../../domain';
+import { ProductCollectionRecord } from '../records';
+export type IProductCollectionDao = IBaseDao<ProductCollectionDto, ProductCollectionRecord>;
+export declare class ProductCollectionDao extends BaseDao<ProductCollectionDto, ProductCollectionRecord> implements IProductCollectionDao {
+    constructor(db: IDatabase);
+    find(payload?: QueryInput<ProductCollectionDto>, options?: RepositoryOptions): Promise<ProductCollectionDto[]>;
+    count(payload?: QueryInput<ProductCollectionDto>, options?: RepositoryOptions): Promise<number>;
+}

package/dist/infra/daos/product-collection.dao.js

@@ -0,0 +1,69 @@
+"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.ProductCollectionDao = void 0;
+const common_1 = require("@heronjs/common");
+const shared_1 = require("../../shared");
+const aqua_ddd_1 = require("@cbidigital/aqua-ddd");
+const mappers_1 = require("../mappers");
+const query_configs_1 = require("../query-configs");
+let ProductCollectionDao = class ProductCollectionDao extends aqua_ddd_1.BaseDao {
+    constructor(db) {
+        super({
+            db,
+            tableName: shared_1.COLLECTION_TABLE_NAMES.PRODUCT_COLLECTION,
+            recordMapper: new mappers_1.ProductCollectionRecordMapper(),
+            queryConfig: query_configs_1.ProductCollectionQueryConfig,
+        });
+    }
+    async find(payload, options) {
+        const { sort } = payload ?? {};
+        const tenantId = options?.tenantId;
+        const client = this.db.getClient(tenantId);
+        const query = client
+            .select([
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION}.* `,
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.COLLECTION}.collection_name `,
+        ])
+            .from({ [shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION]: this.tableName })
+            .leftJoin({ [shared_1.COLLECTION_TABLE_NAMES_ALIAS.COLLECTION]: shared_1.COLLECTION_TABLE_NAMES.COLLECTION }, `${[shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION]}.collection_id`, `${[shared_1.COLLECTION_TABLE_NAMES_ALIAS.COLLECTION]}.id`)
+            .groupBy([
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION}.id`,
+            `${shared_1.COLLECTION_TABLE_NAMES_ALIAS.COLLECTION}.collection_name`,
+        ]);
+        if (payload?.filter !== undefined)
+            aqua_ddd_1.DaoUtils.applyFilter(payload.filter, this.queryConfig, query);
+        const records = await query;
+        const dtos = this.recordMapper.fromRecordsToDtos(records);
+        return dtos;
+    }
+    async count(payload, options) {
+        const tenantId = options?.tenantId;
+        const client = this.db.getClient(tenantId);
+        const query = client
+            .select(client.raw(`count(distinct ${shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION}.id) as total_count`))
+            .from({ [shared_1.COLLECTION_TABLE_NAMES_ALIAS.PRODUCT_COLLECTION]: this.tableName })
+            .first();
+        if (payload?.filter !== undefined)
+            aqua_ddd_1.DaoUtils.applyFilter(payload.filter, this.queryConfig, query);
+        const record = await query;
+        return Number(record?.total_count);
+    }
+};
+ProductCollectionDao = __decorate([
+    (0, common_1.Dao)({ token: shared_1.COLLECTION_INJECT_TOKENS.DAO.PRODUCT_COLLECTION, scope: common_1.Lifecycle.Singleton }),
+    __param(0, (0, common_1.DataSource)()),
+    __metadata("design:paramtypes", [Object])
+], ProductCollectionDao);
+exports.ProductCollectionDao = ProductCollectionDao;

package/dist/infra/event-handlers/collection.event-emitter.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent, IAggregateRoot, IDomainEventEmitter } from '@cbidigital/aqua-ddd';
+export declare class CollectionDomainEventEmitter<T extends IAggregateRoot> implements IDomainEventEmitter<T> {
+    private readonly logger;
+    constructor();
+    emit(name: string, data?: DomainEvent<T>): void;
+}