@infrab4a/connect-angular 5.8.20 → 5.8.21-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect-angular",
-  "version": "5.8.20",
+  "version": "5.8.21-beta.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },

package/src/services/catalog/adapters/new-category-structure.adapter.spec.ts

@@ -55,7 +55,7 @@ describe('NewCategoryStructureAdapter', () => {
 
     const result = await adapter.buildProductFilterByCategory(category)
 
-    expect(categoryRepository.get).toHaveBeenCalledOnceWith({ id: '12' })
+    expect(categoryRepository.get).toHaveBeenCalledWith({ id: '12' })
     expect(result).toEqual({ id: { operator: Where.IN, value: ['9'] } })
   })
 })

package/src/services/catalog/strategies/category-search.strategy.spec.ts

@@ -18,6 +18,16 @@ describe('CategorySearchStrategy', () => {
     count: 0,
   }
 
+  const daysAgo = (days: number): Date => new Date(Date.now() - days * 24 * 60 * 60 * 1000)
+
+  const buildProduct = (overrides: Partial<Product> & { id: string }): Product =>
+    ({
+      stock: { quantity: 10 },
+      shoppingCount: 0,
+      createdAt: daysAgo(60),
+      ...overrides,
+    }) as Product
+
   beforeEach(() => {
     findCatalog = jasmine.createSpy('findCatalog').and.resolveTo(emptyResult)
     buildProductFilterByCategory = jasmine
@@ -90,4 +100,115 @@ describe('CategorySearchStrategy', () => {
     expect(findCatalog.calls.mostRecent().args[0].orderBy).toEqual({ createdAt: 'desc' })
     expect(findCatalog.calls.mostRecent().args[0].limits).toEqual(limits)
   })
+
+  it('should keep wishlist most-relevant as best-sellers without pins/Novo block', async () => {
+    const category = { id: '10', isWishlist: true, products: ['1', '2'] } as Category
+
+    await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+    expect(findCatalog).toHaveBeenCalledTimes(1)
+    expect(findCatalog.calls.mostRecent().args[0].orderBy.shoppingCount).toBe('desc')
+  })
+
+  describe('most-relevant in-memory order', () => {
+    const setupMostRelevant = (products: Product[], pinIds: string[]) => {
+      const category = {
+        id: '20',
+        isWishlist: false,
+        getMostRelevantByShop: () => pinIds,
+      } as unknown as Category
+
+      findCatalog.and.callFake(async (params: any) => {
+        if (params.fields?.length === 1 && params.fields[0] === 'id') {
+          return { data: products.map((p) => ({ id: p.id })), count: products.length }
+        }
+
+        return { data: products, count: products.length }
+      })
+
+      return category
+    }
+
+    it('should keep in-stock pin first when most-relevant', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 100, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(60) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'C'])
+    })
+
+    it('should place in-stock Novo after pins ordered by createdAt desc', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 100, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'B', shoppingCount: 5, createdAt: daysAgo(20) }),
+        buildProduct({ id: 'A', shoppingCount: 5, createdAt: daysAgo(5) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(60) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'A', 'B', 'C'])
+    })
+
+    it('should not duplicate a pinned Novo', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 50, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(3) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'C'])
+      expect(result.data.filter((p) => p.id === 'P').length).toBe(1)
+    })
+
+    it('should keep age 0 and 30 days in Novo block and exclude 31 days', async () => {
+      const products = [
+        buildProduct({ id: 'old', shoppingCount: 80, createdAt: daysAgo(31) }),
+        buildProduct({ id: 'edge', shoppingCount: 5, createdAt: daysAgo(30) }),
+        buildProduct({ id: 'fresh', shoppingCount: 5, createdAt: daysAgo(0) }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['fresh', 'edge', 'old'])
+    })
+
+    it('should not treat invalid or future createdAt as Novo', async () => {
+      const products = [
+        buildProduct({ id: 'best', shoppingCount: 90, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'invalid', shoppingCount: 5, createdAt: 'not-a-date' as any }),
+        buildProduct({ id: 'future', shoppingCount: 5, createdAt: new Date(Date.now() + 86400000) }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['best', 'invalid', 'future'])
+    })
+
+    it('should not boost OOS Novo above in-stock bestsellers', async () => {
+      const products = [
+        buildProduct({ id: 'best', shoppingCount: 100, createdAt: daysAgo(60), stock: { quantity: 5 } as any }),
+        buildProduct({
+          id: 'oos-novo',
+          shoppingCount: 1,
+          createdAt: daysAgo(2),
+          stock: { quantity: 0 } as any,
+        }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['best', 'oos-novo'])
+    })
+  })
 })

package/src/services/catalog/strategies/category-search.strategy.ts

@@ -164,9 +164,16 @@ export class CategorySearchStrategy implements CatalogSearchStrategy {
     const firstProducts = totalResult.data
       .filter((product: any) => mostRelevants.includes(product.id) && product.stock.quantity > 0)
       .sort((a: any, b: any) => mostRelevants.indexOf(a.id) - mostRelevants.indexOf(b.id))
-    const lastProducts = totalResult.data
-      .filter((product: any) => !mostRelevants.includes(product.id))
-      .concat(mostRelevantWithoutStock)
+
+    const nonPinnedProducts = totalResult.data.filter((product: any) => !mostRelevants.includes(product.id))
+    const novoProducts = nonPinnedProducts
+      .filter((product: any) => product.stock?.quantity > 0 && this.isCreatedWithinLastDays(product.createdAt, 30))
+      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+    const restProducts = nonPinnedProducts.filter(
+      (product: any) => !(product.stock?.quantity > 0 && this.isCreatedWithinLastDays(product.createdAt, 30)),
+    )
+
+    const lastProducts = novoProducts.concat(restProducts).concat(mostRelevantWithoutStock)
     const categoryMostRelevants = firstProducts.concat(lastProducts)
     const resultFinal = categoryMostRelevants.slice(limits.offset, limits.offset + limits.limit)
 
@@ -178,4 +185,23 @@ export class CategorySearchStrategy implements CatalogSearchStrategy {
       distinct: totalResult.distinct,
     }
   }
+
+  private isCreatedWithinLastDays(createdAt: string | Date | undefined, days: number): boolean {
+    if (!createdAt || days <= 0) {
+      return false
+    }
+
+    const createdDate = createdAt instanceof Date ? createdAt : new Date(createdAt)
+    if (Number.isNaN(createdDate.getTime())) {
+      return false
+    }
+
+    const diffMs = Date.now() - createdDate.getTime()
+    if (diffMs < 0) {
+      return false
+    }
+
+    const diffDays = diffMs / (1000 * 60 * 60 * 24)
+    return diffDays <= days
+  }
 }

package/src/test.ts

@@ -1,2 +1,3 @@
 // Karma entry required by tsconfig.spec.json. Specs in this package are Jasmine-only.
+;(globalThis as any).global = globalThis
 export {}