@sneat/space-services 0.1.3 → 0.1.6

package/eslint.config.js

@@ -1,7 +0,0 @@
-const baseConfig = require('../../../eslint.config.js');
-const { sneatLibConfig } = require('../../../eslint.lib.config.js');
-
-module.exports = [
-  ...baseConfig,
-  ...sneatLibConfig(__dirname),
-];

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../../dist/libs/space/services",
-  "lib": {
-    "entryFile": "src/index.ts"
-  }
-}

package/project.json

@@ -1,38 +0,0 @@
-{
-  "name": "space-services",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "projectType": "library",
-  "sourceRoot": "libs/space/services/src",
-  "prefix": "sneat",
-  "targets": {
-    "build": {
-      "executor": "@nx/angular:ng-packagr-lite",
-      "outputs": [
-        "{workspaceRoot}/dist/libs/space/services"
-      ],
-      "options": {
-        "project": "libs/space/services/ng-package.json",
-        "tsConfig": "libs/space/services/tsconfig.lib.json"
-      },
-      "configurations": {
-        "production": {
-          "tsConfig": "libs/space/services/tsconfig.lib.prod.json"
-        },
-        "development": {}
-      },
-      "defaultConfiguration": "production"
-    },
-    "test": {
-      "executor": "@nx/vitest:test",
-      "outputs": [
-        "{workspaceRoot}/coverage/libs/space/services"
-      ],
-      "options": {
-        "tsConfig": "libs/space/services/tsconfig.spec.json"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}

package/src/lib/components/with-space-input.directive.spec.ts

@@ -1,41 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { NavController } from '@ionic/angular';
-import { AnalyticsService, ErrorLogger } from '@sneat/core';
-import { SpaceNavService } from '../services/space-nav.service';
-
-// Simplified test - complex component testing skipped for now
-describe('WithSpaceInput', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        {
-          provide: SpaceNavService,
-          useValue: {
-            navigateToSpace: vi.fn(),
-            navigateToSpaces: vi.fn(),
-          },
-        },
-        {
-          provide: NavController,
-          useValue: {
-            navigateRoot: vi.fn().mockResolvedValue(true),
-            navigateForward: vi.fn().mockResolvedValue(true),
-          },
-        },
-        {
-          provide: AnalyticsService,
-          useValue: { logEvent: vi.fn() },
-        },
-        {
-          provide: ErrorLogger,
-          useValue: { logError: vi.fn(), logErrorHandler: () => vi.fn() },
-        },
-      ],
-    });
-  });
-
-  it('should have SpaceNavService available', () => {
-    const service = TestBed.inject(SpaceNavService);
-    expect(service).toBeTruthy();
-  });
-});

package/src/lib/components/with-space-input.directive.ts

@@ -1,40 +0,0 @@
-import { computed, Directive, effect, inject, input } from '@angular/core';
-import { ISpaceContext } from '@sneat/space-models';
-import { SneatBaseComponent } from '@sneat/ui';
-import { BehaviorSubject, distinctUntilChanged } from 'rxjs';
-import { SpaceNavService } from '../services/space-nav.service';
-
-@Directive()
-export abstract class WithSpaceInput extends SneatBaseComponent {
-  protected readonly spaceNavService = inject(SpaceNavService);
-
-  public readonly $space = input.required<ISpaceContext>();
-
-  protected readonly $spaceID = computed(() => this.$space().id);
-  private readonly spaceIDChanged = new BehaviorSubject<string | undefined>(
-    undefined,
-  );
-  protected spaceID$ = this.spaceIDChanged
-    .asObservable()
-    .pipe(this.takeUntilDestroyed(), distinctUntilChanged());
-
-  protected readonly $spaceType = computed(() => this.$space().type);
-  protected readonly $spaceRef = computed(() => ({
-    id: this.$spaceID(),
-    type: this.$spaceType(),
-  }));
-
-  constructor() {
-    super();
-    effect(() => {
-      const spaceID = this.$spaceID();
-      if (spaceID !== this.spaceIDChanged.value) {
-        this.onSpaceIdChanged(spaceID);
-      }
-    });
-  }
-
-  protected onSpaceIdChanged(spaceID: string): void {
-    this.spaceIDChanged.next(spaceID);
-  }
-}

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

@@ -1,16 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { SpaceContextService } from './space-context.service';
-
-describe('SpaceContextService', () => {
-  let service: SpaceContextService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = TestBed.inject(SpaceContextService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

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>,
-  //       ),
-  //     ),
-  //   );
-  // }
-}