@infrab4a/connect 4.1.6 → 4.2.0-beta.1

package/esm2020/infra/firebase/firestore/types/firestore.helpers.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZXN0b3JlLmhlbHBlcnMudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2ZpcmViYXNlL2ZpcmVzdG9yZS90eXBlcy9maXJlc3RvcmUuaGVscGVycy50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBRdWVyeURvY3VtZW50U25hcHNob3QsIFF1ZXJ5U25hcHNob3QgfSBmcm9tICdmaXJlYmFzZS9maXJlc3RvcmUnXG5cbmltcG9ydCB7IE1vZGVsQmFzZVN0cnVjdHVyZSB9IGZyb20gJy4uLy4uLy4uLy4uL2RvbWFpbidcblxuaW1wb3J0IHsgRmlyZXN0b3JlU3ViUmVwb3NpdG9yeSB9IGZyb20gJy4vZmlyZXN0b3JlLXN1Yi5yZXBvc2l0b3J5LnR5cGUnXG5pbXBvcnQgeyBGaXJlc3RvcmVSZXBvc2l0b3J5IH0gZnJvbSAnLi9maXJlc3RvcmUucmVwb3NpdG9yeS50eXBlJ1xuXG5leHBvcnQgaW50ZXJmYWNlIEZpcmVzdG9yZUhlbHBlcnMge1xuICB0b0FycmF5PFQgZXh0ZW5kcyBNb2RlbEJhc2VTdHJ1Y3R1cmU8VD4+KHNuYXBTaG90OiBRdWVyeVNuYXBzaG90PFQ+IHwgQXJyYXk8UXVlcnlEb2N1bWVudFNuYXBzaG90PFQ+Pik6IEFycmF5PFQ+XG4gIGlzU3ViQ29sbGVjdGlvbjxUIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlPFQ+LCBFIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlPEU+PihcbiAgICByZXBvc2l0b3J5OiBGaXJlc3RvcmVSZXBvc2l0b3J5PFQ+IHwgRmlyZXN0b3JlU3ViUmVwb3NpdG9yeTxULCBFPixcbiAgKTogcmVwb3NpdG9yeSBpcyBGaXJlc3RvcmVTdWJSZXBvc2l0b3J5PFQsIEU+XG59XG4iXX0=

package/esm2020/infra/firebase/firestore/types/firestore.repository.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZXN0b3JlLnJlcG9zaXRvcnkudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2ZpcmViYXNlL2ZpcmVzdG9yZS90eXBlcy9maXJlc3RvcmUucmVwb3NpdG9yeS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2xsZWN0aW9uUmVmZXJlbmNlLCBEb2N1bWVudERhdGEsIEZpcmVzdG9yZSwgUXVlcnlEb2N1bWVudFNuYXBzaG90IH0gZnJvbSAnZmlyZWJhc2UvZmlyZXN0b3JlJ1xuXG5pbXBvcnQgeyBCYXNlTW9kZWxCdWlsZGVyLCBNb2RlbEJhc2VTdHJ1Y3R1cmUsIE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnR5TmFtZXMgfSBmcm9tICcuLi8uLi8uLi8uLi9kb21haW4nXG5pbXBvcnQgeyBGaXJlc3RvcmVGaWVsZFR5cGUgfSBmcm9tICcuLi9lbnVtcydcbmltcG9ydCB7IEZpcmVzdG9yZUludGVyY2VwdG9ycyB9IGZyb20gJy4vZmlyZXN0b3JlLWludGVyY2VwdG9ycy50eXBlJ1xuXG5leHBvcnQgdHlwZSBGaXJlc3RvcmVSZXBvc2l0b3J5PE1vZGVsIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlPE1vZGVsPj4gPSB7XG4gIHJlYWRvbmx5IGZpcmVzdG9yZT86IEZpcmVzdG9yZVxuICBjb2xsZWN0aW9uTmFtZTogc3RyaW5nXG4gIG1vZGVsOiBCYXNlTW9kZWxCdWlsZGVyPE1vZGVsPlxuICBjb2xsZWN0aW9uKHBhdGg/OiBzdHJpbmcpOiBDb2xsZWN0aW9uUmVmZXJlbmNlPE1vZGVsPlxuICBmaWVsZHM/OiBQYXJ0aWFsPFJlY29yZDxOb25GdW5jdGlvbkFuZElkZW50aWZpZXJQcm9wZXJ0eU5hbWVzPE1vZGVsPiwgRmlyZXN0b3JlRmllbGRUeXBlPj5cbiAgaW50ZXJjZXB0b3JzPzogRmlyZXN0b3JlSW50ZXJjZXB0b3JzPE1vZGVsPlxuICBidWlsZE1vZGVsSW5zdGFuY2UoKToge1xuICAgIHRvRmlyZXN0b3JlOiAoZGF0YTogTW9kZWwpID0+IERvY3VtZW50RGF0YVxuICAgIGZyb21GaXJlc3RvcmU6IChzbmFwOiBRdWVyeURvY3VtZW50U25hcHNob3Q8TW9kZWw+KSA9PiBNb2RlbFxuICB9XG59XG4iXX0=

package/esm2020/infra/firebase/firestore/types/index.mjs

@@ -0,0 +1,5 @@
+export * from './firestore-interceptors.type';
+export * from './firestore-sub.repository.type';
+export * from './firestore.helpers.type';
+export * from './firestore.repository.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9maXJlYmFzZS9maXJlc3RvcmUvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQTtBQUM3QyxjQUFjLGlDQUFpQyxDQUFBO0FBQy9DLGNBQWMsMEJBQTBCLENBQUE7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlLWludGVyY2VwdG9ycy50eXBlJ1xuZXhwb3J0ICogZnJvbSAnLi9maXJlc3RvcmUtc3ViLnJlcG9zaXRvcnkudHlwZSdcbmV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlLmhlbHBlcnMudHlwZSdcbmV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlLnJlcG9zaXRvcnkudHlwZSdcbiJdfQ==

package/esm2020/infra/firebase/index.mjs

@@ -0,0 +1,3 @@
+export * from './firestore';
+export * from './auth';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9maXJlYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLFFBQVEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlJ1xuZXhwb3J0ICogZnJvbSAnLi9hdXRoJ1xuIl19

