@sneat/space-services 0.1.0

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

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

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

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

@@ -0,0 +1,32 @@
+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();
+  });
+});

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

@@ -0,0 +1,175 @@
+import { Injectable, inject } from '@angular/core';
+import { Params } from '@angular/router';
+import { NavController } from '@ionic/angular';
+import { AnalyticsService, IAnalyticsService, IIdAndBrief, ISpaceRef } from '@sneat/core';
+import { IMemberBrief } from '@sneat/contactus-core';
+
+type NavigationOptions = NonNullable<
+  Parameters<NavController['navigateRoot']>[1]
+>;
+import { IRecord } from '@sneat/data';
+import { ISpaceDbo } from '@sneat/dto';
+import { ErrorLogger, IErrorLogger } from '@sneat/core';
+import { ISpaceContext } from '@sneat/space-models';
+
+export type ScrumPageTab = 'team' | 'my' | 'risks' | 'qna';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SpaceNavService {
+  private readonly errorLogger = inject<IErrorLogger>(ErrorLogger);
+  private readonly navController = inject(NavController);
+  private readonly analyticsService =
+    inject<IAnalyticsService>(AnalyticsService);
+
+  public navigateToSpaces(animationDirection?: 'forward' | 'back'): void {
+    this.analyticsService.logEvent('navigateToTeams');
+    this.navController
+      .navigateRoot('spaces', { animationDirection })
+      .catch((err) =>
+        this.errorLogger.logError(err, 'Failed to navigate to teams page'),
+      );
+  }
+
+  public navigateToLogin(options?: {
+    returnTo?: string;
+    queryParams?: Params;
+    // fragment?: string;
+  }): void {
+
+    // Do not log `returnTo` as it might holds sensitive info
+    this.analyticsService.logEvent('navigateToLogin');
+
+    const navOptions: NavigationOptions = {
+      queryParams: options?.queryParams,
+      animationDirection: 'back',
+    };
+    if (options?.returnTo) {
+      navOptions.fragment = options.returnTo;
+    }
+    this.navController
+      .navigateRoot('login', navOptions)
+      .catch((err) =>
+        this.errorLogger.logError(err, 'Failed to navigate to login page'),
+      );
+  }
+
+  public navigateToUserProfile(): void {
+    this.analyticsService.logEvent('navigateToUserProfile');
+    this.navController
+      .navigateRoot('user-profile')
+      .catch((err) =>
+        this.errorLogger.logError(err, 'Failed to naviage to user profile'),
+      );
+  }
+
+  public navigateToSpace(
+    space: ISpaceContext,
+    animationDirection?: 'forward' | 'back',
+  ): Promise<boolean> {
+    this.analyticsService.logEvent('navigateToSpace', { spaceID: space.id });
+    const url = `space/${space.type || space.brief?.type}/${space.id}`;
+    return new Promise<boolean>((resolve, reject) => {
+      this.navController
+        .navigateRoot(url, {
+          state: { space },
+          animationDirection,
+        })
+        .then(resolve)
+        .catch((err) => {
+          this.errorLogger.logError(
+            err,
+            'Failed to navigate to team overview page with URL: ' + url,
+          );
+          reject(err);
+        });
+    });
+  }
+
+  public navigateToMember(
+    space: ISpaceContext,
+    memberInfo: IIdAndBrief<IMemberBrief>,
+  ): void {
+    const id = `${space.id}:${memberInfo.id}`;
+    this.navForward(
+      this.navController,
+      'member',
+      {
+        queryParams: { id },
+        state: { space, memberInfo },
+      },
+    );
+  }
+
+  public navigateToAddMetric = (
+    navController: NavController,
+    team: IRecord<ISpaceDbo>,
+  ): void =>
+    this.navToSpacePage(
+      navController,
+      team,
+      'add-metric',
+      'navigateToAddMetric',
+    );
+
+  public navigateBackToSpacePage(
+    space: ISpaceContext,
+    page: string,
+    navOptions: NavigationOptions = {},
+  ): Promise<boolean> {
+    navOptions.animationDirection = 'back';
+    return this.navigateToSpacePage(space, page, navOptions);
+  }
+
+  public navigateForwardToSpacePage(
+    space: ISpaceContext,
+    page: string,
+    navOptions: NavigationOptions = {},
+  ): Promise<boolean> {
+    navOptions.animationDirection = 'forward';
+    return this.navigateToSpacePage(space, page, navOptions);
+  }
+
+  private navigateToSpacePage(
+    space: ISpaceContext,
+    page: string,
+    navOptions: NavigationOptions,
+  ): Promise<boolean> {
+    const url = `space/${space?.type}/${space?.id}/${page}`;
+    const state = navOptions.state || {};
+    navOptions = { ...navOptions, state: { space, ...state } };
+    return this.navController.navigateForward(url, navOptions);
+  }
+
+  private navForward(
+    navController: NavController,
+    url: string,
+    navOptions: NavigationOptions,
+    // _analyticsEvent: { name: string; params?: Record<string, unknown> },
+  ): void {
+    navController = navController || this.navController;
+    // this.analyticsService.logEvent(analyticsEvent.name, analyticsEvent.params);
+    navController
+      .navigateForward(url, navOptions)
+      .catch((err) =>
+        this.errorLogger.logError(err, 'Failed to navigate to: ' + url),
+      );
+  }
+
+  private navToSpacePage = (
+    navController: NavController,
+    space: ISpaceRef,
+    url: string,
+    eventName: string,
+    params?: Record<string, unknown>,
+  ): void => {
+    params = { ...params, space: space.id };
+    this.analyticsService.logEvent(eventName, params);
+    this.navForward(
+      navController,
+      url,
+      { queryParams: params, state: { space } },
+    );
+  };
+}

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

@@ -0,0 +1,46 @@
+import { TestBed } from '@angular/core/testing';
+import { Firestore } from '@angular/fire/firestore';
+import { SneatApiService } from '@sneat/api';
+import { SneatAuthStateService, SneatUserService } from '@sneat/auth-core';
+import { ErrorLogger } from '@sneat/core';
+import { of } from 'rxjs';
+import { SpaceServiceModule } from './space-service.module';
+import { SpaceService } from './space.service';
+
+describe('SpaceServiceModule', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [SpaceServiceModule],
+      providers: [
+        {
+          provide: ErrorLogger,
+          useValue: { logError: vi.fn(), logErrorHandler: () => vi.fn() },
+        },
+        {
+          provide: Firestore,
+          useValue: { type: 'Firestore', toJSON: () => ({}) },
+        },
+        {
+          provide: SneatUserService,
+          useValue: { userState: of({ record: undefined }) },
+        },
+        {
+          provide: SneatApiService,
+          useValue: { post: vi.fn(), get: vi.fn() },
+        },
+        {
+          provide: SneatAuthStateService,
+          useValue: {
+            authStatus: of('notAuthenticated'),
+            authState: of({ status: 'notAuthenticated' }),
+          },
+        },
+      ],
+    });
+  });
+
+  it('should provide SpaceService', () => {
+    const service = TestBed.inject(SpaceService);
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,7 @@
+import { NgModule } from '@angular/core';
+import { SpaceService } from './space.service';
+
+@NgModule({
+  providers: [SpaceService],
+})
+export class SpaceServiceModule {}