@infrab4a/connect 3.16.0-beta.1 → 4.0.0-beta.0

package/esm2020/infra/firebase/auth/authentication-firebase-auth.service.mjs

@@ -0,0 +1,41 @@
+import { GoogleAuthProvider, sendPasswordResetEmail, signInAnonymously, signInWithEmailAndPassword, signInWithPopup, } from 'firebase/auth';
+export class AuthenticationFirebaseAuthService {
+    constructor(firebaseAuth) {
+        this.firebaseAuth = firebaseAuth;
+    }
+    async signInWithEmailAndPassword(data) {
+        const credentials = await signInWithEmailAndPassword(this.firebaseAuth, data.email, data.password);
+        const user = credentials.user;
+        return {
+            id: user.uid,
+            displayName: user.displayName,
+            email: user.email,
+            phone: user.phoneNumber,
+            isAnonymous: false,
+        };
+    }
+    async signInWithGoogle() {
+        const credentials = await signInWithPopup(this.firebaseAuth, new GoogleAuthProvider());
+        const user = credentials.user;
+        return {
+            id: user.uid,
+            displayName: user.displayName,
+            email: user.email,
+            phone: user.phoneNumber,
+            isAnonymous: false,
+        };
+    }
+    async signOut() {
+        this.firebaseAuth.signOut();
+    }
+    async signInAnonymously() {
+        const auth = await signInAnonymously(this.firebaseAuth);
+        const user = auth.user;
+        user.id = auth.user.uid;
+        return user;
+    }
+    async sendPasswordResetEmail(email) {
+        return sendPasswordResetEmail(this.firebaseAuth, email);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/auth/register-firebase-auth.service.mjs

@@ -0,0 +1,33 @@
+import { createUserWithEmailAndPassword, sendEmailVerification } from 'firebase/auth';
+import { UserAlreadyRegisteredError, WeakPasswordError } from '../../../domain';
+import { RequiredArgumentError } from '../../../errors';
+import { is } from '../../../utils';
+export class RegisterFirebaseAuthService {
+    constructor(firebaseAuth) {
+        this.firebaseAuth = firebaseAuth;
+    }
+    async register(params) {
+        if (!params.email)
+            throw new RequiredArgumentError(['email']);
+        try {
+            const auth = await createUserWithEmailAndPassword(this.firebaseAuth, params.email, params.password);
+            const user = is(auth.user);
+            if (!user)
+                throw new Error('User not created');
+            await sendEmailVerification(user);
+            user.id = user.uid;
+            return user;
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            const firebaseError = error;
+            if (firebaseError.code === 'auth/email-already-in-use')
+                throw new UserAlreadyRegisteredError('Email already registered');
+            if (firebaseError.code === 'auth/weak-password')
+                throw new WeakPasswordError();
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/infra/firebase/auth/types/firebase-user-with-id.type.js → esm2020/infra/firebase/auth/types/firebase-user-with-id.type.mjs}

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZWJhc2UtdXNlci13aXRoLWlkLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9maXJlYmFzZS9hdXRoL3R5cGVzL2ZpcmViYXNlLXVzZXItd2l0aC1pZC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBGaXJlYmFzZVVzZXJXaXRoSWQgPSBmaXJlYmFzZS5Vc2VyICYgeyBpZDogc3RyaW5nIH1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZWJhc2UtdXNlci13aXRoLWlkLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9maXJlYmFzZS9hdXRoL3R5cGVzL2ZpcmViYXNlLXVzZXItd2l0aC1pZC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyIH0gZnJvbSAnZmlyZWJhc2UvYXV0aCdcbmltcG9ydCB7IEJhc2ljVXNlckRhdGEgfSBmcm9tICcuLi8uLi8uLi8uLi9kb21haW4nXG5cbmV4cG9ydCB0eXBlIEZpcmViYXNlVXNlcldpdGhJZCA9IEJhc2ljVXNlckRhdGEgJiBVc2VyICYgeyBpZDogc3RyaW5nIH1cbiJdfQ==

package/esm2020/infra/firebase/firestore/mixins/with-create-firestore.mixin.mjs

@@ -0,0 +1,27 @@
+import { addDoc, doc, getDoc, setDoc } from 'firebase/firestore';
+import { isEmpty } from '../../../../utils';
+export const withCreateFirestore = (MixinBase) => {
+    return class CreateFirestore extends MixinBase {
+        async create(data) {
+            const docRef = await this.save(this.model.toInstance(data));
+            const doc = await getDoc(docRef);
+            return doc.data();
+        }
+        async save(data) {
+            const id = data.identifier[data.identifiersFields?.shift()]?.toString();
+            const collectionPath = this.buildCollectionPathForAdd(data);
+            const collection = this.collection(collectionPath);
+            if (isEmpty(id))
+                return addDoc(collection, data);
+            const docRef = doc(collection, id);
+            await setDoc(docRef, data);
+            return docRef;
+        }
+        buildCollectionPathForAdd(identifiers) {
+            return this.isSubCollection(this)
+                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
+                : this.collectionName;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1jcmVhdGUtZmlyZXN0b3JlLm1peGluLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvaW5mcmEvZmlyZWJhc2UvZmlyZXN0b3JlL21peGlucy93aXRoLWNyZWF0ZS1maXJlc3RvcmUubWl4aW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQXFCLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUduRixPQUFPLEVBQUUsT0FBTyxFQUFxQyxNQUFNLG1CQUFtQixDQUFBO0FBRzlFLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLENBSWpDLFNBQWdGLEVBSWhGLEVBQUU7SUFDRixPQUFPLE1BQU0sZUFBZ0IsU0FBUSxTQUFTO1FBQzVDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBbUM7WUFDOUMsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLElBQVcsQ0FBQyxDQUFDLENBQUE7WUFDbEUsTUFBTSxHQUFHLEdBQUcsTUFBTSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUE7WUFFaEMsT0FBTyxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUE7UUFDbkIsQ0FBQztRQUVELEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBVztZQUNwQixNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLFFBQVEsRUFBRSxDQUFBO1lBQ3ZFLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyx5QkFBeUIsQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUMzRCxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLGNBQWMsQ0FBQyxDQUFBO1lBRWxELElBQUksT0FBTyxDQUFDLEVBQUUsQ0FBQztnQkFBRSxPQUFPLE1BQU0sQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLENBQUE7WUFFaEQsTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsQ0FBQTtZQUNsQyxNQUFNLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUE7WUFFMUIsT0FBTyxNQUFNLENBQUE7UUFDZixDQUFDO1FBRUQseUJBQXlCLENBQUMsV0FBMkI7WUFDbkQsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQztnQkFDL0IsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGNBQWMsSUFBSSxXQUFXLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLElBQUksQ0FBQyxjQUFjLEVBQUU7Z0JBQ3JHLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFBO1FBQ3pCLENBQUM7S0FDSyxDQUFBO0FBQ1YsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYWRkRG9jLCBkb2MsIERvY3VtZW50UmVmZXJlbmNlLCBnZXREb2MsIHNldERvYyB9IGZyb20gJ2ZpcmViYXNlL2ZpcmVzdG9yZSdcblxuaW1wb3J0IHsgQ3JlYXRlUmVwb3NpdG9yeSwgQ3JlYXRlUmVwb3NpdG9yeVBhcmFtcywgTW9kZWxCYXNlU3RydWN0dXJlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZG9tYWluJ1xuaW1wb3J0IHsgaXNFbXB0eSwgTWVyZ2VDb25zdHJ1Y3RvclBhcmFtcywgTWl4aW5DdG9yIH0gZnJvbSAnLi4vLi4vLi4vLi4vdXRpbHMnXG5pbXBvcnQgeyBGaXJlc3RvcmVIZWxwZXJzLCBGaXJlc3RvcmVSZXBvc2l0b3J5IH0gZnJvbSAnLi4vdHlwZXMnXG5cbmV4cG9ydCBjb25zdCB3aXRoQ3JlYXRlRmlyZXN0b3JlID0gPFxuICBUQmFzZSBleHRlbmRzIE1vZGVsQmFzZVN0cnVjdHVyZSxcbiAgVE1peGluQmFzZSBleHRlbmRzIE1peGluQ3RvcjxGaXJlc3RvcmVSZXBvc2l0b3J5PFRCYXNlPj4sXG4+KFxuICBNaXhpbkJhc2U6IE1peGluQ3RvcjxGaXJlc3RvcmVSZXBvc2l0b3J5PFRCYXNlPiAmIEZpcmVzdG9yZUhlbHBlcnM+ICYgVE1peGluQmFzZSxcbik6IE1peGluQ3RvcjxcbiAgRmlyZXN0b3JlUmVwb3NpdG9yeTxUQmFzZT4gJiBJbnN0YW5jZVR5cGU8VE1peGluQmFzZT4gJiBDcmVhdGVSZXBvc2l0b3J5PFRCYXNlPiAmIEZpcmVzdG9yZUhlbHBlcnMsXG4gIE1lcmdlQ29uc3RydWN0b3JQYXJhbXM8W10sIENvbnN0cnVjdG9yUGFyYW1ldGVyczxUTWl4aW5CYXNlPj5cbj4gPT4ge1xuICByZXR1cm4gY2xhc3MgQ3JlYXRlRmlyZXN0b3JlIGV4dGVuZHMgTWl4aW5CYXNlIGltcGxlbWVudHMgQ3JlYXRlUmVwb3NpdG9yeTxUQmFzZT4ge1xuICAgIGFzeW5jIGNyZWF0ZShkYXRhOiBDcmVhdGVSZXBvc2l0b3J5UGFyYW1zPFRCYXNlPik6IFByb21pc2U8VEJhc2U+IHtcbiAgICAgIGNvbnN0IGRvY1JlZiA9IGF3YWl0IHRoaXMuc2F2ZSh0aGlzLm1vZGVsLnRvSW5zdGFuY2UoZGF0YSBhcyBhbnkpKVxuICAgICAgY29uc3QgZG9jID0gYXdhaXQgZ2V0RG9jKGRvY1JlZilcblxuICAgICAgcmV0dXJuIGRvYy5kYXRhKClcbiAgICB9XG5cbiAgICBhc3luYyBzYXZlKGRhdGE6IFRCYXNlKTogUHJvbWlzZTxEb2N1bWVudFJlZmVyZW5jZTxUQmFzZT4+IHtcbiAgICAgIGNvbnN0IGlkID0gZGF0YS5pZGVudGlmaWVyW2RhdGEuaWRlbnRpZmllcnNGaWVsZHM/LnNoaWZ0KCldPy50b1N0cmluZygpXG4gICAgICBjb25zdCBjb2xsZWN0aW9uUGF0aCA9IHRoaXMuYnVpbGRDb2xsZWN0aW9uUGF0aEZvckFkZChkYXRhKVxuICAgICAgY29uc3QgY29sbGVjdGlvbiA9IHRoaXMuY29sbGVjdGlvbihjb2xsZWN0aW9uUGF0aClcblxuICAgICAgaWYgKGlzRW1wdHkoaWQpKSByZXR1cm4gYWRkRG9jKGNvbGxlY3Rpb24sIGRhdGEpXG5cbiAgICAgIGNvbnN0IGRvY1JlZiA9IGRvYyhjb2xsZWN0aW9uLCBpZClcbiAgICAgIGF3YWl0IHNldERvYyhkb2NSZWYsIGRhdGEpXG5cbiAgICAgIHJldHVybiBkb2NSZWZcbiAgICB9XG5cbiAgICBidWlsZENvbGxlY3Rpb25QYXRoRm9yQWRkKGlkZW50aWZpZXJzOiBQYXJ0aWFsPFRCYXNlPik6IHN0cmluZyB7XG4gICAgICByZXR1cm4gdGhpcy5pc1N1YkNvbGxlY3Rpb24odGhpcylcbiAgICAgICAgPyBgJHt0aGlzLnBhcmVudFJlcG9zaXRvcnkuY29sbGVjdGlvbk5hbWV9LyR7aWRlbnRpZmllcnNbdGhpcy5wYXJlbnRJZEZpZWxkXX0vJHt0aGlzLmNvbGxlY3Rpb25OYW1lfWBcbiAgICAgICAgOiB0aGlzLmNvbGxlY3Rpb25OYW1lXG4gICAgfVxuICB9IGFzIGFueVxufVxuIl19

package/esm2020/infra/firebase/firestore/mixins/with-crud-firestore.mixin.mjs

@@ -0,0 +1,10 @@
+import { withCreateFirestore } from './with-create-firestore.mixin';
+import { withDeleteFirestore } from './with-delete-firestore.mixin';
+import { withFindFirestore } from './with-find-firestore.mixin';
+import { withGetFirestore } from './with-get-firestore.mixin';
+import { withUpdateFirestore } from './with-update-firestore.mixin';
+export const withCrudFirestore = (MixinBase) => {
+    return class CrudFirestore extends withUpdateFirestore(withGetFirestore(withFindFirestore(withDeleteFirestore(withCreateFirestore(MixinBase))))) {
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/firestore/mixins/with-delete-firestore.mixin.mjs

@@ -0,0 +1,14 @@
+import { deleteDoc, doc } from 'firebase/firestore';
+export const withDeleteFirestore = (MixinBase) => {
+    return class DeleteFirestore extends MixinBase {
+        async delete(identifiers) {
+            await deleteDoc(doc(this.collection(this.buildCollectionPathForRemove(identifiers)), Object.values(identifiers).shift().toString()));
+        }
+        buildCollectionPathForRemove(identifiers) {
+            return this.isSubCollection(this)
+                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
+                : this.collectionName;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/firestore/mixins/with-find-firestore.mixin.mjs

@@ -0,0 +1,107 @@
+import { doc, getDoc, getDocs, limit, orderBy, query, startAfter, startAt, where, } from 'firebase/firestore';
+import { Where, } from '../../../../domain';
+import { is, isDate, isNil, isNumber, isObject, isString, set, } from '../../../../utils';
+import { FirestoreFieldType } from '../enums';
+export const withFindFirestore = (MixinBase) => {
+    const checkIfIsFilterOption = (filter) => !isNil(filter?.operator);
+    const getValueFromFilter = (filter) => {
+        return checkIfIsFilterOption(filter) ? filter.value : filter;
+    };
+    const getFinalValueFrom = (value) => isNumber(value) || isString(value) || isDate(value) || Array.isArray(value)
+        ? value
+        : Object.values(getFinalValueFrom);
+    return class FindFirestore extends MixinBase {
+        constructor() {
+            super(...arguments);
+            this.makeFirestoreWhere = (filter) => Object.keys(filter).reduce((queries, fieldName) => [
+                ...queries,
+                ...this.buildWhereSentence(fieldName, is(filter[fieldName])),
+            ], []);
+            this.buildWhereSentence = (fieldName, options) => {
+                if (this.isSubCollection(this) && fieldName === this.parentIdField)
+                    [];
+                const value = options?.value || options;
+                const object = {};
+                set(object, fieldName, value);
+                const plainInstance = new this.model(object).toPlain();
+                const firestoreFieldName = fieldName.toString().indexOf('.') > -1
+                    ? fieldName.toString()
+                    : Object.keys(plainInstance).find((key) => plainInstance[key]);
+                if (options?.operator === Where.LIKE) {
+                    if (Array.isArray(options?.value) &&
+                        (this.fields[firestoreFieldName] ===
+                            FirestoreFieldType.Array ||
+                            !this.fields[firestoreFieldName]))
+                        return [where(firestoreFieldName, 'array-contains-any', options.value)];
+                    return [where(firestoreFieldName, '>=', options.value), where(firestoreFieldName, '<=', `${options.value}~`)];
+                }
+                if (options?.operator === Where.IN &&
+                    Array.isArray(options?.value) &&
+                    (this.fields[firestoreFieldName] === FirestoreFieldType.Array ||
+                        !this.fields[firestoreFieldName]))
+                    return [where(firestoreFieldName, 'array-contains', options.value)];
+                if (isObject(options) && isNil(options?.operator) && isNil(options?.value)) {
+                    return Object.keys(options).reduce((queries, key) => [
+                        ...queries,
+                        ...this.buildWhereSentence(`${fieldName.toString()}.${key}`, is(options)[key]),
+                    ], []);
+                }
+                return [where(firestoreFieldName, options?.operator || '==', options?.value || options)];
+            };
+            this.makeFirestoreOrderBy = (filters, fieldsToOrderBy) => {
+                const orderByKeys = Object.keys(fieldsToOrderBy || {});
+                if (!orderByKeys.length)
+                    return [];
+                const filtersKeysWithUnordered = Object.keys(filters || {}).filter((filterKey) => !orderByKeys.includes(filterKey));
+                if (filtersKeysWithUnordered.length)
+                    filtersKeysWithUnordered.forEach((filterKey) => (fieldsToOrderBy = {
+                        ...(![Where.EQUALS].includes(is(filters[filterKey]).operator)
+                            ? { [filterKey]: 'asc' }
+                            : {}),
+                        ...fieldsToOrderBy,
+                    }));
+                return Object.keys(fieldsToOrderBy).map((fieldName) => orderBy(fieldName, fieldsToOrderBy[fieldName]));
+            };
+        }
+        async find({ filters, limits, orderBy, } = {}) {
+            const collection = this.collection(this.buildCollectionPathForFind(filters));
+            const queries = this.makeFirestoreWhere(filters || {});
+            const ordination = this.makeFirestoreOrderBy(filters, orderBy);
+            const offsets = await this.defineLimits(filters, limits);
+            const queryArgumments = [...queries, ...ordination, ...offsets];
+            const docs = await getDocs(query(collection, ...queryArgumments));
+            const data = docs.docs.map((doc) => doc.data());
+            return {
+                data,
+                count: this.calculateCount(data, limits),
+            };
+        }
+        buildCollectionPathForFind(filters) {
+            if (!this.isSubCollection(this))
+                return this.collectionName;
+            const parentIdField = this.parentIdField;
+            const parentId = getValueFromFilter(filters?.[parentIdField]);
+            return `${this.parentRepository.collectionName}/${parentId}/${this.collectionName}`;
+        }
+        async defineLimits(filters, limits) {
+            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.shift()))));
+                else if (isNumber(limits.offset) || isString(limits.offset))
+                    queries.push(startAt(limits.offset));
+            }
+            if (limits?.limit)
+                queries.push(limit(limits.limit));
+            return queries;
+        }
+        calculateCount(data, limits) {
+            if (data.length <= 0)
+                return 0;
+            if (data.length < limits?.limit)
+                return data.length;
+            return Infinity;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-find-firestore.mixin.js","sourceRoot":"","sources":["../../../../../../../projects/connect/src/infra/firebase/firestore/mixins/with-find-firestore.mixin.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CollectionReference,\n  doc,\n  getDoc,\n  getDocs,\n  limit,\n  orderBy,\n  query,\n  QueryConstraint,\n  startAfter,\n  startAt,\n  where,\n  WhereFilterOp,\n} from 'firebase/firestore'\n\nimport {\n  FindRepository,\n  ModelBaseStructure,\n  NonFunctionAndIdentifierPropertyNames,\n  NonFunctionPropertyNames,\n  RepositoryFindField,\n  RepositoryFindFielters,\n  RepositoryFindFieltersOptions,\n  RepositoryFindResult,\n  RepositoryLimitOptions,\n  RepositoryOrderBy,\n  Where,\n} from '../../../../domain'\nimport {\n  is,\n  isDate,\n  isNil,\n  isNumber,\n  isObject,\n  isString,\n  MergeConstructorParams,\n  MixinCtor,\n  set,\n} from '../../../../utils'\nimport { FirestoreFieldType } from '../enums'\nimport { FirestoreHelpers, FirestoreRepository } from '../types'\n\nexport const withFindFirestore = <\n  TBase extends ModelBaseStructure,\n  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,\n>(\n  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,\n): MixinCtor<\n  FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase> & FirestoreHelpers,\n  MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>\n> => {\n  const checkIfIsFilterOption = (filter: any): filter is RepositoryFindFieltersOptions<TBase, any> =>\n    !isNil(filter?.operator)\n  const getValueFromFilter = (filter: RepositoryFindField<TBase, any>): any => {\n    return checkIfIsFilterOption(filter) ? filter.value : filter\n  }\n  const getFinalValueFrom = (value: any) =>\n    isNumber(value) || isString(value) || isDate(value) || Array.isArray(value)\n      ? value\n      : Object.values(getFinalValueFrom)\n\n  return class FindFirestore extends MixinBase implements FindRepository<TBase> {\n    async find({\n      filters,\n      limits,\n      orderBy,\n    }: {\n      filters?: RepositoryFindFielters<TBase>\n      limits?: RepositoryLimitOptions<TBase>\n      orderBy?: RepositoryOrderBy<TBase>\n    } = {}): Promise<RepositoryFindResult<TBase>> {\n      const collection: CollectionReference<TBase> = this.collection(this.buildCollectionPathForFind(filters))\n      const queries = this.makeFirestoreWhere(filters || {})\n      const ordination = this.makeFirestoreOrderBy(filters, orderBy)\n      const offsets = await this.defineLimits(filters, limits)\n      const queryArgumments: QueryConstraint[] = [...queries, ...ordination, ...offsets]\n      const docs = await getDocs(query(collection, ...queryArgumments))\n      const data = docs.docs.map((doc) => doc.data())\n\n      return {\n        data,\n        count: this.calculateCount(data, limits),\n      }\n    }\n\n    buildCollectionPathForFind(filters: RepositoryFindFielters<TBase>): string {\n      if (!this.isSubCollection<TBase>(this)) return this.collectionName\n\n      const parentIdField = this.parentIdField\n      const parentId = getValueFromFilter(filters?.[parentIdField])\n\n      return `${this.parentRepository.collectionName}/${parentId}/${this.collectionName}`\n    }\n\n    makeFirestoreWhere = (filter: RepositoryFindFielters<TBase>): QueryConstraint[] =>\n      Object.keys(filter).reduce(\n        (queries: QueryConstraint[], fieldName: string) => [\n          ...queries,\n          ...this.buildWhereSentence(fieldName, is(filter[fieldName as NonFunctionPropertyNames<TBase>])),\n        ],\n        [],\n      )\n\n    buildWhereSentence = (\n      fieldName: NonFunctionPropertyNames<TBase> | string,\n      options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>,\n    ): QueryConstraint[] => {\n      if (this.isSubCollection<TBase>(this) && fieldName === this.parentIdField) []\n\n      const value = options?.value || options\n      const object = {}\n\n      set(object, fieldName, value)\n\n      const plainInstance = new this.model(object).toPlain()\n      const firestoreFieldName =\n        fieldName.toString().indexOf('.') > -1\n          ? fieldName.toString()\n          : Object.keys(plainInstance).find((key) => plainInstance[key])\n\n      if (options?.operator === Where.LIKE) {\n        if (\n          Array.isArray(options?.value) &&\n          (this.fields[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>] ===\n            FirestoreFieldType.Array ||\n            !this.fields[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>])\n        )\n          return [where(firestoreFieldName, 'array-contains-any', options.value)]\n\n        return [where(firestoreFieldName, '>=', options.value), where(firestoreFieldName, '<=', `${options.value}~`)]\n      }\n      if (\n        options?.operator === Where.IN &&\n        Array.isArray(options?.value) &&\n        (this.fields[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>] === FirestoreFieldType.Array ||\n          !this.fields[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>])\n      )\n        return [where(firestoreFieldName, 'array-contains', options.value)]\n      if (isObject(options) && isNil(options?.operator) && isNil(options?.value)) {\n        return Object.keys(options).reduce(\n          (queries, key) => [\n            ...queries,\n            ...this.buildWhereSentence(`${fieldName.toString()}.${key}`, is<Record<string, any>>(options)[key]),\n          ],\n          [],\n        )\n      }\n\n      return [where(firestoreFieldName, (options?.operator as WhereFilterOp) || '==', options?.value || options)]\n    }\n\n    makeFirestoreOrderBy = (\n      filters: RepositoryFindFielters<TBase>,\n      fieldsToOrderBy?: RepositoryOrderBy<TBase>,\n    ): QueryConstraint[] => {\n      const orderByKeys = Object.keys(fieldsToOrderBy || {})\n\n      if (!orderByKeys.length) return []\n\n      const filtersKeysWithUnordered = Object.keys(filters || {}).filter(\n        (filterKey) => !orderByKeys.includes(filterKey),\n      )\n\n      if (filtersKeysWithUnordered.length)\n        filtersKeysWithUnordered.forEach(\n          (filterKey) =>\n            (fieldsToOrderBy = {\n              ...(![Where.EQUALS].includes(\n                is<RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>>(\n                  filters[filterKey as NonFunctionPropertyNames<TBase>],\n                ).operator,\n              )\n                ? { [filterKey]: 'asc' }\n                : {}),\n              ...fieldsToOrderBy,\n            }),\n        )\n\n      return Object.keys(fieldsToOrderBy).map((fieldName) =>\n        orderBy(fieldName, fieldsToOrderBy[fieldName as NonFunctionPropertyNames<TBase>]),\n      )\n    }\n\n    async defineLimits(\n      filters: RepositoryFindFielters<TBase>,\n      limits: RepositoryLimitOptions<TBase>,\n    ): Promise<QueryConstraint[]> {\n      const queries = []\n\n      if (limits?.offset) {\n        if (this.model.isModel(limits.offset))\n          queries.push(\n            startAfter(\n              await getDoc(\n                doc(this.collection(this.buildCollectionPathForFind(filters)), limits.offset.identifier.shift()),\n              ),\n            ),\n          )\n        else if (isNumber(limits.offset) || isString(limits.offset)) queries.push(startAt(limits.offset))\n      }\n      if (limits?.limit) queries.push(limit(limits.limit))\n\n      return queries\n    }\n\n    calculateCount(data: TBase[], limits: RepositoryLimitOptions<TBase>): number {\n      if (data.length <= 0) return 0\n      if (data.length < limits?.limit) return data.length\n\n      return Infinity\n    }\n  } as any\n}\n"]}

package/esm2020/infra/firebase/firestore/mixins/with-firestore.mixin.mjs

@@ -0,0 +1,57 @@
+import { collection } from 'firebase/firestore';
+export const withFirestore = (MixinBase) => {
+    const isObjectsAndNoDate = (data) => data &&
+        !Array.isArray(data) &&
+        typeof data === 'object' &&
+        data?.constructor.name !== 'Timestamp' &&
+        !('seconds' in data);
+    const bindDate = (data, keyName) => {
+        if (data?.constructor.name === 'Timestamp')
+            return data.toDate();
+        if (data && typeof data === 'object' && 'seconds' in data)
+            return new Date(data.seconds * 1000);
+        if (typeof data === 'number' && ['createdAt', 'updatedAt'].includes(keyName))
+            return new Date(data);
+        return data;
+    };
+    const bindAllDateFromObject = (data) => {
+        return Object.keys(data).reduce((object, key) => ({
+            ...object,
+            [key]: isObjectsAndNoDate(data[key])
+                ? bindAllDateFromObject(data[key])
+                : Array.isArray(data[key])
+                    ? data[key].map((element) => (isObjectsAndNoDate(element) ? bindAllDateFromObject(element) : element))
+                    : bindDate(data[key], key),
+        }), {});
+    };
+    return class extends MixinBase {
+        constructor() {
+            super(...arguments);
+            this.collectionName = '';
+        }
+        collection(path) {
+            return collection(this.firestore, path || this.collectionName).withConverter(this.buildModelInstance());
+        }
+        buildModelInstance() {
+            return {
+                toFirestore: (data) => (data?.toPlain ? data.toPlain() : data),
+                fromFirestore: (snap) => {
+                    const data = snap.data();
+                    let bindedData = null;
+                    try {
+                        const ids = { id: snap.id };
+                        bindedData = bindAllDateFromObject(data);
+                        return this.model.toInstance({ ...bindedData, ...ids });
+                    }
+                    catch (error) {
+                        console.info('id', snap.id);
+                        console.info('data', JSON.stringify(bindedData));
+                        console.error(error);
+                        throw error;
+                    }
+                },
+            };
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1maXJlc3RvcmUubWl4aW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9maXJlYmFzZS9maXJlc3RvcmUvbWl4aW5zL3dpdGgtZmlyZXN0b3JlLm1peGluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQXVFLE1BQU0sb0JBQW9CLENBQUE7QUFZcEgsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQzNCLFNBQVksRUFDc0MsRUFBRTtJQUNwRCxNQUFNLGtCQUFrQixHQUFHLENBQUMsSUFBUyxFQUFXLEVBQUUsQ0FDaEQsSUFBSTtRQUNKLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7UUFDcEIsT0FBTyxJQUFJLEtBQUssUUFBUTtRQUN4QixJQUFJLEVBQUUsV0FBVyxDQUFDLElBQUksS0FBSyxXQUFXO1FBQ3RDLENBQUMsQ0FBQyxTQUFTLElBQUksSUFBSSxDQUFDLENBQUE7SUFDdEIsTUFBTSxRQUFRLEdBQUcsQ0FBQyxJQUF5QixFQUFFLE9BQWUsRUFBdUIsRUFBRTtRQUNuRixJQUFJLElBQUksRUFBRSxXQUFXLENBQUMsSUFBSSxLQUFLLFdBQVc7WUFBRSxPQUFPLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQTtRQUNoRSxJQUFJLElBQUksSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLElBQUksU0FBUyxJQUFJLElBQUk7WUFBRSxPQUFPLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLENBQUE7UUFDL0YsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLElBQUksQ0FBQyxXQUFXLEVBQUUsV0FBVyxDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQztZQUFFLE9BQU8sSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7UUFFbkcsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDLENBQUE7SUFDRCxNQUFNLHFCQUFxQixHQUFHLENBQUMsSUFBeUIsRUFBMEQsRUFBRTtRQUNsSCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsTUFBTSxDQUM3QixDQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDaEIsR0FBRyxNQUFNO1lBQ1QsQ0FBQyxHQUFHLENBQUMsRUFBRSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ2xDLENBQUMsQ0FBQyxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ2xDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztvQkFDMUIsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFZLEVBQUUsRUFBRSxDQUFDLENBQUMsa0JBQWtCLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQztvQkFDM0csQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxDQUFDO1NBQzdCLENBQUMsRUFDRixFQUE0RCxDQUM3RCxDQUFBO0lBQ0gsQ0FBQyxDQUFBO0lBRUQsT0FBTyxLQUFNLFNBQVEsU0FBUztRQUF2Qjs7WUFFTCxtQkFBYyxHQUFXLEVBQUUsQ0FBQTtRQWtDN0IsQ0FBQztRQTlCQyxVQUFVLENBQUMsSUFBYTtZQUN0QixPQUFPLFVBQVUsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLElBQUksSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLENBQUE7UUFDekcsQ0FBQztRQUVELGtCQUFrQjtZQUloQixPQUFPO2dCQUNMLFdBQVcsRUFBRSxDQUFDLElBQVcsRUFBZ0IsRUFBRSxDQUFDLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7Z0JBQ25GLGFBQWEsRUFBRSxDQUFDLElBQWtDLEVBQVMsRUFBRTtvQkFDM0QsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFBO29CQUN4QixJQUFJLFVBQVUsR0FBMkQsSUFBSSxDQUFBO29CQUU3RSxJQUFJO3dCQUNGLE1BQU0sR0FBRyxHQUFHLEVBQUUsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQTt3QkFFM0IsVUFBVSxHQUFHLHFCQUFxQixDQUFDLElBQUksQ0FBQyxDQUFBO3dCQUV4QyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsR0FBRyxVQUFVLEVBQUUsR0FBRyxHQUFHLEVBQUUsQ0FBQyxDQUFBO3FCQUN4RDtvQkFBQyxPQUFPLEtBQUssRUFBRTt3QkFDZCxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUE7d0JBQzNCLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQTt3QkFDaEQsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQTt3QkFFcEIsTUFBTSxLQUFLLENBQUE7cUJBQ1o7Z0JBQ0gsQ0FBQzthQUNGLENBQUE7UUFDSCxDQUFDO0tBQ0YsQ0FBQTtBQUNILENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvbGxlY3Rpb24sIENvbGxlY3Rpb25SZWZlcmVuY2UsIERvY3VtZW50RGF0YSwgRmlyZXN0b3JlLCBRdWVyeURvY3VtZW50U25hcHNob3QgfSBmcm9tICdmaXJlYmFzZS9maXJlc3RvcmUnXG5cbmltcG9ydCB7XG4gIEJhc2VNb2RlbEJ1aWxkZXIsXG4gIE1vZGVsQmFzZVN0cnVjdHVyZSxcbiAgTm9uRnVuY3Rpb25BbmRJZGVudGlmaWVyUHJvcGVydGllc1dpdGhOb1BhcnRpYWwsXG4gIE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnR5TmFtZXMsXG59IGZyb20gJy4uLy4uLy4uLy4uL2RvbWFpbidcbmltcG9ydCB7IE1peGluQ3RvciB9IGZyb20gJy4uLy4uLy4uLy4uL3V0aWxzJ1xuaW1wb3J0IHsgRmlyZXN0b3JlRmllbGRUeXBlIH0gZnJvbSAnLi4vZW51bXMnXG5pbXBvcnQgeyBGaXJlc3RvcmVSZXBvc2l0b3J5IH0gZnJvbSAnLi4vdHlwZXMnXG5cbmV4cG9ydCBjb25zdCB3aXRoRmlyZXN0b3JlID0gPFRCYXNlIGV4dGVuZHMgTW9kZWxCYXNlU3RydWN0dXJlLCBUIGV4dGVuZHMgTWl4aW5DdG9yID0gTWl4aW5DdG9yPihcbiAgTWl4aW5CYXNlOiBULFxuKTogTWl4aW5DdG9yPEZpcmVzdG9yZVJlcG9zaXRvcnk8VEJhc2U+LCB1bmtub3duW10+ID0+IHtcbiAgY29uc3QgaXNPYmplY3RzQW5kTm9EYXRlID0gKGRhdGE6IGFueSk6IGJvb2xlYW4gPT5cbiAgICBkYXRhICYmXG4gICAgIUFycmF5LmlzQXJyYXkoZGF0YSkgJiZcbiAgICB0eXBlb2YgZGF0YSA9PT0gJ29iamVjdCcgJiZcbiAgICBkYXRhPy5jb25zdHJ1Y3Rvci5uYW1lICE9PSAnVGltZXN0YW1wJyAmJlxuICAgICEoJ3NlY29uZHMnIGluIGRhdGEpXG4gIGNvbnN0IGJpbmREYXRlID0gKGRhdGE6IFJlY29yZDxzdHJpbmcsIGFueT4sIGtleU5hbWU6IHN0cmluZyk6IFJlY29yZDxzdHJpbmcsIGFueT4gPT4ge1xuICAgIGlmIChkYXRhPy5jb25zdHJ1Y3Rvci5uYW1lID09PSAnVGltZXN0YW1wJykgcmV0dXJuIGRhdGEudG9EYXRlKClcbiAgICBpZiAoZGF0YSAmJiB0eXBlb2YgZGF0YSA9PT0gJ29iamVjdCcgJiYgJ3NlY29uZHMnIGluIGRhdGEpIHJldHVybiBuZXcgRGF0ZShkYXRhLnNlY29uZHMgKiAxMDAwKVxuICAgIGlmICh0eXBlb2YgZGF0YSA9PT0gJ251bWJlcicgJiYgWydjcmVhdGVkQXQnLCAndXBkYXRlZEF0J10uaW5jbHVkZXMoa2V5TmFtZSkpIHJldHVybiBuZXcgRGF0ZShkYXRhKVxuXG4gICAgcmV0dXJuIGRhdGFcbiAgfVxuICBjb25zdCBiaW5kQWxsRGF0ZUZyb21PYmplY3QgPSAoZGF0YTogUmVjb3JkPHN0cmluZywgYW55Pik6IE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnRpZXNXaXRoTm9QYXJ0aWFsPFRCYXNlPiA9PiB7XG4gICAgcmV0dXJuIE9iamVjdC5rZXlzKGRhdGEpLnJlZHVjZShcbiAgICAgIChvYmplY3QsIGtleSkgPT4gKHtcbiAgICAgICAgLi4ub2JqZWN0LFxuICAgICAgICBba2V5XTogaXNPYmplY3RzQW5kTm9EYXRlKGRhdGFba2V5XSlcbiAgICAgICAgICA/IGJpbmRBbGxEYXRlRnJvbU9iamVjdChkYXRhW2tleV0pXG4gICAgICAgICAgOiBBcnJheS5pc0FycmF5KGRhdGFba2V5XSlcbiAgICAgICAgICA/IGRhdGFba2V5XS5tYXAoKGVsZW1lbnQ6IGFueSkgPT4gKGlzT2JqZWN0c0FuZE5vRGF0ZShlbGVtZW50KSA/IGJpbmRBbGxEYXRlRnJvbU9iamVjdChlbGVtZW50KSA6IGVsZW1lbnQpKVxuICAgICAgICAgIDogYmluZERhdGUoZGF0YVtrZXldLCBrZXkpLFxuICAgICAgfSksXG4gICAgICB7fSBhcyBOb25GdW5jdGlvbkFuZElkZW50aWZpZXJQcm9wZXJ0aWVzV2l0aE5vUGFydGlhbDxUQmFzZT4sXG4gICAgKVxuICB9XG5cbiAgcmV0dXJuIGNsYXNzIGV4dGVuZHMgTWl4aW5CYXNlIGltcGxlbWVudHMgRmlyZXN0b3JlUmVwb3NpdG9yeTxUQmFzZT4ge1xuICAgIHJlYWRvbmx5IGZpcmVzdG9yZT86IEZpcmVzdG9yZVxuICAgIGNvbGxlY3Rpb25OYW1lOiBzdHJpbmcgPSAnJ1xuICAgIG1vZGVsOiBCYXNlTW9kZWxCdWlsZGVyPFRCYXNlPlxuICAgIGZpZWxkczogUmVjb3JkPE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnR5TmFtZXM8VEJhc2U+LCBGaXJlc3RvcmVGaWVsZFR5cGU+XG5cbiAgICBjb2xsZWN0aW9uKHBhdGg/OiBzdHJpbmcpOiBDb2xsZWN0aW9uUmVmZXJlbmNlPFRCYXNlPiB7XG4gICAgICByZXR1cm4gY29sbGVjdGlvbih0aGlzLmZpcmVzdG9yZSwgcGF0aCB8fCB0aGlzLmNvbGxlY3Rpb25OYW1lKS53aXRoQ29udmVydGVyKHRoaXMuYnVpbGRNb2RlbEluc3RhbmNlKCkpXG4gICAgfVxuXG4gICAgYnVpbGRNb2RlbEluc3RhbmNlKCk6IHtcbiAgICAgIHRvRmlyZXN0b3JlOiAoZGF0YTogVEJhc2UpID0+IERvY3VtZW50RGF0YVxuICAgICAgZnJvbUZpcmVzdG9yZTogKHNuYXA6IFF1ZXJ5RG9jdW1lbnRTbmFwc2hvdDxUQmFzZT4pID0+IFRCYXNlXG4gICAgfSB7XG4gICAgICByZXR1cm4ge1xuICAgICAgICB0b0ZpcmVzdG9yZTogKGRhdGE6IFRCYXNlKTogRG9jdW1lbnREYXRhID0+IChkYXRhPy50b1BsYWluID8gZGF0YS50b1BsYWluKCkgOiBkYXRhKSxcbiAgICAgICAgZnJvbUZpcmVzdG9yZTogKHNuYXA6IFF1ZXJ5RG9jdW1lbnRTbmFwc2hvdDxUQmFzZT4pOiBUQmFzZSA9PiB7XG4gICAgICAgICAgY29uc3QgZGF0YSA9IHNuYXAuZGF0YSgpXG4gICAgICAgICAgbGV0IGJpbmRlZERhdGE6IE5vbkZ1bmN0aW9uQW5kSWRlbnRpZmllclByb3BlcnRpZXNXaXRoTm9QYXJ0aWFsPFRCYXNlPiA9IG51bGxcblxuICAgICAgICAgIHRyeSB7XG4gICAgICAgICAgICBjb25zdCBpZHMgPSB7IGlkOiBzbmFwLmlkIH1cblxuICAgICAgICAgICAgYmluZGVkRGF0YSA9IGJpbmRBbGxEYXRlRnJvbU9iamVjdChkYXRhKVxuXG4gICAgICAgICAgICByZXR1cm4gdGhpcy5tb2RlbC50b0luc3RhbmNlKHsgLi4uYmluZGVkRGF0YSwgLi4uaWRzIH0pXG4gICAgICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgIGNvbnNvbGUuaW5mbygnaWQnLCBzbmFwLmlkKVxuICAgICAgICAgICAgY29uc29sZS5pbmZvKCdkYXRhJywgSlNPTi5zdHJpbmdpZnkoYmluZGVkRGF0YSkpXG4gICAgICAgICAgICBjb25zb2xlLmVycm9yKGVycm9yKVxuXG4gICAgICAgICAgICB0aHJvdyBlcnJvclxuICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgIH1cbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/esm2020/infra/firebase/firestore/mixins/with-get-firestore.mixin.mjs

@@ -0,0 +1,20 @@
+import { doc, getDoc } from 'firebase/firestore';
+import { NotFoundError } from '../../../../errors';
+import { isNil } from '../../../../utils';
+export const withGetFirestore = (MixinBase) => {
+    return class GetFirestore extends MixinBase {
+        async get(identifiers) {
+            const docRef = await getDoc(doc(await this.collection(this.buildCollectionPathForGet(identifiers)), Object.values(identifiers).shift().toString()));
+            const data = docRef.data();
+            if (isNil(data))
+                throw new NotFoundError(`Document ${JSON.stringify(identifiers)} not found`);
+            return data;
+        }
+        buildCollectionPathForGet(identifiers) {
+            return this.isSubCollection(this)
+                ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
+                : this.collectionName;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/firestore/mixins/with-helpers.mixin.mjs

@@ -0,0 +1,17 @@
+import { isNil } from '../../../../utils';
+export const withHelpers = (MixinBase) => {
+    return class extends MixinBase {
+        toArray(snapShot) {
+            if (Array.isArray(snapShot)) {
+                return snapShot.map((doc) => doc.data());
+            }
+            else {
+                return snapShot.docs.map((doc) => doc.data());
+            }
+        }
+        isSubCollection(repository) {
+            return !isNil(Object.keys(this).find((key) => key === 'parentRepository'));
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/firestore/mixins/with-sub-collection.mixin.mjs

@@ -0,0 +1,11 @@
+export const withSubCollection = (MixinBase, ParentModel) => {
+    return class SubCollectionMix extends MixinBase {
+        constructor(...args) {
+            super(args);
+        }
+        collection(path) {
+            return super.collection(path);
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/infra/firebase/firestore/mixins/with-update-firestore.mixin.mjs

@@ -0,0 +1,48 @@
+import { arrayRemove, arrayUnion, deleteField, doc, getDoc, setDoc } from 'firebase/firestore';
+import { UpdateOptionActions, } from '../../../../domain';
+import { is, isNil } from '../../../../utils';
+export const withUpdateFirestore = (MixinBase) => {
+    const getValueFromParams = (params, field) => (isNil(is(params[field])?.value)
+        ? is(params[field])
+        : is(params[field]).value) || null;
+    const getValueByAction = (options) => {
+        if (isNil(options?.action))
+            return options;
+        if (options?.action === UpdateOptionActions.REMOVE_FIELD)
+            return deleteField();
+        if (options?.action === UpdateOptionActions.NULL)
+            return null;
+        if (Array.isArray(options?.value)) {
+            if (options?.action === UpdateOptionActions.MERGE)
+                return arrayUnion(...options.value);
+            if (options?.action === UpdateOptionActions.REMOVE)
+                return arrayRemove(...options.value);
+        }
+        return options?.value;
+    };
+    return class UpdateFirestore extends MixinBase {
+        async update(data) {
+            const model = new this.model();
+            const keyField = model.identifiersFields.shift();
+            const docRef = doc(this.collection(this.buildCollectionPathForUpdate(data)), getValueFromParams(data, keyField).toString());
+            await setDoc(docRef, this.paramsToPlain(data), { merge: true });
+            const docData = await getDoc(docRef);
+            return docData.data();
+        }
+        buildCollectionPathForUpdate(identifiers) {
+            return this.isSubCollection(this)
+                ? `${this.parentRepository.collectionName}/${getValueFromParams(identifiers, this.parentIdField)}/${this.collectionName}`
+                : this.collectionName;
+        }
+        paramsToPlain(params) {
+            const model = this.model;
+            if (model.isModel(params))
+                return params.toPlain();
+            return Object.keys(params).reduce((data, currentKey) => ({
+                ...data,
+                ...((value) => (value === undefined ? {} : { [currentKey]: value }))(getValueByAction(params[currentKey])),
+            }), {});
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-update-firestore.mixin.js","sourceRoot":"","sources":["../../../../../../../projects/connect/src/infra/firebase/firestore/mixins/with-update-firestore.mixin.ts"],"names":[],"mappings":"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","sourcesContent":["import { arrayRemove, arrayUnion, deleteField, doc, FieldValue, getDoc, setDoc } from 'firebase/firestore'\n\nimport {\n  ModelBaseStructure,\n  NonFunctionPropertyNames,\n  RepositoryUpdateParams,\n  UpdateOptionActions,\n  UpdateOptions,\n  UpdateRepository,\n} from '../../../../domain'\nimport { is, isNil, MergeConstructorParams, MixinCtor, PropType } from '../../../../utils'\nimport { FirestoreHelpers, FirestoreRepository } from '../types'\n\ntype RepositoryUpdateParamsKeys<TBase extends ModelBaseStructure> = keyof RepositoryUpdateParams<TBase>\n\nexport type UpdateFirestoreRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {\n  paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>\n}\n\nexport const withUpdateFirestore = <\n  TBase extends ModelBaseStructure,\n  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,\n>(\n  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,\n): MixinCtor<\n  FirestoreRepository<TBase> & UpdateRepository<TBase> & InstanceType<TMixinBase> & FirestoreHelpers,\n  MergeConstructorParams<{}[], ConstructorParameters<TMixinBase>>\n> => {\n  const getValueFromParams = (\n    params: RepositoryUpdateParams<TBase>,\n    field: NonFunctionPropertyNames<TBase>,\n  ): PropType<TBase, NonFunctionPropertyNames<TBase>> =>\n    (isNil(is<UpdateOptions<PropType<TBase, NonFunctionPropertyNames<TBase>>>>(params[field])?.value)\n      ? is<PropType<TBase, NonFunctionPropertyNames<TBase>>>(params[field])\n      : is<UpdateOptions<PropType<TBase, NonFunctionPropertyNames<TBase>>>>(params[field]).value) || null\n  const getValueByAction = (options: UpdateOptions<TBase>): FieldValue | unknown => {\n    if (isNil(options?.action)) return options\n    if (options?.action === UpdateOptionActions.REMOVE_FIELD) return deleteField()\n    if (options?.action === UpdateOptionActions.NULL) return null\n    if (Array.isArray(options?.value)) {\n      if (options?.action === UpdateOptionActions.MERGE) return arrayUnion(...options.value)\n      if (options?.action === UpdateOptionActions.REMOVE) return arrayRemove(...options.value)\n    }\n\n    return options?.value\n  }\n\n  return class UpdateFirestore extends MixinBase implements UpdateRepository<TBase> {\n    async update(data: RepositoryUpdateParams<TBase>): Promise<TBase> {\n      const model = new this.model()\n      const keyField = model.identifiersFields.shift()\n      const docRef = doc(\n        this.collection(this.buildCollectionPathForUpdate(data)),\n        getValueFromParams(data, keyField).toString(),\n      )\n\n      await setDoc(docRef, this.paramsToPlain(data), { merge: true })\n\n      const docData = await getDoc(docRef)\n\n      return docData.data()\n    }\n\n    buildCollectionPathForUpdate(identifiers: RepositoryUpdateParams<TBase>): string {\n      return this.isSubCollection(this)\n        ? `${this.parentRepository.collectionName}/${getValueFromParams(identifiers, this.parentIdField)}/${\n            this.collectionName\n          }`\n        : this.collectionName\n    }\n\n    paramsToPlain(params: RepositoryUpdateParams<TBase>): Partial<TBase> {\n      const model = this.model\n\n      if (model.isModel(params)) return params.toPlain()\n\n      return Object.keys(params).reduce(\n        (data, currentKey) => ({\n          ...data,\n          ...((value): Record<string, any> => (value === undefined ? {} : { [currentKey]: value }))(\n            getValueByAction(params[currentKey as never]),\n          ),\n        }),\n        {},\n      )\n    }\n  } as any\n}\n"]}

package/esm2020/infra/firebase/firestore/repositories/catalog/category-firestore.repository.mjs

@@ -0,0 +1,54 @@
+import { getDocs, limit, query, where } from 'firebase/firestore';
+import { Category } from '../../../../../domain';
+import { Base, chunk, is } from '../../../../../utils';
+import { DuplicatedResultsError, NotFoundError, RequiredArgumentError } from '../../../../../errors';
+import { withCrudFirestore, withFirestore, withHelpers } from '../../mixins';
+export class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor(firestore) {
+        super();
+        this.firestore = firestore;
+        this.collectionName = 'categories';
+        this.model = Category;
+    }
+    async getCategoryBySlug(slug, shop) {
+        const categoryDocs = await getDocs(query(this.collection(this.collectionName), where('slug', '==', slug), where('shop', '==', shop), where('published', '==', true)));
+        if (categoryDocs.size > 1)
+            throw new DuplicatedResultsError('Query returned duplicated values');
+        if (categoryDocs.empty)
+            throw new NotFoundError(`Document with slug ${slug} not found`);
+        return categoryDocs.docs[0].data();
+    }
+    async getCategoriesForHome(categoryIds, limit = 4) {
+        const categorySnap = await getDocs(query(this.collection(this.collectionName), where('id', 'in', categoryIds.filter(Boolean)), where('published', '==', true)));
+        if (categorySnap.empty)
+            throw new NotFoundError('Categories not found');
+        const categories = categorySnap.docs.map((doc) => doc.data());
+        const homeSections = await Promise.all(categories.map(async (category) => ({
+            category,
+            products: await this.mountCategory(category, { limit, hasStock: true }),
+        })));
+        return homeSections;
+    }
+    async mountCategory(category, options) {
+        if (!category.products)
+            throw new RequiredArgumentError(['Category products is empty']);
+        const chunks = chunk(category.products, 10);
+        const products = [];
+        const wheres = [];
+        for (const productIds of chunks) {
+            if (options?.limit && products.length >= options?.limit)
+                break;
+            wheres.push(where('published', '==', true), where('id', 'in', productIds));
+            if (options?.hasStock)
+                wheres.push(where('stock.quantity', '>', 0));
+            if (options?.limit)
+                wheres.push(limit(options?.limit));
+            const productSnap = await getDocs(query(this.collection('productsErpVitrine'), ...wheres));
+            if (productSnap.empty)
+                continue;
+            products.push(...productSnap.docs);
+        }
+        return is(products);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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