@sneat/space-services 0.1.0

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

@@ -0,0 +1,44 @@
+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 { SpaceService } from './space.service';
+
+describe('SpaceService', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        SpaceService,
+        {
+          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 be created', () => {
+    expect(TestBed.inject(SpaceService)).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,291 @@
+import { HttpParams } from '@angular/common/http';
+import {
+  Injectable,
+  Injector,
+  inject,
+  runInInjectionContext,
+} from '@angular/core';
+import {
+  Firestore as AngularFirestore,
+  CollectionReference,
+  collection,
+} from '@angular/fire/firestore';
+import { SneatApiService, SneatFirestoreService } from '@sneat/api';
+import {
+  AuthStatus,
+  AuthStatuses,
+  SneatAuthStateService,
+} from '@sneat/auth-core';
+import { IUserSpaceBrief } from '@sneat/auth-models';
+import { IIdAndBrief } from '@sneat/core';
+import { IRecord } from '@sneat/data';
+import { ISpaceBrief, ISpaceDbo, ISpaceMetric } from '@sneat/dto';
+import { ErrorLogger, IErrorLogger } from '@sneat/core';
+import {
+  ICreateSpaceRequest,
+  ICreateSpaceResponse,
+  ILeaveSpaceRequest,
+  ISpaceContext,
+  IUpdateRelatedRequest,
+  zipMapBriefsWithIDs,
+} from '@sneat/space-models';
+import { ISneatUserState, SneatUserService } from '@sneat/auth-core';
+import {
+  BehaviorSubject,
+  Observable,
+  Subject,
+  Subscription,
+  throwError,
+} from 'rxjs';
+import { filter, first, map, tap } from 'rxjs/operators';
+
+const spaceBriefFromUserSpaceInfo = (v: IUserSpaceBrief): ISpaceBrief => ({
+  ...v,
+  type: v.type,
+});
+
+// export class CachedDataService<Brief, Dbo extends Brief> {
+// 	constructor(
+// 		private readonly db: AngularFirestore,
+// 	) {
+// 	}
+//
+// 	// watchRecord()
+// }
+
+@Injectable()
+export class SpaceService {
+  readonly sneatAuthStateService = inject(SneatAuthStateService);
+  private readonly errorLogger = inject<IErrorLogger>(ErrorLogger);
+  private readonly afs = inject(AngularFirestore);
+  private readonly userService = inject(SneatUserService);
+  private readonly sneatApiService = inject(SneatApiService);
+
+  private userID?: string;
+
+  private currentUserSpaces?: Record<string, IUserSpaceBrief>;
+
+  private spaces$: Record<string, BehaviorSubject<ISpaceContext | undefined>> =
+    {};
+  private subscriptions: Subscription[] = [];
+
+  private readonly sfs: SneatFirestoreService<ISpaceBrief, ISpaceDbo>;
+
+  private readonly injector = inject(Injector);
+
+  constructor() {
+    const sneatAuthStateService = this.sneatAuthStateService;
+
+    // console.log('SpaceService.constructor()');
+    this.sfs = new SneatFirestoreService<ISpaceBrief, ISpaceDbo>(
+      this.injector,
+      (id: string, dto: ISpaceDbo) => ({
+        id,
+        ...dto,
+      }),
+    );
+    const onAuthStatusChanged = (status: AuthStatus): void => {
+      if (status === 'notAuthenticated') {
+        this.unsubscribe('signed out');
+      }
+    };
+    sneatAuthStateService.authStatus.subscribe(onAuthStatusChanged);
+
+    // We are intentionally not un-subscribing from user record updates. TODO: why?
+    this.userService.userState.subscribe({
+      next: this.processUserRecordInSpaceService,
+      error: this.errorLogger.logErrorHandler('failed to load user record'),
+    });
+  }
+
+  private readonly processUserRecordInSpaceService = (
+    userState: ISneatUserState,
+  ): void => {
+    const user = userState?.record;
+    if (!user) {
+      // this.userID = undefined;
+      if (
+        userState.status === AuthStatuses.notAuthenticated &&
+        this.subscriptions?.length
+      ) {
+        this.unsubscribe(
+          'user is not authenticated and active team subscriptions',
+        );
+      }
+      return;
+    }
+    if (userState.user?.uid !== this.userID) {
+      if (this.userID) {
+        this.unsubscribe('user id changed');
+      }
+      this.userID = userState.user?.uid;
+    }
+    this.currentUserSpaces = user?.spaces;
+
+    zipMapBriefsWithIDs(user.spaces).forEach(this.subscribeForUserSpaceChanges);
+  };
+
+  public createSpace(
+    request: ICreateSpaceRequest,
+  ): Observable<IRecord<ISpaceDbo>> {
+    return this.sneatApiService
+      .post<ICreateSpaceResponse>('spaces/create_space', request)
+      .pipe(map((response: ICreateSpaceResponse) => response.space));
+  }
+
+  // public getSpace(ref: ISpaceRef): Observable<ISpaceContext> {
+  // 	return this.watchSpace(ref).pipe(first());
+  // }
+
+  public watchSpace(id: string): Observable<ISpaceContext> {
+    if (!id) {
+      throw new Error('space id is a required parameter');
+    }
+    if (id === 'contacts') {
+      throw new Error('watchSpace({i}d===contacts})');
+    }
+    let subj = this.spaces$[id];
+    if (subj) {
+      return subj.asObservable().pipe(filter((s) => !!s));
+    }
+    let spaceContext: ISpaceContext | undefined = undefined;
+    if (this.currentUserSpaces) {
+      const userSpaceInfo = this.currentUserSpaces[id];
+      if (userSpaceInfo) {
+        spaceContext = {
+          id,
+          type: userSpaceInfo.type,
+          brief: spaceBriefFromUserSpaceInfo(userSpaceInfo),
+        };
+      }
+    }
+    subj = new BehaviorSubject<ISpaceContext | undefined>(spaceContext);
+    this.spaces$[id] = subj;
+    if (this.userService.currentUserID) {
+      this.subscribeForSpaceChanges(id, subj);
+    } else {
+      this.userService.userState
+        .pipe(
+          filter((v) => v.status === AuthStatuses.authenticated),
+          first(),
+        )
+        .subscribe({
+          next: () => this.subscribeForSpaceChanges(id, subj),
+        });
+    }
+    return subj.asObservable().pipe(filter((s) => !!s));
+  }
+
+  public onSpaceUpdated(space: ISpaceContext): void {
+    let team$ = this.spaces$[space.id];
+    if (team$) {
+      const prevTeam = team$.value;
+      space = { ...prevTeam, ...space };
+    } else {
+      this.spaces$[space.id] = team$ = new BehaviorSubject<
+        ISpaceContext | undefined
+      >(space);
+    }
+    team$.next(space);
+  }
+
+  public leaveSpace(request: ILeaveSpaceRequest): Observable<void> {
+    return this.sneatApiService.post('space/leave_space', request);
+  }
+
+  public updateRelated(request: IUpdateRelatedRequest): Observable<void> {
+    return this.sneatApiService.post('space/update_related', request);
+  }
+
+  // TODO: move to separate module
+  public deleteMetrics(space: string, metrics: string[]): Observable<void> {
+    return this.sneatApiService.post('space/remove_metrics', {
+      space,
+      metrics,
+    });
+  }
+
+  // TODO: move to separate module
+  public addMetric(space: string, metric: ISpaceMetric): Observable<void> {
+    if (!space) {
+      return throwError(() => 'space parameter is required');
+    }
+    const params = new HttpParams({ fromObject: { id: space } });
+    return this.sneatApiService.post('space/add_metric?' + params.toString(), {
+      metric,
+    });
+  }
+
+  private readonly subscribeForUserSpaceChanges = (
+    userSpaceBrief: IIdAndBrief<IUserSpaceBrief>,
+  ): void => {
+    let subj = this.spaces$[userSpaceBrief.id];
+    if (subj) {
+      let space = subj.value;
+      if (space && !space?.type) {
+        space = {
+          ...space,
+          type: userSpaceBrief.brief?.type,
+          brief: spaceBriefFromUserSpaceInfo(userSpaceBrief.brief),
+        };
+        subj.next(space);
+      }
+      return;
+    }
+
+    const space: ISpaceContext = {
+      id: userSpaceBrief.id,
+      type: userSpaceBrief.brief.type,
+      brief: spaceBriefFromUserSpaceInfo(userSpaceBrief.brief),
+    };
+    this.spaces$[space.id] = subj = new BehaviorSubject<
+      ISpaceContext | undefined
+    >(space);
+    this.subscribeForSpaceChanges(space.id, subj);
+  };
+
+  private subscribeForSpaceChanges(
+    id: string,
+    subj: Subject<ISpaceContext | undefined>,
+  ): void {
+    if (id === 'contacts') {
+      throw new Error('subscribeForSpaceChanges(id===contacts)');
+    }
+    const spacesCollection = runInInjectionContext(
+      this.injector,
+      () => collection(this.afs, 'spaces') as CollectionReference<ISpaceDbo>,
+    );
+    const o: Observable<ISpaceContext> = this.sfs
+      .watchByID(spacesCollection, id)
+      .pipe(
+        map((team) => {
+          // const _prevTeam = this.spaces$[id].value;
+          // if (prevTeam.assets) {
+          // 	team = { ...team, assets: prevTeam.assets};
+          // 	console.log('Reusing assets from prev context');
+          // }
+          return team;
+        }),
+        tap(() => {
+          // subj.next(team);
+        }),
+      );
+
+    this.subscriptions.push(
+      o.subscribe({
+        next: (v) => subj.next(v), // Do not use as "next: subj.next" because it will be called with wrong "this" context
+        error: (err) => subj.error(err),
+      }),
+    );
+  }
+
+  private unsubscribe(_reason?: string): void {
+    try {
+      this.subscriptions.forEach((s) => s.unsubscribe());
+      this.subscriptions = [];
+      this.spaces$ = {};
+    } catch (e) {
+      this.errorLogger.logError(e, 'SpaceService failed to unsubscribe');
+    }
+  }
+}

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: 'space-services',
+	}),
+);