firestore-meilisearch 0.1.0

package/functions/__tests__/util.test.ts

@@ -0,0 +1,200 @@
+import * as firebaseFunctionsTestInit from 'firebase-functions-test'
+import mockedEnv from 'mocked-env'
+import { getChangeType, ChangeType, getChangedDocumentId } from '../src/util'
+import defaultEnvironment from './data/environment'
+
+describe('getChangeType', () => {
+  const firebaseMock = firebaseFunctionsTestInit()
+
+  test('return a create change type', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      {},
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/1'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const changeType: ChangeType = getChangeType(documentChange)
+
+    expect(changeType).toEqual(ChangeType.CREATE)
+  })
+
+  test('return a update change type', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bars' },
+      'docs/1'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const changeType: ChangeType = getChangeType(documentChange)
+
+    expect(changeType).toEqual(ChangeType.UPDATE)
+  })
+
+  test('return a delete change type', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      {},
+      'docs/1'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const changeType: ChangeType = getChangeType(documentChange)
+
+    expect(changeType).toEqual(ChangeType.DELETE)
+  })
+})
+
+describe('getChangedDocumentId', () => {
+  const firebaseMock = firebaseFunctionsTestInit()
+
+  test('return id after create document', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      {},
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/2'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const id: string = getChangedDocumentId(documentChange)
+
+    expect(id).toEqual('2')
+  })
+
+  test('return id after update document', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bars' },
+      'docs/2'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const id: string = getChangedDocumentId(documentChange)
+
+    expect(id).toEqual('2')
+  })
+
+  test('return id after delete document', () => {
+    const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      { foo: 'bar' },
+      'docs/1'
+    )
+    const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+      {},
+      'docs/2'
+    )
+
+    const documentChange = firebaseMock.makeChange(
+      beforeSnapshot,
+      afterSnapshot
+    )
+
+    const id: string = getChangedDocumentId(documentChange)
+
+    expect(id).toEqual('1')
+  })
+})
+
+describe('getFieldsToIndex', () => {
+  let util
+  let restoreEnv
+  let mockGetFieldsToIndex
+  const config = global.config
+
+  beforeEach(() => {
+    jest.resetModules()
+    restoreEnv = mockedEnv(defaultEnvironment)
+  })
+  afterEach(() => restoreEnv())
+
+  test('configuration detected from environment variables', () => {
+    const mockConfig = config()
+    expect(mockConfig).toMatchSnapshot()
+  })
+
+  test('return empty list', () => {
+    util = require('../src/util')
+    mockGetFieldsToIndex = util.getFieldsToIndex()
+    expect(mockGetFieldsToIndex).toMatchObject([])
+  })
+
+  test('return list with one field', () => {
+    restoreEnv = mockedEnv({
+      ...defaultEnvironment,
+      MEILISEARCH_FIELDS_TO_INDEX: 'field',
+    })
+    util = require('../src/util')
+    mockGetFieldsToIndex = util.getFieldsToIndex()
+    expect(mockGetFieldsToIndex).toMatchObject(['field'])
+  })
+
+  test('return list with multiple fields', () => {
+    restoreEnv = mockedEnv({
+      ...defaultEnvironment,
+      MEILISEARCH_FIELDS_TO_INDEX: 'field1,field2,field3',
+    })
+    util = require('../src/util')
+    mockGetFieldsToIndex = util.getFieldsToIndex()
+    expect(mockGetFieldsToIndex).toMatchObject(['field1', 'field2', 'field3'])
+  })
+
+  test('return list with multiple fields and spaces', () => {
+    restoreEnv = mockedEnv({
+      ...defaultEnvironment,
+      MEILISEARCH_FIELDS_TO_INDEX: 'field1, field2,  field3',
+    })
+    util = require('../src/util')
+    mockGetFieldsToIndex = util.getFieldsToIndex()
+    expect(mockGetFieldsToIndex).toMatchObject(['field1', 'field2', 'field3'])
+  })
+
+  test('return list of fiels with underscore', () => {
+    restoreEnv = mockedEnv({
+      ...defaultEnvironment,
+      MEILISEARCH_FIELDS_TO_INDEX: 'field_1,field_2,field_3',
+    })
+    util = require('../src/util')
+    mockGetFieldsToIndex = util.getFieldsToIndex()
+    expect(mockGetFieldsToIndex).toMatchObject([
+      'field_1',
+      'field_2',
+      'field_3',
+    ])
+  })
+})

