@goatlab/fluent-firebase 0.6.15 → 0.7.1

package/dist/FirebaseConnector.js

@@ -1,407 +1,366 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirebaseConnector = exports.createFirebaseRepository = void 0;
+exports.FirebaseConnector = void 0;
 const tslib_1 = require("tslib");
 const admin = tslib_1.__importStar(require("firebase-admin"));
-const fireorm_1 = require("fireorm");
-const firestore_1 = require("@google-cloud/firestore");
 const fluent_1 = require("@goatlab/fluent");
+const fluent_2 = require("@goatlab/fluent");
 const js_utils_1 = require("@goatlab/js-utils");
-const createFirebaseRepository = (Entity, dataSource) => {
-    const typeOrmRepo = dataSource.getRepository(Entity);
-    const repository = (0, fireorm_1.getRepository)(Entity);
-    let name = '';
-    let path = '';
-    const relations = {};
-    for (const relation of typeOrmRepo.metadata.relations) {
-        relations[relation.propertyName] = {
-            isOneToMany: relation.isOneToMany,
-            isManyToOne: relation.isManyToOne,
-            isManyToMany: relation.isManyToMany,
-            inverseSidePropertyPath: relation.inverseSidePropertyPath,
-            propertyPath: relation.propertyName,
-            entityName: relation.inverseEntityMetadata.name,
-            tableName: relation.inverseEntityMetadata.tableName,
-            targetClass: relation.inverseEntityMetadata.target,
-            joinColumns: relation.joinColumns,
-            inverseJoinColumns: relation.inverseJoinColumns
-        };
-    }
-    try {
-        const parsed = JSON.parse(JSON.stringify(repository));
-        name = parsed.colMetadata.name;
-        path = parsed.path;
-    }
-    catch (error) {
-        name = '';
-    }
-    return {
-        repository,
-        name,
-        path,
-        keys: [...['id', '_id'], ...(0, fluent_1.getOutputKeys)(typeOrmRepo)],
-        relations
-    };
-};
-exports.createFirebaseRepository = createFirebaseRepository;
-class FirebaseConnector extends fluent_1.BaseConnector {
-    constructor(Entity, dataSource, relationQuery) {
+class FirebaseConnector extends fluent_2.BaseConnector {
+    constructor({ entity, inputSchema, outputSchema }) {
         super();
-        const { repository, keys, name, relations } = (0, exports.createFirebaseRepository)(Entity, dataSource);
-        this.relationQuery = relationQuery;
-        this.repository = repository;
-        this.collection = admin.firestore().collection(name);
-        this.outputKeys = keys || [];
+        this.inputSchema = inputSchema;
+        this.outputSchema =
+            outputSchema || inputSchema;
+        this.entity = entity;
+        const relationShipBuilder = fluent_1.modelGeneratorDataSource.getRepository(entity);
+        const name = relationShipBuilder.metadata.givenTableName;
+        if (!name) {
+            throw new Error(`Could not find table by name. Did you include @f.entity in your model?`);
+        }
+        this.collection = admin
+            .firestore()
+            .collection(name);
+        const { relations } = (0, fluent_1.getRelationsFromModelGenerator)(relationShipBuilder);
         this.modelRelations = relations;
+        this.outputKeys = (0, fluent_2.getOutputKeys)(relationShipBuilder) || [];
     }
-    async get() {
-        let query = this.getGeneratedQuery();
-        let pivotData = [];
-        if (this.relationQuery && this.relationQuery.data && this.relationQuery.relation) {
-            const ids = this.relationQuery.data.map(d => d.id);
-            if (this.relationQuery?.relation?.isManyToMany) {
-                const pivotForeignKey = this.relationQuery.relation.joinColumns[0].propertyName;
-                const pivotInverseKey = this.relationQuery.relation.inverseJoinColumns[0].propertyName;
-                const { pivot } = this.relationQuery;
-                pivotData = await pivot.where(key => key[pivotForeignKey], "in", ids).get();
-                if (!pivotData.length) {
-                    return [];
-                }
-                const inverseIds = [...new Set(pivotData.map(d => d[pivotInverseKey]))];
-                if (!inverseIds.length) {
-                    return [];
-                }
-                if (inverseIds.length) {
-                    query = query.where("id", 'in', inverseIds);
-                }
+    async insert(data) {
+        const validatedData = this.inputSchema.parse(data);
+        if (data['id']) {
+            const found = await this.findById(data['id']);
+            if (found) {
+                throw new Error(`A document with id ${found[0]['id']} already exists.`);
             }
-            else {
-                query = query.where(this.relationQuery.relation.inverseSidePropertyPath, 'in', ids);
-            }
-        }
-        const snapshot = await query.get();
-        const result = [];
-        snapshot.forEach(doc => {
-            result.push(doc.data());
-        });
-        let data = this.jsApplySelect(result);
-        data = await (0, fluent_1.loadRelations)({
-            data,
-            relations: this.relations,
-            modelRelations: this.modelRelations,
-            provider: 'firebase',
-            self: this,
-            returnPivot: Boolean(this.relationQuery?.returnPivot)
-        });
-        if (pivotData.length && this.relationQuery?.returnPivot) {
-            const pivotInverseKey = this.relationQuery.relation.inverseJoinColumns[0].propertyName;
-            data = data.map(d => {
-                return { ...d, pivot: pivotData.find(p => p[pivotInverseKey] === d.id) };
-            });
         }
-        this.reset();
-        return data;
-    }
-    async getPaginated() {
-        const response = await this.get();
-        const result = this.jsApplySelect(response);
-        const results = {
-            current_page: 1,
-            data: result,
-            first_page_url: 'response[0].meta.firstPageUrl,',
-            next_page_url: 'response[0].meta.nextPageUrl',
-            path: 'response[0].meta.path',
-            per_page: 1,
-            prev_page_url: ' response[0].meta.previousPageUrl',
-            total: 10
+        const id = data['id'] || js_utils_1.Ids.objectIdString();
+        const item = {
+            id,
+            ...validatedData
         };
-        return results;
-    }
-    async all() {
-        return this.get();
+        await this.collection.doc(id).set(item);
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(item)));
     }
-    async find(filter = {}) {
-        const stringFilter = filter;
-        let parsedFilter = {};
-        try {
-            parsedFilter = JSON.parse(stringFilter);
-        }
-        catch (error) {
-            parsedFilter = {};
-        }
-        this.selectArray = (parsedFilter && parsedFilter.fields) || [];
-        this.whereArray =
-            (parsedFilter && parsedFilter.where && parsedFilter.where.and) || [];
-        this.orWhereArray =
-            (parsedFilter && parsedFilter.where && parsedFilter.where.or) || [];
-        this.limit((parsedFilter && (parsedFilter.limit || parsedFilter.take)) || 20);
-        this.offset((parsedFilter && (parsedFilter.offset || parsedFilter.skip)) || 0);
-        if (parsedFilter && parsedFilter.order) {
-            const orderB = [
-                parsedFilter.order.field,
-                parsedFilter.order.asc ? 'asc' : 'desc',
-                parsedFilter.order.type || 'string'
-            ];
-            this.chainReference.push({ method: 'orderBy', orderB });
-            this.orderByArray = orderB;
-        }
-        return this.get();
-    }
-    async paginate(paginator) {
-        if (!paginator) {
-            throw new Error('Paginator cannot be empty');
-        }
-        this.paginator = paginator;
-        const response = await this.getPaginated();
-        return response;
+    async insertMany(data) {
+        const validatedData = this.inputSchema.array().parse(data);
+        const batch = admin.firestore().batch();
+        const batchInserted = [];
+        validatedData.forEach(d => {
+            const id = d['id'] || js_utils_1.Ids.objectIdString();
+            const item = { id, ...d };
+            const insert = this.collection.doc(id);
+            batch.set(insert, item);
+            batchInserted.push(item);
+        });
+        await batch.commit();
+        return this.outputSchema.array().parse(batchInserted.map(d => {
+            return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        }));
     }
     raw() {
         return this.collection;
     }
-    async insert(data, forcedId) {
-        const id = forcedId || js_utils_1.Ids.objectIdString();
-        const datum = await this.repository.create({ id, ...data });
-        const result = this.jsApplySelect([datum]);
-        this.reset();
-        return result[0];
+    rawFirebase() {
+        return admin.firestore();
     }
-    async insertMany(data, forcedId) {
-        const batch = [];
-        data.forEach(d => {
-            const id = js_utils_1.Ids.objectIdString();
-            batch.push(this.repository.create({ id, ...d }));
-        });
-        const inserted = await Promise.all(batch);
-        const result = this.jsApplySelect(inserted);
-        this.reset();
-        return result;
-    }
-    async batchInsert(data) {
-        const batch = this.repository.createBatch();
-        data.forEach(d => {
-            const id = js_utils_1.Ids.objectIdString();
-            batch.create({ id, ...d });
+    async loadRelatedData(data, loadedKeys) {
+        let pivotData = [];
+        const result = await (0, fluent_2.loadRelations)({
+            data,
+            relations: loadedKeys,
+            modelRelations: this.modelRelations,
+            provider: 'firebase',
+            self: this,
+            returnPivot: false
         });
-        const inserted = await batch.commit();
-        const result = this.jsApplySelect(inserted);
-        this.reset();
         return result;
     }
-    async updateById(id, data) {
-        const parsedId = id;
-        const dbResult = await this.repository.findById(parsedId);
-        const updateData = {
-            ...dbResult,
-            ...data
-        };
-        const updated = await this.repository.update(updateData);
-        const result = this.jsApplySelect([updated]);
-        this.reset();
-        return result[0];
-    }
-    async replaceById(id, data) {
-        const parsedId = id;
-        const value = await this.repository.findById(parsedId);
-        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
-        Object.keys(flatValue).forEach(key => {
-            if (key !== 'id') {
-                flatValue[key] = null;
-            }
-        });
-        const nullObject = js_utils_1.Objects.nest(flatValue);
-        const newValue = { ...nullObject, ...data };
-        delete newValue.created;
-        delete newValue.updated;
-        const entity = { ...newValue };
-        await this.repository.update(entity);
-        const val = await this.repository.findById(parsedId);
-        const returnValue = this.jsApplySelect([val]);
-        this.reset();
-        return returnValue[0];
-    }
-    async clear({ sure }) {
-        if (!sure || sure !== true) {
-            throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
+    async findMany(query) {
+        const [andQuery, orQueries] = this.getGeneratedQueries(query);
+        const results = [];
+        if (andQuery) {
+            const snapshot = await andQuery.get();
+            snapshot.forEach(doc => {
+                results.push(doc.data());
+            });
         }
-        const query = this.collection.orderBy('__name__').limit(300);
-        this.reset();
-        return new Promise((resolve, reject) => {
-            this.deleteQueryBatch(admin.firestore(), query, 300, resolve, reject);
+        const promises = [];
+        for (const orQuery of orQueries) {
+            promises.push(orQuery.get());
+        }
+        const orSnapshots = await Promise.all(promises);
+        for (const orSnapshot of orSnapshots) {
+            orSnapshot.forEach(doc => {
+                results.push(doc.data());
+            });
+        }
+        let found = [...new Map(results.map(v => [v.id, v])).values()];
+        found.map(d => {
+            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
         });
-    }
-    async deleteById(id) {
-        const parsedId = id;
-        await this.repository.delete(parsedId);
-        this.reset();
-        return id;
-    }
-    async findById(id) {
-        const parsedId = id;
-        const data = await this.repository.findById(parsedId);
-        const result = this.jsApplySelect(data);
-        this.reset();
-        if (result.length === 0) {
-            return null;
+        if (query?.include) {
+            found = await this.loadRelatedData(found, js_utils_1.Objects.flatten(query?.include || {}));
         }
-        return result[0];
-    }
-    async findByIds(ids) {
-        const data = await this.raw().where('id', 'in', ids).get();
-        if (data.empty) {
-            return null;
+        if (query?.paginated) {
+            const paginationInfo = {
+                total: 0,
+                perPage: query.paginated.perPage,
+                currentPage: query.paginated.page,
+                nextPage: query.paginated.page + 1,
+                firstPage: 1,
+                lastPage: Math.ceil(0 / query.paginated.perPage),
+                prevPage: query.paginated.page === 1 ? null : query.paginated.page - 1,
+                from: (query.paginated.page - 1) * query.paginated.perPage + 1,
+                to: query.paginated.perPage * query.paginated.page,
+                data: found
+            };
+            return paginationInfo;
         }
-        const res = [];
-        data.forEach(doc => {
-            res.push(doc.data());
+        if (query?.select) {
+            return found;
+        }
+        return this.outputSchema?.array().parse(found);
+    }
+    loadFirst(query) {
+        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        detachedClass.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query
         });
-        const results = this.jsApplySelect(res);
-        this.reset();
-        return results;
+        return detachedClass;
     }
-    getPage() {
-        const page = 'page=';
-        if (this.paginator && this.paginator.page) {
-            return `${page + this.paginator.page}&`;
+    getGeneratedQueries(query) {
+        let { andWhere, orWhere } = this.getFirebaseWhereQuery(query?.where);
+        let mergedQueries = [];
+        if (andWhere) {
+            mergedQueries = [andWhere, ...orWhere];
         }
-        return '';
-    }
-    getPaginatorLimit(filter) {
-        if (this.paginator && this.paginator.perPage) {
-            return { ...filter, limit: this.paginator.perPage };
+        else {
+            mergedQueries = orWhere;
         }
-        return filter;
-    }
-    getPopulate() {
-        const populate = [];
-        this.populateArray.forEach(relation => {
-            if (typeof relation === 'string') {
-                populate.push({ relation });
+        const select = Object.keys(js_utils_1.Objects.flatten(query?.select || {}));
+        for (const [index] of mergedQueries.entries()) {
+            if (select?.length > 0) {
+                mergedQueries[index] = mergedQueries[index].select(...['id', ...select]);
             }
-            else if (Array.isArray(relation)) {
-                relation.forEach(nestedRelation => {
-                    if (typeof nestedRelation === 'string') {
-                        populate.push({ relation: nestedRelation });
+            mergedQueries[index] = mergedQueries[index].limit(query?.limit || 10);
+            mergedQueries[index] = mergedQueries[index].offset(query?.offset || 0);
+            if (query?.orderBy) {
+                for (const order of query?.orderBy) {
+                    const flattenObject = js_utils_1.Objects.flatten(order);
+                    for (const attribute of Object.keys(flattenObject)) {
+                        mergedQueries[index] = mergedQueries[index].orderBy(attribute, flattenObject[attribute]);
                     }
-                    else if (typeof nestedRelation === 'object') {
-                        populate.push(nestedRelation);
-                    }
-                });
-            }
-            else if (typeof relation === 'object') {
-                populate.push(relation);
+                }
             }
-        });
-        return populate;
-    }
-    getGeneratedQuery() {
-        let queryBuilder = this.getFilters();
-        const select = this.getSelect();
-        if (select.length > 0) {
-            queryBuilder = queryBuilder.select(...this.getSelect());
         }
-        const limit = this.getLimit();
-        if (limit > 0) {
-            queryBuilder = queryBuilder.limit(limit);
+        const cloned = [...mergedQueries];
+        if (andWhere) {
+            cloned.shift();
         }
-        const skip = this.getSkip();
-        if (skip) {
-            queryBuilder = queryBuilder.offset(skip);
+        return [andWhere ? mergedQueries[0] : undefined, cloned];
+    }
+    getFirebaseWhereQuery(where) {
+        if (!where || Object.keys(where).length === 0) {
+            return { andWhere: this.collection, orWhere: [] };
         }
-        const order = this.getOrderBy();
-        if (order[0] && order[0] !== '') {
-            const fieldPath = new firestore_1.FieldPath(order[0] || '');
-            const orderByOrder = order[1] || 'desc';
-            queryBuilder = queryBuilder.orderBy(fieldPath, orderByOrder);
+        let andWhereQuery = this.collection;
+        let orWhereQueries = [];
+        const orConditions = this.extractConditions(where['OR']);
+        const andConditions = this.extractConditions(where['AND']);
+        const copy = js_utils_1.Objects.clone(where);
+        if (!!copy['AND']) {
+            delete copy['AND'];
         }
-        return queryBuilder;
-    }
-    getFilters() {
-        const andFilters = this.whereArray;
-        const orFilters = this.orWhereArray;
-        if (!andFilters || andFilters.length === 0) {
-            return this.collection;
+        if (!!copy['OR']) {
+            delete copy['OR'];
         }
-        let filterQuery;
-        andFilters.forEach((condition, index) => {
-            const element = condition[0];
-            const operator = condition[1];
-            const value = condition[2];
-            if (index === 0) {
-                filterQuery = this.collection;
-            }
+        const rootLevelConditions = this.extractConditions([copy]);
+        for (const condition of andConditions) {
+            const { element, operator, value } = condition;
             switch (operator) {
-                case '=':
-                    filterQuery = filterQuery.where(element, '==', value);
+                case fluent_1.LogicOperator.equals:
+                    andWhereQuery = andWhereQuery.where(element, '==', value);
                     break;
-                case '!=':
-                    filterQuery = filterQuery.where(element, '!=', value);
+                case fluent_1.LogicOperator.isNot:
+                    andWhereQuery = andWhereQuery.where(element, '!=', value);
                     break;
-                case '>':
-                    filterQuery = filterQuery.where(element, operator, value);
+                case fluent_1.LogicOperator.greaterThan:
+                    andWhereQuery = andWhereQuery.where(element, '>', value);
                     break;
-                case '>=':
-                    filterQuery = filterQuery.where(element, operator, value);
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    andWhereQuery = andWhereQuery.where(element, '>=', value);
                     break;
-                case '<':
-                    filterQuery = filterQuery.where(element, operator, value);
+                case fluent_1.LogicOperator.lessThan:
+                    andWhereQuery = andWhereQuery.where(element, '<', value);
                     break;
-                case '<=':
-                    filterQuery = filterQuery.where(element, operator, value);
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    andWhereQuery = andWhereQuery.where(element, '<=', value);
                     break;
-                case 'in':
-                    filterQuery = filterQuery.where(element, 'in', value);
+                case fluent_1.LogicOperator.in:
+                    andWhereQuery = andWhereQuery.where(element, 'in', value);
                     break;
-                case 'array-contains':
-                    filterQuery = filterQuery.where(element, 'array-contains', value);
+                case fluent_1.LogicOperator.arrayContains:
+                    andWhereQuery = andWhereQuery.where(element, 'array-contains', value);
                     break;
-                case 'nin':
-                    throw new Error('The nin Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.notIn:
+                    andWhereQuery = andWhereQuery.where(element, 'not-in', value);
                     break;
-                case 'exists':
+                case fluent_1.LogicOperator.exists:
                     throw new Error('The nin Operator cannot be used in Firabase');
-                    break;
-                case '!exists':
+                case fluent_1.LogicOperator.notExists:
                     throw new Error('The !exists Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.regexp:
+                    throw new Error('The regexp Operator cannot be used in Firabase');
+                default:
+                    throw new Error('The regexp Operator cannot be used in Firabase');
+            }
+        }
+        for (const condition of rootLevelConditions) {
+            const { element, operator, value } = condition;
+            switch (operator) {
+                case fluent_1.LogicOperator.equals:
+                    andWhereQuery = andWhereQuery.where(element, '==', value);
+                    break;
+                case fluent_1.LogicOperator.isNot:
+                    andWhereQuery = andWhereQuery.where(element, '!=', value);
+                    break;
+                case fluent_1.LogicOperator.greaterThan:
+                    andWhereQuery = andWhereQuery.where(element, '>', value);
                     break;
-                case 'regexp':
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    andWhereQuery = andWhereQuery.where(element, '>=', value);
+                    break;
+                case fluent_1.LogicOperator.lessThan:
+                    andWhereQuery = andWhereQuery.where(element, '<', value);
+                    break;
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    andWhereQuery = andWhereQuery.where(element, '<=', value);
+                    break;
+                case fluent_1.LogicOperator.in:
+                    andWhereQuery = andWhereQuery.where(element, 'in', value);
+                    break;
+                case fluent_1.LogicOperator.arrayContains:
+                    andWhereQuery = andWhereQuery.where(element, 'array-contains', value);
+                    break;
+                case fluent_1.LogicOperator.notIn:
+                    andWhereQuery = andWhereQuery.where(element, 'not-in', value);
+                    break;
+                case fluent_1.LogicOperator.exists:
+                    throw new Error('The nin Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.notExists:
+                    throw new Error('The !exists Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.regexp:
                     throw new Error('The regexp Operator cannot be used in Firabase');
+                default:
+                    throw new Error('The regexp Operator cannot be used in Firabase');
+            }
+        }
+        for (const condition of orConditions) {
+            const { element, operator, value } = condition;
+            let orQuery = this.collection;
+            switch (operator) {
+                case fluent_1.LogicOperator.equals:
+                    orQuery = orQuery.where(element, '==', value);
+                    break;
+                case fluent_1.LogicOperator.isNot:
+                    orQuery = orQuery.where(element, '!=', value);
+                    break;
+                case fluent_1.LogicOperator.greaterThan:
+                    orQuery = orQuery.where(element, '>', value);
+                    break;
+                case fluent_1.LogicOperator.greaterOrEqualThan:
+                    orQuery = orQuery.where(element, '>=', value);
+                    break;
+                case fluent_1.LogicOperator.lessThan:
+                    orQuery = orQuery.where(element, '<', value);
+                    break;
+                case fluent_1.LogicOperator.lessOrEqualThan:
+                    orQuery = orQuery.where(element, '<=', value);
                     break;
+                case fluent_1.LogicOperator.in:
+                    orQuery = orQuery.where(element, 'in', value);
+                    break;
+                case fluent_1.LogicOperator.arrayContains:
+                    orQuery = orQuery.where(element, 'array-contains', value);
+                    break;
+                case fluent_1.LogicOperator.notIn:
+                    orQuery = orQuery.where(element, 'not-in', value);
+                    break;
+                case fluent_1.LogicOperator.exists:
+                    throw new Error('The nin Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.notExists:
+                    throw new Error('The !exists Operator cannot be used in Firabase');
+                case fluent_1.LogicOperator.regexp:
+                    throw new Error('The regexp Operator cannot be used in Firabase');
+                default:
+                    throw new Error('The regexp Operator cannot be used in Firabase');
             }
-        });
-        return filterQuery;
-    }
-    getOrderBy() {
-        if (!this.orderByArray || this.orderByArray.length === 0) {
-            return [];
+            orWhereQueries.push(orQuery);
         }
-        return [this.orderByArray[0], this.orderByArray[1].toLowerCase()];
-    }
-    getLimit() {
-        if (!this.limitNumber || this.limitNumber === 0) {
-            this.limitNumber = (this.rawQuery && this.rawQuery.limit) || 20;
+        let andWhereCondition = undefined;
+        if (!andConditions?.length &&
+            !rootLevelConditions?.length &&
+            !orConditions?.length) {
+            andWhereCondition = this.collection;
         }
-        return this.limitNumber;
-    }
-    getSkip() {
-        if (!this.offsetNumber) {
-            this.offsetNumber = (this.rawQuery && this.rawQuery.skip) || 0;
+        if (andConditions?.length || rootLevelConditions?.length) {
+            andWhereCondition = andWhereQuery;
         }
-        return this.offsetNumber;
+        return {
+            andWhere: andWhereCondition,
+            orWhere: orWhereQueries
+        };
     }
-    getSelect() {
-        let select = this.selectArray;
-        select = select.map(s => {
-            s = s.split(' as ')[0];
-            s = s.includes('id') ? 'id' : s;
-            return s;
+    async updateById(id, data) {
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        await this.collection.doc(id).update({
+            ...validatedData,
+            id
         });
-        if (select.find(e => e.startsWith('data.'))) {
-            select.unshift('data');
-        }
-        if (!select) {
-            return [];
+        const dbResult = await this.findById(id);
+        if (!dbResult) {
+            throw new Error(`Object not found: ${id}`);
         }
-        return select;
+        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
+    }
+    async replaceById(id, data) {
+        const value = await this.findById(id);
+        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
+        Object.keys(flatValue).forEach(key => {
+            flatValue[key] = null;
+        });
+        const nullObject = js_utils_1.Objects.nest(flatValue);
+        const newValue = { ...nullObject, ...data };
+        delete newValue._id;
+        delete newValue.id;
+        delete newValue.created;
+        delete newValue.updated;
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        await this.collection
+            .doc(id)
+            .update(validatedData);
+        const val = await this.findById(id);
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
+    }
+    async clear() {
+        const query = this.collection.orderBy('__name__').limit(300);
+        return new Promise((resolve, reject) => {
+            this.deleteQueryBatch(admin.firestore(), query, 300, resolve, reject);
+        });
     }
     deleteQueryBatch(db, query, batchSize, resolve, reject) {
         query
@@ -427,5 +386,50 @@ class FirebaseConnector extends fluent_1.BaseConnector {
         })
             .catch(reject);
     }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                where: {
+                    id
+                }
+            }
+        });
+        return newInstance;
+    }
+    clone() {
+        return new this.constructor();
+    }
+    async findByIds(ids, q) {
+        let data = await this.findMany({
+            where: {
+                id: {
+                    in: ids
+                }
+            },
+            limit: q?.limit,
+            select: q?.select,
+            include: q?.include
+        });
+        return this.outputSchema?.array().parse(data);
+    }
+    async findById(id, q) {
+        const found = await this.findByIds([id], q);
+        return found[0];
+    }
+    async requireById(id, q) {
+        let found = await this.findById(id, {
+            select: q?.select,
+            include: q?.include,
+            limit: 1
+        });
+        if (!found) {
+            throw new Error(`Object ${id} not found`);
+        }
+        found = this.clearEmpties(js_utils_1.Objects.deleteNulls(found));
+        return this.outputSchema?.parse(found);
+    }
 }
 exports.FirebaseConnector = FirebaseConnector;