scandic/web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merged in feat/sw-2866-move-partners-router-to-trpc-package (pull request #2414)

Browse Source 
feat(sw-2866): Move partners router to trpc package

* Add eslint to trpc package

* Apply lint rules

* Use direct imports from trpc package

* Add lint-staged config to trpc

* Move lang enum to common

* Restructure trpc package folder structure

* WIP first step

* update internal imports in trpc

* Fix most errors in scandic-web

Just 100 left...

* Move Props type out of trpc

* Fix CategorizedFilters types

* Move more schemas in hotel router

* Fix deps

* fix getNonContentstackUrls

* Fix import error

* Fix entry error handling

* Fix generateMetadata metrics

* Fix alertType enum

* Fix duplicated types

* lint:fix

* Merge branch 'master' into feat/sw-2863-move-contentstack-router-to-trpc-package

* Fix broken imports

* Move booking router to trpc package

* Move partners router to trpc package

* Merge branch 'master' into feat/sw-2866-move-partners-router-to-trpc-package


Approved-by: Linus Flood
This commit is contained in:
Anton Gunnarsson
2025-06-26 09:44:13 +00:00
parent 395d466c51
commit f9c719ff4b
31 changed files with 63 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
apps/scandic-web/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/callback/route.ts
View File

@@ -3,11 +3,12 @@ import { redirect } from "next/navigation"
import { z } from "zod"
import { safeTry } from "@scandic-hotels/common/utils/safeTry"
import { SAS_TOKEN_STORAGE_KEY } from "@scandic-hotels/trpc/constants/partnerSAS"
import { env } from "@/env/server"
import { serverClient } from "@/lib/trpc/server"
import { SAS_TOKEN_STORAGE_KEY, stateSchema } from "../sasUtils"
import { stateSchema } from "../sasUtils"
import type { NextRequest } from "next/server"

3
apps/scandic-web/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/otp/OneTimePasswordForm.tsx
View File

@@ -19,7 +19,8 @@ import Loading from "./loading"
import styles from "./OneTimePasswordForm.module.css"
import type { RequestOtpError } from "@/server/routers/partners/sas/otp/request/requestOtpError"
import type { RequestOtpError } from "@scandic-hotels/trpc/routers/partners/sas/otp/request/requestOtpError"
import type { OtpError } from "./page"
type Redirect = { url: string; type?: "replace" | "push" }

5
apps/scandic-web/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/otp/page.tsx
View File

@@ -3,13 +3,16 @@ import { redirect } from "next/navigation"
import { z } from "zod"
import { safeTry } from "@scandic-hotels/common/utils/safeTry"
import {
SAS_TOKEN_STORAGE_KEY,
SAS_TRANSFER_POINT_KEY,
} from "@scandic-hotels/trpc/constants/partnerSAS"
import { myPages } from "@/constants/routes/myPages"
import { serverClient } from "@/lib/trpc/server"
import { getIntl } from "@/i18n"
import { SAS_TOKEN_STORAGE_KEY, SAS_TRANSFER_POINT_KEY } from "../sasUtils"
import OneTimePasswordForm, {
type OnSubmitHandler,
} from "./OneTimePasswordForm"

3
apps/scandic-web/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/sasUtils.ts
View File

@@ -1,8 +1,5 @@
import { z } from "zod"
export const SAS_TOKEN_STORAGE_KEY = "sas-x-scandic-token"
export const SAS_TRANSFER_POINT_KEY = "sas-x-scandic-eb-points"
export const stateSchema = z.object({
intent: z.enum(["link", "unlink", "transfer"]),
})

2
apps/scandic-web/components/Blocks/DynamicContent/SAS/TransferPoints/TransferPointsFormClient.tsx
View File

@@ -18,8 +18,8 @@ import { useIntl } from "react-intl"
import { MaterialIcon } from "@scandic-hotels/design-system/Icons/MaterialIcon"
import { Input } from "@scandic-hotels/design-system/Input"
import { Typography } from "@scandic-hotels/design-system/Typography"
import { SAS_TRANSFER_POINT_KEY } from "@scandic-hotels/trpc/constants/partnerSAS"
import { SAS_TRANSFER_POINT_KEY } from "@/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/sasUtils"
import Image from "@/components/Image"
import Modal from "@/components/Modal"
import Button from "@/components/TempDesignSystem/Button"

10
apps/scandic-web/constants/membershipLevels.ts
View File

@@ -2,16 +2,6 @@ import { MembershipLevelEnum } from "@scandic-hotels/common/constants/membership
import type { EurobonusTier } from "@scandic-hotels/trpc/types/user"
export const FriendsMembershipLevels = [
"L1",
"L2",
"L3",
"L4",
"L5",
"L6",
"L7",
] as const
export enum membershipLevels {
L1 = 1,
L2 = 2,

2
apps/scandic-web/server/index.ts
View File

@@ -2,11 +2,11 @@
import { router } from "@scandic-hotels/trpc"
import { contentstackRouter } from "@scandic-hotels/trpc/routers/contentstack"
import { hotelsRouter } from "@scandic-hotels/trpc/routers/hotels"
import { partnerRouter } from "@scandic-hotels/trpc/routers/partners"
import { autocompleteRouter } from "./routers/autocomplete"
import { bookingRouter } from "./routers/booking"
import { navigationRouter } from "./routers/navigation"
import { partnerRouter } from "./routers/partners"
import { userRouter } from "./routers/user"
export const appRouter = router({

9
apps/scandic-web/server/routers/partners/index.ts
View File

@@ -1,9 +0,0 @@
import { router } from "@scandic-hotels/trpc"
import { jobylonQueryRouter } from "./jobylon/query"
import { sasRouter } from "./sas"
export const partnerRouter = router({
sas: sasRouter,
jobylon: jobylonQueryRouter,
})

129
apps/scandic-web/server/routers/partners/jobylon/output.ts
View File

@@ -1,129 +0,0 @@
import { z } from "zod"
import { dt } from "@scandic-hotels/common/dt"
const categoriesSchema = z
.array(
z
.object({ category: z.object({ id: z.number(), text: z.string() }) })
.transform(({ category }) => {
return {
id: category.id,
text: category.text,
}
})
)
.transform((categories) =>
categories.filter(
(category): category is NonNullable<typeof category> => !!category
)
)
const departmentsSchema = z
.array(
z
.object({
department: z.object({
id: z.number(),
name: z.string(),
}),
})
.transform(({ department }) => {
if (!department.id || !department.name) {
return null
}
return {
id: department.id,
name: department.name,
}
})
)
.transform((departments) =>
departments.filter(
(department): department is NonNullable<typeof department> => !!department
)
)
const locationsSchema = z
.array(
z
.object({
location: z.object({
city: z.string().nullish(),
country: z.string().nullish(),
place_id: z.string().nullish(),
country_short: z.string().nullish(),
}),
})
.transform(({ location }) => {
if (!location.city || !location.country) {
return null
}
return {
city: location.city,
country: location.country,
countryShort: location.country_short ?? null,
placeId: location.place_id ?? null,
}
})
)
.transform((locations) =>
locations.filter(
(location): location is NonNullable<typeof location> => !!location
)
)
const urlsSchema = z
.object({
apply: z.string(),
ad: z.string(),
})
.transform(({ ad }) => ad)
export const jobylonItemSchema = z
.object({
id: z.number(),
title: z.string(),
from_date: z.string().nullish(),
to_date: z.string().nullish(),
categories: categoriesSchema,
departments: departmentsSchema,
locations: locationsSchema,
urls: urlsSchema,
})
.transform(
({
id,
from_date,
to_date,
title,
categories,
departments,
locations,
urls,
}) => {
const now = dt.utc()
const fromDate = from_date ? dt(from_date) : null
const toDate = to_date ? dt(to_date) : null
// Transformed to string as Dayjs objects cannot be passed to client components
const toDateAsString = toDate?.toString() ?? null
return {
id,
title,
isActive:
fromDate &&
now.isSameOrAfter(fromDate) &&
(!toDate || now.isSameOrBefore(toDate)),
categories,
departments,
toDate: toDateAsString,
locations,
url: urls,
}
}
)
export const jobylonFeedSchema = z
.array(jobylonItemSchema)
.transform((jobs) => jobs.filter((job) => job.isActive))

70
apps/scandic-web/server/routers/partners/jobylon/query.ts
View File

@@ -1,70 +0,0 @@
import { getCacheClient } from "@scandic-hotels/common/dataCache"
import { createCounter } from "@scandic-hotels/common/telemetry"
import { router } from "@scandic-hotels/trpc"
import { publicProcedure } from "@scandic-hotels/trpc/procedures"
import { jobylonFeedSchema } from "./output"
export const TWENTYFOUR_HOURS = 60 * 60 * 24
// The URL for the Jobylon feed including the hash for the specific feed.
// The URL and hash are generated by Jobylon. Documentation: https://developer.jobylon.com/feed-api
const feedUrl =
"https://feed.jobylon.com/feeds/cc04ba19-f0bd-4412-8b9b-d1d1fcbf0800"
export const jobylonQueryRouter = router({
feed: router({
get: publicProcedure.query(async function () {
const jobylonFeedGetCounter = createCounter("trpc.jobylon.feed", "get")
const metricsJobylonFeedGet = jobylonFeedGetCounter.init()
metricsJobylonFeedGet.start()
const url = new URL(feedUrl)
url.search = new URLSearchParams({
format: "json",
}).toString()
const cacheClient = await getCacheClient()
const result = cacheClient.cacheOrGet(
"jobylon:feed",
async () => {
const response = await fetch(url, {
cache: "no-cache",
signal: AbortSignal.timeout(15_000),
})
if (!response.ok) {
await metricsJobylonFeedGet.httpError(response)
const text = await response.text()
throw new Error(
`Failed to fetch Jobylon feed: ${JSON.stringify({
status: response.status,
statusText: response.statusText,
text,
})}`
)
}
const responseJson = await response.json()
const validatedResponse = jobylonFeedSchema.safeParse(responseJson)
if (!validatedResponse.success) {
metricsJobylonFeedGet.validationError(validatedResponse.error)
throw new Error(
`Failed to parse Jobylon feed: ${JSON.stringify(validatedResponse.error)}`
)
}
return validatedResponse.data
},
"1d"
)
metricsJobylonFeedGet.success()
return result
}),
}),
})

11
apps/scandic-web/server/routers/partners/sas/getSasToken.ts
View File

@@ -1,11 +0,0 @@
import { cookies } from "next/headers"
import { SAS_TOKEN_STORAGE_KEY } from "@/app/[lang]/(partner)/(sas)/(protected)/sas-x-scandic/sasUtils"
export async function getSasToken() {
const cookieStore = await cookies()
const tokenCookie = cookieStore.get(SAS_TOKEN_STORAGE_KEY)
const sasAuthToken = tokenCookie?.value
return sasAuthToken
}

17
apps/scandic-web/server/routers/partners/sas/index.ts
View File

@@ -1,17 +0,0 @@
import { router } from "@scandic-hotels/trpc"
import { requestOtp } from "./otp/request/requestOtp"
import { verifyOtp } from "./otp/verify/verifyOtp"
import { linkAccount } from "./linkAccount"
import { performLevelUpgrade } from "./performLevelUpgrade"
import { transferPoints } from "./transferPoints"
import { unlinkAccount } from "./unlinkAccount"
export const sasRouter = router({
verifyOtp,
requestOtp,
linkAccount,
unlinkAccount,
performLevelUpgrade,
transferPoints,
})

116
apps/scandic-web/server/routers/partners/sas/linkAccount.ts
View File

@@ -1,116 +0,0 @@
import * as Sentry from "@sentry/nextjs"
import { z } from "zod"
import * as api from "@scandic-hotels/trpc/api"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { getOTPState } from "./otp/getOTPState"
import { getSasToken } from "./getSasToken"
const outputSchema = z.object({
linkingState: z.enum([
"linked",
"alreadyLinked",
"dateOfBirthMismatch",
"nameNotMatched",
"blockedForRelink",
"accountToNew",
"error",
]),
})
export const linkAccount = protectedProcedure
.output(outputSchema)
.mutation(async function ({ ctx }) {
const sasAuthToken = await getSasToken()
const { referenceId } = await getOTPState()
console.log("[SAS] link account")
const apiResponse = await api.post(api.endpoints.v1.Profile.link, {
headers: {
Authorization: `Bearer ${ctx.session.token.access_token}`,
},
body: {
partner: "sas_eb",
tocDate: getCurrentDateWithoutTime(),
partnerSpecific: {
eurobonusAccessToken: sasAuthToken,
eurobonusOtpReferenceId: referenceId,
},
},
})
const linkedAndBoosted = apiResponse.status === 200
const linkedWithoutBoost = apiResponse.status === 204
const linkedWithUnknownBoost = apiResponse.status === 202
const linked =
linkedAndBoosted || linkedWithoutBoost || linkedWithUnknownBoost
if (linked) {
console.log("[SAS] link account done")
return { linkingState: "linked" }
}
if (apiResponse.status === 400) {
const result = await apiResponse.json()
const data = badRequestSchema.safeParse(result)
if (!data.success) {
const linkAccountBadRequestSchemaError = `[SAS] failed to parse link account bad request schema ${JSON.stringify(data.error)}`
console.error(linkAccountBadRequestSchemaError)
Sentry.captureMessage(linkAccountBadRequestSchemaError)
return { linkingState: "error" }
}
console.log("[SAS] link account error with response", result)
const { errors } = data.data
if (errors.some((x) => x.code === "BirthDateNotMatched")) {
return { linkingState: "dateOfBirthMismatch" }
}
if (errors.some((x) => x.code === "BlockedForRelink")) {
return { linkingState: "blockedForRelink" }
}
if (errors.some((x) => x.code === "AccountToNew")) {
return { linkingState: "accountToNew" }
}
if (errors.some((x) => x.code === "NameNotMatched")) {
return { linkingState: "nameNotMatched" }
}
if (errors.some((x) => x.code === "AlreadyLinked")) {
return { linkingState: "alreadyLinked" }
}
return { linkingState: "error" }
}
if (apiResponse.status === 409) {
return { linkingState: "alreadyLinked" }
}
const errorMessage = `[SAS] link account error with status code ${apiResponse.status} and response ${await apiResponse.text()}`
console.warn(errorMessage)
Sentry.captureMessage(errorMessage)
return { linkingState: "error" }
})
function getCurrentDateWithoutTime() {
return new Date().toISOString().slice(0, 10)
}
const badRequestSchema = z.object({
errors: z.array(
z.object({
code: z.enum([
"BirthDateNotMatched",
"NameNotMatched",
"AlreadyLinked",
"BlockedForRelink",
"AccountToNew",
"UnknownReason",
]),
details: z.string().optional(),
})
),
})

2
apps/scandic-web/server/routers/partners/sas/otp/constants.ts
View File

@@ -1,2 +0,0 @@
export const SAS_REQUEST_OTP_STATE_STORAGE_COOKIE_NAME =
"sas-x-scandic-request-otp-state"

18
apps/scandic-web/server/routers/partners/sas/otp/getOTPState.ts
View File

@@ -1,18 +0,0 @@
import { cookies } from "next/headers"
import { z } from "zod"
import { SAS_REQUEST_OTP_STATE_STORAGE_COOKIE_NAME } from "./constants"
const otpStateSchema = z.object({
referenceId: z.string().uuid(),
databaseUUID: z.string().uuid(),
})
export type OtpState = z.infer<typeof otpStateSchema>
export async function getOTPState() {
const cookieStore = await cookies()
const otpState = cookieStore.get(SAS_REQUEST_OTP_STATE_STORAGE_COOKIE_NAME)
return otpStateSchema.parse(JSON.parse(otpState?.value ?? "{}"))
}

138
apps/scandic-web/server/routers/partners/sas/otp/request/requestOtp.ts
View File

@@ -1,138 +0,0 @@
import * as Sentry from "@sentry/nextjs"
import { TRPCError } from "@trpc/server"
import { cookies } from "next/headers"
import { v4 as uuidv4 } from "uuid"
import { z } from "zod"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { env } from "@/env/server"
import { getSasToken } from "../../getSasToken"
import { SAS_REQUEST_OTP_STATE_STORAGE_COOKIE_NAME } from "../constants"
import {
parseSASRequestOtpError,
type RequestOtpGeneralError,
} from "./requestOtpError"
import type { OtpState } from "../getOTPState"
const successSchema = z.object({
status: z.literal("SENT"),
referenceId: z.string().uuid(),
databaseUUID: z.string().uuid(),
otpExpiration: z.number(),
otpReceiver: z.string(),
})
const failureSchema = z.object({
status: z.enum([
"VERIFIED",
"ABUSED",
"EXPIRED",
"PENDING",
"RETRY",
"NULL",
"NOTSENT",
]),
})
const outputSchema = z.union([successSchema, failureSchema])
export const requestOtp = protectedProcedure
.output(outputSchema)
.mutation(async function () {
const sasAuthToken = await getSasToken()
if (!sasAuthToken) {
throw createError("AUTH_TOKEN_NOT_FOUND")
}
const tokenResponse = await fetchRequestOtp({ sasAuthToken })
console.log(
"[SAS] requestOtp",
tokenResponse.status,
tokenResponse.statusText
)
const body = await tokenResponse.json()
const parseResult = outputSchema.safeParse(body)
if (!parseResult.success) {
console.error("[SAS] requestOtp error", body)
if (!tokenResponse.ok) {
throw createError(body)
}
throw createError(parseResult.error)
}
if (parseResult.data.status === "SENT") {
setSASOtpCookie(parseResult.data)
} else {
const sasRequestOtpErrorMessage = `[SAS] requestOtp did not return SENT status with body: ${JSON.stringify(body)}`
console.warn(sasRequestOtpErrorMessage)
Sentry.captureMessage(sasRequestOtpErrorMessage)
}
return parseResult.data
})
function createError(
errorBody:
| {
status: string
error: string
errorCode: number
databaseUUID: string
}
| Error
| RequestOtpGeneralError
): TRPCError {
const errorInfo = parseSASRequestOtpError(errorBody)
console.error("[SAS] createError", errorInfo)
return new TRPCError({
code: "BAD_REQUEST",
cause: errorInfo,
})
}
async function fetchRequestOtp({ sasAuthToken }: { sasAuthToken: string }) {
const endpoint = `${env.SAS_API_ENDPOINT}/api/scandic-partnership/customer/send-otp`
console.log("[SAS]: Requesting OTP")
return await fetch(endpoint, {
method: "POST",
headers: {
"Content-Type": "application/json",
"Ocp-Apim-Subscription-Key": env.SAS_OCP_APIM,
Authorization: `Bearer ${sasAuthToken}`,
},
body: JSON.stringify({
referenceId: uuidv4(),
}),
signal: AbortSignal.timeout(15_000),
})
}
async function setSASOtpCookie({
referenceId,
databaseUUID,
}: {
referenceId: string
databaseUUID: string
}) {
const cookieStore = await cookies()
cookieStore.set(
SAS_REQUEST_OTP_STATE_STORAGE_COOKIE_NAME,
JSON.stringify({
referenceId: referenceId,
databaseUUID: databaseUUID,
} satisfies OtpState),
{
httpOnly: true,
maxAge: 3600,
secure: env.NODE_ENV !== "development",
}
)
}

17
apps/scandic-web/server/routers/partners/sas/otp/request/requestOtpError.test.ts
View File

@@ -1,17 +0,0 @@
import { describe, expect, it } from "@jest/globals"
import { parseSASRequestOtpError } from "./requestOtpError"
describe("requestOtpError", () => {
it("parses error with invalid error code", () => {
const actual = parseSASRequestOtpError({
status: "status",
error: "error",
errorCode: "a" as unknown as number,
databaseUUID: "9ffefefe-df0e-4229-9792-5ed31bef1db4",
} as any)
expect(actual).toEqual({
errorCode: "UNKNOWN",
})
})
})

70
apps/scandic-web/server/routers/partners/sas/otp/request/requestOtpError.ts
View File

@@ -1,70 +0,0 @@
import { z } from "zod"
export type RequestOtpResponseError = "TOO_MANY_REQUESTS" | "UNKNOWN"
const requestOtpGeneralError = z.enum([
"AUTH_TOKEN_EXPIRED",
"AUTH_TOKEN_NOT_FOUND",
"UNKNOWN",
])
export type RequestOtpGeneralError = z.infer<typeof requestOtpGeneralError>
export type RequestOtpError = {
errorCode: RequestOtpResponseError | RequestOtpGeneralError
}
export function parseSASRequestOtpError(
error: SasOtpRequestError | {}
): RequestOtpError {
const parseResult = sasOtpRequestErrorSchema.safeParse(error)
if (!parseResult.success) {
const generalErrorResult = requestOtpGeneralError.safeParse(error)
if (!generalErrorResult.success) {
return {
errorCode: "UNKNOWN",
}
}
return {
errorCode: generalErrorResult.data,
}
}
return {
errorCode: getErrorCodeByNumber(parseResult.data.errorCode),
}
}
const SAS_REQUEST_OTP_ERROR_CODES: {
[key in Exclude<RequestOtpResponseError, "UNKNOWN">]: number
} = {
TOO_MANY_REQUESTS: 10,
}
const getErrorCodeByNumber = (number: number): RequestOtpResponseError => {
const v =
Object.entries(SAS_REQUEST_OTP_ERROR_CODES).find(
([_, value]) => value === number
)?.[0] ?? "UNKNOWN"
console.log("[SAS] getErrorCodeByNumber", number, v)
return v as RequestOtpResponseError
}
const sasOtpRequestErrorSchema = z.object({
status: z.enum([
"VERIFIED",
"ABUSED",
"EXPIRED",
"PENDING",
"RETRY",
"SENT",
"NULL",
"NOTSENT",
]),
otpExpiration: z.string().datetime(),
error: z.string(),
errorCode: z.number(),
databaseUUID: z.string().uuid(),
})
export type SasOtpRequestError = z.infer<typeof sasOtpRequestErrorSchema>

113
apps/scandic-web/server/routers/partners/sas/otp/verify/verifyOtp.ts
View File

@@ -1,113 +0,0 @@
import { TRPCError } from "@trpc/server"
import { z } from "zod"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { env } from "@/env/server"
import { getSasToken } from "../../getSasToken"
import { getOTPState } from "../getOTPState"
import {
parseSASVerifyOtpError,
type VerifyOtpGeneralError,
} from "./verifyOtpError"
const inputSchema = z.object({
otp: z.string(),
})
const outputSchema = z.object({
status: z.enum([
"VERIFIED",
"ABUSED",
"EXPIRED",
"PENDING",
"RETRY",
"SENT",
"NULL",
"NOTSENT",
]),
referenceId: z.string().uuid().optional(),
databaseUUID: z.string().uuid().optional(),
})
export const verifyOtp = protectedProcedure
.input(inputSchema)
.output(outputSchema)
.mutation(async function ({ input }) {
const sasAuthToken = await getSasToken()
if (!sasAuthToken) {
throw createError("AUTH_TOKEN_NOT_FOUND")
}
const verifyResponse = await fetchVerifyOtp(input)
console.log(
"[SAS] verifyOTP",
verifyResponse.status,
verifyResponse.statusText
)
if (verifyResponse.status > 499) {
console.error("[SAS] verifyOTP error", await verifyResponse.text())
throw new TRPCError({
code: "SERVICE_UNAVAILABLE",
message: "Error from downstream SAS service",
})
}
const data = await verifyResponse.json()
console.log("[SAS] verifyOTP data", data)
const result = outputSchema.safeParse(data)
if (!result.success) {
console.error("[SAS] verifyOTP error", result.error)
throw createError(data)
}
console.log("[SAS] verifyOTP success")
console.log("[SAS] verifyOTP responding", result.data)
return result.data
})
async function fetchVerifyOtp(input: z.infer<typeof inputSchema>) {
const sasAuthToken = await getSasToken()
const { referenceId, databaseUUID } = await getOTPState()
return await fetch(
`${env.SAS_API_ENDPOINT}/api/scandic-partnership/customer/verify-otp`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
"Ocp-Apim-Subscription-Key": env.SAS_OCP_APIM,
Authorization: `Bearer ${sasAuthToken}`,
},
body: JSON.stringify({
referenceId: referenceId,
otpCode: input.otp,
databaseUUID: databaseUUID,
}),
signal: AbortSignal.timeout(15_000),
}
)
}
function createError(
errorBody:
| {
status: string
error: string
errorCode: number
databaseUUID: string
}
| Error
| VerifyOtpGeneralError
): TRPCError {
const errorInfo = parseSASVerifyOtpError(errorBody)
return new TRPCError({
code: "BAD_REQUEST",
cause: errorInfo,
})
}

24
apps/scandic-web/server/routers/partners/sas/otp/verify/verifyOtpError.test.ts
View File

@@ -1,24 +0,0 @@
import { describe, expect, it } from "@jest/globals"
import { parseSASVerifyOtpError } from "./verifyOtpError"
describe("verifyOtpError", () => {
it("parses error with invalid error code", () => {
const error = {
status: "status",
error: "error",
errorCode: "a",
databaseUUID: "9ffefefe-df0e-4229-9792-5ed31bef1db4",
}
const actual = parseSASVerifyOtpError({
status: "status",
error: "error",
errorCode: "a" as unknown as number,
databaseUUID: "9ffefefe-df0e-4229-9792-5ed31bef1db4",
} as any)
expect(actual).toEqual({
errorCode: "UNKNOWN",
})
})
})

57
apps/scandic-web/server/routers/partners/sas/otp/verify/verifyOtpError.ts
View File

@@ -1,57 +0,0 @@
import { z } from "zod"
export type VerifyOtpResponseError = "OTP_EXPIRED" | "WRONG_OTP" | "UNKNOWN"
const VerifyOtpGeneralError = z.enum(["AUTH_TOKEN_NOT_FOUND", "UNKNOWN"])
export type VerifyOtpGeneralError = z.infer<typeof VerifyOtpGeneralError>
export type VerifyOtpError = {
errorCode: VerifyOtpResponseError | VerifyOtpGeneralError
}
export function parseSASVerifyOtpError(
error: SasOtpVerifyError | {}
): VerifyOtpError {
const parseResult = sasOtpVerifyErrorSchema.safeParse(error)
if (!parseResult.success) {
const generalErrorResult = VerifyOtpGeneralError.safeParse(error)
if (!generalErrorResult.success) {
return {
errorCode: "UNKNOWN",
}
}
return {
errorCode: generalErrorResult.data,
}
}
return {
errorCode: getErrorCodeByNumber(parseResult.data.errorCode),
}
}
const SAS_VERIFY_OTP_ERROR_CODES: {
[key in Exclude<VerifyOtpResponseError, "UNKNOWN">]: number
} = {
OTP_EXPIRED: 1,
WRONG_OTP: 2,
}
const getErrorCodeByNumber = (number: number): VerifyOtpResponseError => {
const v =
Object.entries(SAS_VERIFY_OTP_ERROR_CODES).find(
([_, value]) => value === number
)?.[0] ?? "UNKNOWN"
return v as VerifyOtpResponseError
}
const sasOtpVerifyErrorSchema = z.object({
status: z.string(),
otpExpiration: z.string().datetime(),
error: z.string(),
errorCode: z.number(),
databaseUUID: z.string().uuid(),
})
export type SasOtpVerifyError = z.infer<typeof sasOtpVerifyErrorSchema>

106
apps/scandic-web/server/routers/partners/sas/performLevelUpgrade.ts
View File

@@ -1,106 +0,0 @@
import * as Sentry from "@sentry/nextjs"
import { cookies } from "next/headers"
import { z } from "zod"
import * as api from "@scandic-hotels/trpc/api"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { getUserSchema } from "@scandic-hotels/trpc/routers/user/output"
import { getVerifiedUser } from "@scandic-hotels/trpc/routers/user/utils"
import { FriendsMembershipLevels } from "@/constants/membershipLevels"
import type { FriendsTier } from "@scandic-hotels/trpc/types/user"
const matchedSchema = z.object({
tierMatchState: z.enum(["matched"]),
toLevel: z.enum(["L1", "L2", "L3", "L4", "L5", "L6", "L7"]),
})
const notMatchedSchema = z.object({
tierMatchState: z.enum(["alreadyMatched", "notLinked", "error", "cached"]),
})
const outputSchema = z.union([matchedSchema, notMatchedSchema])
export const performLevelUpgrade = protectedProcedure
.output(outputSchema)
.mutation(async function ({ ctx }) {
const cookieStore = await cookies()
const sasTierMatch = cookieStore.get("sasTierMatch")
if (sasTierMatch) {
return { tierMatchState: "cached" }
}
const profile = await getVerifiedUser({ session: ctx.session })
if (!profile || "error" in profile || !profile.data.membership) {
return { tierMatchState: "error" }
}
const currentLevel = profile.data.membership.membershipLevel
console.log("[SAS] tier match started")
const apiResponse = await api.post(api.endpoints.v1.Profile.matchTier, {
headers: {
Authorization: `Bearer ${ctx.session.token.access_token}`,
},
body: {
partner: "sas_eb",
partnerSpecific: {},
},
})
cookieStore.set("sasTierMatch", "true", {
maxAge: 60 * 60 * 24,
httpOnly: true,
})
const updated = apiResponse.status === 200
if (updated) {
console.log("[SAS] tier match complete - boosted")
const result = await apiResponse.json()
const user = getUserSchema.parse(result)
if (!user.membership) {
const tierMatchErrorNoMembershipMessage =
"[SAS] tier match error - no membership"
console.log(tierMatchErrorNoMembershipMessage)
Sentry.captureException(new Error(tierMatchErrorNoMembershipMessage))
return { tierMatchState: "error" }
}
const newLevel = user.membership.membershipLevel
if (isHigherLevel(newLevel, currentLevel)) {
return { tierMatchState: "matched", toLevel: newLevel }
}
return { tierMatchState: "alreadyMatched" }
}
const matchedNoChange = apiResponse.status === 204
if (matchedNoChange) {
console.log("[SAS] tier match complete - no change")
return { tierMatchState: "alreadyMatched" }
}
const notLinked = apiResponse.status === 404
if (notLinked) {
const tierMatchErrorNotLinkedMessage =
"[SAS] tier match error - not linked"
console.warn(tierMatchErrorNotLinkedMessage)
Sentry.captureMessage(tierMatchErrorNotLinkedMessage)
return { tierMatchState: "notLinked" }
}
const tierMatchErrorMessage = `[SAS] tier match error with status code ${apiResponse.status} and response ${await apiResponse.text()}`
console.error(tierMatchErrorMessage)
Sentry.captureException(new Error(tierMatchErrorMessage))
return { tierMatchState: "error" }
})
function isHigherLevel(
newLevel: FriendsTier,
currentLevel: FriendsTier
): boolean {
const currentIndex = FriendsMembershipLevels.indexOf(currentLevel)
const newIndex = FriendsMembershipLevels.indexOf(newLevel)
return newIndex > currentIndex
}

72
apps/scandic-web/server/routers/partners/sas/transferPoints.ts
View File

@@ -1,72 +0,0 @@
import * as Sentry from "@sentry/nextjs"
import { z } from "zod"
import * as api from "@scandic-hotels/trpc/api"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { getOTPState } from "./otp/getOTPState"
import { getSasToken } from "./getSasToken"
const outputSchema = z.object({
transferState: z.enum(["success", "notLinked", "error"]),
})
const transferPointsInputSchema = z.object({
points: z.number(),
})
export const transferPoints = protectedProcedure
.output(outputSchema)
.input(transferPointsInputSchema)
.mutation(async function ({ ctx, input }) {
const sasAuthToken = await getSasToken()
const { referenceId } = await getOTPState()
const apiResponse = await api.post(api.endpoints.v1.Profile.pointTransfer, {
headers: {
Authorization: `Bearer ${ctx.session.token.access_token}`,
},
body: {
partner: "sas_eb",
partnerPoints: input.points,
partnerSpecific: {
eurobonusAccessToken: sasAuthToken,
eurobonusOtpReferenceId: referenceId,
},
},
})
if (apiResponse.status === 204) {
return { transferState: "success" }
}
if (apiResponse.status === 400) {
const result = await apiResponse.json()
const data = badRequestSchema.safeParse(result)
if (!data.success) {
const transferPointsBadRequestSchemaError = `[SAS] failed to parse transfer points bad request schema ${JSON.stringify(data.error)}`
console.error(transferPointsBadRequestSchemaError)
Sentry.captureMessage(transferPointsBadRequestSchemaError)
return { transferState: "error" }
}
}
if (apiResponse.status === 404) {
const transferPointsNotFoundError = `[SAS] transfer points failed, no active partner link`
console.error(transferPointsNotFoundError)
Sentry.captureMessage(transferPointsNotFoundError)
return { transferState: "notLinked" }
}
const errorMessage = `[SAS] transfer points error with status code ${apiResponse.status} and response ${await apiResponse.text()}`
console.warn(errorMessage)
Sentry.captureMessage(errorMessage)
return { transferState: "error" }
})
const badRequestSchema = z.object({
errors: z.array(
z.object({
code: z.string(),
details: z.string().optional(),
})
),
})

53
apps/scandic-web/server/routers/partners/sas/unlinkAccount.ts
View File

@@ -1,53 +0,0 @@
import { z } from "zod"
import * as api from "@scandic-hotels/trpc/api"
import { protectedProcedure } from "@scandic-hotels/trpc/procedures"
import { getOTPState } from "./otp/getOTPState"
import { getSasToken } from "./getSasToken"
const outputSchema = z.object({
linkingState: z.enum(["unlinked", "notLinked", "error"]),
})
export const unlinkAccount = protectedProcedure
.output(outputSchema)
.mutation(async function ({ ctx }) {
const sasAuthToken = await getSasToken()
const { referenceId } = await getOTPState()
const apiResponse = await api.post(api.endpoints.v1.Profile.unlink, {
headers: {
Authorization: `Bearer ${ctx.session.token.access_token}`,
},
body: {
partner: "sas_eb",
partnerSpecific: {
eurobonusAccessToken: sasAuthToken,
eurobonusOtpReferenceId: referenceId,
},
},
})
if (apiResponse.status === 204 || apiResponse.status === 202) {
console.log("[SAS] unlink account success")
return { linkingState: "unlinked" }
}
if (apiResponse.status === 400) {
const result = await apiResponse.json()
console.log("[SAS] unlink account error with response", result)
return { linkingState: "error" }
}
if (apiResponse.status === 404) {
console.log("[SAS] tried unlinking an account that was not linked")
return { linkingState: "notLinked" }
}
console.log(
`[SAS] unlink account error with status code ${apiResponse.status} and response ${await apiResponse.text()}`
)
return { linkingState: "error" }
})

3
apps/scandic-web/types/trpc/routers/jobylon/index.ts
View File

@@ -1,5 +1,4 @@
import type { jobylonItemSchema } from "@scandic-hotels/trpc/routers/partners/jobylon/output"
import type { z } from "zod"
import type { jobylonItemSchema } from "@/server/routers/partners/jobylon/output"
export interface JobylonItem extends z.output<typeof jobylonItemSchema> {}