package/functions/jest.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  rootDir: './',
+  preset: 'ts-jest',
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/__tests__/tsconfig.json',
+    },
+  },
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/*.test.ts'],
+  setupFiles: ['<rootDir>/__tests__/jest.setup.ts'],
+}

package/functions/lib/adapter.js

@@ -0,0 +1,61 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptValues = exports.adaptDocument = void 0;
+const firestore_1 = require("firebase-admin/lib/firestore");
+const util_1 = require("./util");
+const logs = require("./logs");
+/**
+ * Adapts documents from the Firestore database to Meilisearch compatible documents.
+ * @param {string} documentId Document id.
+ * @param {DocumentSnapshot} snapshot Snapshot of the data contained in the document read from your Firestore database.
+ * @return {Record<string, any>} A properly formatted document to be added or updated in Meilisearch.
+ */
+function adaptDocument(documentId, snapshot) {
+    const fields = (0, util_1.getFieldsToIndex)();
+    const data = snapshot.data() || {};
+    if ('_firestore_id' in data) {
+        delete data.id;
+    }
+    if (fields.length === 0) {
+        return { _firestore_id: documentId, ...data };
+    }
+    const document = Object.keys(data).reduce((acc, key) => {
+        if (fields.includes(key)) {
+            const [field, value] = adaptValues(key, data[key]);
+            return { ...acc, [field]: value };
+        }
+        return acc;
+    }, { _firestore_id: documentId });
+    return document;
+}
+exports.adaptDocument = adaptDocument;
+/**
+ * Checks and adapts each values to be compatible with Meilisearch documents.
+ * @param {string} field
+ * @param {FirestoreRow} value
+ * @return {[string,FirestoreRow]} A properly formatted array of field and value.
+ */
+function adaptValues(field, value) {
+    if (value instanceof firestore_1.GeoPoint) {
+        if (field === '_geo') {
+            logs.infoGeoPoint(true);
+            return [field, adaptGeoPoint(value)];
+        }
+        else {
+            logs.infoGeoPoint(false);
+        }
+    }
+    return [field, value];
+}
+exports.adaptValues = adaptValues;
+/**
+ * Adapts GeoPoint Firestore instance to fit with Meilisearch geo point.
+ * @param {GeoPoint} geoPoint GeoPoint Firestore object.
+ * @return {MeilisearchGeoPoint} A properly formatted geo point for Meilisearch.
+ */
+const adaptGeoPoint = (geoPoint) => {
+    return {
+        lat: geoPoint.latitude,
+        lng: geoPoint.longitude,
+    };
+};

package/functions/lib/config.js

@@ -0,0 +1,13 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.config = {
+    location: process.env.LOCATION || 'europe-west1',
+    collectionPath: process.env.COLLECTION_PATH || '',
+    meilisearch: {
+        host: process.env.MEILISEARCH_HOST || '',
+        apiKey: process.env.MEILISEARCH_API_KEY || '',
+        indexUid: process.env.MEILISEARCH_INDEX_NAME || '',
+        fieldsToIndex: process.env.MEILISEARCH_FIELDS_TO_INDEX || '',
+    },
+};

