@buunguyen3589/collections-module 1.0.0

package/dist/shared/core/filter.js

@@ -0,0 +1,554 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filter = exports.FilterTypes = exports.Operator = void 0;
+var Operator;
+(function (Operator) {
+    Operator["EQUAL"] = "eq";
+    Operator["NOT_EQUAL"] = "neq";
+    Operator["NULL"] = "null";
+    Operator["NOT_NULL"] = "nnull";
+    Operator["LESS_THAN"] = "lt";
+    Operator["LESS_THAN_OR_EQUAL"] = "lte";
+    Operator["GREATER_THAN"] = "gt";
+    Operator["GREATER_THAN_OR_EQUAL"] = "gte";
+    Operator["START_WITH"] = "sw";
+    Operator["END_WITH"] = "ew";
+    Operator["CONTAIN"] = "ct";
+    Operator["IS"] = "is";
+    Operator["IS_NOT"] = "isnot";
+    Operator["IN"] = "in";
+    Operator["NIN"] = "nin";
+    Operator["AND:EQUAL"] = "a:eq";
+    Operator["AND:NOT_EQUAL"] = "a:neq";
+    Operator["AND:NULL"] = "a:null";
+    Operator["AND:NOT_NULL"] = "a:nnull";
+    Operator["AND:LESS_THAN"] = "a:lt";
+    Operator["AND:LESS_THAN_OR_EQUAL"] = "a:lte";
+    Operator["AND:GREATER_THAN"] = "a:gt";
+    Operator["AND:GREATER_THAN_OR_EQUAL"] = "a:gte";
+    Operator["AND:START_WITH"] = "a:sw";
+    Operator["AND:END_WITH"] = "a:ew";
+    Operator["AND:CONTAIN"] = "a:ct";
+    Operator["AND:IS"] = "a:is";
+    Operator["AND:IS_NOT"] = "a:isnot";
+    Operator["OR:EQUAL"] = "o:eq";
+    Operator["OR:NOT_EQUAL"] = "o:neq";
+    Operator["OR:NULL"] = "o:null";
+    Operator["OR:NOT_NULL"] = "o:nnull";
+    Operator["OR:LESS_THAN"] = "o:lt";
+    Operator["OR:LESS_THAN_OR_EQUAL"] = "o:lte";
+    Operator["OR:GREATER_THAN"] = "o:gt";
+    Operator["OR:GREATER_THAN_OR_EQUAL"] = "o:gte";
+    Operator["OR:START_WITH"] = "o:sw";
+    Operator["OR:END_WITH"] = "o:ew";
+    Operator["OR:CONTAIN"] = "o:ct";
+    Operator["OR:IS"] = "o:is";
+    Operator["OR:IS_NOT"] = "o:isnot";
+})(Operator = exports.Operator || (exports.Operator = {}));
+var FilterTypes;
+(function (FilterTypes) {
+    FilterTypes[FilterTypes["LOGICAL"] = 0] = "LOGICAL";
+    FilterTypes[FilterTypes["NUMERIC"] = 1] = "NUMERIC";
+    FilterTypes[FilterTypes["STRING"] = 2] = "STRING";
+    FilterTypes[FilterTypes["BOOLEAN"] = 3] = "BOOLEAN";
+    FilterTypes[FilterTypes["ARRAY"] = 4] = "ARRAY";
+})(FilterTypes = exports.FilterTypes || (exports.FilterTypes = {}));
+class Filter {
+    constructor({ type, operator, value, compareField, requiredFields, handler, }) {
+        // Revert transfromation form aqua-ddd
+        operator = operator.replace('$', '');
+        this.type = type;
+        this.operator = operator;
+        this.value = value;
+        this.compareField = compareField;
+        this.requiredFields = requiredFields ?? (this.compareField ? [this.compareField] : undefined);
+        this.handler = handler;
+    }
+    apply(query, compareField, getFieldAlias) {
+        if (!compareField)
+            compareField = this.compareField;
+        if (this.handler) {
+            this.handler(query, this.operator, this.value, compareField);
+            return;
+        }
+        if (this.type === FilterTypes.LOGICAL) {
+            logicalOperatorHandler(query, this.operator, this.value, getFieldAlias);
+        }
+        else if (compareField !== undefined) {
+            if (getFieldAlias)
+                compareField = getFieldAlias(compareField);
+            let value = this.value;
+            // Transform value to array for multiple operators
+            if ([
+                Operator.IS,
+                Operator['AND:IS'],
+                Operator['OR:IS'],
+                Operator.IS_NOT,
+                Operator['AND:IS_NOT'],
+                Operator['OR:IS_NOT'],
+                Operator.IN,
+                Operator.NIN,
+            ].includes(this.operator)) {
+                if (typeof this.value === 'string')
+                    value = this.value.trim().split(',');
+                if (!Array.isArray(value))
+                    throw new Error('Value of multiple operator must is array');
+            }
+            // Process handler of filter
+            switch (this.type) {
+                case FilterTypes.NUMERIC:
+                    numericOperatorHandler(query, this.operator, value, compareField);
+                    break;
+                case FilterTypes.STRING:
+                    stringOperatorHandler(query, this.operator, value, compareField);
+                    break;
+                case FilterTypes.BOOLEAN:
+                    booleanOperatorHandler(query, this.operator, value, compareField);
+                    break;
+                case FilterTypes.ARRAY:
+                    arrayOperatorHandler(query, this.operator, value, compareField);
+                    break;
+            }
+        }
+    }
+}
+exports.Filter = Filter;
+const logicalOperatorHandler = (query, operator, value, getFieldAlias) => {
+    switch (operator) {
+        case 'and': {
+            if (!Array.isArray(value))
+                throw new Error('Value of operator "and" must is filter');
+            value.forEach((childFilter) => {
+                if (childFilter instanceof Filter)
+                    query.where((builder) => {
+                        childFilter.apply(builder, undefined, getFieldAlias);
+                    });
+                else
+                    throw new Error('Value of operator "and" must is array of filter');
+            });
+            break;
+        }
+        case 'or': {
+            if (!Array.isArray(value))
+                throw new Error('Value of operator "or" must is filter');
+            value.forEach((childFilter) => {
+                if (childFilter instanceof Filter)
+                    query.orWhere((builder) => {
+                        childFilter.apply(builder, undefined, getFieldAlias);
+                    });
+                else
+                    throw new Error('Value of operator "or" must is array of filter');
+            });
+            break;
+        }
+        default:
+            throw new Error(`Operator "${operator}" isn't locgical operator`);
+    }
+};
+const numericOperatorHandler = (query, operator, value, compareField) => {
+    switch (operator) {
+        case Operator.EQUAL:
+        case Operator['AND:EQUAL']: {
+            query.where(compareField, '=', value);
+            break;
+        }
+        case Operator.NOT_EQUAL:
+        case Operator['AND:NOT_EQUAL']: {
+            query.where(compareField, '<>', value);
+            break;
+        }
+        case Operator.LESS_THAN:
+        case Operator['AND:LESS_THAN']: {
+            query.where(compareField, '<', value);
+            break;
+        }
+        case Operator.LESS_THAN_OR_EQUAL:
+        case Operator['AND:LESS_THAN_OR_EQUAL']: {
+            query.where(compareField, '<=', value);
+            break;
+        }
+        case Operator.GREATER_THAN:
+        case Operator['AND:GREATER_THAN']: {
+            query.where(compareField, '>', value);
+            break;
+        }
+        case Operator.GREATER_THAN_OR_EQUAL:
+        case Operator['AND:GREATER_THAN_OR_EQUAL']: {
+            query.where(compareField, '>=', value);
+            break;
+        }
+        case Operator.NULL:
+        case Operator['AND:NULL']: {
+            query.whereNull(compareField);
+            break;
+        }
+        case Operator.NOT_NULL:
+        case Operator['AND:NOT_NULL']: {
+            query.whereNotNull(compareField);
+            break;
+        }
+        case Operator['OR:EQUAL']: {
+            query.orWhere(compareField, '=', value);
+            break;
+        }
+        case Operator['OR:NOT_EQUAL']: {
+            query.orWhere(compareField, '<>', value);
+            break;
+        }
+        case Operator['OR:LESS_THAN']: {
+            query.orWhere(compareField, '<', value);
+            break;
+        }
+        case Operator['OR:LESS_THAN_OR_EQUAL']: {
+            query.orWhere(compareField, '<=', value);
+            break;
+        }
+        case Operator['OR:GREATER_THAN']: {
+            query.orWhere(compareField, '>', value);
+            break;
+        }
+        case Operator['OR:GREATER_THAN_OR_EQUAL']: {
+            query.orWhere(compareField, '>=', value);
+            break;
+        }
+        case Operator['OR:NULL']: {
+            query.orWhereNull(compareField);
+            break;
+        }
+        case Operator['OR:NOT_NULL']: {
+            query.orWhereNotNull(compareField);
+            break;
+        }
+        case Operator.IN:
+        case Operator.IS:
+        case Operator['AND:IS']: {
+            query.whereIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS']: {
+            query.orWhereIn(compareField, value);
+            break;
+        }
+        case Operator.NIN:
+        case Operator.IS_NOT:
+        case Operator['AND:IS_NOT']: {
+            query.whereNotIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS_NOT']: {
+            query.orWhereNotIn(compareField, value);
+            break;
+        }
+        default:
+            throw new Error(`Operator "${operator}" isn't numeric operator`);
+    }
+};
+const stringOperatorHandler = (query, operator, value, compareField) => {
+    if (typeof value === 'string')
+        value = value.trim();
+    switch (operator) {
+        case Operator.EQUAL:
+        case Operator['AND:EQUAL']: {
+            query.where(compareField, '=', value);
+            break;
+        }
+        case Operator.NOT_EQUAL:
+        case Operator['AND:NOT_EQUAL']: {
+            query.where(compareField, '<>', value);
+            break;
+        }
+        case Operator.CONTAIN:
+        case Operator['AND:CONTAIN']: {
+            query.whereILike(compareField, `%${value?.trim()}%`);
+            break;
+        }
+        case Operator.START_WITH:
+        case Operator['AND:START_WITH']: {
+            query.whereILike(compareField, `${value}%`);
+            break;
+        }
+        case Operator.END_WITH:
+        case Operator['AND:END_WITH']: {
+            query.whereILike(compareField, `%${value}`);
+            break;
+        }
+        case Operator.NULL:
+        case Operator['AND:NULL']: {
+            query.whereNull(compareField);
+            break;
+        }
+        case Operator.NOT_NULL:
+        case Operator['AND:NOT_NULL']: {
+            query.whereNotNull(compareField);
+            break;
+        }
+        case Operator['OR:EQUAL']: {
+            query.orWhere(compareField, '=', value);
+            break;
+        }
+        case Operator['OR:NOT_EQUAL']: {
+            query.orWhere(compareField, '<>', value);
+            break;
+        }
+        case Operator['OR:CONTAIN']: {
+            query.orWhereILike(compareField, `%${value?.trim()}%`);
+            break;
+        }
+        case Operator['OR:START_WITH']: {
+            query.orWhereILike(compareField, `${value}%`);
+            break;
+        }
+        case Operator['OR:END_WITH']: {
+            query.orWhereILike(compareField, `%${value}`);
+            break;
+        }
+        case Operator['OR:NULL']: {
+            query.orWhereNull(compareField);
+            break;
+        }
+        case Operator['OR:NOT_NULL']: {
+            query.orWhereNotNull(compareField);
+            break;
+        }
+        case Operator.IN:
+        case Operator.IS:
+        case Operator['AND:IS']: {
+            query.whereIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS']: {
+            query.orWhereIn(compareField, value);
+            break;
+        }
+        case Operator.NIN:
+        case Operator.IS_NOT:
+        case Operator['AND:IS_NOT']: {
+            query.whereNotIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS_NOT']: {
+            query.orWhereNotIn(compareField, value);
+            break;
+        }
+        case Operator.LESS_THAN:
+        case Operator['AND:LESS_THAN']: {
+            query.where(compareField, '<', value);
+            break;
+        }
+        case Operator.LESS_THAN_OR_EQUAL:
+        case Operator['AND:LESS_THAN_OR_EQUAL']: {
+            query.where(compareField, '<=', value);
+            break;
+        }
+        case Operator.GREATER_THAN:
+        case Operator['AND:GREATER_THAN']: {
+            query.where(compareField, '>', value);
+            break;
+        }
+        case Operator.GREATER_THAN_OR_EQUAL:
+        case Operator['AND:GREATER_THAN_OR_EQUAL']: {
+            query.where(compareField, '>=', value);
+            break;
+        }
+        case Operator['OR:LESS_THAN']: {
+            query.orWhere(compareField, '<', value);
+            break;
+        }
+        case Operator['OR:LESS_THAN_OR_EQUAL']: {
+            query.orWhere(compareField, '<=', value);
+            break;
+        }
+        case Operator['OR:GREATER_THAN']: {
+            query.orWhere(compareField, '>', value);
+            break;
+        }
+        case Operator['OR:GREATER_THAN_OR_EQUAL']: {
+            query.orWhere(compareField, '>', value);
+            break;
+        }
+        default:
+            throw new Error(`Operator "${operator}" isn't string operator`);
+    }
+};
+const booleanOperatorHandler = (query, operator, value, compareField) => {
+    switch (operator) {
+        case Operator.EQUAL:
+        case Operator['AND:EQUAL']: {
+            query.where(compareField, '=', value);
+            break;
+        }
+        case Operator.NOT_EQUAL:
+        case Operator['AND:NOT_EQUAL']: {
+            query.where(compareField, '<>', value);
+            break;
+        }
+        case Operator.NULL:
+        case Operator['AND:NULL']: {
+            query.whereNull(compareField);
+            break;
+        }
+        case Operator.NOT_NULL:
+        case Operator['AND:NOT_NULL']: {
+            query.whereNotNull(compareField);
+            break;
+        }
+        case Operator['OR:EQUAL']: {
+            query.orWhere(compareField, '=', value);
+            break;
+        }
+        case Operator['OR:NOT_EQUAL']: {
+            query.orWhere(compareField, '<>', value);
+            break;
+        }
+        case Operator['OR:NULL']: {
+            query.orWhereNull(compareField);
+            break;
+        }
+        case Operator['OR:NOT_NULL']: {
+            query.orWhereNotNull(compareField);
+            break;
+        }
+        case Operator.IN:
+        case Operator.IS:
+        case Operator['AND:IS']: {
+            query.whereIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS']: {
+            query.orWhereIn(compareField, value);
+            break;
+        }
+        case Operator.NIN:
+        case Operator.IS_NOT:
+        case Operator['AND:IS_NOT']: {
+            query.whereNotIn(compareField, value);
+            break;
+        }
+        case Operator['OR:IS_NOT']: {
+            query.orWhereNotIn(compareField, value);
+            break;
+        }
+        default:
+            throw new Error(`Operator "${operator}" isn't boolean operator`);
+    }
+};
+const arrayOperatorHandler = (query, operator, value, compareField) => {
+    if (typeof value === 'string')
+        value = value.trim();
+    switch (operator) {
+        case Operator.EQUAL:
+        case Operator['AND:EQUAL']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field = ?)`, [
+                compareField,
+                value,
+            ]);
+            break;
+        }
+        case Operator.NOT_EQUAL:
+        case Operator['AND:NOT_EQUAL']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field <> ?)`, [
+                compareField,
+                value,
+            ]);
+            break;
+        }
+        case Operator.CONTAIN:
+        case Operator['AND:CONTAIN']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [
+                compareField,
+                `%${value}%`,
+            ]);
+            break;
+        }
+        case Operator.START_WITH:
+        case Operator['AND:START_WITH']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [
+                compareField,
+                `${value}%`,
+            ]);
+            break;
+        }
+        case Operator.END_WITH:
+        case Operator['AND:END_WITH']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [
+                compareField,
+                `%${value}`,
+            ]);
+            break;
+        }
+        case Operator.NULL:
+        case Operator['AND:NULL']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field is null ?)`, [compareField, value]);
+            break;
+        }
+        case Operator.NOT_NULL:
+        case Operator['AND:NOT_NULL']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field notnull ?)`, [compareField, value]);
+            break;
+        }
+        case Operator['OR:EQUAL']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field = ?)`, [
+                compareField,
+                value,
+            ]);
+            break;
+        }
+        case Operator['OR:NOT_EQUAL']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field <> ?)`, [
+                compareField,
+                value,
+            ]);
+            break;
+        }
+        case Operator['OR:CONTAIN']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [compareField, `%${value}%`]);
+            break;
+        }
+        case Operator['OR:START_WITH']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [compareField, `${value}%`]);
+            break;
+        }
+        case Operator['OR:END_WITH']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field ilike ?)`, [compareField, `%${value}`]);
+            break;
+        }
+        case Operator['OR:NULL']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field is null ?)`, [compareField, value]);
+            break;
+        }
+        case Operator['OR:NOT_NULL']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field notnull ?)`, [compareField, value]);
+            break;
+        }
+        case Operator.IN:
+        case Operator.IS:
+        case Operator['AND:IS']: {
+            query.whereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field in (${value
+                .map(() => '?')
+                .join(',')}))`, [compareField, ...value]);
+            break;
+        }
+        case Operator['OR:IS']: {
+            query.orWhereRaw(`exists (select 1 from unnest(??) as compare_field where compare_field in (${value
+                .map(() => '?')
+                .join(',')}))`, [compareField, ...value]);
+            break;
+        }
+        case Operator.NIN:
+        case Operator.IS_NOT:
+        case Operator['AND:IS_NOT']: {
+            query.whereRaw(`not exists (select 1 from unnest(??) as compare_field where compare_field in (${value
+                .map(() => '?')
+                .join(',')}))`, [compareField, ...value]);
+            break;
+        }
+        case Operator['OR:IS_NOT']: {
+            query.orWhereRaw(`not exists (select 1 from unnest(??) as compare_field where compare_field in (${value
+                .map(() => '?')
+                .join(',')}))`, [compareField, ...value]);
+            break;
+        }
+        default:
+            throw new Error(`Operator "${operator}" isn't array operator`);
+    }
+};

