feat(products): add resolvers

src/app/resolvers/product-resolver.spec.ts

@@ -0,0 +1,58 @@
+import { TestBed } from '@angular/core/testing';
+import { provideRouter, RedirectCommand, ResolveFn, Router } from '@angular/router';
+
+import { productResolver } from './product-resolver';
+import { Product } from '../models/Product';
+import { ProductDAO } from '../dao/ProductDAO';
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-mock',
+  template: ``,
+  styles: ``,
+})
+class MockComponent {}
+
+describe('productResolver', () => {
+  const executeResolver: ResolveFn<Product | RedirectCommand> = (...resolverParameters) =>
+    TestBed.runInInjectionContext(() => productResolver(...resolverParameters));
+
+  let productDAO: Partial<ProductDAO>;
+  let router: Router;
+
+  let PRODUCT_MOCK: Product;
+  beforeEach(() => {
+    productDAO = {
+      findBy: vi.fn().mockResolvedValue([]),
+    };
+
+    PRODUCT_MOCK = new Product('mock','mock','',1);
+
+    TestBed.configureTestingModule({
+      providers: [
+        provideRouter([
+          { path: 'mock/:id', component: MockComponent, resolve: { product: productResolver } },
+          { path: 'settings/products', component: MockComponent },
+        ]),
+        { provide: ProductDAO, useValue: productDAO },
+      ],
+    });
+
+    router = TestBed.inject(Router);
+  });
+
+  it('should be created', () => {
+    expect(executeResolver).toBeTruthy();
+  });
+
+  it('should navigate back to settings for not found ids', async () => {
+    await router.navigate(['mock', '99']);
+    expect(router.url).toEqual('/settings/products');
+  });
+
+  it('should complete navigation for found ids', async () => {
+    productDAO.findBy = vi.fn().mockResolvedValue([PRODUCT_MOCK]);
+    await router.navigate(['mock', String(PRODUCT_MOCK.id)]);
+    expect(router.url).toEqual(`/mock/${PRODUCT_MOCK.id}`);
+  });
+});

src/app/resolvers/product-resolver.ts

@@ -0,0 +1,25 @@
+import { inject } from '@angular/core';
+import { RedirectCommand, ResolveFn, Router } from '@angular/router';
+import { ProductDAO } from '../dao/ProductDAO';
+import { Product } from '../models/Product';
+
+export const productResolver: ResolveFn<Product|RedirectCommand> = async (route, _) => {
+  const productDAO = inject(ProductDAO);
+  const router = inject(Router);
+  const chainID = (<{ id: string }>route.params).id;
+  let product: Product;
+  
+  try {
+    const results = await productDAO.findBy({ id: Number(chainID) });
+    if (!results[0]) {
+      throw new Error('The search for chain on edit did not find any match');
+    }
+    product = results[0];
+  } catch (e) {
+    console.error(e);
+    return new RedirectCommand(router.parseUrl('settings/products'), {
+      skipLocationChange: true,
+    });
+  }
+  return product;
+};

src/app/resolvers/products-resolver.spec.ts

@@ -0,0 +1,48 @@
+import { TestBed } from '@angular/core/testing';
+import { provideRouter, ResolveFn, Router } from '@angular/router';
+
+import { productsResolver } from './products-resolver';
+import { Product } from '../models/Product';
+import { ProductDAO } from '../dao/ProductDAO';
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-mock',
+  template: ``,
+  styles: ``,
+})
+class MockComponent {}
+
+describe('productsResolver', () => {
+  const executeResolver: ResolveFn<Product[]> = (...resolverParameters) =>
+    TestBed.runInInjectionContext(() => productsResolver(...resolverParameters));
+
+  let productDAO: Partial<ProductDAO>;
+  let router: Router;
+
+  beforeEach(() => {
+    productDAO = {
+      findAll: vi.fn().mockResolvedValue([]),
+    };
+
+    TestBed.configureTestingModule({
+      providers: [
+        provideRouter([
+          { path: 'products', component: MockComponent, resolve: { products: productsResolver } },
+        ]),
+        { provide: ProductDAO, useValue: productDAO },
+      ],
+    });
+
+    router = TestBed.inject(Router);
+  });
+
+  it('should be created', () => {
+    expect(executeResolver).toBeTruthy();
+  });
+
+  it('should call productDAO findAll method', async () => {
+    await router.navigate(['products']);
+    expect(productDAO.findAll).toHaveBeenCalled();
+  });
+});

src/app/resolvers/products-resolver.ts

@@ -0,0 +1,17 @@
+import { ResolveFn } from '@angular/router';
+import { ProductDAO } from '../dao/ProductDAO';
+import { inject } from '@angular/core';
+import { Product } from '../models/Product';
+
+export const productsResolver: ResolveFn<Product[]> = async (route, state) => {
+  const productDAO = inject(ProductDAO);
+  let products: Product[] = [];
+
+  try {
+    products = await productDAO.findAll()
+  } catch(e) {
+    console.error(e);
+    //TODO: report error
+  }
+  return products;
+};