package/functions/lib/import/config.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfig = void 0;
+const commander_1 = require("commander");
+const inquirer = require("inquirer");
+const FIRESTORE_VALID_CHARACTERS = /^[^/]+$/;
+const FIRESTORE_COLLECTION_NAME_MAX_CHARS = 6144;
+const PROJECT_ID_MAX_CHARS = 30;
+const MEILISEARCH_VALID_CHARACTERS = /^[a-zA-Z-_0-9,]*$/;
+const MEILISEARCH_UID_MAX_CHARS = 6144;
+// Create a new interface to manage the arguments from the non-interactive command line.
+const program = new commander_1.Command();
+program
+    .name('firestore-meilisearch')
+    .option('--non-interactive', 'Parse all input from command line flags instead of prompting the caller.', false)
+    .option('-P, --project <project>', 'Firebase Project ID for project containing the Cloud Firestore database.')
+    .option('-s, --source-collection-path <source-collection-path>', 'The path of the Cloud Firestore Collection to import from. (This may, or may not, be the same Collection for which you plan to mirror changes.)')
+    .option('-q, --query-collection-group [true|false]', "Use 'true' for a collection group query, otherwise a collection query is performed.")
+    .option('-i, --index <index>', "The Uid of the index in Meilisearch to import to. (An index will be created if it doesn't already exist.)")
+    .option('-b, --batch-size [batch-size]', 'Number of documents to stream into Meilisearch at once.', value => parseInt(value, 10), 1000)
+    .option('-H, --host <host>', 'The Host of your Meilisearch database. Example: http://localhost:7700.')
+    .option('-a, --api-key <api-key>', 'The Meilisearch API key with permission to perform actions on indexes. Both the private key and the master key are valid choices but we strongly recommend using the private key for security purposes.');
+const validateInput = (value, name, regex, sizeLimit) => {
+    if (!value || typeof value !== 'string' || value.trim() === '') {
+        return `Please supply a ${name}`;
+    }
+    if (value.trim().length > sizeLimit) {
+        return `${name} must be at most ${sizeLimit} characters long`;
+    }
+    if (!value.match(regex)) {
+        return `The ${name} does not match the regular expression provided`;
+    }
+    return true;
+};
+const validateBatchSize = (value) => {
+    if (/^\d+$/.test(value) == false) {
+        return `The batchsize ${value} should be a number`;
+    }
+    return parseInt(value, 10) > 0;
+};
+// Questions for the interactive user interface in command line.
+const questions = [
+    {
+        message: 'What is your Firebase project ID?',
+        name: 'project',
+        type: 'input',
+        validate: value => validateInput(value, 'project ID', FIRESTORE_VALID_CHARACTERS, PROJECT_ID_MAX_CHARS),
+    },
+    {
+        message: 'What is the path of the Cloud Firestore Collection you would like to import from? ' +
+            '(This may, or may not, be the same Collection for which you plan to mirror changes.)',
+        name: 'sourceCollectionPath',
+        type: 'input',
+        validate: value => validateInput(value, 'collection path', FIRESTORE_VALID_CHARACTERS, FIRESTORE_COLLECTION_NAME_MAX_CHARS),
+    },
+    {
+        message: 'Would you like to import documents via a Collection Group query?',
+        name: 'queryCollectionGroup',
+        type: 'confirm',
+        default: false,
+    },
+    {
+        message: "What is the Uid of the Meilisearch index that you would like to use? (A index will be created if it doesn't already exist)",
+        name: 'index',
+        type: 'input',
+        validate: value => validateInput(value, 'index', MEILISEARCH_VALID_CHARACTERS, MEILISEARCH_UID_MAX_CHARS),
+    },
+    {
+        message: 'How many documents should the import stream into Meilisearch at once?',
+        name: 'batchSize',
+        type: 'input',
+        default: 1000,
+        validate: validateBatchSize,
+    },
+    {
+        message: 'What is the host of the Meilisearch database that you would like to use? Example: http://localhost:7700.',
+        name: 'host',
+        type: 'input',
+    },
+    {
+        message: 'Which Meilisearch API key with permission to perform actions on indexes do you like to use? Both the private key and the master key are valid choices but we strongly recommend using the private key for security purposes.',
+        name: 'apiKey',
+        type: 'input',
+    },
+];
+/**
+ * Parse the argument from the interactive or non-interactive command line.
+ */
+async function parseConfig() {
+    program.parse(process.argv);
+    const options = program.opts();
+    if (options.nonInteractive) {
+        if (options.project === undefined ||
+            options.sourceCollectionPath === undefined ||
+            options.index === undefined ||
+            options.host === undefined ||
+            options.apiKey === undefined ||
+            !validateBatchSize(options.batchSize)) {
+            program.outputHelp();
+            process.exit(1);
+        }
+        return {
+            projectId: options.project,
+            sourceCollectionPath: options.sourceCollectionPath,
+            queryCollectionGroup: options.queryCollectionGroup === 'true',
+            batchSize: options.batchSize,
+            meilisearch: {
+                indexUid: options.index,
+                host: options.host,
+                apiKey: options.apiKey,
+            },
+        };
+    }
+    const { project, sourceCollectionPath, queryCollectionGroup, index, batchSize, host, apiKey, } = await inquirer.prompt(questions);
+    return {
+        projectId: project,
+        sourceCollectionPath: sourceCollectionPath,
+        queryCollectionGroup: queryCollectionGroup,
+        batchSize: batchSize,
+        meilisearch: {
+            indexUid: index,
+            host: host,
+            apiKey: apiKey,
+        },
+    };
+}
+exports.parseConfig = parseConfig;

