Firestore implementation

packages/external-db-firestore/lib/connection_provider.js

@@ -1,6 +1,6 @@
 const SchemaProvider = require('./firestore_schema_provider')
 const DataProvider  = require('./firestore_data_provider')
-// const FilterParser = require('./sql_filter_transformer')
+const FilterParser = require('./sql_filter_transformer')
 const DatabaseOperations = require('./firestore_operations')
 const Firestore = require('@google-cloud/firestore');
 
@@ -11,8 +11,8 @@ const init = ([projectId]) => {
 
     const databaseOperations = new DatabaseOperations(firestore)
 
-    // const filterParser = new FilterParser()
-    const dataProvider = new DataProvider(firestore)
+    const filterParser = new FilterParser()
+    const dataProvider = new DataProvider(firestore,filterParser)
     const schemaProvider = new SchemaProvider(firestore)
 
     return { dataProvider, schemaProvider, databaseOperations, connection: firestore, cleanup: async () => await firestore.terminate() }

packages/external-db-firestore/lib/firestore_data_provider.js

@@ -1,4 +1,4 @@
-// const { recordSetToObj, escapeId, patchFieldName, unpatchFieldName } = require('./spanner_utils')
+const { Timestamp } = require('@google-cloud/firestore')
 const { SystemFields } = require('velo-external-db-commons')
 
 class DataProvider {
@@ -8,118 +8,87 @@ class DataProvider {
         this.database = database
     }
 
-    // async find(collectionName, filter, sort, skip, limit) {
-    //     const {filterExpr, parameters} = this.filterParser.transform(filter)
-    //     const { sortExpr } = this.filterParser.orderBy(sort)
-    //
-    //     const query = {
-    //         sql: `SELECT * FROM ${escapeId(collectionName)} ${filterExpr} ${sortExpr} LIMIT @limit OFFSET @skip`,
-    //         params: {
-    //             skip: skip,
-    //             limit: limit,
-    //         },
-    //     }
-    //     Object.assign(query.params, parameters)
-    //
-    //     const [rows] = await this.database.run(query);
-    //     return recordSetToObj(rows).map( this.asEntity.bind(this) )
-    // }
-    //
-    // async count(collectionName, filter) {
-    //     const {filterExpr, parameters} = this.filterParser.transform(filter)
-    //     const query = {
-    //         sql: `SELECT COUNT(*) AS num FROM ${escapeId(collectionName)} ${filterExpr}`.trim(),
-    //         params: { },
-    //     };
-    //     Object.assign(query.params, parameters)
-    //
-    //     const [rows] = await this.database.run(query)
-    //     const objs = recordSetToObj(rows).map( this.asEntity.bind(this) )
-    //
-    //     return objs[0].num;
-    // }
-    //
-    // async insert(collectionName, items) {
-    //     await this.database.table(collectionName)
-    //                        .insert(items.map(this.asDBEntity.bind(this)))
-    //     return items.length
-    // }
-    //
-    // asDBEntity(item) {
-    //     return Object.keys(item)
-    //                  .reduce((obj, key) => {
-    //                      return { ...obj, [patchFieldName(key)]: item[key] }
-    //                  }, {})
-    // }
-    //
-    // fixDates(value) {
-    //     if (value instanceof Date) {
-    //         // todo: fix this hack !!!
-    //         const date = value.toISOString()
-    //         const date2 = `${date.substring(0, date.lastIndexOf('.') + 4)}${date.slice(-1)}`
-    //         return new Date(date2)
-    //     }
-    //     return value
-    //
-    // }
-    //
-    // asEntity(dbEntity) {
-    //     return Object.keys(dbEntity)
-    //                  .reduce(function (obj, key) {
-    //                      return { ...obj, [unpatchFieldName(key)]: this.fixDates(dbEntity[key]) }
-    //                  }.bind(this), {})
-    // }
-    //
-    // async update(collectionName, items) {
-    //     const item = items[0]
-    //     const systemFieldNames = SystemFields.map(f => f.name)
-    //     const updateFields = Object.keys(item).filter( k => !systemFieldNames.includes(k) )
-    //
-    //     if (updateFields.length === 0) {
-    //         return 0
-    //     }
-    //
-    //     await this.database.table(collectionName)
-    //                        .update(items.map( this.asDBEntity.bind(this) ))
-    //     return items.length
-    // }
-    //
-    // async delete(collectionName, itemIds) {
-    //     await this.database.table(collectionName)
-    //                        .deleteRows(itemIds)
-    //     return itemIds.length
-    // }
-    //
-    // async truncate(collectionName) {
-    //     // todo: properly implement this
-    //     const query = {
-    //         sql: `SELECT * FROM ${escapeId(collectionName)} LIMIT @limit OFFSET @skip`,
-    //         params: {
-    //             skip: 0,
-    //             limit: 1000,
-    //         },
-    //     }
-    //
-    //     const [rows] = await this.database.run(query);
-    //     const itemIds = recordSetToObj(rows).map( this.asEntity.bind(this) ).map(e => e._id)
-    //
-    //     await this.delete(collectionName, itemIds)
-    // }
-    //
-    // async aggregate(collectionName, filter, aggregation) {
-    //     const {filterExpr: whereFilterExpr, parameters: whereParameters} = this.filterParser.transform(filter)
-    //     const {fieldsStatement, groupByColumns, havingFilter, parameters} = this.filterParser.parseAggregation(aggregation.processingStep, aggregation.postFilteringStep)
-    //
-    //     const query = {
-    //         sql: `SELECT ${fieldsStatement} FROM ${escapeId(collectionName)} ${whereFilterExpr} GROUP BY ${groupByColumns.map( escapeId ).join(', ')} ${havingFilter}`,
-    //         params: { },
-    //     }
-    //
-    //     Object.assign(query.params, whereParameters, parameters)
-    //
-    //     const [rows] = await this.database.run(query)
-    //     return recordSetToObj(rows).map( this.asEntity.bind(this) )
-    // }
+    async find(collectionName, filter, sort, skip, limit) {
+        const filterOperations = this.filterParser.transform(filter)
+        const sortOperations = this.filterParser.orderBy(sort)
+
+        let collectionRef = this.database.collection(collectionName)
+
+        filterOperations.forEach(filterOp => collectionRef.where(filterOp.fieldName,filterOp.opStr,filterOp.value))
+
+        sortOperations.forEach(sortOp => collectionRef = collectionRef.orderBy(sortOp.fieldName,sortOp.direction))
+
+
+        const docs = (await collectionRef.limit(limit).get()).docs
+
+        return docs.map(doc => this.asEntity(doc))
+    }
+
+    async count(collectionName, filter) {
+        const filterOperations = this.filterParser.transform(filter)
+        const collectionRef = this.database.collection(collectionName)
+
+        filterOperations.forEach( filterOp => collectionRef.where(filterOp.fieldName,filterOp.opStr,filterOp.value))
+
+        return (await collectionRef.get()).size
+    }
+
+    async insert(collectionName, items) {
+        const batch = this.database.batch()
+
+        items.forEach( item => batch.set(this.database.doc(`${collectionName}/${item._id}`),item));
+
+        return (await batch.commit()).length
+    }
+
+    fixDates(value) {
+        if (value instanceof Timestamp) {
+            return value.toDate()
+        }
+        return value
+    }
+
+    asEntity(docEntity) {
+        const doc = docEntity.data()
+        return Object.keys(doc)
+        .reduce(function (obj, key) {
+            return { ...obj, [key]: this.fixDates(doc[key]) }
+        }.bind(this), {})
+    }
+
+    async update(collectionName, items) {
+        const item = items[0]
+        const batch = this.database.batch()
+        const systemFieldNames = SystemFields.map(f => f.name)
+        const updateFields = Object.keys(item).filter( k => !systemFieldNames.includes(k) )
+
+        if (updateFields.length === 0) {
+            return 0
+        }
+
+        items.forEach( item => 
+            batch.update(this.database.doc(`${collectionName}/${item._id}`),item));
+
+        return (await batch.commit()).length
+    }
+
+    async delete(collectionName, itemIds) {
+        const batch = this.database.batch()
+        itemIds.forEach( itemId => batch.delete(this.database.doc(`${collectionName}/${itemId}`)) )
+
+        return (await batch.commit()).length
+    }
+
+    async truncate(collectionName) {
+        const snapshot = await this.database.collection(collectionName).get()
+
+        if(snapshot.size === 0){
+            return 0
+        }
+
+        const itemIds =  snapshot.docs.map((doc) => (doc.data())._id );
+        return await this.delete(collectionName, itemIds)
+    }
 
 }
 

packages/external-db-firestore/lib/firestore_utils.js

@@ -17,12 +17,12 @@
 //     return f
 // }
 //
-// const testLiteral = s => /^[a-zA-Z_0-9_]+$/.test(s)
-// const validateLiteral = l => {
-//     if (!testLiteral(l)) {
-//         throw new InvalidQuery(`Invalid literal`)
-//     }
-//     return `@${l}`
-// }
+const testLiteral = s => /^[a-zA-Z_0-9_]+$/.test(s)
+const validateLiteral = l => {
+    if (!testLiteral(l)) {
+        throw new InvalidQuery(`Invalid literal`)
+    }
+    return `@${l}`
+}
 
-module.exports = { /*recordSetToObj, escapeId, patchFieldName, unpatchFieldName, testLiteral, validateLiteral*/ }
+module.exports = { /*recordSetToObj, escapeId, patchFieldName, unpatchFieldName,*/ testLiteral, validateLiteral }