@sneat/api 0.1.2 → 0.1.4

package/src/lib/sneat-api-service-factory.spec.ts

@@ -1,132 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { TestBed } from '@angular/core/testing';
-import {
-  SneatApiServiceFactory,
-  getStoreUrl,
-} from './sneat-api-service-factory';
-import { provideHttpClientTesting } from '@angular/common/http/testing';
-import { Auth } from '@angular/fire/auth';
-import { SneatApiBaseUrl } from './sneat-api-service';
-import * as coreModule from '@sneat/core';
-
-const onIdTokenChangedMock = vi.fn();
-
-vi.mock('@angular/fire/auth', () => ({
-  onIdTokenChanged: (...args: unknown[]) => onIdTokenChangedMock(...args),
-  Auth: vi.fn(),
-}));
-
-describe('SneatApiServiceFactory', () => {
-  let factory: SneatApiServiceFactory;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        SneatApiServiceFactory,
-        provideHttpClientTesting(),
-        { provide: SneatApiBaseUrl, useValue: undefined },
-        { provide: Auth, useValue: {} },
-      ],
-    });
-    factory = TestBed.inject(SneatApiServiceFactory);
-    onIdTokenChangedMock.mockClear();
-  });
-
-  it('should be created', () => {
-    expect(factory).toBeTruthy();
-  });
-
-  describe('getSneatApiService', () => {
-    it('should throw error if storeId is empty', () => {
-      expect(() => factory.getSneatApiService('')).toThrow(
-        'storeRef is a required parameter, got empty: string',
-      );
-    });
-
-    it('should throw error if storeRef.type is empty', () => {
-      // Mock parseStoreRef to return an object with empty type
-      const parseStoreRefSpy = vi.spyOn(coreModule, 'parseStoreRef');
-      parseStoreRefSpy.mockReturnValue({ type: '' } as any);
-
-      expect(() => factory.getSneatApiService('test')).toThrow(
-        'storeRef.type is a required parameter, got empty: string',
-      );
-
-      parseStoreRefSpy.mockRestore();
-    });
-
-    it('should throw error for unknown store type', () => {
-      TestBed.runInInjectionContext(() => {
-        // 'github' is a valid storeId for parseStoreRef but not handled by factory
-        expect(() => factory.getSneatApiService('github')).toThrow(
-          'unknown store type: github',
-        );
-      });
-    });
-
-    it('should return service for firestore type', () => {
-      TestBed.runInInjectionContext(() => {
-        const service = factory.getSneatApiService('firestore');
-        expect(service).toBeTruthy();
-      });
-    });
-
-    it('should cache and return same service instance for same storeId', () => {
-      TestBed.runInInjectionContext(() => {
-        const service1 = factory.getSneatApiService('firestore');
-        const service2 = factory.getSneatApiService('firestore');
-        expect(service1).toBe(service2);
-      });
-    });
-  });
-
-  describe('getStoreUrl', () => {
-    it('should return localhost URL for firestore without trailing slash', () => {
-      const url = getStoreUrl('firestore');
-      expect(url).toBe('http://localhost:4300/v0');
-    });
-
-    it('should remove trailing slash from firestore URL', () => {
-      // The function returns without trailing slash already
-      const url = getStoreUrl('firestore');
-      expect(url).not.toMatch(/\/$/);
-    });
-
-    it('should return storeId if it is empty', () => {
-      const url = getStoreUrl('');
-      expect(url).toBe('');
-    });
-
-    it('should return storeId if it matches http URL pattern', () => {
-      const httpUrl = 'http://example.com/api';
-      const url = getStoreUrl(httpUrl);
-      expect(url).toBe(httpUrl);
-    });
-
-    it('should return storeId if it matches https URL pattern', () => {
-      const httpsUrl = 'https://example.com/api';
-      const url = getStoreUrl(httpsUrl);
-      expect(url).toBe(httpsUrl);
-    });
-
-    it('should convert http- prefix to http://', () => {
-      const url = getStoreUrl('http-example.com');
-      expect(url).toBe('http://example.com');
-    });
-
-    it('should convert https- prefix to https://', () => {
-      const url = getStoreUrl('https-example.com');
-      expect(url).toBe('https://example.com');
-    });
-
-    it('should handle host:port format', () => {
-      const url = getStoreUrl('localhost:8080');
-      expect(url).toBe('//localhost:8080');
-    });
-
-    it('should handle host:port:path format', () => {
-      const url = getStoreUrl('localhost:8080:api');
-      expect(url).toBe('//localhost:8080:api');
-    });
-  });
-});