package/functions/lib/import/index.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * Copyright 2022 Meilisearch
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const admin = require("firebase-admin");
+const config_1 = require("./config");
+const logs = require("../logs");
+const adapter_1 = require("../adapter");
+const create_index_1 = require("../meilisearch/create-index");
+const run = async () => {
+    // Retrieve all arguments from the commande line.
+    const config = await (0, config_1.parseConfig)();
+    // Initialize Firebase using the Google Credentials in the GOOGLE_APPLICATION_CREDENTIALS environment variable.
+    admin.initializeApp({
+        credential: admin.credential.applicationDefault(),
+        databaseURL: `https://${config.projectId}.firebaseio.com`,
+    });
+    const database = admin.firestore();
+    // Initialize Meilisearch index.
+    const index = (0, create_index_1.initMeilisearchIndex)(config.meilisearch);
+    await retrieveCollectionFromFirestore(database, config, index);
+};
+/**
+ * Retrieves a collection or collection group in Firestore and aggregates the data.
+ * @param {FirebaseFirestore.Firestore} database
+ * @param {CLIConfig} config
+ * @param {Index} index
+ */
+async function retrieveCollectionFromFirestore(database, config, index) {
+    const batch = parseInt(config.batchSize);
+    let query;
+    let total = 0;
+    let batches = 0;
+    let lastDocument = null;
+    let lastBatchSize = batch;
+    while (lastBatchSize === batch) {
+        batches++;
+        if (config.queryCollectionGroup) {
+            query = database.collectionGroup(config.sourceCollectionPath).limit(batch);
+        }
+        else {
+            query = database.collection(config.sourceCollectionPath).limit(batch);
+        }
+        if (lastDocument !== null) {
+            query = query.startAfter(lastDocument);
+        }
+        const snapshot = await query.get();
+        const docs = snapshot.docs;
+        if (docs.length === 0)
+            break;
+        total += await sendDocumentsToMeilisearch(docs, index);
+        if (docs.length) {
+            lastDocument = docs[docs.length - 1];
+        }
+        lastBatchSize = docs.length;
+    }
+    logs.importData(total, batches);
+    return total;
+}
+/**
+ * Adapts documents and indexes them in Meilisearch.
+ * @param {any} docs
+ * @param {Index} index
+ * @param {Change<DocumentSnapshot>} change
+ */
+async function sendDocumentsToMeilisearch(docs, index) {
+    const document = docs.map(snapshot => {
+        return (0, adapter_1.adaptDocument)(snapshot.id, snapshot);
+    });
+    try {
+        await index.addDocuments(document, { primaryKey: '_firestore_id' });
+    }
+    catch (e) {
+        logs.error(e);
+        return 0;
+    }
+    return document.length;
+}
+void run();

package/functions/lib/index.js

@@ -0,0 +1,90 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexingWorker = void 0;
+/*
+ * Copyright 2022 Meilisearch
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const functions = require("firebase-functions");
+const create_index_1 = require("./meilisearch/create-index");
+const util_1 = require("./util");
+const logs = require("./logs");
+const adapter_1 = require("./adapter");
+const config_1 = require("./config");
+const index = (0, create_index_1.initMeilisearchIndex)(config_1.config.meilisearch);
+logs.init();
+/**
+ * IndexingWorker is responsible for aggregating a defined field from a Firestore collection into a Meilisearch index.
+ * It is controlled by a Firestore handler.
+ */
+exports.indexingWorker = functions.handler.firestore.document.onWrite(async (change) => {
+    logs.start();
+    const changeType = (0, util_1.getChangeType)(change);
+    const documentId = (0, util_1.getChangedDocumentId)(change);
+    switch (changeType) {
+        case util_1.ChangeType.CREATE:
+            await handleAddDocument(documentId, change.after);
+            break;
+        case util_1.ChangeType.DELETE:
+            await handleDeleteDocument(documentId);
+            break;
+        case util_1.ChangeType.UPDATE:
+            await handleUpdateDocument(documentId, change.after);
+            break;
+    }
+    logs.complete();
+});
+/**
+ * Handle addition of a document in the Meilisearch index.
+ * @param {string} documentId Document id to add.
+ * @param {Change} snapshot Snapshot of the data contained in the document read from your Firestore database.
+ */
+async function handleAddDocument(documentId, snapshot) {
+    try {
+        const document = (0, adapter_1.adaptDocument)(documentId, snapshot);
+        await index.addDocuments([document], { primaryKey: '_firestore_id' });
+        logs.addDocument(documentId, document);
+    }
+    catch (e) {
+        logs.error(e);
+    }
+}
+/**
+ * Handle deletion of a document in the Meilisearch index.
+ * @param {string} documentId Document id to delete.
+ */
+async function handleDeleteDocument(documentId) {
+    try {
+        await index.deleteDocument(documentId);
+        logs.deleteDocument(documentId);
+    }
+    catch (e) {
+        logs.error(e);
+    }
+}
+/**
+ * Handle update of a document in the Meilisearch index.
+ * @param {string} documentId Document id to update.
+ * @param {Change} after Snapshot of the data contained in the document read from your Firestore database.
+ */
+async function handleUpdateDocument(documentId, after) {
+    try {
+        const document = (0, adapter_1.adaptDocument)(documentId, after);
+        await index.updateDocuments([document]);
+        logs.updateDocument(documentId, document);
+    }
+    catch (e) {
+        logs.error(e);
+    }
+}

