@infrab4a/connect 4.0.2-beta.9 → 4.0.3-beta.0

package/esm2020/infra/hasura-graphql/mixins/helpers/bind-filter-query.helper.mjs

@@ -0,0 +1,71 @@
+import { Where, } from '../../../../domain';
+import { is, isNil, isObject } from '../../../../utils';
+import { HasuraGraphQLColumnType, HasuraGraphQLWhere } from '../../enums';
+import { AttributeOptionHelper } from './attribute-option.helper';
+import { FilterOptionHelper } from './filter-option.helper';
+export 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;
+            return {
+                ...variables,
+                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
+            };
+        }, {});
+    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
+        return {
+            [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);
+};
+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))];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bind-filter-query.helper.js","sourceRoot":"","sources":["../../../../../../../projects/connect/src/infra/hasura-graphql/mixins/helpers/bind-filter-query.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ModelBaseStructure,\r\n  NonFunctionAndIdentifierPropertyNames,\r\n  NonFunctionPropertyNames,\r\n  RepositoryFindFielters,\r\n  RepositoryFindFieltersOptions,\r\n  Where,\r\n} from '../../../../domain'\r\nimport { is, isNil, isObject } from '../../../../utils'\r\nimport { HasuraGraphQLColumnType, HasuraGraphQLWhere } from '../../enums'\r\nimport { ColumnOptions, HasuraGraphQLFields, VariableOptions } from '../../types'\r\nimport { AttributeOptionHelper } from './attribute-option.helper'\r\nimport { FilterOptionHelper } from './filter-option.helper'\r\n\r\nexport class BindFilterQueryHelper {\r\n  static MakeGraphQLWhere = <MBase extends ModelBaseStructure<MBase>>(\r\n    filter: RepositoryFindFielters<MBase>,\r\n    fields: HasuraGraphQLFields<MBase>,\r\n  ): VariableOptions =>\r\n    Object.keys(filter).reduce((variables: VariableOptions, fieldName: string) => {\r\n      const columnOption = AttributeOptionHelper.FindByAttribute(\r\n        fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n        fields,\r\n      )\r\n\r\n      if (!columnOption.bindFindFilter)\r\n        return {\r\n          ...variables,\r\n          ...{\r\n            [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(\r\n              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n              filter[fieldName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<\r\n                MBase,\r\n                NonFunctionAndIdentifierPropertyNames<MBase>\r\n              >,\r\n              fields,\r\n            ),\r\n          },\r\n        }\r\n\r\n      const builtFilter: RepositoryFindFielters<MBase> = columnOption.bindFindFilter(\r\n        filter[fieldName as NonFunctionPropertyNames<MBase>] as RepositoryFindFieltersOptions<\r\n          MBase,\r\n          NonFunctionPropertyNames<MBase>\r\n        >,\r\n      )\r\n\r\n      return {\r\n        ...variables,\r\n        ...Object.keys(builtFilter).reduce(\r\n          (variablesList: VariableOptions, columnName: string) => ({\r\n            ...variablesList,\r\n            [columnName]: BindFilterQueryHelper.BuildWhereSentence(\r\n              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n              builtFilter[columnName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<\r\n                MBase,\r\n                NonFunctionAndIdentifierPropertyNames<MBase>\r\n              >,\r\n              fields,\r\n            ),\r\n          }),\r\n          {},\r\n        ),\r\n      }\r\n    }, {})\r\n\r\n  static BuildWhereSentence = <MBase extends ModelBaseStructure<MBase>>(\r\n    field: NonFunctionAndIdentifierPropertyNames<MBase>,\r\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>,\r\n    fields: HasuraGraphQLFields<MBase>,\r\n  ): VariableOptions => {\r\n    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute<MBase>(field, fields)\r\n    const isNestedField =\r\n      !Array.isArray(options) &&\r\n      isObject(options) &&\r\n      isNil(options?.operator) &&\r\n      isNil(options?.value) &&\r\n      isNil(fieldSentenceOptions?.to)\r\n\r\n    if (isNestedField)\r\n      return Object.keys(options).reduce((variables, key) => {\r\n        const fieldOptions = AttributeOptionHelper.FindByAttribute<MBase>(\r\n          key as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n          fieldSentenceOptions?.fields || (fields as any),\r\n        )\r\n        const columnName = fieldOptions.columnName\r\n        const columnFields = fieldOptions.fields\r\n\r\n        return {\r\n          ...variables,\r\n          [columnName]: BindFilterQueryHelper.BuildWhereSentence<MBase>(\r\n            key as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n            is<RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>>(\r\n              is<RepositoryFindFielters<MBase>>(options)[key as NonFunctionAndIdentifierPropertyNames<MBase>],\r\n            ),\r\n            fieldSentenceOptions?.fields || columnFields || (fields as any),\r\n          ),\r\n        }\r\n      }, {})\r\n\r\n    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))\r\n      return {\r\n        [fieldSentenceOptions.fields[0] as NonFunctionAndIdentifierPropertyNames<MBase>]:\r\n          BindFilterQueryHelper.BuildOperatorSentence(\r\n            options,\r\n            fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\r\n          ),\r\n      }\r\n\r\n    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))\r\n      options = Object.values(options)[0] as RepositoryFindFieltersOptions<MBase, any>\r\n\r\n    return Array.isArray(options)\r\n      ? options.reduce(\r\n          (whereSentence, option) => ({\r\n            ...whereSentence,\r\n            ...BindFilterQueryHelper.BuildOperatorSentence(\r\n              option,\r\n              fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\r\n            ),\r\n          }),\r\n          {},\r\n        )\r\n      : BindFilterQueryHelper.BuildOperatorSentence(\r\n          options,\r\n          fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\r\n        )\r\n  }\r\n\r\n  static BuildOperatorSentence = <MBase extends ModelBaseStructure<MBase>>(\r\n    options: RepositoryFindFieltersOptions<MBase, any>,\r\n    fieldOption: ColumnOptions<any, any>,\r\n  ): VariableOptions => ({\r\n    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(\r\n      options,\r\n      fieldOption,\r\n    ),\r\n  })\r\n\r\n  static GetHasuraOperator = <MBase extends ModelBaseStructure<MBase>>(\r\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,\r\n    fieldOption: ColumnOptions<any, any>,\r\n  ): HasuraGraphQLWhere =>\r\n    FilterOptionHelper.CheckIfIsFilterOption(options)\r\n      ? fieldOption.type === HasuraGraphQLColumnType.Jsonb\r\n        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)\r\n        : HasuraGraphQLWhere[\r\n            Object.keys(HasuraGraphQLWhere).find(\r\n              (graphQLOperator) =>\r\n                graphQLOperator ===\r\n                Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),\r\n            ) as keyof typeof HasuraGraphQLWhere\r\n          ]\r\n      : HasuraGraphQLWhere.EQUALS\r\n\r\n  static GetHasuraJsonbOperator = <MBase extends ModelBaseStructure<MBase>>(\r\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,\r\n  ): HasuraGraphQLWhere =>\r\n    options.operator === Where.IN\r\n      ? HasuraGraphQLWhere.JSON_CONTAINS\r\n      : options.operator === Where.LIKE\r\n      ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY\r\n      : HasuraGraphQLWhere[\r\n          Object.keys(HasuraGraphQLWhere).find(\r\n            (graphQLOperator) =>\r\n              graphQLOperator ===\r\n              Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),\r\n          ) as keyof typeof HasuraGraphQLWhere\r\n        ]\r\n}\r\n"]}