package/esm2020/infra/hasura-graphql/enums/hasura-graphql-column-type.enum.mjs

@@ -0,0 +1,13 @@
+export var HasuraGraphQLColumnType;
+(function (HasuraGraphQLColumnType) {
+    HasuraGraphQLColumnType["Int"] = "Int";
+    HasuraGraphQLColumnType["Float"] = "Float";
+    HasuraGraphQLColumnType["Boolean"] = "Boolean";
+    HasuraGraphQLColumnType["String"] = "String";
+    HasuraGraphQLColumnType["DateTime"] = "timestampz";
+    HasuraGraphQLColumnType["Json"] = "json";
+    HasuraGraphQLColumnType["Jsonb"] = "jsonb";
+    HasuraGraphQLColumnType["Enum"] = "enum";
+    HasuraGraphQLColumnType["Uuid"] = "uuid";
+})(HasuraGraphQLColumnType || (HasuraGraphQLColumnType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzdXJhLWdyYXBocWwtY29sdW1uLXR5cGUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2hhc3VyYS1ncmFwaHFsL2VudW1zL2hhc3VyYS1ncmFwaHFsLWNvbHVtbi10eXBlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksdUJBVVg7QUFWRCxXQUFZLHVCQUF1QjtJQUNqQyxzQ0FBVyxDQUFBO0lBQ1gsMENBQWUsQ0FBQTtJQUNmLDhDQUFtQixDQUFBO0lBQ25CLDRDQUFpQixDQUFBO0lBQ2pCLGtEQUF1QixDQUFBO0lBQ3ZCLHdDQUFhLENBQUE7SUFDYiwwQ0FBZSxDQUFBO0lBQ2Ysd0NBQWEsQ0FBQTtJQUNiLHdDQUFhLENBQUE7QUFDZixDQUFDLEVBVlcsdUJBQXVCLEtBQXZCLHVCQUF1QixRQVVsQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEhhc3VyYUdyYXBoUUxDb2x1bW5UeXBlIHtcbiAgSW50ID0gJ0ludCcsXG4gIEZsb2F0ID0gJ0Zsb2F0JyxcbiAgQm9vbGVhbiA9ICdCb29sZWFuJyxcbiAgU3RyaW5nID0gJ1N0cmluZycsXG4gIERhdGVUaW1lID0gJ3RpbWVzdGFtcHonLFxuICBKc29uID0gJ2pzb24nLFxuICBKc29uYiA9ICdqc29uYicsXG4gIEVudW0gPSAnZW51bScsXG4gIFV1aWQgPSAndXVpZCcsXG59XG4iXX0=

package/esm2020/infra/hasura-graphql/enums/hasura-graphql-where.enum.mjs

@@ -0,0 +1,17 @@
+export var HasuraGraphQLWhere;
+(function (HasuraGraphQLWhere) {
+    HasuraGraphQLWhere["EQUALS"] = "_eq";
+    HasuraGraphQLWhere["GT"] = "_gt";
+    HasuraGraphQLWhere["GTE"] = "_gte";
+    HasuraGraphQLWhere["IN"] = "_in";
+    HasuraGraphQLWhere["NOTIN"] = "_nin";
+    HasuraGraphQLWhere["LT"] = "_lt";
+    HasuraGraphQLWhere["LTE"] = "_lte";
+    HasuraGraphQLWhere["LIKE"] = "_like";
+    HasuraGraphQLWhere["NOTLIKE"] = "_nlike";
+    HasuraGraphQLWhere["ISNULL"] = "_is_null";
+    HasuraGraphQLWhere["ISNOTNULL"] = "_is_null";
+    HasuraGraphQLWhere["JSON_CONTAINS"] = "_contains";
+    HasuraGraphQLWhere["JSON_HAS_KEYS_ANY"] = "_has_keys_any";
+})(HasuraGraphQLWhere || (HasuraGraphQLWhere = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzdXJhLWdyYXBocWwtd2hlcmUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2hhc3VyYS1ncmFwaHFsL2VudW1zL2hhc3VyYS1ncmFwaHFsLXdoZXJlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksa0JBY1g7QUFkRCxXQUFZLGtCQUFrQjtJQUM1QixvQ0FBYyxDQUFBO0lBQ2QsZ0NBQVUsQ0FBQTtJQUNWLGtDQUFZLENBQUE7SUFDWixnQ0FBVSxDQUFBO0lBQ1Ysb0NBQWMsQ0FBQTtJQUNkLGdDQUFVLENBQUE7SUFDVixrQ0FBWSxDQUFBO0lBQ1osb0NBQWMsQ0FBQTtJQUNkLHdDQUFrQixDQUFBO0lBQ2xCLHlDQUFtQixDQUFBO0lBQ25CLDRDQUFzQixDQUFBO0lBQ3RCLGlEQUEyQixDQUFBO0lBQzNCLHlEQUFtQyxDQUFBO0FBQ3JDLENBQUMsRUFkVyxrQkFBa0IsS0FBbEIsa0JBQWtCLFFBYzdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gSGFzdXJhR3JhcGhRTFdoZXJlIHtcbiAgRVFVQUxTID0gJ19lcScsXG4gIEdUID0gJ19ndCcsXG4gIEdURSA9ICdfZ3RlJyxcbiAgSU4gPSAnX2luJyxcbiAgTk9USU4gPSAnX25pbicsXG4gIExUID0gJ19sdCcsXG4gIExURSA9ICdfbHRlJyxcbiAgTElLRSA9ICdfbGlrZScsXG4gIE5PVExJS0UgPSAnX25saWtlJyxcbiAgSVNOVUxMID0gJ19pc19udWxsJyxcbiAgSVNOT1ROVUxMID0gJ19pc19udWxsJyxcbiAgSlNPTl9DT05UQUlOUyA9ICdfY29udGFpbnMnLFxuICBKU09OX0hBU19LRVlTX0FOWSA9ICdfaGFzX2tleXNfYW55Jyxcbn1cbiJdfQ==

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

@@ -0,0 +1,3 @@
+export * from './hasura-graphql-where.enum';
+export * from './hasura-graphql-column-type.enum';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9lbnVtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFBO0FBQzNDLGNBQWMsbUNBQW1DLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2hhc3VyYS1ncmFwaHFsLXdoZXJlLmVudW0nXG5leHBvcnQgKiBmcm9tICcuL2hhc3VyYS1ncmFwaHFsLWNvbHVtbi10eXBlLmVudW0nXG4iXX0=

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

@@ -0,0 +1,5 @@
+export * from './mixins';
+export * from './models';
+export * from './repositories';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQTtBQUN4QixjQUFjLFVBQVUsQ0FBQTtBQUN4QixjQUFjLGdCQUFnQixDQUFBO0FBQzlCLGNBQWMsU0FBUyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9taXhpbnMnXG5leHBvcnQgKiBmcm9tICcuL21vZGVscydcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3NpdG9yaWVzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcydcbiJdfQ==

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

@@ -0,0 +1,35 @@
+import { is, isNil, isObject } from '../../../../utils';
+export class AttributeOptionHelper {
+}
+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,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

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":"AAAA,OAAO,EAML,KAAK,GACN,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAEzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAE3D,MAAM,OAAO,qBAAqB;;AACzB,sCAAgB,GAAG,CACxB,MAAqC,EACrC,MAAkC,EACjB,EAAE,CACnB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,SAA0B,EAAE,SAAiB,EAAE,EAAE;IAC3E,MAAM,YAAY,GAAG,qBAAqB,CAAC,eAAe,CACxD,SAAyD,EACzD,MAAM,CACP,CAAA;IAED,IAAI,CAAC,YAAY,CAAC,cAAc;QAC9B,OAAO;YACL,GAAG,SAAS;YACZ,GAAG;gBACD,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC,kBAAkB,CACjE,SAAyD,EACzD,MAAM,CAAC,SAAyD,CAG/D,EACD,MAAM,CACP;aACF;SACF,CAAA;IAEH,MAAM,WAAW,GAAkC,YAAY,CAAC,cAAc,CAC5E,MAAM,CAAC,SAA4C,CAGlD,CACF,CAAA;IAED,OAAO;QACL,GAAG,SAAS;QACZ,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAChC,CAAC,aAA8B,EAAE,UAAkB,EAAE,EAAE,CAAC,CAAC;YACvD,GAAG,aAAa;YAChB,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC,kBAAkB,CACpD,SAAyD,EACzD,WAAW,CAAC,UAA0D,CAGrE,EACD,MAAM,CACP;SACF,CAAC,EACF,EAAE,CACH;KACF,CAAA;AACH,CAAC,EAAE,EAAE,CAAC,CAAA;AAED,wCAAkB,GAAG,CAC1B,KAAmD,EACnD,OAA2F,EAC3F,MAAkC,EACjB,EAAE;IACnB,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,eAAe,CAAQ,KAAK,EAAE,MAAM,CAAC,CAAA;IACxF,MAAM,aAAa,GACjB,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QACvB,QAAQ,CAAC,OAAO,CAAC;QACjB,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC;QACxB,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC;QACrB,KAAK,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAA;IAEjC,IAAI,aAAa;QACf,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE;YACpD,MAAM,YAAY,GAAG,qBAAqB,CAAC,eAAe,CACxD,GAAmD,EACnD,oBAAoB,EAAE,MAAM,IAAK,MAAc,CAChD,CAAA;YACD,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,CAAA;YAC1C,MAAM,YAAY,GAAG,YAAY,CAAC,MAAM,CAAA;YAExC,OAAO;gBACL,GAAG,SAAS;gBACZ,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC,kBAAkB,CACpD,GAAmD,EACnD,EAAE,CACA,EAAE,CAAgC,OAAO,CAAC,CAAC,GAAmD,CAAC,CAChG,EACD,oBAAoB,EAAE,MAAM,IAAI,YAAY,IAAK,MAAc,CAChE;aACF,CAAA;QACH,CAAC,EAAE,EAAE,CAAC,CAAA;IAER,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC;QAChE,OAAO;YACL,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAiD,CAAC,EAC9E,qBAAqB,CAAC,qBAAqB,CACzC,OAAO,EACP,oBAAiG,CAClG;SACJ,CAAA;IAEH,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,OAAO,CAAC;QACpG,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAA8C,CAAA;IAElF,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAC3B,CAAC,CAAC,OAAO,CAAC,MAAM,CACZ,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;YAC1B,GAAG,aAAa;YAChB,GAAG,qBAAqB,CAAC,qBAAqB,CAC5C,MAAM,EACN,oBAAiG,CAClG;SACF,CAAC,EACF,EAAE,CACH;QACH,CAAC,CAAC,qBAAqB,CAAC,qBAAqB,CACzC,OAAO,EACP,oBAAiG,CAClG,CAAA;AACP,CAAC,CAAA;AAEM,2CAAqB,GAAG,CAC7B,OAAkD,EAClD,WAAoC,EACnB,EAAE,CAAC,CAAC;IACrB,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,kBAAkB,CAAC,kBAAkB,CACpG,OAAO,EACP,WAAW,CACZ;CACF,CAAC,CAAA;AAEK,uCAAiB,GAAG,CACzB,OAA8E,EAC9E,WAAoC,EAChB,EAAE,CACtB,kBAAkB,CAAC,qBAAqB,CAAC,OAAO,CAAC;IAC/C,CAAC,CAAC,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,KAAK;QAClD,CAAC,CAAC,qBAAqB,CAAC,sBAAsB,CAAC,OAAO,CAAC;QACvD,CAAC,CAAC,kBAAkB,CAChB,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAClC,CAAC,eAAe,EAAE,EAAE,CAClB,eAAe;YACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,QAA8B,CAAC,KAAK,OAAO,EAAE,QAAQ,CAAC,CAClE,CACrC;IACL,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAA;AAExB,4CAAsB,GAAG,CAC9B,OAA8E,EAC1D,EAAE,CACtB,OAAO,CAAC,QAAQ,KAAK,KAAK,CAAC,EAAE;IAC3B,CAAC,CAAC,kBAAkB,CAAC,aAAa;IAClC,CAAC,CAAC,OAAO,CAAC,QAAQ,KAAK,KAAK,CAAC,IAAI;QACjC,CAAC,CAAC,kBAAkB,CAAC,iBAAiB;QACtC,CAAC,CAAC,kBAAkB,CAChB,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAClC,CAAC,eAAe,EAAE,EAAE,CAClB,eAAe;YACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,QAA8B,CAAC,KAAK,OAAO,EAAE,QAAQ,CAAC,CAClE,CACrC,CAAA","sourcesContent":["import {\n  ModelBaseStructure,\n  NonFunctionAndIdentifierPropertyNames,\n  NonFunctionPropertyNames,\n  RepositoryFindFielters,\n  RepositoryFindFieltersOptions,\n  Where,\n} from '../../../../domain'\nimport { is, isNil, isObject } from '../../../../utils'\nimport { HasuraGraphQLColumnType, HasuraGraphQLWhere } from '../../enums'\nimport { ColumnOptions, HasuraGraphQLFields, VariableOptions } from '../../types'\nimport { AttributeOptionHelper } from './attribute-option.helper'\nimport { FilterOptionHelper } from './filter-option.helper'\n\nexport class BindFilterQueryHelper {\n  static MakeGraphQLWhere = <MBase extends ModelBaseStructure<MBase>>(\n    filter: RepositoryFindFielters<MBase>,\n    fields: HasuraGraphQLFields<MBase>,\n  ): VariableOptions =>\n    Object.keys(filter).reduce((variables: VariableOptions, fieldName: string) => {\n      const columnOption = AttributeOptionHelper.FindByAttribute(\n        fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\n        fields,\n      )\n\n      if (!columnOption.bindFindFilter)\n        return {\n          ...variables,\n          ...{\n            [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(\n              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\n              filter[fieldName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<\n                MBase,\n                NonFunctionAndIdentifierPropertyNames<MBase>\n              >,\n              fields,\n            ),\n          },\n        }\n\n      const builtFilter: RepositoryFindFielters<MBase> = columnOption.bindFindFilter(\n        filter[fieldName as NonFunctionPropertyNames<MBase>] as RepositoryFindFieltersOptions<\n          MBase,\n          NonFunctionPropertyNames<MBase>\n        >,\n      )\n\n      return {\n        ...variables,\n        ...Object.keys(builtFilter).reduce(\n          (variablesList: VariableOptions, columnName: string) => ({\n            ...variablesList,\n            [columnName]: BindFilterQueryHelper.BuildWhereSentence(\n              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,\n              builtFilter[columnName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<\n                MBase,\n                NonFunctionAndIdentifierPropertyNames<MBase>\n              >,\n              fields,\n            ),\n          }),\n          {},\n        ),\n      }\n    }, {})\n\n  static BuildWhereSentence = <MBase extends ModelBaseStructure<MBase>>(\n    field: NonFunctionAndIdentifierPropertyNames<MBase>,\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>,\n    fields: HasuraGraphQLFields<MBase>,\n  ): VariableOptions => {\n    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute<MBase>(field, fields)\n    const isNestedField =\n      !Array.isArray(options) &&\n      isObject(options) &&\n      isNil(options?.operator) &&\n      isNil(options?.value) &&\n      isNil(fieldSentenceOptions?.to)\n\n    if (isNestedField)\n      return Object.keys(options).reduce((variables, key) => {\n        const fieldOptions = AttributeOptionHelper.FindByAttribute<MBase>(\n          key as NonFunctionAndIdentifierPropertyNames<MBase>,\n          fieldSentenceOptions?.fields || (fields as any),\n        )\n        const columnName = fieldOptions.columnName\n        const columnFields = fieldOptions.fields\n\n        return {\n          ...variables,\n          [columnName]: BindFilterQueryHelper.BuildWhereSentence<MBase>(\n            key as NonFunctionAndIdentifierPropertyNames<MBase>,\n            is<RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>>(\n              is<RepositoryFindFielters<MBase>>(options)[key as NonFunctionAndIdentifierPropertyNames<MBase>],\n            ),\n            fieldSentenceOptions?.fields || columnFields || (fields as any),\n          ),\n        }\n      }, {})\n\n    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))\n      return {\n        [fieldSentenceOptions.fields[0] as NonFunctionAndIdentifierPropertyNames<MBase>]:\n          BindFilterQueryHelper.BuildOperatorSentence(\n            options,\n            fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\n          ),\n      }\n\n    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))\n      options = Object.values(options)[0] as RepositoryFindFieltersOptions<MBase, any>\n\n    return Array.isArray(options)\n      ? options.reduce(\n          (whereSentence, option) => ({\n            ...whereSentence,\n            ...BindFilterQueryHelper.BuildOperatorSentence(\n              option,\n              fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\n            ),\n          }),\n          {},\n        )\n      : BindFilterQueryHelper.BuildOperatorSentence(\n          options,\n          fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,\n        )\n  }\n\n  static BuildOperatorSentence = <MBase extends ModelBaseStructure<MBase>>(\n    options: RepositoryFindFieltersOptions<MBase, any>,\n    fieldOption: ColumnOptions<any, any>,\n  ): VariableOptions => ({\n    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(\n      options,\n      fieldOption,\n    ),\n  })\n\n  static GetHasuraOperator = <MBase extends ModelBaseStructure<MBase>>(\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,\n    fieldOption: ColumnOptions<any, any>,\n  ): HasuraGraphQLWhere =>\n    FilterOptionHelper.CheckIfIsFilterOption(options)\n      ? fieldOption.type === HasuraGraphQLColumnType.Jsonb\n        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)\n        : HasuraGraphQLWhere[\n            Object.keys(HasuraGraphQLWhere).find(\n              (graphQLOperator) =>\n                graphQLOperator ===\n                Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),\n            ) as keyof typeof HasuraGraphQLWhere\n          ]\n      : HasuraGraphQLWhere.EQUALS\n\n  static GetHasuraJsonbOperator = <MBase extends ModelBaseStructure<MBase>>(\n    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,\n  ): HasuraGraphQLWhere =>\n    options.operator === Where.IN\n      ? HasuraGraphQLWhere.JSON_CONTAINS\n      : options.operator === Where.LIKE\n      ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY\n      : HasuraGraphQLWhere[\n          Object.keys(HasuraGraphQLWhere).find(\n            (graphQLOperator) =>\n              graphQLOperator ===\n              Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),\n          ) as keyof typeof HasuraGraphQLWhere\n        ]\n}\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'\nimport {\n  BaseModel,\n  ModelBaseStructure,\n  NonFunctionAndIdentifierPropertiesWithNoPartial,\n  NonFunctionAndIdentifierPropertyNames,\n  PartialIdentifiersModel,\n} from '../../../../domain'\nimport { is, isDate, isEmpty, isNil, isObject, isString, parseDateTime } from '../../../../utils'\nimport { ColumnOptions, Fields, GraphQLParams, HasuraGraphQLFields } from '../../types'\nimport { AttributeOptionHelper } from './attribute-option.helper'\nimport { BindFilterQueryHelper } from './bind-filter-query.helper'\n\nexport class GraphQLFieldHelper {\n  static CheckIsGraphQLParams = <Model extends ModelBaseStructure<Model>>(\n    params: string | IOperation | GraphQLParams<Model>[],\n  ): params is GraphQLParams<Model>[] =>\n    !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation\n\n  static ConvertModelFieldsToGraphQLFields = <Model extends ModelBaseStructure<Model>>(\n    fields: HasuraGraphQLFields<Model>,\n  ): Fields => {\n    return fields\n      ?.map((field) => {\n        if (isString(field)) return field.toString()\n        if (field === 'affected_rows') return field\n\n        const fieldName = Object.keys(field).shift()\n        const fieldValue = is<ColumnOptions<any, Model>>(field[fieldName as keyof typeof field])\n\n        if (Array.isArray(fieldValue))\n          return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) }\n        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue)) return\n\n        const isNestedField = !!fieldValue.fields\n\n        if (isNestedField) return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue as any)\n\n        return fieldValue.columnName\n      })\n      .filter((field) => !!field)\n  }\n\n  static ConvertFieldValueFrom = <\n    Model extends ModelBaseStructure,\n    RecordDataType extends string | number | DataType | Date,\n    DataType extends Record<string, RecordDataType | RecordDataType[]>,\n  >(\n    data: DataType,\n    fields: HasuraGraphQLFields<Model>,\n  ): NonFunctionAndIdentifierPropertiesWithNoPartial<Model> | PartialIdentifiersModel<Model> =>\n    Object.keys(data).reduce((result, columnName) => {\n      const {\n        attributeName,\n        fields: attributeFields,\n        from,\n      } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields)\n\n      if (!!attributeFields && Array.isArray(attributeFields)) {\n        if (Array.isArray(data[columnName]))\n          return {\n            ...result,\n            [attributeName]: from\n              ? from(data[columnName], data)\n              : is<RecordDataType[]>(data[columnName]).map((value) =>\n                  GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(value), attributeFields),\n                ),\n          }\n        if (isObject(data[columnName]))\n          return {\n            ...result,\n            [attributeName]: !!from\n              ? from(data[columnName])\n              : GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(data[columnName]), attributeFields),\n          }\n      }\n\n      if (!!from) return { ...result, [attributeName]: from(data[columnName], data) }\n\n      return {\n        ...result,\n        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],\n      }\n    }, {})\n\n  static ConvertFieldValueTo = <\n    Model extends ModelBaseStructure<Model>,\n    DataType extends Record<string, string | number | DataType | Date>,\n  >(\n    instance: Model,\n    fields: HasuraGraphQLFields<Model>,\n    update = false,\n  ): DataType => {\n    const data: Partial<Model> = instance.toPlain?.() || instance\n\n    return Object.keys(data).reduce((result, attributeName) => {\n      const {\n        columnName,\n        fields: attributeFields,\n        foreignKeyColumn,\n        to,\n        bindPersistData,\n      } = AttributeOptionHelper.FindByAttribute(attributeName as NonFunctionAndIdentifierPropertyNames<Model>, fields)\n\n      if (bindPersistData)\n        return {\n          ...result,\n          ...bindPersistData(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>], instance),\n        }\n      if (isNil(columnName)) return result\n      if (\n        !!foreignKeyColumn &&\n        !isEmpty(foreignKeyColumn) &&\n        !Object.keys(foreignKeyColumn).filter(\n          (key) =>\n            !is<Record<string, string>>(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>])?.[key],\n        ).length\n      )\n        return Object.keys(foreignKeyColumn).reduce(\n          (object, current) => {\n            const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(\n              foreignKeyColumn[current as keyof HasuraGraphQLFields<Model>[number]],\n              fields,\n            )\n\n            return {\n              ...object,\n              [foreignColumnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]]?.[current],\n            }\n          },\n          { ...result },\n        )\n\n      if (\n        update &&\n        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]]) &&\n        !isNil(attributeFields) &&\n        !isDate(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])\n      )\n        return result\n\n      if (\n        !!columnName &&\n        Array.isArray(attributeFields) &&\n        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])\n      ) {\n        const converted =\n          !isNil(columnName) && to\n            ? to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance)\n            : data[attributeName as keyof HasuraGraphQLFields<Model>[number]]\n\n        return {\n          ...result,\n          ...(converted !== undefined\n            ? {\n                [columnName]: {\n                  data:\n                    instance[attributeName as NonFunctionAndIdentifierPropertyNames<Model>] instanceof BaseModel\n                      ? GraphQLFieldHelper.ConvertFieldValueTo(\n                          data[attributeName as keyof HasuraGraphQLFields<Model>[number]],\n                          attributeFields as HasuraGraphQLFields<Model>,\n                        )\n                      : converted,\n                },\n              }\n            : {}),\n        }\n      }\n\n      if (!!to)\n        return {\n          ...result,\n          [columnName]: to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance),\n        }\n\n      return { ...result, [columnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]] }\n    }, {} as DataType)\n  }\n\n  private static ConvertNestedFieldsToGraphQLFields = <\n    T extends ModelBaseStructure<T>,\n    P extends ModelBaseStructure<P>,\n  >(\n    fieldName: string,\n    fieldValue: ColumnOptions<T, P>,\n  ) => {\n    const hasCustomFilters = !!fieldValue.filters\n\n    if (hasCustomFilters)\n      return {\n        operation: fieldValue.columnName || fieldName,\n        fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),\n        variables: {\n          [`${fieldValue.columnName}_where`]: {\n            name: 'where',\n            type: fieldValue.filters.filterType,\n            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),\n            required: true,\n          },\n        },\n      }\n\n    return {\n      [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),\n    }\n  }\n}\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFBO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUE7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHdCQUF3QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdHRyaWJ1dGUtb3B0aW9uLmhlbHBlcidcbmV4cG9ydCAqIGZyb20gJy4vYmluZC1maWx0ZXItcXVlcnkuaGVscGVyJ1xuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXItb3B0aW9uLmhlbHBlcidcbmV4cG9ydCAqIGZyb20gJy4vZ3JhcGhxbC1maWVsZC5oZWxwZXInXG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQ0FBb0MsQ0FBQTtBQUNsRCxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsNkJBQTZCLENBQUE7QUFDM0MsY0FBYyxvQ0FBb0MsQ0FBQTtBQUNsRCxjQUFjLGlDQUFpQyxDQUFBO0FBQy9DLGNBQWMsa0NBQWtDLENBQUE7QUFDaEQsY0FBYyxrQ0FBa0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vd2l0aC1jcmVhdGUtaGFzdXJhLWdyYXBocWwubWl4aW4nXG5leHBvcnQgKiBmcm9tICcuL3dpdGgtZGVsZXRlLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLXVwZGF0ZS1oYXN1cmEtZ3JhcGhxbC5taXhpbidcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1nZXQtaGFzdXJhLWdyYXBocWwubWl4aW4nXG5leHBvcnQgKiBmcm9tICcuL3dpdGgtZmluZC1oYXN1cmEtZ3JhcGhxbC5taXhpbidcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1jcnVkLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuIl19

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1jcnVkLWhhc3VyYS1ncmFwaHFsLm1peGluLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvaW5mcmEvaGFzdXJhLWdyYXBocWwvbWl4aW5zL3dpdGgtY3J1ZC1oYXN1cmEtZ3JhcGhxbC5taXhpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBQTJCLHVCQUF1QixFQUFFLE1BQU0sb0NBQW9DLENBQUE7QUFDckcsT0FBTyxFQUEyQix1QkFBdUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFBO0FBQ3JHLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFBO0FBQ3hFLE9BQU8sRUFBd0Isb0JBQW9CLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQTtBQUU1RixPQUFPLEVBR0wsdUJBQXVCLEdBQ3hCLE1BQU0sb0NBQW9DLENBQUE7QUFFM0MsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FLbkMsU0FBMkQsRUFjM0QsRUFBRTtJQUNGLE9BQU8sTUFBTSxzQkFDWCxTQUFRLHVCQUF1QixDQUM3QixvQkFBb0IsQ0FDbEIscUJBQXFCLENBQ25CLHVCQUF1QixDQUFDLHVCQUF1QixDQUFDLFNBQWdELENBQUMsQ0FBQyxDQUNuRyxDQUNGLENBQ0Y7S0FDeUMsQ0FBQTtBQUM5QyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDcnVkUmVwb3NpdG9yeSwgTW9kZWxCYXNlU3RydWN0dXJlIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluJ1xuaW1wb3J0IHsgTWVyZ2VDb25zdHJ1Y3RvclBhcmFtcywgTWl4aW5DdG9yIH0gZnJvbSAnLi4vLi4vLi4vdXRpbHMnXG5pbXBvcnQgeyBHcmFwaFFMUmVwb3NpdG9yeSB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBDcmVhdGVDb25zdHJ1Y3RvclBhcmFtcywgd2l0aENyZWF0ZUhhc3VyYUdyYXBoUUwgfSBmcm9tICcuL3dpdGgtY3JlYXRlLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuaW1wb3J0IHsgRGVsZXRlQ29uc3RydWN0b3JQYXJhbXMsIHdpdGhEZWxldGVIYXN1cmFHcmFwaFFMIH0gZnJvbSAnLi93aXRoLWRlbGV0ZS1oYXN1cmEtZ3JhcGhxbC5taXhpbidcbmltcG9ydCB7IHdpdGhGaW5kSGFzdXJhR3JhcGhRTCB9IGZyb20gJy4vd2l0aC1maW5kLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuaW1wb3J0IHsgR2V0Q29uc3RydWN0b3JQYXJhbXMsIHdpdGhHZXRIYXN1cmFHcmFwaFFMIH0gZnJvbSAnLi93aXRoLWdldC1oYXN1cmEtZ3JhcGhxbC5taXhpbidcbmltcG9ydCB7IEhhc3VyYUNvbnN0cnVjdG9yUGFyYW1zIH0gZnJvbSAnLi93aXRoLWhhc3VyYS1ncmFwaHFsLm1peGluJ1xuaW1wb3J0IHtcbiAgVXBkYXRlQ29uc3RydWN0b3JQYXJhbXMsXG4gIFVwZGF0ZUhhc3VyYUdyYXBoUUxSZXBvc2l0b3J5VHlwZSxcbiAgd2l0aFVwZGF0ZUhhc3VyYUdyYXBoUUwsXG59IGZyb20gJy4vd2l0aC11cGRhdGUtaGFzdXJhLWdyYXBocWwubWl4aW4nXG5cbmV4cG9ydCBjb25zdCB3aXRoQ3J1ZEhhc3VyYUdyYXBoUUwgPSA8XG4gIFRCYXNlIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlPFRCYXNlLCBUQmFzZVsnaWRlbnRpZmllcnNGaWVsZHMnXVtudW1iZXJdPixcbiAgUmVwb3NpdG9yeSA9IENydWRSZXBvc2l0b3J5PFRCYXNlPixcbiAgVE1peGluQmFzZSBleHRlbmRzIE1peGluQ3RvciA9IE1peGluQ3Rvcixcbj4oXG4gIE1peGluQmFzZTogTWl4aW5DdG9yPEdyYXBoUUxSZXBvc2l0b3J5PFRCYXNlPj4gJiBUTWl4aW5CYXNlLFxuKTogTWl4aW5DdG9yPFxuICBHcmFwaFFMUmVwb3NpdG9yeTxUQmFzZT4gJiBSZXBvc2l0b3J5ICYgVXBkYXRlSGFzdXJhR3JhcGhRTFJlcG9zaXRvcnlUeXBlPFRCYXNlPixcbiAgTWVyZ2VDb25zdHJ1Y3RvclBhcmFtczxcbiAgICBbXG4gICAgICBIYXN1cmFDb25zdHJ1Y3RvclBhcmFtczxUQmFzZT4gJlxuICAgICAgICBDcmVhdGVDb25zdHJ1Y3RvclBhcmFtcyAmXG4gICAgICAgIERlbGV0ZUNvbnN0cnVjdG9yUGFyYW1zICZcbiAgICAgICAgR2V0Q29uc3RydWN0b3JQYXJhbXMgJlxuICAgICAgICBVcGRhdGVDb25zdHJ1Y3RvclBhcmFtcyxcbiAgICAgIC4uLmFueVtdLFxuICAgIF0sXG4gICAgQ29uc3RydWN0b3JQYXJhbWV0ZXJzPFRNaXhpbkJhc2U+XG4gID5cbj4gPT4ge1xuICByZXR1cm4gY2xhc3MgQ3J1ZEhhc3VyYUdyYXBoUUxNaXhpblxuICAgIGV4dGVuZHMgd2l0aFVwZGF0ZUhhc3VyYUdyYXBoUUwoXG4gICAgICB3aXRoR2V0SGFzdXJhR3JhcGhRTChcbiAgICAgICAgd2l0aEZpbmRIYXN1cmFHcmFwaFFMKFxuICAgICAgICAgIHdpdGhEZWxldGVIYXN1cmFHcmFwaFFMKHdpdGhDcmVhdGVIYXN1cmFHcmFwaFFMKE1peGluQmFzZSBhcyBNaXhpbkN0b3I8R3JhcGhRTFJlcG9zaXRvcnk8VEJhc2U+PikpLFxuICAgICAgICApLFxuICAgICAgKSxcbiAgICApXG4gICAgaW1wbGVtZW50cyBDcnVkUmVwb3NpdG9yeTxUQmFzZT4ge30gYXMgYW55XG59XG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1kZWxldGUtaGFzdXJhLWdyYXBocWwubWl4aW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9taXhpbnMvd2l0aC1kZWxldGUtaGFzdXJhLWdyYXBocWwubWl4aW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQXFDLE1BQU0sZ0JBQWdCLENBQUE7QUFHdEYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sV0FBVyxDQUFBO0FBTWpELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBSXJDLFNBQTJELEVBSTNELEVBQUU7SUFDRixPQUFPLE1BQU0sd0JBQXlCLFNBQVEsU0FBUztRQUdyRCxZQUFZLEdBQUcsTUFBYTtZQUMxQixNQUFNLE9BQU8sR0FBNEIsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFFcEQsS0FBSyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUE7WUFFaEIsSUFBSSxDQUFDLHNCQUFzQixHQUFHLE9BQU8sRUFBRSxzQkFBc0IsSUFBSSxVQUFVLElBQUksQ0FBQyxTQUFTLFFBQVEsQ0FBQTtRQUNuRyxDQUFDO1FBRUQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxXQUEwQztZQUNyRCxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFBO1lBRTlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBRW5ELE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FDakIsSUFBSSxDQUFDLHNCQUFzQixFQUMzQixJQUFJLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FDOUIsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFVBQVUsQ0FDbEQsRUFDL0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsVUFBVSxFQUFFLEVBQUU7Z0JBQ3RELE1BQU0sZ0JBQWdCLEdBR2xCLFVBQVUsQ0FBQTtnQkFFZCxJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDLENBQUM7b0JBQUUsT0FBTyxHQUFHLENBQUE7Z0JBRTVELE1BQU0sWUFBWSxHQUFHLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO2dCQUNuRixNQUFNLEtBQUssR0FBRyxZQUFZLENBQUMsRUFBRSxDQUFDLFdBQVcsQ0FBQyxVQUFpRCxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUE7Z0JBRXZHLE9BQU87b0JBQ0wsR0FBRyxHQUFHO29CQUNOLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxFQUFFO3dCQUN6QixJQUFJLEVBQUUsSUFBSSxDQUFDLHlCQUF5QixDQUFDLFlBQVksQ0FBQyxJQUFJLElBQUksS0FBSyxDQUFDO3dCQUNoRSxLQUFLO3dCQUNMLFFBQVEsRUFBRSxJQUFJO3FCQUNmO2lCQUNGLENBQUE7WUFDSCxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQ1AsQ0FBQTtRQUNILENBQUM7S0FDSyxDQUFBO0FBQ1YsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGVsZXRlUmVwb3NpdG9yeSxcbiAgRGVsZXRlUmVwb3NpdG9yeVBhcmFtcyxcbiAgTW9kZWxCYXNlU3RydWN0dXJlLFxuICBOb25GdW5jdGlvbkFuZElkZW50aWZpZXJQcm9wZXJ0eU5hbWVzLFxufSBmcm9tICcuLi8uLi8uLi9kb21haW4nXG5pbXBvcnQgeyBEZWJ1Z0hlbHBlciwgaXNOaWwsIE1lcmdlQ29uc3RydWN0b3JQYXJhbXMsIE1peGluQ3RvciB9IGZyb20gJy4uLy4uLy4uL3V0aWxzJ1xuaW1wb3J0IHsgR3JhcGhRTFJlcG9zaXRvcnksIEhhc3VyYUdyYXBoUUxGaWVsZHMgfSBmcm9tICcuLi90eXBlcydcblxuaW1wb3J0IHsgQXR0cmlidXRlT3B0aW9uSGVscGVyIH0gZnJvbSAnLi9oZWxwZXJzJ1xuXG5leHBvcnQgdHlwZSBEZWxldGVDb25zdHJ1Y3RvclBhcmFtcyA9IHtcbiAgZGVsZXRlR3JhcGhRTE9wZXJhdGlvbj86IHN0cmluZ1xufVxuXG5leHBvcnQgY29uc3Qgd2l0aERlbGV0ZUhhc3VyYUdyYXBoUUwgPSA8XG4gIE1CYXNlIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlPE1CYXNlLCBNQmFzZVsnaWRlbnRpZmllcnNGaWVsZHMnXVtudW1iZXJdPixcbiAgVE1peGluQmFzZSBleHRlbmRzIE1peGluQ3RvcjxHcmFwaFFMUmVwb3NpdG9yeTxNQmFzZT4+LFxuPihcbiAgTWl4aW5CYXNlOiBNaXhpbkN0b3I8R3JhcGhRTFJlcG9zaXRvcnk8TUJhc2U+PiAmIFRNaXhpbkJhc2UsXG4pOiBNaXhpbkN0b3I8XG4gIEdyYXBoUUxSZXBvc2l0b3J5PE1CYXNlPiAmIERlbGV0ZVJlcG9zaXRvcnk8TUJhc2U+ICYgSW5zdGFuY2VUeXBlPFRNaXhpbkJhc2U+LFxuICBNZXJnZUNvbnN0cnVjdG9yUGFyYW1zPFtEZWxldGVDb25zdHJ1Y3RvclBhcmFtcywgLi4uYW55W11dLCBDb25zdHJ1Y3RvclBhcmFtZXRlcnM8VE1peGluQmFzZT4+XG4+ID0+IHtcbiAgcmV0dXJuIGNsYXNzIERlbGV0ZUhhc3VyYUdyYXBoUUxNaXhpbiBleHRlbmRzIE1peGluQmFzZSBpbXBsZW1lbnRzIERlbGV0ZVJlcG9zaXRvcnk8TUJhc2U+IHtcbiAgICBkZWxldGVHcmFwaFFMT3BlcmF0aW9uOiBzdHJpbmdcblxuICAgIGNvbnN0cnVjdG9yKC4uLnBhcmFtczogYW55W10pIHtcbiAgICAgIGNvbnN0IG9wdGlvbnM6IERlbGV0ZUNvbnN0cnVjdG9yUGFyYW1zID0gcGFyYW1zPy5bMF1cblxuICAgICAgc3VwZXIoLi4ucGFyYW1zKVxuXG4gICAgICB0aGlzLmRlbGV0ZUdyYXBoUUxPcGVyYXRpb24gPSBvcHRpb25zPy5kZWxldGVHcmFwaFFMT3BlcmF0aW9uIHx8IGBkZWxldGVfJHt0aGlzLnRhYmxlTmFtZX1fYnlfcGtgXG4gICAgfVxuXG4gICAgYXN5bmMgZGVsZXRlKGlkZW50aWZpZXJzOiBEZWxldGVSZXBvc2l0b3J5UGFyYW1zPE1CYXNlPik6IFByb21pc2U8dm9pZD4ge1xuICAgICAgdGhpcy5sb2dnZXIgPSBEZWJ1Z0hlbHBlci5mcm9tKHRoaXMsICdkZWxldGUnKVxuXG4gICAgICBjb25zdCBpbnN0YW5jZSA9IHRoaXMubW9kZWwudG9JbnN0YW5jZShpZGVudGlmaWVycylcblxuICAgICAgYXdhaXQgdGhpcy5tdXRhdGlvbihcbiAgICAgICAgdGhpcy5kZWxldGVHcmFwaFFMT3BlcmF0aW9uLFxuICAgICAgICB0aGlzLm1vZGVsLmlkZW50aWZpZXJzRmllbGRzLm1hcChcbiAgICAgICAgICAoZmllbGQpID0+IEF0dHJpYnV0ZU9wdGlvbkhlbHBlci5GaW5kQnlBdHRyaWJ1dGUoZmllbGQsIHRoaXMuZmllbGRzKS5jb2x1bW5OYW1lLFxuICAgICAgICApIGFzIEhhc3VyYUdyYXBoUUxGaWVsZHM8TUJhc2U+LFxuICAgICAgICB0aGlzLm1vZGVsLmlkZW50aWZpZXJzRmllbGRzLnJlZHVjZSgoaWRzLCBpZGVudGlmaWVyKSA9PiB7XG4gICAgICAgICAgY29uc3QgaWRlbnRpZmllckJpbmRlZDogRXh0cmFjdDxcbiAgICAgICAgICAgIE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnR5TmFtZXM8TUJhc2U+LFxuICAgICAgICAgICAgTUJhc2VbJ2lkZW50aWZpZXJzRmllbGRzJ11bbnVtYmVyXVxuICAgICAgICAgID4gPSBpZGVudGlmaWVyXG5cbiAgICAgICAgICBpZiAoaXNOaWwoaW5zdGFuY2UuaWRlbnRpZmllcltpZGVudGlmaWVyQmluZGVkXSkpIHJldHVybiBpZHNcblxuICAgICAgICAgIGNvbnN0IGNvbHVtbk9wdGlvbiA9IEF0dHJpYnV0ZU9wdGlvbkhlbHBlci5GaW5kQnlBdHRyaWJ1dGUoaWRlbnRpZmllciwgdGhpcy5maWVsZHMpXG4gICAgICAgICAgY29uc3QgdmFsdWUgPSBjb2x1bW5PcHRpb24udG8oaWRlbnRpZmllcnNbaWRlbnRpZmllciBhcyBrZXlvZiBEZWxldGVSZXBvc2l0b3J5UGFyYW1zPE1CYXNlPl0sIGluc3RhbmNlKVxuXG4gICAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIC4uLmlkcyxcbiAgICAgICAgICAgIFtjb2x1bW5PcHRpb24uY29sdW1uTmFtZV06IHtcbiAgICAgICAgICAgICAgdHlwZTogdGhpcy5nZXRBdHRyaWJ1dGVHcmFwaFFMVHlwZU9mKGNvbHVtbk9wdGlvbi50eXBlIHx8IHZhbHVlKSxcbiAgICAgICAgICAgICAgdmFsdWUsXG4gICAgICAgICAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgICAgICAgICAgfSxcbiAgICAgICAgICB9XG4gICAgICAgIH0sIHt9KSxcbiAgICAgIClcbiAgICB9XG4gIH0gYXMgYW55XG59XG4iXX0=