@sneat/space-services 0.1.3 → 0.1.4

package/src/lib/services/space-context.service.ts

@@ -1,45 +0,0 @@
-import { Injectable } from '@angular/core';
-import { ParamMap } from '@angular/router';
-import { distinctUntilChanged, Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { ISpaceContext } from '@sneat/space-models';
-import { SpaceType } from '@sneat/core';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class SpaceContextService {
-  // public trackUrl(
-  // 	route: ActivatedRoute,
-  // 	paramName: string,
-  // ): Observable<ISpaceContext | undefined> {
-  // 	return route.paramMap.pipe(
-  // 		map(params => {
-  // 			const id = params.get('spaceID') || undefined;
-  // 			const spaceContext: ISpaceContext | undefined = id ? { id } : undefined;
-  // 			return spaceContext;
-  // 		}),
-  // 	);
-  // }
-}
-
-export function trackSpaceIdAndTypeFromRouteParameter(
-  paramMap$: Observable<ParamMap>,
-): Observable<ISpaceContext | undefined> {
-  return paramMap$.pipe(
-    map((params) => {
-      const id = params.get('spaceID'),
-        type = params.get('spaceType') as SpaceType;
-      // console.log('trackSpaceIdAndTypeFromRouteParameter', params, id, type);
-      const spaceContext: ISpaceContext | undefined = id
-        ? { id: id, type: type || undefined }
-        : undefined;
-      // console.log('trackSpaceIdAndTypeFromRouteParameter() => spaceContext:', spaceContext)
-      return spaceContext;
-    }),
-    distinctUntilChanged(
-      (previous, current) =>
-        previous?.id === current?.id && previous?.type == current?.type,
-    ),
-  );
-}

package/src/lib/services/space-item.service.spec.ts

@@ -1,179 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { Injector } from '@angular/core';
-import { Firestore, collection } from '@angular/fire/firestore';
-import { SneatApiService } from '@sneat/api';
-import { firstValueFrom, of } from 'rxjs';
-import {
-  GlobalSpaceItemService,
-  ModuleSpaceItemService,
-} from './space-item.service';
-
-// Mock collection function
-vi.mock('@angular/fire/firestore', async () => {
-  const actual = await vi.importActual('@angular/fire/firestore');
-  return {
-    ...actual,
-    collection: vi.fn(() => ({ id: 'mock-collection' })),
-  };
-});
-
-describe('GlobalSpaceItemService', () => {
-  let service: GlobalSpaceItemService<unknown, unknown>;
-  let mockInjector: Injector;
-  let mockFirestore: Firestore;
-  let mockSneatApiService: SneatApiService;
-
-  beforeEach(() => {
-    mockInjector = TestBed.inject(Injector);
-    mockFirestore = {
-      type: 'Firestore',
-      toJSON: () => ({}),
-    } as unknown as Firestore;
-    mockSneatApiService = {
-      post: vi.fn(),
-      delete: vi.fn(),
-    } as unknown as SneatApiService;
-
-    service = new GlobalSpaceItemService(
-      mockInjector,
-      'test-collection',
-      mockFirestore,
-      mockSneatApiService,
-    );
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should throw error if collectionName is not provided', () => {
-    expect(() => {
-      new GlobalSpaceItemService(
-        mockInjector,
-        '',
-        mockFirestore,
-        mockSneatApiService,
-      );
-    }).toThrow('collectionName is required');
-  });
-
-  it('should have correct collection name', () => {
-    expect(service.collectionName).toBe('test-collection');
-  });
-
-  it('should delete space item', async () => {
-    const mockResponse = { success: true };
-    vi.spyOn(mockSneatApiService, 'delete').mockReturnValue(of(mockResponse));
-
-    const request = { spaceID: 'space1' };
-    const response = await firstValueFrom(
-      service.deleteSpaceItem('test-endpoint', request),
-    );
-    expect(response).toEqual(mockResponse);
-    expect(mockSneatApiService.delete).toHaveBeenCalledWith(
-      'test-endpoint',
-      undefined,
-      request,
-    );
-  });
-
-  it('should create space item', async () => {
-    const mockResponse = {
-      id: 'item1',
-      dbo: { name: 'Test Item' },
-    };
-    vi.spyOn(mockSneatApiService, 'post').mockReturnValue(of(mockResponse));
-
-    const spaceRef = { id: 'space1', type: 'team' as const };
-    const request = { spaceID: 'space1', data: { name: 'Test' } };
-
-    const item = await firstValueFrom(
-      service.createSpaceItem('create-endpoint', spaceRef, request),
-    );
-    expect(item.id).toBe('item1');
-    expect(item.space).toEqual(spaceRef);
-    expect(item.dbo).toEqual(mockResponse.dbo);
-  });
-
-  it('should throw error if create response is empty', async () => {
-    vi.spyOn(mockSneatApiService, 'post').mockReturnValue(of(null as unknown));
-
-    const spaceRef = { id: 'space1', type: 'team' as const };
-    const request = { spaceID: 'space1' };
-
-    await expect(
-      firstValueFrom(
-        service.createSpaceItem('create-endpoint', spaceRef, request),
-      ),
-    ).rejects.toThrow('create team item response is empty');
-  });
-
-  it('should throw error if create response has no ID', async () => {
-    const mockResponse = { dbo: { name: 'Test' } };
-    vi.spyOn(mockSneatApiService, 'post').mockReturnValue(of(mockResponse));
-
-    const spaceRef = { id: 'space1', type: 'team' as const };
-    const request = { spaceID: 'space1' };
-
-    await expect(
-      firstValueFrom(
-        service.createSpaceItem('create-endpoint', spaceRef, request),
-      ),
-    ).rejects.toThrow('create team item response have no ID');
-  });
-});
-
-describe('ModuleSpaceItemService', () => {
-  let service: ModuleSpaceItemService<unknown, unknown>;
-  let mockInjector: Injector;
-  let mockFirestore: Firestore;
-  let mockSneatApiService: SneatApiService;
-
-  beforeEach(() => {
-    mockInjector = TestBed.inject(Injector);
-    mockFirestore = {
-      type: 'Firestore',
-      toJSON: () => ({}),
-    } as unknown as Firestore;
-    mockSneatApiService = {
-      post: vi.fn(),
-    } as unknown as SneatApiService;
-
-    vi.mocked(collection).mockReturnValue({ id: 'spaces' } as unknown);
-
-    service = new ModuleSpaceItemService(
-      mockInjector,
-      'test-module',
-      'items',
-      mockFirestore,
-      mockSneatApiService,
-    );
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should throw error if moduleID is not provided', () => {
-    expect(() => {
-      new ModuleSpaceItemService(
-        mockInjector,
-        '',
-        'items',
-        mockFirestore,
-        mockSneatApiService,
-      );
-    }).toThrow('moduleID is required');
-  });
-
-  it('should have correct moduleID', () => {
-    expect(service.moduleID).toBe('test-module');
-  });
-
-  it('should throw error when creating collection ref without spaceID', () => {
-    expect(() => {
-      // Access protected method via unknown cast for testing
-      (service as unknown as { collectionRef: (spaceID: string) => unknown }).collectionRef('');
-    }).toThrow('spaceID is required');
-  });
-});

package/src/lib/services/space-item.service.ts

@@ -1,308 +0,0 @@
-import { Injector, runInInjectionContext } from '@angular/core';
-import {
-  Firestore as AngularFirestore,
-  doc,
-  collection,
-  CollectionReference,
-} from '@angular/fire/firestore';
-import { QuerySnapshot } from '@firebase/firestore-types';
-import { IQueryArgs, SneatApiService, SneatFirestoreService } from '@sneat/api';
-import {
-  IIdAndBriefAndDbo,
-  IIdAndOptionalBriefAndOptionalDbo,
-  ISpaceItemWithBriefAndDbo,
-  ISpaceRef,
-} from '@sneat/core';
-import { ISpaceDbo } from '@sneat/dto';
-import { ISpaceItemNavContext, ISpaceRequest } from '@sneat/space-models';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-
-type ICreateSpaceItemResponse<
-  Brief,
-  Dbo extends Brief,
-> = ISpaceItemWithBriefAndDbo<Brief, Dbo>;
-
-abstract class SpaceItemBaseService<Brief, Dbo extends Brief> {
-  protected readonly sfs: SneatFirestoreService<Brief, Dbo>;
-
-  protected constructor(
-    protected readonly injector: Injector,
-    public readonly collectionName: string,
-    public readonly afs: AngularFirestore,
-    public readonly sneatApiService: SneatApiService,
-  ) {
-    if (!this.collectionName) {
-      throw new Error('collectionName is required');
-    }
-    this.sfs = new SneatFirestoreService<Brief, Dbo>(this.injector);
-  }
-
-  private _collectionRef?: CollectionReference<Dbo>;
-
-  protected abstract collectionRef<Dbo2 extends Dbo>(
-    spaceID: string,
-  ): CollectionReference<Dbo2>;
-
-  public watchSpaceItemByIdWithSpaceRef<Dbo2 extends Dbo>(
-    space: ISpaceRef,
-    itemID: string,
-  ): Observable<ISpaceItemNavContext<Brief, Dbo2>> {
-
-    if (!space.id) {
-      throw new Error('spaceID is required');
-    }
-    let collectionRef: CollectionReference<Dbo2>;
-    if (this._collectionRef?.id == space.id) {
-      collectionRef = this._collectionRef as CollectionReference<Dbo2>;
-    } else {
-      collectionRef = this.collectionRef<Dbo2>(space.id);
-      this._collectionRef = collectionRef;
-    }
-    return runInInjectionContext(this.injector, () =>
-      this.sfs
-        .watchByID(collectionRef, itemID)
-        .pipe(map((o) => ({ space, ...o }))),
-    );
-  }
-
-  protected queryItems<Dbo2 extends Dbo>(
-    collectionRef: CollectionReference<Dbo2>,
-    queryArgs?: IQueryArgs,
-  ): Observable<IIdAndBriefAndDbo<Brief, Dbo2>[]> {
-    const $querySnapshot = this.sfs.watchSnapshotsByFilter<Dbo2>(
-      collectionRef,
-      queryArgs,
-    );
-    return $querySnapshot.pipe(
-      map((querySnapshot) => {
-        return this.mapQueryItem<Dbo2>(
-          querySnapshot as unknown as QuerySnapshot<Dbo2>,
-        );
-      }),
-    );
-  }
-
-  protected mapQueryItem<Dbo2 extends Dbo>(
-    querySnapshot: QuerySnapshot<Dbo2>,
-  ): IIdAndBriefAndDbo<Brief, Dbo2>[] {
-    return querySnapshot.docs.map((docSnapshot) => {
-      const dto = docSnapshot.data();
-      const { id } = docSnapshot;
-      const brief: Brief = dto;
-      return { id, brief, dbo: dto };
-    });
-  }
-
-  public deleteSpaceItem<Response>(
-    endpoint: string,
-    request: ISpaceRequest,
-  ): Observable<Response> {
-    return this.sneatApiService.delete<Response>(endpoint, undefined, request);
-  }
-
-  public createSpaceItem<Brief, Dbo extends Brief>(
-    endpoint: string,
-    spaceRef: ISpaceRef,
-    request: ISpaceRequest,
-  ): Observable<ISpaceItemWithBriefAndDbo<Brief, Dbo>> {
-    return this.sneatApiService
-      .post<ICreateSpaceItemResponse<Brief, Dbo>>(endpoint, request)
-      .pipe(
-        map((response) => {
-          if (!response) {
-            throw new Error('create team item response is empty');
-          }
-          if (!response.id) {
-            throw new Error('create team item response have no ID');
-          }
-          const item: ISpaceItemWithBriefAndDbo<Brief, Dbo> = {
-            space: spaceRef,
-            id: response.id,
-            dbo: response.dbo,
-            brief: { id: response.id, ...response.dbo } as unknown as Brief,
-          };
-          return item;
-        }),
-      );
-  }
-}
-
-// At the moment reserved to `happenings` only
-export class GlobalSpaceItemService<
-  Brief,
-  Dbo extends Brief,
-> extends SpaceItemBaseService<Brief, Dbo> {
-  protected override collectionRef<
-    Dbo2 extends Dbo,
-  >(): CollectionReference<Dbo2> {
-    return runInInjectionContext(
-      this.injector,
-      () =>
-        collection(this.afs, this.collectionName) as CollectionReference<Dbo2>,
-    );
-  }
-
-  public watchGlobalItems<Dbo2 extends Dbo>(
-    queryArgs: IQueryArgs,
-  ): Observable<IIdAndBriefAndDbo<Brief, Dbo2>[]> {
-    const collectionRef = this.collectionRef<Dbo2>();
-    return this.queryItems<Dbo2>(collectionRef, queryArgs);
-  }
-
-  public watchGlobalSpaceItemsWithSpaceRef<Dbo2 extends Dbo>(
-    space: ISpaceRef,
-    queryArgs: IQueryArgs,
-  ): Observable<ISpaceItemWithBriefAndDbo<Brief, Dbo2>[]> {
-    return this.watchGlobalSpaceItems<Dbo2>(space.id, queryArgs).pipe(
-      map((items) => items.map((item) => ({ ...item, space }))),
-    );
-  }
-
-  public watchGlobalSpaceItems<Dbo2 extends Dbo>(
-    spaceID: string,
-    queryArgs: IQueryArgs,
-  ): Observable<IIdAndBriefAndDbo<Brief, Dbo2>[]> {
-    queryArgs = {
-      ...queryArgs,
-      filter: [
-        ...(queryArgs?.filter || []),
-        { field: 'spaceIDs', operator: '==', value: spaceID },
-      ],
-    };
-    const collectionRef = this.collectionRef<Dbo2>();
-    return this.queryItems<Dbo2>(collectionRef, queryArgs);
-  }
-}
-
-// intentionally not abstract
-export class ModuleSpaceItemService<
-  Brief,
-  Dbo extends Brief,
-> extends SpaceItemBaseService<Brief, Dbo> {
-  protected readonly spacesCollection: CollectionReference<ISpaceDbo>;
-
-  constructor(
-    injector: Injector,
-    public readonly moduleID: string,
-    collectionName: string,
-    afs: AngularFirestore,
-    sneatApiService: SneatApiService,
-  ) {
-    super(injector, collectionName, afs, sneatApiService);
-    if (!moduleID) {
-      throw new Error('moduleID is required');
-    }
-    this.spacesCollection = collection(
-      this.afs,
-      'spaces',
-    ) as CollectionReference<ISpaceDbo>;
-  }
-
-  protected readonly dto2brief = (id: string, dto: Dbo) => ({ id, ...dto });
-
-  // protected teamCollection(spaceID: string): AngularFirestoreCollection<ITeamDto> {
-  // 	return this.afs.collection('spaces');
-  // }
-
-  protected override collectionRef<Dbo2 extends Dbo>(
-    spaceID: string,
-  ): CollectionReference<Dbo2> {
-    if (!spaceID) {
-      throw new Error('spaceID is required');
-    }
-    return runInInjectionContext(
-      this.injector,
-      () =>
-        collection(
-          this.spacesCollection,
-          spaceID,
-          'ext',
-          this.moduleID,
-          this.collectionName,
-        ) as CollectionReference<Dbo2>,
-    );
-  }
-
-  private readonly spaceRef = (id: string) => doc(this.spacesCollection, id);
-
-  public watchModuleSpaceItem<Dbo2 extends Dbo>(
-    space: ISpaceRef,
-    itemID: string,
-  ): Observable<IIdAndOptionalBriefAndOptionalDbo<Brief, Dbo2>> {
-    const collection = this.collectionRef<Dbo2>(space.id);
-    return this.sfs.watchByID<Dbo2>(collection, itemID);
-  }
-
-  public watchModuleSpaceItemsWithSpaceRef<Dbo2 extends Dbo>(
-    space: ISpaceRef,
-    queryArgs?: IQueryArgs,
-  ): Observable<ISpaceItemWithBriefAndDbo<Brief, Dbo2>[]> {
-    return this.watchModuleSpaceItems<Dbo2>(space.id, queryArgs).pipe(
-      map((items) => items.map((item) => ({ ...item, space }))),
-    );
-  }
-
-  public watchModuleSpaceItems<Dbo2 extends Dbo>(
-    spaceID: string,
-    queryArgs?: IQueryArgs,
-  ): Observable<IIdAndBriefAndDbo<Brief, Dbo2>[]> {
-    // filter = [
-    // 	...(filter || []),
-    // 	// { field: 'spaceIDs', operator: '==', value: spaceID },
-    // ];
-    return runInInjectionContext(this.injector, () => {
-      const collectionRef = this.collectionRef<Dbo2>(spaceID);
-      return this.queryItems<Dbo2>(collectionRef, queryArgs);
-    });
-  }
-
-  // private readonly mapItemTeamItemContext = <
-  //   Brief2 extends Brief,
-  //   Dbo2 extends Dto,
-  // >(
-  //   space: ISpaceContext,
-  //   item: IIdAndBrief<Brief2, Dbo2>,
-  // ) => {
-  //   return querySnapshot.docs.map((docSnapshot) => {
-  //     const dto = docSnapshot.data();
-  //     const { id } = docSnapshot;
-  //     const brief: Brief2 = { id, ...dto } as unknown as Brief2;
-  //     const c: ISpaceItemContext<Brief2, Dbo2> = { id, team, dto, brief };
-  //     return c;
-  //   });
-  // };
-
-  // public watchSpaceItems<Brief2 extends Brief, Dbo2 extends Dto>(
-  //   spaceID: string,
-  //   filter?: readonly IFilter[],
-  // ): Observable<IIdAndBriefAndDto<Brief2, Dbo2>[]> {
-  //   console.log('watchSpaceItems()', spaceID, this.collectionName);
-  //   const collectionRef = collection(
-  //     this.teamRef(spaceID),
-  //     this.collectionName,
-  //   );
-  //   const querySnapshots = this.sfs.watchSnapshotsByFilter<Dbo2>(
-  //     collectionRef as CollectionReference<Dbo2>,
-  //     filter || [],
-  //   );
-  //   return querySnapshots.pipe(
-  //     map(a => this.mapQueryItem(a)),
-  //   );
-  // }
-
-  // public watchTeamItemsWithSpaceContext<Brief2 extends Brief, Dbo2 extends Dto>(
-  //   space: ISpaceRef,
-  //   filter?: readonly IFilter[],
-  // ): Observable<ISpaceItemContext<Brief2, Dbo2>[]> {
-  //   const querySnapshots = this.watchTeamItems(space.id, filter);
-  //   return querySnapshots.pipe(
-  //     map((querySnapshot) =>
-  //       this.mapItemSpaceItemContext(
-  //         team,
-  //         querySnapshot as unknown as QuerySnapshot<Dbo2>,
-  //       ),
-  //     ),
-  //   );
-  // }
-}

package/src/lib/services/space-module.service.spec.ts

@@ -1,48 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { Injector } from '@angular/core';
-import { Firestore, collection } from '@angular/fire/firestore';
-import { SpaceModuleService } from './space-module.service';
-
-// Mock collection function
-vi.mock('@angular/fire/firestore', async () => {
-  const actual = await vi.importActual('@angular/fire/firestore');
-  return {
-    ...actual,
-    collection: vi.fn(() => ({ id: 'mock-collection' })),
-  };
-});
-
-class TestSpaceModuleService extends SpaceModuleService<{ title: string }> {
-  constructor(injector: Injector, afs: Firestore) {
-    super(injector, 'test-module', afs);
-  }
-}
-
-describe('SpaceModuleService', () => {
-  let service: TestSpaceModuleService;
-  let mockFirestore: Firestore;
-
-  beforeEach(() => {
-    mockFirestore = {
-      type: 'Firestore',
-      toJSON: () => ({}),
-    } as unknown as Firestore;
-
-    vi.mocked(collection).mockReturnValue({ id: 'spaces' } as unknown);
-
-    const injector = TestBed.inject(Injector);
-    service = new TestSpaceModuleService(injector, mockFirestore);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should have correct moduleID', () => {
-    expect(service.moduleID).toBe('test-module');
-  });
-
-  it('should have correct collectionName', () => {
-    expect(service.collectionName).toBe('ext');
-  });
-});

package/src/lib/services/space-module.service.ts

@@ -1,69 +0,0 @@
-import { Injector, runInInjectionContext } from '@angular/core';
-import {
-  collection,
-  CollectionReference,
-  Firestore as AngularFirestore,
-} from '@angular/fire/firestore';
-import { SneatApiService } from '@sneat/api';
-import { IIdAndBrief, IIdAndOptionalDbo } from '@sneat/core';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { ModuleSpaceItemService } from './space-item.service';
-
-// import firebase from "firebase/compat";
-// import Item = firebase.analytics.Item;
-
-export abstract class SpaceModuleService<Dbo> extends ModuleSpaceItemService<
-  Dbo,
-  Dbo
-> {
-  // protected readonly sfs: SneatFirestoreService<Brief, Dto>;
-  protected constructor(
-    injector: Injector,
-    moduleID: string,
-    afs: AngularFirestore,
-  ) {
-    // this.sfs = new SneatFirestoreService<Brief, Dto>(collectionName, afs);
-    super(
-      injector,
-      moduleID,
-      'ext',
-      afs,
-      undefined as unknown as SneatApiService,
-    );
-  }
-
-  watchSpaceModuleRecord(spaceID: string): Observable<IIdAndOptionalDbo<Dbo>> {
-    return runInInjectionContext(this.injector, () => {
-      const collectionRef = collection(
-        this.spacesCollection,
-        spaceID,
-        'ext',
-      ) as CollectionReference<Dbo>;
-      // if (this.moduleID === 'trackus') {
-      // 	return throwError(() => new Error('test error'));
-      // }
-      return this.sfs
-        .watchByID<Dbo>(collectionRef, this.moduleID)
-        .pipe
-        // tap((o) => console.log(`${logPrefix} =>`, o)),
-        ();
-    });
-  }
-
-  watchBriefs<ItemBrief>(
-    spaceID: string,
-    getBriefs: (dto?: Dbo) => Readonly<Record<string, ItemBrief>>,
-  ): Observable<IIdAndBrief<ItemBrief>[]> {
-    const o = this.watchSpaceModuleRecord(spaceID);
-    return o.pipe(
-      map((teamModule) => {
-        const briefs = getBriefs(teamModule?.dbo || undefined);
-        const items: IIdAndBrief<ItemBrief>[] = briefs
-          ? Object.keys(briefs).map((id) => ({ id, brief: briefs[id] }))
-          : [];
-        return items;
-      }),
-    );
-  }
-}

package/src/lib/services/space-nav-service.service.spec.ts

@@ -1,32 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { provideRouter } from '@angular/router';
-import { SpaceNavService } from './space-nav.service';
-import { ErrorLogger } from '@sneat/core';
-import { AnalyticsService } from '@sneat/core';
-import { NavController } from '@ionic/angular';
-
-describe('SpaceNavService', () => {
-  beforeEach(() =>
-    TestBed.configureTestingModule({
-      providers: [
-        SpaceNavService,
-        provideRouter([]),
-        { provide: ErrorLogger, useValue: { logError: vi.fn() } },
-        { provide: AnalyticsService, useValue: { logEvent: vi.fn() } },
-        {
-          provide: NavController,
-          useValue: {
-            navigateRoot: vi.fn().mockResolvedValue(true),
-            navigateForward: vi.fn().mockResolvedValue(true),
-            navigateBack: vi.fn().mockResolvedValue(true),
-          },
-        },
-      ],
-    }),
-  );
-
-  it('should be created', () => {
-    const service: SpaceNavService = TestBed.inject(SpaceNavService);
-    expect(service).toBeTruthy();
-  });
-});