package/esm2020/infra/hasura-graphql/mixins/helpers/filter-option.helper.mjs

@@ -0,0 +1,22 @@
+import { Where } from '../../../../domain';
+import { isNil } from '../../../../utils';
+export class FilterOptionHelper {
+}
+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);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/hasura-graphql/mixins/helpers/graphql-field.helper.mjs

@@ -0,0 +1,125 @@
+import { BaseModel, } from '../../../../domain';
+import { is, isDate, isEmpty, isNil, isObject, isString, parseDateTime } from '../../../../utils';
+import { AttributeOptionHelper } from './attribute-option.helper';
+import { BindFilterQueryHelper } from './bind-filter-query.helper';
+export 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;
+        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,
+                    [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] };
+    }, {});
+};
+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,
+                },
+            },
+        };
+    return {
+        [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql-field.helper.js","sourceRoot":"","sources":["../../../../../../../projects/connect/src/infra/hasura-graphql/mixins/helpers/graphql-field.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'\r\nimport {\r\n  BaseModel,\r\n  ModelBaseStructure,\r\n  NonFunctionAndIdentifierPropertiesWithNoPartial,\r\n  NonFunctionAndIdentifierPropertyNames,\r\n  PartialIdentifiersModel,\r\n} from '../../../../domain'\r\nimport { is, isDate, isEmpty, isNil, isObject, isString, parseDateTime } from '../../../../utils'\r\nimport { ColumnOptions, Fields, GraphQLParams, HasuraGraphQLFields } from '../../types'\r\nimport { AttributeOptionHelper } from './attribute-option.helper'\r\nimport { BindFilterQueryHelper } from './bind-filter-query.helper'\r\n\r\nexport class GraphQLFieldHelper {\r\n  static CheckIsGraphQLParams = <Model extends ModelBaseStructure<Model>>(\r\n    params: string | IOperation | GraphQLParams<Model>[],\r\n  ): params is GraphQLParams<Model>[] =>\r\n    !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation\r\n\r\n  static ConvertModelFieldsToGraphQLFields = <Model extends ModelBaseStructure<Model>>(\r\n    fields: HasuraGraphQLFields<Model>,\r\n  ): Fields => {\r\n    return fields\r\n      ?.map((field) => {\r\n        if (isString(field)) return field.toString()\r\n        if (field === 'affected_rows') return field\r\n\r\n        const fieldName = Object.keys(field).shift()\r\n        const fieldValue = is<ColumnOptions<any, Model>>(field[fieldName as keyof typeof field])\r\n\r\n        if (Array.isArray(fieldValue))\r\n          return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) }\r\n        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue)) return\r\n\r\n        const isNestedField = !!fieldValue.fields\r\n\r\n        if (isNestedField) return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue as any)\r\n\r\n        return fieldValue.columnName\r\n      })\r\n      .filter((field) => !!field)\r\n  }\r\n\r\n  static ConvertFieldValueFrom = <\r\n    Model extends ModelBaseStructure,\r\n    RecordDataType extends string | number | DataType | Date,\r\n    DataType extends Record<string, RecordDataType | RecordDataType[]>,\r\n  >(\r\n    data: DataType,\r\n    fields: HasuraGraphQLFields<Model>,\r\n  ): NonFunctionAndIdentifierPropertiesWithNoPartial<Model> | PartialIdentifiersModel<Model> =>\r\n    Object.keys(data).reduce((result, columnName) => {\r\n      const {\r\n        attributeName,\r\n        fields: attributeFields,\r\n        from,\r\n      } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields)\r\n\r\n      if (!!attributeFields && Array.isArray(attributeFields)) {\r\n        if (Array.isArray(data[columnName]))\r\n          return {\r\n            ...result,\r\n            [attributeName]: from\r\n              ? from(data[columnName], data)\r\n              : is<RecordDataType[]>(data[columnName]).map((value) =>\r\n                  GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(value), attributeFields),\r\n                ),\r\n          }\r\n        if (isObject(data[columnName]))\r\n          return {\r\n            ...result,\r\n            [attributeName]: !!from\r\n              ? from(data[columnName])\r\n              : GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(data[columnName]), attributeFields),\r\n          }\r\n      }\r\n\r\n      if (!!from) return { ...result, [attributeName]: from(data[columnName], data) }\r\n\r\n      return {\r\n        ...result,\r\n        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],\r\n      }\r\n    }, {})\r\n\r\n  static ConvertFieldValueTo = <\r\n    Model extends ModelBaseStructure<Model>,\r\n    DataType extends Record<string, string | number | DataType | Date>,\r\n  >(\r\n    instance: Model,\r\n    fields: HasuraGraphQLFields<Model>,\r\n    update = false,\r\n  ): DataType => {\r\n    const data: Partial<Model> = instance.toPlain?.() || instance\r\n\r\n    return Object.keys(data).reduce((result, attributeName) => {\r\n      const {\r\n        columnName,\r\n        fields: attributeFields,\r\n        foreignKeyColumn,\r\n        to,\r\n        bindPersistData,\r\n      } = AttributeOptionHelper.FindByAttribute(attributeName as NonFunctionAndIdentifierPropertyNames<Model>, fields)\r\n\r\n      if (bindPersistData)\r\n        return {\r\n          ...result,\r\n          ...bindPersistData(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>], instance),\r\n        }\r\n      if (isNil(columnName)) return result\r\n      if (\r\n        !!foreignKeyColumn &&\r\n        !isEmpty(foreignKeyColumn) &&\r\n        !Object.keys(foreignKeyColumn).filter(\r\n          (key) =>\r\n            !is<Record<string, string>>(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>])?.[key],\r\n        ).length\r\n      )\r\n        return Object.keys(foreignKeyColumn).reduce(\r\n          (object, current) => {\r\n            const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(\r\n              foreignKeyColumn[current as keyof HasuraGraphQLFields<Model>[number]],\r\n              fields,\r\n            )\r\n\r\n            return {\r\n              ...object,\r\n              [foreignColumnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]]?.[current],\r\n            }\r\n          },\r\n          { ...result },\r\n        )\r\n\r\n      if (\r\n        update &&\r\n        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]]) &&\r\n        !isNil(attributeFields) &&\r\n        !isDate(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])\r\n      )\r\n        return result\r\n\r\n      if (\r\n        !!columnName &&\r\n        Array.isArray(attributeFields) &&\r\n        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])\r\n      ) {\r\n        const converted =\r\n          !isNil(columnName) && to\r\n            ? to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance)\r\n            : data[attributeName as keyof HasuraGraphQLFields<Model>[number]]\r\n\r\n        return {\r\n          ...result,\r\n          ...(converted !== undefined\r\n            ? {\r\n                [columnName]: {\r\n                  data:\r\n                    instance[attributeName as NonFunctionAndIdentifierPropertyNames<Model>] instanceof BaseModel\r\n                      ? GraphQLFieldHelper.ConvertFieldValueTo(\r\n                          data[attributeName as keyof HasuraGraphQLFields<Model>[number]],\r\n                          attributeFields as HasuraGraphQLFields<Model>,\r\n                        )\r\n                      : converted,\r\n                },\r\n              }\r\n            : {}),\r\n        }\r\n      }\r\n\r\n      if (!!to)\r\n        return {\r\n          ...result,\r\n          [columnName]: to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance),\r\n        }\r\n\r\n      return { ...result, [columnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]] }\r\n    }, {} as DataType)\r\n  }\r\n\r\n  private static ConvertNestedFieldsToGraphQLFields = <\r\n    T extends ModelBaseStructure<T>,\r\n    P extends ModelBaseStructure<P>,\r\n  >(\r\n    fieldName: string,\r\n    fieldValue: ColumnOptions<T, P>,\r\n  ) => {\r\n    const hasCustomFilters = !!fieldValue.filters\r\n\r\n    if (hasCustomFilters)\r\n      return {\r\n        operation: fieldValue.columnName || fieldName,\r\n        fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),\r\n        variables: {\r\n          [`${fieldValue.columnName}_where`]: {\r\n            name: 'where',\r\n            type: fieldValue.filters.filterType,\r\n            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),\r\n            required: true,\r\n          },\r\n        },\r\n      }\r\n\r\n    return {\r\n      [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/infra/hasura-graphql/mixins/helpers/index.mjs

@@ -0,0 +1,5 @@
+export * from './attribute-option.helper';
+export * from './bind-filter-query.helper';
+export * from './filter-option.helper';
+export * from './graphql-field.helper';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFBO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUE7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHdCQUF3QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdHRyaWJ1dGUtb3B0aW9uLmhlbHBlcidcclxuZXhwb3J0ICogZnJvbSAnLi9iaW5kLWZpbHRlci1xdWVyeS5oZWxwZXInXHJcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLW9wdGlvbi5oZWxwZXInXHJcbmV4cG9ydCAqIGZyb20gJy4vZ3JhcGhxbC1maWVsZC5oZWxwZXInXHJcbiJdfQ==

package/esm2020/infra/hasura-graphql/mixins/index.mjs

@@ -0,0 +1,8 @@
+export * from './with-create-hasura-graphql.mixin';
+export * from './with-delete-hasura-graphql.mixin';
+export * from './with-hasura-graphql.mixin';
+export * from './with-update-hasura-graphql.mixin';
+export * from './with-get-hasura-graphql.mixin';
+export * from './with-find-hasura-graphql.mixin';
+export * from './with-crud-hasura-graphql.mixin';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQ0FBb0MsQ0FBQTtBQUNsRCxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsNkJBQTZCLENBQUE7QUFDM0MsY0FBYyxvQ0FBb0MsQ0FBQTtBQUNsRCxjQUFjLGlDQUFpQyxDQUFBO0FBQy9DLGNBQWMsa0NBQWtDLENBQUE7QUFDaEQsY0FBYyxrQ0FBa0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vd2l0aC1jcmVhdGUtaGFzdXJhLWdyYXBocWwubWl4aW4nXHJcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1kZWxldGUtaGFzdXJhLWdyYXBocWwubWl4aW4nXHJcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1oYXN1cmEtZ3JhcGhxbC5taXhpbidcclxuZXhwb3J0ICogZnJvbSAnLi93aXRoLXVwZGF0ZS1oYXN1cmEtZ3JhcGhxbC5taXhpbidcclxuZXhwb3J0ICogZnJvbSAnLi93aXRoLWdldC1oYXN1cmEtZ3JhcGhxbC5taXhpbidcclxuZXhwb3J0ICogZnJvbSAnLi93aXRoLWZpbmQtaGFzdXJhLWdyYXBocWwubWl4aW4nXHJcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1jcnVkLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xyXG4iXX0=

package/esm2020/infra/hasura-graphql/mixins/with-create-hasura-graphql.mixin.mjs

@@ -0,0 +1,39 @@
+import { DebugHelper } from '../../../utils';
+import { AttributeOptionHelper } from './helpers';
+export const withCreateHasuraGraphQL = (MixinBase) => {
+    return class CreateHasuraGraphQLMixin extends MixinBase {
+        constructor(...params) {
+            const options = params?.[0];
+            super(...params);
+            this.insertGraphQLOperation = options?.insertGraphQLOperation || `insert_${this.tableName}_one`;
+            this.insertGraphQLObjectType = options?.insertGraphQLObjectType || `${this.tableName}_insert_input`;
+        }
+        async create(data) {
+            this.logger = DebugHelper.from(this, 'create');
+            const newData = await this.save(this.model.toInstance(data));
+            return this.model.toInstance(newData);
+        }
+        async save(data) {
+            const primaryKeyColumns = this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName);
+            const foreignKeyColumns = this.fields
+                .map((field) => {
+                const columnOptions = Object.values(field).shift();
+                return (AttributeOptionHelper.CheckIsColumnOption(columnOptions) &&
+                    columnOptions.foreignKeyColumn && [
+                    ...Object.values(columnOptions.foreignKeyColumn).map((foreignKeyName) => AttributeOptionHelper.FindByAttribute(foreignKeyName, this.fields)?.columnName),
+                    {
+                        [columnOptions.columnName]: Object.keys(columnOptions.foreignKeyColumn).map((foreignKeyField) => AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions?.fields)
+                            ?.columnName || foreignKeyField),
+                    },
+                ]);
+            })
+                .filter(Boolean)
+                .reduce((keys, current) => [...keys, ...current], []);
+            const result = await this.mutation(this.insertGraphQLOperation, [...primaryKeyColumns, ...foreignKeyColumns], {
+                object: { type: this.insertGraphQLObjectType, required: true, value: this.convertDataToHasura(data) },
+            });
+            return { ...data.toPlain(), ...this.convertDataFromHasura(result[this.insertGraphQLOperation]).toPlain() };
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/hasura-graphql/mixins/with-crud-hasura-graphql.mixin.mjs

@@ -0,0 +1,10 @@
+import { withCreateHasuraGraphQL } from './with-create-hasura-graphql.mixin';
+import { withDeleteHasuraGraphQL } from './with-delete-hasura-graphql.mixin';
+import { withFindHasuraGraphQL } from './with-find-hasura-graphql.mixin';
+import { withGetHasuraGraphQL } from './with-get-hasura-graphql.mixin';
+import { withUpdateHasuraGraphQL, } from './with-update-hasura-graphql.mixin';
+export const withCrudHasuraGraphQL = (MixinBase) => {
+    return class CrudHasuraGraphQLMixin extends withUpdateHasuraGraphQL(withGetHasuraGraphQL(withFindHasuraGraphQL(withDeleteHasuraGraphQL(withCreateHasuraGraphQL(MixinBase))))) {
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/hasura-graphql/mixins/with-delete-hasura-graphql.mixin.mjs

@@ -0,0 +1,31 @@
+import { DebugHelper, isNil } from '../../../utils';
+import { AttributeOptionHelper } from './helpers';
+export const withDeleteHasuraGraphQL = (MixinBase) => {
+    return class DeleteHasuraGraphQLMixin extends MixinBase {
+        constructor(...params) {
+            const options = params?.[0];
+            super(...params);
+            this.deleteGraphQLOperation = options?.deleteGraphQLOperation || `delete_${this.tableName}_by_pk`;
+        }
+        async delete(identifiers) {
+            this.logger = DebugHelper.from(this, 'delete');
+            const instance = this.model.toInstance(identifiers);
+            await this.mutation(this.deleteGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), this.model.identifiersFields.reduce((ids, identifier) => {
+                const identifierBinded = identifier;
+                if (isNil(instance.identifier[identifierBinded]))
+                    return ids;
+                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
+                const value = columnOption.to(identifiers[identifier], instance);
+                return {
+                    ...ids,
+                    [columnOption.columnName]: {
+                        type: this.getAttributeGraphQLTypeOf(columnOption.type || value),
+                        value,
+                        required: true,
+                    },
+                };
+            }, {}));
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1kZWxldGUtaGFzdXJhLWdyYXBocWwubWl4aW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvd2l0aC1kZWxldGUtaGFzdXJhLWdyYXBocWwubWl4aW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQXFDLE1BQU0sZ0JBQWdCLENBQUE7QUFHdEYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sV0FBVyxDQUFBO0FBTWpELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBSXJDLFNBQTJELEVBSTNELEVBQUU7SUFDRixPQUFPLE1BQU0sd0JBQXlCLFNBQVEsU0FBUztRQUdyRCxZQUFZLEdBQUcsTUFBYTtZQUMxQixNQUFNLE9BQU8sR0FBNEIsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFFcEQsS0FBSyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUE7WUFFaEIsSUFBSSxDQUFDLHNCQUFzQixHQUFHLE9BQU8sRUFBRSxzQkFBc0IsSUFBSSxVQUFVLElBQUksQ0FBQyxTQUFTLFFBQVEsQ0FBQTtRQUNuRyxDQUFDO1FBRUQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxXQUEwQztZQUNyRCxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFBO1lBRTlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBRW5ELE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FDakIsSUFBSSxDQUFDLHNCQUFzQixFQUMzQixJQUFJLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FDOUIsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFVBQVUsQ0FDbEQsRUFDL0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsVUFBVSxFQUFFLEVBQUU7Z0JBQ3RELE1BQU0sZ0JBQWdCLEdBR2xCLFVBQVUsQ0FBQTtnQkFFZCxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDLENBQUM7b0JBQUUsT0FBTyxHQUFHLENBQUE7Z0JBRTVELE1BQU0sWUFBWSxHQUFHLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO2dCQUNuRixNQUFNLEtBQUssR0FBRyxZQUFZLENBQUMsRUFBRSxDQUFDLFdBQVcsQ0FBQyxVQUFpRCxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUE7Z0JBRXZHLE9BQU87b0JBQ0wsR0FBRyxHQUFHO29CQUNOLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxFQUFFO3dCQUN6QixJQUFJLEVBQUUsSUFBSSxDQUFDLHlCQUF5QixDQUFDLFlBQVksQ0FBQyxJQUFJLElBQUksS0FBSyxDQUFDO3dCQUNoRSxLQUFLO3dCQUNMLFFBQVEsRUFBRSxJQUFJO3FCQUNmO2lCQUNGLENBQUE7WUFDSCxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQ1AsQ0FBQTtRQUNILENBQUM7S0FDSyxDQUFBO0FBQ1YsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcclxuICBEZWxldGVSZXBvc2l0b3J5LFxyXG4gIERlbGV0ZVJlcG9zaXRvcnlQYXJhbXMsXHJcbiAgTW9kZWxCYXNlU3RydWN0dXJlLFxyXG4gIE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnR5TmFtZXMsXHJcbn0gZnJvbSAnLi4vLi4vLi4vZG9tYWluJ1xyXG5pbXBvcnQgeyBEZWJ1Z0hlbHBlciwgaXNOaWwsIE1lcmdlQ29uc3RydWN0b3JQYXJhbXMsIE1peGluQ3RvciB9IGZyb20gJy4uLy4uLy4uL3V0aWxzJ1xyXG5pbXBvcnQgeyBHcmFwaFFMUmVwb3NpdG9yeSwgSGFzdXJhR3JhcGhRTEZpZWxkcyB9IGZyb20gJy4uL3R5cGVzJ1xyXG5cclxuaW1wb3J0IHsgQXR0cmlidXRlT3B0aW9uSGVscGVyIH0gZnJvbSAnLi9oZWxwZXJzJ1xyXG5cclxuZXhwb3J0IHR5cGUgRGVsZXRlQ29uc3RydWN0b3JQYXJhbXMgPSB7XHJcbiAgZGVsZXRlR3JhcGhRTE9wZXJhdGlvbj86IHN0cmluZ1xyXG59XHJcblxyXG5leHBvcnQgY29uc3Qgd2l0aERlbGV0ZUhhc3VyYUdyYXBoUUwgPSA8XHJcbiAgTUJhc2UgZXh0ZW5kcyBNb2RlbEJhc2VTdHJ1Y3R1cmU8TUJhc2UsIE1CYXNlWydpZGVudGlmaWVyc0ZpZWxkcyddW251bWJlcl0+LFxyXG4gIFRNaXhpbkJhc2UgZXh0ZW5kcyBNaXhpbkN0b3I8R3JhcGhRTFJlcG9zaXRvcnk8TUJhc2U+PixcclxuPihcclxuICBNaXhpbkJhc2U6IE1peGluQ3RvcjxHcmFwaFFMUmVwb3NpdG9yeTxNQmFzZT4+ICYgVE1peGluQmFzZSxcclxuKTogTWl4aW5DdG9yPFxyXG4gIEdyYXBoUUxSZXBvc2l0b3J5PE1CYXNlPiAmIERlbGV0ZVJlcG9zaXRvcnk8TUJhc2U+ICYgSW5zdGFuY2VUeXBlPFRNaXhpbkJhc2U+LFxyXG4gIE1lcmdlQ29uc3RydWN0b3JQYXJhbXM8W0RlbGV0ZUNvbnN0cnVjdG9yUGFyYW1zLCAuLi5hbnlbXV0sIENvbnN0cnVjdG9yUGFyYW1ldGVyczxUTWl4aW5CYXNlPj5cclxuPiA9PiB7XHJcbiAgcmV0dXJuIGNsYXNzIERlbGV0ZUhhc3VyYUdyYXBoUUxNaXhpbiBleHRlbmRzIE1peGluQmFzZSBpbXBsZW1lbnRzIERlbGV0ZVJlcG9zaXRvcnk8TUJhc2U+IHtcclxuICAgIGRlbGV0ZUdyYXBoUUxPcGVyYXRpb246IHN0cmluZ1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKC4uLnBhcmFtczogYW55W10pIHtcclxuICAgICAgY29uc3Qgb3B0aW9uczogRGVsZXRlQ29uc3RydWN0b3JQYXJhbXMgPSBwYXJhbXM/LlswXVxyXG5cclxuICAgICAgc3VwZXIoLi4ucGFyYW1zKVxyXG5cclxuICAgICAgdGhpcy5kZWxldGVHcmFwaFFMT3BlcmF0aW9uID0gb3B0aW9ucz8uZGVsZXRlR3JhcGhRTE9wZXJhdGlvbiB8fCBgZGVsZXRlXyR7dGhpcy50YWJsZU5hbWV9X2J5X3BrYFxyXG4gICAgfVxyXG5cclxuICAgIGFzeW5jIGRlbGV0ZShpZGVudGlmaWVyczogRGVsZXRlUmVwb3NpdG9yeVBhcmFtczxNQmFzZT4pOiBQcm9taXNlPHZvaWQ+IHtcclxuICAgICAgdGhpcy5sb2dnZXIgPSBEZWJ1Z0hlbHBlci5mcm9tKHRoaXMsICdkZWxldGUnKVxyXG5cclxuICAgICAgY29uc3QgaW5zdGFuY2UgPSB0aGlzLm1vZGVsLnRvSW5zdGFuY2UoaWRlbnRpZmllcnMpXHJcblxyXG4gICAgICBhd2FpdCB0aGlzLm11dGF0aW9uKFxyXG4gICAgICAgIHRoaXMuZGVsZXRlR3JhcGhRTE9wZXJhdGlvbixcclxuICAgICAgICB0aGlzLm1vZGVsLmlkZW50aWZpZXJzRmllbGRzLm1hcChcclxuICAgICAgICAgIChmaWVsZCkgPT4gQXR0cmlidXRlT3B0aW9uSGVscGVyLkZpbmRCeUF0dHJpYnV0ZShmaWVsZCwgdGhpcy5maWVsZHMpLmNvbHVtbk5hbWUsXHJcbiAgICAgICAgKSBhcyBIYXN1cmFHcmFwaFFMRmllbGRzPE1CYXNlPixcclxuICAgICAgICB0aGlzLm1vZGVsLmlkZW50aWZpZXJzRmllbGRzLnJlZHVjZSgoaWRzLCBpZGVudGlmaWVyKSA9PiB7XHJcbiAgICAgICAgICBjb25zdCBpZGVudGlmaWVyQmluZGVkOiBFeHRyYWN0PFxyXG4gICAgICAgICAgICBOb25GdW5jdGlvbkFuZElkZW50aWZpZXJQcm9wZXJ0eU5hbWVzPE1CYXNlPixcclxuICAgICAgICAgICAgTUJhc2VbJ2lkZW50aWZpZXJzRmllbGRzJ11bbnVtYmVyXVxyXG4gICAgICAgICAgPiA9IGlkZW50aWZpZXJcclxuXHJcbiAgICAgICAgICBpZiAoaXNOaWwoaW5zdGFuY2UuaWRlbnRpZmllcltpZGVudGlmaWVyQmluZGVkXSkpIHJldHVybiBpZHNcclxuXHJcbiAgICAgICAgICBjb25zdCBjb2x1bW5PcHRpb24gPSBBdHRyaWJ1dGVPcHRpb25IZWxwZXIuRmluZEJ5QXR0cmlidXRlKGlkZW50aWZpZXIsIHRoaXMuZmllbGRzKVxyXG4gICAgICAgICAgY29uc3QgdmFsdWUgPSBjb2x1bW5PcHRpb24udG8oaWRlbnRpZmllcnNbaWRlbnRpZmllciBhcyBrZXlvZiBEZWxldGVSZXBvc2l0b3J5UGFyYW1zPE1CYXNlPl0sIGluc3RhbmNlKVxyXG5cclxuICAgICAgICAgIHJldHVybiB7XHJcbiAgICAgICAgICAgIC4uLmlkcyxcclxuICAgICAgICAgICAgW2NvbHVtbk9wdGlvbi5jb2x1bW5OYW1lXToge1xyXG4gICAgICAgICAgICAgIHR5cGU6IHRoaXMuZ2V0QXR0cmlidXRlR3JhcGhRTFR5cGVPZihjb2x1bW5PcHRpb24udHlwZSB8fCB2YWx1ZSksXHJcbiAgICAgICAgICAgICAgdmFsdWUsXHJcbiAgICAgICAgICAgICAgcmVxdWlyZWQ6IHRydWUsXHJcbiAgICAgICAgICAgIH0sXHJcbiAgICAgICAgICB9XHJcbiAgICAgICAgfSwge30pLFxyXG4gICAgICApXHJcbiAgICB9XHJcbiAgfSBhcyBhbnlcclxufVxyXG4iXX0=

package/esm2020/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.mjs

@@ -0,0 +1,152 @@
+import { DebugHelper, isNil, set } from '../../../utils';
+import { AttributeOptionHelper, BindFilterQueryHelper } from './helpers';
+export const withFindHasuraGraphQL = (MixinBase) => {
+    return class FindHasuraGraphQLMixin extends MixinBase {
+        constructor() {
+            super(...arguments);
+            this.bindOrderByAttributes = (orderBy, fields) => Object.keys(orderBy).reduce((acc, current) => [
+                ...acc,
+                {
+                    [AttributeOptionHelper.FindByAttribute(current, fields)
+                        .columnName]: orderBy[current] === 'asc'
+                        ? 'asc_nulls_last'
+                        : 'desc_nulls_last',
+                },
+            ], []);
+            this.bindAggretageAttributes = (aggregates, fields) => [
+                ...(aggregates?.minimal?.length
+                    ? [
+                        {
+                            min: this.bindAttributesToColumns(aggregates?.minimal, fields),
+                        },
+                    ]
+                    : []),
+                ...(aggregates?.maximum?.length
+                    ? [
+                        {
+                            max: this.bindAttributesToColumns(aggregates?.maximum, fields),
+                        },
+                    ]
+                    : []),
+            ];
+            this.bindDistinctAttributes = (distinct, fields) => this.bindAttributesToColumns(distinct, fields);
+            this.bindAttributesToColumns = (attributes, fields) => attributes.map((attr) => AttributeOptionHelper.FindByAttribute(attr.toString().split('.').pop(), fields)?.columnName || attr);
+        }
+        async find(params) {
+            this.logger = DebugHelper.from(this, 'find');
+            const { filters, limits, orderBy, options } = params || {};
+            const enableCount = options?.enableCount ?? true;
+            const variablesFilters = isNil(filters)
+                ? {}
+                : {
+                    where: {
+                        value: BindFilterQueryHelper.MakeGraphQLWhere(filters, this.fields),
+                        type: `${this.tableName}_bool_exp`,
+                        required: true,
+                    },
+                };
+            const variablesCount = {
+                ...(isNil(orderBy)
+                    ? {}
+                    : {
+                        order_by: {
+                            type: `${this.tableName}_order_by!`,
+                            list: true,
+                            value: this.bindOrderByAttributes(orderBy, this.fields),
+                        },
+                    }),
+                ...variablesFilters,
+            };
+            const variables = {
+                ...(isNil(limits) ? {} : limits),
+                ...variablesCount,
+            };
+            const aggregateFields = [
+                ...(enableCount ? ['count'] : []),
+                ...this.bindAggretageAttributes(params.options, this.fields),
+            ];
+            const result = await this.query([
+                {
+                    operation: this.tableName,
+                    fields: params.fields
+                        ? params.fields
+                            .map((fieldName) => this.fields.find((fieldOption) => fieldOption === fieldName) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === fieldName))
+                            .filter(Boolean)
+                        : this.fields,
+                    variables,
+                },
+                ...(aggregateFields.length > 0
+                    ? [
+                        {
+                            operation: `${this.tableName}_aggregate`,
+                            fields: [
+                                {
+                                    aggregate: aggregateFields,
+                                },
+                            ],
+                            variables: variablesCount,
+                        },
+                    ]
+                    : []),
+                ...((!params.limits?.offset &&
+                    params.options?.distinct?.map((distinct) => {
+                        const distinctOption = this.fields.find((fieldOption) => fieldOption === distinct) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === distinct);
+                        const fieldName = Object.values(distinctOption).shift()?.columnName || distinct;
+                        return {
+                            operation: {
+                                name: `${this.tableName}`,
+                                alias: `${this.tableName}_${distinct.toString()}_distinct`,
+                            },
+                            fields: [distinctOption],
+                            variables: {
+                                ...variablesFilters,
+                                [`${this.tableName}_${fieldName}_distinct`]: {
+                                    type: `${this.tableName}_select_column!`,
+                                    list: true,
+                                    value: fieldName,
+                                    name: 'distinct_on',
+                                },
+                            },
+                        };
+                    })) ||
+                    []),
+            ]);
+            const data = result[this.tableName].map((row) => this.convertDataFromHasura(row));
+            return {
+                data,
+                count: enableCount ? result[`${this.tableName}_aggregate`].aggregate.count : Infinity,
+                ...(options?.minimal?.length
+                    ? {
+                        minimal: options.minimal.reduce((minimals, current) => ({
+                            ...minimals,
+                            ...set(minimals, current, result[`${this.tableName}_aggregate`].aggregate.min[AttributeOptionHelper.FindByAttribute(current.toString().split('.').pop(), this.fields)?.columnName || current]),
+                        }), {}),
+                    }
+                    : {}),
+                ...(options?.maximum?.length
+                    ? {
+                        maximum: options.maximum.reduce((maximums, current) => ({
+                            ...maximums,
+                            ...set(maximums, current, result[`${this.tableName}_aggregate`].aggregate.max[AttributeOptionHelper.FindByAttribute(current.toString().split('.').pop(), this.fields)?.columnName || current]),
+                        }), {}),
+                    }
+                    : {}),
+                ...(!params.limits?.offset &&
+                    options?.distinct?.length && {
+                    distinct: options?.distinct.reduce((distinct, current) => {
+                        const distinctOption = this.fields.find((fieldOption) => fieldOption === current) ??
+                            this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === current);
+                        const fieldName = Object.values(distinctOption).shift()?.columnName || current;
+                        return {
+                            ...distinct,
+                            [current.toString()]: result[`${this.tableName}_${current.toString()}_distinct`].map((obj) => obj[fieldName]),
+                        };
+                    }, {}),
+                }),
+            };
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-find-hasura-graphql.mixin.js","sourceRoot":"","sources":["../../../../../../projects/connect/src/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  FindRepository,\r\n  FindRepositoryParams,\r\n  ModelBaseStructure,\r\n  NonFunctionAndIdentifierPropertyNames,\r\n  RepositoryFindResult,\r\n  RepositoryOrderBy,\r\n} from '../../../domain'\r\nimport { DebugHelper, isNil, MixinCtor, set } from '../../../utils'\r\nimport { GraphQLParams, GraphQLRepository, HasuraGraphQLFields } from '../types'\r\nimport { AttributeOptionHelper, BindFilterQueryHelper } from './helpers'\r\n\r\nexport const withFindHasuraGraphQL = <\r\n  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,\r\n  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,\r\n>(\r\n  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,\r\n) => {\r\n  return class FindHasuraGraphQLMixin extends MixinBase implements FindRepository<MBase> {\r\n    async find(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>> {\r\n      this.logger = DebugHelper.from(this, 'find')\r\n\r\n      const { filters, limits, orderBy, options } = params || {}\r\n      const enableCount = options?.enableCount ?? true\r\n      const variablesFilters = isNil(filters)\r\n        ? {}\r\n        : {\r\n            where: {\r\n              value: BindFilterQueryHelper.MakeGraphQLWhere(filters, this.fields),\r\n              type: `${this.tableName}_bool_exp`,\r\n              required: true,\r\n            },\r\n          }\r\n      const variablesCount = {\r\n        ...(isNil(orderBy)\r\n          ? {}\r\n          : {\r\n              order_by: {\r\n                type: `${this.tableName}_order_by!`,\r\n                list: true,\r\n                value: this.bindOrderByAttributes(orderBy, this.fields),\r\n              },\r\n            }),\r\n        ...variablesFilters,\r\n      }\r\n      const variables = {\r\n        ...(isNil(limits) ? {} : limits),\r\n        ...variablesCount,\r\n      }\r\n      const aggregateFields = [\r\n        ...(enableCount ? ['count'] : []),\r\n        ...this.bindAggretageAttributes(params.options, this.fields),\r\n      ]\r\n      const result = await this.query([\r\n        {\r\n          operation: this.tableName,\r\n          fields: params.fields\r\n            ? params.fields\r\n                .map(\r\n                  (fieldName) =>\r\n                    this.fields.find((fieldOption) => fieldOption === fieldName) ??\r\n                    this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === fieldName),\r\n                )\r\n                .filter(Boolean)\r\n            : this.fields,\r\n          variables,\r\n        },\r\n        ...(aggregateFields.length > 0\r\n          ? [\r\n              {\r\n                operation: `${this.tableName}_aggregate`,\r\n                fields: [\r\n                  {\r\n                    aggregate: aggregateFields,\r\n                  },\r\n                ],\r\n                variables: variablesCount,\r\n              } as GraphQLParams<MBase>,\r\n            ]\r\n          : []),\r\n        ...((!params.limits?.offset &&\r\n          params.options?.distinct?.map((distinct) => {\r\n            const distinctOption =\r\n              this.fields.find((fieldOption) => fieldOption === distinct) ??\r\n              this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === distinct)\r\n            const fieldName = Object.values(distinctOption).shift()?.columnName || distinct\r\n\r\n            return {\r\n              operation: {\r\n                name: `${this.tableName}`,\r\n                alias: `${this.tableName}_${distinct.toString()}_distinct`,\r\n              },\r\n              fields: [distinctOption],\r\n              variables: {\r\n                ...variablesFilters,\r\n                [`${this.tableName}_${fieldName}_distinct`]: {\r\n                  type: `${this.tableName}_select_column!`,\r\n                  list: true,\r\n                  value: fieldName,\r\n                  name: 'distinct_on',\r\n                },\r\n              },\r\n            } as GraphQLParams<MBase>\r\n          })) ||\r\n          []),\r\n      ])\r\n      const data: MBase[] = result[this.tableName].map((row: Record<string, string | number>) =>\r\n        this.convertDataFromHasura(row),\r\n      )\r\n\r\n      return {\r\n        data,\r\n        count: enableCount ? result[`${this.tableName}_aggregate`].aggregate.count : Infinity,\r\n        ...(options?.minimal?.length\r\n          ? {\r\n              minimal: options.minimal.reduce(\r\n                (minimals, current) => ({\r\n                  ...(minimals as any),\r\n                  ...set(\r\n                    minimals as any,\r\n                    current as any,\r\n                    result[`${this.tableName}_aggregate`].aggregate.min[\r\n                      AttributeOptionHelper.FindByAttribute(\r\n                        current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n                        this.fields,\r\n                      )?.columnName || (current as any)\r\n                    ],\r\n                  ),\r\n                }),\r\n                {},\r\n              ) as RepositoryFindResult<MBase>['minimal'],\r\n            }\r\n          : {}),\r\n        ...(options?.maximum?.length\r\n          ? {\r\n              maximum: options.maximum.reduce(\r\n                (maximums, current) => ({\r\n                  ...(maximums as any),\r\n                  ...set(\r\n                    maximums as any,\r\n                    current as any,\r\n                    result[`${this.tableName}_aggregate`].aggregate.max[\r\n                      AttributeOptionHelper.FindByAttribute(\r\n                        current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n                        this.fields,\r\n                      )?.columnName || (current as any)\r\n                    ],\r\n                  ),\r\n                }),\r\n                {},\r\n              ) as RepositoryFindResult<MBase>['maximum'],\r\n            }\r\n          : {}),\r\n        ...(!params.limits?.offset &&\r\n          options?.distinct?.length && {\r\n            distinct: options?.distinct.reduce((distinct, current) => {\r\n              const distinctOption =\r\n                this.fields.find((fieldOption) => fieldOption === current) ??\r\n                this.fields.find((fieldOption) => Object.keys(fieldOption).shift() === current)\r\n              const fieldName = Object.values(distinctOption).shift()?.columnName || current\r\n\r\n              return {\r\n                ...distinct,\r\n                [current.toString()]: result[`${this.tableName}_${current.toString()}_distinct`].map(\r\n                  (obj: Record<string, string | number>) => obj[fieldName],\r\n                ),\r\n              }\r\n            }, {} as any),\r\n          }),\r\n      }\r\n    }\r\n\r\n    bindOrderByAttributes = (orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>) =>\r\n      Object.keys(orderBy).reduce(\r\n        (acc, current) => [\r\n          ...acc,\r\n          {\r\n            [AttributeOptionHelper.FindByAttribute(current as NonFunctionAndIdentifierPropertyNames<MBase>, fields)\r\n              .columnName]:\r\n              orderBy[current as NonFunctionAndIdentifierPropertyNames<MBase>] === 'asc'\r\n                ? 'asc_nulls_last'\r\n                : 'desc_nulls_last',\r\n          },\r\n        ],\r\n        [],\r\n      )\r\n\r\n    bindAggretageAttributes = (\r\n      aggregates: {\r\n        minimal?: FindRepositoryParams<MBase>['options']['minimal']\r\n        maximum?: FindRepositoryParams<MBase>['options']['maximum']\r\n      },\r\n      fields: HasuraGraphQLFields<MBase>,\r\n    ) => [\r\n      ...(aggregates?.minimal?.length\r\n        ? [\r\n            {\r\n              min: this.bindAttributesToColumns(aggregates?.minimal, fields),\r\n            },\r\n          ]\r\n        : []),\r\n      ...(aggregates?.maximum?.length\r\n        ? [\r\n            {\r\n              max: this.bindAttributesToColumns(aggregates?.maximum, fields),\r\n            },\r\n          ]\r\n        : []),\r\n    ]\r\n\r\n    bindDistinctAttributes = (\r\n      distinct: FindRepositoryParams<MBase>['options']['distinct'],\r\n      fields: HasuraGraphQLFields<MBase>,\r\n    ) => this.bindAttributesToColumns(distinct, fields)\r\n\r\n    bindAttributesToColumns = (\r\n      attributes: Array<NonFunctionAndIdentifierPropertyNames<MBase> | {}>,\r\n      fields: HasuraGraphQLFields<MBase>,\r\n    ) =>\r\n      attributes.map(\r\n        (attr) =>\r\n          AttributeOptionHelper.FindByAttribute(\r\n            attr.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,\r\n            fields,\r\n          )?.columnName || attr,\r\n      )\r\n  }\r\n}\r\n"]}