@infrab4a/connect 4.0.0-beta.25 → 4.0.0-beta.27

package/fesm2020/infrab4a-connect.mjs

@@ -3,8 +3,10 @@ import { plainToInstance, instanceToPlain, Expose, Type } from 'class-transforme
 import { __decorate, __metadata } from 'tslib';
 import { parseISO } from 'date-fns';
 export { add, addBusinessDays, addDays, addMonths, addYears, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import { get as get$1, isString, isNil, isNumber, isDate, set, isObject, isEmpty, chunk, isBoolean, isInteger, isNaN as isNaN$1, omit } from 'lodash';
+import { isNil, isArray, first, last, flatten, compact, get as get$1, isString, isNumber, isDate, set, isObject, isEmpty, chunk, isBoolean, isInteger, isNaN as isNaN$1, omit } from 'lodash';
 export { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set } from 'lodash';
+import { Subject } from 'rxjs';
+import { debug } from 'debug';
 import { CustomError } from 'ts-custom-error';
 import axios from 'axios';
 import { collection, getDoc, doc, where, orderBy, getDocs, query, startAfter, startAt, limit, addDoc, setDoc, deleteField, arrayUnion, arrayRemove, deleteDoc, Timestamp } from 'firebase/firestore';
@@ -14,7 +16,8 @@ import { mutation, query as query$1 } from 'gql-query-builder';
 class BaseModel {
     get identifier() {
         const fields = this.constructor.identifiersFields.filter((field) => field !== 'identifier');
-        return fields.reduce((object, field) => ({ ...object, [field]: this[field] }), {});
+        const data = this;
+        return fields.reduce((object, field) => ({ ...object, [field]: data[field] }), {});
     }
     get identifiersFields() {
         return this.constructor.identifiersFields;
@@ -460,11 +463,437 @@ __decorate([
     __metadata("design:type", Payment)
 ], SubscriptionPayment.prototype, "payment", void 0);
 
-class Address extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
+var DebugNamespaces;
+(function (DebugNamespaces) {
+    DebugNamespaces["ROOT"] = "connect";
+    DebugNamespaces["TRACE"] = "trace";
+    DebugNamespaces["ERROR"] = "error";
+})(DebugNamespaces || (DebugNamespaces = {}));
+const Logger = debug(DebugNamespaces.ROOT);
+
+class ReflectHelper {
+    static get items() {
+        return this._items;
+    }
+    static get keys() {
+        return Object.keys(ReflectHelper.items);
+    }
+    static has(key, target, property) {
+        return (!isNil(key) &&
+            !isNil(ReflectHelper.items[key]) &&
+            (isNil(target) ||
+                (!isNil(ReflectHelper.items[key][target]) &&
+                    (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)])))));
+    }
+    static get({ key, target, property, own = true }) {
+        try {
+            if (own) {
+                return Reflect.getOwnMetadata(key, target, property) || null;
+            }
+            else {
+                return Reflect.getMetadata(key, target, property) || null;
+            }
+        }
+        catch (_err) {
+            return null;
+        }
+    }
+    static first({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? first(values) : values;
+    }
+    static last({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? last(values) : values;
+    }
+    static set({ key, target, property, value, propertyDescriptor }) {
+        Reflect.defineMetadata(key, value, target, property);
+        ReflectHelper.put({ key, target, property, value, propertyDescriptor });
+    }
+    static add({ key, target, property, value, propertyDescriptor }) {
+        let values = ReflectHelper.get({ key, target, property }) || new Array();
+        if (!Array.isArray(values))
+            values = [values];
+        values.push(value);
+        ReflectHelper.set({ key, target, property, value: values, propertyDescriptor });
+    }
+    static all({ key }) {
+        const items = ReflectHelper.items[key] || {};
+        return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))));
+    }
+    static allFrom(key, target) {
+        return Object.keys(target)
+            .filter((property) => property !== 'object')
+            .map((property) => this.allValuesFrom(key, target, property));
+    }
+    static allValuesFrom(key, target, property) {
+        const values = target[property];
+        let value = values.value;
+        const propertyDescriptor = values.propertyDescriptor;
+        if (!isArray(value))
+            value = [value];
+        return flatten(value.map((val) => {
+            return {
+                key,
+                target: target.object,
+                property,
+                value: val,
+                propertyDescriptor,
+            };
+        }));
+    }
+    static delete({ key, target, property }) {
+        Reflect.deleteMetadata(key, target, property);
+        return ReflectHelper.remove(key, target, property);
+    }
+    static clear(key) {
+        if (!key) {
+            ReflectHelper.keys.forEach((storedKey) => {
+                ReflectHelper.clear(storedKey);
+            });
+        }
+        else {
+            if (ReflectHelper.keys.includes(key)) {
+                Object.values(ReflectHelper.items[key]).forEach((target) => {
+                    if (ReflectHelper.has(key, target)) {
+                        Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {
+                            ReflectHelper.delete({
+                                key,
+                                target: target.object,
+                                property: String(property),
+                            });
+                            ReflectHelper.remove(key, target, String(property));
+                        });
+                    }
+                    ReflectHelper.delete({ key, target: target.object });
+                    ReflectHelper.remove(key, target);
+                });
+            }
+        }
+    }
+    static getType({ target, propertyKey }) {
+        return Reflect.getMetadata('design:type', target, propertyKey);
+    }
+    static getReturntype({ target, propertyKey }) {
+        return Reflect.getMetadata('design:returntype', target, propertyKey);
+    }
+    static getAllMethods(target) {
+        const props = [];
+        let obj = target;
+        do {
+            props.push(...Object.getOwnPropertyNames(obj));
+        } while ((obj = Object.getPrototypeOf(obj)));
+        return props.sort().filter((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;
+        });
+    }
+    static put({ key, target, property, value, propertyDescriptor }) {
+        const 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 (isNil(property)) {
+            ReflectHelper.items[key][index].value = {
+                value,
+                propertyDescriptor,
+            };
+        }
+        else {
+            ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {};
+            ReflectHelper.items[key][index][String(property)] = {
+                value,
+                propertyDescriptor,
+            };
+        }
+    }
+    static remove(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;
+    }
+}
+ReflectHelper._items = {};
+
+class DebugDecoratorHelper {
+    static set(target, options) {
+        ReflectHelper.add({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+            value: options,
+        });
+    }
+    static get(target) {
+        return ReflectHelper.first({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+        });
+    }
+}
+DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
+
+class ClassNameHelper {
+    static get(clazz) {
+        if (!clazz)
+            return null;
+        const prototype = Object.getPrototypeOf(clazz);
+        const names = compact([
+            get$1(clazz, 'constructor.name'),
+            get$1(prototype, 'constructor.name'),
+            get$1(prototype, '__proto__.constructor.name'),
+        ]);
+        return names.find((name) => name !== 'class_1');
+    }
+}
+
+const isDebuggable = (object) => {
+    return 'debug' in object;
+};
+class DebugHelper {
+    constructor(...namespace) {
+        this.namespaces = new Set();
+        this.push(...namespace);
+    }
+    static namespacesFor(target) {
+        if (isNil(target))
+            return [];
+        const decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target));
+        const namespaces = get$1(decorator, 'namespaces', []);
+        const name = get$1(decorator, 'name', ClassNameHelper.get(target));
+        return [...namespaces, name];
+    }
+    static as(...namespaces) {
+        return new DebugHelper(...namespaces);
+    }
+    static for(target, ...namespaces) {
+        const targetNamespaces = this.namespacesFor(target);
+        return new DebugHelper(...targetNamespaces, ...namespaces);
+    }
+    static from(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            const debug = target.debug;
+            if (namespaces)
+                debug.push(...namespaces);
+            return debug;
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clonedFrom(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            namespaces.push(...target.debug.entries);
+        }
+        else if (!isNil(target)) {
+            namespaces.push(...this.namespacesFor(target));
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clone(target, ...namespaces) {
+        let original;
+        if (this.isDebuggable(target)) {
+            original = target.debug;
+            namespaces.push(...original.entries);
+        }
+        return {
+            original,
+            debug: DebugHelper.for(target, ...namespaces),
+        };
+    }
+    static replace(target, attrs) {
+        if (this.isDebuggable(target))
+            target.debug = attrs.with;
+    }
+    static mock(target, ...namespaces) {
+        const { original, debug } = DebugHelper.clone(target, ...namespaces);
+        DebugHelper.replace(target, { with: debug });
+        return { original, debug };
+    }
+    get entries() {
+        return Array.from(get$1(this, 'namespaces', []));
+    }
+    get namespace() {
+        return compact(flatten(this.entries)).join(':');
+    }
+    log(message, ...args) {
+        this.logger(JSON.stringify(message), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.logs$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    trace(message, ...args) {
+        this.logger.extend(DebugNamespaces.TRACE)(message, ...args);
+        DebugHelper.traces$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    error(error, ...args) {
+        this.logger.extend(DebugNamespaces.ERROR)(JSON.stringify(error), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.errors$.next({ namespace: this.namespace, error, args });
+        return this;
+    }
+    build() {
+        this.logger = Logger;
+        this.tracer = Logger;
+        this.err = Logger;
+        this.entries.forEach((namespace) => {
+            this.logger = this.logger.extend(namespace);
+            this.tracer = this.tracer.extend(namespace);
+            this.err = this.err.extend(namespace);
+        });
+        return this;
+    }
+    with(...namespace) {
+        return new DebugHelper(...this.entries, ...namespace);
+    }
+    push(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.add(item));
+        }
+        return this.build();
+    }
+    unshift(...namespace) {
+        if (namespace) {
+            return this.reset(...namespace, ...this.entries);
+        }
+        return this;
+    }
+    reset(...namespace) {
+        this.namespaces = new Set(flatten(compact(namespace)));
+        return this.build();
     }
+    startWith(...namespace) {
+        const current = this.namespaces;
+        this.namespaces = new Set(flatten([compact(namespace), ...current]));
+        return this.build();
+    }
+    shift() {
+        const list = this.entries;
+        list.shift();
+        return this.reset(...list);
+    }
+    pop() {
+        const list = this.entries;
+        list.pop();
+        return this.reset(...list);
+    }
+    clear() {
+        return this.reset();
+    }
+    remove(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.delete(item));
+        }
+        return this.build();
+    }
+    puts(...args) {
+        return [`[${this.namespace}]`, ...args].join(' ');
+    }
+}
+DebugHelper.logs$ = new Subject();
+DebugHelper.traces$ = new Subject();
+DebugHelper.errors$ = new Subject();
+DebugHelper.isDebuggable = isDebuggable;
+
+function Debug(opts) {
+    return function (target) {
+        DebugDecoratorHelper.set(target.prototype, opts);
+    };
+}
+
+const ASYNC_IDENTIFIER = 'async';
+function Log(options = {}) {
+    return Trace({ level: 'log', ...options });
+}
+function Trace(options = {}) {
+    return function (target, propertyKey, propertyDescriptor) {
+        const method = propertyDescriptor.value;
+        const isPromise = method.toString().includes(ASYNC_IDENTIFIER);
+        const args = {
+            options,
+            method,
+            target,
+            propertyKey,
+            propertyDescriptor,
+        };
+        propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args);
+        return propertyDescriptor;
+    };
 }
