@infrab4a/connect 1.0.0-beta.15 → 1.0.0-beta.17

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/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,16 +1,12 @@
 import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
-import { ColumnModelOptions, ColumnOptions, HasuraGraphQLFields } 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>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
-    static CheckIsColumnModelOption: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(fieldValue: ColumnModelOptions<Model, ParentModel>) => fieldValue is ColumnModelOptions<Model, ParentModel>;
     static CheckIsColumnOption: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(fieldValue: ColumnOptions<Model, ParentModel, string | number | boolean | Record<string, any>>) => fieldValue is ColumnOptions<Model, ParentModel, string | number | boolean | Record<string, any>>;
     static FindColumnOptionFromList: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, string | number | boolean | Record<string, any>> & {
-        fields?: HasuraGraphQLFields<Model>;
-        foreignKeyColumn?: { [key in NonFunctionAndIdentifierPropertyNames<Model>]?: string; };
-    } & {
         attributeName: NonFunctionAndIdentifierPropertyNames<ParentModel>;
     };
 }

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,7 +1,7 @@
 import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
-import { ColumnOptions, GraphQLRepository, HasuraGraphQLFields, 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?: {

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

@@ -1,6 +1,6 @@
-import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields } 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>;

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

@@ -1,3 +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

@@ -1,7 +1,9 @@
 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;
+    kitProducts?: KitProductHasuraGraphQL[];
 }

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

@@ -10,6 +10,7 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     getBySlug(slug: string, shop: Shops): Promise<ProductHasuraGraphQL>;
     update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     private updateCategories;
+    private updateKitProducts;
     private getId;
 }
 export {};

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

@@ -1,27 +1,21 @@
 import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, RepositoryFindField } from '../../../domain';
 import { PropType } from '../../../utils';
 import { HasuraGraphQLColumnType } from '../enums';
-export declare type ColumnOptions<FieldType, Model extends ModelBaseStructure, ValueFrom = string | number | boolean | Record<string, any>> = {
+export declare type ColumnOptions<FieldType, Model, ValueFrom = string | number | boolean | Record<string, 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;
     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 ColumnModelOptions<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure> = ColumnOptions<Model, ParentModel> & {
-    fields?: HasuraGraphQLFields<Model>;
-    foreignKeyColumn?: {
-        [key in NonFunctionAndIdentifierPropertyNames<Model>]?: string;
-    };
-};
 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> = {
+export declare type AggregateOptions<Model> = {
     avg?: Array<AggregateOptionFields<Model, number>>;
     max?: Array<AggregateOptionFields<Model, number | Date>>;
     min?: Array<AggregateOptionFields<Model, number | Date>>;
@@ -33,10 +27,10 @@ export declare type AggregateOptions<Model extends ModelBaseStructure> = {
     var_samp?: Array<AggregateOptionFields<Model, number>>;
     variance?: Array<AggregateOptionFields<Model, number>>;
 };
-export declare type HasuraGraphQLFields<Model extends ModelBaseStructure> = (NonFunctionAndIdentifierPropertyNames<Model> | {
+export declare type HasuraGraphQLFields<Model> = ((Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
     [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGraphQLFields<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>;
-} | {
+    [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/index.d.ts

@@ -1,3 +1,4 @@
 export * from './elasticsearch';
 export * from './firebase';
 export * from './hasura-graphql';
+export * from './millenium';

package/infra/millenium/index.d.ts

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

package/infra/millenium/millenium.d.ts

@@ -0,0 +1,25 @@
+import { BaseModel, CrudRepository, Product } from '../../domain';
+import { HasuraGraphQLAuthOptions, ProductHasuraGraphQL, ProductHasuraGraphQLRepository } from '../hasura-graphql';
+declare type MilleniumProductIdentifier = 'id' | 'productId';
+export declare class MilleniumProduct extends BaseModel<MilleniumProduct> {
+    id: number;
+    productId: string;
+    internalId: string;
+    codProduct: string;
+    createdAt: Date;
+    updatedAt?: Date;
+    product: Product;
+    static get identifiersFields(): MilleniumProductIdentifier[];
+}
+export declare class MilleniumProductHasuraGraphQL extends MilleniumProduct {
+    product: ProductHasuraGraphQL;
+}
+declare const MilleniumProductHasuraGraphQLRepository_base: import("../../utils").MixinCtor<import("../hasura-graphql").GraphQLRepository<MilleniumProductHasuraGraphQL> & CrudRepository<MilleniumProductHasuraGraphQL, import("../../domain").CrudParams<MilleniumProductHasuraGraphQL>> & import("../../domain").UpdateRepository<MilleniumProductHasuraGraphQL, import("../../domain").RepositoryUpdateParams<MilleniumProductHasuraGraphQL>> & {
+    paramsToPlain(params: import("../../domain").RepositoryUpdateParams<MilleniumProductHasuraGraphQL>): Partial<MilleniumProductHasuraGraphQL>;
+}, [import("../hasura-graphql").ConstructorParams<MilleniumProductHasuraGraphQL> & import("../hasura-graphql").CreateConstructorParams & import("../hasura-graphql").DeleteConstructorParams & import("../hasura-graphql").GetConstructorParams & import("../hasura-graphql").UpdateConstructorParams, ...any[]]>;
+export declare class MilleniumProductHasuraGraphQLRepository extends MilleniumProductHasuraGraphQLRepository_base implements MilleniumProductRepository {
+    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions, productRepository: ProductHasuraGraphQLRepository);
+}
+export interface MilleniumProductRepository extends CrudRepository<MilleniumProduct> {
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },