@travetto/model-firestore 2.1.3 → 2.2.0

package/README.md

@@ -10,7 +10,7 @@ npm install @travetto/model-firestore
 
 This module provides an [Firestore](https://firebase.google.com/docs/firestore)-based implementation of the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [Firestore](https://firebase.google.com/docs/firestore).
 
-Supported featrues:
+Supported features:
    
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
    *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12)
@@ -57,7 +57,7 @@ export class FirestoreModelConfig {
     private_key: string;
   };
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     if (this.emulator) {
       process.env.FIRESTORE_EMULATOR_HOST = this.emulator;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-firestore",
   "displayName": "Firestore Model Support",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Firestore backing for the travetto model module.",
   "keywords": [
     "typescript",
@@ -26,8 +26,8 @@
     "directory": "module/model-firestore"
   },
   "dependencies": {
-    "@travetto/config": "^2.1.3",
-    "@travetto/model": "^2.1.3",
+    "@travetto/config": "^2.2.0",
+    "@travetto/model": "^2.2.0",
     "@google-cloud/firestore": "^5.0.2"
   },
   "private": false,

package/src/config.ts

@@ -16,7 +16,7 @@ export class FirestoreModelConfig {
     private_key: string;
   };
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     if (this.emulator) {
       process.env.FIRESTORE_EMULATOR_HOST = this.emulator;
     }

package/src/service.ts

@@ -1,4 +1,4 @@
-import { FieldValue, Firestore, Precondition, Query } from '@google-cloud/firestore';
+import { DocumentData, FieldValue, Firestore, PartialWithFieldValue, Query, UpdateData } from '@google-cloud/firestore';
 
 import { ShutdownManager, Util, Class } from '@travetto/base';
 import { DeepPartial } from '@travetto/schema';
@@ -13,9 +13,9 @@ import { ModelIndexedUtil } from '@travetto/model/src/internal/service/indexed';
 
 import { FirestoreModelConfig } from './config';
 
-const clone = <T>(inp: T) => JSON.parse(JSON.stringify(inp));
+const clone = <T>(inp: T): T => JSON.parse(JSON.stringify(inp));
 
-const toSimpleObj = <T>(inp: T, missingValue: unknown = null) =>
+const toSimpleObj = <T>(inp: T, missingValue: unknown = null): PartialWithFieldValue<DocumentData> =>
   JSON.parse(JSON.stringify(inp, (_, v) => v ?? null), (_, v) => v ?? missingValue);
 
 /**
@@ -28,7 +28,7 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
 
   constructor(public readonly config: FirestoreModelConfig) { }
 
-  #resolveTable(cls: Class) {
+  #resolveTable(cls: Class): string {
     let table = ModelRegistry.getStore(cls);
     if (this.config.namespace) {
       table = `${this.config.namespace}_${table}`;
@@ -36,20 +36,20 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
     return table;
   }
 
-  #getCollection(cls: Class) {
+  #getCollection(cls: Class): FirebaseFirestore.CollectionReference<DocumentData> {
     return this.client.collection(this.#resolveTable(cls));
   }
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     this.client = new Firestore(this.config);
     ShutdownManager.onShutdown(this.constructor.ᚕid, () => this.client.terminate());
   }
 
   // Storage
-  async createStorage() { }
-  async deleteStorage() { }
+  async createStorage(): Promise<void> { }
+  async deleteStorage(): Promise<void> { }
 
-  async deleteModel(cls: Class) {
+  async deleteModel(cls: Class): Promise<void> {
     for await (const el of this.list(cls)) {
       await this.delete(cls, el.id);
     }
@@ -60,7 +60,7 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
     return Util.uuid();
   }
 
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     const res = await this.#getCollection(cls).doc(id).get();
 
     if (res && res.exists) {
@@ -69,67 +69,70 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
     throw new NotFoundError(cls, id);
   }
 
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     const prepped = await ModelCrudUtil.preStore(cls, item, this);
     await this.#getCollection(cls).doc(prepped.id).create(clone(prepped));
     return prepped;
   }
 
-  async update<T extends ModelType>(cls: Class<T>, item: T) {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
-    item = await ModelCrudUtil.preStore(cls, item, this);
-    await this.#getCollection(cls).doc(item.id).update(clone(item));
+    const prepped = await ModelCrudUtil.preStore(cls, item, this);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    await this.#getCollection(cls).doc(item.id).update(clone(prepped) as unknown as UpdateData<DocumentData>);
     return item;
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const prepped = await ModelCrudUtil.preStore(cls, item, this);
     await this.#getCollection(cls).doc(prepped.id).set(clone(prepped));
     return prepped;
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const id = item.id;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     item = await ModelCrudUtil.naivePartialUpdate(cls, item, view, async () => ({} as unknown as T));
     const cleaned = toSimpleObj(item, FieldValue.delete());
     await this.#getCollection(cls).doc(id).set(cleaned, { merge: true });
     return this.get(cls, id);
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     ModelCrudUtil.ensureNotSubType(cls);
     try {
-      await this.#getCollection(cls).doc(id).delete({ exists: true } as unknown as Precondition);
+      await this.#getCollection(cls).doc(id).delete({ exists: true });
     } catch (err) {
-      if (`${err.message}`.includes('NOT_FOUND')) {
+      if (err && err instanceof Error && err.message.includes('NOT_FOUND')) {
         throw new NotFoundError(cls, id);
       }
       throw err;
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     const batch = await this.#getCollection(cls).select().get();
     for (const el of batch.docs) {
       try {
         yield await this.get(cls, el.id);
-      } catch (e) {
-        if (!(e instanceof NotFoundError)) {
-          throw e;
+      } catch (err) {
+        if (!(err instanceof NotFoundError)) {
+          throw err;
         }
       }
     }
   }
 
   // Indexed
-  async #getIdByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async #getIdByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<string> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const { fields } = ModelIndexedUtil.computeIndexParts(cls, idx, body);
-    const query = fields.reduce((q, { path, value }) => q.where(path.join('.'), '==', value),
-      this.#getCollection(cls) as Query
+    const query = fields.reduce<Query>(
+      (q, { path, value }) => q.where(path.join('.'), '==', value),
+      this.#getCollection(cls)
     );
 
     const item = await query.get();
@@ -140,11 +143,11 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
     throw new NotFoundError(`${cls.name} Index=${idx}`, ModelIndexedUtil.computeIndexKey(cls, idx, body, { sep: '; ' })?.key);
   }
 
-  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T> {
     return this.get(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void> {
     return this.delete(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
@@ -152,12 +155,12 @@ export class FirestoreModelService implements ModelCrudSupport, ModelStorageSupp
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): AsyncIterable<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const { fields, sorted } = ModelIndexedUtil.computeIndexParts(cls, idx, body, { emptySortValue: null });
-    let query = fields.reduce((q, { path, value }) =>
-      q.where(path.join('.'), '==', value), this.#getCollection(cls) as Query);
+    let query = fields.reduce<Query>((q, { path, value }) =>
+      q.where(path.join('.'), '==', value), this.#getCollection(cls));
 
     if (sorted) {
       query = query.orderBy(sorted.path.join('.'), sorted.dir === 1 ? 'asc' : 'desc');