package/functions/lib/logs.js

@@ -0,0 +1,97 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importData = exports.infoGeoPoint = exports.deleteDocument = exports.updateDocument = exports.addDocument = exports.complete = exports.error = exports.start = exports.init = void 0;
+/*
+ * Copyright 2022 Meilisearch
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const firebase_functions_1 = require("firebase-functions");
+const config_1 = require("./config");
+/**
+ * Initialization logger.
+ */
+function init() {
+    firebase_functions_1.logger.log('Initializing extension with configuration', config_1.config);
+}
+exports.init = init;
+/**
+ * Start logger.
+ */
+function start() {
+    firebase_functions_1.logger.log('Started execution of extension with configuration', config_1.config);
+}
+exports.start = start;
+/**
+ * Error logger.
+ * @param {Error} err
+ */
+function error(err) {
+    firebase_functions_1.logger.error('Unhandled error occurred during processing:', err);
+}
+exports.error = error;
+/**
+ * Complete logger.
+ */
+function complete() {
+    firebase_functions_1.logger.log('Completed execution of extension');
+}
+exports.complete = complete;
+/**
+ * Log an addition of a document.
+ * @param {string} id Document id added.
+ * @param {object} data Data contained in the document.
+ */
+function addDocument(id, data) {
+    firebase_functions_1.logger.info(`Creating new document ${id} in Meilisearch index ${config_1.config.meilisearch.indexUid}`, data);
+}
+exports.addDocument = addDocument;
+/**
+ * Log an update of a document.
+ * @param {string} id Document id updated.
+ * @param {object} data Data contained in the document.
+ */
+function updateDocument(id, data) {
+    firebase_functions_1.logger.info(`Updating document ${id} in Meilisearch index ${config_1.config.meilisearch.indexUid}`, data);
+}
+exports.updateDocument = updateDocument;
+/**
+ * Log a deletion of a document.
+ * @param {string} id Document id deleted.
+ */
+function deleteDocument(id) {
+    firebase_functions_1.logger.info(`Deleting document ${id} in Meilisearch index ${config_1.config.meilisearch.indexUid}`);
+}
+exports.deleteDocument = deleteDocument;
+/**
+ * Log a modification of geoPoint based on whether or not it has the correct naming to enable `geosearch` in Meilisearch.
+ * @param {boolean} hasGeoField a boolean value that indicates whether the field is correctly named to enable `geosearch` in Meilisearch.
+ */
+function infoGeoPoint(hasGeoField) {
+    if (hasGeoField) {
+        firebase_functions_1.logger.info(`A GeoPoint was found with the field name '_geo' for compatibility with Meilisearch the field 'latitude' was renamed to 'lat' and the field 'longitude' to 'lng'`);
+    }
+    else {
+        firebase_functions_1.logger.info(`A GeoPoint was found without the field name '_geo' if you want to use the geoSearch with Meilisearch rename it to '_geo'`);
+    }
+}
+exports.infoGeoPoint = infoGeoPoint;
+/**
+ * Importation data logger.
+ * @param {number} total
+ * @param {number} batches
+ */
+function importData(total, batches) {
+    firebase_functions_1.logger.info(`Imported ${total} documents in ${batches} batches.`);
+}
+exports.importData = importData;