package/src/lib/sneat-api-service-factory.ts

@@ -1,59 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { ISneatApiService } from './sneat-api-service.interface';
-import { parseStoreRef } from '@sneat/core';
-import { SneatApiService } from './sneat-api-service';
-
-export const getStoreUrl = (storeId: string): string => {
-  if (storeId === 'firestore') {
-    const v = 'http://localhost:4300/v0'; //environment.agents.firestoreStoreAgent;
-    return v.endsWith('/') ? v.substring(0, v.length - 1) : v;
-  }
-  if (!storeId || storeId.match(/https?:\/\//)) {
-    return storeId;
-  }
-  if (storeId.startsWith('http-')) {
-    return storeId.replace('http-', 'http' + '://');
-  }
-  if (storeId.startsWith('https-')) {
-    return storeId.replace('https-', 'https://');
-  }
-  const a = storeId.split(':');
-  storeId = `//${a[0]}:${a[1]}`;
-  if (a[2]) {
-    storeId += ':' + a[2];
-  }
-  return storeId;
-};
-
-@Injectable({ providedIn: 'root' })
-export class SneatApiServiceFactory {
-  private services: Record<string, ISneatApiService> = {};
-
-  public getSneatApiService(storeId: string): ISneatApiService {
-    if (!storeId) {
-      throw new Error(
-        'storeRef is a required parameter, got empty: ' + typeof storeId,
-      );
-    }
-    const storeRef = parseStoreRef(storeId);
-    if (!storeRef.type) {
-      throw new Error(
-        'storeRef.type is a required parameter, got empty: ' +
-          typeof storeRef.type,
-      );
-    }
-    const id = `${storeRef.type}:${storeRef.url}`;
-    let service = this.services[id];
-    if (service) {
-      return service;
-    }
-    // const baseUrl = getStoreUrl(storeRefToId(storeRef));
-    switch (storeRef.type) {
-      case 'firestore':
-        this.services[id] = service = inject(SneatApiService);
-        return service;
-      default:
-        throw new Error('unknown store type: ' + storeRef.type);
-    }
-  }
-}

package/src/lib/sneat-api-service.interface.ts

@@ -1,50 +0,0 @@
-import { Observable } from 'rxjs';
-import { HttpHeaders, HttpParams } from '@angular/common/http';
-
-export interface IHttpRequestOptions {
-  headers?: HttpHeaders | Record<string, string | string[]>;
-  observe?: 'body';
-  params?: HttpParams | Record<string, string | string[]>;
-  reportProgress?: boolean;
-  responseType?: 'json';
-  withCredentials?: boolean;
-}
-
-// const SneatApiService = new InjectionToken('ISneatApiService');
-
-export interface ISneatApiResponse<T> {
-  // TODO: Either use or delete
-  data: T;
-}
-
-export interface ISneatApiService {
-  post<I, O>(
-    endpoint: string,
-    body: I,
-    options?: IHttpRequestOptions,
-  ): Observable<O>;
-
-  put<I, O>(
-    endpoint: string,
-    body: I,
-    options?: IHttpRequestOptions,
-  ): Observable<O>;
-
-  get<T>(
-    endpoint: string,
-    params?: HttpParams,
-    options?: IHttpRequestOptions,
-  ): Observable<T>;
-
-  getAsAnonymous<T>(
-    endpoint: string,
-    params?: HttpParams,
-    options?: IHttpRequestOptions,
-  ): Observable<T>;
-
-  delete<T>(
-    endpoint: string,
-    params?: HttpParams,
-    body?: unknown,
-  ): Observable<T>;
-}

package/src/lib/sneat-api-service.spec.ts

@@ -1,298 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {
-  HttpTestingController,
-  provideHttpClientTesting,
-} from '@angular/common/http/testing';
-import { HttpClient, HttpParams } from '@angular/common/http';
-import { firstValueFrom } from 'rxjs';
-import {
-  DefaultSneatAppApiBaseUrl,
-  SneatApiBaseUrl,
-  SneatApiService,
-} from './sneat-api-service';
-import { Auth, User } from '@angular/fire/auth';
-
-const onIdTokenChangedMock = vi.fn();
-
-vi.mock('@angular/fire/auth', () => ({
-  onIdTokenChanged: (...args: unknown[]) => onIdTokenChangedMock(...args),
-  Auth: vi.fn(),
-}));
-
-const NOT_AUTHENTICATED_ERROR =
-  'User is not authenticated yet - no Firebase ID token';
-
-describe('SneatApiService', () => {
-  let httpMock: HttpTestingController;
-  let service: SneatApiService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        provideHttpClientTesting(),
-        { provide: SneatApiBaseUrl, useValue: undefined },
-        { provide: Auth, useValue: {} },
-      ],
-    });
-
-    httpMock = TestBed.inject(HttpTestingController);
-    service = TestBed.inject(SneatApiService);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-    vi.clearAllMocks();
-  });
-
-  it('registers for ID token changes on construction', () => {
-    expect(onIdTokenChangedMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('uses custom base URL when provided', async () => {
-    const customService = Object.create(SneatApiService.prototype);
-    customService.baseUrl = 'https://custom-api.com/';
-    customService.httpClient = TestBed.inject(HttpClient);
-    // Manually implement setApiAuthToken as it's an arrow function property in the original class
-    customService.setApiAuthToken = (token?: string) => {
-      (customService as unknown as { authToken?: string }).authToken = token;
-    };
-    customService.setApiAuthToken('token-123');
-
-    // Manually implement headers and errorIfNotAuthenticated as they are used by get/post etc
-    customService.headers = (
-      service as unknown as { headers: () => void }
-    ).headers.bind(customService);
-    customService.errorIfNotAuthenticated = (
-      service as unknown as { errorIfNotAuthenticated: () => void }
-    ).errorIfNotAuthenticated.bind(customService);
-
-    const responsePromise = firstValueFrom(customService.get('health'));
-    const req = httpMock.expectOne('https://custom-api.com/health');
-
-    expect(req.request.method).toBe('GET');
-    req.flush({ ok: true });
-
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('handles onIdTokenChanged callback for authenticated user', async () => {
-    const callback = onIdTokenChangedMock.mock.calls[0][1];
-    const mockUser = {
-      getIdToken: vi.fn().mockResolvedValue('new-token'),
-    } as unknown as User;
-
-    callback.next(mockUser);
-
-    // Wait for promise resolution
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    service.setApiAuthToken('new-token'); // Manual set because we can't easily wait for the internal async call
-    const responsePromise = firstValueFrom(service.get('auth-test'));
-    const req = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}auth-test`);
-    expect(req.request.headers.get('Authorization')).toBe('Bearer new-token');
-    req.flush({ ok: true });
-    await responsePromise;
-  });
-
-  it('handles onIdTokenChanged callback for unauthenticated user', async () => {
-    const callback = onIdTokenChangedMock.mock.calls[0][1];
-    service.setApiAuthToken('old-token');
-
-    callback.next(null);
-    service.setApiAuthToken(undefined);
-
-    await expect(firstValueFrom(service.get('auth-test'))).rejects.toBe(
-      NOT_AUTHENTICATED_ERROR,
-    );
-  });
-
-  it('handles getIdToken error', async () => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {
-      /* ignore */
-    });
-    const callback = onIdTokenChangedMock.mock.calls[0][1];
-    const mockUser = {
-      getIdToken: vi.fn().mockRejectedValue(new Error('token error')),
-    } as unknown as User;
-
-    callback.next(mockUser);
-
-    // Wait for promise resolution
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(consoleSpy).toHaveBeenCalledWith(
-      'getIdToken() error:',
-      expect.any(Error),
-    );
-    consoleSpy.mockRestore();
-  });
-
-  it('handles onIdTokenChanged error', () => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {
-      /* ignore */
-    });
-    const callback = onIdTokenChangedMock.mock.calls[0][1];
-
-    callback.error(new Error('auth error'));
-
-    expect(consoleSpy).toHaveBeenCalledWith(
-      'onIdTokenChanged() error:',
-      expect.any(Error),
-    );
-    consoleSpy.mockRestore();
-  });
-
-  it('handles onIdTokenChanged complete', () => {
-    const callback = onIdTokenChangedMock.mock.calls[0][1];
-    expect(callback.complete()).toBeUndefined();
-  });
-
-  it('emits on destroyed subject when ngOnDestroy is called', () => {
-    const nextSpy = vi.spyOn(
-      (service as unknown as { destroyed: { next: () => void } }).destroyed,
-      'next',
-    );
-    const completeSpy = vi.spyOn(
-      (service as unknown as { destroyed: { complete: () => void } }).destroyed,
-      'complete',
-    );
-
-    service.ngOnDestroy();
-
-    expect(nextSpy).toHaveBeenCalled();
-    expect(completeSpy).toHaveBeenCalled();
-  });
-
-  it('performs PUT requests', async () => {
-    service.setApiAuthToken('token');
-    const responsePromise = firstValueFrom(service.put('update', { x: 1 }));
-    const req = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}update`);
-    expect(req.request.method).toBe('PUT');
-    expect(req.request.body).toEqual({ x: 1 });
-    req.flush({ ok: true });
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('performs GET requests with params', async () => {
-    service.setApiAuthToken('token');
-    const params = new HttpParams().set('id', '123');
-    const responsePromise = firstValueFrom(service.get('search', params));
-    const req = httpMock.expectOne(
-      (r) =>
-        r.url === `${DefaultSneatAppApiBaseUrl}search` && r.params.has('id'),
-    );
-    expect(req.request.method).toBe('GET');
-    expect(req.request.params.get('id')).toBe('123');
-    req.flush({ ok: true });
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('performs GET as anonymous with params', async () => {
-    const params = new HttpParams().set('q', 'test');
-    const responsePromise = firstValueFrom(
-      service.getAsAnonymous('search', params),
-    );
-    const req = httpMock.expectOne(
-      (r) =>
-        r.url === `${DefaultSneatAppApiBaseUrl}search` && r.params.has('q'),
-    );
-    expect(req.request.params.get('q')).toBe('test');
-    req.flush({ ok: true });
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('handles headers when not authenticated', () => {
-    (service as unknown as { authToken?: string }).authToken = undefined;
-    const headers = (
-      service as unknown as {
-        headers: () => {
-          has: (name: string) => boolean;
-        };
-      }
-    ).headers();
-    expect(headers.has('Authorization')).toBe(false);
-  });
-
-  it('uses default base URL when none provided', async () => {
-    service.setApiAuthToken('token-123');
-
-    const responsePromise = firstValueFrom(service.get('health'));
-    const req = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}health`);
-
-    expect(req.request.method).toBe('GET');
-    req.flush({ ok: true });
-
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('throws when not authenticated', async () => {
-    await expect(firstValueFrom(service.get('spaces'))).rejects.toBe(
-      NOT_AUTHENTICATED_ERROR,
-    );
-    await expect(firstValueFrom(service.post('spaces', {}))).rejects.toBe(
-      NOT_AUTHENTICATED_ERROR,
-    );
-    await expect(firstValueFrom(service.put('spaces', {}))).rejects.toBe(
-      NOT_AUTHENTICATED_ERROR,
-    );
-    await expect(firstValueFrom(service.delete('spaces'))).rejects.toBe(
-      NOT_AUTHENTICATED_ERROR,
-    );
-  });
-
-  it('adds Authorization header when authenticated', async () => {
-    service.setApiAuthToken('abc123');
-
-    const responsePromise = firstValueFrom(
-      service.post('spaces', { name: 'x' }),
-    );
-    const req = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}spaces`);
-
-    expect(req.request.method).toBe('POST');
-    expect(req.request.headers.get('Authorization')).toBe('Bearer abc123');
-    expect(req.request.body).toEqual({ name: 'x' });
-
-    req.flush({ ok: true });
-
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-
-  it('performs anonymous requests without auth header', async () => {
-    const getPromise = firstValueFrom(service.getAsAnonymous('public'));
-    const getReq = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}public`);
-
-    expect(getReq.request.method).toBe('GET');
-    expect(getReq.request.headers.get('Authorization')).toBeNull();
-    getReq.flush({ ok: true });
-    await expect(getPromise).resolves.toEqual({ ok: true });
-
-    const postPromise = firstValueFrom(
-      service.postAsAnonymous('public', { hello: 'world' }),
-    );
-    const postReq = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}public`);
-
-    expect(postReq.request.method).toBe('POST');
-    expect(postReq.request.headers.get('Authorization')).toBeNull();
-    expect(postReq.request.body).toEqual({ hello: 'world' });
-    postReq.flush({ ok: true });
-    await expect(postPromise).resolves.toEqual({ ok: true });
-  });
-
-  it('sends body on delete when provided', async () => {
-    service.setApiAuthToken('delete-token');
-
-    const responsePromise = firstValueFrom(
-      service.delete('spaces', undefined, { id: 'space-1' }),
-    );
-    const req = httpMock.expectOne(`${DefaultSneatAppApiBaseUrl}spaces`);
-
-    expect(req.request.method).toBe('DELETE');
-    expect(req.request.headers.get('Authorization')).toBe(
-      'Bearer delete-token',
-    );
-    expect(req.request.body).toEqual({ id: 'space-1' });
-    req.flush({ ok: true });
-
-    await expect(responsePromise).resolves.toEqual({ ok: true });
-  });
-});

package/src/lib/sneat-api-service.ts

@@ -1,138 +0,0 @@
-import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
-import {
-  Inject,
-  Injectable,
-  InjectionToken,
-  OnDestroy,
-  Optional,
-} from '@angular/core';
-import { Auth, onIdTokenChanged } from '@angular/fire/auth';
-import { Observable, Subject, throwError } from 'rxjs';
-import { ISneatApiService } from './sneat-api-service.interface';
-
-const userIsNotAuthenticatedNoFirebaseToken =
-  'User is not authenticated yet - no Firebase ID token';
-
-export const SneatApiAuthTokenProvider = new InjectionToken(
-  'SneatApiAuthTokenProvider',
-);
-export const SneatApiBaseUrl = new InjectionToken('SneatApiBaseUrl');
-export const DefaultSneatAppApiBaseUrl = 'https://api.sneat.ws/v0/';
-
-@Injectable({ providedIn: 'root' }) // Should it be in root? Probably it is OK.
-export class SneatApiService implements ISneatApiService, OnDestroy {
-  private readonly baseUrl: string;
-
-  private readonly destroyed = new Subject<void>();
-  private authToken?: string;
-
-  constructor(
-    private readonly httpClient: HttpClient,
-    @Inject(SneatApiBaseUrl) @Optional() baseUrl: string | null,
-    private readonly afAuth: Auth,
-  ) {
-    this.baseUrl = baseUrl ?? DefaultSneatAppApiBaseUrl;
-    // console.log('SneatApiService.constructor()', this.baseUrl);
-    onIdTokenChanged(this.afAuth, {
-      next: (user) => {
-        user
-          ?.getIdToken()
-          .then(this.setApiAuthToken)
-          .catch((err) => console.error('getIdToken() error:', err));
-      },
-      error: (error) => {
-        console.error('onIdTokenChanged() error:', error);
-      },
-      complete: () => void 0,
-    });
-  }
-
-  ngOnDestroy() {
-    this.destroyed.next();
-    this.destroyed.complete();
-  }
-
-  // TODO: It's made public because we use it in Login page, might be a bad idea consider making private and rely on afAuth.idToken event
-  setApiAuthToken = (token?: string) => {
-    // console.log('setApiAuthToken()', token);
-    this.authToken = token;
-  };
-
-  public post<T>(endpoint: string, body: unknown): Observable<T> {
-    const url = this.baseUrl + endpoint;
-    // console.log('post()', endpoint, url, body);
-    return (
-      this.errorIfNotAuthenticated() ||
-      this.httpClient.post<T>(url, body, {
-        headers: this.headers(),
-      })
-    );
-  }
-
-  public put<T>(endpoint: string, body: unknown): Observable<T> {
-    return (
-      this.errorIfNotAuthenticated() ||
-      this.httpClient.put<T>(this.baseUrl + endpoint, body, {
-        headers: this.headers(),
-      })
-    );
-  }
-
-  public get<T>(endpoint: string, params?: HttpParams): Observable<T> {
-    return (
-      this.errorIfNotAuthenticated() ||
-      this.httpClient.get<T>(this.baseUrl + endpoint, {
-        headers: this.headers(),
-        params,
-      })
-    );
-  }
-
-  public getAsAnonymous<T>(
-    endpoint: string,
-    params?: HttpParams,
-  ): Observable<T> {
-    return this.httpClient.get<T>(this.baseUrl + endpoint, {
-      params,
-    });
-  }
-
-  public postAsAnonymous<T>(endpoint: string, body: unknown): Observable<T> {
-    const url = this.baseUrl + endpoint;
-    // alert('postAsAnonymous(), url=' + url);
-    return this.httpClient.post<T>(url, body);
-  }
-
-  public delete<T>(
-    endpoint: string,
-    params?: HttpParams,
-    body?: unknown,
-  ): Observable<T> {
-    // console.log('delete()', endpoint, params);
-    const url = this.baseUrl + endpoint;
-    return (
-      this.errorIfNotAuthenticated() ||
-      this.httpClient.delete<T>(url, {
-        params,
-        headers: this.headers(),
-        body,
-      })
-    );
-  }
-
-  private errorIfNotAuthenticated(): Observable<never> | undefined {
-    const result: Observable<never> | undefined =
-      (!this.authToken &&
-        throwError(() => userIsNotAuthenticatedNoFirebaseToken)) ||
-      undefined;
-    return result;
-  }
-
-  private headers(): HttpHeaders {
-    let headers = new HttpHeaders();
-    if (this.authToken) {
-      headers = headers.append('Authorization', 'Bearer ' + this.authToken);
-    }
-    return headers;
-  }
-}

package/src/lib/sneat-api.module.spec.ts

@@ -1,18 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { SneatApiModule } from './sneat-api.module';
-
-describe('SneatApiModule', () => {
-  it('should create module', () => {
-    const module = new SneatApiModule();
-    expect(module).toBeTruthy();
-  });
-
-  it('should be importable in TestBed', () => {
-    TestBed.configureTestingModule({
-      imports: [SneatApiModule],
-    });
-
-    const module = TestBed.inject(SneatApiModule);
-    expect(module).toBeTruthy();
-  });
-});