firestore-meilisearch 0.1.0

package/functions/.eslintrc.js

@@ -0,0 +1,54 @@
+module.exports = {
+  root: true,
+  env: {
+    'jest/globals': true,
+    'browser': true,
+    'commonjs': true,
+    'es2021': true,
+    'es6': true,
+    'node': true,
+  },
+  extends: [
+    'eslint:recommended',
+    'plugin:import/errors',
+    'plugin:import/warnings',
+    'plugin:import/typescript',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:@typescript-eslint/recommended-requiring-type-checking',
+    'google',
+    'plugin:prettier/recommended',
+  ],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: ['tsconfig.eslint.json'],
+    sourceType: 'module',
+    tsconfigRootDir: __dirname,
+  },
+  ignorePatterns: [
+    '/lib/**/*', // Ignore built files.
+  ],
+  plugins: ['@typescript-eslint', 'import', 'jest'],
+  rules: {
+    '@typescript-eslint/no-unused-vars': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    'no-unused-vars': 'off',
+    'array-callback-return': 'off',
+    'arrow-parens': ['error', 'as-needed'],
+    'prettier/prettier': [
+      'error',
+      {
+        quoteProps: 'consistent',
+        semi: false,
+        arrowParens: 'avoid',
+        singleQuote: true,
+      },
+    ],
+  },
+}

package/functions/__tests__/__mocks__/console.ts

@@ -0,0 +1,7 @@
+import { logger } from 'firebase-functions'
+
+export const mockConsoleLog = jest.spyOn(logger, 'log').mockImplementation()
+
+export const mockConsoleInfo = jest.spyOn(logger, 'info').mockImplementation()
+
+export const mockConsoleError = jest.spyOn(logger, 'error').mockImplementation()

package/functions/__tests__/adapter.test.ts

@@ -0,0 +1,98 @@
+import * as firebaseFunctionsTestInit from 'firebase-functions-test'
+import { mocked } from 'ts-jest/utils'
+import { mockConsoleInfo } from './__mocks__/console'
+import { GeoPoint } from 'firebase-admin/lib/firestore'
+import { adaptDocument, adaptValues } from '../src/adapter'
+import { getFieldsToIndex } from '../src/util'
+import defaultDocument from './data/document'
+
+jest.mock('../src/util')
+
+// Mocking of Firebase functions
+const firebaseMock = firebaseFunctionsTestInit()
+
+describe('extensions process', () => {
+  describe('adaptDocument', () => {
+    const mockedGetFieldsToIndex = mocked(getFieldsToIndex, true)
+
+    test('adaptDocument with fields not set', () => {
+      mockedGetFieldsToIndex.mockReturnValueOnce([])
+      const snapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        defaultDocument.document,
+        `docs/${defaultDocument.id}`
+      )
+
+      expect(adaptDocument(defaultDocument.id, snapshot)).toStrictEqual({
+        _firestore_id: defaultDocument.id,
+        ...defaultDocument.document,
+      })
+    })
+
+    test('adaptDocument with fields not set and with id field in document', () => {
+      mockedGetFieldsToIndex.mockReturnValueOnce([])
+      const snapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { id: '12345', ...defaultDocument.document },
+        `docs/${defaultDocument.id}`
+      )
+
+      expect(adaptDocument(defaultDocument.id, snapshot)).toStrictEqual({
+        _firestore_id: defaultDocument.id,
+        id: '12345',
+        ...defaultDocument.document,
+      })
+    })
+
+    test('adaptDocument with fields set', () => {
+      mockedGetFieldsToIndex.mockReturnValueOnce([
+        'title',
+        'overview',
+        'release_date',
+      ])
+      const snapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        defaultDocument.document,
+        `docs/${defaultDocument.id}`
+      )
+
+      expect(adaptDocument(defaultDocument.id, snapshot)).toStrictEqual({
+        _firestore_id: defaultDocument.id,
+        title: defaultDocument.document.title,
+        overview: defaultDocument.document.overview,
+        release_date: defaultDocument.document.release_date,
+      })
+    })
+  })
+
+  describe('adaptValues', () => {
+    test('adaptValues an id value', () => {
+      expect(adaptValues('id', defaultDocument.id as any)).toStrictEqual([
+        'id',
+        defaultDocument.id,
+      ])
+    })
+    test('adaptValues a geo point value', () => {
+      const geoPoint = new GeoPoint(48.866667, 2.333333)
+
+      expect(adaptValues('_geo', geoPoint)).toStrictEqual([
+        '_geo',
+        {
+          lat: 48.866667,
+          lng: 2.333333,
+        },
+      ])
+      expect(mockConsoleInfo).toBeCalledWith(
+        `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'`
+      )
+    })
+    test('adaptValues a wrong geo point value', () => {
+      const geoPoint = new GeoPoint(48.866667, 2.333333)
+
+      expect(adaptValues('wrong_geo', geoPoint)).toStrictEqual([
+        'wrong_geo',
+        geoPoint,
+      ])
+      expect(mockConsoleInfo).toBeCalledWith(
+        `A GeoPoint was found without the field name '_geo' if you want to use the geoSearch with Meilisearch rename it to '_geo'`
+      )
+    })
+  })
+})

