@goatlab/fluent-firebase 0.7.17 → 0.7.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) GOAT, SPA. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,39 +1,27 @@
 {
   "name": "@goatlab/fluent-firebase",
-  "version": "0.7.17",
+  "version": "0.7.19",
   "description": "Readable query Interface & API generator for TS and Node",
   "dependencies": {
-    "@goatlab/fluent": "^0.7.31",
-    "@goatlab/js-utils": "^0.8.24",
+    "@goatlab/fluent": "^0.7.33",
     "@google-cloud/firestore": "^6.0.0",
-    "firebase-admin": "^11.0.1"
+    "firebase-admin": "^11.0.1",
+    "@goatlab/js-utils": "0.8.35"
   },
   "devDependencies": {
     "@types/jest": "^27.4.1",
     "@types/node": "^17.0.23",
     "dotenv-cli": "^5.1.0",
     "eslint": "^8.5.0",
-    "jest": "^27.5.1",
+    "jest": "^29.7.0",
     "jest-environment-node": "^27.5.1",
     "prettier": "^2.6.1",
     "pretty-quick": "^3.1.3",
-    "ts-jest": "^27.1.4",
-    "ts-node": "^10.7.0",
+    "ts-jest": "^29.2.6",
+    "ts-node": "^10.9.2",
     "turbo": "^1.1.10",
-    "typescript": "^4.6.3"
-  },
-  "scripts": {
-    "install-p": "yarn",
-    "prebuild": "rimraf dist",
-    "prestart": "rimraf dist",
-    "predev": "rimraf dist",
-    "test": "jest --forceExit --passWithNoTests",
-    "dev": "tsc --watch",
-    "lint": "eslint src --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-    "update:packages": "npm-check-updates -u && yarn",
-    "serve": "tsc -w",
-    "build": "tsc"
+    "typescript": "^4.6.3",
+    "@goatlab/tsconfig": "0.0.11"
   },
   "homepage": "https://docs.goatlab.io",
   "main": "dist/index.js",
@@ -53,5 +41,17 @@
   "license": "MIT",
   "engines": {
     "node": ">=14.16.0"
+  },
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "prestart": "rimraf dist",
+    "predev": "rimraf dist",
+    "test": "echo 'skip'",
+    "dev": "tsc --watch",
+    "lint": "echo 'skip'",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "update:packages": "npm-check-updates -u && yarn",
+    "serve": "tsc -w",
+    "build": "echo 'skip'"
   }
-}
+}

package/dist/Firebase.d.ts

@@ -1,9 +0,0 @@
-import * as admin from 'firebase-admin';
-import { getAuth as firebaseGetAuth } from 'firebase-admin/auth';
-export declare type FirebaseUser = admin.auth.DecodedIdToken;
-declare class FirebaseClass {
-    verifyIdToken: (token: string) => Promise<import("firebase-admin/auth").DecodedIdToken>;
-    getAuth: typeof firebaseGetAuth;
-}
-export declare const Firebase: FirebaseClass;
-export {};

package/dist/Firebase.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Firebase = void 0;
-const tslib_1 = require("tslib");
-const admin = tslib_1.__importStar(require("firebase-admin"));
-const auth_1 = require("firebase-admin/auth");
-class FirebaseClass {
-    constructor() {
-        this.verifyIdToken = (token) => admin.auth().verifyIdToken(token);
-        this.getAuth = auth_1.getAuth;
-    }
-}
-exports.Firebase = new FirebaseClass();

package/dist/FirebaseConnector.d.ts

@@ -1,33 +0,0 @@
-import * as admin from 'firebase-admin';
-import { AnyObject, FluentQuery, LoadedResult, QueryOutput } from '@goatlab/fluent';
-import { BaseConnector, FluentConnectorInterface } from '@goatlab/fluent';
-import { z } from 'zod';
-export interface FirebaseConnectorParams<Input, Output> {
-    entity: any;
-    inputSchema: z.ZodType<Input>;
-    outputSchema?: z.ZodType<Output>;
-}
-export declare class FirebaseConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
-    private readonly inputSchema;
-    private readonly outputSchema;
-    private collection;
-    private readonly entity;
-    constructor({ entity, inputSchema, outputSchema }: FirebaseConnectorParams<InputDTO, OutputDTO>);
-    initDB(): number;
-    insert(data: InputDTO): Promise<OutputDTO>;
-    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
-    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
-    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
-    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    deleteById(id: string): Promise<string>;
-    clear(): Promise<boolean>;
-    loadFirst(query?: FluentQuery<ModelDTO>): LoadedResult<this>;
-    loadById(id: string): LoadedResult<this>;
-    raw(): admin.firestore.CollectionReference<ModelDTO>;
-    rawFirebase(): admin.firestore.Firestore;
-    private deleteQueryBatch;
-    protected clone(): any;
-    protected loadRelatedData(data: any[], loadedKeys: AnyObject): Promise<admin.firestore.DocumentData[]>;
-    private getGeneratedQueries;
-    private getFirebaseWhereQuery;
-}

