@infrab4a/connect 4.29.0 → 4.29.1-alpha.1

package/src/infra/hasura-graphql/mixins/factories/delete-hasura-class.factory.d.ts

@@ -0,0 +1,26 @@
+import { DeleteRepositoryParams, ModelBaseStructure } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+import { GraphQLRepository } from '../../types';
+export type DeleteConstructorParams = {
+    deleteGraphQLOperation?: string;
+};
+export declare function createDeleteHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase): {
+    new (...params: any[]): {
+        deleteGraphQLOperation: string;
+        delete(identifiers: DeleteRepositoryParams<MBase>): Promise<void>;
+        tableName: string;
+        model: import("../../../../domain").BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../../types").HasuraGraphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../../types").HasuraGraphQLAuthOptions;
+        logger: import("../../../../utils").DebugHelper;
+        cache?: import("../../../../domain").CacheConfig;
+        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../../types").GraphQLParams<MBase>[], fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[]): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/src/infra/hasura-graphql/mixins/factories/find-hasura-class.factory.d.ts

@@ -0,0 +1,31 @@
+import { BaseModelBuilder, FindRepositoryParams, ModelBaseStructure, RepositoryCacheOptions, RepositoryFindResult } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+import { GraphQLRepository } from '../../types';
+import { HasuraFindBindingHelper } from '../helpers';
+export declare function createFindHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase): {
+    new (...args: any[]): {
+        lastDistinct: Record<string, any>;
+        bindOrderByAttributes: typeof HasuraFindBindingHelper.bindOrderByAttributes;
+        bindAggregateAttributes: typeof HasuraFindBindingHelper.bindAggregateAttributes;
+        bindDistinctAttributes: typeof HasuraFindBindingHelper.bindDistinctAttributes;
+        bindAttributesToColumns: typeof HasuraFindBindingHelper.bindAttributesToColumns;
+        getColumnName: typeof HasuraFindBindingHelper.getColumnName;
+        find(params?: FindRepositoryParams<MBase>, options?: {
+            cache?: RepositoryCacheOptions;
+        }): Promise<RepositoryFindResult<MBase>>;
+        tableName: string;
+        model: BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../../types").HasuraGraphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../../types").HasuraGraphQLAuthOptions;
+        logger: import("../../../../utils").DebugHelper;
+        cache?: import("../../../../domain").CacheConfig;
+        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../../types").GraphQLParams<MBase>[], fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[]): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/src/infra/hasura-graphql/mixins/factories/get-hasura-class.factory.d.ts

@@ -0,0 +1,29 @@
+import { GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+import { GraphQLRepository } from '../../types';
+export type GetConstructorParams = {
+    getGraphQLOperation?: string;
+};
+export declare function createGetHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase): {
+    new (...params: any[]): {
+        getGraphQLOperation: string;
+        generateCacheKey(identifiers: GetRepositoryParams<MBase>): string;
+        get(identifiers: GetRepositoryParams<MBase>, options?: {
+            cache?: RepositoryCacheOptions;
+        }): Promise<MBase>;
+        tableName: string;
+        model: import("../../../../domain").BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../../types").HasuraGraphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../../types").HasuraGraphQLAuthOptions;
+        logger: import("../../../../utils").DebugHelper;
+        cache?: import("../../../../domain").CacheConfig;
+        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../../types").GraphQLParams<MBase>[], fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[]): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/src/infra/hasura-graphql/mixins/factories/hasura-graphql-class.factory.d.ts

@@ -0,0 +1,40 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../../domain';
+import { DebugHelper, MixinCtor } from '../../../../utils';
+import { GraphQLParams, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../../types';
+import { GraphQLOperationParams, HasuraDataConverterHelper, HasuraQueryBuilderHelper, QueryBuilderOptions } from '../helpers';
+export interface HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOptions[]> {
+    request?: <R>(request: P) => Promise<P & R>;
+    response?: <R>(response: R, request: P) => Promise<R>;
+}
+export interface HasuraConstructorParams<Model extends ModelBaseStructure<Model, Model['identifiersFields'][number]>> {
+    tableName: string;
+    model: BaseModelBuilder<Model>;
+    fields: HasuraGraphQLFields<Model>;
+    endpoint: string;
+    interceptors?: HasuraGraphQLInterceptors;
+    authOptions: HasuraGraphQLAuthOptions;
+    cache?: CacheConfig;
+}
+export declare function createHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>, T extends MixinCtor = MixinCtor>(MixinBase: T): {
+    new (...params: any[]): {
+        [x: string]: any;
+        tableName: string;
+        endpoint: string;
+        authOptions: HasuraGraphQLAuthOptions;
+        interceptors: HasuraGraphQLInterceptors;
+        model: BaseModelBuilder<MBase>;
+        fields: HasuraGraphQLFields<MBase>;
+        logger: DebugHelper;
+        cache?: CacheConfig;
+        getAttributeGraphQLTypeOf: typeof HasuraDataConverterHelper.getAttributeGraphQLTypeOf;
+        checkIfIsDateTimeAndParse: typeof HasuraDataConverterHelper.checkIfIsDateTimeAndParse;
+        buildHasuraQueryFields: typeof HasuraQueryBuilderHelper.buildHasuraQueryFields;
+        readonly headers: import("../../types").HasuraGraphQLHeaders;
+        mutation<ReturnFields = any>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: VariableOptions): Promise<ReturnFields>;
+        query<ReturnFields_1 = any>(operation: string | IOperation | GraphQLParams<MBase>[], fields?: string[] | HasuraGraphQLFields<MBase>, variables?: VariableOptions): Promise<ReturnFields_1>;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<MBase>): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+        getOperationParams(): GraphQLOperationParams<MBase>;
+    };
+} & T;

package/src/infra/hasura-graphql/mixins/factories/index.d.ts

@@ -0,0 +1,6 @@
+export * from './create-hasura-class.factory';
+export * from './delete-hasura-class.factory';
+export * from './find-hasura-class.factory';
+export * from './get-hasura-class.factory';
+export * from './hasura-graphql-class.factory';
+export * from './update-hasura-class.factory';

package/src/infra/hasura-graphql/mixins/factories/update-hasura-class.factory.d.ts

@@ -0,0 +1,36 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, RepositoryUpdateParams, UpdateRepository } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+import { GraphQLRepository } from '../../types';
+export interface UpdateConstructorParams {
+    updateGraphQLOperation?: string;
+    updateGraphQLObjectType?: string;
+    updateGraphQLPKType?: string;
+}
+export interface UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>> extends UpdateRepository<MBase> {
+    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
+}
+export declare function createUpdateHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase): {
+    new (...params: any[]): {
+        updateGraphQLOperation: string;
+        updateGraphQLObjectType: string;
+        updateGraphQLPKType: string;
+        getIdentifiersFromData(data: Partial<MBase>): Record<string, any>;
+        update(data: RepositoryUpdateParams<MBase>): Promise<MBase>;
+        paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
+        getUpdateModelKeys(data: Partial<MBase>): NonFunctionAndIdentifierProperties<MBase>;
+        tableName: string;
+        model: import("../../../../domain").BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../../types").HasuraGraphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../../types").HasuraGraphQLAuthOptions;
+        logger: import("../../../../utils").DebugHelper;
+        cache?: import("../../../../domain").CacheConfig;
+        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../../types").GraphQLParams<MBase>[], fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[]): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;

package/src/infra/hasura-graphql/mixins/helpers/create/hasura-column.helper.d.ts

@@ -0,0 +1,7 @@
+import { ModelBaseStructure } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export declare class HasuraColumnHelper {
+    static extractPrimaryKeyColumns<MBase extends ModelBaseStructure<MBase>>(model: any, fields: HasuraGraphQLFields<MBase>): HasuraGraphQLFields<MBase>;
+    static extractForeignKeyColumns<MBase extends ModelBaseStructure<MBase>>(fields: HasuraGraphQLFields<MBase>): any[];
+    static buildQueryColumns<MBase extends ModelBaseStructure<MBase>>(model: any, fields: HasuraGraphQLFields<MBase>): HasuraGraphQLFields<MBase>;
+}

package/src/infra/hasura-graphql/mixins/helpers/create/hasura-create-operations.helper.d.ts

@@ -0,0 +1,16 @@
+import { BaseModelBuilder, CreateRepositoryParams, ModelBaseStructure } from '../../../../../domain';
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types';
+export type ExecuteCreateParams<MBase extends ModelBaseStructure<MBase>> = {
+    data: MBase;
+    repository: GraphQLRepository<MBase>;
+    insertGraphQLOperation: string;
+    insertGraphQLObjectType: string;
+    fields: HasuraGraphQLFields<MBase>;
+    model: BaseModelBuilder<MBase>;
+};
+export declare class HasuraCreateOperationsHelper {
+    static buildInsertOperationName(tableName: string, customOperation?: string): string;
+    static buildInsertObjectType(tableName: string, customObjectType?: string): string;
+    static executeCreate<MBase extends ModelBaseStructure<MBase>>(data: CreateRepositoryParams<MBase>, params: Omit<ExecuteCreateParams<MBase>, 'data'>): Promise<MBase>;
+    static executeSave<MBase extends ModelBaseStructure<MBase>>(params: ExecuteCreateParams<MBase>): Promise<Partial<MBase>>;
+}

package/src/infra/hasura-graphql/mixins/helpers/create/index.d.ts

@@ -0,0 +1,2 @@
+export { HasuraColumnHelper } from './hasura-column.helper';
+export { ExecuteCreateParams, HasuraCreateOperationsHelper } from './hasura-create-operations.helper';

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-cache-operations.helper.d.ts

@@ -0,0 +1,9 @@
+import { CacheConfig, ModelBaseStructure } from '../../../../../domain';
+import { DebugHelper } from '../../../../../utils';
+export declare class HasuraCacheOperationsHelper {
+    static removeCacheData<MBase extends ModelBaseStructure<MBase>>(cache: CacheConfig | undefined, params: {
+        model: any;
+        identifiers: any;
+        logger: DebugHelper;
+    }): Promise<void>;
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-delete-operations.helper.d.ts

@@ -0,0 +1,15 @@
+import { CacheConfig, DeleteRepositoryParams, ModelBaseStructure } from '../../../../../domain';
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types';
+export type ExecuteDeleteParams<MBase extends ModelBaseStructure<MBase>> = {
+    identifiers: DeleteRepositoryParams<MBase>;
+    repository: GraphQLRepository<MBase>;
+    deleteGraphQLOperation: string;
+    fields: HasuraGraphQLFields<MBase>;
+    model: any;
+    cache?: CacheConfig;
+};
+export declare class HasuraDeleteOperationsHelper {
+    static buildDeleteOperationName(tableName: string, customOperation?: string): string;
+    static executeDelete<MBase extends ModelBaseStructure<MBase>>(params: ExecuteDeleteParams<MBase>): Promise<void>;
+    private static handleCacheRemoval;
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-delete-variables.helper.d.ts

@@ -0,0 +1,10 @@
+import { DeleteRepositoryParams, ModelBaseStructure } from '../../../../../domain';
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types';
+export declare class HasuraDeleteVariablesHelper {
+    static buildDeleteIdentifierColumns<MBase extends ModelBaseStructure<MBase>>(model: any, fields: HasuraGraphQLFields<MBase>): HasuraGraphQLFields<MBase>;
+    static buildDeleteVariables<MBase extends ModelBaseStructure<MBase>>(identifiers: DeleteRepositoryParams<MBase>, params: {
+        model: any;
+        fields: HasuraGraphQLFields<MBase>;
+        repository: GraphQLRepository<MBase>;
+    }): Record<string, any>;
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/index.d.ts

@@ -0,0 +1,3 @@
+export { HasuraCacheOperationsHelper } from './hasura-cache-operations.helper';
+export { ExecuteDeleteParams, HasuraDeleteOperationsHelper } from './hasura-delete-operations.helper';
+export { HasuraDeleteVariablesHelper } from './hasura-delete-variables.helper';

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-binding.helper.d.ts

@@ -0,0 +1,18 @@
+import { FindRepositoryParams, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, RepositoryOrderBy } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export declare class HasuraFindBindingHelper {
+    static bindOrderByAttributes<MBase extends ModelBaseStructure<MBase>>(orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>): any[];
+    static bindAggregateAttributes<MBase extends ModelBaseStructure<MBase>>(aggregates: {
+        minimal?: FindRepositoryParams<MBase>['options']['minimal'];
+        maximum?: FindRepositoryParams<MBase>['options']['maximum'];
+    }, fields: HasuraGraphQLFields<MBase>): ({
+        min: any[];
+        max?: undefined;
+    } | {
+        max: any[];
+        min?: undefined;
+    })[];
+    static bindDistinctAttributes<MBase extends ModelBaseStructure<MBase>>(distinct: FindRepositoryParams<MBase>['options']['distinct'], fields: HasuraGraphQLFields<MBase>): any[];
+    static bindAttributesToColumns<MBase extends ModelBaseStructure<MBase>>(attributes: Array<NonFunctionAndIdentifierPropertyNames<MBase> | any>, fields: HasuraGraphQLFields<MBase>): any[];
+    static getColumnName<MBase extends ModelBaseStructure<MBase>>(attributeName: NonFunctionAndIdentifierPropertyNames<MBase>, fields: HasuraGraphQLFields<MBase>): string;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-cache.helper.d.ts

@@ -0,0 +1,25 @@
+import { BaseModelBuilder, CacheConfig, FindRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain';
+export declare class HasuraFindCacheHelper {
+    static generateCacheKey<MBase extends ModelBaseStructure<MBase>>(model: BaseModelBuilder<MBase, any, MBase & {
+        prototype: unknown;
+    }>, params?: FindRepositoryParams<MBase>): string;
+    static getCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+        cache?: CacheConfig;
+        model: BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        findParams?: FindRepositoryParams<MBase>;
+        cacheOptions?: RepositoryCacheOptions;
+        logger?: any;
+    }): Promise<any | null>;
+    static setCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+        cache?: CacheConfig;
+        model: BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        findParams?: FindRepositoryParams<MBase>;
+        cacheOptions?: RepositoryCacheOptions;
+        result: any;
+        logger?: any;
+    }): Promise<void>;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-operations.helper.d.ts

@@ -0,0 +1,20 @@
+import { BaseModelBuilder, FindRepositoryParams, ModelBaseStructure, RepositoryCacheOptions, RepositoryFindResult } from '../../../../../domain';
+import { GraphQLParams, HasuraGraphQLFields } from '../../../types';
+export interface ExecuteFindParams<MBase extends ModelBaseStructure<MBase>> {
+    params?: FindRepositoryParams<MBase>;
+    cacheOptions?: {
+        cache?: RepositoryCacheOptions;
+    };
+    model: BaseModelBuilder<MBase, any, MBase & {
+        prototype: unknown;
+    }>;
+    tableName: string;
+    fields: HasuraGraphQLFields<MBase>;
+    cache?: any;
+    query: (queries: GraphQLParams<MBase>[]) => Promise<any>;
+    convertDataFromHasura: (data: any) => MBase;
+    lastDistinct: Record<string, any>;
+}
+export declare class HasuraFindOperationsHelper {
+    static executeFindOperation<MBase extends ModelBaseStructure<MBase>>(operationParams: ExecuteFindParams<MBase>): Promise<RepositoryFindResult<MBase>>;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-query-builder.helper.d.ts

@@ -0,0 +1,14 @@
+import { FindRepositoryParams, ModelBaseStructure } from '../../../../../domain';
+import { GraphQLParams, HasuraGraphQLFields } from '../../../types';
+export interface BuildQueryParams<MBase extends ModelBaseStructure<MBase>> {
+    tableName: string;
+    fields: HasuraGraphQLFields<MBase>;
+    params?: FindRepositoryParams<MBase>;
+    lastDistinct: Record<string, any>;
+}
+export declare class HasuraFindQueryBuilderHelper {
+    static buildCompleteQuery<MBase extends ModelBaseStructure<MBase>>(queryParams: BuildQueryParams<MBase>): GraphQLParams<MBase>[];
+    private static buildMainQuery;
+    private static buildAggregateQuery;
+    private static buildDistinctQueries;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-result.helper.d.ts

@@ -0,0 +1,26 @@
+import { FindRepositoryParams, ModelBaseStructure, RepositoryFindResult } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export interface ProcessResultParams<MBase extends ModelBaseStructure<MBase>> {
+    result: any;
+    tableName: string;
+    enableCount: boolean;
+    findOptions: FindRepositoryParams<MBase>['options'];
+    tableFiltersNamed: string;
+    fields: HasuraGraphQLFields<MBase>;
+    convertDataFromHasura: (data: any) => MBase;
+    lastDistinct: Record<string, any>;
+}
+export declare class HasuraFindResultHelper {
+    static processResult<MBase extends ModelBaseStructure<MBase>>(params: ProcessResultParams<MBase>): RepositoryFindResult<MBase>;
+    static bindAggregateAttributes<MBase extends ModelBaseStructure<MBase>>(params: {
+        aggregates: {
+            minimal?: FindRepositoryParams<MBase>['options']['minimal'];
+            maximum?: FindRepositoryParams<MBase>['options']['maximum'];
+        };
+        fields: HasuraGraphQLFields<MBase>;
+    }): Array<any>;
+    private static processMinimalAggregates;
+    private static processMaximumAggregates;
+    private static processDistinctResults;
+    private static bindAttributesToColumns;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-variables.helper.d.ts

@@ -0,0 +1,21 @@
+import { FindRepositoryParams, ModelBaseStructure, RepositoryOrderBy } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export declare class HasuraFindVariablesHelper {
+    static buildFiltersVariables<MBase extends ModelBaseStructure<MBase>>(params: {
+        filters: FindRepositoryParams<MBase>['filters'];
+        tableName: string;
+        fields: HasuraGraphQLFields<MBase>;
+    }): Record<string, any>;
+    static buildOrderByVariables<MBase extends ModelBaseStructure<MBase>>(params: {
+        orderBy: RepositoryOrderBy<MBase>;
+        tableName: string;
+        fields: HasuraGraphQLFields<MBase>;
+    }): Record<string, any>;
+    static buildDistinctVariables<MBase extends ModelBaseStructure<MBase>>(params: {
+        distinct: string;
+        tableName: string;
+        fields: HasuraGraphQLFields<MBase>;
+        filtersVariables: Record<string, any>;
+    }): Record<string, any>;
+    private static bindOrderByAttributes;
+}

package/src/infra/hasura-graphql/mixins/helpers/find/index.d.ts

@@ -0,0 +1,6 @@
+export { HasuraFindBindingHelper } from './hasura-find-binding.helper';
+export { HasuraFindCacheHelper } from './hasura-find-cache.helper';
+export { ExecuteFindParams, HasuraFindOperationsHelper } from './hasura-find-operations.helper';
+export { BuildQueryParams, HasuraFindQueryBuilderHelper } from './hasura-find-query-builder.helper';
+export { HasuraFindResultHelper, ProcessResultParams } from './hasura-find-result.helper';
+export { HasuraFindVariablesHelper } from './hasura-find-variables.helper';

package/src/infra/hasura-graphql/mixins/helpers/get/hasura-get-cache.helper.d.ts

@@ -0,0 +1,21 @@
+import { CacheConfig, GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain';
+import { DebugHelper } from '../../../../../utils';
+export declare class HasuraGetCacheHelper {
+    static generateCacheKey<MBase extends ModelBaseStructure<MBase>>(model: any, identifiers: GetRepositoryParams<MBase>): string;
+    static getCachedData<MBase extends ModelBaseStructure<MBase>>(cache: CacheConfig | undefined, params: {
+        identifiers: GetRepositoryParams<MBase>;
+        options?: {
+            cache?: RepositoryCacheOptions;
+        };
+        model: any;
+        logger: DebugHelper;
+    }): Promise<MBase | null>;
+    static saveCacheData<MBase extends ModelBaseStructure<MBase>>(cache: CacheConfig | undefined, params: {
+        identifiers: GetRepositoryParams<MBase>;
+        options?: {
+            cache?: RepositoryCacheOptions;
+        };
+        data: MBase;
+        logger: DebugHelper;
+    }): Promise<void>;
+}

package/src/infra/hasura-graphql/mixins/helpers/get/hasura-get-operations.helper.d.ts

@@ -0,0 +1,18 @@
+import { CacheConfig, GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain';
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types';
+export type ExecuteGetParams<MBase extends ModelBaseStructure<MBase>> = {
+    identifiers: GetRepositoryParams<MBase>;
+    options?: {
+        cache?: RepositoryCacheOptions;
+    };
+    repository: GraphQLRepository<MBase>;
+    getGraphQLOperation: string;
+    fields: HasuraGraphQLFields<MBase>;
+    model: any;
+    cache?: CacheConfig;
+};
+export declare class HasuraGetOperationsHelper {
+    static buildGetOperationName(tableName: string, customOperation?: string): string;
+    static executeGet<MBase extends ModelBaseStructure<MBase>>(params: ExecuteGetParams<MBase>): Promise<MBase>;
+    private static executeQuery;
+}

package/src/infra/hasura-graphql/mixins/helpers/get/hasura-get-variables.helper.d.ts

@@ -0,0 +1,9 @@
+import { GetRepositoryParams, ModelBaseStructure } from '../../../../../domain';
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types';
+export declare class HasuraGetVariablesHelper {
+    static buildGetVariables<MBase extends ModelBaseStructure<MBase>>(identifiers: GetRepositoryParams<MBase>, params: {
+        model: any;
+        fields: HasuraGraphQLFields<MBase>;
+        repository: GraphQLRepository<MBase>;
+    }): Record<string, any>;
+}

package/src/infra/hasura-graphql/mixins/helpers/get/index.d.ts

@@ -0,0 +1,3 @@
+export { HasuraGetCacheHelper } from './hasura-get-cache.helper';
+export { ExecuteGetParams, HasuraGetOperationsHelper } from './hasura-get-operations.helper';
+export { HasuraGetVariablesHelper } from './hasura-get-variables.helper';

package/src/infra/hasura-graphql/mixins/helpers/hasura-auth.helper.d.ts

@@ -0,0 +1,4 @@
+import { HasuraGraphQLAuthOptions, HasuraGraphQLHeaders } from '../../types';
+export declare class HasuraAuthHelper {
+    static buildHeaders(authOptions: HasuraGraphQLAuthOptions): HasuraGraphQLHeaders;
+}

package/src/infra/hasura-graphql/mixins/helpers/hasura-data-converter.helper.d.ts

@@ -0,0 +1,8 @@
+import { ModelBaseStructure } from '../../../../domain';
+import { HasuraGraphQLFields } from '../../types';
+export declare class HasuraDataConverterHelper {
+    static getAttributeGraphQLTypeOf<FieldType>(value: FieldType): string;
+    static checkIfIsDateTimeAndParse(value: string): Date | string;
+    static convertDataFromHasura<MBase extends ModelBaseStructure<MBase>>(data: Record<string, string | number>, fields: HasuraGraphQLFields<MBase>, model: any): MBase;
+    static convertDataToHasura<MBase extends ModelBaseStructure<MBase>>(instance: MBase, fields: HasuraGraphQLFields<MBase>, update?: boolean): Record<string, string | number>;
+}

package/src/infra/hasura-graphql/mixins/helpers/hasura-graphql-operations.helper.d.ts

@@ -0,0 +1,32 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { ModelBaseStructure } from '../../../../domain';
+import { DebugHelper } from '../../../../utils';
+import { GraphQLParams, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../../types';
+import { QueryBuilderOptions } from './hasura-query-builder.helper';
+export interface GraphQLOperationParams<MBase extends ModelBaseStructure<MBase>> {
+    endpoint: string;
+    authOptions: HasuraGraphQLAuthOptions;
+    fields: HasuraGraphQLFields<MBase>;
+    interceptors?: any;
+    logger: DebugHelper;
+}
+export declare class HasuraGraphQLOperationsHelper {
+    static executeMutation<MBase extends ModelBaseStructure<MBase>, ReturnFields = any>(params: {
+        operation: string | IOperation;
+        fields?: string[] | HasuraGraphQLFields<MBase>;
+        variables?: VariableOptions;
+        operationParams: GraphQLOperationParams<MBase>;
+    }): Promise<ReturnFields>;
+    static executeQuery<MBase extends ModelBaseStructure<MBase>, ReturnFields = any>(params: {
+        operation: string | IOperation | GraphQLParams<MBase>[];
+        fields?: string[] | HasuraGraphQLFields<MBase>;
+        variables?: VariableOptions;
+        operationParams: GraphQLOperationParams<MBase>;
+        buildHasuraQueryFields: (params: {
+            operation: string | IOperation | GraphQLParams<MBase>[];
+            fields?: string[] | HasuraGraphQLFields<MBase>;
+            variables?: VariableOptions;
+        }) => QueryBuilderOptions | QueryBuilderOptions[];
+    }): Promise<ReturnFields>;
+    private static executeFetch;
+}

package/src/infra/hasura-graphql/mixins/helpers/hasura-query-builder.helper.d.ts

@@ -0,0 +1,23 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { ModelBaseStructure } from '../../../../domain';
+import { Fields, GraphQLParams, HasuraGraphQLFields, VariableOptions } from '../../types';
+export type QueryBuilderOptions = {
+    operation: string | IOperation;
+    fields: Fields;
+    variables?: VariableOptions;
+};
+export declare class HasuraQueryBuilderHelper {
+    static buildMutation<MBase extends ModelBaseStructure<MBase>>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: VariableOptions): {
+        variables: any;
+        query: string;
+    };
+    static buildQuery<MBase extends ModelBaseStructure<MBase>>(params: QueryBuilderOptions | QueryBuilderOptions[]): {
+        variables: any;
+        query: string;
+    };
+    static buildHasuraQueryFields<MBase extends ModelBaseStructure<MBase>>(params: {
+        operation: string | IOperation | GraphQLParams<MBase>[];
+        fields?: string[] | HasuraGraphQLFields<MBase>;
+        variables?: VariableOptions;
+    }): QueryBuilderOptions | QueryBuilderOptions[];
+}

package/src/infra/hasura-graphql/mixins/helpers/hasura-request.helper.d.ts

@@ -0,0 +1,11 @@
+import { DebugHelper } from '../../../../utils';
+import { HasuraGraphQLHeaders } from '../../types';
+export declare class HasuraRequestHelper {
+    static fetch<ReturnFields = any>(params: {
+        variables: any;
+        query: string;
+        endpoint: string;
+        headers: HasuraGraphQLHeaders;
+        logger: DebugHelper;
+    }): Promise<ReturnFields>;
+}

package/src/infra/hasura-graphql/mixins/helpers/index.d.ts

@@ -2,5 +2,15 @@ export * from './attribute-option.helper';
 export * from './bind-filter-query.helper';
 export * from './cache-key-generator.helper';
 export * from './filter-option.helper';
-export * from './graphql-field.helper';
+export { GraphQLFieldHelper } from './graphql-field.helper';
 export * from './md5-generator.helper';
+export { HasuraAuthHelper } from './hasura-auth.helper';
+export { HasuraDataConverterHelper } from './hasura-data-converter.helper';
+export { GraphQLOperationParams, HasuraGraphQLOperationsHelper } from './hasura-graphql-operations.helper';
+export { HasuraQueryBuilderHelper, QueryBuilderOptions } from './hasura-query-builder.helper';
+export { HasuraRequestHelper } from './hasura-request.helper';
+export * from './create';
+export * from './delete';
+export * from './find';
+export * from './get';
+export * from './update';

package/src/infra/hasura-graphql/mixins/helpers/update/hasura-update-data.helper.d.ts

@@ -0,0 +1,6 @@
+import { BaseModelBuilder, ModelBaseStructure, RepositoryUpdateParams, UpdateOptions } from '../../../../../domain';
+export declare class HasuraUpdateDataHelper {
+    static getValueByAction<MBase extends ModelBaseStructure<MBase>>(options: UpdateOptions<MBase>): unknown;
+    static paramsToPlain<MBase extends ModelBaseStructure<MBase>>(params: RepositoryUpdateParams<MBase>, model: BaseModelBuilder<MBase>): Partial<MBase>;
+    static getIdentifiersFromData<MBase extends ModelBaseStructure<MBase>>(data: Partial<MBase>, model: any): Record<string, any>;
+}

package/src/infra/hasura-graphql/mixins/helpers/update/hasura-update-operations.helper.d.ts

@@ -0,0 +1,18 @@
+import { ModelBaseStructure, RepositoryUpdateParams } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export interface UpdateOperationsParams<MBase extends ModelBaseStructure<MBase>> {
+    data: RepositoryUpdateParams<MBase>;
+    updateGraphQLOperation: string;
+    updateGraphQLObjectType: string;
+    updateGraphQLPKType: string;
+    model: any;
+    fields: any;
+    cache?: any;
+    logger?: any;
+    mutation: (operation: string, fields: HasuraGraphQLFields<MBase>, variables: any) => Promise<any>;
+    convertDataToHasura: (data: any, isUpdate?: boolean) => any;
+}
+export declare class HasuraUpdateOperationsHelper {
+    static executeUpdateOperation<MBase extends ModelBaseStructure<MBase>>(params: UpdateOperationsParams<MBase>): Promise<MBase>;
+    private static handleCacheRemoval;
+}

package/src/infra/hasura-graphql/mixins/helpers/update/hasura-update-variables.helper.d.ts

@@ -0,0 +1,25 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties } from '../../../../../domain';
+import { HasuraGraphQLFields } from '../../../types';
+export declare class HasuraUpdateVariablesHelper {
+    static getUpdateModelKeys<MBase extends ModelBaseStructure<MBase>>(data: Partial<MBase>, model: any, fields: any): NonFunctionAndIdentifierProperties<MBase>;
+    static getIdentifierFields<MBase extends ModelBaseStructure<MBase>>(model: any, fields: any): HasuraGraphQLFields<MBase>;
+    static buildMutationVariables<MBase extends ModelBaseStructure<MBase>>(params: {
+        plainData: Partial<MBase>;
+        updateGraphQLObjectType: string;
+        updateGraphQLPKType: string;
+        convertDataToHasura: (data: any, isUpdate?: boolean) => any;
+        getUpdateModelKeys: (data: Partial<MBase>) => NonFunctionAndIdentifierProperties<MBase>;
+        model: any;
+    }): {
+        _set: {
+            type: string;
+            value: any;
+            required: boolean;
+        };
+        pk_columns: {
+            type: string;
+            value: NonFunctionAndIdentifierProperties<MBase>;
+            required: boolean;
+        };
+    };
+}

package/src/infra/hasura-graphql/mixins/helpers/update/index.d.ts

@@ -0,0 +1,3 @@
+export { HasuraUpdateDataHelper } from './hasura-update-data.helper';
+export { HasuraUpdateOperationsHelper, UpdateOperationsParams } from './hasura-update-operations.helper';
+export { HasuraUpdateVariablesHelper } from './hasura-update-variables.helper';