Add TypeSense to Firestore FTS (#883)

Author: samtstern

fulltext-search-firestore/README.md

@@ -1,6 +1,10 @@
-# Full Text search via Algolia
+# Full Text search
 
-This template shows how to enable full text search on Firestore documents by using an [Algolia](https://algolia.com) hosted search service.
+This template shows how to enable full text search on Firestore documents by using one of the followning hosted search services:
+
+  * [Algolia](https://algolia.com)
+  * [Elastic](https://elastic.co)
+  * [Typesense](https://typesense.org)
 
 ## Functions Code
 
@@ -16,17 +20,14 @@ As an example we'll be using a secure note structure:
 /notes
     /note-123456
         text: "This is my first note...",
-        author: "FIREBASE_USER_ID"
+        owner: "FIREBASE_USER_ID"
     /note-123457
         text: "This is my second note entry...",
-        author: "FIREBASE_USER_ID"
+        owner: "FIREBASE_USER_ID"
         tags: ["some_category"]
 ```
 
-Whenever a new note is created or modified a Function sends the content to be indexed to the Algolia instance.
-
-To securely search notes, a user is issued a [Secured API Key](https://www.algolia.com/doc/guides/security/api-keys/#secured-api-keys) from Algolia which
-limits which documents they can search through.
+Whenever a new note is created or modified a Function sends the content to be indexed.
 
 ## Setting up the sample
 

fulltext-search-firestore/functions/index.js

@@ -101,8 +101,8 @@ app.get('/', (req, res) => {
   // Create the params object as described in the Algolia documentation:
   // https://www.algolia.com/doc/guides/security/api-keys/#generating-api-keys
   const params = {
-    // This filter ensures that only documents where author == uid will be readable
-    filters: `author:${uid}`,
+    // This filter ensures that only documents where owner == uid will be readable
+    filters: `owner:${uid}`,
     // We also proxy the uid as a unique token for this key.
     userToken: uid,
   };

fulltext-search-firestore/functions/package.json

@@ -7,7 +7,8 @@
     "cors": "^2.8.5",
     "express": "^4.17.1",
     "firebase-admin": "^9.9.0",
-    "firebase-functions": "^3.14.1"
+    "firebase-functions": "^3.14.1",
+    "typesense": "^0.13.0"
   },
   "devDependencies": {
     "eslint": "^6.8.0",

fulltext-search-firestore/functions/typesense.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright 2021 Google Inc. All Rights Reserved.
+ *
+ * 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
+ *
+ *      http://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");
+
+// [START init_typesense]
+// Initialize Typesense, requires installing Typesense dependencies:
+// https://github.com/typesense/typesense-js
+const Typesense = require("typesense");
+
+// Typesense API keys are stored in functions config variables
+const TYPESENSE_ADMIN_API_KEY = functions.config().typesense.admin_api_key;
+const TYPESENSE_SEARCH_API_KEY = functions.config().typesense.search_api_key;
+
+const client = new Typesense.Client({
+  'nodes': [{
+    'host': 'xxx.a1.typesense.net', // where xxx is the ClusterID of your Typesense Cloud cluster
+    'port': '443',
+    'protocol': 'https'
+  }],
+  'apiKey': TYPESENSE_ADMIN_API_KEY,
+  'connectionTimeoutSeconds': 2
+});
+// [END init_typesense]
+
+// [START create_typesense_collections]
+async function createTypesenseCollections() {
+  // Every 'collection' in Typesense needs a schema. A collection only
+  // needs to be created one time before you index your first document.
+  //
+  // Alternatively, use auto schema detection:
+  // https://typesense.org/docs/latest/api/collections.html#with-auto-schema-detection
+  const notesCollection = {
+    'name': 'notes',
+    'fields': [
+      {'name': 'id', 'type': 'string'},
+      {'name': 'owner', 'type': 'string' },
+      {'name': 'text', 'type': 'string' }
+    ]
+  };
+  
+  await client.collections().create(notesCollection);
+}
+// [END create_typesense_collections]
+
+// [START update_index_function_typesense]
+// Update the search index every time a blog post is written.
+exports.onNoteWritten = functions.firestore.document('notes/{noteId}').onWrite(async (snap, context) => {
+  // Use the 'nodeId' path segment as the identifier for Typesense
+  const id = context.params.noteId;
+
+  // If the note is deleted, delete the note from the Typesense index
+  if (!snap.after.exists) {
+    await client.collections('notes').documents(id).delete();
+    return;
+  }
+
+  // Otherwise, create/update the note in the the Typesense index
+  const note = snap.after.data();
+  await client.collections('notes').documents().upsert({
+    id,
+    owner: note.owner,
+    text: note.text
+  });
+});
+// [END update_index_function_typesense]
+
+// [START api_key_function_typesense]
+exports.getScopedApiKey = functions.https.onCall(async (data, context) => {
+  // Ensure that the user is authenticated with Firebase Auth
+  if (!(context.auth && context.auth.uid)) {
+    throw new functions.https.HttpsError('permission-denied', 'Must be signed in!');
+  }
+
+  // Generate a scoped API key which allows the user to search ONLY
+  // documents which belong to them (based on the 'owner' field).
+  const scopedApiKey = client.keys().generateScopedSearchKey(
+    TYPESENSE_SEARCH_API_KEY, 
+    { 
+      'filter_by': `owner:${context.auth.uid}`
+    }
+  );
+
+  return {
+    key: scopedApiKey
+  };
+});
+// [END api_key_function_typesense]

fulltext-search-firestore/public/index.js

@@ -14,11 +14,17 @@
  * limitations under the License.
  */
 
-var PROJECT_ID = ''          // Required - your Firebase project ID
-var ALGOLIA_APP_ID = '';     // Required - your Algolia app ID
-var ALGOLIA_SEARCH_KEY = ''; // Optional - Only used for unauthenticated search
+const PROJECT_ID = '...'          // Required - your Firebase project ID
 
-function unauthenticated_search(query) {
+const ALGOLIA_APP_ID = '...';     // Required - your Algolia app ID
+const ALGOLIA_SEARCH_KEY = '...'; // Optional - Only used for unauthenticated search
+
+// A search-only API Typesense API key. NEVER use your Admin API Key in a
+// web app. You can generate API keys using either the TypeSense Cloud console
+// or the TypeSense API.
+const TYPESENSE_SEARCH_API_KEY = '...';
+
+function searchAlgoliaUnauthenticated(query) {
 
   // [START search_index_unsecure]
   var client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_KEY);
@@ -38,7 +44,7 @@ function unauthenticated_search(query) {
   // [END search_index_unsecure]
 }
 
-function authenticated_search(query) {
+function searchAlgoliaAuthenticated(query) {
   var client;
   var index;
   // [START search_index_secure]
@@ -76,11 +82,11 @@ function search(query) {
     console.warn('Please set ALGOLIA_APP_ID in /index.js!');
   } else if (ALGOLIA_SEARCH_KEY) {
     console.log('Performing unauthenticated search...');
-    return unauthenticated_search(query);
+    return searchAlgoliaUnauthenticated(query);
   } else {
     return firebase.auth().signInAnonymously()
       .then(function() {
-        return authenticated_search(query).catch(function(err) {
+        return searchAlgoliaAuthenticated(query).catch(function(err) {
           console.warn(err);
         });
       }).catch(function(err) {
@@ -91,21 +97,76 @@ function search(query) {
 }
 
 function searchElastic(query) {
-   // [START search_elastic]
-   const searchNotes = firebase.functions().httpsCallable('searchNotes');
-   searchNotes({ query: query })
-     .then((result) => {
-       const notes = result.data.notes;
-       // ...
-     });
-   // [END search_elastic]
+  // [START search_elastic]
+  const searchNotes = firebase.functions().httpsCallable('searchNotes');
+  searchNotes({ query: query })
+    .then((result) => {
+      const notes = result.data.notes;
+      // ...
+    });
+  // [END search_elastic]
+}
+
+async function searchTypesenseUnauthenticated(query) {
+  // [START search_typesense_unauthenticated]
+  // Create a Typesense Client using the search-only API key
+  const client = new Typesense.Client({
+    'nodes': [{
+      'host': 'xxx.a1.typesense.net', // where xxx is the ClusterID of your Typesense Cloud cluster
+      'port': '443',
+      'protocol': 'https'
+    }],
+    'apiKey': TYPESENSE_SEARCH_API_KEY,
+    'connectionTimeoutSeconds': 2
+  });
+
+  // Search for notes with matching text
+  const searchParameters = {
+    'q': query,
+    'query_by': 'text'
+  };
+  const searchResults = await client.collections('notes')
+    .documents()
+    .search(searchParameters);
+  // ...
+  // [END search_typesense_unauthenticated]
+}
+
+async function searchTypesenseAuthenticated(query) {
+  // [START search_typesense_authenticated]
+  // Get a scoped TypeSense API key from our Callable Function
+  const getScopedApiKey = firebase.functions().httpsCallable('getScopedApiKey');
+  const scopedApiKeyResponse = await getScopedApiKey();
+  const apiKey = scopedApiKeyResponse.data.key;
+
+  // Create a Typesense Client
+  const client = new Typesense.Client({
+    'nodes': [{
+      'host': 'xxx.a1.typesense.net', // where xxx is the ClusterID of your Typesense Cloud cluster
+      'port': '443',
+      'protocol': 'https'
+    }],
+    'apiKey': apiKey,
+    'connectionTimeoutSeconds': 2
+  });
+
+  // Search for notes with matching text
+  const searchParameters = {
+    'q': query,
+    'query_by': 'text'
+  };
+  const searchResults = await client.collections('notes')
+    .documents()
+    .search(searchParameters);
+  // ...
+  // [END search_typesense_authenticated]
 }
 
 // Other code to wire up the buttons and textboxes.
 
 document.querySelector('#do-add-note').addEventListener('click', function() {
   firebase.firestore().collection('notes').add({
-    author: [firebase.auth().currentUser.uid],
+    owner: [firebase.auth().currentUser.uid],
     text: document.querySelector('#note-text').value
   }).then(function() {
     document.querySelector('#note-text').value = '';