@sneat/api 0.1.2 → 0.1.4

package/src/lib/sneat-api.module.ts

@@ -1,10 +0,0 @@
-import { NgModule } from '@angular/core';
-import { HttpClientModule } from '@angular/common/http';
-
-@NgModule({
-  imports: [HttpClientModule],
-  providers: [
-    // SneatTeamApiService,
-  ],
-})
-export class SneatApiModule {}

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

@@ -1,465 +0,0 @@
-import { TestBed, fakeAsync, tick } from '@angular/core/testing';
-import { Injector } from '@angular/core';
-import {
-  CollectionReference,
-  DocumentReference,
-  DocumentSnapshot,
-  QuerySnapshot,
-} from '@angular/fire/firestore';
-import { Subject } from 'rxjs';
-import {
-  SneatFirestoreService,
-  docSnapshotToDto,
-  IQueryArgs,
-} from './sneat-firestore.service';
-
-// Mock Firebase functions
-const mockDoc = vi.fn();
-const mockGetDoc = vi.fn();
-const mockOnSnapshot = vi.fn();
-const mockQuery = vi.fn();
-const mockWhere = vi.fn();
-const mockLimit = vi.fn();
-
-vi.mock('@angular/fire/firestore', () => ({
-  doc: (...args: unknown[]) => mockDoc(...args),
-  getDoc: (...args: unknown[]) => mockGetDoc(...args),
-  onSnapshot: (...args: unknown[]) => mockOnSnapshot(...args),
-  query: (...args: unknown[]) => mockQuery(...args),
-  where: (...args: unknown[]) => mockWhere(...args),
-  limit: (...args: unknown[]) => mockLimit(...args),
-}));
-
-interface TestBrief {
-  id: string;
-  name: string;
-}
-
-interface TestDbo extends TestBrief {
-  email: string;
-}
-
-describe('SneatFirestoreService', () => {
-  let service: SneatFirestoreService<TestBrief, TestDbo>;
-  let injector: Injector;
-  let dto2brief: (id: string, dto: TestDbo) => TestBrief;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [],
-    });
-    injector = TestBed.inject(Injector);
-    dto2brief = (id: string, dto: TestDbo) => ({ id, name: dto.name });
-
-    // Clear all mocks
-    mockDoc.mockClear();
-    mockGetDoc.mockClear();
-    mockOnSnapshot.mockClear();
-    mockQuery.mockClear();
-    mockWhere.mockClear();
-    mockLimit.mockClear();
-  });
-
-  it('should be created', () => {
-    service = new SneatFirestoreService(injector, dto2brief);
-    expect(service).toBeTruthy();
-  });
-
-  it('should use default dto2brief if not provided', () => {
-    // The constructor has a default value for dto2brief, so it will never throw
-    // when undefined is passed - it will just use the default
-    service = new SneatFirestoreService(injector);
-    expect(service).toBeTruthy();
-
-    // Test that the default dto2brief works correctly
-    const mockSnapshot = {
-      id: 'doc1',
-      exists: () => true,
-      data: () =>
-        ({ id: 'doc1', name: 'Test', email: 'test1@example.com' }) as TestDbo,
-    } as unknown as DocumentSnapshot<TestDbo>;
-
-    const result = service.docSnapshotToContext(mockSnapshot);
-    expect(result.id).toBe('doc1');
-    expect(result.dto).toBeDefined();
-    expect((result.brief as TestBrief).id).toBe('doc1');
-  });
-
-  it('should throw error if dto2brief is explicitly null', () => {
-    // Use type assertion to bypass TypeScript and test runtime behavior
-    expect(() => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      new SneatFirestoreService(injector, null as any);
-    }).toThrow('dto2brief is required');
-  });
-
-  describe('watchByID', () => {
-    it('should watch document by ID', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockCollection = {
-        path: 'test-collection',
-      } as CollectionReference<TestDbo>;
-      const mockDocRef = {
-        id: 'doc1',
-        path: 'test-collection/doc1',
-      } as DocumentReference<TestDbo>;
-      const mockSnapshot = {
-        exists: () => true,
-        data: () => ({ id: 'doc1', name: 'Test', email: 'test1@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      mockDoc.mockReturnValue(mockDocRef);
-      mockOnSnapshot.mockImplementation((docRef, next) => {
-        // Simulate snapshot
-        setTimeout(() => next(mockSnapshot), 0);
-      });
-
-      const result$ = service.watchByID(mockCollection, 'doc1');
-      let result: unknown;
-      result$.subscribe((data) => {
-        result = data;
-      });
-
-      tick();
-
-      expect(mockDoc).toHaveBeenCalledWith(mockCollection, 'doc1');
-      expect(result).toEqual({
-        id: 'doc1',
-        dbo: { id: 'doc1', name: 'Test', email: 'test1@example.com' },
-        brief: { id: 'doc1', name: 'Test' },
-      });
-    }));
-  });
-
-  describe('watchByDocRef', () => {
-    it('should watch document by reference', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockDocRef = {
-        id: 'doc2',
-        path: 'test-collection/doc2',
-      } as DocumentReference<TestDbo>;
-      const mockSnapshot = {
-        exists: () => true,
-        data: () => ({ id: 'doc2', name: 'Test2', email: 'test2@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      mockOnSnapshot.mockImplementation((docRef, next) => {
-        setTimeout(() => next(mockSnapshot), 0);
-      });
-
-      const result$ = service.watchByDocRef(mockDocRef);
-      let result: unknown;
-      result$.subscribe((data) => {
-        result = data;
-      });
-
-      tick();
-
-      expect(mockOnSnapshot).toHaveBeenCalled();
-      expect(result).toEqual({
-        id: 'doc2',
-        dbo: { id: 'doc2', name: 'Test2', email: 'test2@example.com' },
-        brief: { id: 'doc2', name: 'Test2' },
-      });
-    }));
-
-    it('should handle errors', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockDocRef = {
-        id: 'doc3',
-        path: 'test-collection/doc3',
-      } as DocumentReference<TestDbo>;
-      const testError = new Error('Firestore error');
-
-      mockOnSnapshot.mockImplementation((docRef, next, error) => {
-        setTimeout(() => error(testError), 0);
-      });
-
-      const result$ = service.watchByDocRef(mockDocRef);
-      let caughtError: unknown;
-      result$.subscribe({
-        error: (err) => {
-          caughtError = err;
-        },
-      });
-
-      tick();
-
-      expect(caughtError).toBe(testError);
-    }));
-
-    it('should handle complete', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockDocRef = {
-        id: 'doc5',
-        path: 'test-collection/doc5',
-      } as DocumentReference<TestDbo>;
-
-      mockOnSnapshot.mockImplementation((docRef, next, error, complete) => {
-        setTimeout(() => complete(), 0);
-      });
-
-      const result$ = service.watchByDocRef(mockDocRef);
-      let completed = false;
-      result$.subscribe({
-        complete: () => {
-          completed = true;
-        },
-      });
-
-      tick();
-
-      expect(completed).toBe(true);
-    }));
-  });
-
-  describe('getByDocRef', () => {
-    it('should get document by reference', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockDocRef = {
-        id: 'doc4',
-        path: 'test-collection/doc4',
-      } as DocumentReference<TestDbo>;
-      const mockSnapshot = {
-        exists: () => true,
-        data: () => ({ id: 'doc4', name: 'Test4', email: 'test4@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      mockGetDoc.mockResolvedValue(mockSnapshot);
-
-      const result$ = service.getByDocRef(mockDocRef);
-      let result: unknown;
-      result$.subscribe((data) => {
-        result = data;
-      });
-
-      tick();
-
-      expect(mockGetDoc).toHaveBeenCalledWith(mockDocRef);
-      expect(result).toEqual({
-        id: 'doc4',
-        dbo: { id: 'doc4', name: 'Test4', email: 'test4@example.com' },
-        brief: { id: 'doc4', name: 'Test4' },
-      });
-    }));
-  });
-
-  describe('watchSnapshotsByFilter', () => {
-    it('should watch documents by filter', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockCollection = {
-        path: 'test-collection',
-      } as CollectionReference<TestDbo>;
-      const queryArgs: IQueryArgs = {
-        filter: [{ field: 'name', operator: '==', value: 'Test' }],
-      };
-      const mockQueryObj = {};
-
-      mockWhere.mockReturnValue({});
-      mockQuery.mockReturnValue(mockQueryObj);
-      mockOnSnapshot.mockImplementation(() => {
-        // Just return to simulate subscription
-      });
-
-      const result$ = service.watchSnapshotsByFilter(mockCollection, queryArgs);
-
-      expect(mockQuery).toHaveBeenCalled();
-      expect(mockWhere).toHaveBeenCalledWith('name', '==', 'Test');
-      expect(result$).toBeTruthy();
-    });
-
-    it('should use array-contains for fields ending with IDs', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockCollection = {
-        path: 'test-collection',
-      } as CollectionReference<TestDbo>;
-      const queryArgs: IQueryArgs = {
-        filter: [{ field: 'userIDs', operator: '==', value: 'user1' }],
-      };
-
-      mockWhere.mockReturnValue({});
-      mockQuery.mockReturnValue({});
-      mockOnSnapshot.mockImplementation(() => {
-        // Just return
-      });
-
-      service.watchSnapshotsByFilter(mockCollection, queryArgs);
-
-      expect(mockWhere).toHaveBeenCalledWith(
-        'userIDs',
-        'array-contains',
-        'user1',
-      );
-    });
-
-    it('should apply limit when specified', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockCollection = {
-        path: 'test-collection',
-      } as CollectionReference<TestDbo>;
-      const queryArgs: IQueryArgs = {
-        limit: 10,
-      };
-
-      mockLimit.mockReturnValue({});
-      mockQuery.mockReturnValue({});
-      mockOnSnapshot.mockImplementation(() => {
-        // Just return
-      });
-
-      service.watchSnapshotsByFilter(mockCollection, queryArgs);
-
-      expect(mockLimit).toHaveBeenCalledWith(10);
-    });
-  });
-
-  describe('watchByFilter', () => {
-    it('should watch and transform documents by filter', fakeAsync(() => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockCollection = {
-        path: 'test-collection',
-      } as CollectionReference<TestDbo>;
-      const mockSnapshot1 = {
-        id: 'doc1',
-        exists: () => true,
-        data: () => ({ id: 'doc1', name: 'Test1', email: 'test1@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-      const mockQuerySnapshot = {
-        docs: [mockSnapshot1],
-      } as QuerySnapshot<TestDbo>;
-
-      mockQuery.mockReturnValue({});
-      mockOnSnapshot.mockImplementation(
-        (q, subj: Subject<QuerySnapshot<TestDbo>>) => {
-          setTimeout(() => subj.next(mockQuerySnapshot), 0);
-        },
-      );
-
-      const result$ = service.watchByFilter(mockCollection);
-      let result: unknown;
-      result$.subscribe((data) => {
-        result = data;
-      });
-
-      tick();
-
-      expect(result).toEqual([
-        {
-          id: 'doc1',
-          dto: { id: 'doc1', name: 'Test1', email: 'test1@example.com' },
-          brief: { id: 'doc1', name: 'Test1' },
-        },
-      ]);
-    }));
-  });
-
-  describe('docSnapshotsToContext', () => {
-    it('should transform array of snapshots to contexts', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockSnapshot1 = {
-        id: 'doc1',
-        exists: () => true,
-        data: () => ({ id: 'doc1', name: 'Test1', email: 'test1@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-      const mockSnapshot2 = {
-        id: 'doc2',
-        exists: () => true,
-        data: () => ({ id: 'doc2', name: 'Test2', email: 'test2@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = service.docSnapshotsToContext([
-        mockSnapshot1,
-        mockSnapshot2,
-      ]);
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({
-        id: 'doc1',
-        dto: { id: 'doc1', name: 'Test1', email: 'test1@example.com' },
-        brief: { id: 'doc1', name: 'Test1' },
-      });
-    });
-  });
-
-  describe('docSnapshotToContext', () => {
-    it('should transform snapshot to context', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockSnapshot = {
-        id: 'doc1',
-        exists: () => true,
-        data: () => ({ id: 'doc1', name: 'Test1', email: 'test1@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = service.docSnapshotToContext(mockSnapshot);
-
-      expect(result).toEqual({
-        id: 'doc1',
-        dto: { id: 'doc1', name: 'Test1', email: 'test1@example.com' },
-        brief: { id: 'doc1', name: 'Test1' },
-      });
-    });
-
-    it('should handle snapshot with no data', () => {
-      service = new SneatFirestoreService(injector, dto2brief);
-      const mockSnapshot = {
-        id: 'doc1',
-        exists: () => true,
-        data: () => undefined,
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = service.docSnapshotToContext(mockSnapshot);
-
-      expect(result).toEqual({
-        id: 'doc1',
-        dto: undefined,
-        brief: undefined,
-      });
-    });
-  });
-
-  describe('docSnapshotToDto', () => {
-    it('should convert existing snapshot to dto', () => {
-      const mockSnapshot = {
-        exists: true,
-        data: () => ({ id: 'doc1', name: 'Test1', email: 'test1@example.com' }),
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = docSnapshotToDto('doc1', dto2brief, mockSnapshot);
-
-      expect(result).toEqual({
-        id: 'doc1',
-        dbo: { id: 'doc1', name: 'Test1', email: 'test1@example.com' },
-        brief: { id: 'doc1', name: 'Test1' },
-      });
-    });
-
-    it('should handle non-existing snapshot', () => {
-      const mockSnapshot = {
-        exists: false,
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = docSnapshotToDto('doc1', dto2brief, mockSnapshot);
-
-      expect(result).toEqual({
-        id: 'doc1',
-        brief: null,
-        dbo: null,
-      });
-    });
-
-    it('should handle snapshot with undefined data', () => {
-      const mockSnapshot = {
-        exists: true,
-        data: () => undefined,
-      } as unknown as DocumentSnapshot<TestDbo>;
-
-      const result = docSnapshotToDto('doc1', dto2brief, mockSnapshot);
-
-      expect(result).toEqual({
-        id: 'doc1',
-        dbo: undefined,
-        brief: undefined,
-      });
-    });
-  });
-});

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

@@ -1,157 +0,0 @@
-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

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

package/tsconfig.json

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

package/tsconfig.lib.json

@@ -1,19 +0,0 @@
-{
-  "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

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