@infrab4a/connect 3.13.3 → 3.13.5

package/bundles/infrab4a-connect.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata'), require('class-transformer'), require('date-fns'), require('lodash'), require('ts-custom-error'), require('axios'), require('firebase'), require('gql-query-builder')) :
-    typeof define === 'function' && define.amd ? define('@infrab4a/connect', ['exports', 'reflect-metadata', 'class-transformer', 'date-fns', 'lodash', 'ts-custom-error', 'axios', 'firebase', 'gql-query-builder'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.infrab4a = global.infrab4a || {}, global.infrab4a.connect = {}), null, global["class-transformer"], global["date-fns"], global.lodash, global["ts-custom-error"], global.axios, global.firebase, global["gql-query-builder"]));
-})(this, (function (exports, reflectMetadata, classTransformer, dateFns, lodash, tsCustomError, axios, firebase, gqlQueryBuilder) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata'), require('class-transformer'), require('date-fns'), require('lodash'), require('rxjs'), require('debug'), require('ts-custom-error'), require('axios'), require('firebase'), require('gql-query-builder')) :
+    typeof define === 'function' && define.amd ? define('@infrab4a/connect', ['exports', 'reflect-metadata', 'class-transformer', 'date-fns', 'lodash', 'rxjs', 'debug', 'ts-custom-error', 'axios', 'firebase', 'gql-query-builder'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.infrab4a = global.infrab4a || {}, global.infrab4a.connect = {}), null, global["class-transformer"], global["date-fns"], global.lodash, global.rxjs, global.debug, global["ts-custom-error"], global.axios, global.firebase, global["gql-query-builder"]));
+})(this, (function (exports, reflectMetadata, classTransformer, dateFns, lodash, rxjs, debug, tsCustomError, axios, firebase, gqlQueryBuilder) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -15,11 +15,11 @@
         }
         Object.defineProperty(BaseModel.prototype, "identifier", {
             get: function () {
-                var _this = this;
                 var fields = this.constructor.identifiersFields.filter(function (field) { return field !== 'identifier'; });
+                var data = this;
                 return fields.reduce(function (object, field) {
                     var _a;
-                    return (Object.assign(Object.assign({}, object), (_a = {}, _a[field] = _this[field], _a)));
+                    return (Object.assign(Object.assign({}, object), (_a = {}, _a[field] = data[field], _a)));
                 }, {});
             },
             enumerable: false,
@@ -816,20 +816,560 @@
         __metadata("design:type", Payment)
     ], SubscriptionPayment.prototype, "payment", void 0);
 
-    var Address = /** @class */ (function (_super) {
-        __extends(Address, _super);
-        function Address() {
-            return _super !== null && _super.apply(this, arguments) || this;
+    exports.DebugNamespaces = void 0;
+    (function (DebugNamespaces) {
+        DebugNamespaces["ROOT"] = "connect";
+        DebugNamespaces["TRACE"] = "trace";
+        DebugNamespaces["ERROR"] = "error";
+    })(exports.DebugNamespaces || (exports.DebugNamespaces = {}));
+    var Logger = debug.debug(exports.DebugNamespaces.ROOT);
+
+    var ReflectHelper = /** @class */ (function () {
+        function ReflectHelper() {
         }
-        Object.defineProperty(Address, "identifiersFields", {
+        Object.defineProperty(ReflectHelper, "items", {
             get: function () {
-                return ['id'];
+                return this._items;
             },
             enumerable: false,
             configurable: true
         });
-        return Address;
-    }(BaseModel));
+        Object.defineProperty(ReflectHelper, "keys", {
+            get: function () {
+                return Object.keys(ReflectHelper.items);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        ReflectHelper.has = function (key, target, property) {
+            return (!lodash.isNil(key) &&
+                !lodash.isNil(ReflectHelper.items[key]) &&
+                (lodash.isNil(target) ||
+                    (!lodash.isNil(ReflectHelper.items[key][target]) &&
+                        (lodash.isNil(property) || !lodash.isNil(ReflectHelper.items[key][target][String(property)])))));
+        };
+        ReflectHelper.get = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, _b = _a.own, own = _b === void 0 ? true : _b;
+            try {
+                if (own) {
+                    return Reflect.getOwnMetadata(key, target, property) || null;
+                }
+                else {
+                    return Reflect.getMetadata(key, target, property) || null;
+                }
+            }
+            catch (_err) {
+                return null;
+            }
+        };
+        ReflectHelper.first = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, _b = _a.own, own = _b === void 0 ? true : _b;
+            var values = ReflectHelper.get({ key: key, target: target, property: property, own: own });
+            return lodash.isArray(values) ? lodash.first(values) : values;
+        };
+        ReflectHelper.last = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, _b = _a.own, own = _b === void 0 ? true : _b;
+            var values = ReflectHelper.get({ key: key, target: target, property: property, own: own });
+            return lodash.isArray(values) ? lodash.last(values) : values;
+        };
+        ReflectHelper.set = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, value = _a.value, propertyDescriptor = _a.propertyDescriptor;
+            Reflect.defineMetadata(key, value, target, property);
+            ReflectHelper.put({ key: key, target: target, property: property, value: value, propertyDescriptor: propertyDescriptor });
+        };
+        ReflectHelper.add = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, value = _a.value, propertyDescriptor = _a.propertyDescriptor;
+            var values = ReflectHelper.get({ key: key, target: target, property: property }) || new Array();
+            if (!Array.isArray(values))
+                values = [values];
+            values.push(value);
+            ReflectHelper.set({ key: key, target: target, property: property, value: values, propertyDescriptor: propertyDescriptor });
+        };
+        ReflectHelper.all = function (_a) {
+            var _this = this;
+            var key = _a.key;
+            var items = ReflectHelper.items[key] || {};
+            return lodash.flatten(Object.keys(items).map(function (item) { return lodash.flatten(_this.allFrom(key, items[item])); }));
+        };
+        ReflectHelper.allFrom = function (key, target) {
+            var _this = this;
+            return Object.keys(target)
+                .filter(function (property) { return property !== 'object'; })
+                .map(function (property) { return _this.allValuesFrom(key, target, property); });
+        };
+        ReflectHelper.allValuesFrom = function (key, target, property) {
+            var values = target[property];
+            var value = values.value;
+            var propertyDescriptor = values.propertyDescriptor;
+            if (!lodash.isArray(value))
+                value = [value];
+            return lodash.flatten(value.map(function (val) {
+                return {
+                    key: key,
+                    target: target.object,
+                    property: property,
+                    value: val,
+                    propertyDescriptor: propertyDescriptor,
+                };
+            }));
+        };
+        ReflectHelper.delete = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property;
+            Reflect.deleteMetadata(key, target, property);
+            return ReflectHelper.remove(key, target, property);
+        };
+        ReflectHelper.clear = function (key) {
+            if (!key) {
+                ReflectHelper.keys.forEach(function (storedKey) {
+                    ReflectHelper.clear(storedKey);
+                });
+            }
+            else {
+                if (ReflectHelper.keys.includes(key)) {
+                    Object.values(ReflectHelper.items[key]).forEach(function (target) {
+                        if (ReflectHelper.has(key, target)) {
+                            Object.values(ReflectHelper.items[key][target]).forEach(function (property) {
+                                ReflectHelper.delete({
+                                    key: key,
+                                    target: target.object,
+                                    property: String(property),
+                                });
+                                ReflectHelper.remove(key, target, String(property));
+                            });
+                        }
+                        ReflectHelper.delete({ key: key, target: target.object });
+                        ReflectHelper.remove(key, target);
+                    });
+                }
+            }
+        };
+        ReflectHelper.getType = function (_a) {
+            var target = _a.target, propertyKey = _a.propertyKey;
+            return Reflect.getMetadata('design:type', target, propertyKey);
+        };
+        ReflectHelper.getReturntype = function (_a) {
+            var target = _a.target, propertyKey = _a.propertyKey;
+            return Reflect.getMetadata('design:returntype', target, propertyKey);
+        };
+        ReflectHelper.getAllMethods = function (target) {
+            var props = [];
+            var obj = target;
+            do {
+                props.push.apply(props, __spreadArray([], __read(Object.getOwnPropertyNames(obj))));
+            } while ((obj = Object.getPrototypeOf(obj)));
+            return props.sort().filter(function (e, i, arr) {
+                if ([
+                    '__defineGetter__',
+                    '__defineSetter__',
+                    '__lookupGetter__',
+                    '__lookupSetter__',
+                    'constructor',
+                    'hasOwnProperty',
+                    'isPrototypeOf',
+                    'propertyIsEnumerable',
+                    'toLocaleString',
+                    'toString',
+                    'valueOf',
+                ].includes(e))
+                    return false;
+                if (e != arr[i + 1] && typeof target[e] === 'function')
+                    return true;
+            });
+        };
+        ReflectHelper.put = function (_a) {
+            var key = _a.key, target = _a.target, property = _a.property, value = _a.value, propertyDescriptor = _a.propertyDescriptor;
+            var index = target.constructor.name;
+            ReflectHelper.items[key] = ReflectHelper.items[key] || {};
+            ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {};
+            ReflectHelper.items[key][index].object = target;
+            if (lodash.isNil(property)) {
+                ReflectHelper.items[key][index].value = {
+                    value: value,
+                    propertyDescriptor: propertyDescriptor,
+                };
+            }
+            else {
+                ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {};
+                ReflectHelper.items[key][index][String(property)] = {
+                    value: value,
+                    propertyDescriptor: propertyDescriptor,
+                };
+            }
+        };
+        ReflectHelper.remove = function (key, target, property) {
+            if (ReflectHelper.has(key, target, property))
+                return delete ReflectHelper.items[key][target][String(property)];
+            else if (ReflectHelper.has(key, target))
+                return delete ReflectHelper.items[key][target];
+            else if (ReflectHelper.has(key))
+                return delete ReflectHelper.items[key];
+            else
+                return false;
+        };
+        return ReflectHelper;
+    }());
+    ReflectHelper._items = {};
+
+    var DebugDecoratorHelper = /** @class */ (function () {
+        function DebugDecoratorHelper() {
+        }
+        DebugDecoratorHelper.set = function (target, options) {
+            ReflectHelper.add({
+                key: DebugDecoratorHelper.DebugNamingMetadataKey,
+                target: target,
+                value: options,
+            });
+        };
+        DebugDecoratorHelper.get = function (target) {
+            return ReflectHelper.first({
+                key: DebugDecoratorHelper.DebugNamingMetadataKey,
+                target: target,
+            });
+        };
+        return DebugDecoratorHelper;
+    }());
+    DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
+
+    var ClassNameHelper = /** @class */ (function () {
+        function ClassNameHelper() {
+        }
+        ClassNameHelper.get = function (clazz) {
+            if (!clazz)
+                return null;
+            var prototype = Object.getPrototypeOf(clazz);
+            var names = lodash.compact([
+                lodash.get(clazz, 'constructor.name'),
+                lodash.get(prototype, 'constructor.name'),
+                lodash.get(prototype, '__proto__.constructor.name'),
+            ]);
+            return names.find(function (name) { return name !== 'class_1'; });
+        };
+        return ClassNameHelper;
+    }());
+
+    var isDebuggable = function (object) {
+        return 'debug' in object;
+    };
+    var DebugHelper = /** @class */ (function () {
+        function DebugHelper() {
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            this.namespaces = new Set();
+            this.push.apply(this, __spreadArray([], __read(namespace)));
+        }
+        DebugHelper.namespacesFor = function (target) {
+            if (lodash.isNil(target))
+                return [];
+            var decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target));
+            var namespaces = lodash.get(decorator, 'namespaces', []);
+            var name = lodash.get(decorator, 'name', ClassNameHelper.get(target));
+            return __spreadArray(__spreadArray([], __read(namespaces)), [name]);
+        };
+        DebugHelper.as = function () {
+            var namespaces = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespaces[_i] = arguments[_i];
+            }
+            return new (DebugHelper.bind.apply(DebugHelper, __spreadArray([void 0], __read(namespaces))))();
+        };
+        DebugHelper.for = function (target) {
+            var namespaces = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                namespaces[_i - 1] = arguments[_i];
+            }
+            var targetNamespaces = this.namespacesFor(target);
+            return new (DebugHelper.bind.apply(DebugHelper, __spreadArray(__spreadArray([void 0], __read(targetNamespaces)), __read(namespaces))))();
+        };
+        DebugHelper.from = function (target) {
+            var namespaces = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                namespaces[_i - 1] = arguments[_i];
+            }
+            if (this.isDebuggable(target)) {
+                var debug = target.debug;
+                if (namespaces)
+                    debug.push.apply(debug, __spreadArray([], __read(namespaces)));
+                return debug;
+            }
+            return DebugHelper.for.apply(DebugHelper, __spreadArray([target], __read(namespaces)));
+        };
+        DebugHelper.clonedFrom = function (target) {
+            var namespaces = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                namespaces[_i - 1] = arguments[_i];
+            }
+            if (this.isDebuggable(target)) {
+                namespaces.push.apply(namespaces, __spreadArray([], __read(target.debug.entries)));
+            }
+            else if (!lodash.isNil(target)) {
+                namespaces.push.apply(namespaces, __spreadArray([], __read(this.namespacesFor(target))));
+            }
+            return DebugHelper.for.apply(DebugHelper, __spreadArray([target], __read(namespaces)));
+        };
+        DebugHelper.clone = function (target) {
+            var namespaces = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                namespaces[_i - 1] = arguments[_i];
+            }
+            var original;
+            if (this.isDebuggable(target)) {
+                original = target.debug;
+                namespaces.push.apply(namespaces, __spreadArray([], __read(original.entries)));
+            }
+            return {
+                original: original,
+                debug: DebugHelper.for.apply(DebugHelper, __spreadArray([target], __read(namespaces))),
+            };
+        };
+        DebugHelper.replace = function (target, attrs) {
+            if (this.isDebuggable(target))
+                target.debug = attrs.with;
+        };
+        DebugHelper.mock = function (target) {
+            var namespaces = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                namespaces[_i - 1] = arguments[_i];
+            }
+            var _a = DebugHelper.clone.apply(DebugHelper, __spreadArray([target], __read(namespaces))), original = _a.original, debug = _a.debug;
+            DebugHelper.replace(target, { with: debug });
+            return { original: original, debug: debug };
+        };
+        Object.defineProperty(DebugHelper.prototype, "entries", {
+            get: function () {
+                return Array.from(lodash.get(this, 'namespaces', []));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DebugHelper.prototype, "namespace", {
+            get: function () {
+                return lodash.compact(lodash.flatten(this.entries)).join(':');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DebugHelper.prototype.log = function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            this.logger.apply(this, __spreadArray([JSON.stringify(message)], __read(args.map(function (element) { return JSON.stringify(element); }))));
+            DebugHelper.logs$.next({ namespace: this.namespace, message: message, args: args });
+            return this;
+        };
+        DebugHelper.prototype.trace = function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            this.logger.extend(exports.DebugNamespaces.TRACE).apply(void 0, __spreadArray([message], __read(args)));
+            DebugHelper.traces$.next({ namespace: this.namespace, message: message, args: args });
+            return this;
+        };
+        DebugHelper.prototype.error = function (error) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            this.logger.extend(exports.DebugNamespaces.ERROR).apply(void 0, __spreadArray([JSON.stringify(error)], __read(args.map(function (element) { return JSON.stringify(element); }))));
+            DebugHelper.errors$.next({ namespace: this.namespace, error: error, args: args });
+            return this;
+        };
+        DebugHelper.prototype.build = function () {
+            var _this = this;
+            this.logger = Logger;
+            this.tracer = Logger;
+            this.err = Logger;
+            this.entries.forEach(function (namespace) {
+                _this.logger = _this.logger.extend(namespace);
+                _this.tracer = _this.tracer.extend(namespace);
+                _this.err = _this.err.extend(namespace);
+            });
+            return this;
+        };
+        DebugHelper.prototype.with = function () {
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            return new (DebugHelper.bind.apply(DebugHelper, __spreadArray(__spreadArray([void 0], __read(this.entries)), __read(namespace))))();
+        };
+        DebugHelper.prototype.push = function () {
+            var _this = this;
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            if (namespace) {
+                namespace.filter(function (item) { return Boolean(item); }).forEach(function (item) { return _this.namespaces.add(item); });
+            }
+            return this.build();
+        };
+        DebugHelper.prototype.unshift = function () {
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            if (namespace) {
+                return this.reset.apply(this, __spreadArray(__spreadArray([], __read(namespace)), __read(this.entries)));
+            }
+            return this;
+        };
+        DebugHelper.prototype.reset = function () {
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            this.namespaces = new Set(lodash.flatten(lodash.compact(namespace)));
+            return this.build();
+        };
+        DebugHelper.prototype.startWith = function () {
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            var current = this.namespaces;
+            this.namespaces = new Set(lodash.flatten(__spreadArray([lodash.compact(namespace)], __read(current))));
+            return this.build();
+        };
+        DebugHelper.prototype.shift = function () {
+            var list = this.entries;
+            list.shift();
+            return this.reset.apply(this, __spreadArray([], __read(list)));
+        };
+        DebugHelper.prototype.pop = function () {
+            var list = this.entries;
+            list.pop();
+            return this.reset.apply(this, __spreadArray([], __read(list)));
+        };
+        DebugHelper.prototype.clear = function () {
+            return this.reset();
+        };
+        DebugHelper.prototype.remove = function () {
+            var _this = this;
+            var namespace = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                namespace[_i] = arguments[_i];
+            }
+            if (namespace) {
+                namespace.filter(function (item) { return Boolean(item); }).forEach(function (item) { return _this.namespaces.delete(item); });
+            }
+            return this.build();
+        };
+        DebugHelper.prototype.puts = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return __spreadArray(["[" + this.namespace + "]"], __read(args)).join(' ');
+        };
+        return DebugHelper;
+    }());
+    DebugHelper.logs$ = new rxjs.Subject();
+    DebugHelper.traces$ = new rxjs.Subject();
+    DebugHelper.errors$ = new rxjs.Subject();
+    DebugHelper.isDebuggable = isDebuggable;
+
+    function Debug(opts) {
+        return function (target) {
+            DebugDecoratorHelper.set(target.prototype, opts);
+        };
+    }
+
+    var ASYNC_IDENTIFIER = 'async';
+    function Log(options) {
+        if (options === void 0) { options = {}; }
+        return Trace(Object.assign({ level: 'log' }, options));
+    }
+    function Trace(options) {
+        if (options === void 0) { options = {}; }
+        return function (target, propertyKey, propertyDescriptor) {
+            var method = propertyDescriptor.value;
+            var isPromise = method.toString().includes(ASYNC_IDENTIFIER);
+            var args = {
+                options: options,
+                method: method,
+                target: target,
+                propertyKey: propertyKey,
+                propertyDescriptor: propertyDescriptor,
+            };
+            propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args);
+            return propertyDescriptor;
+        };
+    }
+    var traceCall = function (_a) {
+        var target = _a.target, propertyKey = _a.propertyKey, propertyDescriptor = _a.propertyDescriptor, args = _a.args;
+        if (!target.debug)
+            target.debug = DebugHelper.for(target, propertyKey);
+        return target.debug.push(propertyKey).trace('called', { target: target, propertyKey: propertyKey, propertyDescriptor: propertyDescriptor, args: args });
+    };
+    var promiseTracer = function (_a) {
+        var options = _a.options, method = _a.method, propertyKey = _a.propertyKey, propertyDescriptor = _a.propertyDescriptor;
+        return function () {
+            var _this = this;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return new Promise(function (resolve, reject) {
+                var debug = traceCall({ target: _this, propertyDescriptor: propertyDescriptor, propertyKey: propertyKey, args: args });
+                if (lodash.get(options, 'level', '') === 'log') {
+                    debug.with('params').log(args);
+                }
+                return method
+                    .apply(_this, args)
+                    .then(function (result) {
+                    if (options.callbackFn) {
+                        options.callbackFn({ target: _this, result: result, args: args, namespace: [propertyKey] });
+                    }
+                    if (lodash.get(options, 'level', '') === 'log') {
+                        debug.with('returns').log(result === undefined ? 'void' : result);
+                    }
+                    return resolve(result);
+                })
+                    .catch(function (error) {
+                    debug.error.apply(debug, __spreadArray([error], __read(args)));
+                    debug.with('stack').error(error.stack).pop();
+                    return reject(error);
+                })
+                    .finally(function () {
+                    return debug.trace('finally', { args: args }).pop();
+                });
+            });
+        };
+    };
+    var functionTracer = function (_a) {
+        var options = _a.options, target = _a.target, method = _a.method, propertyKey = _a.propertyKey, propertyDescriptor = _a.propertyDescriptor;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var debug = traceCall({ target: this || target, propertyDescriptor: propertyDescriptor, propertyKey: propertyKey, args: args });
+            if (lodash.get(options, 'level', '') === 'log') {
+                debug.with('params').log(args);
+            }
+            var result;
+            try {
+                result = method.apply(this, args);
+                if (options.callbackFn)
+                    options.callbackFn({ target: this, result: result, args: args, namespace: [propertyKey] });
+                if (lodash.get(options, 'level', '') === 'log') {
+                    debug.with('returns').log(result === undefined ? 'void' : result);
+                }
+                return result;
+            }
+            catch (error) {
+                debug.error.apply(debug, __spreadArray([error], __read(args))).pop();
+                throw error;
+            }
+            finally {
+                debug.trace('finally', { args: args }).pop();
+            }
+        };
+    };
 
     var isUUID = function (value) { return lodash.isString(value) && /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/.test(value); };
 
