@digitalaidseattle/firebase 1.0.9 → 1.0.12

package/dist/declarations/src/FirebaseAuthService.d.ts

@@ -1,8 +1,15 @@
-import { AuthError, AuthService, OAuthResponse, User } from '@digitalaidseattle/core';
-declare class FirebaseAuthService implements AuthService {
-    currentUser: User | undefined;
-    auth: import("@firebase/auth").Auth;
-    constructor();
+/**
+ *  storageService.ts
+ *
+ *  @copyright 2024 Digital Aid Seattle
+ *
+ */
+import { AuthError, AuthService, OAuthResponse } from '@digitalaidseattle/core';
+import { FirebaseApp } from 'firebase/app';
+import { Auth } from 'firebase/auth';
+export declare class FirebaseAuthService implements AuthService {
+    auth: Auth;
+    constructor(firebaseClient: FirebaseApp);
     getProviders(): string[];
     signInWith(provider: string): Promise<OAuthResponse>;
     hasUser(): Promise<boolean>;
@@ -12,4 +19,3 @@ declare class FirebaseAuthService implements AuthService {
     }>;
     signInWithGoogle: () => Promise<any>;
 }
-export { FirebaseAuthService };

package/dist/declarations/src/FirebaseStorageService.d.ts

@@ -1,18 +1,21 @@
 /**
- *  storageService.ts
+ *  FirebaseStorageService.ts
  *
- *  @copyright 2024 Digital Aid Seattle
+ *  @copyright 2026 Digital Aid Seattle
  *
  */
 import { StorageService } from "@digitalaidseattle/core";
+import { FirebaseApp } from "firebase/app";
+import { FirebaseStorage } from "firebase/storage";
 export declare class FirebaseStorageService implements StorageService {
-    storage: import("@firebase/storage").FirebaseStorage;
+    storage: FirebaseStorage;
     decoder: TextDecoder;
+    constructor(firebaseClient: FirebaseApp);
     downloadFile: (filepath: string) => Promise<string>;
     getUrlAsync(filepath: string): Promise<string>;
-    list(filepath?: string): Promise<any[]>;
     getUrl(filepath: string): string;
-    upload(path: string, blob: any): Promise<any>;
     downloadBlob(filepath: string): Promise<Blob | null>;
-    removeFile(fileName: string): Promise<any>;
+    removeFile(path: string): Promise<void>;
+    list(filepath?: string): Promise<any[]>;
+    upload(path: string, file: any): Promise<any>;
 }

package/dist/declarations/src/FirestoreService.d.ts

@@ -7,8 +7,9 @@ declare class FirestoreService<T extends Entity> implements EntityService<T> {
     getById(id: string, select?: string, mapper?: (json: any) => T): Promise<T>;
     batchInsert(entities: T[], select?: string, mapper?: (json: any) => T, user?: User): Promise<T[]>;
     insert(entity: T, select?: string, mapper?: (json: any) => T, user?: User): Promise<T>;
-    update(entityId: Identifier, updatedFields: T, select?: string, mapper?: (json: any) => T, user?: User): Promise<T>;
+    update(entityId: Identifier, updatedFields: Partial<T>, select?: string, mapper?: (json: any) => T, user?: User): Promise<T>;
     delete(entityId: Identifier): Promise<void>;
+    upsert(entity: T): Promise<T>;
 }
 export { FirestoreService };
 export type { Entity };

package/dist/declarations/src/GeminiService.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Institution AI Service
+ *
+ *
+ * Provision Firebase application  in Google Cloud
+ * <ol>
+ * <li>Go to the Google Cloud Console.</li>
+ * <li>Select an existing project.</li>
+ * <li>Navigate to the "APIs & Services" page.</li>
+ * <li>Click on "Credential".</li>
+ * <li>Edit API (the key should match the API key in the .env file).</li>
+ * <li>Enable the "Generative Language API" and "Firebase AI Logic API" restrictions.</li>
+ * </ol>
+ */
+import { AiService } from "@digitalaidseattle/core";
+import { AI } from "firebase/ai";
+declare class GeminiService implements AiService {
+    ai: AI;
+    constructor(modelType?: string);
+    getModels(): string[];
+    calcTokenCount(model: string, prompt: string): Promise<number>;
+    generateContent(model: string, prompt: string): Promise<any>;
+    generateParameterizedContent(model: string, prompt: string, schemaParams: string[]): Promise<any>;
+}
+export { GeminiService };

package/dist/declarations/src/index.d.ts

@@ -2,3 +2,4 @@ export * from "./FirebaseAuthService.js";
 export * from "./firebaseClient.js";
 export * from "./FirebaseStorageService.js";
 export * from "./FirestoreService.js";
+export * from "./GeminiService.js";

package/dist/digitalaidseattle-firebase.cjs.dev.js

@@ -12,35 +12,35 @@ var app = require('firebase/app');
 var storage = require('firebase/storage');
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var firestore = require('firebase/firestore');
+var firebase = require('@digitalaidseattle/firebase');
+var ai = require('firebase/ai');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
 var _regeneratorRuntime__default = /*#__PURE__*/_interopDefault(_regeneratorRuntime);
 
-var firebaseConfig = {
-  apiKey: undefined.VITE_FIREBASE_API_KEY,
-  authDomain: undefined.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: undefined.VITE_FIREBASE_PROJECT_ID,
-  storageBucket: undefined.VITE_FIREBASE_STORAGE_BUCKET,
-  messagingSenderId: undefined.VITE_FIREBASE_MESSAGING_SENDER_ID,
-  appId: undefined.VITE_FIREBASE_APP_ID,
-  measurementId: undefined.VITE_FIREBASE_MEASUREMENT_ID
-};
-
-// Initialize Firebase
-var firebaseClient = app.initializeApp(firebaseConfig);
-
 var FirebaseAuthService = /*#__PURE__*/function () {
-  function FirebaseAuthService() {
+  function FirebaseAuthService(firebaseClient) {
     var _this = this;
     _classCallCheck(this, FirebaseAuthService);
-    _defineProperty(this, "currentUser", undefined);
-    _defineProperty(this, "auth", auth.getAuth(firebaseClient));
     _defineProperty(this, "getUser", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee() {
       return _regeneratorRuntime__default["default"].wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            return _context.abrupt("return", _this.currentUser);
+            return _context.abrupt("return", new Promise(function (resolve) {
+              var unsubscribe = auth.onAuthStateChanged(_this.auth, function (gUser) {
+                unsubscribe(); // stop listening after first call
+                var user = gUser ? {
+                  email: gUser.email,
+                  user_metadata: {
+                    name: gUser.displayName,
+                    avatar_url: gUser.photoURL,
+                    email: gUser.email
+                  }
+                } : null;
+                resolve(user);
+              });
+            }));
           case 1:
           case "end":
             return _context.stop();
@@ -51,19 +51,20 @@ var FirebaseAuthService = /*#__PURE__*/function () {
       return _regeneratorRuntime__default["default"].wrap(function (_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            _this.currentUser = undefined;
-            _this.auth.signOut();
+            _context2.next = 1;
+            return _this.auth.signOut();
+          case 1:
             return _context2.abrupt("return", {
               error: null
             });
-          case 1:
+          case 2:
           case "end":
             return _context2.stop();
         }
       }, _callee2);
     })));
     _defineProperty(this, "signInWithGoogle", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee3() {
-      var provider, resp, _t;
+      var provider, _t;
       return _regeneratorRuntime__default["default"].wrap(function (_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
@@ -72,15 +73,6 @@ var FirebaseAuthService = /*#__PURE__*/function () {
             _context3.next = 1;
             return auth.signInWithPopup(_this.auth, provider);
           case 1:
-            resp = _context3.sent;
-            _this.currentUser = {
-              email: resp.user.email,
-              user_metadata: {
-                name: resp.user.displayName,
-                avatar_url: resp.user.photoURL,
-                email: resp.user.email
-              }
-            };
             return _context3.abrupt("return", {
               data: {
                 url: undefined.VITE_AUTH_DOMAIN
@@ -89,25 +81,15 @@ var FirebaseAuthService = /*#__PURE__*/function () {
           case 2:
             _context3.prev = 2;
             _t = _context3["catch"](0);
-            console.error(_t);
+            console.error('signInWithGoogle', _t);
+            throw _t;
           case 3:
           case "end":
             return _context3.stop();
         }
       }, _callee3, null, [[0, 2]]);
     })));
-    this.auth.onAuthStateChanged(function (user) {
-      if (user) {
-        _this.currentUser = {
-          email: user.email,
-          user_metadata: {
-            name: user.displayName,
-            avatar_url: user.photoURL,
-            email: user.email
-          }
-        };
-      }
-    });
+    this.auth = auth.getAuth(firebaseClient);
   }
   return _createClass(FirebaseAuthService, [{
     key: "getProviders",
@@ -127,17 +109,34 @@ var FirebaseAuthService = /*#__PURE__*/function () {
   }, {
     key: "hasUser",
     value: function hasUser() {
-      return Promise.resolve(this.currentUser !== null);
+      var _this2 = this;
+      return new Promise(function (resolve) {
+        var unsubscribe = auth.onAuthStateChanged(_this2.auth, function (user) {
+          unsubscribe(); // stop listening after first call
+          resolve(user ? true : false);
+        });
+      });
     }
   }]);
 }();
 
+var firebaseConfig = {
+  apiKey: undefined.VITE_FIREBASE_API_KEY,
+  authDomain: undefined.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: undefined.VITE_FIREBASE_PROJECT_ID,
+  storageBucket: undefined.VITE_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: undefined.VITE_FIREBASE_MESSAGING_SENDER_ID,
+  appId: undefined.VITE_FIREBASE_APP_ID,
+  measurementId: undefined.VITE_FIREBASE_MEASUREMENT_ID
+};
+
+// Initialize Firebase
+var firebaseClient = app.initializeApp(firebaseConfig);
+
 var FirebaseStorageService = /*#__PURE__*/function () {
-  function FirebaseStorageService() {
+  function FirebaseStorageService(firebaseClient) {
     var _this = this;
     _classCallCheck(this, FirebaseStorageService);
-    _defineProperty(this, "storage", storage.getStorage(firebaseClient));
-    _defineProperty(this, "decoder", new TextDecoder("utf-8"));
     _defineProperty(this, "downloadFile", /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee(filepath) {
         var fileRef;
@@ -158,6 +157,8 @@ var FirebaseStorageService = /*#__PURE__*/function () {
         return _ref.apply(this, arguments);
       };
     }());
+    this.storage = storage.getStorage(firebaseClient);
+    this.decoder = new TextDecoder("utf-8");
   }
   return _createClass(FirebaseStorageService, [{
     key: "getUrlAsync",
@@ -189,31 +190,128 @@ var FirebaseStorageService = /*#__PURE__*/function () {
       }
       return getUrlAsync;
     }()
-  }, {
-    key: "list",
-    value: function list(filepath) {
-      throw new Error("Method not implemented.");
-    }
   }, {
     key: "getUrl",
     value: function getUrl(filepath) {
       throw new Error("Method not supported.");
     }
-  }, {
-    key: "upload",
-    value: function upload(path, blob) {
-      throw new Error("Method not implemented.");
-    }
   }, {
     key: "downloadBlob",
     value: function downloadBlob(filepath) {
-      throw new Error("Method not implemented.");
+      var fileRef = storage.ref(this.storage, filepath);
+      return storage.getBytes(fileRef).then(function (bytes) {
+        return new Blob([bytes]);
+      });
     }
   }, {
     key: "removeFile",
-    value: function removeFile(fileName) {
-      throw new Error("Method not implemented.");
+    value: function removeFile(path) {
+      try {
+        var fileRef = storage.ref(this.storage, path);
+        return storage.deleteObject(fileRef);
+      } catch (error) {
+        if (error.code === "storage/object-not-found") {
+          console.warn("File does not exist");
+        } else if (error.code === "storage/unauthorized") {
+          console.error("User not authorized to delete file");
+        } else {
+          console.error("Delete failed:", error);
+        }
+        throw error;
+      }
     }
+  }, {
+    key: "list",
+    value: function () {
+      var _list = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee4(filepath) {
+        var folderRef, result, files;
+        return _regeneratorRuntime__default["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (filepath) {
+                _context4.next = 1;
+                break;
+              }
+              return _context4.abrupt("return", []);
+            case 1:
+              folderRef = storage.ref(this.storage, filepath);
+              _context4.next = 2;
+              return storage.listAll(folderRef);
+            case 2:
+              result = _context4.sent;
+              _context4.next = 3;
+              return Promise.all(result.items.map(/*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee3(item) {
+                  var metadata;
+                  return _regeneratorRuntime__default["default"].wrap(function (_context3) {
+                    while (1) switch (_context3.prev = _context3.next) {
+                      case 0:
+                        _context3.next = 1;
+                        return storage.getMetadata(item);
+                      case 1:
+                        metadata = _context3.sent;
+                        return _context3.abrupt("return", {
+                          name: item.name,
+                          fullPath: item.fullPath,
+                          type: metadata.contentType,
+                          size: metadata.size,
+                          updated: metadata.updated
+                        });
+                      case 2:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }, _callee3);
+                }));
+                return function (_x4) {
+                  return _ref2.apply(this, arguments);
+                };
+              }()));
+            case 3:
+              files = _context4.sent;
+              return _context4.abrupt("return", files);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function list(_x3) {
+        return _list.apply(this, arguments);
+      }
+      return list;
+    }()
+  }, {
+    key: "upload",
+    value: function () {
+      var _upload = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee5(path, file) {
+        var storageRef, snapshot, downloadUrl;
+        return _regeneratorRuntime__default["default"].wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              storageRef = storage.ref(this.storage, path); // Upload file
+              _context5.next = 1;
+              return storage.uploadBytes(storageRef, file, {
+                contentType: file === null || file === void 0 ? void 0 : file.type
+              });
+            case 1:
+              snapshot = _context5.sent;
+              _context5.next = 2;
+              return storage.getDownloadURL(snapshot.ref);
+            case 2:
+              downloadUrl = _context5.sent;
+              return _context5.abrupt("return", downloadUrl);
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function upload(_x5, _x6) {
+        return _upload.apply(this, arguments);
+      }
+      return upload;
+    }()
   }]);
 }();
 
@@ -405,10 +503,112 @@ var FirestoreService = /*#__PURE__*/function () {
       }
       return _delete;
     }()
+  }, {
+    key: "upsert",
+    value: function () {
+      var _upsert = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee7(entity) {
+        return _regeneratorRuntime__default["default"].wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 1;
+              return firestore.setDoc(firestore.doc(this.db, this.collectionName, entity.id), entity);
+            case 1:
+              return _context7.abrupt("return", entity);
+            case 2:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function upsert(_x19) {
+        return _upsert.apply(this, arguments);
+      }
+      return upsert;
+    }()
+  }]);
+}();
+
+var GeminiService = /*#__PURE__*/function () {
+  function GeminiService(modelType) {
+    _classCallCheck(this, GeminiService);
+    this.ai = ai.getAI(firebase.firebaseClient, {
+      backend: new ai.GoogleAIBackend()
+    });
+  }
+  return _createClass(GeminiService, [{
+    key: "getModels",
+    value: function getModels() {
+      return ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.5-flash-lite"];
+    }
+  }, {
+    key: "calcTokenCount",
+    value: function calcTokenCount(model, prompt) {
+      return ai.getGenerativeModel(this.ai, {
+        model: model
+      }).countTokens(prompt).then(function (response) {
+        return response.totalTokens;
+      });
+    }
+
+    // Wrap in an async function so you can use await
+  }, {
+    key: "generateContent",
+    value: function generateContent(model, prompt) {
+      // To generate text output, call generateContent with the text input
+      console.log('generateContent', model, prompt);
+      return ai.getGenerativeModel(this.ai, {
+        model: model
+      }).generateContent(prompt).then(function (result) {
+        return result.response.text();
+      })["catch"](function (error) {
+        console.error("Error querying AI: ", error);
+        throw new Error("Failed to query AI: " + error.message);
+      });
+    }
+
+    // Wrap in an async function so you can use await
+  }, {
+    key: "generateParameterizedContent",
+    value: function generateParameterizedContent(model, prompt, schemaParams) {
+      // Provide a JSON schema object using a standard format.
+      // Later, pass this schema object into `responseSchema` in the generation config.
+      var schema = ai.Schema.object({
+        properties: {
+          characters: ai.Schema.array({
+            items: ai.Schema.object({
+              properties: Object.fromEntries(schemaParams.map(function (field) {
+                return [field, ai.Schema.string()];
+              }))
+            })
+          })
+        }
+      });
+
+      // Create a `GenerativeModel` instance with a model that supports your use case
+      var jModel = ai.getGenerativeModel(this.ai, {
+        model: model,
+        // In the generation config, set the `responseMimeType` to `application/json`
+        // and pass the JSON schema object into `responseSchema`.
+        generationConfig: {
+          responseMimeType: "application/json",
+          responseSchema: schema
+        }
+      });
+
+      // To generate text output, call generateContent with the text input
+      return jModel.generateContent(prompt).then(function (result) {
+        var content = result.response.text();
+        return JSON.parse(content).characters[0];
+      })["catch"](function (error) {
+        console.error("Error querying AI: ", error);
+        throw new Error("Failed to query AI: " + error.message);
+      });
+    }
   }]);
 }();
 
 exports.FirebaseAuthService = FirebaseAuthService;
 exports.FirebaseStorageService = FirebaseStorageService;
 exports.FirestoreService = FirestoreService;
+exports.GeminiService = GeminiService;
 exports.firebaseClient = firebaseClient;