125 lines
3.6 KiB
TypeScript
125 lines
3.6 KiB
TypeScript
import { cache } from "react"
|
|
|
|
import {
|
|
type MembershipLevel,
|
|
MembershipLevelEnum,
|
|
} from "@/constants/membershipLevels"
|
|
import {
|
|
GetAllLoyaltyLevels,
|
|
GetLoyaltyLevel,
|
|
} from "@/lib/graphql/Query/LoyaltyLevels.graphql"
|
|
import { request } from "@/lib/graphql/request"
|
|
import { notFound } from "@/server/errors/trpc"
|
|
import { createCounter } from "@/server/telemetry"
|
|
import { contentstackBaseProcedure, router } from "@/server/trpc"
|
|
|
|
import { generateLoyaltyConfigTag } from "@/utils/generateTag"
|
|
|
|
import { loyaltyLevelInput } from "./input"
|
|
import {
|
|
type LoyaltyLevel,
|
|
type LoyaltyLevelsResponse,
|
|
validateLoyaltyLevelsSchema,
|
|
} from "./output"
|
|
|
|
import type { Context } from "@/server/context"
|
|
|
|
export const getAllLoyaltyLevels = cache(async (ctx: Context) => {
|
|
const getLoyaltyLevelAllCounter = createCounter(
|
|
"trpc.contentstack",
|
|
"loyaltyLevel.all"
|
|
)
|
|
const metricsGetLoyaltyLevelAll = getLoyaltyLevelAllCounter.init()
|
|
|
|
metricsGetLoyaltyLevelAll.start()
|
|
|
|
// Ideally we should fetch all available tiers from API, but since they
|
|
// are static, we can just use the enum values. We want to know which
|
|
// levels we are fetching so that we can use tags to cache them
|
|
const allLevelIds = Object.values(MembershipLevelEnum)
|
|
|
|
const tags = allLevelIds.map((levelId) =>
|
|
generateLoyaltyConfigTag(ctx.lang, "loyalty_level", levelId)
|
|
)
|
|
|
|
const loyaltyLevelsConfigResponse = await request<LoyaltyLevelsResponse>(
|
|
GetAllLoyaltyLevels,
|
|
{ lang: ctx.lang, level_ids: allLevelIds },
|
|
{ key: tags, ttl: "max" }
|
|
)
|
|
|
|
if (!loyaltyLevelsConfigResponse.data) {
|
|
const notFoundError = notFound(loyaltyLevelsConfigResponse)
|
|
metricsGetLoyaltyLevelAll.noDataError()
|
|
throw notFoundError
|
|
}
|
|
|
|
const validatedLoyaltyLevels = validateLoyaltyLevelsSchema.safeParse(
|
|
loyaltyLevelsConfigResponse.data
|
|
)
|
|
if (!validatedLoyaltyLevels.success) {
|
|
metricsGetLoyaltyLevelAll.validationError(validatedLoyaltyLevels.error)
|
|
return []
|
|
}
|
|
|
|
metricsGetLoyaltyLevelAll.success()
|
|
|
|
return validatedLoyaltyLevels.data
|
|
})
|
|
|
|
export const getLoyaltyLevel = cache(
|
|
async (ctx: Context, level_id: MembershipLevel) => {
|
|
const getLoyaltyLevelCounter = createCounter(
|
|
"trpc.contentstack",
|
|
"loyaltyLevel.get"
|
|
)
|
|
const metricsGetLoyaltyLevel = getLoyaltyLevelCounter.init({
|
|
lang: ctx.lang,
|
|
level_id,
|
|
})
|
|
|
|
metricsGetLoyaltyLevel.start()
|
|
|
|
const loyaltyLevelsConfigResponse = await request<LoyaltyLevelsResponse>(
|
|
GetLoyaltyLevel,
|
|
{ lang: ctx.lang, level_id },
|
|
{
|
|
key: generateLoyaltyConfigTag(ctx.lang, "loyalty_level", level_id),
|
|
ttl: "max",
|
|
}
|
|
)
|
|
if (
|
|
!loyaltyLevelsConfigResponse.data ||
|
|
!loyaltyLevelsConfigResponse.data.all_loyalty_level.items.length
|
|
) {
|
|
const notFoundError = notFound(loyaltyLevelsConfigResponse)
|
|
metricsGetLoyaltyLevel.noDataError()
|
|
throw notFoundError
|
|
}
|
|
|
|
const validatedLoyaltyLevels = validateLoyaltyLevelsSchema.safeParse(
|
|
loyaltyLevelsConfigResponse.data
|
|
)
|
|
if (!validatedLoyaltyLevels.success) {
|
|
metricsGetLoyaltyLevel.validationError(validatedLoyaltyLevels.error)
|
|
return null
|
|
}
|
|
|
|
metricsGetLoyaltyLevel.success()
|
|
|
|
const result: LoyaltyLevel = validatedLoyaltyLevels.data[0]
|
|
return result
|
|
}
|
|
)
|
|
|
|
export const loyaltyLevelQueryRouter = router({
|
|
byLevel: contentstackBaseProcedure
|
|
.input(loyaltyLevelInput)
|
|
.query(async function ({ ctx, input }) {
|
|
return getLoyaltyLevel(ctx, input.level)
|
|
}),
|
|
all: contentstackBaseProcedure.query(async function ({ ctx }) {
|
|
return getAllLoyaltyLevels(ctx)
|
|
}),
|
|
})
|