+const traceCall = function ({ target, propertyKey, propertyDescriptor, args }) {
+    if (!target.debug)
+        target.debug = DebugHelper.for(target, propertyKey);
+    return target.debug.push(propertyKey).trace('called', { target, propertyKey, propertyDescriptor, args });
+};
+const promiseTracer = function ({ options, method, propertyKey, propertyDescriptor }) {
+    return function (...args) {
+        return new Promise((resolve, reject) => {
+            const debug = traceCall({ target: this, propertyDescriptor, propertyKey, args });
+            if (get$1(options, 'level', '') === 'log') {
+                debug.with('params').log(args);
+            }
+            return method
+                .apply(this, args)
+                .then((result) => {
+                if (options.callbackFn) {
+                    options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+                }
+                if (get$1(options, 'level', '') === 'log') {
+                    debug.with('returns').log(result === undefined ? 'void' : result);
+                }
+                return resolve(result);
+            })
+                .catch((error) => {
+                debug.error(error, ...args);
+                debug.with('stack').error(error.stack).pop();
+                return reject(error);
+            })
+                .finally(() => {
+                return debug.trace('finally', { args }).pop();
+            });
+        });
+    };
+};
+const functionTracer = function ({ options, target, method, propertyKey, propertyDescriptor, }) {
+    return function (...args) {
+        const debug = traceCall({ target: this || target, propertyDescriptor, propertyKey, args });
+        if (get$1(options, 'level', '') === 'log') {
+            debug.with('params').log(args);
+        }
+        let result;
+        try {
+            result = method.apply(this, args);
+            if (options.callbackFn)
+                options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+            if (get$1(options, 'level', '') === 'log') {
+                debug.with('returns').log(result === undefined ? 'void' : result);
+            }
+            return result;
+        }
+        catch (error) {
+            debug.error(error, ...args).pop();
+            throw error;
+        }
+        finally {
+            debug.trace('finally', { args }).pop();
+        }
+    };
+};
 
 const get = (object, path, defaultValue) => get$1(object, path, defaultValue);
 
