@infrab4a/connect 4.2.0-beta.1 → 4.2.0-beta.2

package/{fesm2020 → fesm2022}/infrab4a-connect.mjs

@@ -602,6 +602,7 @@ class ReflectHelper {
                 return true;
         });
     }
+    static { this._items = {}; }
     static put({ key, target, property, value, propertyDescriptor }) {
         const index = target.constructor.name;
         ReflectHelper.items[key] = ReflectHelper.items[key] || {};
@@ -632,9 +633,9 @@ class ReflectHelper {
             return false;
     }
 }
-ReflectHelper._items = {};
 
 class DebugDecoratorHelper {
+    static { this.DebugNamingMetadataKey = 'model:naming:decorator'; }
     static set(target, options) {
         ReflectHelper.add({
             key: DebugDecoratorHelper.DebugNamingMetadataKey,
@@ -649,7 +650,6 @@ class DebugDecoratorHelper {
         });
     }
 }
-DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
 
 class ClassNameHelper {
     static get(clazz) {
@@ -669,10 +669,10 @@ const isDebuggable = (object) => {
     return 'debug' in object;
 };
 class DebugHelper {
-    constructor(...namespace) {
-        this.namespaces = new Set();
-        this.push(...namespace);
-    }
+    static { this.logs$ = new Subject(); }
+    static { this.traces$ = new Subject(); }
+    static { this.errors$ = new Subject(); }
+    static { this.isDebuggable = isDebuggable; }
     static namespacesFor(target) {
         if (isNil(target))
             return [];
@@ -726,6 +726,10 @@ class DebugHelper {
         DebugHelper.replace(target, { with: debug });
         return { original, debug };
     }
+    constructor(...namespace) {
+        this.namespaces = new Set();
+        this.push(...namespace);
+    }
     get entries() {
         return Array.from(get$1(this, 'namespaces', []));
     }
@@ -805,10 +809,6 @@ class DebugHelper {
         return [`[${this.namespace}]`, ...args].join(' ');
     }
 }
-DebugHelper.logs$ = new Subject();
-DebugHelper.traces$ = new Subject();
-DebugHelper.errors$ = new Subject();
-DebugHelper.isDebuggable = isDebuggable;
 
 function Debug(opts) {
     return function (target) {
@@ -2720,38 +2720,38 @@ class RegisterFirebaseAuthService {
 }
 
 class AttributeOptionHelper {
+    static { this.FindByAttribute = (attributeName, fields) => {
+        if (fields.includes(attributeName))
+            return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value };
+        const field = fields.find((columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()));
+        const fieldOption = is(field)?.[attributeName];
+        if (isNil(fieldOption))
+            return { columnName: attributeName.toString(), attributeName };
+        if (Array.isArray(fieldOption))
+            return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
+        return { attributeName, columnName: attributeName.toString(), ...fieldOption };
+    }; }
+    static { this.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName; }
+    static { this.FindColumnOptionFromList = (columnName, fields) => {
+        if (fields.includes(columnName))
+            return { columnName, attributeName: columnName };
+        const field = is(fields.find((field) => {
+            if (!isObject(field))
+                return false;
+            const columnOption = Object.values(field).find((option) => AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {});
+            return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName;
+        }) || {});
+        const attributeName = Object.keys(field).find((fieldOptionFromList) => AttributeOptionHelper.CheckIsColumnOption(field[fieldOptionFromList]) || Array.isArray(field[fieldOptionFromList]));
+        const fieldOption = field?.[attributeName];
+        if (Array.isArray(fieldOption))
+            return { attributeName: attributeName, fields: fieldOption };
+        return {
+            attributeName: attributeName || columnName,
+            columnName,
+            ...fieldOption,
+        };
+    }; }
 }
-AttributeOptionHelper.FindByAttribute = (attributeName, fields) => {
-    if (fields.includes(attributeName))
-        return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value };
-    const field = fields.find((columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()));
-    const fieldOption = is(field)?.[attributeName];
-    if (isNil(fieldOption))
-        return { columnName: attributeName.toString(), attributeName };
-    if (Array.isArray(fieldOption))
-        return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
-    return { attributeName, columnName: attributeName.toString(), ...fieldOption };
-};
-AttributeOptionHelper.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName;
-AttributeOptionHelper.FindColumnOptionFromList = (columnName, fields) => {
-    if (fields.includes(columnName))
-        return { columnName, attributeName: columnName };
-    const field = is(fields.find((field) => {
-        if (!isObject(field))
-            return false;
-        const columnOption = Object.values(field).find((option) => AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {});
-        return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName;
-    }) || {});
-    const attributeName = Object.keys(field).find((fieldOptionFromList) => AttributeOptionHelper.CheckIsColumnOption(field[fieldOptionFromList]) || Array.isArray(field[fieldOptionFromList]));
-    const fieldOption = field?.[attributeName];
-    if (Array.isArray(fieldOption))
-        return { attributeName: attributeName, fields: fieldOption };
-    return {
-        attributeName: attributeName || columnName,
-        columnName,
-        ...fieldOption,
-    };
-};
 
 var HasuraGraphQLWhere;
 (function (HasuraGraphQLWhere) {
@@ -2784,211 +2784,211 @@ var HasuraGraphQLColumnType;
 })(HasuraGraphQLColumnType || (HasuraGraphQLColumnType = {}));
 
 class FilterOptionHelper {
+    static { this.CheckIfIsFilterOption = (filter) => !isNil(filter?.operator); }
+    static { this.GetValueFromFilter = (filter, fieldOption) => {
+        if (!FilterOptionHelper.CheckIfIsFilterOption(filter))
+            return filter;
+        if (filter.operator === Where.ISNULL)
+            return true;
+        if (filter.operator === Where.ISNOTNULL)
+            return false;
+        const converter = fieldOption.to
+            ? fieldOption.to
+            : (value) => filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
+                ? `%${value}%`
+                : value;
+        return Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
+            ? filter.value.map((fieldValue) => converter(fieldValue))
+            : converter(filter.value);
+    }; }
 }
-FilterOptionHelper.CheckIfIsFilterOption = (filter) => !isNil(filter?.operator);
-FilterOptionHelper.GetValueFromFilter = (filter, fieldOption) => {
-    if (!FilterOptionHelper.CheckIfIsFilterOption(filter))
-        return filter;
-    if (filter.operator === Where.ISNULL)
-        return true;
-    if (filter.operator === Where.ISNOTNULL)
-        return false;
-    const converter = fieldOption.to
-        ? fieldOption.to
-        : (value) => filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
-            ? `%${value}%`
-            : value;
-    return Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
-        ? filter.value.map((fieldValue) => converter(fieldValue))
-        : converter(filter.value);
-};
 
 class BindFilterQueryHelper {
-}
-BindFilterQueryHelper.MakeGraphQLWhere = (filter, fields) => Object.keys(filter).reduce((variables, fieldName) => {
-    const columnOption = AttributeOptionHelper.FindByAttribute(fieldName, fields);
-    if (!columnOption.bindFindFilter)
-        return {
-            ...variables,
-            ...{
-                [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, filter[fieldName], fields),
-            },
-        };
-    const builtFilter = columnOption.bindFindFilter(filter[fieldName]);
-    return {
-        ...variables,
-        ...Object.keys(builtFilter).reduce((variablesList, columnName) => ({
-            ...variablesList,
-            [columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, builtFilter[columnName], fields),
-        }), {}),
-    };
-}, {});
-BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
-    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-    const isNestedField = !Array.isArray(options) &&
-        isObject(options) &&
-        isNil(options?.operator) &&
-        isNil(options?.value) &&
-        isNil(fieldSentenceOptions?.to);
-    if (isNestedField)
-        return Object.keys(options).reduce((variables, key) => {
-            const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
-            const columnName = fieldOptions.columnName;
-            const columnFields = fieldOptions.fields;
+    static { this.MakeGraphQLWhere = (filter, fields) => Object.keys(filter).reduce((variables, fieldName) => {
+        const columnOption = AttributeOptionHelper.FindByAttribute(fieldName, fields);
+        if (!columnOption.bindFindFilter)
             return {
                 ...variables,
-                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
+                ...{
+                    [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, filter[fieldName], fields),
+                },
             };
-        }, {});
-    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
+        const builtFilter = columnOption.bindFindFilter(filter[fieldName]);
         return {
-            [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
+            ...variables,
+            ...Object.keys(builtFilter).reduce((variablesList, columnName) => ({
+                ...variablesList,
+                [columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, builtFilter[columnName], fields),
+            }), {}),
         };
-    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
-        options = Object.values(options)[0];
-    return Array.isArray(options)
-        ? options.reduce((whereSentence, option) => ({
-            ...whereSentence,
-            ...BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions),
-        }), {})
-        : BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions);
-};
-BindFilterQueryHelper.BuildOperatorSentence = (options, fieldOption) => ({
-    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(options, fieldOption),
-});
-BindFilterQueryHelper.GetHasuraOperator = (options, fieldOption) => FilterOptionHelper.CheckIfIsFilterOption(options)
-    ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
-        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
-        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-            Object.keys(Where).find((operator) => Where[operator] === options?.operator))]
-    : HasuraGraphQLWhere.EQUALS;
-BindFilterQueryHelper.GetHasuraJsonbOperator = (options) => options.operator === Where.IN
-    ? HasuraGraphQLWhere.JSON_CONTAINS
-    : options.operator === Where.LIKE
-        ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
-        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-            Object.keys(Where).find((operator) => Where[operator] === options?.operator))];
-
-class GraphQLFieldHelper {
-}
-GraphQLFieldHelper.CheckIsGraphQLParams = (params) => !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation;
-GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = (fields) => {
-    return fields
-        ?.map((field) => {
-        if (isString(field))
-            return field.toString();
-        if (field === 'affected_rows')
-            return field;
-        const fieldName = Object.keys(field).shift();
-        const fieldValue = is(field[fieldName]);
-        if (Array.isArray(fieldValue))
-            return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
-        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
-            return;
-        const isNestedField = !!fieldValue.fields;
+    }, {}); }
+    static { this.BuildWhereSentence = (field, options, fields) => {
+        const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
+        const isNestedField = !Array.isArray(options) &&
+            isObject(options) &&
+            isNil(options?.operator) &&
+            isNil(options?.value) &&
+            isNil(fieldSentenceOptions?.to);
         if (isNestedField)
-            return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
-        return fieldValue.columnName;
-    })
-        .filter((field) => !!field);
-};
-GraphQLFieldHelper.ConvertFieldValueFrom = (data, fields) => Object.keys(data).reduce((result, columnName) => {
-    const { attributeName, fields: attributeFields, from, } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields);
-    if (!!attributeFields && Array.isArray(attributeFields)) {
-        if (Array.isArray(data[columnName]))
-            return {
-                ...result,
-                [attributeName]: from
-                    ? from(data[columnName], data)
-                    : is(data[columnName]).map((value) => GraphQLFieldHelper.ConvertFieldValueFrom(is(value), attributeFields)),
-            };
-        if (isObject(data[columnName]))
-            return {
-                ...result,
-                [attributeName]: !!from
-                    ? from(data[columnName])
-                    : GraphQLFieldHelper.ConvertFieldValueFrom(is(data[columnName]), attributeFields),
-            };
-    }
-    if (!!from)
-        return { ...result, [attributeName]: from(data[columnName], data) };
-    return {
-        ...result,
-        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
-    };
-}, {});
-GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
-    const data = instance.toPlain?.() || instance;
-    return Object.keys(data).reduce((result, attributeName) => {
-        const { columnName, fields: attributeFields, foreignKeyColumn, to, bindPersistData, } = AttributeOptionHelper.FindByAttribute(attributeName, fields);
-        if (bindPersistData)
-            return {
-                ...result,
-                ...bindPersistData(data[attributeName], instance),
-            };
-        if (isNil(columnName))
-            return result;
-        if (!!foreignKeyColumn &&
-            !isEmpty(foreignKeyColumn) &&
-            !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
-            return Object.keys(foreignKeyColumn).reduce((object, current) => {
-                const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(foreignKeyColumn[current], fields);
+            return Object.keys(options).reduce((variables, key) => {
+                const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
+                const columnName = fieldOptions.columnName;
+                const columnFields = fieldOptions.fields;
                 return {
-                    ...object,
-                    [foreignColumnName]: data[attributeName]?.[current],
+                    ...variables,
+                    [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
                 };
-            }, { ...result });
-        if (update &&
-            isObject(data[attributeName]) &&
-            !isNil(attributeFields) &&
-            !isDate(data[attributeName]))
-            return result;
-        if (!!columnName &&
-            Array.isArray(attributeFields) &&
-            isObject(data[attributeName])) {
-            const converted = !isNil(columnName) && to
-                ? to(instance[attributeName], instance)
-                : data[attributeName];
+            }, {});
+        if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
             return {
-                ...result,
-                ...(converted !== undefined
-                    ? {
-                        [columnName]: {
-                            data: instance[attributeName] instanceof BaseModel
-                                ? GraphQLFieldHelper.ConvertFieldValueTo(data[attributeName], attributeFields)
-                                : converted,
-                        },
-                    }
-                    : {}),
+                [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
             };
+        if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
+            options = Object.values(options)[0];
+        return Array.isArray(options)
+            ? options.reduce((whereSentence, option) => ({
+                ...whereSentence,
+                ...BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions),
+            }), {})
+            : BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions);
+    }; }
+    static { this.BuildOperatorSentence = (options, fieldOption) => ({
+        [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(options, fieldOption),
+    }); }
+    static { this.GetHasuraOperator = (options, fieldOption) => FilterOptionHelper.CheckIfIsFilterOption(options)
+        ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
+            ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
+            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
+                Object.keys(Where).find((operator) => Where[operator] === options?.operator))]
+        : HasuraGraphQLWhere.EQUALS; }
+    static { this.GetHasuraJsonbOperator = (options) => options.operator === Where.IN
+        ? HasuraGraphQLWhere.JSON_CONTAINS
+        : options.operator === Where.LIKE
+            ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
+            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
+                Object.keys(Where).find((operator) => Where[operator] === options?.operator))]; }
+}
+
+class GraphQLFieldHelper {
+    static { this.CheckIsGraphQLParams = (params) => !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation; }
+    static { this.ConvertModelFieldsToGraphQLFields = (fields) => {
+        return fields
+            ?.map((field) => {
+            if (isString(field))
+                return field.toString();
+            if (field === 'affected_rows')
+                return field;
+            const fieldName = Object.keys(field).shift();
+            const fieldValue = is(field[fieldName]);
+            if (Array.isArray(fieldValue))
+                return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
+            if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
+                return;
+            const isNestedField = !!fieldValue.fields;
+            if (isNestedField)
+                return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
+            return fieldValue.columnName;
+        })
+            .filter((field) => !!field);
+    }; }
+    static { this.ConvertFieldValueFrom = (data, fields) => Object.keys(data).reduce((result, columnName) => {
+        const { attributeName, fields: attributeFields, from, } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields);
+        if (!!attributeFields && Array.isArray(attributeFields)) {
+            if (Array.isArray(data[columnName]))
+                return {
+                    ...result,
+                    [attributeName]: from
+                        ? from(data[columnName], data)
+                        : is(data[columnName]).map((value) => GraphQLFieldHelper.ConvertFieldValueFrom(is(value), attributeFields)),
+                };
+            if (isObject(data[columnName]))
+                return {
+                    ...result,
+                    [attributeName]: !!from
+                        ? from(data[columnName])
+                        : GraphQLFieldHelper.ConvertFieldValueFrom(is(data[columnName]), attributeFields),
+                };
         }
-        if (!!to)
+        if (!!from)
+            return { ...result, [attributeName]: from(data[columnName], data) };
+        return {
+            ...result,
+            [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
+        };
+    }, {}); }
+    static { this.ConvertFieldValueTo = (instance, fields, update = false) => {
+        const data = instance.toPlain?.() || instance;
+        return Object.keys(data).reduce((result, attributeName) => {
+            const { columnName, fields: attributeFields, foreignKeyColumn, to, bindPersistData, } = AttributeOptionHelper.FindByAttribute(attributeName, fields);
+            if (bindPersistData)
+                return {
+                    ...result,
+                    ...bindPersistData(data[attributeName], instance),
+                };
+            if (isNil(columnName))
+                return result;
+            if (!!foreignKeyColumn &&
+                !isEmpty(foreignKeyColumn) &&
+                !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
+                return Object.keys(foreignKeyColumn).reduce((object, current) => {
+                    const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(foreignKeyColumn[current], fields);
+                    return {
+                        ...object,
+                        [foreignColumnName]: data[attributeName]?.[current],
+                    };
+                }, { ...result });
+            if (update &&
+                isObject(data[attributeName]) &&
+                !isNil(attributeFields) &&
+                !isDate(data[attributeName]))
+                return result;
+            if (!!columnName &&
+                Array.isArray(attributeFields) &&
+                isObject(data[attributeName])) {
+                const converted = !isNil(columnName) && to
+                    ? to(instance[attributeName], instance)
+                    : data[attributeName];
+                return {
+                    ...result,
+                    ...(converted !== undefined
+                        ? {
+                            [columnName]: {
+                                data: instance[attributeName] instanceof BaseModel
+                                    ? GraphQLFieldHelper.ConvertFieldValueTo(data[attributeName], attributeFields)
+                                    : converted,
+                            },
+                        }
+                        : {}),
+                };
+            }
+            if (!!to)
+                return {
+                    ...result,
+                    [columnName]: to(instance[attributeName], instance),
+                };
+            return { ...result, [columnName]: data[attributeName] };
+        }, {});
+    }; }
+    static { this.ConvertNestedFieldsToGraphQLFields = (fieldName, fieldValue) => {
+        const hasCustomFilters = !!fieldValue.filters;
+        if (hasCustomFilters)
             return {
-                ...result,
-                [columnName]: to(instance[attributeName], instance),
+                operation: fieldValue.columnName || fieldName,
+                fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+                variables: {
+                    [`${fieldValue.columnName}_where`]: {
+                        name: 'where',
+                        type: fieldValue.filters.filterType,
+                        value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
+                        required: true,
+                    },
+                },
             };
-        return { ...result, [columnName]: data[attributeName] };
-    }, {});
-};
-GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields = (fieldName, fieldValue) => {
-    const hasCustomFilters = !!fieldValue.filters;
-    if (hasCustomFilters)
         return {
-            operation: fieldValue.columnName || fieldName,
-            fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-            variables: {
-                [`${fieldValue.columnName}_where`]: {
-                    name: 'where',
-                    type: fieldValue.filters.filterType,
-                    value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
-                    required: true,
-                },
-            },
+            [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
         };
-    return {
-        [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-    };
-};
+    }; }
+}
 
 const withCreateHasuraGraphQL = (MixinBase) => {
     return class CreateHasuraGraphQLMixin extends MixinBase {
@@ -3058,16 +3058,6 @@ const withDeleteHasuraGraphQL = (MixinBase) => {
 
 const withHasuraGraphQL = (MixinBase) => {
     return class HasuraGraphQLMixin extends MixinBase {
-        constructor(...params) {
-            const options = params[0];
-            super(...params);
-            this.tableName = options.tableName;
-            this.endpoint = options.endpoint;
-            this.authOptions = options.authOptions;
-            this.model = options.model;
-            this.fields = options.fields || this.model.identifiersFields;
-            this.logger = DebugHelper.from(this);
-        }
         get headers() {
             return {
                 'Content-Type': 'application/json',
@@ -3081,6 +3071,16 @@ const withHasuraGraphQL = (MixinBase) => {
                     }),
             };
         }
+        constructor(...params) {
+            const options = params[0];
+            super(...params);
+            this.tableName = options.tableName;
+            this.endpoint = options.endpoint;
+            this.authOptions = options.authOptions;
+            this.model = options.model;
+            this.fields = options.fields || this.model.identifiersFields;
+            this.logger = DebugHelper.from(this);
+        }
         async mutation(operation, fields, variables) {
             const resultQuery = mutation({
                 operation,
@@ -4032,6 +4032,24 @@ class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasu
 }
 
 class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    get reviewsFields() {
+        return [
+            'id',
+            'shop',
+            'rate',
+            'author',
+            'email',
+            'location',
+            'review',
+            'status',
+            'title',
+            { personId: { columnName: 'person_id' } },
+            'points',
+            { orderId: { columnName: 'order_id' } },
+            { createdAt: { columnName: 'created_at' } },
+            { updatedAt: { columnName: 'updated_at' } },
+        ];
+    }
     constructor({ endpoint, authOptions, interceptors, }) {
         super({
             tableName: 'product',
@@ -4232,24 +4250,6 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             },
         ];
     }
-    get reviewsFields() {
-        return [
-            'id',
-            'shop',
-            'rate',
-            'author',
-            'email',
-            'location',
-            'review',
-            'status',
-            'title',
-            { personId: { columnName: 'person_id' } },
-            'points',
-            { orderId: { columnName: 'order_id' } },
-            { createdAt: { columnName: 'created_at' } },
-            { updatedAt: { columnName: 'updated_at' } },
-        ];
-    }
     async create(params) {
         const { metadata, ...data } = params;
         const product = await super.create(omit({ ...data, metadata: metadata || { description: null, title: null } }, ['reviews']));