freshyo/apps/backend/src/trpc/apis/common-apis/common.ts
2026-10-08 19:48:14 +05:30

151 lines
5.7 KiB
TypeScript

import { router, publicProcedure, protectedProcedure } from '@/src/trpc/trpc-index'
import {
getSuspendedSkuIds,
getNextDeliveryDateWithCapacity,
getAllSkusSummary as getAllSkusSummaryInDb,
getAllTagsForCache,
getAllTagProductMappings,
getAvailabilityForCache,
getAllProductsForCache,
getAllDeliverySlotsForCache,
} from '@/src/dbService'
import { generateSignedUrlsFromS3Urls, generateSignedUrlFromS3Url, scaffoldAssetUrl } from '@/src/lib/s3-client'
import { getRegionConstValues } from '@/src/lib/const-store'
import { CONST_KEYS } from '@/src/lib/const-keys'
// Re-export with original name for backwards compatibility
export const getNextDeliveryDate = getNextDeliveryDateWithCapacity
export async function scaffoldProducts(regionId: number) {
// Scoped DB reads directly (NOT the in-memory product-store) so the output
// contains ONLY in-region SKUs/products/tags.
const [productsData, suspendedSkuIds, allTags, tagMappings, deliveryRows] = await Promise.all([
getAllProductsForCache(regionId),
getSuspendedSkuIds(regionId),
getAllTagsForCache(regionId),
getAllTagProductMappings(regionId),
getAllDeliverySlotsForCache(regionId),
])
const suspended = new Set(suspendedSkuIds)
const products = productsData.filter(item => Boolean(item.id) && !suspended.has(item.id))
// Latest in-region delivery slot per SKU (matches the old DESC first-match
// semantics of getNextDeliveryDateWithCapacity).
const nextDeliveryBySku = new Map<number, Date>()
for (const row of deliveryRows) {
const prev = nextDeliveryBySku.get(row.skuId)
if (!prev || row.deliveryTime > prev) {
nextDeliveryBySku.set(row.skuId, row.deliveryTime)
}
}
// Format products to match the expected response structure
const formattedProducts = products.map((product) => {
const nextDeliveryDate = nextDeliveryBySku.get(product.id) ?? null
return {
id: product.id,
name: product.name,
shortDescription: product.shortDescription,
unit: product.unitNotation,
unitNotation: product.unitNotation,
incrementStep: product.incrementStep,
productQuantity: product.productQuantity,
storeId: product.storeId ?? null,
isOutOfStock: product.isOutOfStock,
nextDeliveryDate: nextDeliveryDate ? nextDeliveryDate.toISOString() : null,
images: scaffoldAssetUrl((product.images as string[]) || []),
productType: product.productType || 'item',
isComboOnly: product.isComboOnly,
isOffer: product.isOffer,
price: Number(product.price ?? 0),
marketPrice: product.marketPrice != null ? Number(product.marketPrice) : null,
flashPrice: product.flashPrice != null ? Number(product.flashPrice) : null,
isFlashAvailable: product.isFlashAvailable,
};
})
// Order tags by the region's admin-defined tagsOrder (unknown tags go to the end).
const regionConsts = await getRegionConstValues(regionId)
const tagsOrderRaw = regionConsts[CONST_KEYS.tagsOrder]
let tagsOrderIds: number[] = []
if (Array.isArray(tagsOrderRaw)) {
tagsOrderIds = tagsOrderRaw.map((id: any) => parseInt(id)).filter((id: number) => !isNaN(id))
} else if (typeof tagsOrderRaw === 'string') {
tagsOrderIds = tagsOrderRaw.split(',').map((id: string) => parseInt(id.trim())).filter((id: number) => !isNaN(id))
}
const tagsById = new Map(allTags.map((tag: any) => [tag.id, tag]))
const orderedTags: any[] = []
for (const id of tagsOrderIds) {
const tag = tagsById.get(id)
if (tag) {
orderedTags.push(tag)
tagsById.delete(id)
}
}
for (const tag of tagsById.values()) {
orderedTags.push(tag)
}
const productIdsByTag = new Map<number, number[]>()
for (const mapping of tagMappings) {
if (!productIdsByTag.has(mapping.tagId)) {
productIdsByTag.set(mapping.tagId, [])
}
productIdsByTag.get(mapping.tagId)!.push(mapping.productId)
}
// Reorder each tag's product ids by the admin-defined sortOrder (unknown products go to the end).
const reorderProductIds = (tagId: number, tagSortOrder: number[] | undefined) => {
const current = productIdsByTag.get(tagId) || []
if (!Array.isArray(tagSortOrder) || tagSortOrder.length === 0) {
return current
}
const ordered = tagSortOrder.filter((id: number) => current.includes(id))
const rest = current.filter((id: number) => !ordered.includes(id))
return [...ordered, ...rest]
}
const tags = orderedTags.map((tag: { id: number; tagName: string; tagDescription: string | null; imageUrl: string | null; isDashboardTag: boolean; relatedStores: unknown; sortOrder: number[] | null }) => ({
id: tag.id,
tagName: tag.tagName,
tagDescription: tag.tagDescription,
imageUrl: tag.imageUrl ? scaffoldAssetUrl(tag.imageUrl) : null,
isDashboardTag: tag.isDashboardTag,
relatedStores: (tag.relatedStores as number[]) || [],
productIds: reorderProductIds(tag.id, tag.sortOrder ?? undefined),
}))
return {
products: formattedProducts,
count: formattedProducts.length,
tags,
};
}
export async function scaffoldAvailability(regionId: number) {
const availability = await getAvailabilityForCache(regionId)
return {
availability,
count: availability.length,
};
}
export const commonRouter = router({
getAllProductsSummary: protectedProcedure
.query(async ({ ctx }) => {
// Admin-only (the customer apps read the regional CDN cache files, not
// this endpoint): return the caller's OWN region only.
return scaffoldProducts(ctx.staffUser!.regionId)
}),
getAllSkusSummary: protectedProcedure
.query(async ({ ctx }) => {
// Admin-only SKU picker; scoped to the caller's region.
const skus = await getAllSkusSummaryInDb(ctx.staffUser!.regionId)
return { skus }
}),
});