@@ -579,7 +1008,7 @@ class User extends BaseModel {
         const instance = super.toInstance(data);
         if (!isNil(data.firstName))
             instance.displayName = `${data.firstName}${!isNil(data.lastName) ? ` ${data.lastName}` : ''}`;
-        return instance;
+        return;
     }
     toPlain() {
         const plain = super.toPlain();
@@ -595,6 +1024,18 @@ __decorate([
     __metadata("design:type", BeautyProfile)
 ], User.prototype, "beautyProfile", void 0);
 
+class Address extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class UserAddress extends Address {
+    static get identifiersFields() {
+        return ['id', 'userId'];
+    }
+}
+
 class Subscription extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -609,12 +1050,12 @@ __decorate([
     __metadata("design:type", SubscriptionPlan)
 ], Subscription.prototype, "subscriptionPlan", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Subscription.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Subscription.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => Coupon),
@@ -629,12 +1070,6 @@ __decorate([
     __metadata("design:type", Array)
 ], Subscription.prototype, "payment", void 0);
 
-class UserAddress extends Address {
-    static get identifiersFields() {
-        return ['id', 'userId'];
-    }
-}
-
 class UserPaymentMethod extends BaseModel {
     static get identifiersFields() {
         return ['id', 'userId'];
@@ -666,7 +1101,7 @@ class Authentication {
     async signIn({ email, password }, signInMethod) {
         const method = this.getServiceByMethod(signInMethod);
         const userAuth = await this.authService[method]({ email, password });
-        const user = this.userRepository.get(userAuth);
+        const user = this.userRepository.get({ id: userAuth.id });
         if (!isNil(user))
             return user;
         if (/^.+@b4a.com.br$/.test(userAuth.email))
@@ -760,18 +1195,12 @@ class RecoveryPassword {
 }
 
 class Filter extends BaseModel {
-    identifierFields() {
-        return ['id'];
-    }
     static get identifiersFields() {
         return ['id'];
     }
 }
 
 class Category extends BaseModel {
-    identifierFields() {
-        return ['id'];
-    }
     static get identifiersFields() {
         return ['id'];
     }
@@ -785,6 +1214,16 @@ __decorate([
     __metadata("design:type", Array)
 ], Category.prototype, "filters", void 0);
 
+class CategoryCollectionChildren extends BaseModel {
+    static get identifiersFields() {
+        return ['collectionId', 'categoryId'];
+    }
+}
+__decorate([
+    Type(() => CategoryCollectionChildren),
+    __metadata("design:type", CategoryCollectionChildren)
+], CategoryCollectionChildren.prototype, "parent", void 0);
+
 class CategoryFilter extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -811,9 +1250,6 @@ var Shops;
 })(Shops || (Shops = {}));
 
 class FilterOption extends BaseModel {
-    identifierFields() {
-        return ['id'];
-    }
     static get identifiersFields() {
         return ['id'];
     }
@@ -838,9 +1274,6 @@ class Product extends BaseModel {
         this.reviewsTotal = evaluation.count || this.reviewsTotal;
         this.rate = evaluation.rating || this.rate;
     }
-    identifierFields() {
-        return ['id'];
-    }
     static get identifiersFields() {
         return ['id'];
     }
@@ -856,7 +1289,7 @@ __decorate([
 
 class KitProduct extends BaseModel {
     static get identifiersFields() {
-        return ['productId', 'kitProducId'];
+        return ['productId', 'kitProductId'];
     }
 }
 __decorate([
@@ -869,9 +1302,6 @@ __decorate([
 ], KitProduct.prototype, "product", void 0);
 
 class Variant extends BaseModel {
-    identifierFields() {
-        return ['id'];
-    }
     static get identifiersFields() {
         return ['id', 'productId'];
     }
@@ -922,12 +1352,12 @@ __decorate([
     __metadata("design:type", User)
 ], Checkout.prototype, "user", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Checkout.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], Checkout.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => ShippingMethod),
@@ -963,12 +1393,12 @@ class CheckoutSubscription extends BaseModel {
     }
 }
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], CheckoutSubscription.prototype, "shippingAddress", void 0);
 __decorate([
-    Type(() => Address),
-    __metadata("design:type", Address)
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
 ], CheckoutSubscription.prototype, "billingAddress", void 0);
 __decorate([
     Type(() => SubscriptionPlan),
@@ -979,6 +1409,20 @@ __decorate([
     __metadata("design:type", Coupon)
 ], CheckoutSubscription.prototype, "coupon", void 0);
 
+class RoundProductPricesHelper {
+    static roundProductPrices(product) {
+        product.price.price = Number(product.price.price.toFixed(2));
+        product.price.fullPrice = Number(product.price.fullPrice.toFixed(2));
+        if (product.price.subscriberPrice) {
+            product.price.subscriberPrice = Number(product.price.subscriberPrice.toFixed(2));
+        }
+        if (product instanceof LineItem && product.pricePaid) {
+            product.pricePaid = Number(product.pricePaid.toFixed(2));
+        }
+        return product;
+    }
+}
+
 var FilterType;
 (function (FilterType) {
     FilterType["ACCESSORY_IMPORTANCE"] = "accessoryImportance";
@@ -1471,7 +1915,7 @@ const withFindFirestore = (MixinBase) => {
             const queries = [];
             if (limits?.offset) {
                 if (this.model.isModel(limits.offset))
-                    queries.push(startAfter(await getDoc(doc(this.collection(this.buildCollectionPathForFind(filters)), limits.offset.identifier[limits.offset.identifiersFields?.shift()]))));
+                    queries.push(startAfter(await getDoc(doc(this.collection(this.buildCollectionPathForFind(filters)), Object.values(limits.offset.identifier).shift()?.toString()))));
                 else if (isNumber(limits.offset) || isString(limits.offset))
                     queries.push(startAt(limits.offset));
             }
@@ -1501,7 +1945,7 @@ const withCreateFirestore = (MixinBase) => {
             return docBuilded;
         }
         async save(data) {
-            const id = data.identifier[data.identifiersFields?.shift()]?.toString();
+            const id = Object.values(data.identifier)?.shift()?.toString();
             const collectionPath = this.buildCollectionPathForAdd(data);
             const collection = this.collection(collectionPath);
             if (isEmpty(id))
@@ -1785,6 +2229,9 @@ class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFire
         }
         return is(products);
     }
+    getCategoryByShop(shop) {
+        return;
+    }
 }
 
 class ProductFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
@@ -2263,11 +2710,12 @@ BindFilterQueryHelper.MakeGraphQLWhere = (filter, fields) => Object.keys(filter)
 }, {});
 BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
     const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-    if (!Array.isArray(options) &&
+    const isNestedField = !Array.isArray(options) &&
         isObject(options) &&
         isNil(options?.operator) &&
         isNil(options?.value) &&
-        isNil(fieldSentenceOptions?.to))
+        isNil(fieldSentenceOptions?.to);
+    if (isNestedField)
         return Object.keys(options).reduce((variables, key) => {
             const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
             const columnName = fieldOptions.columnName;
@@ -2281,7 +2729,7 @@ BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
         return {
             [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
         };
-    if (isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
+    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
         options = Object.values(options)[0];
     return Array.isArray(options)
         ? options.reduce((whereSentence, option) => ({
@@ -2317,28 +2765,14 @@ GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = (fields) => {
         if (field === 'affected_rows')
             return field;
         const fieldName = Object.keys(field).shift();
-        const fieldValue = field[fieldName];
+        const fieldValue = is(field[fieldName]);
         if (Array.isArray(fieldValue))
             return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
         if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
-            return null;
-        if (fieldValue.fields)
-            return !fieldValue.filters
-                ? {
-                    [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                }
-                : {
-                    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;
+        const isNestedField = !!fieldValue.fields;
+        if (isNestedField)
+            return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
         return fieldValue.columnName;
     })
         .filter((field) => !!field);
@@ -2421,6 +2855,25 @@ GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
         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),
+    };
+};
 
 const withCreateHasuraGraphQL = (MixinBase) => {
     return class CreateHasuraGraphQLMixin extends MixinBase {
@@ -2431,6 +2884,7 @@ const withCreateHasuraGraphQL = (MixinBase) => {
             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);
         }
@@ -2443,8 +2897,8 @@ const withCreateHasuraGraphQL = (MixinBase) => {
                     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),
+                        [columnOptions.columnName]: Object.keys(columnOptions.foreignKeyColumn).map((foreignKeyField) => AttributeOptionHelper.FindByAttribute(foreignKeyField, columnOptions?.fields)
+                            ?.columnName || foreignKeyField),
                     },
                 ]);
             })
@@ -2466,9 +2920,11 @@ const withDeleteHasuraGraphQL = (MixinBase) => {
             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) => {
-                if (isNil(instance[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);
@@ -2495,6 +2951,7 @@ const withHasuraGraphQL = (MixinBase) => {
             this.authOptions = options.authOptions;
             this.model = options.model;
             this.fields = options.fields || this.model.identifiersFields;
+            this.logger = DebugHelper.from(this);
         }
         get headers() {
             return {
@@ -2518,13 +2975,18 @@ const withHasuraGraphQL = (MixinBase) => {
             return this.fetch(resultQuery);
         }
         async query(operation, fields, variables) {
-            const builded = this.buildHasuraQueryFields({ operation, fields, variables });
+            const builded = this.buildHasuraQueryFields({
+                operation,
+                fields: fields,
+                variables,
+            });
             const interpected = (await this.interceptors?.request?.(builded)) || builded;
             const resultQuery = query$1(interpected);
             const result = await this.fetch(resultQuery);
             return (await this.interceptors?.response?.(result, interpected)) || result;
         }
         async fetch(params) {
+            this.logger.with('params').log(params);
             const headers = this.headers;
             const { data: result } = await axios({
                 url: `${this.endpoint}`,
@@ -2534,6 +2996,7 @@ const withHasuraGraphQL = (MixinBase) => {
             });
             if (!isNil(result.errors))
                 throw new Error(JSON.stringify(result.errors));
+            this.logger.with('returns').log(result);
             return result.data;
         }
         getAttributeGraphQLTypeOf(value) {
@@ -2559,8 +3022,8 @@ const withHasuraGraphQL = (MixinBase) => {
                 return value;
             return date;
         }
-        convertDataFromHasura(data) {
-            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, this.fields);
+        convertDataFromHasura(data, fields) {
+            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, fields || this.fields);
             return this.model.toInstance(plain);
         }
         convertDataToHasura(instance, update = false) {
@@ -2601,6 +3064,7 @@ const withUpdateHasuraGraphQL = (MixinBase) => {
             this.updateGraphQLPKType = options?.updateGraphQLPKType || `${this.tableName}_pk_columns_input`;
         }
         async update(data) {
+            this.logger = DebugHelper.from(this, 'update');
             const plainData = this.paramsToPlain(data);
             await this.mutation(this.updateGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), {
                 _set: {
@@ -2626,10 +3090,11 @@ const withUpdateHasuraGraphQL = (MixinBase) => {
         getUpdateModelKeys(data) {
             const instance = this.model.toInstance(data);
             return this.model.identifiersFields.reduce((ids, identifier) => {
-                if (isNil(instance[identifier]))
+                const identifierBinded = identifier;
+                if (isNil(instance.identifier[identifierBinded]))
                     return ids;
-                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
-                const value = columnOption?.to?.(data[identifier], instance) || data[columnOption.attributeName];
+                const columnOption = AttributeOptionHelper.FindByAttribute(identifierBinded, this.fields);
+                const value = columnOption?.to?.(data[identifierBinded], instance) || data[columnOption.attributeName];
                 return {
                     ...ids,
                     [columnOption.columnName]: value,
@@ -2647,9 +3112,11 @@ const withGetHasuraGraphQL = (MixinBase) => {
             this.getGraphQLOperation = options?.getGraphQLOperation || `${this.tableName}_by_pk`;
         }
         async get(identifiers) {
+            this.logger = DebugHelper.from(this, 'get');
             const instance = this.model.toInstance(identifiers);
             const result = await this.query(this.getGraphQLOperation, this.fields, this.model.identifiersFields.reduce((ids, identifier) => {
-                if (isNil(instance[identifier]))
+                const identifierBinded = identifier;
+                if (isNil(instance[identifierBinded]))
                     return ids;
                 const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
                 const value = columnOption?.to?.(identifiers[identifier], instance) ||
@@ -2673,11 +3140,28 @@ const withGetHasuraGraphQL = (MixinBase) => {
 
 const withFindHasuraGraphQL = (MixinBase) => {
     return class FindHasuraGraphQLMixin extends MixinBase {
+        constructor() {
+            super(...arguments);
+            this.bindOrderByAttributes = (orderBy, fields) => Object.keys(orderBy).reduce((acc, current) => ({
+                ...acc,
+                [AttributeOptionHelper.FindByAttribute(current, fields)
+                    .columnName]: orderBy[current],
+            }), {});
+        }
         async find(params) {
+            this.logger = DebugHelper.from(this, 'find');
             const { filters, limits, orderBy, options } = params || {};
             const enableCount = options?.enableCount ?? true;
             const variablesCount = {
-                ...(isNil(orderBy) ? {} : { order_by: { type: `${this.tableName}_order_by!`, list: true, value: orderBy } }),
+                ...(isNil(orderBy)
+                    ? {}
+                    : {
+                        order_by: {
+                            type: `${this.tableName}_order_by!`,
+                            list: true,
+                            value: this.bindOrderByAttributes(orderBy, this.fields),
+                        },
+                    }),
                 ...(isNil(filters)
                     ? {}
                     : {
@@ -2753,6 +3237,41 @@ class VariantHasuraGraphQL extends Variant {
     }
 }
 
+class CategoryCollectionChildrenHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor(endpoint, authOptions) {
+        super({
+            tableName: 'category_collection_children',
+            model: CategoryCollectionChildren,
+            endpoint,
+            authOptions,
+            fields: [
+                { collectionId: { columnName: 'collection_id' } },
+                { categoryId: { columnName: 'category_id' } },
+                'name',
+                'slug',
+                'reference',
+                { parentCollectionId: { columnName: 'parent_collection_id' } },
+                { parentCategoryId: { columnName: 'parent_category_id' } },
+                {
+                    parent: {
+                        columnName: 'parent',
+                        foreignKeyColumn: { collectionId: 'parentCollectionId', categoryId: 'parentCategoryId' },
+                        fields: [
+                            { collectionId: { columnName: 'collection_id' } },
+                            { categoryId: { columnName: 'category_id' } },
+                            'name',
+                            'slug',
+                            'reference',
+                            { parentCollectionId: { columnName: 'parent_collection_id' } },
+                            { parentCategoryId: { columnName: 'parent_category_id' } },
+                        ],
+                    },
+                },
+            ],
+        });
+    }
+}
+
 class CategoryFilterHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, }) {
         super({
@@ -2822,6 +3341,7 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                 'image',
                 'published',
                 'shop',
+                { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
                 'slug',
                 { brandCategory: { columnName: 'brand_category' } },
                 { brandCategoryBanner: { columnName: 'brand_banner' } },
@@ -2919,13 +3439,36 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
     async getCategoryBySlug(slug, shop) {
         if (!slug)
             return null;
-        const { data } = await this.find({ filters: { slug, shop, published: true }, options: { enableCount: false } });
+        const { data } = await this.find({
+            filters: {
+                slug,
+                shops: { operator: Where.IN, value: [shop] },
+                published: { operator: Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
         if (!data.length)
             throw new NotFoundError(`Category with slug ${slug} not found`);
         if (data.length > 1)
             throw new DuplicatedResultsError('Query returned duplicated values');
         return data.shift();
     }
+    async getCategoryByShop(shop) {
+        if (!shop)
+            return;
+        const { data } = await this.find({
+            filters: {
+                shops: { operator: Where.IN, value: [shop] },
+                published: { operator: Where.EQUALS, value: true },
+            },
+            options: {
+                enableCount: false,
+            },
+        });
+        return data;
+    }
     async getCategoriesForHome(categoryIds, limit = 4, gender) {
         if (!categoryIds?.length)
             return [];
@@ -3504,6 +4047,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             },
         });
         const product = result?.data?.shift();
+        RoundProductPricesHelper.roundProductPrices(product);
         return product;
     }
     async update(params) {
@@ -3835,5 +4379,5 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
  * Generated bundle index. Do not edit.
  */
 
-export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, CampaignDashboard, CampaignDashboardFirestoreRepository, CampaignHashtag, CampaignHashtagFirestoreRepository, Category, CategoryFilter, CategoryFilterHasuraGraphQLRepository, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, Filter, FilterHasuraGraphQLRepository, FilterOption, FilterOptionHasuraGraphQLRepository, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, Register, RegisterFirebaseAuthService, RequiredArgumentError, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, ShopSettings, ShopSettingsFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, get, is, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
+export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, CampaignDashboard, CampaignDashboardFirestoreRepository, CampaignHashtag, CampaignHashtagFirestoreRepository, Category, CategoryCollectionChildren, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryFilter, CategoryFilterHasuraGraphQLRepository, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, ClassNameHelper, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, Debug, DebugDecoratorHelper, DebugHelper, DebugNamespaces, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, Filter, FilterHasuraGraphQLRepository, FilterOption, FilterOptionHasuraGraphQLRepository, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, Log, Logger, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, ReflectHelper, Register, RegisterFirebaseAuthService, RequiredArgumentError, RoundProductPricesHelper, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, ShopSettings, ShopSettingsFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, Trace, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, get, is, isDebuggable, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
 //# sourceMappingURL=infrab4a-connect.mjs.map