@sneat/api 0.1.1

package/src/lib/sneat-firestore.service.ts

@@ -0,0 +1,157 @@
+import { Injector, runInInjectionContext } from '@angular/core';
+import {
+  doc,
+  getDoc,
+  CollectionReference,
+  DocumentReference,
+  DocumentSnapshot,
+  query,
+  where,
+  onSnapshot,
+  limit,
+} from '@angular/fire/firestore';
+import { IIdAndOptionalBriefAndOptionalDbo } from '@sneat/core';
+import { QuerySnapshot, QueryOrderByConstraint } from 'firebase/firestore';
+import { WhereFilterOp } from '@firebase/firestore-types';
+import { INavContext } from '@sneat/core';
+import { from, map, Observable, Subject } from 'rxjs';
+
+export interface IFilter {
+  readonly field: string;
+  readonly operator: WhereFilterOp;
+  readonly value: unknown;
+}
+
+export interface IQueryArgs {
+  readonly limit?: number;
+  readonly filter?: readonly IFilter[];
+  readonly orderBy?: readonly QueryOrderByConstraint[];
+}
+
+export class SneatFirestoreService<Brief, Dbo extends Brief> {
+  constructor(
+    private readonly injector: Injector,
+    // private readonly afs: AngularFirestore,
+    private readonly dto2brief: (id: string, dto: Dbo) => Brief = (
+      id: string,
+      dto: Dbo,
+    ) => ({
+      ...(dto as unknown as Brief),
+      id,
+    }),
+  ) {
+    if (!dto2brief) {
+      throw new Error('dto2brief is required');
+    }
+  }
+
+  watchByID<Dbo2 extends Dbo>(
+    collection: CollectionReference<Dbo2>,
+    id: string,
+  ): Observable<IIdAndOptionalBriefAndOptionalDbo<Brief, Dbo2>> {
+    const docRef = runInInjectionContext(this.injector, () =>
+      doc(collection, id),
+    );
+    return this.watchByDocRef(docRef);
+  }
+
+  watchByDocRef<Dbo2 extends Dbo>(
+    docRef: DocumentReference<Dbo2>,
+  ): Observable<IIdAndOptionalBriefAndOptionalDbo<Brief, Dbo2>> {
+    return runInInjectionContext(this.injector, () => {
+      const subj = new Subject<DocumentSnapshot<Dbo2>>();
+      // const snapshots = docSnapshots<Dbo2>(docRef);
+      onSnapshot(
+        docRef,
+        (snapshot) => subj.next(snapshot),
+        (err) => subj.error(err),
+        () => subj.complete(),
+      );
+      // const snapshots = from(getDoc<Dbo2>(docRef));
+      return subj.asObservable().pipe(
+        // tap((snapshot) =>
+        // 	console.log(
+        // 		`SneatFirestoreService.watchByDocRef(${docRef.path}): snapshot:`,
+        // 		snapshot,
+        // 	),
+        // ),
+        map((changes) =>
+          docSnapshotToDto<Brief, Dbo2>(docRef.id, this.dto2brief, changes),
+        ),
+      );
+    });
+  }
+
+  getByDocRef<Dbo2 extends Dbo>(
+    docRef: DocumentReference<Dbo2>,
+  ): Observable<INavContext<Brief, Dbo2>> {
+    return from(getDoc(docRef)).pipe(
+      map((changes) =>
+        docSnapshotToDto<Brief, Dbo2>(docRef.id, this.dto2brief, changes),
+      ),
+    );
+  }
+
+  watchSnapshotsByFilter<Dbo2 extends Dbo>(
+    collectionRef: CollectionReference<Dbo2>,
+    queryArgs?: IQueryArgs,
+  ): Observable<QuerySnapshot<Dbo2>> {
+    const operator = (f: IFilter) =>
+      f.field.endsWith('IDs') ? 'array-contains' : f.operator;
+    const q = query(
+      collectionRef,
+      ...(queryArgs?.filter || []).map((f) =>
+        where(f.field, operator(f), f.value),
+      ),
+      ...(queryArgs?.orderBy || []),
+      ...(queryArgs?.limit ? [limit(queryArgs.limit)] : []),
+    );
+    const subj = new Subject<QuerySnapshot<Dbo2>>();
+    onSnapshot(q, subj);
+    return subj;
+  }
+
+  watchByFilter<Dbo2 extends Dbo>(
+    collectionRef: CollectionReference<Dbo2>,
+    queryArgs?: IQueryArgs,
+  ): Observable<INavContext<Brief, Dbo2>[]> {
+    return this.watchSnapshotsByFilter(collectionRef, queryArgs).pipe(
+      map((querySnapshot) => {
+        return querySnapshot.docs.map(this.docSnapshotToContext.bind(this));
+      }),
+    );
+  }
+
+  docSnapshotsToContext<Dbo2 extends Dbo>(
+    docSnapshots: DocumentSnapshot<Dbo2>[],
+  ): INavContext<Brief, Dbo2>[] {
+    return docSnapshots.map((doc) => {
+      return this.docSnapshotToContext(doc);
+    });
+  }
+
+  docSnapshotToContext<Dbo2 extends Dbo>(
+    doc: DocumentSnapshot<Dbo2>,
+  ): INavContext<Brief, Dbo2> {
+    const { id } = doc;
+    const dto: Dbo2 | undefined = doc.data();
+    const brief = dto && this.dto2brief(id, dto);
+    return {
+      id,
+      dto,
+      brief,
+    } as unknown as INavContext<Brief, Dbo2>; // TODO: try to remove this cast
+  }
+}
+
+export function docSnapshotToDto<Brief, Dbo extends Brief>(
+  id: string,
+  dto2brief: (id: string, dto: Dbo) => Brief,
+  docSnapshot: DocumentSnapshot<Dbo>,
+): INavContext<Brief, Dbo> {
+  if (!docSnapshot.exists) {
+    return { id, brief: null, dbo: null };
+  }
+  const dto: Dbo | undefined = docSnapshot.data();
+  return { id, dbo: dto, brief: dto ? dto2brief(id, dto) : undefined };
+}

package/src/test-setup.ts

@@ -0,0 +1,3 @@
+import { setupTestEnvironment } from '@sneat/core/testing';
+
+setupTestEnvironment();

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.angular.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.lib.base.json",
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/test-setup.ts",
+    "src/lib/testing/**/*"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {}
+}

package/tsconfig.spec.json

@@ -0,0 +1,31 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ],
+  "files": [
+    "src/test-setup.ts"
+  ]
+}

package/vite.config.mts

@@ -0,0 +1,10 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vitest/config';
+import { createBaseViteConfig } from '../../vite.config.base';
+
+export default defineConfig(() =>
+	createBaseViteConfig({
+		dirname: __dirname,
+		name: 'api',
+	}),
+);