@infrab4a/connect 6.0.0-alpha.0 → 6.0.0-alpha.1

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-update.helper.d.ts

@@ -0,0 +1,20 @@
+import { NonFunctionPropertyNames, ProductReview, UpdateRepositoryParams } from '../../../../../domain';
+import { UpdateHasuraGraphQLRepositoryType } from '../../../mixins';
+import { ProductHasuraGraphQL } from '../../../models';
+import { GraphQLRepository } from '../../../types';
+interface ReviewUpdateDependencies {
+    mutation: GraphQLRepository<ProductHasuraGraphQL>['mutation'];
+    findReview: (review: ProductReview, productId: number) => Promise<ProductReview>;
+    bindReviewToModel: (plain: Record<'person_id' | 'order_id' | 'created_at' | 'updated_at', any>) => ProductReview;
+    bindReviewToHasura: (review: ProductReview) => any;
+    reviewsFields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+    paramsToPlain: UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>['paramsToPlain'];
+}
+export declare class ProductReviewUpdateHelper {
+    static executeUpdate(productId: number, reviews: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'reviews'>['reviews'], dependencies: ReviewUpdateDependencies): Promise<ProductReview[]>;
+    private static handleRemoveReviews;
+    private static handleUpsertReviews;
+    private static updateExistingReview;
+    private static insertNewReview;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-variant-report.helper.d.ts

@@ -0,0 +1,9 @@
+import { ProductVariantReport } from '../../../../../domain';
+interface VariantReportDependencies {
+    query: (table: string, fields: string[]) => Promise<any>;
+}
+export declare class ProductVariantReportHelper {
+    static getReportFields(): string[];
+    static executeReport(dependencies: VariantReportDependencies): Promise<ProductVariantReport[]>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/index.d.ts

@@ -0,0 +1,12 @@
+export * from './category-collection-children-hasura-graphql.repository';
+export * from './category-filter-hasura-graphql.repository';
+export * from './category-hasura-graphql.repository';
+export * from './category-product-hasura-graphql.repository';
+export * from './filter-hasura-graphql.repository';
+export * from './filter-option-hasura-graphql.repository';
+export * from './product-errors-hasura-graphql.repository';
+export * from './product-hasura-graphql.repository';
+export * from './product-review-hasura-graphql.repository';
+export * from './product-stock-notification-hasura-graphql.repository';
+export * from './variant-hasura-graphql.repository';
+export * from './wishlist-hasura-graphql.repository';

package/src/infra/hasura-graphql/repositories/catalog/product-errors-hasura-graphql.repository.d.ts

@@ -0,0 +1,13 @@
+import { FindRepositoryParams, GetRepositoryParams } from '../../../../domain';
+import { ProductErrorsRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+import { ProductErrorsHasuraGraphQL } from '../../models';
+import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
+declare const ProductErrorsHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductErrorsHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").CrudParams<ProductErrorsHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductErrorsHasuraGraphQL>, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
+    private readonly productRepository;
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository);
+    get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<ProductErrorsHasuraGraphQL>;
+    find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<import("../../../../domain").RepositoryFindResult<ProductErrorsHasuraGraphQL>>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/product-hasura-graphql.repository.d.ts

@@ -0,0 +1,42 @@
+import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, PaginatedReviewFilters, ProductGender, ProductRepository, ProductVariantReport, RepositoryCacheOptions, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+import { ProductHasuraGraphQL } from '../../models';
+declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductHasuraGraphQL, import("../../../../domain").CrudParams<ProductHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>, [HasuraConstructorParams<ProductHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
+    private get reviewsFields();
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
+    create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
+    get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>, options?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<ProductHasuraGraphQL>;
+    find(params?: FindRepositoryParams<ProductHasuraGraphQL>, optionsParams?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
+    getBySlug(slug: string, options?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<ProductHasuraGraphQL>;
+    update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
+    fetchProductReviews(filters: PaginatedReviewFilters, options?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<ReviewWithProductData[]>;
+    fetchReviews(status: ReviewStatusParams, options?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<ReviewWithProductData[]>;
+    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>, options?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
+    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
+    private getReviewStatus;
+    private updateKitProducts;
+    private updateReviews;
+    private updateMetadata;
+    private getId;
+    private findReviewsByProduct;
+    private findReview;
+    private getReviewByPersonId;
+    private getReviewByAuthorAndEmail;
+    private bindReviewToModel;
+    private bindReviewToHasura;
+    productVariantFullReport(): Promise<ProductVariantReport[]>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/product-review-hasura-graphql.repository.d.ts

@@ -0,0 +1,11 @@
+import { ProductReview } from '../../../../domain';
+import { ProductReviewRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const ProductReviewHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductReview> & import("../../../../domain").CrudRepository<ProductReview, import("../../../../domain").CrudParams<ProductReview>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductReview>, [HasuraConstructorParams<ProductReview> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class ProductReviewHasuraGraphQLRepository extends ProductReviewHasuraGraphQLRepository_base implements ProductReviewRepository {
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductReview>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
+    updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void>;
+    aproveReview(id: number): Promise<ProductReview>;
+    disaproveReview(id: number): Promise<ProductReview>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/product-stock-notification-hasura-graphql.repository.d.ts

@@ -0,0 +1,22 @@
+import { Filter, ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, RepositoryFindResult, Shops } from '../../../../domain';
+import { ProductStockNotificationRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+type AddCustomerEmailParams = {
+    shop: Shops;
+    productId: string;
+    name: string;
+    email: string;
+};
+declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductStockNotification> & import("../../../../domain").CrudRepository<ProductStockNotification, import("../../../../domain").CrudParams<ProductStockNotification>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductStockNotification>, [HasuraConstructorParams<ProductStockNotification> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class ProductStockNotificationHasuraGraphQLRepository extends ProductStockNotificationHasuraGraphQLRepository_base implements ProductStockNotificationRepository {
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
+    addCustomerEmail(params: AddCustomerEmailParams): Promise<void>;
+    getNotificationsReport(params: ReportStockNotificationInput, orderBy: {
+        field: string;
+        direction: string;
+    }, pagination?: {
+        offset: number;
+        limit: number;
+    }): Promise<RepositoryFindResult<ReportStockNotification>>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/variant-hasura-graphql.repository.d.ts

@@ -0,0 +1,12 @@
+import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+import { VariantHasuraGraphQL } from '../../models';
+declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<VariantHasuraGraphQL>, [HasuraConstructorParams<VariantHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
+    get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
+    find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
+    update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
+    private getId;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/wishlist-hasura-graphql.repository.d.ts

@@ -0,0 +1,29 @@
+import { Category, CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, Product, RepositoryFindResult, Shops, UpdateRepositoryParams, Wishlist, WishlistRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+import { WishlistHasuraGraphQL } from '../../models/wishlist-hasura-graphql';
+import { CategoryProductHasuraGraphQLRepository } from './category-product-hasura-graphql.repository';
+declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<WishlistHasuraGraphQL> & import("../../../../domain").CrudRepository<WishlistHasuraGraphQL, import("../../../../domain").CrudParams<WishlistHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<WishlistHasuraGraphQL>, [HasuraConstructorParams<WishlistHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class WishlistHasuraGraphQLRepository extends WishlistHasuraGraphQLRepository_base implements WishlistRepository {
+    private readonly categoryProductRepository;
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, categoryProductRepository: CategoryProductHasuraGraphQLRepository);
+    create(params: CreateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
+    get(identifiers: GetRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
+    find(params?: FindRepositoryParams<WishlistHasuraGraphQL>): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
+    update(params: UpdateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
+    getWishlistBySlug(slug: string): Promise<WishlistHasuraGraphQL>;
+    getWishlistByPerson(personId: string): Promise<WishlistHasuraGraphQL[]>;
+    getCategoryBySlug(slug: string, _shop: Shops): Promise<Wishlist>;
+    getCategoryByShop(shop: string): Promise<any>;
+    findBfluOrGlamgirlWishlists(params: FindRepositoryParams<WishlistHasuraGraphQL>, shops: Shops[]): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
+    getCategoriesForHome(): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(): Promise<Product[]>;
+    getChildren(_parentId: number): Promise<Category[]>;
+    isChild(_id: number, _parentId: number): Promise<boolean>;
+    private updateMetadata;
+    addProduct(wishlistId: string, productId: string): Promise<void>;
+    removeProduct(wishlistId: string, productId: string): Promise<void>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/index.d.ts

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

package/src/infra/hasura-graphql/types/fields.type.d.ts

@@ -0,0 +1,2 @@
+import { NestedField } from './nested-field.type';
+export type Fields = Array<string | object | NestedField | 'aggregate' | 'nodes'>;

package/src/infra/hasura-graphql/types/graphql.repository.type.d.ts

@@ -0,0 +1,25 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../domain';
+import { DebugHelper } from '../../../utils';
+import { HasuraGraphQLAuthOptions } from './hasura-graphql-auth-options.type';
+import { HasuraGraphQLFields } from './hasura-graphql-fields.type';
+import { VariableOptions } from './variable-options.type';
+export type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
+    operation: string | IOperation;
+    fields?: HasuraGraphQLFields<Model>;
+    variables?: VariableOptions;
+};
+export type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
+    tableName: string;
+    model: BaseModelBuilder<Model>;
+    fields: HasuraGraphQLFields<Model>;
+    endpoint: string;
+    authOptions: HasuraGraphQLAuthOptions;
+    logger: DebugHelper;
+    cache?: CacheConfig;
+    mutation: <ReturnFields = any>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    query: <ReturnFields = any>(operation: string | IOperation | GraphQLParams<Model>[], fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model;
+    convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>;
+};

package/src/infra/hasura-graphql/types/hasura-graphql-auth-options.type.d.ts

@@ -0,0 +1,8 @@
+export type HasuraGraphQLAuthOptions = {
+    adminSecret?: string;
+    authRole?: {
+        role: string;
+        userId: string;
+    };
+    authToken?: string;
+};

package/src/infra/hasura-graphql/types/hasura-graphql-fields.type.d.ts

@@ -0,0 +1,44 @@
+import { ModelBaseStructure, NestedRepositoryFindFieltersOptions, NonFunctionAndIdentifierPropertyNames, RepositoryFindField } from '../../../domain';
+import { PropType } from '../../../utils';
+import { HasuraGraphQLColumnType } from '../enums';
+export type ColumnOptions<FieldType, Model, ValueFrom = any> = {
+    type?: HasuraGraphQLColumnType;
+    columnName?: string;
+    filters?: {
+        filterType: HasuraGraphQLColumnType | string;
+        filters: NestedRepositoryFindFieltersOptions<FieldType>;
+    };
+    fields?: HasuraGraphQLFields<FieldType>;
+    foreignKeyColumn?: Partial<Record<NonFunctionAndIdentifierPropertyNames<FieldType extends any[] ? FieldType[number] : FieldType>, NonFunctionAndIdentifierPropertyNames<Model> | (string & {})>> | {};
+    from?: (value: ValueFrom | ValueFrom[], data?: any) => FieldType;
+    to?: (value: FieldType, instance?: Model) => ValueFrom;
+    bindFindFilter?: (sentence: RepositoryFindField<Model, keyof Model>) => Record<string, RepositoryFindField<any, any> | ValueFrom> | RepositoryFindField<any, any> | ValueFrom;
+    bindPersistData?: (value: FieldType, instance?: Model) => Record<string, ValueFrom>;
+};
+export type AggregateOptionNames = 'avg' | 'count' | 'max' | 'min' | 'stddev' | 'stddev_pop' | 'stddev_samp' | 'sum' | 'var_pop' | 'var_samp' | 'variance';
+export type AggregateOptionFields<Model, Type, Properties extends keyof Model = keyof Model> = {
+    [K in Properties]: PropType<Model, K> extends Type ? K : never;
+}[Properties] | string;
+export type AggregateOptions<Model> = {
+    avg?: Array<AggregateOptionFields<Model, number>>;
+    max?: Array<AggregateOptionFields<Model, number | Date>>;
+    min?: Array<AggregateOptionFields<Model, number | Date>>;
+    stddev?: Array<AggregateOptionFields<Model, number>>;
+    stddev_pop?: Array<AggregateOptionFields<Model, number>>;
+    stddev_samp?: Array<AggregateOptionFields<Model, number>>;
+    sum?: Array<AggregateOptionFields<Model, number>>;
+    var_pop?: Array<AggregateOptionFields<Model, number>>;
+    var_samp?: Array<AggregateOptionFields<Model, number>>;
+    variance?: Array<AggregateOptionFields<Model, number>>;
+};
+type ModelBaseHasuraGraphQLFields<Model> = Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
+    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGraphQLFields<PropType<Model, key>> : PropType<Model, key> extends any[] ? PropType<Model, key>[] extends ModelBaseStructure[] ? HasuraGraphQLFields<PropType<Model, key>[]> : never : never;
+} | {
+    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate' ? never : PropType<Model, key> extends ModelBaseStructure ? ColumnOptions<PropType<Model, key>, Model> : ColumnOptions<PropType<Model, key>, Model>;
+} | Record<string, ColumnOptions<PropType<Model, any>, Model>> : string;
+export type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
+    aggregate: Array<AggregateOptions<Model> | 'count'>;
+} | {
+    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
+} | 'affected_rows')[];
+export {};

package/src/infra/hasura-graphql/types/hasura-graphql-headers.type.d.ts

@@ -0,0 +1,7 @@
+export type HasuraGraphQLHeaders = {
+    Authorization?: string;
+    'Content-Type': string;
+    'X-Hasura-Admin-Secret'?: string;
+    'X-Hasura-Role'?: string;
+    'X-Hasura-User-Id'?: string;
+};

package/src/infra/hasura-graphql/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './fields.type';
+export * from './graphql.repository.type';
+export * from './nested-field.type';
+export * from './query-builder-options.type';
+export * from './variable-options.type';
+export * from './hasura-graphql-auth-options.type';
+export * from './hasura-graphql-fields.type';
+export * from './hasura-graphql-headers.type';

package/src/infra/hasura-graphql/types/nested-field.type.d.ts

@@ -0,0 +1,7 @@
+import { Fields } from './fields.type';
+import { QueryBuilderOptions } from './query-builder-options.type';
+export type NestedField = {
+    operation: string;
+    variables: QueryBuilderOptions[];
+    fields: Fields;
+};

package/src/infra/hasura-graphql/types/query-builder-options.type.d.ts

@@ -0,0 +1,7 @@
+import { Fields } from './fields.type';
+import { VariableOptions } from './variable-options.type';
+export interface QueryBuilderOptions {
+    operation: string;
+    fields?: Fields;
+    variables?: VariableOptions;
+}

package/src/infra/hasura-graphql/types/variable-options.type.d.ts

@@ -0,0 +1,9 @@
+export type VariableOptions = {
+    type?: string;
+    name?: string;
+    value: any;
+    list?: boolean;
+    required?: boolean;
+} | {
+    [k: string]: any;
+};

package/src/infra/index.d.ts

@@ -0,0 +1,7 @@
+export * from './adyen';
+export * from './cache';
+export * from './elasticsearch';
+export * from './firebase';
+export * from './hasura-graphql';
+export * from './pagarme';
+export * from './vertex-ai';

package/src/infra/pagarme/adapters/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pagarme-blocked-order.helper';
+export * from './pagarme-payment-factory.helper';
+export * from './pagarme-payment-operations.helper';

package/src/infra/pagarme/adapters/helpers/pagarme-blocked-order.helper.d.ts

@@ -0,0 +1,14 @@
+import { Checkout, PaymentCardInfo } from '../../../../domain';
+import { OrderBlockedRepository } from '../../../../domain/shopping/repositories';
+import { PaymentError } from '../../../../errors';
+interface BlockedOrderParams {
+    checkout: Checkout;
+    card: PaymentCardInfo;
+    orderBlockedRepository: OrderBlockedRepository;
+}
+export declare class PagarmeBlockedOrderHelper {
+    static createBlockedOrderForUnauthorizedCard(params: BlockedOrderParams): Promise<void>;
+    static createPaymentError(checkout: Checkout, resultData: any): PaymentError;
+    static createGenericPaymentError(checkout: Checkout, errorResponseData: any): PaymentError;
+}
+export {};

package/src/infra/pagarme/adapters/helpers/pagarme-payment-factory.helper.d.ts

@@ -0,0 +1,11 @@
+import { Checkout, Payment } from '../../../../domain';
+import { PaymentRepository } from '../../../../domain/shopping/repositories';
+interface CreatePaymentParams {
+    checkout: Checkout;
+    resultData: any;
+    paymentRepository: PaymentRepository;
+}
+export declare class PagarmePaymentFactoryHelper {
+    static createSuccessfulPayment(params: CreatePaymentParams): Promise<Payment>;
+}
+export {};

package/src/infra/pagarme/adapters/helpers/pagarme-payment-operations.helper.d.ts

@@ -0,0 +1,12 @@
+import { Checkout, PaymentCardInfo } from '../../../../domain';
+import { PagarmeCredentials } from '../../../../domain/shopping/types';
+interface PaymentRequestParams {
+    checkout: Checkout;
+    card: PaymentCardInfo;
+    credentials: PagarmeCredentials;
+    createPayloadFunction: (checkout: Checkout, card: PaymentCardInfo) => any;
+}
+export declare class PagarmePaymentOperationsHelper {
+    static executePaymentRequest(params: PaymentRequestParams): Promise<any>;
+}
+export {};

package/src/infra/pagarme/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pagarme-bank-slip-payment-axios.adapter';
+export * from './pagarme-card-payment-axios.adapter';
+export * from './pagarme-pix-payment-axios.adapter';

package/src/infra/pagarme/adapters/pagarme-bank-slip-payment-axios.adapter.d.ts

@@ -0,0 +1,12 @@
+import { PaymentProviderBankSlip } from '../../../domain/shopping/interfaces';
+import { Checkout, Payment, PaymentTransaction } from '../../../domain/shopping/models';
+import { PaymentRepository } from '../../../domain/shopping/repositories';
+import { PagarmeCredentials } from '../../../domain/shopping/types';
+export declare class PagarmeBankSlipAxiosAdapter implements PaymentProviderBankSlip {
+    private credentials;
+    private paymentRepository;
+    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository);
+    pay(checkout: Checkout): Promise<Payment>;
+    getBoletoTransaction(paymentId: number): Promise<PaymentTransaction>;
+    private createBoletoPayment;
+}

package/src/infra/pagarme/adapters/pagarme-card-payment-axios.adapter.d.ts

@@ -0,0 +1,17 @@
+import { BusinessUnitEnum } from '../../../domain/shopping/enums';
+import { PaymentProviderCard } from '../../../domain/shopping/interfaces';
+import { Checkout, Payment, PaymentTransaction } from '../../../domain/shopping/models';
+import { OrderBlockedRepository, PaymentRepository } from '../../../domain/shopping/repositories';
+import { CardInfo, PagarMeCard, PagarmeCredentials, PaymentCardInfo } from '../../../domain/shopping/types';
+export declare class PagarmeCardAxiosAdapter implements PaymentProviderCard<PagarMeCard> {
+    private credentials;
+    private paymentRepository;
+    private orderBlockedRepository;
+    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository, orderBlockedRepository: OrderBlockedRepository);
+    pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment>;
+    addCard(card: CardInfo): Promise<PagarMeCard>;
+    createCardHash<PagarMeCardManualHash>(bu: BusinessUnitEnum): Promise<PagarMeCardManualHash>;
+    getCardByToken(id: string): Promise<PagarMeCard>;
+    createTransaction(info: any): Promise<PaymentTransaction>;
+    private createCardPayment;
+}

package/src/infra/pagarme/adapters/pagarme-pix-payment-axios.adapter.d.ts

@@ -0,0 +1,11 @@
+import { PaymentProviderPix } from '../../../domain/shopping/interfaces';
+import { Checkout, Payment } from '../../../domain/shopping/models';
+import { PaymentRepository } from '../../../domain/shopping/repositories';
+import { PagarmeCredentials } from '../../../domain/shopping/types';
+export declare class PagarmePixAxiosAdapter implements PaymentProviderPix {
+    private credentials;
+    private paymentRepository;
+    constructor(credentials: PagarmeCredentials, paymentRepository: PaymentRepository);
+    pay(checkout: Checkout): Promise<Payment>;
+    private createPixPayment;
+}

package/src/infra/pagarme/index.d.ts

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

package/src/infra/vertex-ai/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './vertex-ai-search.adapter';
+export * from './vertex-axios.adapter';

package/src/infra/vertex-ai/adapters/vertex-ai-search.adapter.d.ts

@@ -0,0 +1,10 @@
+import { Product } from '../../../domain';
+import { ProductBulk } from '../types';
+export interface VertexSearchAdapter<T> {
+    query(searchTerm: string, total: number, gender?: String): Promise<T[]>;
+    get(id: string): Promise<T>;
+    save(data: Product): Promise<any>;
+    update(id: string, data: Product): Promise<any>;
+    delete(id: string): Promise<void>;
+    bulkProducts(products: ProductBulk[]): Promise<void>;
+}

package/src/infra/vertex-ai/adapters/vertex-axios.adapter.d.ts

@@ -0,0 +1,15 @@
+import { Product } from '../../../domain';
+import { ProductBulk, ProductSearch } from '../types';
+import { VertexSearchConfig } from '../types/axios-vertex-search-config';
+import { VertexSearchAdapter } from './vertex-ai-search.adapter';
+export declare class VertexAxiosAdapter implements VertexSearchAdapter<ProductSearch> {
+    private readonly config;
+    private logger;
+    constructor(config: VertexSearchConfig);
+    query(term: string, total: number, gender?: String): Promise<ProductSearch[]>;
+    get(id: string): Promise<ProductSearch>;
+    save(data: Product): Promise<any>;
+    update(id: string, data: Product): Promise<any>;
+    delete(id: string): Promise<void>;
+    bulkProducts(_products: ProductBulk[]): Promise<void>;
+}

package/src/infra/vertex-ai/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adapters';
+export * from './indexes';
+export * from './types';

package/src/infra/vertex-ai/indexes/index.d.ts

@@ -0,0 +1 @@
+export * from './products-vertex-search';

package/src/infra/vertex-ai/indexes/products-vertex-search.d.ts

@@ -0,0 +1,13 @@
+import { ProductSearchIndex } from '../../../domain';
+import { ProductHasuraGraphQL } from '../../hasura-graphql';
+import { VertexSearchAdapter } from '../adapters';
+import { ProductSearch } from '../types';
+export declare class ProductsVertexSearch implements ProductSearchIndex {
+    private readonly adapter;
+    constructor(adapter: VertexSearchAdapter<ProductSearch>);
+    getById(id: string): Promise<ProductSearch>;
+    search<ProductSearch>(searchTerm: string, total: number, gender?: String): Promise<ProductSearch[]>;
+    save(product: ProductHasuraGraphQL): Promise<void>;
+    update(product: ProductHasuraGraphQL): Promise<void>;
+    delete(id: string): Promise<void>;
+}

package/src/infra/vertex-ai/types/axios-vertex-search-config.d.ts

@@ -0,0 +1,4 @@
+export type VertexSearchConfig = {
+    url: string;
+    token?: string;
+};

package/src/infra/vertex-ai/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './axios-vertex-search-config';
+export * from './product-bulk';
+export * from './product-search';

package/src/infra/vertex-ai/types/product-bulk.d.ts

@@ -0,0 +1,4 @@
+export type ProductBulk = {
+    id: string;
+    jsonData: string;
+};

package/src/infra/vertex-ai/types/product-search.d.ts

@@ -0,0 +1,21 @@
+export type ProductSearch = {
+    id: string;
+    name: string;
+    ean?: string;
+    sku: string;
+    icon?: string;
+    miniatures?: string;
+    description?: string;
+    slug: string;
+    brand: string;
+    published: boolean;
+    gender: string;
+    shoppingCount: number;
+    stock: number;
+    rating: number;
+    fullPrice: number;
+    price: number;
+    subscriberPrice: number;
+    outlet: boolean;
+    createdAt: Date;
+};

package/src/utils/circular-dependencies.d.ts

@@ -0,0 +1,3 @@
+export declare function registerClass(name: string, classConstructor: any): void;
+export declare function getClass(name: string): any;
+export declare function resolveClass(name: string): () => any;

package/src/utils/decorators/debug.class.decorator.d.ts

@@ -0,0 +1,2 @@
+import { DebugOptions } from '../helpers';
+export declare function Debug(opts?: DebugOptions): ClassDecorator;

package/src/utils/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debug.class.decorator';
+export * from './trace.method.decorator';

package/src/utils/decorators/trace.method.decorator.d.ts

@@ -0,0 +1,14 @@
+export type CallbackFnArgs<T, Result> = {
+    target: T;
+    result: Result;
+    args: Array<any>;
+    namespace?: Array<string>;
+};
+type CallbackFn<T, Result> = (opts: CallbackFnArgs<T, Result>) => void;
+type TraceOptions<T, Result> = {
+    callbackFn?: CallbackFn<T, Result>;
+    level?: 'trace' | 'log';
+};
+export declare function Log<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Trace<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export {};

package/src/utils/get.d.ts

@@ -0,0 +1 @@
+export declare const get: (object: any, path: string, defaultValue?: any) => any;

package/src/utils/helpers/class-name.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class ClassNameHelper {
+    static get(clazz: any): string;
+}

package/src/utils/helpers/debug-decorator.helper.d.ts

@@ -0,0 +1,9 @@
+export type DebugOptions = {
+    name?: string;
+    namespaces?: Array<string>;
+};
+export declare class DebugDecoratorHelper {
+    static DebugNamingMetadataKey: string;
+    static set(target: object, options: DebugOptions): void;
+    static get(target: object): DebugOptions;
+}