package/dist/shared/core/index.d.ts

@@ -0,0 +1 @@
+export * from './filter';

package/dist/shared/core/index.js

@@ -0,0 +1,17 @@
+"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("./filter"), exports);

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './configs';
+export * from './core';
+export * from './interfaces';
+export * from './types';

package/dist/shared/index.js

@@ -0,0 +1,21 @@
+"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("./constants"), exports);
+__exportStar(require("./configs"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./types"), exports);

package/dist/shared/interfaces/ambassador-dao.interface.d.ts

@@ -0,0 +1,5 @@
+import { QueryInputFindOne, RepositoryOptions, Optional } from '@cbidigital/aqua-ddd';
+import { AmbassadorDto } from './ambassador-usecase.interface';
+export interface IAmbassadorDao {
+    findOne(payload?: QueryInputFindOne<AmbassadorDto>, options?: RepositoryOptions): Promise<Optional<AmbassadorDto>>;
+}

package/dist/shared/interfaces/ambassador-dao.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/interfaces/ambassador-usecase.interface.d.ts

@@ -0,0 +1,16 @@
+import { IUseCase, UseCaseContext } from '@cbidigital/aqua-ddd';
+export interface AmbassadorDto {
+    id: string;
+    ambassadorDiscountValue?: number;
+    ambassadorDiscountValueType?: string;
+    ambassadorMetric?: Array<{
+        socialUsername?: string;
+        [key: string]: any;
+    }>;
+    [key: string]: any;
+}
+export type GetAmbassadorByIdUseCaseInput = {
+    id: string;
+};
+export type GetAmbassadorByIdUseCaseOutput = Partial<AmbassadorDto>;
+export type IGetAmbassadorByIdUseCase = IUseCase<GetAmbassadorByIdUseCaseInput, GetAmbassadorByIdUseCaseOutput, UseCaseContext>;

package/dist/shared/interfaces/ambassador-usecase.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/interfaces/campaign-service.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ICampaignService {
+    [key: string]: any;
+}

package/dist/shared/interfaces/campaign-service.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+// Interface for Campaign Service
+// This should be implemented by the consuming application
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ambassador-dao.interface';
+export * from './ambassador-usecase.interface';
+export * from './post-product-dao.interface';
+export * from './product-service.interface';
+export * from './ugc-management-service.interface';
+export * from './campaign-service.interface';

package/dist/shared/interfaces/index.js

@@ -0,0 +1,22 @@
+"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("./ambassador-dao.interface"), exports);
+__exportStar(require("./ambassador-usecase.interface"), exports);
+__exportStar(require("./post-product-dao.interface"), exports);
+__exportStar(require("./product-service.interface"), exports);
+__exportStar(require("./ugc-management-service.interface"), exports);
+__exportStar(require("./campaign-service.interface"), exports);

package/dist/shared/interfaces/post-product-dao.interface.d.ts

@@ -0,0 +1,8 @@
+import { IBaseDao } from '@cbidigital/aqua-ddd';
+export interface PostProductDto {
+    id: string;
+    postId: string;
+    productId: string;
+    ambassadorId: string;
+}
+export type IPostProductDao = IBaseDao<PostProductDto, any>;