package/functions/__tests__/config.test.ts

@@ -0,0 +1,130 @@
+import { readFileSync } from 'fs'
+import { resolve as pathResolve } from 'path'
+import * as yaml from 'js-yaml'
+import mockedEnv from 'mocked-env'
+import defaultEnvironment from './data/environment'
+
+const EXTENSION_YAML = yaml.load(
+  readFileSync(pathResolve(__dirname, '../../extension.yaml'), 'utf8')
+)
+
+const extensionParams = EXTENSION_YAML.params.reduce((obj, parameter) => {
+  obj[parameter.param] = parameter
+  return obj
+}, {})
+
+describe('extensions config', () => {
+  let config
+  let restoreEnv
+
+  beforeEach(() => {
+    jest.resetModules()
+    restoreEnv = mockedEnv(defaultEnvironment)
+    config = require('../src/config').config
+  })
+  afterEach(() => restoreEnv())
+
+  test('config loaded from environment variables', () => {
+    const testConfig = {
+      location: defaultEnvironment.LOCATION,
+      collectionPath: defaultEnvironment.COLLECTION_PATH,
+      meilisearch: {
+        host: defaultEnvironment.MEILISEARCH_HOST,
+        apiKey: defaultEnvironment.MEILISEARCH_API_KEY,
+        indexUid: defaultEnvironment.MEILISEARCH_INDEX_NAME,
+        fieldsToIndex: defaultEnvironment.MEILISEARCH_FIELDS_TO_INDEX,
+      },
+    }
+
+    expect(config).toStrictEqual(testConfig)
+  })
+
+  // MEILISEARCH_FIELDS_TO_INDEX
+  describe('Test fieldsToIndex parameter', () => {
+    test('param exists', () => {
+      const extensionParam = extensionParams['MEILISEARCH_FIELDS_TO_INDEX']
+      expect(extensionParam).toMatchSnapshot()
+    })
+
+    describe('validationRegex', () => {
+      test('does not allow spaces', () => {
+        const { validationRegex } =
+          extensionParams['MEILISEARCH_FIELDS_TO_INDEX']
+        const text = 'foo bar'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).toBeNull()
+      })
+
+      test('allow comma-separated list', () => {
+        const { validationRegex } =
+          extensionParams['MEILISEARCH_FIELDS_TO_INDEX']
+        const text = 'field1,field2,field3'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).not.toBeNull()
+      })
+
+      test('allows a alphanumeric underscore list of field', () => {
+        const { validationRegex } =
+          extensionParams['MEILISEARCH_FIELDS_TO_INDEX']
+        const text = 'field_1,field_2,field_3'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).not.toBeNull()
+      })
+
+      test('allows a alphanumeric dash list of field', () => {
+        const { validationRegex } =
+          extensionParams['MEILISEARCH_FIELDS_TO_INDEX']
+        const text = 'field-1,field-2,field-3'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).not.toBeNull()
+      })
+    })
+  })
+
+  // MEILISEARCH_INDEX_NAME
+  describe('Test MeilisearchIndex parameters', () => {
+    test('param exists', () => {
+      const extensionParam = extensionParams['MEILISEARCH_INDEX_NAME']
+
+      expect(extensionParam).toMatchSnapshot()
+    })
+
+    describe('validationRegex', () => {
+      test('does not allow empty strings', () => {
+        const { validationRegex } = extensionParams['MEILISEARCH_INDEX_NAME']
+        const text = ''
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).toBeNull()
+      })
+
+      test('does not allow spaces', () => {
+        const { validationRegex } = extensionParams['MEILISEARCH_INDEX_NAME']
+        const text = 'foo bar'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).toBeNull()
+      })
+
+      test('allows a alphanumeric underscore in index name', () => {
+        const { validationRegex } = extensionParams['MEILISEARCH_INDEX_NAME']
+        const text = 'index_1'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).not.toBeNull()
+      })
+
+      test('allows a alphanumeric dash in index name', () => {
+        const { validationRegex } = extensionParams['MEILISEARCH_INDEX_NAME']
+        const text = 'index-1'
+        const search = new RegExp(validationRegex)
+
+        expect(search.exec(text)).not.toBeNull()
+      })
+    })
+  })
+})

