@infrab4a/connect 1.0.0-beta.9 → 1.0.1-beta.0

package/infra/elasticsearch/adapters/axios.adapter.d.ts

@@ -7,5 +7,8 @@ export declare type AxiosElasticSearchConfig = {
 export declare class AxiosAdapter<T extends BaseModel<T>> {
     private readonly config;
     constructor(config: AxiosElasticSearchConfig);
+    get(index: string): Promise<Partial<T>>;
     query(index: string, query: any): Promise<ElasticSearchResult<Partial<T>>>;
+    save(index: string, data: Partial<T>): Promise<void>;
+    delete(index: string): Promise<void>;
 }

package/infra/elasticsearch/adapters/elastic-search.adapter.d.ts

@@ -1,4 +1,7 @@
 import { ElasticSearchResult } from '../types/elastic-search-result';
 export interface ElasticSearchAdapter<T = any> {
+    get(index: string): Promise<T>;
     query(index: string, query: any): Promise<ElasticSearchResult<T>>;
+    save(index: string, data: Partial<T>): Promise<void>;
+    delete(index: string): Promise<void>;
 }

package/infra/elasticsearch/indexes/products-index.d.ts

@@ -1,11 +1,15 @@
-import { AxiosAdapter } from '../adapters';
 import { Product, Shops } from '../../../domain';
+import { ProductHasuraGraphQL } from '../../hasura-graphql';
+import { AxiosAdapter } from '../adapters';
 export declare class ProductsIndex {
     private readonly adapter;
     constructor(adapter: AxiosAdapter<Product>);
+    get(id: any): Promise<Product>;
     findById(ids: string[], options?: {
         hasStock: boolean;
         size: number;
         shop: Shops;
     }): Promise<Product[]>;
+    save(product: ProductHasuraGraphQL): Promise<void>;
+    delete(product: ProductHasuraGraphQL): Promise<void>;
 }

package/infra/firebase/auth/authentication-firebase-auth.service.d.ts

@@ -1,4 +1,4 @@
-import firebase from 'firebase/app';
+import firebase from 'firebase';
 import { AuthenticationService, BasicUserData, LoginAndPasswordParams } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class AuthenticationFirebaseAuthService implements AuthenticationService {

package/infra/firebase/auth/register-firebase-auth.service.d.ts

@@ -1,4 +1,4 @@
-import firebase from 'firebase/app';
+import firebase from 'firebase';
 import { RegisterParams, RegisterService } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class RegisterFirebaseAuthService implements RegisterService {

package/infra/firebase/firestore/mixins/with-find-firestore.mixin.d.ts

@@ -1,4 +1,4 @@
 import { FindRepository, ModelBaseStructure } from '../../../../domain';
-import { FirestoreHelpers, FirestoreRepository } from '../types';
 import { MergeConstructorParams, MixinCtor } from '../../../../utils';
+import { FirestoreHelpers, FirestoreRepository } from '../types';
 export declare const withFindFirestore: <TBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers, any[]> & TMixinBase) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase, import("../../../../domain").FindRepositoryParams<TBase>> & FirestoreHelpers, MergeConstructorParams<{}, ConstructorParameters<TMixinBase>>>;

package/infra/firebase/firestore/mixins/with-firestore.mixin.d.ts

@@ -1,4 +1,4 @@
 import { ModelBaseStructure } from '../../../../domain';
-import { FirestoreRepository } from '../types';
 import { MixinCtor } from '../../../../utils';
+import { FirestoreRepository } from '../types';
 export declare const withFirestore: <TBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<FirestoreRepository<TBase>, never>;

package/infra/firebase/firestore/repositories/catalog/product-firestore.repository.d.ts

@@ -1,9 +1,11 @@
 import { FirebaseFirestore } from '@firebase/firestore-types';
-import { Product, ProductRepository, Shops } from '../../../../../domain';
+import { Product, ProductRepository, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
 declare const ProductFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<Product> & import("../../../../../domain").CrudRepository<Product, import("../../../../../domain").CrudParams<Product>> & import("@infrab4a/connect").FirestoreHelpers, never>;
 export declare class ProductFirestoreRepository extends ProductFirestoreRepository_base implements ProductRepository {
     readonly firestore: FirebaseFirestore;
+    private reviews;
     constructor(firestore: FirebaseFirestore);
-    getBySlug(slug: string, shop: Shops): Promise<Product>;
+    getBySlug(slug: string): Promise<Product>;
+    fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
 }
 export {};

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

@@ -1,3 +1,4 @@
 export * from './mixins';
-export * from './types';
+export * from './models';
 export * from './repositories';
+export * from './types';

package/infra/hasura-graphql/mixins/helpers/attribute-option.helper.d.ts

@@ -1,10 +1,13 @@
 import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
-import { ColumnModelOptions, HasuraGrahphQLFields } from '../../types';
+import { ColumnOptions, HasuraGraphQLFields } from '../../types';
+declare type FindByAttributeResult<MBase extends ModelBaseStructure<MBase>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase>> = ColumnOptions<MBase[Attribute], MBase> & {
+    attributeName: Attribute;
+};
 export declare class AttributeOptionHelper {
-    static findByAttribute: <MBase extends ModelBaseStructure<any, any>, T extends ModelBaseStructure<any, any> = ModelBaseStructure<any, any>>(attributeName: NonFunctionAndIdentifierPropertyNames<MBase>, fields: HasuraGrahphQLFields<MBase>) => import("../../types").ColumnOptions<T, MBase, string | number | Record<string, any>> & {
-        fields?: HasuraGrahphQLFields<T>;
-        foreignKeyColumn?: { [key in NonFunctionAndIdentifierPropertyNames<T>]?: string; };
-    } & {
-        attributeName: NonFunctionAndIdentifierPropertyNames<MBase>;
+    static FindByAttribute: <MBase extends ModelBaseStructure<any, any>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
+    static CheckIsColumnOption: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(fieldValue: ColumnOptions<Model, ParentModel, any>) => fieldValue is ColumnOptions<Model, ParentModel, any>;
+    static FindColumnOptionFromList: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, any> & {
+        attributeName: NonFunctionAndIdentifierPropertyNames<ParentModel>;
     };
 }
+export {};

package/infra/hasura-graphql/mixins/helpers/filter-option.helper.d.ts

@@ -0,0 +1,6 @@
+import { ModelBaseStructure, RepositoryFindFieltersOptions } from '../../../../domain';
+import { ColumnOptions } from '../../types';
+export declare class FilterOptionHelper {
+    static CheckIfIsFilterOption: <Model extends ModelBaseStructure<any, any>>(filter: any) => filter is RepositoryFindFieltersOptions<Model, any>;
+    static GetValueFromFilter: <Model extends ModelBaseStructure<any, any>>(filter: RepositoryFindFieltersOptions<Model, any>, fieldOption: ColumnOptions<any, any>) => any;
+}

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

@@ -0,0 +1,8 @@
+import { ModelBaseStructure, NonFunctionProperties } from '../../../../domain';
+import { Fields, GraphQLParams, HasuraGraphQLFields } from '../../types';
+export declare class GraphQLFieldHelper {
+    static CheckIsGraphQLParams: <Model extends ModelBaseStructure<any, any>>(params: string | GraphQLParams<Model>[]) => params is GraphQLParams<Model>[];
+    static ConvertModelFieldsToGraphQLFields: <Model extends ModelBaseStructure<any, any>>(fields: HasuraGraphQLFields<Model>) => Fields;
+    static ConvertFieldValueFrom: <Model extends ModelBaseStructure<any, any>, DataType extends Record<string, string | number | Date | DataType>>(data: string | number | Date | DataType, fields: HasuraGraphQLFields<Model>) => Partial<NonFunctionProperties<Model>>;
+    static ConvertFieldValueTo: <Model extends ModelBaseStructure<any, any>, DataType extends Record<string, string | number | Date | DataType>>(instance: Model, fields: HasuraGraphQLFields<Model>, update?: boolean) => DataType;
+}

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

@@ -1 +1,3 @@
 export * from './attribute-option.helper';
+export * from './graphql-field.helper';
+export * from './filter-option.helper';

package/infra/hasura-graphql/mixins/with-create-hasura-graphql.mixin.d.ts

@@ -1,6 +1,6 @@
 import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../domain';
-import { GraphQLRepository } from '../types';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
 export declare type CreateConstructorParams = {
     insertGraphQLOperation?: string;
     insertGraphQLObjectType?: string;

package/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.d.ts

@@ -1,16 +1,17 @@
 import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
-import { ColumnOptions, GraphQLRepository, HasuraGrahphQLFields, VariableOptions } from '../types';
-import { HasuraGraphQLWhere } from '../enums';
 import { MixinCtor } from '../../../utils';
+import { HasuraGraphQLWhere } from '../enums';
+import { ColumnOptions, GraphQLRepository, HasuraGraphQLFields, VariableOptions } from '../types';
 export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
     new (...args: any[]): {
         find(options?: {
             filters?: RepositoryFindFielters<MBase>;
+            fields?: NonFunctionPropertyNames<MBase, keyof MBase>[];
             limits?: RepositoryLimitOptions<MBase>;
             orderBy?: RepositoryOrderBy<MBase>;
         }): Promise<RepositoryFindResult<MBase>>;
-        makeGraphQLWhere: (filter: RepositoryFindFielters<MBase>, fields: HasuraGrahphQLFields<MBase>) => VariableOptions;
-        buildWhereSentence: (field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fields: HasuraGrahphQLFields<MBase>) => VariableOptions;
+        makeGraphQLWhere: (filter: RepositoryFindFielters<MBase>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
+        buildWhereSentence: (field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
         buildOperatorSentence: (options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
         getHasuraOperator: (options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
         getHasuraJsonbOperator: (options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>) => HasuraGraphQLWhere;
@@ -18,11 +19,11 @@ export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<an
         model: import("../../../domain").BaseModelBuilder<MBase, NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
             prototype: unknown;
         }>;
-        fields: HasuraGrahphQLFields<MBase>;
+        fields: HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        mutation: <ReturnFields = any>(operation: string, fields?: HasuraGrahphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: HasuraGrahphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields_1>;
+        mutation: <ReturnFields = any>(operation: string, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: string[] | HasuraGraphQLFields<MBase>, variables?: VariableOptions) => Promise<ReturnFields_1>;
         getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
         convertDataFromHasura: (data: Record<string, string | number>) => MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;

package/infra/hasura-graphql/mixins/with-get-hasura-graphql.mixin.d.ts

@@ -1,6 +1,6 @@
-import { ModelBaseStructure, GetRepositoryParams } from '../../../domain';
-import { GraphQLRepository } from '../types';
+import { GetRepositoryParams, ModelBaseStructure } from '../../../domain';
 import { MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
 export declare type GetConstructorParams = {
     getGraphQLOperation?: string;
 };
@@ -12,11 +12,11 @@ export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<any
         model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
             prototype: unknown;
         }>;
-        fields: import("../types").HasuraGrahphQLFields<MBase>;
+        fields: import("../types").HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGrahphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGrahphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        mutation: <ReturnFields = any>(operation: string, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
         getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
         convertDataFromHasura: (data: Record<string, string | number>) => MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;

package/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.d.ts

@@ -1,10 +1,10 @@
-import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGrahphQLFields } from '../types';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields } from '../types';
 export declare type ConstructorParams<Model extends ModelBaseStructure> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
-    fields: HasuraGrahphQLFields<Model>;
+    fields: HasuraGraphQLFields<Model>;
     endpoint: string;
     authOptions: HasuraGraphQLAuthOptions;
 };

package/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.d.ts

@@ -1,6 +1,6 @@
 import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../domain';
-import { GraphQLRepository } from '../types';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
 export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {
     paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
 };

package/infra/hasura-graphql/models/category-hasura-graphql.d.ts

@@ -1,4 +1,6 @@
 import { Category } from '../../../domain';
 export declare class CategoryHasuraGraphQL extends Category {
-    firestore_id?: string;
+    firestoreId?: string;
+    brandCondition?: string;
+    tagCondition?: string[];
 }

package/infra/hasura-graphql/models/index.d.ts

@@ -1 +1,4 @@
 export * from './category-hasura-graphql';
+export * from './kit-product-hasura-graphql';
+export * from './product-hasura-graphql';
+export * from './variant-hasura-graphql';

package/infra/hasura-graphql/models/kit-product-hasura-graphql.d.ts

@@ -0,0 +1,6 @@
+import { KitProduct } from '../../../domain';
+import { ProductHasuraGraphQL } from './product-hasura-graphql';
+export declare class KitProductHasuraGraphQL extends KitProduct {
+    kit: ProductHasuraGraphQL;
+    product: ProductHasuraGraphQL;
+}

package/infra/hasura-graphql/models/product-hasura-graphql.d.ts

@@ -0,0 +1,10 @@
+import { Product } from '../../../domain';
+import { KitProductHasuraGraphQL } from './kit-product-hasura-graphql';
+export declare class ProductHasuraGraphQL extends Product {
+    firestoreId?: string;
+    fullPrice?: number;
+    subscriberDiscountPercentage?: number;
+    subscriberPrice?: number;
+    productId?: number;
+    kitProducts?: KitProductHasuraGraphQL[];
+}

package/infra/hasura-graphql/models/variant-hasura-graphql.d.ts

@@ -0,0 +1,9 @@
+import { Variant } from '../../../domain';
+export declare class VariantHasuraGraphQL extends Variant {
+    firestoreId?: string;
+    fullPrice?: number;
+    subscriberDiscountPercentage?: number;
+    subscriberPrice?: number;
+    name?: string;
+    hasVariants?: boolean;
+}

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

@@ -1,2 +1,3 @@
 export * from './category-hasura-graphql.repository';
 export * from './product-hasura-graphql.repository';
+export * from './variant-hasura-graphql.repository';

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

@@ -1,10 +1,27 @@
+import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { ProductHasuraGraphQL } from '../../models';
 import { HasuraGraphQLAuthOptions } from '../../types';
-import { Product, ProductRepository, Shops } from '../../../../domain';
-declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<Product> & import("../../../../domain").CrudRepository<Product, import("../../../../domain").CrudParams<Product>> & import("../../../../domain").UpdateRepository<Product, import("../../../../domain").RepositoryUpdateParams<Product>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<Product>): Partial<Product>;
-}, [import("../../mixins").ConstructorParams<Product> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductHasuraGraphQL, import("../../../../domain").CrudParams<ProductHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>): Partial<ProductHasuraGraphQL>;
+}, [import("../../mixins").ConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
+    private get reviewsFields();
     constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
-    getBySlug(slug: string, shop: Shops): Promise<Product>;
+    create(data: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
+    get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
+    find(params?: FindRepositoryParams<ProductHasuraGraphQL>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
+    getBySlug(slug: string): Promise<ProductHasuraGraphQL>;
+    update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
+    fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
+    private updateCategories;
+    private updateKitProducts;
+    private updateReviews;
+    private getId;
+    private findReviewsByProduct;
+    private findReview;
+    private getReviewByPersonId;
+    private getReviewByAuthorAndEmail;
+    private bindReviewToModel;
+    private bindReviewToHasura;
 }
 export {};

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

@@ -0,0 +1,14 @@
+import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
+import { VariantHasuraGraphQL } from '../../models';
+import { HasuraGraphQLAuthOptions } from '../../types';
+declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../../../domain").UpdateRepository<VariantHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>): Partial<VariantHasuraGraphQL>;
+}, [import("../../mixins").ConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
+    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
+    get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
+    find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
+    update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
+    private getId;
+}
+export {};

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

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

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

@@ -1,25 +1,21 @@
-import { HasuraGraphQLColumnType } from '../enums';
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../domain';
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, RepositoryFindField } from '../../../domain';
 import { PropType } from '../../../utils';
-export declare type ColumnOptions<FieldType, Model extends ModelBaseStructure, ValueFrom = string | number | Record<string, any>> = {
+import { HasuraGraphQLColumnType } from '../enums';
+export declare type ColumnOptions<FieldType, Model, ValueFrom = any> = {
     type?: HasuraGraphQLColumnType;
     columnName?: string;
-    fields?: any[];
-    foreignKeyColumn?: any;
+    fields?: HasuraGraphQLFields<FieldType extends any[] ? FieldType[number] : 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;
-};
-export declare type ColumnModelOptions<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure> = ColumnOptions<Model, ParentModel> & {
-    fields?: HasuraGrahphQLFields<Model>;
-    foreignKeyColumn?: {
-        [key in NonFunctionAndIdentifierPropertyNames<Model>]?: string;
-    };
+    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 declare type AggregateOptionNames = 'avg' | 'count' | 'max' | 'min' | 'stddev' | 'stddev_pop' | 'stddev_samp' | 'sum' | 'var_pop' | 'var_samp' | 'variance';
-export declare type AggregateOptionFields<Model extends ModelBaseStructure, Type, Properties extends keyof Model = keyof Model> = {
+export declare type AggregateOptionFields<Model, Type, Properties extends keyof Model = keyof Model> = {
     [K in Properties]: PropType<Model, K> extends Type ? K : never;
-}[Properties];
-export declare type AggregateOptions<Model extends ModelBaseStructure> = {
+}[Properties] | string;
+export declare type AggregateOptions<Model> = {
     avg?: Array<AggregateOptionFields<Model, number>>;
     max?: Array<AggregateOptionFields<Model, number | Date>>;
     min?: Array<AggregateOptionFields<Model, number | Date>>;
@@ -31,10 +27,10 @@ export declare type AggregateOptions<Model extends ModelBaseStructure> = {
     var_samp?: Array<AggregateOptionFields<Model, number>>;
     variance?: Array<AggregateOptionFields<Model, number>>;
 };
-export declare type HasuraGrahphQLFields<Model extends ModelBaseStructure> = (NonFunctionAndIdentifierPropertyNames<Model> | {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGrahphQLFields<PropType<Model, key>> : never;
-} | {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate' ? never : PropType<Model, key> extends ModelBaseStructure ? ColumnModelOptions<PropType<Model, key>, Model> : ColumnOptions<PropType<Model, key>, Model>;
+export declare type HasuraGraphQLFields<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>;
+} : string) | {
     aggregate: Array<AggregateOptions<Model> | 'count'>;
-})[];
+} | 'affected_rows')[];

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

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

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

@@ -5,3 +5,4 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.1-beta.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -10,14 +10,15 @@
   },
   "dependencies": {
     "axios": "^0.27.2",
-    "class-transformer": "^0.4.0",
+    "class-transformer": "^0.5.1",
     "date-fns": "^2.28.0",
     "firebase": "7.24.0",
     "gql-query-builder": "^3.7.0",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
+    "ts-custom-error": "3.2.2",
     "ts-md5": "^1.2.9",
-    "tslib": "^2.2.0"
+    "tslib": "^2.4.0"
   },
   "main": "bundles/infrab4a-connect.umd.js",
   "module": "fesm2015/infrab4a-connect.js",