@@ -978,7 +1518,7 @@
             var instance = _super.toInstance.call(this, data);
             if (!lodash.isNil(data.firstName))
                 instance.displayName = "" + data.firstName + (!lodash.isNil(data.lastName) ? " " + data.lastName : '');
-            return instance;
+            return;
         };
         User.prototype.toPlain = function () {
             var plain = _super.prototype.toPlain.call(this);
@@ -999,6 +1539,36 @@
         __metadata("design:type", BeautyProfile)
     ], User.prototype, "beautyProfile", void 0);
 
+    var Address = /** @class */ (function (_super) {
+        __extends(Address, _super);
+        function Address() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(Address, "identifiersFields", {
+            get: function () {
+                return ['id'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return Address;
+    }(BaseModel));
+
+    var UserAddress = /** @class */ (function (_super) {
+        __extends(UserAddress, _super);
+        function UserAddress() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(UserAddress, "identifiersFields", {
+            get: function () {
+                return ['id', 'userId'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return UserAddress;
+    }(Address));
+
     var Subscription = /** @class */ (function (_super) {
         __extends(Subscription, _super);
         function Subscription() {
@@ -1022,12 +1592,12 @@
         __metadata("design:type", SubscriptionPlan)
     ], Subscription.prototype, "subscriptionPlan", void 0);
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], Subscription.prototype, "shippingAddress", void 0);
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], Subscription.prototype, "billingAddress", void 0);
     __decorate([
         classTransformer.Type(function () { return Coupon; }),
@@ -1042,21 +1612,6 @@
         __metadata("design:type", Array)
     ], Subscription.prototype, "payment", void 0);
 
-    var UserAddress = /** @class */ (function (_super) {
-        __extends(UserAddress, _super);
-        function UserAddress() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(UserAddress, "identifiersFields", {
-            get: function () {
-                return ['id', 'userId'];
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return UserAddress;
-    }(Address));
-
     var UserPaymentMethod = /** @class */ (function (_super) {
         __extends(UserPaymentMethod, _super);
         function UserPaymentMethod() {
@@ -1256,9 +1811,6 @@
         function Filter() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        Filter.prototype.identifierFields = function () {
-            return ['id'];
-        };
         Object.defineProperty(Filter, "identifiersFields", {
             get: function () {
                 return ['id'];
@@ -1274,9 +1826,6 @@
         function Category() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        Category.prototype.identifierFields = function () {
-            return ['id'];
-        };
         Object.defineProperty(Category, "identifiersFields", {
             get: function () {
                 return ['id'];
@@ -1300,9 +1849,6 @@
         function CategoryCollectionChildren() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        CategoryCollectionChildren.prototype.identifierFields = function () {
-            return ['collectionId', 'categoryId'];
-        };
         Object.defineProperty(CategoryCollectionChildren, "identifiersFields", {
             get: function () {
                 return ['collectionId', 'categoryId'];
@@ -1323,9 +1869,6 @@
             return _super !== null && _super.apply(this, arguments) || this;
         }
         Object.defineProperty(CategoryFilter, "identifiersFields", {
-            // identifierFields(): NonFunctionPropertyNames<CategoryFilter>[] {
-            //   return ['id']
-            // }
             get: function () {
                 return ['id', 'filterId', 'categoryId'];
             },
@@ -1355,9 +1898,6 @@
         function FilterOption() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        FilterOption.prototype.identifierFields = function () {
-            return ['id'];
-        };
         Object.defineProperty(FilterOption, "identifiersFields", {
             get: function () {
                 return ['id'];
@@ -1395,9 +1935,6 @@
             enumerable: false,
             configurable: true
         });
-        Product.prototype.identifierFields = function () {
-            return ['id'];
-        };
         Object.defineProperty(Product, "identifiersFields", {
             get: function () {
                 return ['id'];
@@ -1423,7 +1960,7 @@
         }
         Object.defineProperty(KitProduct, "identifiersFields", {
             get: function () {
-                return ['productId', 'kitProducId'];
+                return ['productId', 'kitProductId'];
             },
             enumerable: false,
             configurable: true
@@ -1444,9 +1981,6 @@
         function Variant() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        Variant.prototype.identifierFields = function () {
-            return ['id'];
-        };
         Object.defineProperty(Variant, "identifiersFields", {
             get: function () {
                 return ['id', 'productId'];
@@ -1552,12 +2086,12 @@
         __metadata("design:type", User)
     ], Checkout.prototype, "user", void 0);
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], Checkout.prototype, "shippingAddress", void 0);
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], Checkout.prototype, "billingAddress", void 0);
     __decorate([
         classTransformer.Type(function () { return ShippingMethod; }),
@@ -1607,12 +2141,12 @@
         return CheckoutSubscription;
     }(BaseModel));
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], CheckoutSubscription.prototype, "shippingAddress", void 0);
     __decorate([
-        classTransformer.Type(function () { return Address; }),
-        __metadata("design:type", Address)
+        classTransformer.Type(function () { return UserAddress; }),
+        __metadata("design:type", UserAddress)
     ], CheckoutSubscription.prototype, "billingAddress", void 0);
     __decorate([
         classTransformer.Type(function () { return SubscriptionPlan; }),
@@ -2327,34 +2861,34 @@
             CreateFirestore.prototype.create = function (data) {
                 return __awaiter(this, void 0, void 0, function () {
                     var docRef, doc;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
                             case 0: return [4 /*yield*/, this.save(this.model.toInstance(data))];
                             case 1:
-                                docRef = _b.sent();
+                                docRef = _c.sent();
                                 return [4 /*yield*/, docRef.get()];
                             case 2:
-                                doc = _b.sent();
+                                doc = _c.sent();
                                 return [2 /*return*/, doc.data()];
                         }
                     });
                 });
             };
             CreateFirestore.prototype.save = function (data) {
-                var _a;
+                var _a, _b;
                 return __awaiter(this, void 0, void 0, function () {
                     var id, collectionPath, docRef;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
                             case 0:
-                                id = (_a = data[data.identifiersFields.shift()]) === null || _a === void 0 ? void 0 : _a.toString();
+                                id = (_b = (_a = Object.values(data.identifier)) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.toString();
                                 collectionPath = this.buildCollectionPathForAdd(data);
                                 if (lodash.isEmpty(id))
                                     return [2 /*return*/, this.collection(collectionPath).add(data)];
                                 docRef = this.collection(collectionPath).doc(id);
                                 return [4 /*yield*/, docRef.set(data)];
                             case 1:
-                                _b.sent();
+                                _c.sent();
                                 return [2 /*return*/, docRef];
                         }
                     });
@@ -3359,11 +3893,12 @@
     BindFilterQueryHelper.BuildWhereSentence = function (field, options, fields) {
         var _a;
         var fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-        if (!Array.isArray(options) &&
+        var isNestedField = !Array.isArray(options) &&
             lodash.isObject(options) &&
             lodash.isNil(options === null || options === void 0 ? void 0 : options.operator) &&
             lodash.isNil(options === null || options === void 0 ? void 0 : options.value) &&
-            lodash.isNil(fieldSentenceOptions === null || fieldSentenceOptions === void 0 ? void 0 : fieldSentenceOptions.to))
+            lodash.isNil(fieldSentenceOptions === null || fieldSentenceOptions === void 0 ? void 0 : fieldSentenceOptions.to);
+        if (isNestedField)
             return Object.keys(options).reduce(function (variables, key) {
                 var _a;
                 var fieldOptions = AttributeOptionHelper.FindByAttribute(key, (fieldSentenceOptions === null || fieldSentenceOptions === void 0 ? void 0 : fieldSentenceOptions.fields) || fields);
@@ -3375,7 +3910,7 @@
             return _a = {},
                 _a[fieldSentenceOptions.fields[0]] = BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
                 _a;
-        if (lodash.isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
+        if (!Array.isArray(options) && lodash.isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
             options = Object.values(options)[0];
         return Array.isArray(options)
             ? options.reduce(function (whereSentence, option) { return (Object.assign(Object.assign({}, whereSentence), BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions))); }, {})
@@ -3387,16 +3922,20 @@
             _a[BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)] = FilterOptionHelper.GetValueFromFilter(options, fieldOption),
             _a);
     };
-    BindFilterQueryHelper.GetHasuraOperator = function (options, fieldOption) { return FilterOptionHelper.CheckIfIsFilterOption(options)
-        ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
-            ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
-            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find(function (graphQLOperator) { return graphQLOperator === Object.keys(exports.Where).find(function (operator) { return exports.Where[operator] === (options === null || options === void 0 ? void 0 : options.operator); }); })]
-        : HasuraGraphQLWhere.EQUALS; };
-    BindFilterQueryHelper.GetHasuraJsonbOperator = function (options) { return options.operator === exports.Where.IN
-        ? '_contains'
-        : options.operator === exports.Where.LIKE
-            ? '_has_keys_any'
-            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find(function (graphQLOperator) { return graphQLOperator === Object.keys(exports.Where).find(function (operator) { return exports.Where[operator] === (options === null || options === void 0 ? void 0 : options.operator); }); })]; };
+    BindFilterQueryHelper.GetHasuraOperator = function (options, fieldOption) {
+        if (!FilterOptionHelper.CheckIfIsFilterOption(options))
+            return HasuraGraphQLWhere.EQUALS;
+        if (fieldOption.type === HasuraGraphQLColumnType.Jsonb)
+            return BindFilterQueryHelper.GetHasuraJsonbOperator(options);
+        return HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find(function (graphQLOperator) { return graphQLOperator === Object.keys(exports.Where).find(function (operator) { return exports.Where[operator] === (options === null || options === void 0 ? void 0 : options.operator); }); })];
+    };
+    BindFilterQueryHelper.GetHasuraJsonbOperator = function (options) {
+        if (options.operator === exports.Where.IN)
+            return '_contains';
+        if (options.operator === exports.Where.LIKE)
+            return '_has_keys_any';
+        return HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find(function (graphQLOperator) { return graphQLOperator === Object.keys(exports.Where).find(function (operator) { return exports.Where[operator] === (options === null || options === void 0 ? void 0 : options.operator); }); })];
+    };
 
     var GraphQLFieldHelper = /** @class */ (function () {
         function GraphQLFieldHelper() {
@@ -3406,7 +3945,7 @@
     GraphQLFieldHelper.CheckIsGraphQLParams = function (params) { return !lodash.isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation; };
     GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = function (fields) {
         return fields === null || fields === void 0 ? void 0 : fields.map(function (field) {
-            var _b, _c, _d;
+            var _b;
             if (lodash.isString(field))
                 return field.toString();
             var fieldName = Object.keys(field).shift();
@@ -3415,22 +3954,9 @@
                 return _b = {}, _b[fieldName] = GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue), _b;
             if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
                 return;
-            if (fieldValue.fields)
-                return !fieldValue.filters
-                    ? (_c = {},
-                        _c[fieldValue.columnName || fieldName] = GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                        _c) : {
-                    operation: fieldValue.columnName || fieldName,
-                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                    variables: (_d = {},
-                        _d[fieldValue.columnName + "_where"] = {
-                            name: 'where',
-                            type: fieldValue.filters.filterType,
-                            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
-                            required: true,
-                        },
-                        _d),
-                };
+            var isNestedField = !!fieldValue.fields;
+            if (isNestedField)
+                return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
             return fieldValue.columnName;
         }).filter(function (field) { return !!field; });
     };
@@ -3489,6 +4015,26 @@
             return Object.assign(Object.assign({}, result), (_d = {}, _d[columnName] = data[attributeName], _d));
         }, {});
     };
+    GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields = function (fieldName, fieldValue) {
+        var _b, _c;
+        var hasCustomFilters = !!fieldValue.filters;
+        if (hasCustomFilters)
+            return {
+                operation: fieldValue.columnName || fieldName,
+                fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+                variables: (_b = {},
+                    _b[fieldValue.columnName + "_where"] = {
+                        name: 'where',
+                        type: fieldValue.filters.filterType,
+                        value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
+                        required: true,
+                    },
+                    _b),
+            };
+        return _c = {},
+            _c[fieldValue.columnName || fieldName] = GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+            _c;
+    };
 
     var withCreateHasuraGraphQL = function (MixinBase) {
         return /** @class */ (function (_super) {
@@ -3502,6 +4048,7 @@
                 var options = params === null || params === void 0 ? void 0 : params[0];
                 _this = _super.apply(this, __spreadArray([], __read(params))) || this;
                 _this.insertGraphQLOperation = (options === null || options === void 0 ? void 0 : options.insertGraphQLOperation) || "insert_" + _this.tableName + "_one";
+                _this.insertAllGraphQLOperation = (options === null || options === void 0 ? void 0 : options.insertAllGraphQLOperation) || "insert_" + _this.tableName;
                 _this.insertGraphQLObjectType = (options === null || options === void 0 ? void 0 : options.insertGraphQLObjectType) || _this.tableName + "_insert_input";
                 return _this;
             }
@@ -3510,7 +4057,9 @@
                     var newData;
                     return __generator(this, function (_b) {
                         switch (_b.label) {
-                            case 0: return [4 /*yield*/, this.save(this.model.toInstance(data))];
+                            case 0:
+                                this.logger = DebugHelper.from(this, 'create');
+                                return [4 /*yield*/, this.save(this.model.toInstance(data))];
                             case 1:
                                 newData = _b.sent();
                                 return [2 /*return*/, this.model.toInstance(newData)];
@@ -3518,6 +4067,29 @@
                     });
                 });
             };
+            CreateHasuraGraphQLMixin.prototype.createAll = function (data) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var result;
+                    var _this = this;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                this.logger = DebugHelper.from(this, 'createAll');
+                                return [4 /*yield*/, this.mutation(this.insertAllGraphQLOperation, [{ returning: this.model.identifiersFields }], {
+                                        objects: {
+                                            type: this.insertGraphQLObjectType,
+                                            required: true,
+                                            list: true,
+                                            value: data.map(function (item) { return _this.convertDataToHasura(item); }),
+                                        },
+                                    })];
+                            case 1:
+                                result = _b.sent();
+                                return [2 /*return*/, result[this.insertAllGraphQLOperation].returning.map(function (item, index) { return _this.model.toInstance(Object.assign(Object.assign({}, data[index]), item)); })];
+                        }
+                    });
+                });
+            };
             CreateHasuraGraphQLMixin.prototype.save = function (data) {
                 return __awaiter(this, void 0, void 0, function () {
                     var primaryKeyColumns, foreignKeyColumns, result;
@@ -3535,8 +4107,7 @@
                                         (_b = {},
                                             _b[columnOptions.columnName] = Object.keys(columnOptions.foreignKeyColumn).map(function (foreignKeyField) {
                                                 var _a;
-                                                return ((_a = AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions === null || columnOptions === void 0 ? void 0 : columnOptions.fields)) === null || _a === void 0 ? void 0 : _a.columnName) ||
-                                                    foreignKeyField;
+                                                return ((_a = AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions === null || columnOptions === void 0 ? void 0 : columnOptions.fields)) === null || _a === void 0 ? void 0 : _a.columnName) || foreignKeyField;
                                             }),
                                             _b),
                                     ]));
@@ -3578,10 +4149,12 @@
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
+                                this.logger = DebugHelper.from(this, 'delete');
                                 instance = this.model.toInstance(identifiers);
                                 return [4 /*yield*/, this.mutation(this.deleteGraphQLOperation, this.model.identifiersFields.map(function (field) { return AttributeOptionHelper.FindByAttribute(field, _this.fields).columnName; }), this.model.identifiersFields.reduce(function (ids, identifier) {
                                         var _a;
-                                        if (lodash.isNil(instance[identifier]))
+                                        var identifierBinded = identifier;
+                                        if (lodash.isNil(instance[identifierBinded]))
                                             return ids;
                                         var columnOption = AttributeOptionHelper.FindByAttribute(identifier, _this.fields);
                                         var value = columnOption.to(identifiers[identifier.toString()], instance);
@@ -3618,6 +4191,7 @@
                 _this.authOptions = options.authOptions;
                 _this.model = options.model;
                 _this.fields = options.fields || _this.model.identifiersFields;
+                _this.logger = DebugHelper.from(_this);
                 return _this;
             }
             Object.defineProperty(HasuraGraphQLMixin.prototype, "headers", {
@@ -3667,6 +4241,7 @@
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
+                                this.logger.with('params').log(params);
                                 headers = this.headers;
                                 return [4 /*yield*/, axios__default["default"]({
                                         url: "" + this.endpoint,
@@ -3678,6 +4253,7 @@
                                 result = (_a.sent()).data;
                                 if (!lodash.isNil(result.errors))
                                     throw new Error(JSON.stringify(result.errors));
+                                this.logger.with('returns').log(result);
                                 return [2 /*return*/, result.data];
                         }
                     });
@@ -3706,8 +4282,8 @@
                     return value;
                 return date;
             };
-            HasuraGraphQLMixin.prototype.convertDataFromHasura = function (data) {
-                var plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, this.fields);
+            HasuraGraphQLMixin.prototype.convertDataFromHasura = function (data, fields) {
+                var plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, fields || this.fields);
                 return this.model.toInstance(plain);
             };
             HasuraGraphQLMixin.prototype.convertDataToHasura = function (instance, update) {
@@ -3750,6 +4326,7 @@
                     return __generator(this, function (_b) {
                         switch (_b.label) {
                             case 0:
+                                this.logger = DebugHelper.from(this, 'update');
                                 plainData = this.paramsToPlain(data);
                                 return [4 /*yield*/, this.mutation(this.updateGraphQLOperation, this.model.identifiersFields.map(function (field) { return AttributeOptionHelper.FindByAttribute(field, _this.fields).columnName; }), {
                                         _set: {
@@ -3781,10 +4358,11 @@
                 return this.model.identifiersFields.reduce(function (ids, identifier) {
                     var _b;
                     var _a;
-                    if (lodash.isNil(instance[identifier]))
+                    var identifierBinded = identifier;
+                    if (lodash.isNil(instance[identifierBinded]))
                         return ids;
-                    var columnOption = AttributeOptionHelper.FindByAttribute(identifier, _this.fields);
-                    var value = ((_a = columnOption === null || columnOption === void 0 ? void 0 : columnOption.to) === null || _a === void 0 ? void 0 : _a.call(columnOption, data[identifier.toString()], instance)) || data[columnOption.attributeName];
+                    var columnOption = AttributeOptionHelper.FindByAttribute(identifierBinded, _this.fields);
+                    var value = ((_a = columnOption === null || columnOption === void 0 ? void 0 : columnOption.to) === null || _a === void 0 ? void 0 : _a.call(columnOption, data[identifierBinded], instance)) || data[columnOption.attributeName];
                     return Object.assign(Object.assign({}, ids), (_b = {}, _b[columnOption.columnName] = value, _b));
                 }, {});
             };
@@ -3813,11 +4391,13 @@
                     return __generator(this, function (_b) {
                         switch (_b.label) {
                             case 0:
+                                this.logger = DebugHelper.from(this, 'get');
                                 instance = this.model.toInstance(identifiers);
                                 return [4 /*yield*/, this.query(this.getGraphQLOperation, this.fields, this.model.identifiersFields.reduce(function (ids, identifier) {
                                         var _b;
                                         var _a;
-                                        if (lodash.isNil(instance[identifier]))
+                                        var identifierBinded = identifier;
+                                        if (lodash.isNil(instance[identifierBinded]))
                                             return ids;
                                         var columnOption = AttributeOptionHelper.FindByAttribute(identifier, _this.fields);
                                         var value = ((_a = columnOption === null || columnOption === void 0 ? void 0 : columnOption.to) === null || _a === void 0 ? void 0 : _a.call(columnOption, identifiers[identifier.toString()], instance)) || identifiers[identifier.toString()];
@@ -3845,7 +4425,13 @@
         return /** @class */ (function (_super) {
             __extends(FindHasuraGraphQLMixin, _super);
             function FindHasuraGraphQLMixin() {
-                return _super !== null && _super.apply(this, arguments) || this;
+                var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+                _this.bindOrderByAttributes = function (orderBy, fields) { return Object.keys(orderBy).reduce(function (acc, current) {
+                    var _b;
+                    return (Object.assign(Object.assign({}, acc), (_b = {}, _b[AttributeOptionHelper.FindByAttribute(current, fields)
+                        .columnName] = orderBy[current], _b)));
+                }, {}); };
+                return _this;
             }
             FindHasuraGraphQLMixin.prototype.find = function (params) {
                 var _a;
@@ -3855,9 +4441,18 @@
                     return __generator(this, function (_c) {
                         switch (_c.label) {
                             case 0:
+                                this.logger = DebugHelper.from(this, 'find');
                                 _b = params || {}, filters = _b.filters, limits = _b.limits, orderBy = _b.orderBy, options = _b.options;
                                 enableCount = (_a = options === null || options === void 0 ? void 0 : options.enableCount) !== null && _a !== void 0 ? _a : true;
-                                variablesCount = Object.assign(Object.assign({}, (lodash.isNil(orderBy) ? {} : { order_by: { type: this.tableName + "_order_by!", list: true, value: orderBy } })), (lodash.isNil(filters)
+                                variablesCount = Object.assign(Object.assign({}, (lodash.isNil(orderBy)
+                                    ? {}
+                                    : {
+                                        order_by: {
+                                            type: this.tableName + "_order_by!",
+                                            list: true,
+                                            value: this.bindOrderByAttributes(orderBy, this.fields),
+                                        },
+                                    })), (lodash.isNil(filters)
                                     ? {}
                                     : {
                                         where: {
@@ -5745,8 +6340,12 @@
     exports.CheckoutFirestoreRepository = CheckoutFirestoreRepository;
     exports.CheckoutSubscription = CheckoutSubscription;
     exports.CheckoutSubscriptionFirestoreRepository = CheckoutSubscriptionFirestoreRepository;
+    exports.ClassNameHelper = ClassNameHelper;
     exports.Coupon = Coupon;
     exports.CouponFirestoreRepository = CouponFirestoreRepository;
+    exports.Debug = Debug;
+    exports.DebugDecoratorHelper = DebugDecoratorHelper;
+    exports.DebugHelper = DebugHelper;
     exports.DuplicatedResultsError = DuplicatedResultsError;
     exports.Edition = Edition;
     exports.Filter = Filter;
@@ -5762,6 +6361,8 @@
     exports.LeadFirestoreRepository = LeadFirestoreRepository;
     exports.LegacyOrderFirestoreRepository = LegacyOrderFirestoreRepository;
     exports.LineItem = LineItem;
+    exports.Log = Log;
+    exports.Logger = Logger;
     exports.NotFoundError = NotFoundError;
     exports.Order = Order;
     exports.OrderFirestoreRepository = OrderFirestoreRepository;
@@ -5774,6 +6375,7 @@
     exports.ProductVariantFirestoreRepository = ProductVariantFirestoreRepository;
     exports.ProductsIndex = ProductsIndex;
     exports.RecoveryPassword = RecoveryPassword;
+    exports.ReflectHelper = ReflectHelper;
     exports.Register = Register;
     exports.RegisterFirebaseAuthService = RegisterFirebaseAuthService;
     exports.RequiredArgumentError = RequiredArgumentError;
@@ -5792,6 +6394,7 @@
     exports.SubscriptionPlan = SubscriptionPlan;
     exports.SubscriptionPlanFirestoreRepository = SubscriptionPlanFirestoreRepository;
     exports.SubscriptionProductFirestoreRepository = SubscriptionProductFirestoreRepository;
+    exports.Trace = Trace;
     exports.UnauthorizedError = UnauthorizedError;
     exports.User = User;
     exports.UserAddress = UserAddress;
@@ -5805,6 +6408,7 @@
     exports.VariantHasuraGraphQL = VariantHasuraGraphQL;
     exports.VariantHasuraGraphQLRepository = VariantHasuraGraphQLRepository;
     exports.WeakPasswordError = WeakPasswordError;
+    exports.isDebuggable = isDebuggable;
     exports.isUUID = isUUID;
     exports.parseDateTime = parseDateTime;
     exports.withCreateFirestore = withCreateFirestore;