package/functions/__tests__/data/document.ts

@@ -0,0 +1,11 @@
+export default {
+  id: '0jKUH3XUNXFyujm3rZAa',
+  document: {
+    title: 'The Lord of the Rings: The Fellowship of the Ring',
+    genre: ['Adventure', 'Fantasy', 'Action'],
+    overview:
+      'Young hobbit Frodo Baggins, after inheriting a mysterious ring from his uncle Bilbo, must leave his home in order to keep it from falling into the hands of its evil creator. Along the way, a fellowship is formed to protect the ringbearer and make sure that the ring arrives at its final destination: Mt. Doom, the only place where it can be destroyed.',
+    poster: 'https://image.tmdb.org/t/p/w500/6oom5QYQ2yQTMJIbnvbkBL9cHo6.jpg',
+    release_date: 1008633600,
+  },
+}

package/functions/__tests__/data/environment.ts

@@ -0,0 +1,9 @@
+export default {
+  LOCATION: 'us-central1',
+  PROJECT_ID: 'fake-project',
+  COLLECTION_PATH: 'collection',
+  MEILISEARCH_FIELDS_TO_INDEX: '',
+  MEILISEARCH_INDEX_NAME: 'example',
+  MEILISEARCH_HOST: 'http://127.0.0.1:7700',
+  MEILISEARCH_API_KEY: 'masterKey',
+}

package/functions/__tests__/functions.test.ts

