@sneat/space-services 0.1.0

package/eslint.config.js

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

package/ng-package.json

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

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@sneat/space-services",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=21.0.0",
+    "@angular/core": ">=21.0.0",
+    "@ionic/angular": ">=8",
+    "firebase": "*",
+    "@angular/fire": ">=20"
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  }
+}

package/project.json

@@ -0,0 +1,38 @@
+{
+  "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/index.ts

@@ -0,0 +1,8 @@
+export * from './lib/services/space-service.module';
+export * from './lib/services/space-nav.service';
+export * from './lib/services/space.service';
+export * from './lib/services/space-item.service';
+export * from './lib/services/space-context.service';
+export * from './lib/services/space-module.service';
+
+export * from './lib/components/with-space-input.directive';

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

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

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

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

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

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