package/dist/FirebaseConnector.js

@@ -1,434 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirebaseConnector = void 0;
-const tslib_1 = require("tslib");
-const admin = tslib_1.__importStar(require("firebase-admin"));
-const fluent_1 = require("@goatlab/fluent");
-const fluent_2 = require("@goatlab/fluent");
-const js_utils_1 = require("@goatlab/js-utils");
-class FirebaseConnector extends fluent_2.BaseConnector {
-    constructor({ entity, inputSchema, outputSchema }) {
-        super();
-        this.inputSchema = inputSchema;
-        this.outputSchema =
-            outputSchema || inputSchema;
-        this.entity = entity;
-    }
-    initDB() {
-        const relationShipBuilder = fluent_1.modelGeneratorDataSource.getRepository(this.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) || [];
-        return 1;
-    }
-    async insert(data) {
-        this.initDB();
-        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.`);
-            }
-        }
-        const id = data['id'] || js_utils_1.Ids.objectIdString();
-        const item = {
-            id,
-            ...validatedData
-        };
-        await this.collection.doc(id).set(item);
-        return this.outputSchema.parse(js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(item)));
-    }
-    async insertMany(data) {
-        this.initDB();
-        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 js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        }));
-    }
-    async findMany(query) {
-        this.initDB();
-        const [andQuery, orQueries] = this.getGeneratedQueries(query);
-        const results = [];
-        if (andQuery) {
-            const snapshot = await andQuery.get();
-            snapshot.forEach(doc => {
-                results.push(doc.data());
-            });
-        }
-        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 => {
-            js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        });
-        if (query?.include) {
-            found = await this.loadRelatedData(found, js_utils_1.Objects.flatten(query?.include || {}));
-        }
-        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;
-        }
-        if (query?.select) {
-            return found;
-        }
-        return this.outputSchema?.array().parse(found);
-    }
-    async updateById(id, data) {
-        this.initDB();
-        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
-        });
-        const dbResult = await this.findById(id);
-        if (!dbResult) {
-            throw new Error(`Object not found: ${id}`);
-        }
-        return this.outputSchema?.parse(js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
-    }
-    async replaceById(id, data) {
-        this.initDB();
-        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.requireById(id);
-        return this.outputSchema.parse(js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
-    }
-    async deleteById(id) {
-        this.initDB();
-        await this.collection.doc(id).delete();
-        return id;
-    }
-    async clear() {
-        this.initDB();
-        const query = this.collection.orderBy('__name__').limit(300);
-        return new Promise((resolve, reject) => {
-            this.deleteQueryBatch(admin.firestore(), query, 300, resolve, reject);
-        });
-    }
-    loadFirst(query) {
-        this.initDB();
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                ...query,
-                limit: 1
-            }
-        });
-        return newInstance;
-    }
-    loadById(id) {
-        this.initDB();
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                where: {
-                    id
-                }
-            }
-        });
-        return newInstance;
-    }
-    raw() {
-        this.initDB();
-        return this.collection;
-    }
-    rawFirebase() {
-        this.initDB();
-        return admin.firestore();
-    }
-    deleteQueryBatch(db, query, batchSize, resolve, reject) {
-        this.initDB();
-        query
-            .get()
-            .then(snapshot => {
-            if (snapshot.size == 0) {
-                return 0;
-            }
-            const batch = db.batch();
-            snapshot.docs.forEach(doc => {
-                batch.delete(doc.ref);
-            });
-            return batch.commit().then(() => snapshot.size);
-        })
-            .then(numDeleted => {
-            if (numDeleted === 0) {
-                resolve();
-                return;
-            }
-            process.nextTick(() => {
-                this.deleteQueryBatch(db, query, batchSize, resolve, reject);
-            });
-        })
-            .catch(reject);
-    }
-    clone() {
-        this.initDB();
-        return new this.constructor();
-    }
-    async loadRelatedData(data, loadedKeys) {
-        const result = await (0, fluent_2.loadRelations)({
-            data,
-            relations: loadedKeys,
-            modelRelations: this.modelRelations,
-            provider: 'firebase',
-            self: this,
-            returnPivot: false
-        });
-        return result;
-    }
-    getGeneratedQueries(query) {
-        let { andWhere, orWhere } = this.getFirebaseWhereQuery(query?.where);
-        let mergedQueries = [];
-        if (andWhere) {
-            mergedQueries = [andWhere, ...orWhere];
-        }
-        else {
-            mergedQueries = orWhere;
-        }
-        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]);
-            }
-            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]);
-                    }
-                }
-            }
-        }
-        const cloned = [...mergedQueries];
-        if (andWhere) {
-            cloned.shift();
-        }
-        return [andWhere ? mergedQueries[0] : undefined, cloned];
-    }
-    getFirebaseWhereQuery(where) {
-        if (!where || Object.keys(where).length === 0) {
-            return { andWhere: this.collection, orWhere: [] };
-        }
-        let andWhereQuery = this.collection;
-        let orWhereQueries = [];
-        const orConditions = (0, fluent_1.extractConditions)(where['OR']);
-        const andConditions = (0, fluent_1.extractConditions)(where['AND']);
-        const copy = js_utils_1.Objects.clone(where);
-        if (!!copy['AND']) {
-            delete copy['AND'];
-        }
-        if (!!copy['OR']) {
-            delete copy['OR'];
-        }
-        const rootLevelConditions = (0, fluent_1.extractConditions)([copy]);
-        for (const condition of andConditions) {
-            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 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 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 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');
-            }
-            orWhereQueries.push(orQuery);
-        }
-        let andWhereCondition = undefined;
-        if (!andConditions?.length &&
-            !rootLevelConditions?.length &&
-            !orConditions?.length) {
-            andWhereCondition = this.collection;
-        }
-        if (andConditions?.length || rootLevelConditions?.length) {
-            andWhereCondition = andWhereQuery;
-        }
-        return {
-            andWhere: andWhereCondition,
-            orWhere: orWhereQueries
-        };
-    }
-}
-tslib_1.__decorate([
-    js_utils_1.Memo.syncMethod(),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", void 0)
-], FirebaseConnector.prototype, "initDB", null);
-exports.FirebaseConnector = FirebaseConnector;

package/dist/FirebaseInit.d.ts

@@ -1,8 +0,0 @@
-interface ConnectionOptions {
-    host?: string;
-    port?: number;
-    databaseName?: string;
-    serviceAccount?: string;
-}
-export declare const FirebaseInit: ({ host, port, databaseName, serviceAccount }: ConnectionOptions) => void;
-export {};

package/dist/FirebaseInit.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirebaseInit = void 0;
-const tslib_1 = require("tslib");
-const admin = tslib_1.__importStar(require("firebase-admin"));
-const FirebaseInit = ({ host, port, databaseName, serviceAccount }) => {
-    if (admin.apps.length) {
-        return;
-    }
-    if (host && port) {
-        process.env.FIRESTORE_EMULATOR_HOST = `${host}:${port}`;
-    }
-    admin.initializeApp({
-        projectId: databaseName,
-        credential: serviceAccount
-            ? admin.credential.cert(serviceAccount)
-            : admin.credential.applicationDefault()
-    });
-    const fireStore = admin.firestore();
-    fireStore.settings({ ignoreUndefinedProperties: true });
-    if (!fireStore) {
-        throw new Error('Could not initialize FireStore');
-    }
-};
-exports.FirebaseInit = FirebaseInit;

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-import { Firebase } from './Firebase';
-import { FirebaseConnector } from './FirebaseConnector';
-import { FirebaseInit } from './FirebaseInit';
-export { FirebaseConnector, FirebaseInit, Firebase };

package/dist/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Firebase = exports.FirebaseInit = exports.FirebaseConnector = void 0;
-const Firebase_1 = require("./Firebase");
-Object.defineProperty(exports, "Firebase", { enumerable: true, get: function () { return Firebase_1.Firebase; } });
-const FirebaseConnector_1 = require("./FirebaseConnector");
-Object.defineProperty(exports, "FirebaseConnector", { enumerable: true, get: function () { return FirebaseConnector_1.FirebaseConnector; } });
-const FirebaseInit_1 = require("./FirebaseInit");
-Object.defineProperty(exports, "FirebaseInit", { enumerable: true, get: function () { return FirebaseInit_1.FirebaseInit; } });