@@ -0,0 +1,280 @@
+import * as firebaseFunctionsTestInit from 'firebase-functions-test'
+import mockedEnv from 'mocked-env'
+import { mocked } from 'ts-jest/utils'
+import { mockConsoleLog, mockConsoleInfo } from './__mocks__/console'
+import { MeiliSearch } from 'meilisearch'
+import defaultEnvironment from './data/environment'
+import defaultDocument from './data/document'
+
+jest.mock('meilisearch')
+
+// Mocking of Firebase functions
+let firebaseMock = firebaseFunctionsTestInit()
+
+describe('extension', () => {
+  let config
+  let restoreEnv
+
+  // Mocking of Meilisearch package
+  const mockedMeilisearch = mocked(MeiliSearch, true)
+  const mockedAddDocuments = jest.fn()
+  const mockedUpdateDocuments = jest.fn()
+  const mockedDeleteDocument = jest.fn()
+  const mockedIndex = jest.fn(() => ({
+    addDocuments: mockedAddDocuments,
+    updateDocuments: mockedUpdateDocuments,
+    deleteDocument: mockedDeleteDocument,
+  }))
+  mockedMeilisearch.mockReturnValue({
+    // @ts-ignore
+    index: mockedIndex,
+  })
+
+  // Mocking of firestore-meilisearch
+  const mockExport = (document: any, data: any) => {
+    const ref = require('../src/index').indexingWorker
+    return firebaseFunctionsTestInit().wrap(ref)(document, data)
+  }
+
+  beforeEach(() => {
+    restoreEnv = mockedEnv(defaultEnvironment)
+    config = require('../src/config').config
+  })
+  afterEach(() => restoreEnv())
+
+  test('functions are exported', () => {
+    const exportedFunctions = jest.requireActual('../src')
+
+    expect(exportedFunctions.indexingWorker).toBeInstanceOf(Function)
+  })
+
+  test('Meilisearch client initialized', () => {
+    expect(mockedMeilisearch).toHaveBeenCalledWith({
+      apiKey: defaultEnvironment.MEILISEARCH_API_KEY,
+      host: defaultEnvironment.MEILISEARCH_HOST,
+    })
+    expect(mockConsoleLog).toBeCalledWith(
+      'Initializing extension with configuration',
+      config
+    )
+  })
+
+  test('Meilisearch index initialized', () => {
+    expect(mockedIndex).toHaveBeenCalledWith(
+      defaultEnvironment.MEILISEARCH_INDEX_NAME
+    )
+    expect(mockConsoleLog).toBeCalledWith(
+      'Initializing extension with configuration',
+      config
+    )
+  })
+
+  describe('functions.indexingWorker', () => {
+    firebaseMock = firebaseFunctionsTestInit()
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    test('function runs with created data', async () => {
+      const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        {},
+        `collection/{}`
+      )
+      const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        defaultDocument.document,
+        `collection/${defaultDocument.id}`
+      )
+      const documentChange = firebaseMock.makeChange(
+        beforeSnapshot,
+        afterSnapshot
+      )
+
+      const callResult = await mockExport(documentChange, {
+        resource: {
+          name: 'test',
+        },
+      })
+
+      expect(callResult).toBeUndefined()
+      expect(mockConsoleLog).toBeCalledWith(
+        'Started execution of extension with configuration',
+        config
+      )
+      expect(mockConsoleLog).toBeCalledWith('Completed execution of extension')
+      expect(mockConsoleInfo).toBeCalledWith(
+        `Creating new document ${
+          afterSnapshot.id as string
+        } in Meilisearch index ${defaultEnvironment.MEILISEARCH_INDEX_NAME}`,
+        { _firestore_id: defaultDocument.id, ...afterSnapshot.data() }
+      )
+      expect(mockedAddDocuments).toHaveBeenCalledWith(
+        [
+          {
+            _firestore_id: defaultDocument.id,
+            ...defaultDocument.document,
+          },
+        ],
+        { primaryKey: '_firestore_id' }
+      )
+    })
+
+    test('function runs with created data with id fields in document', async () => {
+      const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        {},
+        `collection/{}`
+      )
+      const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { id: '12345', ...defaultDocument.document },
+        `collection/${defaultDocument.id}`
+      )
+      const documentChange = firebaseMock.makeChange(
+        beforeSnapshot,
+        afterSnapshot
+      )
+
+      const callResult = await mockExport(documentChange, {
+        resource: {
+          name: 'test',
+        },
+      })
+
+      expect(callResult).toBeUndefined()
+      expect(mockConsoleLog).toBeCalledWith(
+        'Started execution of extension with configuration',
+        config
+      )
+      expect(mockConsoleLog).toBeCalledWith('Completed execution of extension')
+      expect(mockConsoleInfo).toBeCalledWith(
+        `Creating new document ${
+          afterSnapshot.id as string
+        } in Meilisearch index ${defaultEnvironment.MEILISEARCH_INDEX_NAME}`,
+        { _firestore_id: defaultDocument.id, ...afterSnapshot.data() }
+      )
+      expect(mockedAddDocuments).toHaveBeenCalledWith(
+        [
+          {
+            _firestore_id: defaultDocument.id,
+            id: '12345',
+            ...defaultDocument.document,
+          },
+        ],
+        { primaryKey: '_firestore_id' }
+      )
+    })
+
+    test('function runs with updated data', async () => {
+      const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { foo: 'bar' },
+        `collection/${defaultDocument.id}`
+      )
+      const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        defaultDocument.document,
+        `collection/${defaultDocument.id}`
+      )
+      const documentChange = firebaseMock.makeChange(
+        beforeSnapshot,
+        afterSnapshot
+      )
+
+      const callResult = await mockExport(documentChange, {
+        resource: {
+          name: 'test',
+        },
+      })
+
+      expect(callResult).toBeUndefined()
+      expect(mockConsoleLog).toBeCalledWith(
+        'Started execution of extension with configuration',
+        config
+      )
+      expect(mockConsoleInfo).toBeCalledWith(
+        `Updating document ${afterSnapshot.id as string} in Meilisearch index ${
+          defaultEnvironment.MEILISEARCH_INDEX_NAME
+        }`,
+        { _firestore_id: defaultDocument.id, ...afterSnapshot.data() }
+      )
+      expect(mockConsoleLog).toBeCalledWith('Completed execution of extension')
+      expect(mockedUpdateDocuments).toHaveBeenCalledWith([
+        {
+          _firestore_id: defaultDocument.id,
+          ...defaultDocument.document,
+        },
+      ])
+    })
+
+    test('function runs with updated data with id fields in document', async () => {
+      const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { foo: 'bar' },
+        `collection/${defaultDocument.id}`
+      )
+      const afterSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { id: '12345', ...defaultDocument.document },
+        `collection/${defaultDocument.id}`
+      )
+      const documentChange = firebaseMock.makeChange(
+        beforeSnapshot,
+        afterSnapshot
+      )
+
+      const callResult = await mockExport(documentChange, {
+        resource: {
+          name: 'test',
+        },
+      })
+
+      expect(callResult).toBeUndefined()
+      expect(mockConsoleLog).toBeCalledWith(
+        'Started execution of extension with configuration',
+        config
+      )
+      expect(mockConsoleInfo).toBeCalledWith(
+        `Updating document ${afterSnapshot.id as string} in Meilisearch index ${
+          defaultEnvironment.MEILISEARCH_INDEX_NAME
+        }`,
+        {
+          _firestore_id: defaultDocument.id,
+          id: '12345',
+          ...afterSnapshot.data(),
+        }
+      )
+      expect(mockConsoleLog).toBeCalledWith('Completed execution of extension')
+      expect(mockedUpdateDocuments).toHaveBeenCalledWith([
+        {
+          _firestore_id: defaultDocument.id,
+          id: '12345',
+          ...defaultDocument.document,
+        },
+      ])
+    })
+
+    test('functions runs with deleted data', async () => {
+      const beforeSnapshot = firebaseMock.firestore.makeDocumentSnapshot(
+        { foo: 'bar' },
+        `collection/${defaultDocument.id}`
+      )
+      const afterSnapshot = { ...defaultDocument.document, exists: false }
+      const documentChange = firebaseMock.makeChange(
+        beforeSnapshot,
+        afterSnapshot
+      )
+
+      const callResult = await mockExport(documentChange, {
+        resource: {
+          name: 'test',
+        },
+      })
+
+      expect(callResult).toBeUndefined()
+      expect(mockConsoleLog).toBeCalledWith(
+        'Started execution of extension with configuration',
+        config
+      )
+      expect(mockConsoleInfo).toBeCalledWith(
+        `Deleting document ${defaultDocument.id} in Meilisearch index ${defaultEnvironment.MEILISEARCH_INDEX_NAME}`
+      )
+      expect(mockConsoleLog).toBeCalledWith('Completed execution of extension')
+      expect(mockedDeleteDocument).toHaveBeenCalledWith(defaultDocument.id)
+    })
+  })
+})

package/functions/__tests__/jest.setup.ts

@@ -0,0 +1 @@
+global.config = () => require('../src/config').default

package/functions/__tests__/test.types.d.ts

@@ -0,0 +1,5 @@
+declare namespace NodeJS {
+  interface Global {
+    config: () => jest.ModuleMocker
+  }
+}

package/functions/__tests__/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../tsconfig.json",
+  "files": ["test.types.d.ts"],
+  "include": ["**/*"]
+}